Format components devtools and devtools_traits #21373

16 files changed, 650 insertions, 453 deletions

diff --git a/components/devtools/actor.rs b/components/devtools/actor.rs
index f2ee6398e9b..634622a2068 100644
--- a/components/devtools/actor.rs
+++ b/components/devtools/actor.rs
@@ -3,7 +3,6 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 /// General actor system infrastructure.
-
 use devtools_traits::PreciseTime;
 use serde_json::{Map, Value};
 use std::any::Any;
@@ -23,11 +22,13 @@ pub enum ActorMessageStatus {
 /// and the ability to process messages that are directed to particular actors.
 /// TODO: ensure the name is immutable
 pub trait Actor: Any + ActorAsAny {
-    fn handle_message(&self,
-                      registry: &ActorRegistry,
-                      msg_type: &str,
-                      msg: &Map<String, Value>,
-                      stream: &mut TcpStream) -> Result<ActorMessageStatus, ()>;
+    fn handle_message(
+        &self,
+        registry: &ActorRegistry,
+        msg_type: &str,
+        msg: &Map<String, Value>,
+        stream: &mut TcpStream,
+    ) -> Result<ActorMessageStatus, ()>;
     fn name(&self) -> String;
 }
 
@@ -37,8 +38,12 @@ pub trait ActorAsAny {
 }
 
 impl<T: Actor> ActorAsAny for T {
-    fn actor_as_any(&self) -> &Any { self }
-    fn actor_as_any_mut(&mut self) -> &mut Any { self }
+    fn actor_as_any(&self) -> &Any {
+        self
+    }
+    fn actor_as_any_mut(&mut self) -> &mut Any {
+        self
+    }
 }
 
 /// A list of known, owned actors.
@@ -57,8 +62,8 @@ impl ActorRegistry {
     pub fn new() -> ActorRegistry {
         ActorRegistry {
             actors: HashMap::new(),
-            new_actors: RefCell::new(vec!()),
-            old_actors: RefCell::new(vec!()),
+            new_actors: RefCell::new(vec![]),
+            old_actors: RefCell::new(vec![]),
             script_actors: RefCell::new(HashMap::new()),
             shareable: None,
             next: Cell::new(0),
@@ -149,29 +154,33 @@ impl ActorRegistry {
 
     /// Attempt to process a message as directed by its `to` property. If the actor is not
     /// found or does not indicate that it knew how to process the message, ignore the failure.
-    pub fn handle_message(&mut self,
-                          msg: &Map<String, Value>,
-                          stream: &mut TcpStream)
-                          -> Result<(), ()> {
+    pub fn handle_message(
+        &mut self,
+        msg: &Map<String, Value>,
+        stream: &mut TcpStream,
+    ) -> Result<(), ()> {
         let to = msg.get("to").unwrap().as_str().unwrap();
 
         match self.actors.get(to) {
             None => debug!("message received for unknown actor \"{}\"", to),
             Some(actor) => {
                 let msg_type = msg.get("type").unwrap().as_str().unwrap();
-                if actor.handle_message(self, msg_type, msg, stream)?
-                        != ActorMessageStatus::Processed {
-                    debug!("unexpected message type \"{}\" found for actor \"{}\"",
-                             msg_type, to);
+                if actor.handle_message(self, msg_type, msg, stream)? !=
+                    ActorMessageStatus::Processed
+                {
+                    debug!(
+                        "unexpected message type \"{}\" found for actor \"{}\"",
+                        msg_type, to
+                    );
                 }
-            }
+            },
         }
-        let new_actors = replace(&mut *self.new_actors.borrow_mut(), vec!());
+        let new_actors = replace(&mut *self.new_actors.borrow_mut(), vec![]);
         for actor in new_actors.into_iter() {
             self.actors.insert(actor.name().to_owned(), actor);
         }
 
-        let old_actors = replace(&mut *self.old_actors.borrow_mut(), vec!());
+        let old_actors = replace(&mut *self.old_actors.borrow_mut(), vec![]);
         for name in old_actors {
             self.drop_actor(name);
         }
diff --git a/components/devtools/actors/console.rs b/components/devtools/actors/console.rs
index 295ebca489b..e1996570164 100644
--- a/components/devtools/actors/console.rs
+++ b/components/devtools/actors/console.rs
@@ -94,32 +94,48 @@ impl Actor for ConsoleActor {
         self.name.clone()
     }
 
-    fn handle_message(&self,
-                      registry: &ActorRegistry,
-                      msg_type: &str,
-                      msg: &Map<String, Value>,
-                      stream: &mut TcpStream) -> Result<ActorMessageStatus, ()> {
+    fn handle_message(
+        &self,
+        registry: &ActorRegistry,
+        msg_type: &str,
+        msg: &Map<String, Value>,
+        stream: &mut TcpStream,
+    ) -> Result<ActorMessageStatus, ()> {
         Ok(match msg_type {
             "getCachedMessages" => {
-                let str_types = msg.get("messageTypes").unwrap().as_array().unwrap().into_iter().map(|json_type| {
-                    json_type.as_str().unwrap()
-                });
+                let str_types = msg
+                    .get("messageTypes")
+                    .unwrap()
+                    .as_array()
+                    .unwrap()
+                    .into_iter()
+                    .map(|json_type| json_type.as_str().unwrap());
                 let mut message_types = CachedConsoleMessageTypes::empty();
                 for str_type in str_types {
                     match str_type {
                         "PageError" => message_types.insert(CachedConsoleMessageTypes::PAGE_ERROR),
-                        "ConsoleAPI" => message_types.insert(CachedConsoleMessageTypes::CONSOLE_API),
+                        "ConsoleAPI" => {
+                            message_types.insert(CachedConsoleMessageTypes::CONSOLE_API)
+                        },
                         s => debug!("unrecognized message type requested: \"{}\"", s),
                     };
-                };
+                }
                 let (chan, port) = ipc::channel().unwrap();
-                self.script_chan.send(DevtoolScriptControlMsg::GetCachedMessages(
-                    self.pipeline, message_types, chan)).unwrap();
-                let messages = port.recv().map_err(|_| ())?.into_iter().map(|message| {
-                    let json_string = message.encode().unwrap();
-                    let json = serde_json::from_str::<Value>(&json_string).unwrap();
-                    json.as_object().unwrap().to_owned()
-                }).collect();
+                self.script_chan
+                    .send(DevtoolScriptControlMsg::GetCachedMessages(
+                        self.pipeline,
+                        message_types,
+                        chan,
+                    )).unwrap();
+                let messages = port
+                    .recv()
+                    .map_err(|_| ())?
+                    .into_iter()
+                    .map(|message| {
+                        let json_string = message.encode().unwrap();
+                        let json = serde_json::from_str::<Value>(&json_string).unwrap();
+                        json.as_object().unwrap().to_owned()
+                    }).collect();
 
                 let msg = GetCachedMessagesReply {
                     from: self.name(),
@@ -127,56 +143,60 @@ impl Actor for ConsoleActor {
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
             "startListeners" => {
                 //TODO: actually implement listener filters that support starting/stopping
                 let msg = StartedListenersReply {
                     from: self.name(),
                     nativeConsoleAPI: true,
-                    startedListeners:
-                        vec!("PageError".to_owned(), "ConsoleAPI".to_owned()),
+                    startedListeners: vec!["PageError".to_owned(), "ConsoleAPI".to_owned()],
                     traits: StartedListenersTraits {
                         customNetworkRequest: true,
-                    }
+                    },
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
             "stopListeners" => {
                 //TODO: actually implement listener filters that support starting/stopping
                 let msg = StopListenersReply {
                     from: self.name(),
-                    stoppedListeners: msg.get("listeners")
-                                         .unwrap()
-                                         .as_array()
-                                         .unwrap_or(&vec!())
-                                         .iter()
-                                         .map(|listener| listener.as_str().unwrap().to_owned())
-                                         .collect(),
+                    stoppedListeners: msg
+                        .get("listeners")
+                        .unwrap()
+                        .as_array()
+                        .unwrap_or(&vec![])
+                        .iter()
+                        .map(|listener| listener.as_str().unwrap().to_owned())
+                        .collect(),
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
             //TODO: implement autocompletion like onAutocomplete in
             //      http://mxr.mozilla.org/mozilla-central/source/toolkit/devtools/server/actors/webconsole.js
             "autocomplete" => {
                 let msg = AutocompleteReply {
                     from: self.name(),
-                    matches: vec!(),
+                    matches: vec![],
                     matchProp: "".to_owned(),
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
             "evaluateJS" => {
                 let input = msg.get("text").unwrap().as_str().unwrap().to_owned();
                 let (chan, port) = ipc::channel().unwrap();
-                self.script_chan.send(DevtoolScriptControlMsg::EvaluateJS(
-                    self.pipeline, input.clone(), chan)).unwrap();
+                self.script_chan
+                    .send(DevtoolScriptControlMsg::EvaluateJS(
+                        self.pipeline,
+                        input.clone(),
+                        chan,
+                    )).unwrap();
 
                 //TODO: extract conversion into protocol module or some other useful place
                 let result = match port.recv().map_err(|_| ())? {
@@ -184,12 +204,12 @@ impl Actor for ConsoleActor {
                         let mut m = Map::new();
                         m.insert("type".to_owned(), Value::String("undefined".to_owned()));
                         Value::Object(m)
-                    }
+                    },
                     NullValue => {
                         let mut m = Map::new();
                         m.insert("type".to_owned(), Value::String("null".to_owned()));
                         Value::Object(m)
-                    }
+                    },
                     BooleanValue(val) => Value::Bool(val),
                     NumberValue(val) => {
                         if val.is_nan() {
@@ -211,7 +231,7 @@ impl Actor for ConsoleActor {
                         } else {
                             Value::Number(Number::from_f64(val).unwrap())
                         }
-                    }
+                    },
                     StringValue(s) => Value::String(s),
                     ActorValue { class, uuid } => {
                         //TODO: make initial ActorValue message include these properties?
@@ -225,7 +245,7 @@ impl Actor for ConsoleActor {
                         m.insert("frozen".to_owned(), Value::Bool(false));
                         m.insert("sealed".to_owned(), Value::Bool(false));
                         Value::Object(m)
-                    }
+                    },
                 };
 
                 //TODO: catch and return exception values from JS evaluation
@@ -240,7 +260,7 @@ impl Actor for ConsoleActor {
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
             "setPreferences" => {
                 let msg = SetPreferencesReply {
@@ -249,9 +269,9 @@ impl Actor for ConsoleActor {
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
-            _ => ActorMessageStatus::Ignored
+            _ => ActorMessageStatus::Ignored,
         })
     }
 }
diff --git a/components/devtools/actors/framerate.rs b/components/devtools/actors/framerate.rs
index 39776c131cb..56145c63620 100644
--- a/components/devtools/actors/framerate.rs
+++ b/components/devtools/actors/framerate.rs
@@ -26,21 +26,24 @@ impl Actor for FramerateActor {
         self.name.clone()
     }
 
-
-    fn handle_message(&self,
-                      _registry: &ActorRegistry,
-                      _msg_type: &str,
-                      _msg: &Map<String, Value>,
-                      _stream: &mut TcpStream) -> Result<ActorMessageStatus, ()> {
+    fn handle_message(
+        &self,
+        _registry: &ActorRegistry,
+        _msg_type: &str,
+        _msg: &Map<String, Value>,
+        _stream: &mut TcpStream,
+    ) -> Result<ActorMessageStatus, ()> {
         Ok(ActorMessageStatus::Ignored)
     }
 }
 
 impl FramerateActor {
     /// return name of actor
-    pub fn create(registry: &ActorRegistry,
-                  pipeline_id: PipelineId,
-                  script_sender: IpcSender<DevtoolScriptControlMsg>) -> String {
+    pub fn create(
+        registry: &ActorRegistry,
+        pipeline_id: PipelineId,
+        script_sender: IpcSender<DevtoolScriptControlMsg>,
+    ) -> String {
         let actor_name = registry.new_name("framerate");
         let mut actor = FramerateActor {
             name: actor_name.clone(),
@@ -60,8 +63,7 @@ impl FramerateActor {
         self.ticks.push(HighResolutionStamp::wrap(tick));
 
         if self.is_recording {
-            let msg = DevtoolScriptControlMsg::RequestAnimationFrame(self.pipeline,
-                                                                     self.name());
+            let msg = DevtoolScriptControlMsg::RequestAnimationFrame(self.pipeline, self.name());
             self.script_sender.send(msg).unwrap();
         }
     }
@@ -78,8 +80,7 @@ impl FramerateActor {
         self.start_time = Some(precise_time_ns());
         self.is_recording = true;
 
-        let msg = DevtoolScriptControlMsg::RequestAnimationFrame(self.pipeline,
-                                                                 self.name());
+        let msg = DevtoolScriptControlMsg::RequestAnimationFrame(self.pipeline, self.name());
         self.script_sender.send(msg).unwrap();
     }
 
@@ -90,7 +91,6 @@ impl FramerateActor {
         self.is_recording = false;
         self.start_time = None;
     }
-
 }
 
 impl Drop for FramerateActor {
diff --git a/components/devtools/actors/inspector.rs b/components/devtools/actors/inspector.rs
index 22a69421ad8..040ba342155 100644
--- a/components/devtools/actors/inspector.rs
+++ b/components/devtools/actors/inspector.rs
@@ -61,27 +61,25 @@ impl Actor for HighlighterActor {
         self.name.clone()
     }
 
-    fn handle_message(&self,
-                      _registry: &ActorRegistry,
-                      msg_type: &str,
-                      _msg: &Map<String, Value>,
-                      stream: &mut TcpStream) -> Result<ActorMessageStatus, ()> {
+    fn handle_message(
+        &self,
+        _registry: &ActorRegistry,
+        msg_type: &str,
+        _msg: &Map<String, Value>,
+        stream: &mut TcpStream,
+    ) -> Result<ActorMessageStatus, ()> {
         Ok(match msg_type {
             "showBoxModel" => {
-                let msg = ShowBoxModelReply {
-                    from: self.name(),
-                };
+                let msg = ShowBoxModelReply { from: self.name() };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
             "hideBoxModel" => {
-                let msg = HideBoxModelReply {
-                    from: self.name(),
-                };
+                let msg = HideBoxModelReply { from: self.name() };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
             _ => ActorMessageStatus::Ignored,
         })
@@ -98,29 +96,33 @@ impl Actor for NodeActor {
         self.name.clone()
     }
 
-    fn handle_message(&self,
-                      registry: &ActorRegistry,
-                      msg_type: &str,
-                      msg: &Map<String, Value>,
-                      stream: &mut TcpStream) -> Result<ActorMessageStatus, ()> {
+    fn handle_message(
+        &self,
+        registry: &ActorRegistry,
+        msg_type: &str,
+        msg: &Map<String, Value>,
+        stream: &mut TcpStream,
+    ) -> Result<ActorMessageStatus, ()> {
         Ok(match msg_type {
             "modifyAttributes" => {
                 let target = msg.get("to").unwrap().as_str().unwrap();
                 let mods = msg.get("modifications").unwrap().as_array().unwrap();
-                let modifications = mods.iter().map(|json_mod| {
-                    serde_json::from_str(&serde_json::to_string(json_mod).unwrap()).unwrap()
-                }).collect();
-
-                self.script_chan.send(ModifyAttribute(self.pipeline,
-                                                      registry.actor_to_script(target.to_owned()),
-                                                      modifications))
-                                .unwrap();
-                let reply = ModifyAttributeReply {
-                    from: self.name(),
-                };
+                let modifications = mods
+                    .iter()
+                    .map(|json_mod| {
+                        serde_json::from_str(&serde_json::to_string(json_mod).unwrap()).unwrap()
+                    }).collect();
+
+                self.script_chan
+                    .send(ModifyAttribute(
+                        self.pipeline,
+                        registry.actor_to_script(target.to_owned()),
+                        modifications,
+                    )).unwrap();
+                let reply = ModifyAttributeReply { from: self.name() };
                 stream.write_json_packet(&reply);
                 ActorMessageStatus::Processed
-            }
+            },
 
             _ => ActorMessageStatus::Ignored,
         })
@@ -175,19 +177,23 @@ struct NodeActorMsg {
 }
 
 trait NodeInfoToProtocol {
-    fn encode(self,
-              actors: &ActorRegistry,
-              display: bool,
-              script_chan: IpcSender<DevtoolScriptControlMsg>,
-              pipeline: PipelineId) -> NodeActorMsg;
+    fn encode(
+        self,
+        actors: &ActorRegistry,
+        display: bool,
+        script_chan: IpcSender<DevtoolScriptControlMsg>,
+        pipeline: PipelineId,
+    ) -> NodeActorMsg;
 }
 
 impl NodeInfoToProtocol for NodeInfo {
-    fn encode(self,
-              actors: &ActorRegistry,
-              display: bool,
-              script_chan: IpcSender<DevtoolScriptControlMsg>,
-              pipeline: PipelineId) -> NodeActorMsg {
+    fn encode(
+        self,
+        actors: &ActorRegistry,
+        display: bool,
+        script_chan: IpcSender<DevtoolScriptControlMsg>,
+        pipeline: PipelineId,
+    ) -> NodeActorMsg {
         let actor_name = if !actors.script_actor_registered(self.uniqueId.clone()) {
             let name = actors.new_name("node");
             let node_actor = NodeActor {
@@ -215,15 +221,16 @@ impl NodeInfoToProtocol for NodeInfo {
             publicId: self.publicId,
             systemId: self.systemId,
 
-            attrs: self.attrs.into_iter().map(|attr| {
-                AttrMsg {
+            attrs: self
+                .attrs
+                .into_iter()
+                .map(|attr| AttrMsg {
                     namespace: attr.namespace,
                     name: attr.name,
                     value: attr.value,
-                }
-            }).collect(),
+                }).collect(),
 
-            pseudoClassLocks: vec!(), //TODO get this data from script
+            pseudoClassLocks: vec![], //TODO get this data from script
 
             isDisplayed: display,
 
@@ -272,25 +279,28 @@ impl Actor for WalkerActor {
         self.name.clone()
     }
 
-    fn handle_message(&self,
-                      registry: &ActorRegistry,
-                      msg_type: &str,
-                      msg: &Map<String, Value>,
-                      stream: &mut TcpStream) -> Result<ActorMessageStatus, ()> {
+    fn handle_message(
+        &self,
+        registry: &ActorRegistry,
+        msg_type: &str,
+        msg: &Map<String, Value>,
+        stream: &mut TcpStream,
+    ) -> Result<ActorMessageStatus, ()> {
         Ok(match msg_type {
             "querySelector" => {
-                let msg = QuerySelectorReply {
-                    from: self.name(),
-                };
+                let msg = QuerySelectorReply { from: self.name() };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
             "documentElement" => {
                 let (tx, rx) = ipc::channel().unwrap();
-                self.script_chan.send(GetDocumentElement(self.pipeline, tx)).unwrap();
+                self.script_chan
+                    .send(GetDocumentElement(self.pipeline, tx))
+                    .unwrap();
                 let doc_elem_info = rx.recv().unwrap().ok_or(())?;
-                let node = doc_elem_info.encode(registry, true, self.script_chan.clone(), self.pipeline);
+                let node =
+                    doc_elem_info.encode(registry, true, self.script_chan.clone(), self.pipeline);
 
                 let msg = DocumentElementReply {
                     from: self.name(),
@@ -298,36 +308,38 @@ impl Actor for WalkerActor {
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
             "clearPseudoClassLocks" => {
-                let msg = ClearPseudoclassesReply {
-                    from: self.name(),
-                };
+                let msg = ClearPseudoclassesReply { from: self.name() };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
             "children" => {
                 let target = msg.get("node").unwrap().as_str().unwrap();
                 let (tx, rx) = ipc::channel().unwrap();
-                self.script_chan.send(GetChildren(self.pipeline,
-                                                  registry.actor_to_script(target.to_owned()),
-                                                  tx))
-                                .unwrap();
+                self.script_chan
+                    .send(GetChildren(
+                        self.pipeline,
+                        registry.actor_to_script(target.to_owned()),
+                        tx,
+                    )).unwrap();
                 let children = rx.recv().unwrap().ok_or(())?;
 
                 let msg = ChildrenReply {
                     hasFirst: true,
                     hasLast: true,
-                    nodes: children.into_iter().map(|child| {
-                        child.encode(registry, true, self.script_chan.clone(), self.pipeline)
-                    }).collect(),
+                    nodes: children
+                        .into_iter()
+                        .map(|child| {
+                            child.encode(registry, true, self.script_chan.clone(), self.pipeline)
+                        }).collect(),
                     from: self.name(),
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
             _ => ActorMessageStatus::Ignored,
         })
@@ -447,52 +459,72 @@ impl Actor for PageStyleActor {
         self.name.clone()
     }
 
-    fn handle_message(&self,
-                      registry: &ActorRegistry,
-                      msg_type: &str,
-                      msg: &Map<String, Value>,
-                      stream: &mut TcpStream) -> Result<ActorMessageStatus, ()> {
+    fn handle_message(
+        &self,
+        registry: &ActorRegistry,
+        msg_type: &str,
+        msg: &Map<String, Value>,
+        stream: &mut TcpStream,
+    ) -> Result<ActorMessageStatus, ()> {
         Ok(match msg_type {
             "getApplied" => {
                 //TODO: query script for relevant applied styles to node (msg.node)
                 let msg = GetAppliedReply {
-                    entries: vec!(),
-                    rules: vec!(),
-                    sheets: vec!(),
+                    entries: vec![],
+                    rules: vec![],
+                    sheets: vec![],
                     from: self.name(),
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
             "getComputed" => {
                 //TODO: query script for relevant computed styles on node (msg.node)
                 let msg = GetComputedReply {
-                    computed: vec!(),
+                    computed: vec![],
                     from: self.name(),
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
             //TODO: query script for box layout properties of node (msg.node)
             "getLayout" => {
                 let target = msg.get("node").unwrap().as_str().unwrap();
                 let (tx, rx) = ipc::channel().unwrap();
-                self.script_chan.send(GetLayout(self.pipeline,
-                                      registry.actor_to_script(target.to_owned()),
-                                      tx))
-                                .unwrap();
+                self.script_chan
+                    .send(GetLayout(
+                        self.pipeline,
+                        registry.actor_to_script(target.to_owned()),
+                        tx,
+                    )).unwrap();
                 let ComputedNodeLayout {
-                    display, position, zIndex, boxSizing,
-                    autoMargins, marginTop, marginRight, marginBottom, marginLeft,
-                    borderTopWidth, borderRightWidth, borderBottomWidth, borderLeftWidth,
-                    paddingTop, paddingRight, paddingBottom, paddingLeft,
-                    width, height,
+                    display,
+                    position,
+                    zIndex,
+                    boxSizing,
+                    autoMargins,
+                    marginTop,
+                    marginRight,
+                    marginBottom,
+                    marginLeft,
+                    borderTopWidth,
+                    borderRightWidth,
+                    borderBottomWidth,
+                    borderLeftWidth,
+                    paddingTop,
+                    paddingRight,
+                    paddingBottom,
+                    paddingLeft,
+                    width,
+                    height,
                 } = rx.recv().unwrap().ok_or(())?;
 
-                let auto_margins = msg.get("autoMargins")
-                    .and_then(&Value::as_bool).unwrap_or(false);
+                let auto_margins = msg
+                    .get("autoMargins")
+                    .and_then(&Value::as_bool)
+                    .unwrap_or(false);
 
                 // http://mxr.mozilla.org/mozilla-central/source/toolkit/devtools/server/actors/styles.js
                 let msg = GetLayoutReply {
@@ -504,10 +536,18 @@ impl Actor for PageStyleActor {
                     autoMargins: if auto_margins {
                         let mut m = Map::new();
                         let auto = serde_json::value::Value::String("auto".to_owned());
-                        if autoMargins.top { m.insert("top".to_owned(), auto.clone()); }
-                        if autoMargins.right { m.insert("right".to_owned(), auto.clone()); }
-                        if autoMargins.bottom { m.insert("bottom".to_owned(), auto.clone()); }
-                        if autoMargins.left { m.insert("left".to_owned(), auto.clone()); }
+                        if autoMargins.top {
+                            m.insert("top".to_owned(), auto.clone());
+                        }
+                        if autoMargins.right {
+                            m.insert("right".to_owned(), auto.clone());
+                        }
+                        if autoMargins.bottom {
+                            m.insert("bottom".to_owned(), auto.clone());
+                        }
+                        if autoMargins.left {
+                            m.insert("left".to_owned(), auto.clone());
+                        }
                         serde_json::value::Value::Object(m)
                     } else {
                         serde_json::value::Value::Null
@@ -531,7 +571,7 @@ impl Actor for PageStyleActor {
                 let msg = serde_json::from_str::<Value>(&msg).unwrap();
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
             _ => ActorMessageStatus::Ignored,
         })
@@ -543,11 +583,13 @@ impl Actor for InspectorActor {
         self.name.clone()
     }
 
-    fn handle_message(&self,
-                      registry: &ActorRegistry,
-                      msg_type: &str,
-                      _msg: &Map<String, Value>,
-                      stream: &mut TcpStream) -> Result<ActorMessageStatus, ()> {
+    fn handle_message(
+        &self,
+        registry: &ActorRegistry,
+        msg_type: &str,
+        _msg: &Map<String, Value>,
+        stream: &mut TcpStream,
+    ) -> Result<ActorMessageStatus, ()> {
         Ok(match msg_type {
             "getWalker" => {
                 if self.walker.borrow().is_none() {
@@ -562,21 +604,24 @@ impl Actor for InspectorActor {
                 }
 
                 let (tx, rx) = ipc::channel().unwrap();
-                self.script_chan.send(GetRootNode(self.pipeline, tx)).unwrap();
+                self.script_chan
+                    .send(GetRootNode(self.pipeline, tx))
+                    .unwrap();
                 let root_info = rx.recv().unwrap().ok_or(())?;
 
-                let node = root_info.encode(registry, false, self.script_chan.clone(), self.pipeline);
+                let node =
+                    root_info.encode(registry, false, self.script_chan.clone(), self.pipeline);
 
                 let msg = GetWalkerReply {
                     from: self.name(),
                     walker: WalkerMsg {
                         actor: self.walker.borrow().clone().unwrap(),
                         root: node,
-                    }
+                    },
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
             "getPageStyle" => {
                 if self.pageStyle.borrow().is_none() {
@@ -598,7 +643,7 @@ impl Actor for InspectorActor {
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
             //TODO: this is an old message; try adding highlightable to the root traits instead
             //      and support getHighlighter instead
@@ -621,7 +666,7 @@ impl Actor for InspectorActor {
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
             _ => ActorMessageStatus::Ignored,
         })
diff --git a/components/devtools/actors/memory.rs b/components/devtools/actors/memory.rs
index 518358ea69b..b88b5a3cf20 100644
--- a/components/devtools/actors/memory.rs
+++ b/components/devtools/actors/memory.rs
@@ -28,11 +28,13 @@ impl Actor for MemoryActor {
         self.name.clone()
     }
 
-    fn handle_message(&self,
-                      _registry: &ActorRegistry,
-                      _msg_type: &str,
-                      _msg: &Map<String, Value>,
-                      _stream: &mut TcpStream) -> Result<ActorMessageStatus, ()> {
+    fn handle_message(
+        &self,
+        _registry: &ActorRegistry,
+        _msg_type: &str,
+        _msg: &Map<String, Value>,
+        _stream: &mut TcpStream,
+    ) -> Result<ActorMessageStatus, ()> {
         Ok(ActorMessageStatus::Ignored)
     }
 }
@@ -42,7 +44,7 @@ impl MemoryActor {
     pub fn create(registry: &ActorRegistry) -> String {
         let actor_name = registry.new_name("memory");
         let actor = MemoryActor {
-            name: actor_name.clone()
+            name: actor_name.clone(),
         };
 
         registry.register_later(Box::new(actor));
diff --git a/components/devtools/actors/network_event.rs b/components/devtools/actors/network_event.rs
index 0906971821a..5e4fe01bcf3 100644
--- a/components/devtools/actors/network_event.rs
+++ b/components/devtools/actors/network_event.rs
@@ -34,7 +34,7 @@ struct HttpRequest {
 struct HttpResponse {
     headers: Option<Headers>,
     status: Option<RawStatus>,
-    body: Option<Vec<u8>>
+    body: Option<Vec<u8>>,
 }
 
 pub struct NetworkEventActor {
@@ -52,7 +52,7 @@ pub struct EventActor {
     pub startedDateTime: String,
     pub timeStamp: i64,
     pub isXHR: bool,
-    pub private: bool
+    pub private: bool,
 }
 
 #[derive(Serialize)]
@@ -79,14 +79,12 @@ pub struct ResponseContentMsg {
     pub discardResponseBody: bool,
 }
 
-
 #[derive(Serialize)]
 pub struct ResponseHeadersMsg {
     pub headers: usize,
     pub headersSize: usize,
 }
 
-
 #[derive(Serialize)]
 pub struct RequestCookiesMsg {
     pub cookies: usize,
@@ -103,7 +101,7 @@ struct GetRequestHeadersReply {
     from: String,
     headers: Vec<Header>,
     headerSize: usize,
-    rawHeaders: String
+    rawHeaders: String,
 }
 
 #[derive(Serialize)]
@@ -117,7 +115,7 @@ struct GetResponseHeadersReply {
     from: String,
     headers: Vec<Header>,
     headerSize: usize,
-    rawHeaders: String
+    rawHeaders: String,
 }
 
 #[derive(Serialize)]
@@ -131,19 +129,19 @@ struct GetResponseContentReply {
 struct GetRequestPostDataReply {
     from: String,
     postData: Option<Vec<u8>>,
-    postDataDiscarded: bool
+    postDataDiscarded: bool,
 }
 
 #[derive(Serialize)]
 struct GetRequestCookiesReply {
     from: String,
-    cookies: Vec<u8>
+    cookies: Vec<u8>,
 }
 
 #[derive(Serialize)]
 struct GetResponseCookiesReply {
     from: String,
-    cookies: Vec<u8>
+    cookies: Vec<u8>,
 }
 
 #[derive(Serialize)]
@@ -179,11 +177,13 @@ impl Actor for NetworkEventActor {
         self.name.clone()
     }
 
-    fn handle_message(&self,
-                      _registry: &ActorRegistry,
-                      msg_type: &str,
-                      _msg: &Map<String, Value>,
-                      stream: &mut TcpStream) -> Result<ActorMessageStatus, ()> {
+    fn handle_message(
+        &self,
+        _registry: &ActorRegistry,
+        msg_type: &str,
+        _msg: &Map<String, Value>,
+        stream: &mut TcpStream,
+    ) -> Result<ActorMessageStatus, ()> {
         Ok(match msg_type {
             "getRequestHeaders" => {
                 let mut headers = Vec::new();
@@ -194,7 +194,10 @@ impl Actor for NetworkEventActor {
                     let value = item.value_string();
                     rawHeadersString = rawHeadersString + name + ":" + &value + "\r\n";
                     headersSize += name.len() + value.len();
-                    headers.push(Header { name: name.to_owned(), value: value.to_owned() });
+                    headers.push(Header {
+                        name: name.to_owned(),
+                        value: value.to_owned(),
+                    });
                 }
                 let msg = GetRequestHeadersReply {
                     from: self.name(),
@@ -204,7 +207,7 @@ impl Actor for NetworkEventActor {
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
             "getRequestCookies" => {
                 let mut cookies = Vec::new();
                 if let Some(req_cookies) = self.request.headers.get_raw("Cookie") {
@@ -221,7 +224,7 @@ impl Actor for NetworkEventActor {
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
             "getRequestPostData" => {
                 let msg = GetRequestPostDataReply {
                     from: self.name(),
@@ -230,7 +233,7 @@ impl Actor for NetworkEventActor {
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
             "getResponseHeaders" => {
                 if let Some(ref response_headers) = self.response.headers {
                     let mut headers = vec![];
@@ -258,7 +261,7 @@ impl Actor for NetworkEventActor {
                     stream.write_json_packet(&msg);
                 }
                 ActorMessageStatus::Processed
-            }
+            },
             "getResponseCookies" => {
                 let mut cookies = Vec::new();
                 if let Some(res_cookies) = self.request.headers.get_raw("set-cookie") {
@@ -275,7 +278,7 @@ impl Actor for NetworkEventActor {
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
             "getResponseContent" => {
                 let msg = GetResponseContentReply {
                     from: self.name(),
@@ -284,7 +287,7 @@ impl Actor for NetworkEventActor {
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
             "getEventTimings" => {
                 // TODO: This is a fake timings msg
                 let timingsObj = Timings {
@@ -304,19 +307,19 @@ impl Actor for NetworkEventActor {
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
             "getSecurityInfo" => {
                 // TODO: Send the correct values for securityInfo.
                 let msg = GetSecurityInfoReply {
                     from: self.name(),
                     securityInfo: SecurityInfo {
-                        state: "insecure".to_owned()
+                        state: "insecure".to_owned(),
                     },
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
-            _ => ActorMessageStatus::Ignored
+            },
+            _ => ActorMessageStatus::Ignored,
         })
     }
 }
@@ -382,8 +385,13 @@ impl NetworkEventActor {
         // TODO: Send the correct values for all these fields.
         let hSizeOption = self.response.headers.as_ref().map(|headers| headers.len());
         let hSize = hSizeOption.unwrap_or(0);
-        let (status_code, status_message) = self.response.status.as_ref().
-                map_or((0, "".to_owned()), |&RawStatus(ref code, ref text)| (*code, text.clone().into_owned()));
+        let (status_code, status_message) = self
+            .response
+            .status
+            .as_ref()
+            .map_or((0, "".to_owned()), |&RawStatus(ref code, ref text)| {
+                (*code, text.clone().into_owned())
+            });
         // TODO: Send the correct values for remoteAddress and remotePort and http_version.
         ResponseStartMsg {
             httpVersion: "HTTP/1.1".to_owned(),
@@ -392,7 +400,7 @@ impl NetworkEventActor {
             status: status_code.to_string(),
             statusText: status_message,
             headersSize: hSize,
-            discardResponseBody: false
+            discardResponseBody: false,
         }
     }
 
@@ -401,7 +409,7 @@ impl NetworkEventActor {
         if let Some(ref headers) = self.response.headers {
             mString = match headers.get() {
                 Some(&ContentType(ref mime)) => mime.to_string(),
-                None => "".to_owned()
+                None => "".to_owned(),
             };
         }
         // TODO: Set correct values when response's body is sent to the devtools in http_loader.
@@ -418,7 +426,7 @@ impl NetworkEventActor {
         if let Some(ref headers) = self.response.headers {
             cookies_size = match headers.get() {
                 Some(&Cookie(ref cookie)) => cookie.len(),
-                None => 0
+                None => 0,
             };
         }
         ResponseCookiesMsg {
@@ -431,10 +439,9 @@ impl NetworkEventActor {
         let mut headers_byte_count = 0;
         if let Some(ref headers) = self.response.headers {
             headers_size = headers.len();
-            for item in headers.iter()  {
+            for item in headers.iter() {
                 headers_byte_count += item.name().len() + item.value_string().len();
             }
-
         }
         ResponseHeadersMsg {
             headers: headers_size,
@@ -443,10 +450,11 @@ impl NetworkEventActor {
     }
 
     pub fn request_headers(&self) -> RequestHeadersMsg {
-        let size = self.request
-                       .headers
-                       .iter()
-                       .fold(0, |acc, h| acc + h.name().len() + h.value_string().len());
+        let size = self
+            .request
+            .headers
+            .iter()
+            .fold(0, |acc, h| acc + h.name().len() + h.value_string().len());
         RequestHeadersMsg {
             headers: self.request.headers.len(),
             headersSize: size,
@@ -456,7 +464,7 @@ impl NetworkEventActor {
     pub fn request_cookies(&self) -> RequestCookiesMsg {
         let cookies_size = match self.request.headers.get() {
             Some(&Cookie(ref cookie)) => cookie.len(),
-            None => 0
+            None => 0,
         };
         RequestCookiesMsg {
             cookies: cookies_size,
diff --git a/components/devtools/actors/object.rs b/components/devtools/actors/object.rs
index 943adf8b5fc..0ed2facf848 100644
--- a/components/devtools/actors/object.rs
+++ b/components/devtools/actors/object.rs
@@ -15,11 +15,13 @@ impl Actor for ObjectActor {
     fn name(&self) -> String {
         self.name.clone()
     }
-    fn handle_message(&self,
-                      _: &ActorRegistry,
-                      _: &str,
-                      _: &Map<String, Value>,
-                      _: &mut TcpStream) -> Result<ActorMessageStatus, ()> {
+    fn handle_message(
+        &self,
+        _: &ActorRegistry,
+        _: &str,
+        _: &Map<String, Value>,
+        _: &mut TcpStream,
+    ) -> Result<ActorMessageStatus, ()> {
         Ok(ActorMessageStatus::Ignored)
     }
 }
diff --git a/components/devtools/actors/performance.rs b/components/devtools/actors/performance.rs
index c246cb26fa4..b3f367958a6 100644
--- a/components/devtools/actors/performance.rs
+++ b/components/devtools/actors/performance.rs
@@ -51,11 +51,13 @@ impl Actor for PerformanceActor {
         self.name.clone()
     }
 
-    fn handle_message(&self,
-                      _registry: &ActorRegistry,
-                      msg_type: &str,
-                      _msg: &Map<String, Value>,
-                      stream: &mut TcpStream) -> Result<ActorMessageStatus, ()> {
+    fn handle_message(
+        &self,
+        _registry: &ActorRegistry,
+        msg_type: &str,
+        _msg: &Map<String, Value>,
+        stream: &mut TcpStream,
+    ) -> Result<ActorMessageStatus, ()> {
         Ok(match msg_type {
             "connect" => {
                 let msg = ConnectReply {
@@ -79,11 +81,11 @@ impl Actor for PerformanceActor {
                     value: SuccessMsg {
                         success: true,
                         errors: vec![],
-                    }
+                    },
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
             _ => ActorMessageStatus::Ignored,
         })
     }
@@ -91,28 +93,34 @@ impl Actor for PerformanceActor {
 
 impl PerformanceActor {
     pub fn new(name: String) -> PerformanceActor {
-        PerformanceActor {
-            name: name,
-        }
+        PerformanceActor { name: name }
     }
 
     pub fn description() -> ActorDescription {
         ActorDescription {
             category: "actor",
             typeName: "performance",
-            methods: vec![
-                Method {
-                    name: "canCurrentlyRecord",
-                    request: Value::Object(vec![
-                        ("type".to_owned(), Value::String("canCurrentlyRecord".to_owned())),
-                    ].into_iter().collect()),
-                    response: Value::Object(vec![
-                        ("value".to_owned(), Value::Object(vec![
-                            ("_retval".to_owned(), Value::String("json".to_owned())),
-                        ].into_iter().collect())),
-                    ].into_iter().collect()),
-                },
-            ],
+            methods: vec![Method {
+                name: "canCurrentlyRecord",
+                request: Value::Object(
+                    vec![(
+                        "type".to_owned(),
+                        Value::String("canCurrentlyRecord".to_owned()),
+                    )].into_iter()
+                    .collect(),
+                ),
+                response: Value::Object(
+                    vec![(
+                        "value".to_owned(),
+                        Value::Object(
+                            vec![("_retval".to_owned(), Value::String("json".to_owned()))]
+                                .into_iter()
+                                .collect(),
+                        ),
+                    )].into_iter()
+                    .collect(),
+                ),
+            }],
         }
     }
 }
diff --git a/components/devtools/actors/profiler.rs b/components/devtools/actors/profiler.rs
index a80e3c0018b..cb19f7afb6b 100644
--- a/components/devtools/actors/profiler.rs
+++ b/components/devtools/actors/profiler.rs
@@ -15,19 +15,19 @@ impl Actor for ProfilerActor {
         self.name.clone()
     }
 
-    fn handle_message(&self,
-                      _registry: &ActorRegistry,
-                      _msg_type: &str,
-                      _msg: &Map<String, Value>,
-                      _stream: &mut TcpStream) -> Result<ActorMessageStatus, ()> {
+    fn handle_message(
+        &self,
+        _registry: &ActorRegistry,
+        _msg_type: &str,
+        _msg: &Map<String, Value>,
+        _stream: &mut TcpStream,
+    ) -> Result<ActorMessageStatus, ()> {
         Ok(ActorMessageStatus::Ignored)
     }
 }
 
 impl ProfilerActor {
     pub fn new(name: String) -> ProfilerActor {
-        ProfilerActor {
-            name: name,
-        }
+        ProfilerActor { name: name }
     }
 }
diff --git a/components/devtools/actors/root.rs b/components/devtools/actors/root.rs
index 20629ea7a7b..4e12055ec8e 100644
--- a/components/devtools/actors/root.rs
+++ b/components/devtools/actors/root.rs
@@ -6,7 +6,6 @@
 /// (http://mxr.mozilla.org/mozilla-central/source/toolkit/devtools/server/actors/root.js).
 /// Connection point for all new remote devtools interactions, providing lists of know actors
 /// that perform more specific actions (tabs, addons, browser chrome, etc.)
-
 use actor::{Actor, ActorMessageStatus, ActorRegistry};
 use actors::performance::PerformanceActor;
 use actors::tab::{TabActor, TabActorMsg};
@@ -65,11 +64,13 @@ impl Actor for RootActor {
         "root".to_owned()
     }
 
-    fn handle_message(&self,
-                      registry: &ActorRegistry,
-                      msg_type: &str,
-                      _msg: &Map<String, Value>,
-                      stream: &mut TcpStream) -> Result<ActorMessageStatus, ()> {
+    fn handle_message(
+        &self,
+        registry: &ActorRegistry,
+        msg_type: &str,
+        _msg: &Map<String, Value>,
+        stream: &mut TcpStream,
+    ) -> Result<ActorMessageStatus, ()> {
         Ok(match msg_type {
             "listAddons" => {
                 let actor = ListAddonsReply {
@@ -78,20 +79,22 @@ impl Actor for RootActor {
                 };
                 stream.write_json_packet(&actor);
                 ActorMessageStatus::Processed
-            }
+            },
 
             //https://wiki.mozilla.org/Remote_Debugging_Protocol#Listing_Browser_Tabs
             "listTabs" => {
                 let actor = ListTabsReply {
                     from: "root".to_owned(),
                     selected: 0,
-                    tabs: self.tabs.iter().map(|tab| {
-                        registry.find::<TabActor>(tab).encodable()
-                    }).collect()
+                    tabs: self
+                        .tabs
+                        .iter()
+                        .map(|tab| registry.find::<TabActor>(tab).encodable())
+                        .collect(),
                 };
                 stream.write_json_packet(&actor);
                 ActorMessageStatus::Processed
-            }
+            },
 
             "protocolDescription" => {
                 let msg = ProtocolDescriptionReply {
@@ -102,9 +105,9 @@ impl Actor for RootActor {
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
-            _ => ActorMessageStatus::Ignored
+            _ => ActorMessageStatus::Ignored,
         })
     }
 }
@@ -118,7 +121,7 @@ impl RootActor {
                 sources: true,
                 highlightable: true,
                 customHighlighters: true,
-                networkMonitor: true
+                networkMonitor: true,
             },
         }
     }
diff --git a/components/devtools/actors/tab.rs b/components/devtools/actors/tab.rs
index 916c5319386..e6f50773f68 100644
--- a/components/devtools/actors/tab.rs
+++ b/components/devtools/actors/tab.rs
@@ -37,7 +37,7 @@ struct TabDetachedReply {
 
 #[derive(Serialize)]
 struct ReconfigureReply {
-    from: String
+    from: String,
 }
 
 #[derive(Serialize)]
@@ -84,25 +84,28 @@ impl Actor for TabActor {
         self.name.clone()
     }
 
-    fn handle_message(&self,
-                      registry: &ActorRegistry,
-                      msg_type: &str,
-                      msg: &Map<String, Value>,
-                      stream: &mut TcpStream) -> Result<ActorMessageStatus, ()> {
+    fn handle_message(
+        &self,
+        registry: &ActorRegistry,
+        msg_type: &str,
+        msg: &Map<String, Value>,
+        stream: &mut TcpStream,
+    ) -> Result<ActorMessageStatus, ()> {
         Ok(match msg_type {
             "reconfigure" => {
                 if let Some(options) = msg.get("options").and_then(|o| o.as_object()) {
                     if let Some(val) = options.get("performReload") {
                         if val.as_bool().unwrap_or(false) {
                             let console_actor = registry.find::<ConsoleActor>(&self.console);
-                            let _ = console_actor.script_chan.send(
-                                DevtoolScriptControlMsg::Reload(console_actor.pipeline));
+                            let _ = console_actor
+                                .script_chan
+                                .send(DevtoolScriptControlMsg::Reload(console_actor.pipeline));
                         }
                     }
                 }
                 stream.write_json_packet(&ReconfigureReply { from: self.name() });
                 ActorMessageStatus::Processed
-            }
+            },
 
             // https://wiki.mozilla.org/Remote_Debugging_Protocol#Listing_Browser_Tabs
             // (see "To attach to a _tabActor_")
@@ -116,12 +119,17 @@ impl Actor for TabActor {
                     traits: TabTraits,
                 };
                 let console_actor = registry.find::<ConsoleActor>(&self.console);
-                console_actor.streams.borrow_mut().push(stream.try_clone().unwrap());
+                console_actor
+                    .streams
+                    .borrow_mut()
+                    .push(stream.try_clone().unwrap());
                 stream.write_json_packet(&msg);
-                console_actor.script_chan.send(
-                    WantsLiveNotifications(console_actor.pipeline, true)).unwrap();
+                console_actor
+                    .script_chan
+                    .send(WantsLiveNotifications(console_actor.pipeline, true))
+                    .unwrap();
                 ActorMessageStatus::Processed
-            }
+            },
 
             //FIXME: The current implementation won't work for multiple connections. Need to ensure 105
             //       that the correct stream is removed.
@@ -133,21 +141,23 @@ impl Actor for TabActor {
                 let console_actor = registry.find::<ConsoleActor>(&self.console);
                 console_actor.streams.borrow_mut().pop();
                 stream.write_json_packet(&msg);
-                console_actor.script_chan.send(
-                    WantsLiveNotifications(console_actor.pipeline, false)).unwrap();
+                console_actor
+                    .script_chan
+                    .send(WantsLiveNotifications(console_actor.pipeline, false))
+                    .unwrap();
                 ActorMessageStatus::Processed
-            }
+            },
 
             "listFrames" => {
                 let msg = ListFramesReply {
                     from: self.name(),
-                    frames: vec!(),
+                    frames: vec![],
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
-            _ => ActorMessageStatus::Ignored
+            _ => ActorMessageStatus::Ignored,
         })
     }
 }
diff --git a/components/devtools/actors/thread.rs b/components/devtools/actors/thread.rs
index 7be5bc55f23..dc2638bd135 100644
--- a/components/devtools/actors/thread.rs
+++ b/components/devtools/actors/thread.rs
@@ -35,7 +35,7 @@ struct ThreadResumedReply {
 
 #[derive(Serialize)]
 struct ReconfigureReply {
-    from: String
+    from: String,
 }
 
 #[derive(Serialize)]
@@ -53,9 +53,7 @@ pub struct ThreadActor {
 
 impl ThreadActor {
     pub fn new(name: String) -> ThreadActor {
-        ThreadActor {
-            name: name,
-        }
+        ThreadActor { name: name }
     }
 }
 
@@ -64,11 +62,13 @@ impl Actor for ThreadActor {
         self.name.clone()
     }
 
-    fn handle_message(&self,
-                      registry: &ActorRegistry,
-                      msg_type: &str,
-                      _msg: &Map<String, Value>,
-                      stream: &mut TcpStream) -> Result<ActorMessageStatus, ()> {
+    fn handle_message(
+        &self,
+        registry: &ActorRegistry,
+        msg_type: &str,
+        _msg: &Map<String, Value>,
+        stream: &mut TcpStream,
+    ) -> Result<ActorMessageStatus, ()> {
         Ok(match msg_type {
             "attach" => {
                 let msg = ThreadAttachedReply {
@@ -76,7 +76,9 @@ impl Actor for ThreadActor {
                     type_: "paused".to_owned(),
                     actor: registry.new_name("pause"),
                     poppedFrames: vec![],
-                    why: WhyMsg { type_: "attached".to_owned() },
+                    why: WhyMsg {
+                        type_: "attached".to_owned(),
+                    },
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
@@ -94,7 +96,7 @@ impl Actor for ThreadActor {
             "reconfigure" => {
                 stream.write_json_packet(&ReconfigureReply { from: self.name() });
                 ActorMessageStatus::Processed
-            }
+            },
 
             "sources" => {
                 let msg = SourcesReply {
@@ -103,7 +105,7 @@ impl Actor for ThreadActor {
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
             _ => ActorMessageStatus::Ignored,
         })
diff --git a/components/devtools/actors/timeline.rs b/components/devtools/actors/timeline.rs
index 0ea57ad8dbb..d5b5295a138 100644
--- a/components/devtools/actors/timeline.rs
+++ b/components/devtools/actors/timeline.rs
@@ -44,7 +44,7 @@ struct Emitter {
 #[derive(Serialize)]
 struct IsRecordingReply {
     from: String,
-    value: bool
+    value: bool,
 }
 
 #[derive(Serialize)]
@@ -103,8 +103,10 @@ pub struct HighResolutionStamp(f64);
 
 impl HighResolutionStamp {
     pub fn new(start_stamp: PreciseTime, time: PreciseTime) -> HighResolutionStamp {
-        let duration = start_stamp.to(time).num_microseconds()
-                                  .expect("Too big duration in microseconds");
+        let duration = start_stamp
+            .to(time)
+            .num_microseconds()
+            .expect("Too big duration in microseconds");
         HighResolutionStamp(duration as f64 / 1000 as f64)
     }
 
@@ -122,11 +124,12 @@ impl Serialize for HighResolutionStamp {
 static DEFAULT_TIMELINE_DATA_PULL_TIMEOUT: u64 = 200; //ms
 
 impl TimelineActor {
-    pub fn new(name: String,
-               pipeline: PipelineId,
-               script_sender: IpcSender<DevtoolScriptControlMsg>) -> TimelineActor {
-        let marker_types = vec!(TimelineMarkerType::Reflow,
-                                TimelineMarkerType::DOMEvent);
+    pub fn new(
+        name: String,
+        pipeline: PipelineId,
+        script_sender: IpcSender<DevtoolScriptControlMsg>,
+    ) -> TimelineActor {
+        let marker_types = vec![TimelineMarkerType::Reflow, TimelineMarkerType::DOMEvent];
 
         TimelineActor {
             name: name,
@@ -141,15 +144,20 @@ impl TimelineActor {
         }
     }
 
-    fn pull_timeline_data(&self, receiver: IpcReceiver<Option<TimelineMarker>>, mut emitter: Emitter) {
+    fn pull_timeline_data(
+        &self,
+        receiver: IpcReceiver<Option<TimelineMarker>>,
+        mut emitter: Emitter,
+    ) {
         let is_recording = self.is_recording.clone();
 
         if !*is_recording.lock().unwrap() {
             return;
         }
 
-        thread::Builder::new().name("PullTimelineMarkers".to_owned()).spawn(move || {
-            loop {
+        thread::Builder::new()
+            .name("PullTimelineMarkers".to_owned())
+            .spawn(move || loop {
                 if !*is_recording.lock().unwrap() {
                     break;
                 }
@@ -161,8 +169,7 @@ impl TimelineActor {
                 emitter.send(markers);
 
                 thread::sleep(Duration::from_millis(DEFAULT_TIMELINE_DATA_PULL_TIMEOUT));
-            }
-        }).expect("Thread spawning failed");
+            }).expect("Thread spawning failed");
     }
 }
 
@@ -171,19 +178,24 @@ impl Actor for TimelineActor {
         self.name.clone()
     }
 
-    fn handle_message(&self,
-                      registry: &ActorRegistry,
-                      msg_type: &str,
-                      msg: &Map<String, Value>,
-                      stream: &mut TcpStream) -> Result<ActorMessageStatus, ()> {
+    fn handle_message(
+        &self,
+        registry: &ActorRegistry,
+        msg_type: &str,
+        msg: &Map<String, Value>,
+        stream: &mut TcpStream,
+    ) -> Result<ActorMessageStatus, ()> {
         Ok(match msg_type {
             "start" => {
                 **self.is_recording.lock().as_mut().unwrap() = true;
 
                 let (tx, rx) = ipc::channel::<Option<TimelineMarker>>().unwrap();
-                self.script_sender.send(SetTimelineMarkers(self.pipeline,
-                                                           self.marker_types.clone(),
-                                                           tx)).unwrap();
+                self.script_sender
+                    .send(SetTimelineMarkers(
+                        self.pipeline,
+                        self.marker_types.clone(),
+                        tx,
+                    )).unwrap();
 
                 *self.stream.borrow_mut() = stream.try_clone().ok();
 
@@ -198,18 +210,22 @@ impl Actor for TimelineActor {
                 if let Some(with_ticks) = msg.get("withTicks") {
                     if let Some(true) = with_ticks.as_bool() {
                         let framerate_actor = Some(FramerateActor::create(
-                                registry,
-                                self.pipeline.clone(),
-                                self.script_sender.clone()));
+                            registry,
+                            self.pipeline.clone(),
+                            self.script_sender.clone(),
+                        ));
                         *self.framerate_actor.borrow_mut() = framerate_actor;
                     }
                 }
 
-                let emitter = Emitter::new(self.name(), registry.shareable(),
-                                           registry.start_stamp(),
-                                           stream.try_clone().unwrap(),
-                                           self.memory_actor.borrow().clone(),
-                                           self.framerate_actor.borrow().clone());
+                let emitter = Emitter::new(
+                    self.name(),
+                    registry.shareable(),
+                    registry.start_stamp(),
+                    stream.try_clone().unwrap(),
+                    self.memory_actor.borrow().clone(),
+                    self.framerate_actor.borrow().clone(),
+                );
 
                 self.pull_timeline_data(rx, emitter);
 
@@ -219,7 +235,7 @@ impl Actor for TimelineActor {
                 };
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
             "stop" => {
                 let msg = StopReply {
@@ -228,7 +244,11 @@ impl Actor for TimelineActor {
                 };
 
                 stream.write_json_packet(&msg);
-                self.script_sender.send(DropTimelineMarkers(self.pipeline, self.marker_types.clone())).unwrap();
+                self.script_sender
+                    .send(DropTimelineMarkers(
+                        self.pipeline,
+                        self.marker_types.clone(),
+                    )).unwrap();
 
                 if let Some(ref actor_name) = *self.framerate_actor.borrow() {
                     registry.drop_actor_later(actor_name.clone());
@@ -241,32 +261,32 @@ impl Actor for TimelineActor {
                 **self.is_recording.lock().as_mut().unwrap() = false;
                 self.stream.borrow_mut().take();
                 ActorMessageStatus::Processed
-            }
+            },
 
             "isRecording" => {
                 let msg = IsRecordingReply {
                     from: self.name(),
-                    value: self.is_recording.lock().unwrap().clone()
+                    value: self.is_recording.lock().unwrap().clone(),
                 };
 
                 stream.write_json_packet(&msg);
                 ActorMessageStatus::Processed
-            }
+            },
 
-            _ => {
-                ActorMessageStatus::Ignored
-            }
+            _ => ActorMessageStatus::Ignored,
         })
     }
 }
 
 impl Emitter {
-    pub fn new(name: String,
-               registry: Arc<Mutex<ActorRegistry>>,
-               start_stamp: PreciseTime,
-               stream: TcpStream,
-               memory_actor_name: Option<String>,
-               framerate_actor_name: Option<String>) -> Emitter {
+    pub fn new(
+        name: String,
+        registry: Arc<Mutex<ActorRegistry>>,
+        start_stamp: PreciseTime,
+        stream: TcpStream,
+        memory_actor_name: Option<String>,
+        framerate_actor_name: Option<String>,
+    ) -> Emitter {
         Emitter {
             from: name,
             stream: stream,
diff --git a/components/devtools/actors/worker.rs b/components/devtools/actors/worker.rs
index 1beead719dc..9ccc5b2e10b 100644
--- a/components/devtools/actors/worker.rs
+++ b/components/devtools/actors/worker.rs
@@ -17,11 +17,13 @@ impl Actor for WorkerActor {
     fn name(&self) -> String {
         self.name.clone()
     }
-    fn handle_message(&self,
-                      _: &ActorRegistry,
-                      _: &str,
-                      _: &Map<String, Value>,
-                      _: &mut TcpStream) -> Result<ActorMessageStatus, ()> {
+    fn handle_message(
+        &self,
+        _: &ActorRegistry,
+        _: &str,
+        _: &Map<String, Value>,
+        _: &mut TcpStream,
+    ) -> Result<ActorMessageStatus, ()> {
         Ok(ActorMessageStatus::Processed)
     }
 }
diff --git a/components/devtools/lib.rs b/components/devtools/lib.rs
index 31a98d7d5a6..2e11fa0eda2 100644
--- a/components/devtools/lib.rs
+++ b/components/devtools/lib.rs
@@ -9,7 +9,6 @@
 
 #![crate_name = "devtools"]
 #![crate_type = "rlib"]
-
 #![allow(non_snake_case)]
 #![deny(unsafe_code)]
 
@@ -19,7 +18,8 @@ extern crate ipc_channel;
 #[macro_use]
 extern crate log;
 extern crate msg;
-#[macro_use] extern crate serde;
+#[macro_use]
+extern crate serde;
 extern crate serde_json;
 extern crate time;
 
@@ -128,23 +128,24 @@ pub fn start_server(port: u16) -> Sender<DevtoolsControlMsg> {
     let (sender, receiver) = channel();
     {
         let sender = sender.clone();
-        thread::Builder::new().name("Devtools".to_owned()).spawn(move || {
-            run_server(sender, receiver, port)
-        }).expect("Thread spawning failed");
+        thread::Builder::new()
+            .name("Devtools".to_owned())
+            .spawn(move || run_server(sender, receiver, port))
+            .expect("Thread spawning failed");
     }
     sender
 }
 
-fn run_server(sender: Sender<DevtoolsControlMsg>,
-              receiver: Receiver<DevtoolsControlMsg>,
-              port: u16) {
+fn run_server(
+    sender: Sender<DevtoolsControlMsg>,
+    receiver: Receiver<DevtoolsControlMsg>,
+    port: u16,
+) {
     let listener = TcpListener::bind(&("127.0.0.1", port)).unwrap();
 
     let mut registry = ActorRegistry::new();
 
-    let root = Box::new(RootActor {
-        tabs: vec!(),
-    });
+    let root = Box::new(RootActor { tabs: vec![] });
 
     registry.register(root);
     registry.find::<RootActor>("root");
@@ -158,7 +159,6 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
 
     let mut actor_workers: HashMap<(PipelineId, WorkerId), String> = HashMap::new();
 
-
     /// Process the input from a single devtools client until EOF.
     fn handle_client(actors: Arc<Mutex<ActorRegistry>>, mut stream: TcpStream) {
         debug!("connection established to {}", stream.peer_addr().unwrap());
@@ -171,21 +171,24 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
         'outer: loop {
             match stream.read_json_packet() {
                 Ok(Some(json_packet)) => {
-                    if let Err(()) = actors.lock().unwrap().handle_message(json_packet.as_object().unwrap(),
-                                                                           &mut stream) {
+                    if let Err(()) = actors
+                        .lock()
+                        .unwrap()
+                        .handle_message(json_packet.as_object().unwrap(), &mut stream)
+                    {
                         debug!("error: devtools actor stopped responding");
                         let _ = stream.shutdown(Shutdown::Both);
-                        break 'outer
+                        break 'outer;
                     }
-                }
+                },
                 Ok(None) => {
                     debug!("error: EOF");
-                    break 'outer
-                }
+                    break 'outer;
+                },
                 Err(err_msg) => {
                     debug!("error: {}", err_msg);
-                    break 'outer
-                }
+                    break 'outer;
+                },
             }
         }
     }
@@ -199,12 +202,14 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
     // We need separate actor representations for each script global that exists;
     // clients can theoretically connect to multiple globals simultaneously.
     // TODO: move this into the root or tab modules?
-    fn handle_new_global(actors: Arc<Mutex<ActorRegistry>>,
-                         ids: (PipelineId, Option<WorkerId>),
-                         script_sender: IpcSender<DevtoolScriptControlMsg>,
-                         actor_pipelines: &mut HashMap<PipelineId, String>,
-                         actor_workers: &mut HashMap<(PipelineId, WorkerId), String>,
-                         page_info: DevtoolsPageInfo) {
+    fn handle_new_global(
+        actors: Arc<Mutex<ActorRegistry>>,
+        ids: (PipelineId, Option<WorkerId>),
+        script_sender: IpcSender<DevtoolScriptControlMsg>,
+        actor_pipelines: &mut HashMap<PipelineId, String>,
+        actor_workers: &mut HashMap<(PipelineId, WorkerId), String>,
+        page_info: DevtoolsPageInfo,
+    ) {
         let mut actors = actors.lock().unwrap();
 
         let (pipeline, worker_id) = ids;
@@ -226,9 +231,7 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
                 pipeline: pipeline,
             };
 
-            let timeline = TimelineActor::new(actors.new_name("timeline"),
-                                              pipeline,
-                                              script_sender);
+            let timeline = TimelineActor::new(actors.new_name("timeline"), pipeline, script_sender);
 
             let profiler = ProfilerActor::new(actors.new_name("profiler"));
             let performance = PerformanceActor::new(actors.new_name("performance"));
@@ -251,7 +254,15 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
             let root = actors.find_mut::<RootActor>("root");
             root.tabs.push(tab.name.clone());
 
-            (tab, console, inspector, timeline, profiler, performance, thread)
+            (
+                tab,
+                console,
+                inspector,
+                timeline,
+                profiler,
+                performance,
+                thread,
+            )
         };
 
         if let Some(id) = worker_id {
@@ -274,14 +285,21 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
         actors.register(Box::new(thread));
     }
 
-    fn handle_console_message(actors: Arc<Mutex<ActorRegistry>>,
-                              id: PipelineId,
-                              worker_id: Option<WorkerId>,
-                              console_message: ConsoleMessage,
-                              actor_pipelines: &HashMap<PipelineId, String>,
-                              actor_workers: &HashMap<(PipelineId, WorkerId), String>) {
-        let console_actor_name = match find_console_actor(actors.clone(), id, worker_id, actor_workers,
-                                                          actor_pipelines) {
+    fn handle_console_message(
+        actors: Arc<Mutex<ActorRegistry>>,
+        id: PipelineId,
+        worker_id: Option<WorkerId>,
+        console_message: ConsoleMessage,
+        actor_pipelines: &HashMap<PipelineId, String>,
+        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,
         };
@@ -296,10 +314,10 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
                     LogLevel::Info => "info",
                     LogLevel::Warn => "warn",
                     LogLevel::Error => "error",
-                    _ => "log"
+                    _ => "log",
                 }.to_owned(),
                 timeStamp: precise_time_ns(),
-                arguments: vec!(console_message.message),
+                arguments: vec![console_message.message],
                 filename: console_message.filename,
                 lineNumber: console_message.lineNumber,
                 columnNumber: console_message.columnNumber,
@@ -310,11 +328,13 @@ 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> {
+    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();
         if let Some(worker_id) = worker_id {
             let actor_name = (*actor_workers).get(&(id, worker_id))?;
@@ -325,20 +345,28 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
         }
     }
 
-    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, None,
-                                                          actor_workers, actor_pipelines) {
+    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,
+            None,
+            actor_workers,
+            actor_pipelines,
+        ) {
             Some(name) => name,
             None => return,
         };
-        let netevent_actor_name = find_network_event_actor(actors.clone(), actor_requests, request_id.clone());
+        let netevent_actor_name =
+            find_network_event_actor(actors.clone(), actor_requests, request_id.clone());
         let mut actors = actors.lock().unwrap();
         let actor = actors.find_mut::<NetworkEventActor>(&netevent_actor_name);
 
@@ -356,8 +384,7 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
                 for stream in &mut connections {
                     stream.write_json_packet(&msg);
                 }
-
-            }
+            },
             NetworkEvent::HttpResponse(httpresponse) => {
                 //Store the response information in the actor
                 actor.add_response(httpresponse);
@@ -385,7 +412,7 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
                     from: netevent_actor_name.clone(),
                     type_: "networkEventUpdate".to_owned(),
                     updateType: "responseStart".to_owned(),
-                    response: actor.response_start()
+                    response: actor.response_start(),
                 };
 
                 for stream in &mut connections {
@@ -441,78 +468,109 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
                 for stream in &mut connections {
                     stream.write_merged_json_packet(&msg, &actor.response_headers());
                 }
-            }
+            },
         }
     }
 
     // Find the name of NetworkEventActor corresponding to request_id
     // Create a new one if it does not exist, add it to the actor_requests hashmap
-    fn find_network_event_actor(actors: Arc<Mutex<ActorRegistry>>,
-                                actor_requests: &mut HashMap<String, String>,
-                                request_id: String) -> String {
+    fn find_network_event_actor(
+        actors: Arc<Mutex<ActorRegistry>>,
+        actor_requests: &mut HashMap<String, String>,
+        request_id: String,
+    ) -> String {
         let mut actors = actors.lock().unwrap();
         match (*actor_requests).entry(request_id) {
             Occupied(name) => {
                 //TODO: Delete from map like Firefox does?
                 name.into_mut().clone()
-            }
+            },
             Vacant(entry) => {
                 let actor_name = actors.new_name("netevent");
                 let actor = NetworkEventActor::new(actor_name.clone());
                 entry.insert(actor_name.clone());
                 actors.register(Box::new(actor));
                 actor_name
-            }
+            },
         }
     }
 
     let sender_clone = sender.clone();
-    thread::Builder::new().name("DevtoolsClientAcceptor".to_owned()).spawn(move || {
-        // accept connections and process them, spawning a new thread for each one
-        for stream in listener.incoming() {
-            // connection succeeded
-            sender_clone.send(DevtoolsControlMsg::FromChrome(
-                    ChromeToDevtoolsControlMsg::AddClient(stream.unwrap()))).unwrap();
-        }
-    }).expect("Thread spawning failed");
+    thread::Builder::new()
+        .name("DevtoolsClientAcceptor".to_owned())
+        .spawn(move || {
+            // accept connections and process them, spawning a new thread for each one
+            for stream in listener.incoming() {
+                // connection succeeded
+                sender_clone
+                    .send(DevtoolsControlMsg::FromChrome(
+                        ChromeToDevtoolsControlMsg::AddClient(stream.unwrap()),
+                    )).unwrap();
+            }
+        }).expect("Thread spawning failed");
 
     while let Ok(msg) = receiver.recv() {
         match msg {
             DevtoolsControlMsg::FromChrome(ChromeToDevtoolsControlMsg::AddClient(stream)) => {
                 let actors = actors.clone();
                 accepted_connections.push(stream.try_clone().unwrap());
-                thread::Builder::new().name("DevtoolsClientHandler".to_owned()).spawn(move || {
-                    handle_client(actors, stream.try_clone().unwrap())
-                }).expect("Thread spawning failed");
-            }
+                thread::Builder::new()
+                    .name("DevtoolsClientHandler".to_owned())
+                    .spawn(move || handle_client(actors, stream.try_clone().unwrap()))
+                    .expect("Thread spawning failed");
+            },
             DevtoolsControlMsg::FromScript(ScriptToDevtoolsControlMsg::FramerateTick(
-                        actor_name, tick)) =>
-                handle_framerate_tick(actors.clone(), actor_name, tick),
+                actor_name,
+                tick,
+            )) => handle_framerate_tick(actors.clone(), actor_name, tick),
             DevtoolsControlMsg::FromScript(ScriptToDevtoolsControlMsg::NewGlobal(
-                        ids, script_sender, pageinfo)) =>
-                handle_new_global(actors.clone(), ids, script_sender, &mut actor_pipelines,
-                                  &mut actor_workers, pageinfo),
+                ids,
+                script_sender,
+                pageinfo,
+            )) => handle_new_global(
+                actors.clone(),
+                ids,
+                script_sender,
+                &mut actor_pipelines,
+                &mut actor_workers,
+                pageinfo,
+            ),
             DevtoolsControlMsg::FromScript(ScriptToDevtoolsControlMsg::ConsoleAPI(
-                        id,
-                        console_message,
-                        worker_id)) =>
-                handle_console_message(actors.clone(), id, worker_id, console_message,
-                                       &actor_pipelines, &actor_workers),
+                id,
+                console_message,
+                worker_id,
+            )) => handle_console_message(
+                actors.clone(),
+                id,
+                worker_id,
+                console_message,
+                &actor_pipelines,
+                &actor_workers,
+            ),
             DevtoolsControlMsg::FromScript(ScriptToDevtoolsControlMsg::ReportCSSError(
-                        id,
-                        css_error)) => {
-                let console_message =  ConsoleMessage {
+                id,
+                css_error,
+            )) => {
+                let console_message = ConsoleMessage {
                     message: css_error.msg,
                     logLevel: LogLevel::Warn,
                     filename: css_error.filename,
                     lineNumber: css_error.line as usize,
                     columnNumber: css_error.column as usize,
                 };
-                handle_console_message(actors.clone(), id, None, console_message,
-                                       &actor_pipelines, &actor_workers)
+                handle_console_message(
+                    actors.clone(),
+                    id,
+                    None,
+                    console_message,
+                    &actor_pipelines,
+                    &actor_workers,
+                )
             },
             DevtoolsControlMsg::FromChrome(ChromeToDevtoolsControlMsg::NetworkEvent(
-                        request_id, network_event)) => {
+                request_id,
+                network_event,
+            )) => {
                 // copy the accepted_connections vector
                 let mut connections = Vec::<TcpStream>::new();
                 for stream in &accepted_connections {
@@ -523,10 +581,18 @@ fn run_server(sender: Sender<DevtoolsControlMsg>,
                     NetworkEvent::HttpResponse(ref response) => response.pipeline_id,
                     NetworkEvent::HttpRequest(ref request) => request.pipeline_id,
                 };
-                handle_network_event(actors.clone(), connections, &actor_pipelines, &mut actor_requests,
-                                     &actor_workers, pipeline_id, request_id, network_event);
+                handle_network_event(
+                    actors.clone(),
+                    connections,
+                    &actor_pipelines,
+                    &mut actor_requests,
+                    &actor_workers,
+                    pipeline_id,
+                    request_id,
+                    network_event,
+                );
             },
-            DevtoolsControlMsg::FromChrome(ChromeToDevtoolsControlMsg::ServerExitMsg) => break
+            DevtoolsControlMsg::FromChrome(ChromeToDevtoolsControlMsg::ServerExitMsg) => break,
         }
     }
     for connection in &mut accepted_connections {
diff --git a/components/devtools/protocol.rs b/components/devtools/protocol.rs
index f0bfce4b3d7..999514affde 100644
--- a/components/devtools/protocol.rs
+++ b/components/devtools/protocol.rs
@@ -55,11 +55,11 @@ impl JsonPacketStream for TcpStream {
     fn read_json_packet(&mut self) -> Result<Option<Value>, String> {
         // 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!();
+        let mut buffer = vec![];
         loop {
             let mut buf = [0];
             let byte = match self.read(&mut buf) {
-                Ok(0) => return Ok(None),  // EOF
+                Ok(0) => return Ok(None), // EOF
                 Ok(1) => buf[0],
                 Ok(_) => unreachable!(),
                 Err(e) => return Err(e.description().to_owned()),