Auto merge of #14831 - servo:rustfmt-traits, r=nox

Rustfmt script_traits and net_traits.

CC #8553.

<!-- Reviewable:start -->
---
This change is [<img src="https://reviewable.io/review_button.svg" height="34" align="absmiddle" alt="Reviewable"/>](https://reviewable.io/reviews/servo/servo/14831)
<!-- Reviewable:end -->

components/net_traits/filemanager_thread.rs

@@ -54,7 +54,7 @@ impl RelativePos {
                 (Some(old_end), Some(rel_end)) => Some(old_end + rel_end),
                 (old, None) => old,
                 (None, rel) => rel,
-            }
+            },
         }
     }
 
@@ -78,7 +78,7 @@ impl RelativePos {
                 } else {
                     min(rel_end, size)
                 }
-            }
+            },
             None => size,
         };
 
@@ -148,7 +148,7 @@ pub enum FileManagerThreadMsg {
 pub enum ReadFileProgress {
     Meta(BlobBuf),
     Partial(Vec<u8>),
-    EOF
+    EOF,
 }
 
 pub type FileManagerResult<T> = Result<T, FileManagerThreadError>;

components/net_traits/hosts.rs

@@ -15,7 +15,7 @@ lazy_static! {
 }
 
 fn create_host_table() -> Option<HashMap<String, IpAddr>> {
-    //TODO: handle bad file path
+    // TODO: handle bad file path
     let path = match env::var("HOST_FILE") {
         Ok(host_file_path) => host_file_path,
         Err(_) => return None,
@@ -58,16 +58,18 @@ pub fn parse_hostsfile(hostsfile_content: &str) -> HashMap<String, IpAddr> {
 }
 
 pub fn replace_hosts(url: &ServoUrl) -> ServoUrl {
-    HOST_TABLE.lock().unwrap().as_ref().map_or_else(|| url.clone(), |host_table| {
+    HOST_TABLE.lock().unwrap().as_ref().map_or_else(|| url.clone(),
-        host_replacement(host_table, url)
+                                                    |host_table| host_replacement(host_table, url))
-    })
 }
 
-pub fn host_replacement(host_table: &HashMap<String, IpAddr>,
+pub fn host_replacement(host_table: &HashMap<String, IpAddr>, url: &ServoUrl) -> ServoUrl {
-                        url: &ServoUrl) -> ServoUrl {
+    url.domain()
-    url.domain().and_then(|domain| host_table.get(domain).map(|ip| {
+        .and_then(|domain| {
-        let mut new_url = url.clone();
+            host_table.get(domain).map(|ip| {
-        new_url.set_ip_host(*ip).unwrap();
+                let mut new_url = url.clone();
-        new_url
+                new_url.set_ip_host(*ip).unwrap();
-    })).unwrap_or_else(|| url.clone())
+                new_url
+            })
+        })
+        .unwrap_or_else(|| url.clone())
 }

components/net_traits/image/base.rs

@@ -8,10 +8,14 @@ use webrender_traits;
 
 #[derive(Clone, Copy, Deserialize, Eq, PartialEq, Serialize, HeapSizeOf)]
 pub enum PixelFormat {
-    K8,         // Luminance channel only
+    /// Luminance channel only
-    KA8,        // Luminance + alpha
+    K8,
-    RGB8,       // RGB, 8 bits per channel
+    /// Luminance + alpha
-    RGBA8,      // RGB + alpha, 8 bits per channel
+    KA8,
+    /// RGB, 8 bits per channel
+    RGB8,
+    /// RGB + alpha, 8 bits per channel
+    RGBA8,
 }
 
 #[derive(Clone, Deserialize, Serialize, HeapSizeOf)]
@@ -59,13 +63,13 @@ pub fn load_from_memory(buffer: &[u8]) -> Option<Image> {
         Err(msg) => {
             debug!("{}", msg);
             None
-        }
+        },
         Ok(_) => {
             match piston_image::load_from_memory(buffer) {
                 Ok(image) => {
                     let mut rgba = match image {
                         DynamicImage::ImageRgba8(rgba) => rgba,
-                        image => image.to_rgba()
+                        image => image.to_rgba(),
                     };
                     byte_swap_and_premultiply(&mut *rgba);
                     Some(Image {
@@ -75,31 +79,38 @@ pub fn load_from_memory(buffer: &[u8]) -> Option<Image> {
                         bytes: IpcSharedMemory::from_bytes(&*rgba),
                         id: None,
                     })
-                }
+                },
                 Err(e) => {
                     debug!("Image decoding error: {:?}", e);
                     None
-                }
+                },
             }
-        }
+        },
     }
 }
 
 
 // https://developer.mozilla.org/en-US/docs/Web/HTML/Element/img
 pub fn detect_image_format(buffer: &[u8]) -> Result<ImageFormat, &str> {
-    if is_gif(buffer)         { Ok(ImageFormat::GIF)
+    if is_gif(buffer) {
-    } else if is_jpeg(buffer) { Ok(ImageFormat::JPEG)
+        Ok(ImageFormat::GIF)
-    } else if is_png(buffer)  { Ok(ImageFormat::PNG)
+    } else if is_jpeg(buffer) {
-    } else if is_bmp(buffer)  { Ok(ImageFormat::BMP)
+        Ok(ImageFormat::JPEG)
-    } else if is_ico(buffer)  { Ok(ImageFormat::ICO)
+    } else if is_png(buffer) {
-    } else { Err("Image Format Not Supported") }
+        Ok(ImageFormat::PNG)
+    } else if is_bmp(buffer) {
+        Ok(ImageFormat::BMP)
+    } else if is_ico(buffer) {
+        Ok(ImageFormat::ICO)
+    } else {
+        Err("Image Format Not Supported")
+    }
 }
 
 fn is_gif(buffer: &[u8]) -> bool {
     match buffer {
-        &[b'G', b'I', b'F', b'8', n, b'a', ..] if n == b'7' || n == b'9' => true,
+        &[b'G', b'I', b'F', b'8', n, b'a', _..] if n == b'7' || n == b'9' => true,
-        _ => false
+        _ => false,
     }
 }
 

