Rustfmt net crate

1 files changed, 113 insertions, 82 deletions

diff --git a/components/net/storage_thread.rs b/components/net/storage_thread.rs
index 5a336d2ea7a..ec5503046ad 100644
--- a/components/net/storage_thread.rs
+++ b/components/net/storage_thread.rs
@@ -22,9 +22,12 @@ impl StorageThreadFactory for IpcSender<StorageThreadMsg> {
     /// Create a storage thread
     fn new(config_dir: Option<PathBuf>) -> IpcSender<StorageThreadMsg> {
         let (chan, port) = ipc::channel().unwrap();
-        thread::Builder::new().name("StorageManager".to_owned()).spawn(move || {
-            StorageManager::new(port, config_dir).start();
-        }).expect("Thread spawning failed");
+        thread::Builder::new()
+            .name("StorageManager".to_owned())
+            .spawn(move || {
+                StorageManager::new(port, config_dir).start();
+            })
+            .expect("Thread spawning failed");
         chan
     }
 }
@@ -37,9 +40,7 @@ struct StorageManager {
 }
 
 impl StorageManager {
-    fn new(port: IpcReceiver<StorageThreadMsg>,
-           config_dir: Option<PathBuf>)
-           -> StorageManager {
+    fn new(port: IpcReceiver<StorageThreadMsg>, config_dir: Option<PathBuf>) -> StorageManager {
         let mut local_data = HashMap::new();
         if let Some(ref config_dir) = config_dir {
             resource_thread::read_json_from_file(&mut local_data, config_dir, "local_data.json");
@@ -59,33 +60,33 @@ impl StorageManager {
             match self.port.recv().unwrap() {
                 StorageThreadMsg::Length(sender, url, storage_type) => {
                     self.length(sender, url, storage_type)
-                }
+                },
                 StorageThreadMsg::Key(sender, url, storage_type, index) => {
                     self.key(sender, url, storage_type, index)
-                }
+                },
                 StorageThreadMsg::Keys(sender, url, storage_type) => {
                     self.keys(sender, url, storage_type)
-                }
+                },
                 StorageThreadMsg::SetItem(sender, url, storage_type, name, value) => {
                     self.set_item(sender, url, storage_type, name, value);
                     self.save_state()
-                }
+                },
                 StorageThreadMsg::GetItem(sender, url, storage_type, name) => {
                     self.request_item(sender, url, storage_type, name)
-                }
+                },
                 StorageThreadMsg::RemoveItem(sender, url, storage_type, name) => {
                     self.remove_item(sender, url, storage_type, name);
                     self.save_state()
-                }
+                },
                 StorageThreadMsg::Clear(sender, url, storage_type) => {
                     self.clear(sender, url, storage_type);
                     self.save_state()
-                }
+                },
                 StorageThreadMsg::Exit(sender) => {
                     // Nothing to do since we save localstorage set eagerly.
                     let _ = sender.send(());
-                    break
-                }
+                    break;
+                },
             }
         }
     }
@@ -96,49 +97,56 @@ impl StorageManager {
         }
     }
 
