Move code related to json packet reading to JsonPacketSender trait

fixup! Move code related to json packet reading to JsonPacketSender trait

components/devtools/actors/console.rs

@@ -7,7 +7,7 @@
 /// inspection, JS evaluation, autocompletion) in Servo.
 
 use actor::{Actor, ActorRegistry};
-use protocol::JsonPacketSender;
+use protocol::JsonPacketStream;
 
 use devtools_traits::{EvaluateJS, NullValue, VoidValue, NumberValue, StringValue, BooleanValue};
 use devtools_traits::{ActorValue, DevtoolScriptControlMsg};

components/devtools/actors/inspector.rs

@@ -8,7 +8,7 @@ use devtools_traits::{GetRootNode, GetDocumentElement, GetChildren, DevtoolScrip
 use devtools_traits::{GetLayout, NodeInfo};
 
 use actor::{Actor, ActorRegistry};
-use protocol::JsonPacketSender;
+use protocol::JsonPacketStream;
 
 use collections::TreeMap;
 use servo_msg::constellation_msg::PipelineId;

components/devtools/actors/root.rs

@@ -8,7 +8,7 @@
 
 use actor::{Actor, ActorRegistry};
 use actors::tab::{TabActor, TabActorMsg};
-use protocol::JsonPacketSender;
+use protocol::JsonPacketStream;
 
 use serialize::json;
 use std::io::TcpStream;

components/devtools/actors/tab.rs

@@ -7,7 +7,7 @@
 /// Supports dynamic attaching and detaching which control notifications of navigation, etc.
 
 use actor::{Actor, ActorRegistry};
-use protocol::JsonPacketSender;
+use protocol::JsonPacketStream;
 
 use serialize::json;
 use std::io::TcpStream;

components/devtools/lib.rs

@@ -34,7 +34,7 @@ use actors::console::ConsoleActor;
 use actors::inspector::InspectorActor;
 use actors::root::RootActor;
 use actors::tab::TabActor;
-use protocol::JsonPacketSender;
+use protocol::JsonPacketStream;
 
 use devtools_traits::{ServerExitMsg, DevtoolsControlMsg, NewGlobal, DevtoolScriptControlMsg};
 use servo_msg::constellation_msg::PipelineId;
@@ -44,9 +44,7 @@ use std::cell::RefCell;
 use std::comm;
 use std::comm::{Disconnected, Empty};
 use std::io::{TcpListener, TcpStream};
-use std::io::{Acceptor, Listener, EndOfFile, TimedOut};
-use std::num;
-use serialize::json;
+use std::io::{Acceptor, Listener, TimedOut};
 use sync::{Arc, Mutex};
 
 mod actor;
@@ -91,41 +89,20 @@ fn run_server(receiver: Receiver<DevtoolsControlMsg>, port: u16) {
     /// Process the input from a single devtools client until EOF.
     fn handle_client(actors: Arc<Mutex<ActorRegistry>>, mut stream: TcpStream) {
         println!("connection established to {:?}", stream.peer_name().unwrap());
-
         {
             let mut actors = actors.lock();
             let msg = actors.find::<RootActor>("root").encodable();
             stream.write_json_packet(&msg);
         }
 
-        // https://wiki.mozilla.org/Remote_Debugging_Protocol_Stream_Transport
-        // In short, each JSON packet is [ascii length]:[JSON data of given length]
-        // TODO: this really belongs in the protocol module.
         'outer: loop {
-            let mut buffer = vec!();
-            loop {
-                let colon = ':' as u8;
-                match stream.read_byte() {
-                    Ok(c) if c != colon => buffer.push(c as u8),
-                    Ok(_) => {
-                        let packet_len_str = String::from_utf8(buffer).unwrap();
-                        let packet_len = num::from_str_radix(packet_len_str.as_slice(), 10).unwrap();
-                        let packet_buf = stream.read_exact(packet_len).unwrap();
-                        let packet = String::from_utf8(packet_buf).unwrap();
-                        println!("{:s}", packet);
-                        let json_packet = json::from_str(packet.as_slice()).unwrap();
-                        actors.lock().handle_message(json_packet.as_object().unwrap(),
-                                                     &mut stream);
-                        break;
-                    }
-                    Err(ref e) if e.kind == EndOfFile => {
-                        println!("\nEOF");
-                        break 'outer;
-                    },
-                    _ => {
-                        println!("\nconnection error");
-                        break 'outer;
-                    }
+            match stream.read_json_packet() {
+                Ok(json_packet) =>
+                    actors.lock().handle_message(json_packet.as_object().unwrap(),
+                                                                &mut stream),
+                Err(e) => {
+                    println!("error: {}", e.desc);
+                    break 'outer
                 }
             }
         }

components/devtools/protocol.rs

@@ -5,18 +5,43 @@
 /// Low-level wire protocol implementation. Currently only supports [JSON packets](https://wiki.mozilla.org/Remote_Debugging_Protocol_Stream_Transport#JSON_Packets).
 
 use serialize::{json, Encodable};
-use std::io::{IoError, TcpStream};
+use std::io::{IoError, OtherIoError, EndOfFile, TcpStream, IoResult};
+use std::num;
 
-pub trait JsonPacketSender {
+pub trait JsonPacketStream {
     fn write_json_packet<'a, T: Encodable<json::Encoder<'a>,IoError>>(&mut self, obj: &T);
+    fn read_json_packet(&mut self) -> IoResult<json::Json>;
 }
 
-impl JsonPacketSender for TcpStream {
+impl JsonPacketStream for TcpStream {
     fn write_json_packet<'a, T: Encodable<json::Encoder<'a>,IoError>>(&mut self, obj: &T) {
         let s = json::encode(obj).replace("__type__", "type");
         println!("<- {:s}", s);
         self.write_str(s.len().to_string().as_slice()).unwrap();
         self.write_u8(':' as u8).unwrap();
         self.write_str(s.as_slice()).unwrap();
     }
+
+    fn read_json_packet<'a>(&mut self) -> IoResult<json::Json> {
+        // https://wiki.mozilla.org/Remote_Debugging_Protocol_Stream_Transport
+        // In short, each JSON packet is [ascii length]:[JSON data of given length]
+        let mut buffer = vec!();
+        loop {
+            let colon = ':' as u8;
+            match self.read_byte() {
+                Ok(c) if c != colon => buffer.push(c as u8),
+                Ok(_) => {
+                    let packet_len_str = String::from_utf8(buffer).unwrap();
+                    let packet_len = num::from_str_radix(packet_len_str.as_slice(), 10).unwrap();
+                    let packet_buf = self.read_exact(packet_len).unwrap();
+                    let packet = String::from_utf8(packet_buf).unwrap();
+                    println!("{:s}", packet);
+                    return Ok(json::from_str(packet.as_slice()).unwrap())
+                },
+                Err(ref e) if e.kind == EndOfFile =>
+                    return Err(IoError { kind: EndOfFile, desc: "EOF", detail: None }),
+                _ => return Err(IoError { kind: OtherIoError, desc: "connection error", detail: None })
+            }
+        }
+    }
 }