Fixes issue #6866

components/devtools/actors/worker.rs

@@ -9,6 +9,7 @@ use std::net::TcpStream;
 
 pub struct WorkerActor {
     pub name: String,
+    pub console: String,
     pub id: WorkerId,
 }
 

components/devtools/lib.rs

@@ -240,6 +240,7 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
         if let Some(id) = worker_id {
             let worker = WorkerActor {
                 name: actors.new_name("worker"),
+                console: console.name(),
                 id: id,
             };
             actor_workers.insert((pipeline, id), worker.name.clone());
@@ -255,9 +256,12 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
 
     fn handle_console_message(actors: Arc<Mutex<ActorRegistry>>,
                               id: PipelineId,
+                              worker_id: Option<WorkerId>,
                               console_message: ConsoleMessage,
-                              actor_pipelines: &HashMap<PipelineId, String>) {
+                              actor_pipelines: &HashMap<PipelineId, String>,
-        let console_actor_name = match find_console_actor(actors.clone(), id, actor_pipelines) {
+                              actor_workers: &HashMap<(PipelineId, WorkerId), String>) {
+        let console_actor_name = match find_console_actor(actors.clone(), id, worker_id, actor_workers,
+                                                          actor_pipelines) {
             Some(name) => name,
             None => return,
         };
@@ -288,27 +292,36 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
 
     fn find_console_actor(actors: Arc<Mutex<ActorRegistry>>,
                           id: PipelineId,
+                          worker_id: Option<WorkerId>,
+                          actor_workers: &HashMap<(PipelineId, WorkerId), String>,
                           actor_pipelines: &HashMap<PipelineId, String>) -> Option<String> {
         let actors = actors.lock().unwrap();
-        let tab_actor_name = match (*actor_pipelines).get(&id) {
+        if let Some(worker_id) = worker_id {
+            let actor_name = match (*actor_workers).get(&(id, worker_id)) {
                 Some(name) => name,
                 None => return None,
             };
-        let tab_actor = actors.find::<TabActor>(tab_actor_name);
+            Some(actors.find::<WorkerActor>(actor_name).console.clone())
-        let console_actor_name = tab_actor.console.clone();
+        } else {
-        return Some(console_actor_name);
+            let actor_name = match (*actor_pipelines).get(&id) {
+                Some(name) => name,
+                None => return None,
+            };
+            Some(actors.find::<TabActor>(actor_name).console.clone())
+        }
     }
 
     fn handle_network_event(actors: Arc<Mutex<ActorRegistry>>,
                             mut connections: Vec<TcpStream>,
                             actor_pipelines: &HashMap<PipelineId, String>,
                             actor_requests: &mut HashMap<String, String>,
+                            actor_workers: &HashMap<(PipelineId, WorkerId), String>,
                             pipeline_id: PipelineId,
                             request_id: String,
                             network_event: NetworkEvent) {
 
-        let console_actor_name = match find_console_actor(actors.clone(), pipeline_id,
+        let console_actor_name = match find_console_actor(actors.clone(), pipeline_id, None,
-                                                          actor_pipelines) {
+                                                          actor_workers, actor_pipelines) {
             Some(name) => name,
             None => return,
         };
@@ -401,9 +414,10 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
                                   &mut actor_workers, pageinfo),
             Ok(DevtoolsControlMsg::FromScript(ScriptToDevtoolsControlMsg::SendConsoleMessage(
                         id,
-                        console_message))) =>
+                        console_message,
-                handle_console_message(actors.clone(), id, console_message,
+                        worker_id))) =>
-                                       &actor_pipelines),
+                handle_console_message(actors.clone(), id, worker_id, console_message,
+                                       &actor_pipelines, &actor_workers),
             Ok(DevtoolsControlMsg::FromChrome(ChromeToDevtoolsControlMsg::NetworkEventMessage(
                         request_id, network_event))) => {
                 // copy the accepted_connections vector
@@ -414,7 +428,7 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
                 //TODO: Get pipeline_id from NetworkEventMessage after fixing the send in http_loader
                 // For now, the id of the first pipeline is passed
                 handle_network_event(actors.clone(), connections, &actor_pipelines, &mut actor_requests,
-                                     PipelineId(0), request_id, network_event);
+                                     &actor_workers, PipelineId(0), request_id, network_event);
             },
             Ok(DevtoolsControlMsg::FromChrome(ChromeToDevtoolsControlMsg::ServerExitMsg)) |
             Err(RecvError) => break

components/devtools_traits/lib.rs

@@ -69,7 +69,7 @@ pub enum ScriptToDevtoolsControlMsg {
     NewGlobal((PipelineId, Option<WorkerId>),
               IpcSender<DevtoolScriptControlMsg>,
               DevtoolsPageInfo),
-    SendConsoleMessage(PipelineId, ConsoleMessage),
+    SendConsoleMessage(PipelineId, ConsoleMessage, Option<WorkerId>),
 }
 
 /// Serialized JS return values
@@ -268,4 +268,3 @@ impl PreciseTime {
         Duration::nanoseconds((later.0 - self.0) as i64)
     }
 }