-    fn select_data(&self, storage_type: StorageType)
-                   -> &HashMap<String, (usize, BTreeMap<String, String>)> {
+    fn select_data(
+        &self,
+        storage_type: StorageType,
+    ) -> &HashMap<String, (usize, BTreeMap<String, String>)> {
         match storage_type {
             StorageType::Session => &self.session_data,
-            StorageType::Local => &self.local_data
+            StorageType::Local => &self.local_data,
         }
     }
 
-    fn select_data_mut(&mut self, storage_type: StorageType)
-                       -> &mut HashMap<String, (usize, BTreeMap<String, String>)> {
+    fn select_data_mut(
+        &mut self,
+        storage_type: StorageType,
+    ) -> &mut HashMap<String, (usize, BTreeMap<String, String>)> {
         match storage_type {
             StorageType::Session => &mut self.session_data,
-            StorageType::Local => &mut self.local_data
+            StorageType::Local => &mut self.local_data,
         }
     }
 
     fn length(&self, sender: IpcSender<usize>, url: ServoUrl, storage_type: StorageType) {
         let origin = self.origin_as_string(url);
         let data = self.select_data(storage_type);
-        sender.send(data.get(&origin).map_or(0, |&(_, ref entry)| entry.len())).unwrap();
+        sender
+            .send(data.get(&origin).map_or(0, |&(_, ref entry)| entry.len()))
+            .unwrap();
     }
 
-    fn key(&self,
-           sender: IpcSender<Option<String>>,
-           url: ServoUrl,
-           storage_type: StorageType,
-           index: u32) {
+    fn key(
+        &self,
+        sender: IpcSender<Option<String>>,
+        url: ServoUrl,
+        storage_type: StorageType,
+        index: u32,
+    ) {
         let origin = self.origin_as_string(url);
         let data = self.select_data(storage_type);
-        let key = data.get(&origin)
-                      .and_then(|&(_, ref entry)| entry.keys().nth(index as usize))
-                      .cloned();
+        let key = data
+            .get(&origin)
+            .and_then(|&(_, ref entry)| entry.keys().nth(index as usize))
+            .cloned();
         sender.send(key).unwrap();
     }
 
-    fn keys(&self,
-            sender: IpcSender<Vec<String>>,
-            url: ServoUrl,
-            storage_type: StorageType) {
+    fn keys(&self, sender: IpcSender<Vec<String>>, url: ServoUrl, storage_type: StorageType) {
         let origin = self.origin_as_string(url);
         let data = self.select_data(storage_type);
-        let keys = data.get(&origin)
-                       .map_or(vec![], |&(_, ref entry)| entry.keys().cloned().collect());
+        let keys = data
+            .get(&origin)
+            .map_or(vec![], |&(_, ref entry)| entry.keys().cloned().collect());
 
         sender.send(keys).unwrap();
     }
@@ -147,12 +155,14 @@ impl StorageManager {
     /// value with the same key name but with different value name
     /// otherwise sends Err(()) to indicate that the operation would result in
     /// exceeding the quota limit
-    fn set_item(&mut self,
-                sender: IpcSender<Result<(bool, Option<String>), ()>>,
-                url: ServoUrl,
-                storage_type: StorageType,
-                name: String,
-                value: String) {
+    fn set_item(
+        &mut self,
+        sender: IpcSender<Result<(bool, Option<String>), ()>>,
+        url: ServoUrl,
+        storage_type: StorageType,
+        name: String,
+        value: String,
+    ) {
         let origin = self.origin_as_string(url);
 
         let (this_storage_size, other_storage_size) = {
@@ -171,64 +181,82 @@ impl StorageManager {
             data.insert(origin.clone(), (0, BTreeMap::new()));
         }
 
-        let message = data.get_mut(&origin).map(|&mut (ref mut total, ref mut entry)| {
-            let mut new_total_size = this_storage_size + value.as_bytes().len();
-            if let Some(old_value) = entry.get(&name) {
-                new_total_size -= old_value.as_bytes().len();
-            } else {
-                new_total_size += name.as_bytes().len();
-            }
+        let message = data
+            .get_mut(&origin)
+            .map(|&mut (ref mut total, ref mut entry)| {
+                let mut new_total_size = this_storage_size + value.as_bytes().len();
+                if let Some(old_value) = entry.get(&name) {
+                    new_total_size -= old_value.as_bytes().len();
+                } else {
+                    new_total_size += name.as_bytes().len();
+                }
 
-            if (new_total_size + other_storage_size) > QUOTA_SIZE_LIMIT {
-                return Err(());
-            }
+                if (new_total_size + other_storage_size) > QUOTA_SIZE_LIMIT {
+                    return Err(());
+                }
 
-            let message = entry.insert(name.clone(), value.clone()).map_or(
-                Ok((true, None)),
-                |old| if old == value {
-                    Ok((false, None))
-                } else {
-                    Ok((true, Some(old)))
-                });
-            *total = new_total_size;
-            message
-        }).unwrap();
+                let message =
+                    entry
+                        .insert(name.clone(), value.clone())
+                        .map_or(Ok((true, None)), |old| {
+                            if old == value {
+                                Ok((false, None))
+                            } else {
+                                Ok((true, Some(old)))
+                            }
+                        });
+                *total = new_total_size;
+                message
+            })
+            .unwrap();
         sender.send(message).unwrap();
     }
 
-    fn request_item(&self,
-                sender: IpcSender<Option<String>>,
-                url: ServoUrl,
-                storage_type: StorageType,
-                name: String) {
+    fn request_item(
+        &self,
+        sender: IpcSender<Option<String>>,
+        url: ServoUrl,
+        storage_type: StorageType,
+        name: String,
+    ) {
         let origin = self.origin_as_string(url);
         let data = self.select_data(storage_type);
-        sender.send(data.get(&origin)
+        sender
+            .send(
+                data.get(&origin)
                     .and_then(|&(_, ref entry)| entry.get(&name))
-                    .map(String::clone)).unwrap();
+                    .map(String::clone),
+            )
+            .unwrap();
     }
 
     /// Sends Some(old_value) in case there was a previous value with the key name, otherwise sends None
-    fn remove_item(&mut self,
-                   sender: IpcSender<Option<String>>,
-                   url: ServoUrl,
-                   storage_type: StorageType,
-                   name: String) {
+    fn remove_item(
+        &mut self,
+        sender: IpcSender<Option<String>>,
+        url: ServoUrl,
+        storage_type: StorageType,
+        name: String,
+    ) {
         let origin = self.origin_as_string(url);
         let data = self.select_data_mut(storage_type);
-        let old_value = data.get_mut(&origin).and_then(|&mut (ref mut total, ref mut entry)| {
-            entry.remove(&name).and_then(|old| {
-                *total -= name.as_bytes().len() + old.as_bytes().len();
-                Some(old)
-            })
-        });
+        let old_value = data
+            .get_mut(&origin)
+            .and_then(|&mut (ref mut total, ref mut entry)| {
+                entry.remove(&name).and_then(|old| {
+                    *total -= name.as_bytes().len() + old.as_bytes().len();
+                    Some(old)
+                })
+            });
         sender.send(old_value).unwrap();
     }
 
     fn clear(&mut self, sender: IpcSender<bool>, url: ServoUrl, storage_type: StorageType) {
         let origin = self.origin_as_string(url);
         let data = self.select_data_mut(storage_type);
-        sender.send(data.get_mut(&origin)
+        sender
+            .send(
+                data.get_mut(&origin)
                     .map_or(false, |&mut (ref mut total, ref mut entry)| {
                         if !entry.is_empty() {
                             entry.clear();
@@ -236,7 +264,10 @@ impl StorageManager {
                             true
                         } else {
                             false
-                        }})).unwrap();
+                        }
+                    }),
+            )
+            .unwrap();
     }
 
     fn origin_as_string(&self, url: ServoUrl) -> String {