Implement a basic thread actor

These should represent JavaScript contexts, but not defining them at all
prevent any remote debugging session to be started from Firefox. They shouldn't
be conflated with tab actors.

components/devtools/actors/tab.rs

@@ -74,6 +74,7 @@ pub struct TabActor {
     pub timeline: String,
     pub profiler: String,
     pub performance: String,
+    pub thread: String,
 }
 
 impl Actor for TabActor {
@@ -98,7 +99,7 @@ impl Actor for TabActor {
                 let msg = TabAttachedReply {
                     from: self.name(),
                     __type__: "tabAttached".to_owned(),
-                    threadActor: self.name(),
+                    threadActor: self.thread.clone(),
                     cacheDisabled: false,
                     javascriptEnabled: true,
                     traits: TabTraits,

components/devtools/actors/thread.rs

@@ -0,0 +1,80 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+use actor::{Actor, ActorMessageStatus, ActorRegistry};
+use protocol::JsonPacketStream;
+use rustc_serialize::json;
+use std::net::TcpStream;
+
+#[derive(RustcEncodable)]
+struct ThreadAttachedReply {
+    from: String,
+    __type__: String,
+    actor: String,
+    poppedFrames: Vec<PoppedFrameMsg>,
+    why: WhyMsg,
+}
+
+#[derive(RustcEncodable)]
+enum PoppedFrameMsg {}
+
+#[derive(RustcEncodable)]
+struct WhyMsg {
+    __type__: String,
+}
+
+#[derive(RustcEncodable)]
+struct ThreadResumedReply {
+    from: String,
+    __type__: String,
+}
+
+pub struct ThreadActor {
+    name: String,
+}
+
+impl ThreadActor {
+    pub fn new(name: String) -> ThreadActor {
+        ThreadActor {
+            name: name,
+        }
+    }
+}
+
+impl Actor for ThreadActor {
+    fn name(&self) -> String {
+        self.name.clone()
+    }
+
+    fn handle_message(&self,
+                      registry: &ActorRegistry,
+                      msg_type: &str,
+                      _msg: &json::Object,
+                      stream: &mut TcpStream) -> Result<ActorMessageStatus, ()> {
+        Ok(match msg_type {
+            "attach" => {
+                let msg = ThreadAttachedReply {
+                    from: self.name(),
+                    __type__: "paused".to_owned(),
+                    actor: registry.new_name("pause"),
+                    poppedFrames: vec![],
+                    why: WhyMsg { __type__: "attached".to_owned() },
+                };
+                stream.write_json_packet(&msg);
+                ActorMessageStatus::Processed
+            },
+
+            "resume" => {
+                let msg = ThreadResumedReply {
+                    from: self.name(),
+                    __type__: "resumed".to_owned(),
+                };
+                stream.write_json_packet(&msg);
+                ActorMessageStatus::Processed
+            },
+
+            _ => ActorMessageStatus::Ignored,
+        })
+    }
+}

components/devtools/lib.rs

@@ -42,6 +42,7 @@ use actors::performance::PerformanceActor;
 use actors::profiler::ProfilerActor;
 use actors::root::RootActor;
 use actors::tab::TabActor;
+use actors::thread::ThreadActor;
 use actors::timeline::TimelineActor;
 use actors::worker::WorkerActor;
 use devtools_traits::{ChromeToDevtoolsControlMsg, ConsoleMessage, DevtoolsControlMsg};
@@ -73,6 +74,7 @@ mod actors {
     pub mod profiler;
     pub mod root;
     pub mod tab;
+    pub mod thread;
     pub mod timeline;
     pub mod worker;
 }
@@ -248,7 +250,7 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
         let (pipeline, worker_id) = ids;
 
         //TODO: move all this actor creation into a constructor method on TabActor
-        let (tab, console, inspector, timeline, profiler, performance) = {
+        let (tab, console, inspector, timeline, profiler, performance, thread) = {
             let console = ConsoleActor {
                 name: actors.new_name("console"),
                 script_chan: script_sender.clone(),
@@ -271,6 +273,8 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
             let profiler = ProfilerActor::new(actors.new_name("profiler"));
             let performance = PerformanceActor::new(actors.new_name("performance"));
 
+            let thread = ThreadActor::new(actors.new_name("context"));
+
             let DevtoolsPageInfo { title, url } = page_info;
             let tab = TabActor {
                 name: actors.new_name("tab"),
@@ -281,12 +285,13 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
                 timeline: timeline.name(),
                 profiler: profiler.name(),
                 performance: performance.name(),
+                thread: thread.name(),
             };
 
             let root = actors.find_mut::<RootActor>("root");
             root.tabs.push(tab.name.clone());
 
-            (tab, console, inspector, timeline, profiler, performance)
+            (tab, console, inspector, timeline, profiler, performance, thread)
         };
 
         if let Some(id) = worker_id {
@@ -306,6 +311,7 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
         actors.register(box timeline);
         actors.register(box profiler);
         actors.register(box performance);
+        actors.register(box thread);
     }
 
     fn handle_console_message(actors: Arc<Mutex<ActorRegistry>>,