-

components/script/dom/bindings/global.rs

@@ -121,6 +121,14 @@ impl<'a> GlobalRef<'a> {
         }
     }
 
+    /// Get the worker's id.
+    pub fn get_worker_id(&self) -> Option<WorkerId> {
+        match *self {
+            GlobalRef::Window(_) => None,
+            GlobalRef::Worker(ref worker) => worker.get_worker_id(),
+        }
+    }
+
     /// Get next worker id.
     pub fn get_next_worker_id(&self) -> WorkerId {
         match *self {

components/script/dom/console.rs

@@ -98,17 +98,9 @@ fn prepare_message(logLevel: LogLevel, message: String) -> ConsoleMessage {
 
 fn propagate_console_msg(console: &&Console, console_message: ConsoleMessage) {
     let global = console.global.root();
-    match global.r() {
+    let pipelineId = global.r().pipeline();
-        GlobalRef::Window(window_ref) => {
+    global.r().devtools_chan().as_ref().map(|chan| {
-            let pipelineId = window_ref.pipeline();
-            console.global.root().r().as_window().devtools_chan().as_ref().map(|chan| {
         chan.send(ScriptToDevtoolsControlMsg::SendConsoleMessage(
-                    pipelineId, console_message.clone())).unwrap();
+            pipelineId, console_message.clone(), global.r().get_worker_id())).unwrap();
     });
-        },
-
-        GlobalRef::Worker(_) => {
-            // TODO: support worker console logs
-        }
-    }
 }

components/script/dom/dedicatedworkerglobalscope.rs

@@ -25,7 +25,7 @@ use dom::workerglobalscope::WorkerGlobalScopeTypeId;
 use script_task::{ScriptTask, ScriptChan, ScriptMsg, TimerSource, ScriptPort};
 use script_task::StackRootTLS;
 
-use msg::constellation_msg::{ConstellationChan, PipelineId};
+use msg::constellation_msg::{ConstellationChan, PipelineId, WorkerId};
 
 use devtools_traits::{ScriptToDevtoolsControlMsg, DevtoolScriptControlMsg};
 
@@ -118,12 +118,14 @@ impl DedicatedWorkerGlobalScope {
                      constellation_chan: ConstellationChan,
                      parent_sender: Box<ScriptChan+Send>,
                      own_sender: Sender<(TrustedWorkerAddress, ScriptMsg)>,
-                     receiver: Receiver<(TrustedWorkerAddress, ScriptMsg)>)
+                     receiver: Receiver<(TrustedWorkerAddress, ScriptMsg)>,
+                     worker_id: Option<WorkerId>)
                      -> DedicatedWorkerGlobalScope {
         DedicatedWorkerGlobalScope {
             workerglobalscope: WorkerGlobalScope::new_inherited(
                 WorkerGlobalScopeTypeId::DedicatedGlobalScope, worker_url, runtime, resource_task,
-                mem_profiler_chan, devtools_chan, devtools_sender, devtools_port, constellation_chan),
+                mem_profiler_chan, devtools_chan, devtools_sender, devtools_port, constellation_chan,
+                worker_id),
             id: id,
             receiver: receiver,
             own_sender: own_sender,
@@ -143,11 +145,13 @@ impl DedicatedWorkerGlobalScope {
                constellation_chan: ConstellationChan,
                parent_sender: Box<ScriptChan+Send>,
                own_sender: Sender<(TrustedWorkerAddress, ScriptMsg)>,
-               receiver: Receiver<(TrustedWorkerAddress, ScriptMsg)>)
+               receiver: Receiver<(TrustedWorkerAddress, ScriptMsg)>,
+               worker_id: Option<WorkerId>)
                -> Root<DedicatedWorkerGlobalScope> {
         let scope = box DedicatedWorkerGlobalScope::new_inherited(
             worker_url, id, mem_profiler_chan, devtools_chan, devtools_sender, devtools_port,
-            runtime.clone(), resource_task, constellation_chan, parent_sender, own_sender, receiver);
+            runtime.clone(), resource_task, constellation_chan, parent_sender, own_sender, receiver,
+            worker_id);
         DedicatedWorkerGlobalScopeBinding::Wrap(runtime.cx(), scope)
     }
 }
