Rustfmt net_traits.

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_replacement(host_table, url)
-    })
+    HOST_TABLE.lock().unwrap().as_ref().map_or_else(|| url.clone(),
+                                                    |host_table| host_replacement(host_table, url))
 }
 
-pub fn host_replacement(host_table: &HashMap<String, IpAddr>,
-                        url: &ServoUrl) -> ServoUrl {
-    url.domain().and_then(|domain| host_table.get(domain).map(|ip| {
+pub fn host_replacement(host_table: &HashMap<String, IpAddr>, url: &ServoUrl) -> ServoUrl {
+    url.domain()
+        .and_then(|domain| {
+            host_table.get(domain).map(|ip| {
                 let mut new_url = url.clone();
                 new_url.set_ip_host(*ip).unwrap();
                 new_url
-    })).unwrap_or_else(|| url.clone())
+            })
+        })
+        .unwrap_or_else(|| url.clone())
 }

components/net_traits/image/base.rs

@@ -63,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 {
@@ -79,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)
-    } else if is_jpeg(buffer) { Ok(ImageFormat::JPEG)
-    } else if is_png(buffer)  { 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") }
+    if is_gif(buffer) {
+        Ok(ImageFormat::GIF)
+    } else if is_jpeg(buffer) {
+        Ok(ImageFormat::JPEG)
+    } else if is_png(buffer) {
+        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,
-        _ => false
+        &[b'G', b'I', b'F', b'8', n, b'a', _..] if n == b'7' || n == b'9' => true,
+        _ => 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,
-                         url: ServoUrl,
-                         result_chan: ImageCacheChan,
-                         responder: Option<ImageResponder>) {
+    pub fn request_image(&self, 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)
-                                  -> Result<Arc<Image>, ImageState> {
+    pub fn find_image(&self, url: ServoUrl, use_placeholder: UsePlaceholder) -> 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,
-                                      url: ServoUrl,
-                                      image_data: Vec<u8>) {
+    pub fn store_complete_image_bytes(&self, 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(
-                              Err(NetworkError::Internal("Network error".into()))));
+            let _ =
+                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,
-               s: IpcSender<StorageThreadMsg>) -> ResourceThreads {
+    pub fn new(c: CoreResourceThread, 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)]
@@ -369,10 +377,8 @@ pub enum CoreResourceMsg {
 }
 
 /// Instruct the resource thread to make a new request.
-pub fn fetch_async<F>(request: RequestInit,
-                      core_resource_thread: &CoreResourceThread,
-                      f: F)
-    where F: Fn(FetchResponseMsg) + Send + 'static
+pub fn fetch_async<F>(request: RequestInit, core_resource_thread: &CoreResourceThread, f: F)
+    where F: Fn(FetchResponseMsg) + Send + 'static,
 {
     let (action_sender, action_receiver) = ipc::channel().unwrap();
     ROUTER.add_route(action_receiver.to_opaque(),
@@ -465,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() {
@@ -474,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),
         }
     }
 }
@@ -511,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) =>
-                slice = remainder,
+            Some((first, remainder)) if HTTP_WS_BYTES.contains(first) => slice = remainder,
             _ => break,
         }
     }
 
     loop {
         match slice.split_last() {
-            Some((last, remainder)) if HTTP_WS_BYTES.contains(last) =>
-                slice = remainder,
+            Some((last, remainder)) if HTTP_WS_BYTES.contains(last) => 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) &&
-                self.wildcards.contains(&domain[index + 1..]) ||
-                self.rules.contains(domain),
+            Some(index) => {
+                !self.exceptions.contains(domain) && self.wildcards.contains(&domain[index + 1..]) ||
+                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) ||
-                !self.wildcards.contains(&domain[index + 1..]) &&
-                !self.rules.contains(domain) &&
-                self.is_public_suffix(&domain[index + 1..]),
+            Some(index) => {
+                self.exceptions.contains(domain) ||
+                !self.wildcards.contains(&domain[index + 1..]) && !self.rules.contains(domain) &&
+                self.is_public_suffix(&domain[index + 1..])
+            },
         }
     }
 }
 
 fn load_pub_domains() -> PubDomainRules {
-    let content = read_resource_file("public_domains.txt")
-        .expect("Could not find public suffix list file");
-    let content = from_utf8(&content)
-        .expect("Could not read public suffix list file");
+    let content = read_resource_file("public_domains.txt").expect("Could not find 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,
-    Script, Style, Track, Video
+    None,
+    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,
-    Media, Object, Report, Script, ServiceWorker,
-    SharedWorker, Style, Worker, XSLT
+    None,
+    Document,
+    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,
-    // TODO: Environmental settings object
+    Client, // 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::Media | Destination::Script
-                | Destination::Style | Destination::XSLT
-                | Destination::None => true,
-            _ => false
+            Destination::Font | Destination::Image | Destination::Manifest | Destination::Media |
+            Destination::Script | Destination::Style | Destination::XSLT | 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,
         }
     }
 
@@ -175,7 +176,8 @@ impl Response {
     #[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!(),
             _ => (),
         }
 
@@ -191,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| {
@@ -236,7 +239,7 @@ impl Response {
                 response.status = None;
                 response.body = Arc::new(Mutex::new(ResponseBody::Empty));
                 response.cache_state = CacheState::None;
-            }
+            },
         }
 
         response
@@ -247,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();
@@ -270,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<()>),
 }