components/net_traits/image_cache_thread.rs

@@ -46,7 +46,7 @@ pub enum ImageResponse {
     /// The requested image failed to load, so a placeholder was loaded instead.
     PlaceholderLoaded(Arc<Image>),
     /// Neither the requested image nor the placeholder could be loaded.
-    None
+    None,
 }
 
 /// Indicating either entire image or just metadata availability
@@ -123,10 +123,7 @@ impl ImageCacheThread {
     }
 
     /// Asynchronously request an image. See ImageCacheCommand::RequestImage.
-    pub fn request_image(&self,
+    pub fn request_image(&self, url: ServoUrl, result_chan: ImageCacheChan, responder: Option<ImageResponder>) {
-                         url: ServoUrl,
-                         result_chan: ImageCacheChan,
-                         responder: Option<ImageResponder>) {
         let msg = ImageCacheCommand::RequestImage(url, result_chan, responder);
         let _ = self.chan.send(msg);
     }
@@ -142,8 +139,7 @@ impl ImageCacheThread {
     }
 
     /// Get the current state of an image. See ImageCacheCommand::GetImageIfAvailable.
-    pub fn find_image(&self, url: ServoUrl, use_placeholder: UsePlaceholder)
+    pub fn find_image(&self, url: ServoUrl, use_placeholder: UsePlaceholder) -> Result<Arc<Image>, ImageState> {
-                                  -> Result<Arc<Image>, ImageState> {
         let (sender, receiver) = ipc::channel().unwrap();
         let msg = ImageCacheCommand::GetImageIfAvailable(url, use_placeholder, sender);
         let _ = self.chan.send(msg);
@@ -154,7 +150,9 @@ impl ImageCacheThread {
     /// See ImageCacheCommand::GetImageOrMetadataIfAvailable.
     ///
     /// FIXME: We shouldn't do IPC for data uris!
-    pub fn find_image_or_metadata(&self, url: ServoUrl, use_placeholder: UsePlaceholder)
+    pub fn find_image_or_metadata(&self,
+                                  url: ServoUrl,
+                                  use_placeholder: UsePlaceholder)
                                   -> Result<ImageOrMetadataAvailable, ImageState> {
         let (sender, receiver) = ipc::channel().unwrap();
         let msg = ImageCacheCommand::GetImageOrMetadataIfAvailable(url, use_placeholder, sender);
@@ -163,9 +161,7 @@ impl ImageCacheThread {
     }
 
     /// Decode the given image bytes and cache the result for the given URL.
-    pub fn store_complete_image_bytes(&self,
+    pub fn store_complete_image_bytes(&self, url: ServoUrl, image_data: Vec<u8>) {
-                                      url: ServoUrl,
-                                      image_data: Vec<u8>) {
         let msg = ImageCacheCommand::StoreDecodeImage(url, image_data);
         let _ = self.chan.send(msg);
     }

components/net_traits/lib.rs

@@ -11,7 +11,8 @@
 
 extern crate cookie as cookie_rs;
 extern crate heapsize;
-#[macro_use] extern crate heapsize_derive;
+#[macro_use]
+extern crate heapsize_derive;
 extern crate hyper;
 extern crate hyper_serde;
 extern crate image as piston_image;
@@ -93,12 +94,16 @@ pub struct CustomResponse {
     #[serde(deserialize_with = "::hyper_serde::deserialize",
             serialize_with = "::hyper_serde::serialize")]
     pub raw_status: RawStatus,
-    pub body: Vec<u8>
+    pub body: Vec<u8>,
 }
 
 impl CustomResponse {
     pub fn new(headers: Headers, raw_status: RawStatus, body: Vec<u8>) -> CustomResponse {
-        CustomResponse { headers: headers, raw_status: raw_status, body: body }
+        CustomResponse {
+            headers: headers,
+            raw_status: raw_status,
+            body: body,
+        }
     }
 }
 
@@ -169,7 +174,7 @@ pub trait FetchTaskTarget {
 #[derive(Serialize, Deserialize)]
 pub enum FilteredMetadata {
     Opaque,
-    Transparent(Metadata)
+    Transparent(Metadata),
 }
 
 #[derive(Serialize, Deserialize)]
@@ -177,8 +182,8 @@ pub enum FetchMetadata {
     Unfiltered(Metadata),
     Filtered {
         filtered: FilteredMetadata,
-        unsafe_: Metadata
+        unsafe_: Metadata,
-    }
+    },
 }
 
 pub trait FetchResponseListener {
@@ -209,8 +214,8 @@ impl FetchTaskTarget for IpcSender<FetchResponseMsg> {
     fn process_response_eof(&mut self, response: &Response) {
         if response.is_network_error() {
             // todo: finer grained errors
-            let _ = self.send(FetchResponseMsg::ProcessResponseEOF(
+            let _ =
-                              Err(NetworkError::Internal("Network error".into()))));
+                self.send(FetchResponseMsg::ProcessResponseEOF(Err(NetworkError::Internal("Network error".into()))));
         } else {
             let _ = self.send(FetchResponseMsg::ProcessResponseEOF(Ok(())));
         }
@@ -243,7 +248,9 @@ pub type IpcSendResult = Result<(), IOError>;
 /// Abstraction of the ability to send a particular type of message,
 /// used by net_traits::ResourceThreads to ease the use its IpcSender sub-fields
 /// XXX: If this trait will be used more in future, some auto derive might be appealing
-pub trait IpcSend<T> where T: serde::Serialize + serde::Deserialize {
+pub trait IpcSend<T>
+    where T: serde::Serialize + serde::Deserialize,
+{
     /// send message T
     fn send(&self, T) -> IpcSendResult;
     /// get underlying sender
@@ -262,8 +269,7 @@ pub struct ResourceThreads {
 }
 
 impl ResourceThreads {
-    pub fn new(c: CoreResourceThread,
+    pub fn new(c: CoreResourceThread, s: IpcSender<StorageThreadMsg>) -> ResourceThreads {
-               s: IpcSender<StorageThreadMsg>) -> ResourceThreads {
         ResourceThreads {
             core_thread: c,
             storage_thread: s,
@@ -293,13 +299,15 @@ impl IpcSend<StorageThreadMsg> for ResourceThreads {
 
 // Ignore the sub-fields
 impl HeapSizeOf for ResourceThreads {
-    fn heap_size_of_children(&self) -> usize { 0 }
+    fn heap_size_of_children(&self) -> usize {
+        0
+    }
 }
 
 #[derive(PartialEq, Copy, Clone, Deserialize, Serialize)]
 pub enum IncludeSubdomains {
     Included,
-    NotIncluded
+    NotIncluded,
 }
 
 #[derive(HeapSizeOf, Deserialize, Serialize)]
@@ -316,12 +324,10 @@ pub enum WebSocketDomAction {
 
 #[derive(Deserialize, Serialize)]
 pub enum WebSocketNetworkEvent {
-    ConnectionEstablished(
+    ConnectionEstablished(#[serde(deserialize_with = "::hyper_serde::deserialize",
-        #[serde(deserialize_with = "::hyper_serde::deserialize",
+                                  serialize_with = "::hyper_serde::serialize")]
-                serialize_with = "::hyper_serde::serialize")]
+                          header::Headers,
-        header::Headers,
+                          Vec<String>),
-        Vec<String>
-    ),
     MessageReceived(MessageData),
     Close(Option<u16>, String),
     Fail,
@@ -346,13 +352,11 @@ pub enum CoreResourceMsg {
     /// Try to make a websocket connection to a URL.
     WebsocketConnect(WebSocketCommunicate, WebSocketConnectData),
     /// Store a cookie for a given originating URL
-    SetCookieForUrl(
+    SetCookieForUrl(ServoUrl,
-        ServoUrl,
+                    #[serde(deserialize_with = "::hyper_serde::deserialize",
-        #[serde(deserialize_with = "::hyper_serde::deserialize",
+                            serialize_with = "::hyper_serde::serialize")]
-                serialize_with = "::hyper_serde::serialize")]
+                    Cookie,
-        Cookie,
+                    CookieSource),
-        CookieSource
-    ),
     /// Store cookies for a given originating URL
     SetCookiesForUrl(ServoUrl, Vec<Serde<Cookie>>, CookieSource),
     /// Retrieve the stored cookies for a given URL
@@ -373,15 +377,12 @@ pub enum CoreResourceMsg {
 }
 
 /// Instruct the resource thread to make a new request.
-pub fn fetch_async<F>(request: RequestInit,
+pub fn fetch_async<F>(request: RequestInit, core_resource_thread: &CoreResourceThread, f: F)
-                      core_resource_thread: &CoreResourceThread,
+    where F: Fn(FetchResponseMsg) + Send + 'static,
-                      f: F)
-    where F: Fn(FetchResponseMsg) + Send + 'static
 {
     let (action_sender, action_receiver) = ipc::channel().unwrap();
-    ROUTER.add_route(action_receiver.to_opaque(), box move |message| {
+    ROUTER.add_route(action_receiver.to_opaque(),
-        f(message.to().unwrap());
+                     box move |message| f(message.to().unwrap()));
-    });
     core_resource_thread.send(CoreResourceMsg::Fetch(request, action_sender)).unwrap();
 }
 
@@ -424,9 +425,9 @@ impl Metadata {
     /// Metadata with defaults for everything optional.
     pub fn default(url: ServoUrl) -> Self {
         Metadata {
-            final_url:    url,
+            final_url: url,
             content_type: None,
-            charset:      None,
+            charset: None,
             headers: None,
             // https://fetch.spec.whatwg.org/#concept-response-status-message
             status: Some((200, b"OK".to_vec())),
@@ -470,7 +471,7 @@ pub fn load_whole_resource(request: RequestInit,
     let (action_sender, action_receiver) = ipc::channel().unwrap();
     core_resource_thread.send(CoreResourceMsg::Fetch(request, action_sender)).unwrap();
 
-    let mut buf = vec!();
+    let mut buf = vec![];
     let mut metadata = None;
     loop {
         match action_receiver.recv().unwrap() {
@@ -479,13 +480,13 @@ pub fn load_whole_resource(request: RequestInit,
             FetchResponseMsg::ProcessResponse(Ok(m)) => {
                 metadata = Some(match m {
                     FetchMetadata::Unfiltered(m) => m,
-                    FetchMetadata::Filtered { unsafe_, .. } => unsafe_
+                    FetchMetadata::Filtered { unsafe_, .. } => unsafe_,
                 })
             },
             FetchResponseMsg::ProcessResponseChunk(data) => buf.extend_from_slice(&data),
             FetchResponseMsg::ProcessResponseEOF(Ok(())) => return Ok((metadata.unwrap(), buf)),
             FetchResponseMsg::ProcessResponse(Err(e)) |
-            FetchResponseMsg::ProcessResponseEOF(Err(e)) => return Err(e)
+            FetchResponseMsg::ProcessResponseEOF(Err(e)) => return Err(e),
         }
     }
 }
@@ -516,16 +517,14 @@ pub fn trim_http_whitespace(mut slice: &[u8]) -> &[u8] {
 
     loop {
         match slice.split_first() {
-            Some((first, remainder)) if HTTP_WS_BYTES.contains(first) =>
+            Some((first, remainder)) if HTTP_WS_BYTES.contains(first) => slice = remainder,
-                slice = remainder,
             _ => break,
         }
     }
 
     loop {
         match slice.split_last() {
-            Some((last, remainder)) if HTTP_WS_BYTES.contains(last) =>
+            Some((last, remainder)) if HTTP_WS_BYTES.contains(last) => slice = remainder,
-                slice = remainder,
             _ => break,
         }
     }

components/net_traits/pub_domains.rs

@@ -32,7 +32,9 @@ lazy_static! {
 }
 
 impl<'a> FromIterator<&'a str> for PubDomainRules {
-    fn from_iter<T>(iter: T) -> Self where T: IntoIterator<Item=&'a str> {
+    fn from_iter<T>(iter: T) -> Self
+        where T: IntoIterator<Item = &'a str>,
+    {
         let mut result = PubDomainRules::new();
         for item in iter {
             if item.starts_with("!") {
@@ -96,9 +98,10 @@ impl PubDomainRules {
         let domain = domain.trim_left_matches(".");
         match domain.find(".") {
             None => !domain.is_empty(),
-            Some(index) => !self.exceptions.contains(domain) &&
+            Some(index) => {
-                self.wildcards.contains(&domain[index + 1..]) ||
+                !self.exceptions.contains(domain) && self.wildcards.contains(&domain[index + 1..]) ||
-                self.rules.contains(domain),
+                self.rules.contains(domain)
+            },
         }
     }
     pub fn is_registrable_suffix(&self, domain: &str) -> bool {
@@ -108,19 +111,18 @@ impl PubDomainRules {
         let domain = domain.trim_left_matches(".");
         match domain.find(".") {
             None => false,
-            Some(index) => self.exceptions.contains(domain) ||
+            Some(index) => {
-                !self.wildcards.contains(&domain[index + 1..]) &&
+                self.exceptions.contains(domain) ||
-                !self.rules.contains(domain) &&
+                !self.wildcards.contains(&domain[index + 1..]) && !self.rules.contains(domain) &&
-                self.is_public_suffix(&domain[index + 1..]),
+                self.is_public_suffix(&domain[index + 1..])
+            },
         }
     }
 }
 
 fn load_pub_domains() -> PubDomainRules {
-    let content = read_resource_file("public_domains.txt")
+    let content = read_resource_file("public_domains.txt").expect("Could not find public suffix list file");
-        .expect("Could not find public suffix list file");
+    let content = from_utf8(&content).expect("Could not read public suffix list file");
-    let content = from_utf8(&content)
-        .expect("Could not read public suffix list file");
     PubDomainRules::parse(content)
 }
 

components/net_traits/request.rs

@@ -9,7 +9,7 @@ use msg::constellation_msg::PipelineId;
 use servo_url::ServoUrl;
 use std::cell::{Cell, RefCell};
 use std::default::Default;
-use url::{Origin as UrlOrigin};
+use url::Origin as UrlOrigin;
 
 /// An [initiator](https://fetch.spec.whatwg.org/#concept-request-initiator)
 #[derive(Copy, Clone, PartialEq, HeapSizeOf)]
@@ -18,29 +18,47 @@ pub enum Initiator {
     Download,
     ImageSet,
     Manifest,
-    XSLT
+    XSLT,
 }
 
 /// A request [type](https://fetch.spec.whatwg.org/#concept-request-type)
 #[derive(Copy, Clone, PartialEq, Serialize, Deserialize, HeapSizeOf)]
 pub enum Type {
-    None, Audio, Font, Image,
+    None,
-    Script, Style, Track, Video
+    Audio,
+    Font,
+    Image,
+    Script,
+    Style,
+    Track,
+    Video,
 }
 
 /// A request [destination](https://fetch.spec.whatwg.org/#concept-request-destination)
 #[derive(Copy, Clone, PartialEq, Serialize, Deserialize, HeapSizeOf)]
 pub enum Destination {
-    None, Document, Embed, Font, Image, Manifest,
+    None,
-    Media, Object, Report, Script, ServiceWorker,
+    Document,
-    SharedWorker, Style, Worker, XSLT
+    Embed,
+    Font,
+    Image,
+    Manifest,
+    Media,
+    Object,
+    Report,
+    Script,
+    ServiceWorker,
+    SharedWorker,
+    Style,
+    Worker,
+    XSLT,
 }
 
 /// A request [origin](https://fetch.spec.whatwg.org/#concept-request-origin)
 #[derive(Clone, PartialEq, Debug, HeapSizeOf)]
 pub enum Origin {
     Client,
-    Origin(UrlOrigin)
+    Origin(UrlOrigin),
 }
 
 /// A [referer](https://fetch.spec.whatwg.org/#concept-request-referrer)
@@ -49,7 +67,7 @@ pub enum Referrer {
     NoReferrer,
     /// Default referrer if nothing is specified
     Client,
-    ReferrerUrl(ServoUrl)
+    ReferrerUrl(ServoUrl),
 }
 
 /// A [request mode](https://fetch.spec.whatwg.org/#concept-request-mode)
@@ -58,7 +76,7 @@ pub enum RequestMode {
     Navigate,
     SameOrigin,
     NoCors,
-    CorsMode
+    CorsMode,
 }
 
 /// Request [credentials mode](https://fetch.spec.whatwg.org/#concept-request-credentials-mode)
@@ -66,7 +84,7 @@ pub enum RequestMode {
 pub enum CredentialsMode {
     Omit,
     CredentialsSameOrigin,
-    Include
+    Include,
 }
 
 /// [Cache mode](https://fetch.spec.whatwg.org/#concept-request-cache-mode)
@@ -77,7 +95,7 @@ pub enum CacheMode {
     Reload,
     NoCache,
     ForceCache,
-    OnlyIfCached
+    OnlyIfCached,
 }
 
 /// [Redirect mode](https://fetch.spec.whatwg.org/#concept-request-redirect-mode)
@@ -85,7 +103,7 @@ pub enum CacheMode {
 pub enum RedirectMode {
     Follow,
     Error,
-    Manual
+    Manual,
 }
 
 /// [Response tainting](https://fetch.spec.whatwg.org/#concept-request-response-tainting)
@@ -93,22 +111,21 @@ pub enum RedirectMode {
 pub enum ResponseTainting {
     Basic,
     CorsTainting,
-    Opaque
+    Opaque,
 }
 
 /// [Window](https://fetch.spec.whatwg.org/#concept-request-window)
 #[derive(Copy, Clone, PartialEq, HeapSizeOf)]
 pub enum Window {
     NoWindow,
-    Client,
+    Client, // TODO: Environmental settings object
-    // TODO: Environmental settings object
 }
 
 /// [CORS settings attribute](https://html.spec.whatwg.org/multipage/#attr-crossorigin-anonymous)
 #[derive(Copy, Clone, PartialEq, Serialize, Deserialize)]
 pub enum CorsSettings {
     Anonymous,
-    UseCredentials
+    UseCredentials,
 }
 
 #[derive(Serialize, Deserialize, Clone, HeapSizeOf)]
@@ -214,7 +231,8 @@ impl Request {
     pub fn new(url: ServoUrl,
                origin: Option<Origin>,
                is_service_worker_global_scope: bool,
-               pipeline_id: Option<PipelineId>) -> Request {
+               pipeline_id: Option<PipelineId>)
+               -> Request {
         Request {
             method: RefCell::new(Method::Get),
             local_urls_only: false,
@@ -251,7 +269,8 @@ impl Request {
     pub fn from_init(init: RequestInit) -> Request {
         let mut req = Request::new(init.url,
                                    Some(Origin::Origin(init.origin.origin())),
-                                   false, init.pipeline_id);
+                                   false,
+                                   init.pipeline_id);
         *req.method.borrow_mut() = init.method;
         *req.headers.borrow_mut() = init.headers;
         req.unsafe_request = init.unsafe_request;
@@ -289,11 +308,9 @@ impl Request {
 
     pub fn is_subresource_request(&self) -> bool {
         match self.destination {
-            Destination::Font | Destination::Image | Destination::Manifest
+            Destination::Font | Destination::Image | Destination::Manifest | Destination::Media |
-                | Destination::Media | Destination::Script
+            Destination::Script | Destination::Style | Destination::XSLT | Destination::None => true,
-                | Destination::Style | Destination::XSLT
+            _ => false,
-                | Destination::None => true,
-            _ => false
         }
     }
 }
@@ -302,7 +319,7 @@ impl Referrer {
     pub fn to_url(&self) -> Option<&ServoUrl> {
         match *self {
             Referrer::NoReferrer | Referrer::Client => None,
-            Referrer::ReferrerUrl(ref url) => Some(url)
+            Referrer::ReferrerUrl(ref url) => Some(url),
         }
     }
 }

components/net_traits/response.rs

@@ -21,7 +21,7 @@ pub enum ResponseType {
     Default,
     Error(NetworkError),
     Opaque,
-    OpaqueRedirect
+    OpaqueRedirect,
 }
 
 /// [Response termination reason](https://fetch.spec.whatwg.org/#concept-response-termination-reason)
@@ -29,7 +29,7 @@ pub enum ResponseType {
 pub enum TerminationReason {
     EndUserAbort,
     Fatal,
-    Timeout
+    Timeout,
 }
 
 /// The response body can still be pushed to after fetch
@@ -45,7 +45,8 @@ impl ResponseBody {
     pub fn is_done(&self) -> bool {
         match *self {
             ResponseBody::Done(..) => true,
-            ResponseBody::Empty | ResponseBody::Receiving(..) => false
+            ResponseBody::Empty |
+            ResponseBody::Receiving(..) => false,
         }
     }
 }
@@ -57,7 +58,7 @@ pub enum CacheState {
     None,
     Local,
     Validated,
-    Partial
+    Partial,
 }
 
 /// [Https state](https://fetch.spec.whatwg.org/#concept-response-https-state)
@@ -65,13 +66,13 @@ pub enum CacheState {
 pub enum HttpsState {
     None,
     Deprecated,
-    Modern
+    Modern,
 }
 
 pub enum ResponseMsg {
     Chunk(Vec<u8>),
     Finished,
-    Errored
+    Errored,
 }
 
 /// A [Response](https://fetch.spec.whatwg.org/#concept-response) as defined by the Fetch spec
@@ -114,7 +115,7 @@ impl Response {
             https_state: HttpsState::None,
             referrer: None,
             internal_response: None,
-            return_internal: Cell::new(true)
+            return_internal: Cell::new(true),
         }
     }
 
@@ -132,7 +133,7 @@ impl Response {
             https_state: HttpsState::None,
             referrer: None,
             internal_response: None,
-            return_internal: Cell::new(true)
+            return_internal: Cell::new(true),
         }
     }
 
@@ -143,7 +144,7 @@ impl Response {
     pub fn is_network_error(&self) -> bool {
         match self.response_type {
             ResponseType::Error(..) => true,
-            _ => false
+            _ => false,
         }
     }
 
@@ -172,9 +173,11 @@ impl Response {
 
     /// Convert to a filtered response, of type `filter_type`.
     /// Do not use with type Error or Default
+    #[cfg_attr(rustfmt, rustfmt_skip)]
     pub fn to_filtered(self, filter_type: ResponseType) -> Response {
         match filter_type {
-            ResponseType::Default | ResponseType::Error(..) => panic!(),
+            ResponseType::Default |
+            ResponseType::Error(..) => panic!(),
             _ => (),
         }
 
@@ -190,7 +193,8 @@ impl Response {
         response.response_type = filter_type;
 
         match response.response_type {
-            ResponseType::Default | ResponseType::Error(..) => unreachable!(),
+            ResponseType::Default |
+            ResponseType::Error(..) => unreachable!(),
 
             ResponseType::Basic => {
                 let headers = old_headers.iter().filter(|header| {
@@ -235,7 +239,7 @@ impl Response {
                 response.status = None;
                 response.body = Arc::new(Mutex::new(ResponseBody::Empty));
                 response.cache_state = CacheState::None;
-            }
+            },
         }
 
         response
@@ -246,7 +250,7 @@ impl Response {
             let mut metadata = Metadata::default(url.clone());
             metadata.set_content_type(match response.headers.get() {
                 Some(&ContentType(ref mime)) => Some(mime),
-                None => None
+                None => None,
             });
             metadata.headers = Some(Serde(response.headers.clone()));
             metadata.status = response.raw_status.clone();
@@ -269,12 +273,12 @@ impl Response {
                     Ok(FetchMetadata::Filtered {
                         filtered: match metadata {
                             Some(m) => FilteredMetadata::Transparent(m),
-                            None => FilteredMetadata::Opaque
+                            None => FilteredMetadata::Opaque,
                         },
-                        unsafe_: unsafe_metadata
+                        unsafe_: unsafe_metadata,
                     })
-                }
+                },
-                None => Err(NetworkError::Internal("No url found in unsafe response".to_owned()))
+                None => Err(NetworkError::Internal("No url found in unsafe response".to_owned())),
             }
         } else {
             Ok(FetchMetadata::Unfiltered(metadata.unwrap()))

components/net_traits/storage_thread.rs

@@ -8,7 +8,7 @@ use servo_url::ServoUrl;
 #[derive(Copy, Clone, Deserialize, Serialize, HeapSizeOf)]
 pub enum StorageType {
     Session,
-    Local
+    Local,
 }
 
 /// Request operations on the storage data associated with a particular url
@@ -36,5 +36,5 @@ pub enum StorageThreadMsg {
     Clear(IpcSender<bool>, ServoUrl, StorageType),
 
     /// send a reply when done cleaning up thread resources and then shut it down
-    Exit(IpcSender<()>)
+    Exit(IpcSender<()>),
 }

components/script_traits/lib.rs

@@ -18,7 +18,8 @@ extern crate devtools_traits;
 extern crate euclid;
 extern crate gfx_traits;
 extern crate heapsize;
-#[macro_use] extern crate heapsize_derive;
+#[macro_use]
+extern crate heapsize_derive;
 extern crate hyper;
 extern crate hyper_serde;
 extern crate ipc_channel;
@@ -252,13 +253,13 @@ pub enum ConstellationControlMsg {
     /// Report an error from a CSS parser for the given pipeline
     ReportCSSError(PipelineId, String, usize, usize, String),
     /// Reload the given page.
-    Reload(PipelineId)
+    Reload(PipelineId),
 }
 
 impl fmt::Debug for ConstellationControlMsg {
     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
         use self::ConstellationControlMsg::*;
-        write!(formatter, "ConstellationMsg::{}", match *self {
+        let variant = match *self {
             AttachLayout(..) => "AttachLayout",
             Resize(..) => "Resize",
             ResizeInactive(..) => "ResizeInactive",
@@ -284,8 +285,9 @@ impl fmt::Debug for ConstellationControlMsg {
             DispatchStorageEvent(..) => "DispatchStorageEvent",
             FramedContentChanged(..) => "FramedContentChanged",
             ReportCSSError(..) => "ReportCSSError",
-            Reload(..) => "Reload"
+            Reload(..) => "Reload",
-        })
+        };
+        write!(formatter, "ConstellationMsg::{}", variant)
     }
 }
 
@@ -383,10 +385,7 @@ pub enum TouchpadPressurePhase {
 
 /// Requests a TimerEvent-Message be sent after the given duration.
 #[derive(Deserialize, Serialize)]
-pub struct TimerEventRequest(pub IpcSender<TimerEvent>,
+pub struct TimerEventRequest(pub IpcSender<TimerEvent>, pub TimerSource, pub TimerEventId, pub MsDuration);
-                             pub TimerSource,
-                             pub TimerEventId,
-                             pub MsDuration);
 
 /// Notifies the script thread to fire due timers.
 /// `TimerSource` must be `FromWindow` when dispatched to `ScriptThread` and
@@ -478,9 +477,7 @@ pub trait ScriptThreadFactory {
     /// Type of message sent from script to layout.
     type Message;
     /// Create a `ScriptThread`.
-    fn create(state: InitialScriptState,
+    fn create(state: InitialScriptState, load_data: LoadData) -> (Sender<Self::Message>, Receiver<Self::Message>);
-              load_data: LoadData)
-              -> (Sender<Self::Message>, Receiver<Self::Message>);
 }
 
 /// Whether the sandbox attribute is present for an iframe element
@@ -489,7 +486,7 @@ pub enum IFrameSandboxState {
     /// Sandbox attribute is present
     IFrameSandboxed,
     /// Sandbox attribute is not present
-    IFrameUnsandboxed
+    IFrameUnsandboxed,
 }
 
 /// Specifies the information required to load an iframe.
@@ -743,5 +740,5 @@ pub struct WorkerScriptLoadOrigin {
     /// the referrer policy which is used
     pub referrer_policy: Option<ReferrerPolicy>,
     /// the pipeline id of the entity requesting the load
-    pub pipeline_id: Option<PipelineId>
+    pub pipeline_id: Option<PipelineId>,
 }

components/script_traits/script_msg.rs

@@ -57,7 +57,7 @@ pub enum LogEntry {
     /// Error, with a reason
     Error(String),
     /// warning, with a reason
-    Warn(String)
+    Warn(String),
 }
 
 /// Messages from the script to the constellation.
@@ -148,7 +148,7 @@ pub enum ScriptMsg {
     /// Enter or exit fullscreen
     SetFullscreenState(bool),
     /// Requests that the compositor shut down.
-    Exit
+    Exit,
 }
 
 /// Entities required to spawn service workers
@@ -175,7 +175,7 @@ pub struct SWManagerSenders {
     /// sender for communicating with constellation
     pub swmanager_sender: IpcSender<SWManagerMsg>,
     /// sender for communicating with resource thread
-    pub resource_sender: IpcSender<CoreResourceMsg>
+    pub resource_sender: IpcSender<CoreResourceMsg>,
 }
 
 /// Messages sent to Service Worker Manager thread
@@ -195,6 +195,5 @@ pub enum ServiceWorkerMsg {
 #[derive(Deserialize, Serialize)]
 pub enum SWManagerMsg {
     /// Provide the constellation with a means of communicating with the Service Worker Manager
-    OwnSender(IpcSender<ServiceWorkerMsg>)
+    OwnSender(IpcSender<ServiceWorkerMsg>),
-
 }

components/script_traits/webdriver_msg.rs

@@ -14,12 +14,10 @@ use servo_url::ServoUrl;
 
 #[derive(Deserialize, Serialize)]
 pub enum WebDriverScriptCommand {
-    AddCookie(
+    AddCookie(#[serde(deserialize_with = "::hyper_serde::deserialize",
-        #[serde(deserialize_with = "::hyper_serde::deserialize",
                 serialize_with = "::hyper_serde::serialize")]
-        Cookie,
+              Cookie,
-        IpcSender<Result<(), WebDriverCookieError>>
+              IpcSender<Result<(), WebDriverCookieError>>),
-    ),
     ExecuteScript(String, IpcSender<WebDriverJSResult>),
     ExecuteAsyncScript(String, IpcSender<WebDriverJSResult>),
     FindElementCSS(String, IpcSender<Result<Option<String>, ()>>),
@@ -37,13 +35,13 @@ pub enum WebDriverScriptCommand {
     GetUrl(IpcSender<ServoUrl>),
     IsEnabled(String, IpcSender<Result<bool, ()>>),
     IsSelected(String, IpcSender<Result<bool, ()>>),
-    GetTitle(IpcSender<String>)
+    GetTitle(IpcSender<String>),
 }
 
 #[derive(Deserialize, Serialize)]
 pub enum WebDriverCookieError {
     InvalidDomain,
-    UnableToSetCookie
+    UnableToSetCookie,
 }
 
 #[derive(Deserialize, Serialize)]
@@ -52,8 +50,7 @@ pub enum WebDriverJSValue {
     Null,
     Boolean(bool),
     Number(f64),
-    String(String),
+    String(String), // TODO: Object and WebElement
-    // TODO: Object and WebElement
 }
 
 #[derive(Deserialize, Serialize)]
@@ -62,7 +59,7 @@ pub enum WebDriverJSError {
     UnknownType,
     /// Occurs when handler received an event message for a layout channel that is not
     /// associated with the current script thread
-    BrowsingContextNotFound
+    BrowsingContextNotFound,
 }
 
 pub type WebDriverJSResult = Result<WebDriverJSValue, WebDriverJSError>;
@@ -71,7 +68,7 @@ pub type WebDriverJSResult = Result<WebDriverJSValue, WebDriverJSError>;
 pub enum WebDriverFrameId {
     Short(u16),
     Element(String),
-    Parent
+    Parent,
 }
 
 impl ToJson for WebDriverJSValue {
@@ -81,7 +78,7 @@ impl ToJson for WebDriverJSValue {
             WebDriverJSValue::Null => Json::Null,
             WebDriverJSValue::Boolean(ref x) => x.to_json(),
             WebDriverJSValue::Number(ref x) => x.to_json(),
-            WebDriverJSValue::String(ref x) => x.to_json()
+            WebDriverJSValue::String(ref x) => x.to_json(),
         }
     }
 }
@@ -89,5 +86,5 @@ impl ToJson for WebDriverJSValue {
 #[derive(Deserialize, Serialize)]
 pub enum LoadStatus {
     LoadComplete,
-    LoadTimeout
+    LoadTimeout,
 }

rustfmt.toml

@@ -0,0 +1,7 @@
+ideal_width = 80
+match_block_trailing_comma = true
+max_width = 120
+newline_style = "Unix"
+normalize_comments = false
+struct_lit_multiline_style = "ForceMulti"
+where_trailing_comma = true