@@ -165,7 +169,8 @@ impl DedicatedWorkerGlobalScope {
                             constellation_chan: ConstellationChan,
                             parent_sender: Box<ScriptChan+Send>,
                             own_sender: Sender<(TrustedWorkerAddress, ScriptMsg)>,
-                            receiver: Receiver<(TrustedWorkerAddress, ScriptMsg)>) {
+                            receiver: Receiver<(TrustedWorkerAddress, ScriptMsg)>,
+                            worker_id: Option<WorkerId>) {
         let serialized_worker_url = worker_url.serialize();
         spawn_named(format!("WebWorker for {}", serialized_worker_url), move || {
             task_state::initialize(SCRIPT | IN_WORKER);
@@ -194,7 +199,8 @@ impl DedicatedWorkerGlobalScope {
 
             let global = DedicatedWorkerGlobalScope::new(
                 url, id, mem_profiler_chan.clone(), devtools_chan, devtools_ipc_chan, devtools_mpsc_port,
-                runtime.clone(), resource_task, constellation_chan, parent_sender, own_sender, receiver);
+                runtime.clone(), resource_task, constellation_chan, parent_sender, own_sender, receiver,
+                worker_id);
             // FIXME(njn): workers currently don't have a unique ID suitable for using in reporter
             // registration (#6631), so we instead use a random number and cross our fingers.
             let scope = WorkerGlobalScopeCast::from_ref(global.r());

components/script/dom/worker.rs

@@ -76,6 +76,7 @@ impl Worker {
         let (sender, receiver) = channel();
         let worker = Worker::new(global, sender.clone());
         let worker_ref = Trusted::new(global.get_cx(), worker.r(), global.script_chan());
+        let worker_id = global.get_next_worker_id();
 
         let (devtools_sender, devtools_receiver) = ipc::channel().unwrap();
         let optional_sender = match global.devtools_chan() {
@@ -86,7 +87,6 @@ impl Worker {
                     title: title,
                     url: worker_url.clone(),
                 };
-                let worker_id = global.get_next_worker_id();
                 chan.send(ScriptToDevtoolsControlMsg::NewGlobal((pipeline_id, Some(worker_id)),
                                                                 devtools_sender.clone(),
                                                                 page_info)).unwrap();
@@ -98,7 +98,7 @@ impl Worker {
         DedicatedWorkerGlobalScope::run_worker_scope(
             worker_url, global.pipeline(), global.mem_profiler_chan(), global.devtools_chan(),
             optional_sender, devtools_receiver, worker_ref, resource_task,
-            constellation_chan, global.script_chan(), sender, receiver);
+            constellation_chan, global.script_chan(), sender, receiver, Some(worker_id));
 
         Ok(worker)
     }

components/script/dom/workerglobalscope.rs

@@ -46,6 +46,7 @@ pub enum WorkerGlobalScopeTypeId {
 #[dom_struct]
 pub struct WorkerGlobalScope {
     eventtarget: EventTarget,
+    worker_id: Option<WorkerId>,
     worker_url: Url,
     runtime: Rc<Runtime>,
     next_worker_id: Cell<WorkerId>,
@@ -82,11 +83,13 @@ impl WorkerGlobalScope {
                          devtools_chan: Option<IpcSender<ScriptToDevtoolsControlMsg>>,
                          devtools_sender: Option<IpcSender<DevtoolScriptControlMsg>>,
                          devtools_receiver: Receiver<DevtoolScriptControlMsg>,
-                         constellation_chan: ConstellationChan)
+                         constellation_chan: ConstellationChan,
+                         worker_id: Option<WorkerId>)
                          -> WorkerGlobalScope {
         WorkerGlobalScope {
             eventtarget: EventTarget::new_inherited(EventTargetTypeId::WorkerGlobalScope(type_id)),
             next_worker_id: Cell::new(WorkerId(0)),
+            worker_id: worker_id,
             worker_url: worker_url,
             runtime: runtime,
             resource_task: resource_task,
@@ -141,6 +144,10 @@ impl WorkerGlobalScope {
         &self.worker_url
     }
 
+    pub fn get_worker_id(&self) -> Option<WorkerId> {
+        self.worker_id.clone()
+    }
+
     pub fn get_next_worker_id(&self) -> WorkerId {
         let worker_id = self.next_worker_id.get();
         let WorkerId(id_num) = worker_id;