Make service workers talk to their serviceworkerglobalscopes

1 files changed, 25 insertions, 9 deletions

diff --git a/components/script/serviceworker_manager.rs b/components/script/serviceworker_manager.rs
index 09f5288929a..898bd2b63f3 100644
--- a/components/script/serviceworker_manager.rs
+++ b/components/script/serviceworker_manager.rs
@@ -35,19 +35,23 @@ pub struct ServiceWorkerManager {
     // receiver to receive messages from constellation
     own_port: Receiver<ServiceWorkerMsg>,
     // to receive resource messages
-    resource_receiver: Receiver<CustomResponseMediator>
+    resource_receiver: Receiver<CustomResponseMediator>,
+    // to send message to constellation
+    constellation_sender: IpcSender<SWManagerMsg>
 }
 
 impl ServiceWorkerManager {
     fn new(own_sender: IpcSender<ServiceWorkerMsg>,
            from_constellation_receiver: Receiver<ServiceWorkerMsg>,
-           resource_port: Receiver<CustomResponseMediator>) -> ServiceWorkerManager {
+           resource_port: Receiver<CustomResponseMediator>,
+           constellation_sender: IpcSender<SWManagerMsg>) -> ServiceWorkerManager {
         ServiceWorkerManager {
             registered_workers: HashMap::new(),
             active_workers: HashMap::new(),
             own_sender: own_sender,
             own_port: from_constellation_receiver,
-            resource_receiver: resource_port
+            resource_receiver: resource_port,
+            constellation_sender: constellation_sender
         }
     }
 
@@ -58,8 +62,12 @@ impl ServiceWorkerManager {
         let resource_port = ROUTER.route_ipc_receiver_to_new_mpsc_receiver(resource_port);
         let _ = sw_senders.resource_sender.send(CoreResourceMsg::NetworkMediator(resource_chan));
         let _ = sw_senders.swmanager_sender.send(SWManagerMsg::OwnSender(own_sender.clone()));
+        let constellation_sender = sw_senders.swmanager_sender.clone();
         spawn_named("ServiceWorkerManager".to_owned(), move || {
-            ServiceWorkerManager::new(own_sender, from_constellation, resource_port).handle_message();
+            ServiceWorkerManager::new(own_sender,
+                                      from_constellation,
+                                      resource_port,
+                                      constellation_sender).handle_message();
         });
     }
 
@@ -93,12 +101,20 @@ impl ServiceWorkerManager {
                                                                              devtools_sender.clone(),
                                                                              page_info));
                 };
+                let (msg_chan, msg_port) = ipc::channel().unwrap();
+                let msg_port = ROUTER.route_ipc_receiver_to_new_mpsc_receiver(msg_port);
                 ServiceWorkerGlobalScope::run_serviceworker_scope(scope_things.clone(),
-                                                                              sender.clone(),
-                                                                              receiver,
-                                                                              devtools_receiver,
-                                                                              self.own_sender.clone(),
-                                                                              scope_url.clone());
+                                                                  sender.clone(),
+                                                                  receiver,
+                                                                  devtools_receiver,
+                                                                  self.own_sender.clone(),
+                                                                  scope_url.clone(),
+                                                                  msg_port);
+                // Send the message to constellation which then talks to the script thread for storing this msg_chan
+                let connection_msg = SWManagerMsg::ConnectServiceWorker(scope_url.clone(),
+                                                                        scope_things.pipeline_id,
+                                                                        msg_chan);
+                let _ = self.constellation_sender.send(connection_msg);
                 // We store the activated worker
                 self.active_workers.insert(scope_url, scope_things.clone());
                 return Some(sender);