broadcasting storage changes events

components/net/storage_task.rs

@@ -30,10 +30,10 @@ pub enum StorageTaskMsg {
 
     /// sets the value of the given key in the associated storage data
     /// TODO throw QuotaExceededError in case of error
-    SetItem(Sender<bool>, Url, StorageType, DOMString, DOMString),
+    SetItem(Sender<(bool, Option<DOMString>)>, Url, StorageType, DOMString, DOMString),
 
     /// removes the key/value pair for the given key in the associated storage data
-    RemoveItem(Sender<bool>, Url, StorageType, DOMString),
+    RemoveItem(Sender<Option<DOMString>>, Url, StorageType, DOMString),
 
     /// clears the associated storage data by removing all the key/value pairs
     Clear(Sender<bool>, Url, StorageType),
@@ -133,23 +133,25 @@ impl StorageManager {
                     .map(|key| key.clone())).unwrap();
     }
 
-    fn set_item(&mut self, sender: Sender<bool>, url: Url, storage_type: StorageType, name: DOMString, value: DOMString) {
+    /// Sends Some(old_value) in case there was a previous value with the same key name but with different
+    /// value name, otherwise sends None
+    fn set_item(&mut self, sender: Sender<(bool, Option<DOMString>)>, url: Url, storage_type: StorageType, name: DOMString, value: DOMString) {
         let origin = self.get_origin_as_string(url);
         let data = self.select_data_mut(storage_type);
         if !data.contains_key(&origin) {
             data.insert(origin.clone(), BTreeMap::new());
         }
 
-        let updated = data.get_mut(&origin).map(|entry| {
+        let (changed, old_value) = data.get_mut(&origin).map(|entry| {
-            if entry.get(&origin).map_or(true, |item| *item != value) {
+            entry.insert(name, value.clone()).map_or(
-                entry.insert(name.clone(), value.clone());
+                (true, None),
-                true
+                |old| if old == value {
+                    (false, None)
                 } else {
-                false
+                    (true, Some(old))
-            }
+                })
         }).unwrap();
-
+        sender.send((changed, old_value)).unwrap();
-        sender.send(updated).unwrap();
     }
 
     fn get_item(&self, sender: Sender<Option<DOMString>>, url: Url, storage_type: StorageType, name: DOMString) {
@@ -160,11 +162,14 @@ impl StorageManager {
                     .map(|value| value.to_string())).unwrap();
     }
 
-    fn remove_item(&mut self, sender: Sender<bool>, url: Url, storage_type: StorageType, name: DOMString) {
+    /// Sends Some(old_value) in case there was a previous value with the key name, otherwise sends None
+    fn remove_item(&mut self, sender: Sender<Option<DOMString>>, url: Url, storage_type: StorageType, name: DOMString) {
         let origin = self.get_origin_as_string(url);
         let data = self.select_data_mut(storage_type);
-        sender.send(data.get_mut(&origin)
+        let old_value = data.get_mut(&origin).map(|entry| {
-                    .map_or(false, |entry| entry.remove(&name).is_some())).unwrap();
+            entry.remove(&name)
+        }).unwrap();
+        sender.send(old_value).unwrap();
     }
 
     fn clear(&mut self, sender: Sender<bool>, url: Url, storage_type: StorageType) {

components/script/dom/storage.rs

@@ -5,15 +5,27 @@
 use dom::bindings::codegen::Bindings::StorageBinding;
 use dom::bindings::codegen::Bindings::StorageBinding::StorageMethods;
 use dom::bindings::global::{GlobalRef, GlobalField};
-use dom::bindings::js::{JSRef, Temporary};
+use dom::bindings::js::{JSRef, Temporary, RootedReference};
+use dom::bindings::refcounted::Trusted;
 use dom::bindings::utils::{Reflector, reflect_dom_object};
+use dom::bindings::codegen::InheritTypes::{EventCast, EventTargetCast};
+use dom::event::{Event, EventHelpers, EventBubbles, EventCancelable};
+use dom::eventtarget::{EventTarget};
+use dom::storageevent::StorageEvent;
+use dom::urlhelper::UrlHelper;
+use dom::window::WindowHelpers;
 use util::str::DOMString;
 use net::storage_task::StorageTask;
 use net::storage_task::StorageType;
 use net::storage_task::StorageTaskMsg;
+use page::IterablePage;
 use std::sync::mpsc::channel;
 use url::Url;
 
+use script_task::{ScriptTask, ScriptMsg, MainThreadRunnable};
+
+use collections::borrow::ToOwned;
+
 #[dom_struct]
 pub struct Storage {
     reflector_: Reflector,
@@ -79,9 +91,10 @@ impl<'a> StorageMethods for JSRef<'a, Storage> {
     fn SetItem(self, name: DOMString, value: DOMString) {
         let (sender, receiver) = channel();
 
-        self.get_storage_task().send(StorageTaskMsg::SetItem(sender, self.get_url(), self.storage_type, name, value)).unwrap();
+        self.get_storage_task().send(StorageTaskMsg::SetItem(sender, self.get_url(), self.storage_type, name.clone(), value.clone())).unwrap();
-        if receiver.recv().unwrap() {
+        let (changed, old_value) = receiver.recv().unwrap();
-            //TODO send notification
+        if changed {
+            self.broadcast_change_notification(Some(name), old_value, Some(value));
         }
     }
 
@@ -96,9 +109,9 @@ impl<'a> StorageMethods for JSRef<'a, Storage> {
     fn RemoveItem(self, name: DOMString) {
         let (sender, receiver) = channel();
 
-        self.get_storage_task().send(StorageTaskMsg::RemoveItem(sender, self.get_url(), self.storage_type, name)).unwrap();
+        self.get_storage_task().send(StorageTaskMsg::RemoveItem(sender, self.get_url(), self.storage_type, name.clone())).unwrap();
-        if receiver.recv().unwrap() {
+        if let Some(old_value) = receiver.recv().unwrap() {
-            //TODO send notification
+            self.broadcast_change_notification(Some(name), Some(old_value), None);
         }
     }
 
@@ -111,7 +124,76 @@ impl<'a> StorageMethods for JSRef<'a, Storage> {
 
         self.get_storage_task().send(StorageTaskMsg::Clear(sender, self.get_url(), self.storage_type)).unwrap();
         if receiver.recv().unwrap() {
-            //TODO send notification
+            self.broadcast_change_notification(None, None, None);
+        }
+    }
+}
+
+trait PrivateStorageHelpers {
+    fn broadcast_change_notification(self, key: Option<DOMString>, old_value: Option<DOMString>,
+                                     new_value: Option<DOMString>);
+}
+
+impl<'a> PrivateStorageHelpers for JSRef<'a, Storage> {
+    /// https://html.spec.whatwg.org/multipage/webstorage.html#send-a-storage-notification
+    fn broadcast_change_notification(self, key: Option<DOMString>, old_value: Option<DOMString>,
+                                     new_value: Option<DOMString>){
+        let global_root = self.global.root();
+        let global_ref = global_root.r();
+        let script_chan = global_ref.script_chan();
+        let trusted_storage = Trusted::new(global_ref.get_cx(), self,
+                                           script_chan.clone());
+        script_chan.send(ScriptMsg::MainThreadRunnableMsg(
+            box StorageEventRunnable::new(trusted_storage, key,
+                                          old_value, new_value))).unwrap();
+    }
+}
+
+pub struct StorageEventRunnable {
+    element: Trusted<Storage>,
+    key: Option<DOMString>,
+    old_value: Option<DOMString>,
+    new_value: Option<DOMString>
+}
+
+impl StorageEventRunnable {
+    fn new(storage: Trusted<Storage>, key: Option<DOMString>, old_value: Option<DOMString>,
+           new_value: Option<DOMString>) -> StorageEventRunnable {
+        StorageEventRunnable { element: storage, key: key, old_value: old_value, new_value: new_value }
+    }
+}
+
+impl MainThreadRunnable for StorageEventRunnable {
+    fn handler(self: Box<StorageEventRunnable>, script_task: &ScriptTask) {
+        let this = *self;
+        let storage_root = this.element.to_temporary().root();
+        let storage = storage_root.r();
+        let global_root = storage.global.root();
+        let global_ref = global_root.r();
+        let ev_window = global_ref.as_window();
+        let ev_url = storage.get_url();
+
+        let storage_event = StorageEvent::new(
+            global_ref,
+            "storage".to_owned(),
+            EventBubbles::DoesNotBubble, EventCancelable::NotCancelable,
+            this.key, this.old_value, this.new_value,
+            ev_url.to_string(),
+            Some(storage)
+        ).root();
+        let event: JSRef<Event> = EventCast::from_ref(storage_event.r());
+
+        let root_page = script_task.root_page();
+        for it_page in root_page.iter() {
+            let it_window_root = it_page.window().root();
+            let it_window = it_window_root.r();
+            assert!(UrlHelper::SameOrigin(&ev_url, &it_window.get_url()));
+            // TODO: Such a Document object is not necessarily fully active, but events fired on such
+            // objects are ignored by the event loop until the Document becomes fully active again.
+            if ev_window.pipeline() != it_window.pipeline() {
+                let target: JSRef<EventTarget> = EventTargetCast::from_ref(it_window);
+                event.fire(target);
+            }
         }
     }
 }

components/script/script_task.rs

@@ -498,7 +498,7 @@ impl ScriptTask {
     }
 
     // Return the root page in the frame tree. Panics if it doesn't exist.
-    fn root_page(&self) -> Rc<Page> {
+    pub fn root_page(&self) -> Rc<Page> {
         self.page.borrow().as_ref().unwrap().clone()
     }
 

tests/wpt/metadata/webstorage/event_local_key.html.ini

@@ -1,6 +0,0 @@
-[event_local_key.html]
-  type: testharness
-  expected: TIMEOUT
-  [key property test of local event]
-    expected: NOTRUN
-

tests/wpt/metadata/webstorage/event_local_newvalue.html.ini

@@ -1,6 +0,0 @@
-[event_local_newvalue.html]
-  type: testharness
-  expected: TIMEOUT
-  [newValue property test of local event]
-    expected: NOTRUN
-

tests/wpt/metadata/webstorage/event_local_oldvalue.html.ini

@@ -1,6 +0,0 @@
-[event_local_oldvalue.html]
-  type: testharness
-  expected: TIMEOUT
-  [oldValue property test of local event]
-    expected: NOTRUN
-

tests/wpt/metadata/webstorage/event_local_storagearea.html.ini

@@ -1,6 +0,0 @@
-[event_local_storagearea.html]
-  type: testharness
-  expected: TIMEOUT
-  [storageArea property test of local event]
-    expected: NOTRUN
-

tests/wpt/metadata/webstorage/event_local_url.html.ini

@@ -1,6 +0,0 @@
-[event_local_url.html]
-  type: testharness
-  expected: TIMEOUT
-  [url property test of local event]
-    expected: NOTRUN
-

tests/wpt/metadata/webstorage/event_session_key.html.ini

@@ -1,6 +0,0 @@
-[event_session_key.html]
-  type: testharness
-  expected: TIMEOUT
-  [key property test of session event]
-    expected: NOTRUN
-

tests/wpt/metadata/webstorage/event_session_newvalue.html.ini

@@ -1,6 +0,0 @@
-[event_session_newvalue.html]
-  type: testharness
-  expected: TIMEOUT
-  [newvalue property test of session event]
-    expected: NOTRUN
-

tests/wpt/metadata/webstorage/event_session_oldvalue.html.ini

@@ -1,6 +0,0 @@
-[event_session_oldvalue.html]
-  type: testharness
-  expected: TIMEOUT
-  [oldvalue property test of session event]
-    expected: NOTRUN
-

tests/wpt/metadata/webstorage/event_session_storagearea.html.ini

@@ -1,6 +0,0 @@
-[event_session_storagearea.html]
-  type: testharness
-  expected: TIMEOUT
-  [storageArea property test of session event]
-    expected: NOTRUN
-

tests/wpt/metadata/webstorage/event_session_url.html.ini

@@ -1,6 +0,0 @@
-[event_session_url.html]
-  type: testharness
-  expected: TIMEOUT
-  [url property test of session event]
-    expected: NOTRUN
-