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.

3 files changed, 90 insertions, 3 deletions

diff --git a/components/devtools/actors/tab.rs b/components/devtools/actors/tab.rs
index 90a03688f12..7c93f3b4a71 100644
--- a/components/devtools/actors/tab.rs
+++ b/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,
diff --git a/components/devtools/actors/thread.rs b/components/devtools/actors/thread.rs
new file mode 100644
index 00000000000..087e1e9027f
--- /dev/null
+++ b/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,
+        })
+    }
+}
diff --git a/components/devtools/lib.rs b/components/devtools/lib.rs
index 3ee14422d53..2a6c532e05b 100644
--- a/components/devtools/lib.rs
+++ b/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>>,