Implement Window.sessionStorage: Storage Task, Storage Methods (excluding Storage event, QuotaExceededError)

1 files changed, 77 insertions, 18 deletions

diff --git a/components/script/dom/storage.rs b/components/script/dom/storage.rs
index 1bbde8326df..8620afae38a 100644
--- a/components/script/dom/storage.rs
+++ b/components/script/dom/storage.rs
@@ -4,58 +4,117 @@
 
 use dom::bindings::codegen::Bindings::StorageBinding;
 use dom::bindings::codegen::Bindings::StorageBinding::StorageMethods;
-use dom::bindings::global::GlobalRef;
+use dom::bindings::global::{GlobalRef, GlobalField};
 use dom::bindings::js::{JSRef, Temporary};
 use dom::bindings::utils::{Reflectable, Reflector, reflect_dom_object};
+use dom::bindings::error::Fallible;
 use servo_util::str::DOMString;
+use servo_net::storage_task::StorageTask;
+use servo_net::storage_task::StorageTaskMsg;
+use std::comm::channel;
+use url::Url;
 
 #[dom_struct]
 pub struct Storage {
     reflector_: Reflector,
+    global: GlobalField,
 }
 
 impl Storage {
-    fn new_inherited() -> Storage {
+    fn new_inherited(global: &GlobalRef) -> Storage {
         Storage {
             reflector_: Reflector::new(),
+            global: GlobalField::from_rooted(global),
         }
     }
 
-    pub fn new(global: GlobalRef) -> Temporary<Storage> {
-        reflect_dom_object(box Storage::new_inherited(), global, StorageBinding::Wrap)
+    pub fn new(global: &GlobalRef) -> Temporary<Storage> {
+        reflect_dom_object(box Storage::new_inherited(global), *global, StorageBinding::Wrap)
     }
+
+    pub fn Constructor(global: &GlobalRef) -> Fallible<Temporary<Storage>> {
+        Ok(Storage::new(global))
+    }
+
+    fn get_url(&self) -> Url {
+        let global_root = self.global.root();
+        let global_ref = global_root.root_ref();
+        global_ref.get_url()
+    }
+
+    fn get_storage_task(&self) -> StorageTask {
+        let global_root = self.global.root();
+        let global_ref = global_root.root_ref();
+        global_ref.as_window().storage_task()
+    }
+
 }
 
 impl<'a> StorageMethods for JSRef<'a, Storage> {
     fn Length(self) -> u32 {
-        0
+        let (sender, receiver) = channel();
+
+        self.get_storage_task().send(StorageTaskMsg::Length(sender, self.get_url()));
+        receiver.recv()
     }
 
     fn Key(self, index: u32) -> Option<DOMString> {
+        let (sender, receiver) = channel();
 
-        //Return null for out of range index
-        if index >= self.Length() {
-            return None;
-        }
-
-        return None;
+        self.get_storage_task().send(StorageTaskMsg::Key(sender, self.get_url(), index));
+        receiver.recv()
     }
 
-    fn GetItem(self, key: DOMString) -> Option<DOMString> {
-        if key.is_empty() {
-            return None;
-        }
+    fn GetItem(self, name: DOMString) -> Option<DOMString> {
+        let (sender, receiver) = channel();
 
-        return None;
+        self.get_storage_task().send(StorageTaskMsg::GetItem(sender, self.get_url(), name));
+        receiver.recv()
     }
 
-    fn NamedGetter(self, key: DOMString, found: &mut bool) -> Option<DOMString> {
-        let item = self.GetItem(key);
+    fn NamedGetter(self, name: DOMString, found: &mut bool) -> Option<DOMString> {
+        let item = self.GetItem(name);
         *found = item.is_some();
         item
     }
 
+    fn SetItem(self, name: DOMString, value: DOMString) {
+        let (sender, receiver) = channel();
+
+        self.get_storage_task().send(StorageTaskMsg::SetItem(sender, self.get_url(), name, value));
+        if receiver.recv() {
+            //TODO send notification
+        }
+    }
+
+    fn NamedSetter(self, name: DOMString, value: DOMString) {
+        self.SetItem(name, value);
+    }
+
+    fn NamedCreator(self, name: DOMString, value: DOMString) {
+        self.SetItem(name, value);
+    }
+
+    fn RemoveItem(self, name: DOMString) {
+        let (sender, receiver) = channel();
+
+        self.get_storage_task().send(StorageTaskMsg::RemoveItem(sender, self.get_url(), name));
+        if receiver.recv() {
+            //TODO send notification
+        }
+    }
+
+    fn NamedDeleter(self, name: DOMString) {
+        self.RemoveItem(name);
+    }
+
     fn Clear(self) {
+        let (sender, receiver) = channel();
+
+        self.get_storage_task().send(StorageTaskMsg::Clear(sender, self.get_url()));
+        if receiver.recv() {
+            //TODO send notification
+        }
     }
 }