Add devtools_chan method to GlobalRef and make new globals notificati…

…ons work with nested workers

fixup! Add devtools_chan method to GlobalRef and make new globals notifications work with nested workers

fixup! Add devtools_chan method to GlobalRef and make new globals notifications work with nested workers

components/script/dom/bindings/global.rs

@@ -13,8 +13,9 @@ use dom::bindings::utils::{Reflectable, Reflector};
 use dom::workerglobalscope::{WorkerGlobalScope, WorkerGlobalScopeHelpers};
 use dom::window::{self, WindowHelpers};
 use script_task::ScriptChan;
+use devtools_traits::DevtoolsControlChan;
 
-use msg::constellation_msg::WorkerId;
+use msg::constellation_msg::{PipelineId, WorkerId};
 use net_traits::ResourceTask;
 
 use js::{JSCLASS_IS_GLOBAL, JSCLASS_IS_DOMJSCLASS};
@@ -82,6 +83,23 @@ impl<'a> GlobalRef<'a> {
         }
     }
 
+    /// Get the `PipelineId` for this global scope.
+    pub fn pipeline(&self) -> PipelineId {
+        match *self {
+            GlobalRef::Window(window) => window.pipeline(),
+            GlobalRef::Worker(worker) => worker.pipeline(),
+        }
+    }
+
+    /// Get `DevtoolsControlChan` to send messages to Devtools
+    /// task when available.
+    pub fn devtools_chan(&self) -> Option<DevtoolsControlChan> {
+        match *self {
+            GlobalRef::Window(window) => window.devtools_chan(),
+            GlobalRef::Worker(worker) => worker.devtools_chan(),
+        }
+    }
+
     /// Get the `ResourceTask` for this global scope.
     pub fn resource_task(&self) -> ResourceTask {
         match *self {

components/script/dom/dedicatedworkerglobalscope.rs

@@ -24,6 +24,10 @@ use dom::workerglobalscope::WorkerGlobalScopeTypeId;
 use script_task::{ScriptTask, ScriptChan, ScriptMsg, TimerSource};
 use script_task::StackRootTLS;
 
+use msg::constellation_msg::PipelineId;
+
+use devtools_traits::DevtoolsControlChan;
+
 use net_traits::{load_whole_resource, ResourceTask};
 use util::task::spawn_named;
 use util::task_state;
@@ -90,6 +94,7 @@ impl<'a> Drop for AutoWorkerReset<'a> {
 #[dom_struct]
 pub struct DedicatedWorkerGlobalScope {
     workerglobalscope: WorkerGlobalScope,
+    id: PipelineId,
     receiver: Receiver<(TrustedWorkerAddress, ScriptMsg)>,
     own_sender: Sender<(TrustedWorkerAddress, ScriptMsg)>,
     worker: DOMRefCell<Option<TrustedWorkerAddress>>,
@@ -99,6 +104,8 @@ pub struct DedicatedWorkerGlobalScope {
 
 impl DedicatedWorkerGlobalScope {
     fn new_inherited(worker_url: Url,
+                         id: PipelineId,
+                         devtools_chan: Option<DevtoolsControlChan>,
                          cx: Rc<Cx>,
                          resource_task: ResourceTask,
                          parent_sender: Box<ScriptChan+Send>,
@@ -107,7 +114,8 @@ impl DedicatedWorkerGlobalScope {
                          -> DedicatedWorkerGlobalScope {
         DedicatedWorkerGlobalScope {
             workerglobalscope: WorkerGlobalScope::new_inherited(
-                WorkerGlobalScopeTypeId::DedicatedGlobalScope, worker_url, cx, resource_task),
+                WorkerGlobalScopeTypeId::DedicatedGlobalScope, worker_url, cx, resource_task, devtools_chan),
+            id: id,
             receiver: receiver,
             own_sender: own_sender,
             parent_sender: parent_sender,
@@ -116,21 +124,25 @@ impl DedicatedWorkerGlobalScope {
     }
 
     pub fn new(worker_url: Url,
+               id: PipelineId,
+               devtools_chan: Option<DevtoolsControlChan>,
                cx: Rc<Cx>,
                resource_task: ResourceTask,
                parent_sender: Box<ScriptChan+Send>,
                own_sender: Sender<(TrustedWorkerAddress, ScriptMsg)>,
                receiver: Receiver<(TrustedWorkerAddress, ScriptMsg)>)
                -> Temporary<DedicatedWorkerGlobalScope> {
         let scope = box DedicatedWorkerGlobalScope::new_inherited(
-            worker_url, cx.clone(), resource_task, parent_sender,
+            worker_url, id, devtools_chan, cx.clone(), resource_task, parent_sender,
             own_sender, receiver);
         DedicatedWorkerGlobalScopeBinding::Wrap(cx.ptr, scope)
     }
 }
 
 impl DedicatedWorkerGlobalScope {
     pub fn run_worker_scope(worker_url: Url,
+                            id: PipelineId,
+                            devtools_chan: Option<DevtoolsControlChan>,
                             worker: TrustedWorkerAddress,
                             resource_task: ResourceTask,
                             parent_sender: Box<ScriptChan+Send>,
@@ -156,7 +168,7 @@ impl DedicatedWorkerGlobalScope {
 
             let (_js_runtime, js_context) = ScriptTask::new_rt_and_cx();
             let global = DedicatedWorkerGlobalScope::new(
-                worker_url, js_context.clone(), resource_task,
+                worker_url, id, devtools_chan, js_context.clone(), resource_task,
                 parent_sender, own_sender, receiver).root();
 
             {
@@ -184,6 +196,7 @@ impl DedicatedWorkerGlobalScope {
 
 pub trait DedicatedWorkerGlobalScopeHelpers {
     fn script_chan(self) -> Box<ScriptChan+Send>;
+    fn pipeline(self) -> PipelineId;
 }
 
 impl<'a> DedicatedWorkerGlobalScopeHelpers for JSRef<'a, DedicatedWorkerGlobalScope> {
@@ -195,6 +208,10 @@ impl<'a> DedicatedWorkerGlobalScopeHelpers for JSRef<'a, DedicatedWorkerGlobalSc
             worker: worker.as_ref().unwrap().clone(),
         }
     }
+
+    fn pipeline(self) -> PipelineId {
+        self.id
+    }
 }
 
 trait PrivateDedicatedWorkerGlobalScopeHelpers {

components/script/dom/worker.rs

@@ -4,7 +4,6 @@
 
 use dom::bindings::codegen::Bindings::WorkerBinding;
 use dom::bindings::codegen::Bindings::WorkerBinding::WorkerMethods;
-use dom::bindings::codegen::Bindings::WindowBinding::WindowMethods;
 use dom::bindings::codegen::Bindings::EventHandlerBinding::EventHandlerNonNull;
 use dom::bindings::codegen::InheritTypes::{EventCast, EventTargetCast};
 use dom::bindings::error::{Fallible, ErrorResult};
@@ -76,25 +75,22 @@ impl Worker {
         let worker = Worker::new(global, sender.clone()).root();
         let worker_ref = Trusted::new(global.get_cx(), worker.r(), global.script_chan());
 
-
-        if let GlobalRef::Window(window) = global {
-            if let Some(ref chan) = window.devtools_chan() {
-                let pipeline_id = window.Window().root().r().pipeline();
-                let (devtools_sender, _) = channel();
-                let title = format!("Worker for {}", worker_url);
-                let page_info = DevtoolsPageInfo {
-                    title: title,
-                    url: worker_url.clone(),
-                };
-                let worker_id = global.get_next_worker_id();
-                chan.send(
-                    DevtoolsControlMsg::NewGlobal((pipeline_id, Some(worker_id)), devtools_sender.clone(), page_info)
-                ).unwrap();
-            }
+        if let Some(ref chan) = global.devtools_chan() {
+            let pipeline_id = global.pipeline();
+            let (devtools_sender, _) = channel();
+            let title = format!("Worker for {}", worker_url);
+            let page_info = DevtoolsPageInfo {
+                title: title,
+                url: worker_url.clone(),
+            };
+            let worker_id = global.get_next_worker_id();
+            chan.send(
+                DevtoolsControlMsg::NewGlobal((pipeline_id, Some(worker_id)), devtools_sender.clone(), page_info)
+            ).unwrap();
         }
 
         DedicatedWorkerGlobalScope::run_worker_scope(
-            worker_url, worker_ref, resource_task, global.script_chan(),
+            worker_url, global.pipeline(), global.devtools_chan(), worker_ref, resource_task, global.script_chan(),
             sender, receiver);
 
         Ok(Temporary::from_rooted(worker.r()))

components/script/dom/workerglobalscope.rs

@@ -19,7 +19,9 @@ use dom::window::{base64_atob, base64_btoa};
 use script_task::{ScriptChan, TimerSource};
 use timers::{IsInterval, TimerId, TimerManager, TimerCallback};
 
-use msg::constellation_msg::WorkerId;
+use devtools_traits::DevtoolsControlChan;
+
+use msg::constellation_msg::{PipelineId, WorkerId};
 use net_traits::{load_whole_resource, ResourceTask};
 use util::str::DOMString;
 
@@ -50,13 +52,15 @@ pub struct WorkerGlobalScope {
     navigator: MutNullableJS<WorkerNavigator>,
     console: MutNullableJS<Console>,
     timers: TimerManager,
+    devtools_chan: Option<DevtoolsControlChan>,
 }
 
 impl WorkerGlobalScope {
     pub fn new_inherited(type_id: WorkerGlobalScopeTypeId,
                          worker_url: Url,
                          cx: Rc<Cx>,
-                         resource_task: ResourceTask) -> WorkerGlobalScope {
+                         resource_task: ResourceTask,
+                         devtools_chan: Option<DevtoolsControlChan>) -> WorkerGlobalScope {
         WorkerGlobalScope {
             eventtarget: EventTarget::new_inherited(EventTargetTypeId::WorkerGlobalScope(type_id)),
             next_worker_id: Cell::new(WorkerId(0)),
@@ -67,9 +71,14 @@ impl WorkerGlobalScope {
             navigator: Default::default(),
             console: Default::default(),
             timers: TimerManager::new(),
+            devtools_chan: devtools_chan,
         }
     }
 
+    pub fn devtools_chan(&self) -> Option<DevtoolsControlChan> {
+        self.devtools_chan.clone()
+    }
+
     #[inline]
     pub fn eventtarget<'a>(&'a self) -> &'a EventTarget {
         &self.eventtarget
@@ -206,6 +215,7 @@ impl<'a> WorkerGlobalScopeMethods for JSRef<'a, WorkerGlobalScope> {
 pub trait WorkerGlobalScopeHelpers {
     fn handle_fire_timer(self, timer_id: TimerId);
     fn script_chan(self) -> Box<ScriptChan+Send>;
+    fn pipeline(self) -> PipelineId;
     fn get_cx(self) -> *mut JSContext;
 }
 
@@ -219,6 +229,15 @@ impl<'a> WorkerGlobalScopeHelpers for JSRef<'a, WorkerGlobalScope> {
         }
     }
 
+    fn pipeline(self) -> PipelineId {
+        let dedicated: Option<JSRef<DedicatedWorkerGlobalScope>> =
+            DedicatedWorkerGlobalScopeCast::to_ref(self);
+        match dedicated {
+            Some(dedicated) => dedicated.pipeline(),
+            None => panic!("need to add a pipeline for SharedWorker"),
+        }
+    }
+
     fn handle_fire_timer(self, timer_id: TimerId) {
         self.timers.fire_timer(timer_id, self);
     }