Untry

34 files changed, 261 insertions, 264 deletions

diff --git a/components/bluetooth/lib.rs b/components/bluetooth/lib.rs
index 81f09a61417..c3e20977293 100644
--- a/components/bluetooth/lib.rs
+++ b/components/bluetooth/lib.rs
@@ -436,7 +436,7 @@ impl BluetoothManager {
                              device_id: &str,
                              filters: &BluetoothScanfilterSequence)
                              -> BluetoothResult<bool> {
-        let mut adapter = try!(self.get_adapter());
+        let mut adapter = self.get_adapter()?;
         match self.get_device(&mut adapter, device_id) {
             Some(ref device) => Ok(matches_filters(device, filters)),
             None => Ok(false),
@@ -578,7 +578,7 @@ impl BluetoothManager {
                       options: RequestDeviceoptions)
                       -> BluetoothResponseResult {
         // Step 6.
-        let mut adapter = try!(self.get_adapter());
+        let mut adapter = self.get_adapter()?;
 
         // Step 7.
         // Note: There are no requiredServiceUUIDS, we scan for all devices.
@@ -630,7 +630,7 @@ impl BluetoothManager {
         if !self.device_is_cached(&device_id) {
             return Err(BluetoothError::Network);
         }
-        let mut adapter = try!(self.get_adapter());
+        let mut adapter = self.get_adapter()?;
 
         // Step 5.1.1.
         match self.get_device(&mut adapter, &device_id) {
@@ -660,7 +660,7 @@ impl BluetoothManager {
 
     // https://webbluetoothcg.github.io/web-bluetooth/#dom-bluetoothremotegattserver-disconnect
     fn gatt_server_disconnect(&mut self, device_id: String) -> BluetoothResult<()> {
-        let mut adapter = try!(self.get_adapter());
+        let mut adapter = self.get_adapter()?;
         match self.get_device(&mut adapter, &device_id) {
             Some(d) => {
                 // Step 2.
@@ -687,7 +687,7 @@ impl BluetoothManager {
                          single: bool,
                          child_type: GATTType)
                          -> BluetoothResponseResult {
-        let mut adapter = try!(self.get_adapter());
+        let mut adapter = self.get_adapter()?;
         match child_type {
             GATTType::PrimaryService => {
                 // Step 5.
@@ -839,7 +839,7 @@ impl BluetoothManager {
     fn read_value(&mut self, id: String) -> BluetoothResponseResult {
         // (Characteristic) Step 5.2: Missing because it is optional.
         // (Descriptor)     Step 5.1: Missing because it is optional.
-        let mut adapter = try!(self.get_adapter());
+        let mut adapter = self.get_adapter()?;
 
         // (Characteristic) Step 5.3.
         let mut value = self.get_gatt_characteristic(&mut adapter, &id)
@@ -871,7 +871,7 @@ impl BluetoothManager {
     fn write_value(&mut self, id: String, value: Vec<u8>) -> BluetoothResponseResult {
         // (Characteristic) Step 7.2: Missing because it is optional.
         // (Descriptor)     Step 7.1: Missing because it is optional.
-        let mut adapter = try!(self.get_adapter());
+        let mut adapter = self.get_adapter()?;
 
         // (Characteristic) Step 7.3.
         let mut result = self.get_gatt_characteristic(&mut adapter, &id)
@@ -913,7 +913,7 @@ impl BluetoothManager {
         }
 
         // (StartNotification) TODO: Step 7: Missing because it is optional.
-        let mut adapter = try!(self.get_adapter());
+        let mut adapter = self.get_adapter()?;
         match self.get_gatt_characteristic(&mut adapter, &id) {
             Some(c) => {
                 let result = match enable {
diff --git a/components/bluetooth/test.rs b/components/bluetooth/test.rs
index b8f8a53750f..29541123d4a 100644
--- a/components/bluetooth/test.rs
+++ b/components/bluetooth/test.rs
@@ -129,9 +129,9 @@ fn generate_id() -> Uuid {
 
 // Set the adapter's name, is_powered and is_discoverable attributes
 fn set_adapter(adapter: &BluetoothAdapter, adapter_name: String) -> Result<(), Box<Error>> {
-    try!(adapter.set_name(adapter_name));
-    try!(adapter.set_powered(true));
-    try!(adapter.set_discoverable(true));
+    adapter.set_name(adapter_name)?;
+    adapter.set_powered(true)?;
+    adapter.set_discoverable(true)?;
     Ok(())
 }
 
@@ -140,10 +140,10 @@ fn create_device(adapter: &BluetoothAdapter,
                  name: String,
                  address: String)
                  -> Result<BluetoothDevice, Box<Error>> {
-    let device = try!(BluetoothDevice::create_mock_device(adapter.clone(), generate_id().to_string()));
-    try!(device.set_name(Some(name)));
-    try!(device.set_address(address));
-    try!(device.set_connectable(true));
+    let device = BluetoothDevice::create_mock_device(adapter.clone(), generate_id().to_string())?;
+    device.set_name(Some(name))?;
+    device.set_address(address)?;
+    device.set_connectable(true)?;
     Ok(device)
 }
 
@@ -153,8 +153,8 @@ fn create_device_with_uuids(adapter: &BluetoothAdapter,
                             address: String,
                             uuids: Vec<String>)
                             -> Result<BluetoothDevice, Box<Error>> {
-    let device = try!(create_device(adapter, name, address));
-    try!(device.set_uuids(uuids));
+    let device = create_device(adapter, name, address)?;
+    device.set_uuids(uuids)?;
     Ok(device)
 }
 
@@ -162,8 +162,8 @@ fn create_device_with_uuids(adapter: &BluetoothAdapter,
 fn create_service(device: &BluetoothDevice,
                   uuid: String)
                   -> Result<BluetoothGATTService, Box<Error>> {
-    let service = try!(BluetoothGATTService::create_mock_service(device.clone(), generate_id().to_string()));
-    try!(service.set_uuid(uuid));
+    let service = BluetoothGATTService::create_mock_service(device.clone(), generate_id().to_string())?;
+    service.set_uuid(uuid)?;
     Ok(service)
 }
 
@@ -172,8 +172,8 @@ fn create_characteristic(service: &BluetoothGATTService,
                          uuid: String)
                          -> Result<BluetoothGATTCharacteristic, Box<Error>> {
     let characteristic =
-        try!(BluetoothGATTCharacteristic::create_mock_characteristic(service.clone(), generate_id().to_string()));
-    try!(characteristic.set_uuid(uuid));
+        BluetoothGATTCharacteristic::create_mock_characteristic(service.clone(), generate_id().to_string())?;
+    characteristic.set_uuid(uuid)?;
     Ok(characteristic)
 }
 
@@ -182,8 +182,8 @@ fn create_characteristic_with_value(service: &BluetoothGATTService,
                                     uuid: String,
                                     value: Vec<u8>)
                                     -> Result<BluetoothGATTCharacteristic, Box<Error>> {
-    let characteristic = try!(create_characteristic(service, uuid));
-    try!(characteristic.set_value(value));
+    let characteristic = create_characteristic(service, uuid)?;
+    characteristic.set_value(value)?;
     Ok(characteristic)
 }
 
@@ -192,8 +192,8 @@ fn create_descriptor(characteristic: &BluetoothGATTCharacteristic,
                                      uuid: String)
                                      -> Result<BluetoothGATTDescriptor, Box<Error>> {
     let descriptor =
-        try!(BluetoothGATTDescriptor::create_mock_descriptor(characteristic.clone(), generate_id().to_string()));
-    try!(descriptor.set_uuid(uuid));
+        BluetoothGATTDescriptor::create_mock_descriptor(characteristic.clone(), generate_id().to_string())?;
+    descriptor.set_uuid(uuid)?;
     Ok(descriptor)
 }
 
@@ -202,8 +202,8 @@ fn create_descriptor_with_value(characteristic: &BluetoothGATTCharacteristic,
                                 uuid: String,
                                 value: Vec<u8>)
                                 -> Result<BluetoothGATTDescriptor, Box<Error>> {
-    let descriptor = try!(create_descriptor(characteristic, uuid));
-    try!(descriptor.set_value(value));
+    let descriptor = create_descriptor(characteristic, uuid)?;
+    descriptor.set_value(value)?;
     Ok(descriptor)
 }
 
@@ -211,7 +211,7 @@ fn create_heart_rate_service(device: &BluetoothDevice,
                              empty: bool)
                              -> Result<BluetoothGATTService, Box<Error>> {
     // Heart Rate Service
-    let heart_rate_service = try!(create_service(device, HEART_RATE_SERVICE_UUID.to_owned()));
+    let heart_rate_service = create_service(device, HEART_RATE_SERVICE_UUID.to_owned())?;
 
     if empty {
         return Ok(heart_rate_service)
@@ -219,26 +219,26 @@ fn create_heart_rate_service(device: &BluetoothDevice,
 
     // Heart Rate Measurement Characteristic
     let heart_rate_measurement_characteristic =
-        try!(create_characteristic_with_value(&heart_rate_service,
+        create_characteristic_with_value(&heart_rate_service,
                                               HEART_RATE_MEASUREMENT_CHARACTERISTIC_UUID.to_owned(),
-                                              vec![0]));
-    try!(heart_rate_measurement_characteristic.set_flags(vec![NOTIFY_FLAG.to_string(),
+                                              vec![0])?;
+    heart_rate_measurement_characteristic.set_flags(vec![NOTIFY_FLAG.to_string(),
                                                               READ_FLAG.to_string(),
-                                                              WRITE_FLAG.to_string()]));
+                                                              WRITE_FLAG.to_string()])?;
 
     // Body Sensor Location Characteristic 1
     let body_sensor_location_characteristic_1 =
-        try!(create_characteristic_with_value(&heart_rate_service,
+        create_characteristic_with_value(&heart_rate_service,
                                               BODY_SENSOR_LOCATION_CHARACTERISTIC_UUID.to_owned(),
-                                              vec![49]));
-    try!(body_sensor_location_characteristic_1.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()]));
+                                              vec![49])?;
+    body_sensor_location_characteristic_1.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?;
 
     // Body Sensor Location Characteristic 2
     let body_sensor_location_characteristic_2 =
-        try!(create_characteristic_with_value(&heart_rate_service,
+        create_characteristic_with_value(&heart_rate_service,
                                               BODY_SENSOR_LOCATION_CHARACTERISTIC_UUID.to_owned(),
-                                              vec![50]));
-    try!(body_sensor_location_characteristic_2.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()]));
+                                              vec![50])?;
+    body_sensor_location_characteristic_2.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?;
     Ok(heart_rate_service)
 }
 
@@ -247,7 +247,7 @@ fn create_generic_access_service(device: &BluetoothDevice,
                                  -> Result<BluetoothGATTService, Box<Error>> {
     // Generic Access Service
     let generic_access_service =
-        try!(create_service(device, GENERIC_ACCESS_SERVICE_UUID.to_owned()));
+        create_service(device, GENERIC_ACCESS_SERVICE_UUID.to_owned())?;
 
     if empty {
         return Ok(generic_access_service)
@@ -255,41 +255,41 @@ fn create_generic_access_service(device: &BluetoothDevice,
 
     // Device Name Characteristic
     let device_name_characteristic =
-        try!(create_characteristic_with_value(&generic_access_service,
+        create_characteristic_with_value(&generic_access_service,
                                               DEVICE_NAME_CHARACTERISTIC_UUID.to_owned(),
-                                              HEART_RATE_DEVICE_NAME.as_bytes().to_vec()));
-    try!(device_name_characteristic.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()]));
+                                              HEART_RATE_DEVICE_NAME.as_bytes().to_vec())?;
+    device_name_characteristic.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?;
 
     // Number of Digitals descriptor
     let number_of_digitals_descriptor_1 =
-        try!(create_descriptor_with_value(&device_name_characteristic,
+        create_descriptor_with_value(&device_name_characteristic,
                                           NUMBER_OF_DIGITALS_UUID.to_owned(),
-                                          vec![49]));
-    try!(number_of_digitals_descriptor_1.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()]));
+                                          vec![49])?;
+    number_of_digitals_descriptor_1.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?;
 
     let number_of_digitals_descriptor_2 =
-        try!(create_descriptor_with_value(&device_name_characteristic,
+        create_descriptor_with_value(&device_name_characteristic,
                                           NUMBER_OF_DIGITALS_UUID.to_owned(),
-                                          vec![50]));
-    try!(number_of_digitals_descriptor_2.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()]));
+                                          vec![50])?;
+    number_of_digitals_descriptor_2.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?;
 
     // Characteristic User Description Descriptor
     let _characteristic_user_description =
-        try!(create_descriptor_with_value(&device_name_characteristic,
+        create_descriptor_with_value(&device_name_characteristic,
                                           CHARACTERISTIC_USER_DESCRIPTION_UUID.to_owned(),
-                                          HEART_RATE_DEVICE_NAME_DESCRIPTION.as_bytes().to_vec()));
+                                          HEART_RATE_DEVICE_NAME_DESCRIPTION.as_bytes().to_vec())?;
 
     // Client Characteristic Configuration descriptor
     let _client_characteristic_configuration =
-        try!(create_descriptor_with_value(&device_name_characteristic,
+        create_descriptor_with_value(&device_name_characteristic,
                                           CLIENT_CHARACTERISTIC_CONFIGURATION_UUID.to_owned(),
-                                          vec![0]));
+                                          vec![0])?;
 
     // Peripheral Privacy Flag Characteristic
     let peripheral_privacy_flag_characteristic =
-        try!(create_characteristic(&generic_access_service, PERIPHERAL_PRIVACY_FLAG_CHARACTERISTIC_UUID.to_owned()));
-    try!(peripheral_privacy_flag_characteristic
-         .set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()]));
+        create_characteristic(&generic_access_service, PERIPHERAL_PRIVACY_FLAG_CHARACTERISTIC_UUID.to_owned())?;
+    peripheral_privacy_flag_characteristic
+         .set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?;
     Ok(generic_access_service)
 }
 
@@ -299,149 +299,149 @@ fn create_heart_rate_device(adapter: &BluetoothAdapter,
                             -> Result<BluetoothDevice, Box<Error>> {
     // Heart Rate Device
     let heart_rate_device =
-        try!(create_device_with_uuids(adapter,
+        create_device_with_uuids(adapter,
                                       HEART_RATE_DEVICE_NAME.to_owned(),
                                       HEART_RATE_DEVICE_ADDRESS.to_owned(),
                                       vec![GENERIC_ACCESS_SERVICE_UUID.to_owned(),
-                                           HEART_RATE_SERVICE_UUID.to_owned()]));
+                                           HEART_RATE_SERVICE_UUID.to_owned()])?;
 
     if empty {
         return Ok(heart_rate_device);
     }
 
     // Generic Access Service
-    let _generic_access_service = try!(create_generic_access_service(&heart_rate_device, false));
+    let _generic_access_service = create_generic_access_service(&heart_rate_device, false)?;
 
     // Heart Rate Service
-    let _heart_rate_service = try!(create_heart_rate_service(&heart_rate_device, false));
+    let _heart_rate_service = create_heart_rate_service(&heart_rate_device, false)?;
 
     Ok(heart_rate_device)
 }
 
 fn create_missing_characterisitc_heart_rate_device(adapter: &BluetoothAdapter) -> Result<(), Box<Error>> {
-    let heart_rate_device_empty = try!(create_heart_rate_device(adapter, true));
+    let heart_rate_device_empty = create_heart_rate_device(adapter, true)?;
 
-    let _generic_access_service_empty = try!(create_generic_access_service(&heart_rate_device_empty, true));
+    let _generic_access_service_empty = create_generic_access_service(&heart_rate_device_empty, true)?;
 
-    let _heart_rate_service_empty = try!(create_heart_rate_service(&heart_rate_device_empty, true));
+    let _heart_rate_service_empty = create_heart_rate_service(&heart_rate_device_empty, true)?;
 
     Ok(())
 }
 
 fn create_missing_descriptor_heart_rate_device(adapter: &BluetoothAdapter) -> Result<(), Box<Error>> {
-    let heart_rate_device_empty = try!(create_heart_rate_device(adapter, true));
+    let heart_rate_device_empty = create_heart_rate_device(adapter, true)?;
 
-    let generic_access_service_empty = try!(create_generic_access_service(&heart_rate_device_empty, true));
+    let generic_access_service_empty = create_generic_access_service(&heart_rate_device_empty, true)?;
 
     let _device_name_characteristic =
-        try!(create_characteristic_with_value(&generic_access_service_empty,
+        create_characteristic_with_value(&generic_access_service_empty,
                                               DEVICE_NAME_CHARACTERISTIC_UUID.to_owned(),
-                                              HEART_RATE_DEVICE_NAME.as_bytes().to_vec()));
+                                              HEART_RATE_DEVICE_NAME.as_bytes().to_vec())?;
 
     let peripheral_privacy_flag_characteristic =
-        try!(create_characteristic(&generic_access_service_empty,
-                                   PERIPHERAL_PRIVACY_FLAG_CHARACTERISTIC_UUID.to_owned()));
-    try!(peripheral_privacy_flag_characteristic.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()]));
+        create_characteristic(&generic_access_service_empty,
+                                   PERIPHERAL_PRIVACY_FLAG_CHARACTERISTIC_UUID.to_owned())?;
+    peripheral_privacy_flag_characteristic.set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?;
 
-    let _heart_rate_service = try!(create_heart_rate_service(&heart_rate_device_empty, false));
+    let _heart_rate_service = create_heart_rate_service(&heart_rate_device_empty, false)?;
 
     Ok(())
 }
 
 fn create_two_heart_rate_services_device(adapter: &BluetoothAdapter) -> Result<(), Box<Error>> {
-    let heart_rate_device_empty = try!(create_heart_rate_device(adapter, true));
+    let heart_rate_device_empty = create_heart_rate_device(adapter, true)?;
 
-    try!(heart_rate_device_empty.set_uuids(vec![GENERIC_ACCESS_SERVICE_UUID.to_owned(),
+    heart_rate_device_empty.set_uuids(vec![GENERIC_ACCESS_SERVICE_UUID.to_owned(),
                                                 HEART_RATE_SERVICE_UUID.to_owned(),
-                                                HEART_RATE_SERVICE_UUID.to_owned()]));
+                                                HEART_RATE_SERVICE_UUID.to_owned()])?;
 
-    let _generic_access_service = try!(create_generic_access_service(&heart_rate_device_empty, false));
+    let _generic_access_service = create_generic_access_service(&heart_rate_device_empty, false)?;
 
-    let heart_rate_service_empty_1 = try!(create_heart_rate_service(&heart_rate_device_empty, true));
+    let heart_rate_service_empty_1 = create_heart_rate_service(&heart_rate_device_empty, true)?;
 
-    let heart_rate_service_empty_2 = try!(create_heart_rate_service(&heart_rate_device_empty, true));
+    let heart_rate_service_empty_2 = create_heart_rate_service(&heart_rate_device_empty, true)?;
 
     let heart_rate_measurement_characteristic =
-        try!(create_characteristic_with_value(&heart_rate_service_empty_1,
+        create_characteristic_with_value(&heart_rate_service_empty_1,
                                               HEART_RATE_MEASUREMENT_CHARACTERISTIC_UUID.to_owned(),
-                                              vec![0]));
-    try!(heart_rate_measurement_characteristic.set_flags(vec![NOTIFY_FLAG.to_string()]));
+                                              vec![0])?;
+    heart_rate_measurement_characteristic.set_flags(vec![NOTIFY_FLAG.to_string()])?;
 
     let _body_sensor_location_characteristic_1 =
-        try!(create_characteristic_with_value(&heart_rate_service_empty_1,
+        create_characteristic_with_value(&heart_rate_service_empty_1,
                                               BODY_SENSOR_LOCATION_CHARACTERISTIC_UUID.to_owned(),
-                                              vec![49]));
+                                              vec![49])?;
 
     let _body_sensor_location_characteristic_2 =
-        try!(create_characteristic_with_value(&heart_rate_service_empty_2,
+        create_characteristic_with_value(&heart_rate_service_empty_2,
                                               BODY_SENSOR_LOCATION_CHARACTERISTIC_UUID.to_owned(),
-                                              vec![50]));
+                                              vec![50])?;
     Ok(())
 }
 
 fn create_blocklisted_device(adapter: &BluetoothAdapter) -> Result<(), Box<Error>> {
     let connectable_device =
-    try!(create_device_with_uuids(adapter,
+    create_device_with_uuids(adapter,
                                  CONNECTABLE_DEVICE_NAME.to_owned(),
                                  CONNECTABLE_DEVICE_ADDRESS.to_owned(),
                                  vec![BLOCKLIST_TEST_SERVICE_UUID.to_owned(),
                                       DEVICE_INFORMATION_UUID.to_owned(),
                                       GENERIC_ACCESS_SERVICE_UUID.to_owned(),
                                       HEART_RATE_SERVICE_UUID.to_owned(),
-                                      HUMAN_INTERFACE_DEVICE_SERVICE_UUID.to_owned()]));
+                                      HUMAN_INTERFACE_DEVICE_SERVICE_UUID.to_owned()])?;
 
-    let blocklist_test_service = try!(create_service(&connectable_device, BLOCKLIST_TEST_SERVICE_UUID.to_owned()));
+    let blocklist_test_service = create_service(&connectable_device, BLOCKLIST_TEST_SERVICE_UUID.to_owned())?;
 
     let blocklist_exclude_reads_characteristic =
-        try!(create_characteristic(&blocklist_test_service,
-                                   BLOCKLIST_EXCLUDE_READS_CHARACTERISTIC_UUID.to_owned()));
-    try!(blocklist_exclude_reads_characteristic
-         .set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()]));
+        create_characteristic(&blocklist_test_service,
+                                   BLOCKLIST_EXCLUDE_READS_CHARACTERISTIC_UUID.to_owned())?;
+    blocklist_exclude_reads_characteristic
+         .set_flags(vec![READ_FLAG.to_string(), WRITE_FLAG.to_string()])?;
 
     let _blocklist_exclude_reads_descriptor =
-        try!(create_descriptor_with_value(&blocklist_exclude_reads_characteristic,
+        create_descriptor_with_value(&blocklist_exclude_reads_characteristic,
                                           BLOCKLIST_EXCLUDE_READS_DESCRIPTOR_UUID.to_owned(),
-                                          vec![54; 3]));
+                                          vec![54; 3])?;
 
     let _blocklist_descriptor =
-        try!(create_descriptor_with_value(&blocklist_exclude_reads_characteristic,
+        create_descriptor_with_value(&blocklist_exclude_reads_characteristic,
                                           BLOCKLIST_DESCRIPTOR_UUID.to_owned(),
-                                          vec![54; 3]));
+                                          vec![54; 3])?;
 
-    let device_information_service = try!(create_service(&connectable_device, DEVICE_INFORMATION_UUID.to_owned()));
+    let device_information_service = create_service(&connectable_device, DEVICE_INFORMATION_UUID.to_owned())?;
 
     let _serial_number_string_characteristic =
-        try!(create_characteristic(&device_information_service, SERIAL_NUMBER_STRING_UUID.to_owned()));
+        create_characteristic(&device_information_service, SERIAL_NUMBER_STRING_UUID.to_owned())?;
 
-    let _generic_access_service = try!(create_generic_access_service(&connectable_device, false));
+    let _generic_access_service = create_generic_access_service(&connectable_device, false)?;
 
-    let _heart_rate_service = try!(create_heart_rate_service(&connectable_device, false));
+    let _heart_rate_service = create_heart_rate_service(&connectable_device, false)?;
 
     let _human_interface_device_service =
-        try!(create_service(&connectable_device, HUMAN_INTERFACE_DEVICE_SERVICE_UUID.to_owned()));
+        create_service(&connectable_device, HUMAN_INTERFACE_DEVICE_SERVICE_UUID.to_owned())?;
     Ok(())
 }
 
 fn create_glucose_heart_rate_devices(adapter: &BluetoothAdapter) -> Result<(), Box<Error>> {
-    let glucose_devie = try!(create_device_with_uuids(adapter,
+    let glucose_devie = create_device_with_uuids(adapter,
                                                       GLUCOSE_DEVICE_NAME.to_owned(),
                                                       GLUCOSE_DEVICE_ADDRESS.to_owned(),
                                                       vec![GLUCOSE_SERVICE_UUID.to_owned(),
-                                                           TX_POWER_SERVICE_UUID.to_owned()]));
+                                                           TX_POWER_SERVICE_UUID.to_owned()])?;
 
-    let heart_rate_device_empty = try!(create_heart_rate_device(adapter, true));
+    let heart_rate_device_empty = create_heart_rate_device(adapter, true)?;
 
     let mut manufacturer_dta = HashMap::new();
     manufacturer_dta.insert(17, vec![1, 2, 3]);
-    try!(glucose_devie.set_manufacturer_data(manufacturer_dta));
+    glucose_devie.set_manufacturer_data(manufacturer_dta)?;
 
     let mut service_data = HashMap::new();
     service_data.insert(GLUCOSE_SERVICE_UUID.to_owned(), vec![1, 2, 3]);
-    try!(glucose_devie.set_service_data(service_data));
+    glucose_devie.set_service_data(service_data)?;
 
     service_data = HashMap::new();
     service_data.insert(HEART_RATE_SERVICE_UUID.to_owned(), vec![1, 2, 3]);
-    try!(heart_rate_device_empty.set_service_data(service_data));
+    heart_rate_device_empty.set_service_data(service_data)?;
     Ok(())
 }
 
@@ -453,68 +453,68 @@ pub fn test(manager: &mut BluetoothManager, data_set_name: String) -> Result<(),
     };
     match data_set_name.as_str() {
         NOT_PRESENT_ADAPTER => {
-            try!(set_adapter(adapter, NOT_PRESENT_ADAPTER.to_owned()));
-            try!(adapter.set_present(false));
+            set_adapter(adapter, NOT_PRESENT_ADAPTER.to_owned())?;
+            adapter.set_present(false)?;
         },
         NOT_POWERED_ADAPTER => {
-            try!(set_adapter(adapter, NOT_POWERED_ADAPTER.to_owned()));
-            try!(adapter.set_powered(false));
+            set_adapter(adapter, NOT_POWERED_ADAPTER.to_owned())?;
+            adapter.set_powered(false)?;
         },
         EMPTY_ADAPTER => {
-            try!(set_adapter(adapter, EMPTY_ADAPTER.to_owned()));
+            set_adapter(adapter, EMPTY_ADAPTER.to_owned())?;
         },
         GLUCOSE_HEART_RATE_ADAPTER => {
-            try!(set_adapter(adapter, GLUCOSE_HEART_RATE_ADAPTER.to_owned()));
-            let _ = try!(create_glucose_heart_rate_devices(adapter));
+            set_adapter(adapter, GLUCOSE_HEART_RATE_ADAPTER.to_owned())?;
+            let _ = create_glucose_heart_rate_devices(adapter)?;
         },
         UNICODE_DEVICE_ADAPTER => {
-            try!(set_adapter(adapter, UNICODE_DEVICE_ADAPTER.to_owned()));
+            set_adapter(adapter, UNICODE_DEVICE_ADAPTER.to_owned())?;
 
-            let _unicode_device = try!(create_device(adapter,
+            let _unicode_device = create_device(adapter,
                                                      UNICODE_DEVICE_NAME.to_owned(),
-                                                     UNICODE_DEVICE_ADDRESS.to_owned()));
+                                                     UNICODE_DEVICE_ADDRESS.to_owned())?;
         },
         MISSING_SERVICE_HEART_RATE_ADAPTER => {
-            try!(set_adapter(adapter, MISSING_SERVICE_HEART_RATE_ADAPTER.to_owned()));
+            set_adapter(adapter, MISSING_SERVICE_HEART_RATE_ADAPTER.to_owned())?;
 
-            let _heart_rate_device_empty = try!(create_heart_rate_device(adapter, true));
+            let _heart_rate_device_empty = create_heart_rate_device(adapter, true)?;
         },
         MISSING_CHARACTERISTIC_HEART_RATE_ADAPTER => {
-            try!(set_adapter(adapter, MISSING_CHARACTERISTIC_HEART_RATE_ADAPTER.to_owned()));
+            set_adapter(adapter, MISSING_CHARACTERISTIC_HEART_RATE_ADAPTER.to_owned())?;
 
-            let _ = try!(create_missing_characterisitc_heart_rate_device(adapter));
+            let _ = create_missing_characterisitc_heart_rate_device(adapter)?;
         },
         MISSING_DESCRIPTOR_HEART_RATE_ADAPTER => {
-            try!(set_adapter(adapter, MISSING_DESCRIPTOR_HEART_RATE_ADAPTER.to_owned()));
+            set_adapter(adapter, MISSING_DESCRIPTOR_HEART_RATE_ADAPTER.to_owned())?;
 
-            let _ = try!(create_missing_descriptor_heart_rate_device(adapter));
+            let _ = create_missing_descriptor_heart_rate_device(adapter)?;
         },
         HEART_RATE_ADAPTER => {
-            try!(set_adapter(adapter, HEART_RATE_ADAPTER.to_owned()));
+            set_adapter(adapter, HEART_RATE_ADAPTER.to_owned())?;
 
-            let _heart_rate_device = try!(create_heart_rate_device(adapter, false));
+            let _heart_rate_device = create_heart_rate_device(adapter, false)?;
         },
         EMPTY_NAME_HEART_RATE_ADAPTER => {
-            try!(set_adapter(adapter, EMPTY_NAME_HEART_RATE_ADAPTER.to_owned()));
+            set_adapter(adapter, EMPTY_NAME_HEART_RATE_ADAPTER.to_owned())?;
 
-            let heart_rate_device = try!(create_heart_rate_device(adapter, false));
-            try!(heart_rate_device.set_name(Some(EMPTY_DEVICE_NAME.to_owned())));
+            let heart_rate_device = create_heart_rate_device(adapter, false)?;
+            heart_rate_device.set_name(Some(EMPTY_DEVICE_NAME.to_owned()))?;
         },
         NO_NAME_HEART_RATE_ADAPTER => {
-            try!(set_adapter(adapter, NO_NAME_HEART_RATE_ADAPTER.to_owned()));
+            set_adapter(adapter, NO_NAME_HEART_RATE_ADAPTER.to_owned())?;
 
-            let heart_rate_device = try!(create_heart_rate_device(adapter, false));
-            try!(heart_rate_device.set_name(None));
+            let heart_rate_device = create_heart_rate_device(adapter, false)?;
+            heart_rate_device.set_name(None)?;
         },
         TWO_HEART_RATE_SERVICES_ADAPTER => {
-            try!(set_adapter(adapter, TWO_HEART_RATE_SERVICES_ADAPTER.to_owned()));
+            set_adapter(adapter, TWO_HEART_RATE_SERVICES_ADAPTER.to_owned())?;
 
-            let _ = try!(create_two_heart_rate_services_device(adapter));
+            let _ = create_two_heart_rate_services_device(adapter)?;
         },
         BLOCKLIST_TEST_ADAPTER => {
-            try!(set_adapter(adapter, BLOCKLIST_TEST_ADAPTER.to_owned()));
+            set_adapter(adapter, BLOCKLIST_TEST_ADAPTER.to_owned())?;
 
-            let _ = try!(create_blocklisted_device(adapter));
+            let _ = create_blocklisted_device(adapter)?;
         },
         _ => return Err(Box::from(WRONG_DATA_SET_ERROR.to_string())),
     }
diff --git a/components/canvas/webgl_paint_thread.rs b/components/canvas/webgl_paint_thread.rs
index a27cb42c7b9..350b5702d9c 100644
--- a/components/canvas/webgl_paint_thread.rs
+++ b/components/canvas/webgl_paint_thread.rs
@@ -56,11 +56,11 @@ impl GLContextWrapper {
     fn resize(&mut self, size: Size2D<i32>) -> Result<Size2D<i32>, &'static str> {
         match *self {
             GLContextWrapper::Native(ref mut ctx) => {
-                try!(ctx.resize(size));
+                ctx.resize(size)?;
                 Ok(ctx.borrow_draw_buffer().unwrap().size())
             }
             GLContextWrapper::OSMesa(ref mut ctx) => {
-                try!(ctx.resize(size));
+                ctx.resize(size)?;
                 Ok(ctx.borrow_draw_buffer().unwrap().size())
             }
         }
@@ -115,7 +115,7 @@ fn create_readback_painter(size: Size2D<i32>,
                            webrender_api: webrender_traits::RenderApi,
                            gl_type: gl::GlType)
     -> Result<(WebGLPaintThread, GLLimits), String> {
-    let context = try!(GLContextWrapper::new(size, attrs, gl_type));
+    let context = GLContextWrapper::new(size, attrs, gl_type)?;
     let limits = context.get_limits();
     let painter = WebGLPaintThread {
         size: size,
@@ -294,7 +294,7 @@ impl WebGLPaintThread {
             WebGLPaintTaskData::Readback(ref mut context, ref webrender_api, ref mut image_key) => {
                 if size.width > self.size.width ||
                    size.height > self.size.height {
-                    self.size = try!(context.resize(size));
+                    self.size = context.resize(size)?;
                 } else {
                     self.size = size;
                     context.gl().scissor(0, 0, size.width, size.height);
diff --git a/components/config/prefs.rs b/components/config/prefs.rs
index 8b790575073..d1a97b91dc2 100644
--- a/components/config/prefs.rs
+++ b/components/config/prefs.rs
@@ -113,7 +113,7 @@ impl Pref {
     }
 
     fn from_json(data: Json) -> Result<Pref, ()> {
-        let value = try!(PrefValue::from_json(data));
+        let value = PrefValue::from_json(data)?;
         Ok(Pref::new_default(value))
     }
 
@@ -158,10 +158,10 @@ pub fn default_prefs() -> Preferences {
 
 pub fn read_prefs_from_file<T>(mut file: T)
     -> Result<HashMap<String, Pref>, ()> where T: Read {
-    let json = try!(Json::from_reader(&mut file).or_else(|e| {
+    let json = Json::from_reader(&mut file).or_else(|e| {
         println!("Ignoring invalid JSON in preferences: {:?}.", e);
         Err(())
-    }));
+    })?;
 
     let mut prefs = HashMap::new();
     if let Json::Object(obj) = json {
@@ -205,14 +205,14 @@ fn init_user_prefs(path: &mut PathBuf) {
 }
 
 fn read_prefs() -> Result<HashMap<String, Pref>, ()> {
-    let mut path = try!(resources_dir_path().map_err(|_| ()));
+    let mut path = resources_dir_path().map_err(|_| ())?;
     path.push("prefs.json");
 
-    let file = try!(File::open(path).or_else(|e| {
+    let file = File::open(path).or_else(|e| {
         writeln!(&mut stderr(), "Error opening preferences: {:?}.", e)
             .expect("failed printing to stderr");
         Err(())
-    }));
+    })?;
 
     read_prefs_from_file(file)
 }
diff --git a/components/config/resource_files.rs b/components/config/resource_files.rs
index 89b9924642e..bc3e9a78e3e 100644
--- a/components/config/resource_files.rs
+++ b/components/config/resource_files.rs
@@ -44,9 +44,9 @@ pub fn resources_dir_path() -> io::Result<PathBuf> {
     // FIXME: Find a way to not rely on the executable being
     // under `<servo source>[/$target_triple]/target/debug`
     // or `<servo source>[/$target_triple]/target/release`.
-    let mut path = try!(env::current_exe());
+    let mut path = env::current_exe()?;
     // Follow symlink
-    path = try!(path.canonicalize());
+    path = path.canonicalize()?;
 
     while path.pop() {
         path.push("resources");
@@ -66,10 +66,10 @@ pub fn resources_dir_path() -> io::Result<PathBuf> {
 }
 
 pub fn read_resource_file<P: AsRef<Path>>(relative_path: P) -> io::Result<Vec<u8>> {
-    let mut path = try!(resources_dir_path());
+    let mut path = resources_dir_path()?;
     path.push(relative_path);
-    let mut file = try!(File::open(&path));
+    let mut file = File::open(&path)?;
     let mut data = Vec::new();
-    try!(file.read_to_end(&mut data));
+    file.read_to_end(&mut data)?;
     Ok(data)
 }
diff --git a/components/constellation/pipeline.rs b/components/constellation/pipeline.rs
index 6779cd2060f..cc6d92bb070 100644
--- a/components/constellation/pipeline.rs
+++ b/components/constellation/pipeline.rs
@@ -273,7 +273,7 @@ impl Pipeline {
                 //
                 // Yes, that's all there is to it!
                 if opts::multiprocess() {
-                    let _ = try!(unprivileged_pipeline_content.spawn_multiprocess());
+                    let _ = unprivileged_pipeline_content.spawn_multiprocess()?;
                 } else {
                     unprivileged_pipeline_content.start_all::<Message, LTF, STF>(false);
                 }
@@ -563,7 +563,7 @@ impl UnprivilegedPipelineContent {
         }
 
         let (_receiver, sender) = server.accept().expect("Server failed to accept.");
-        try!(sender.send(self));
+        sender.send(self)?;
 
         Ok(())
     }
diff --git a/components/devtools/actor.rs b/components/devtools/actor.rs
index 1e517bd1ef9..f2ee6398e9b 100644
--- a/components/devtools/actor.rs
+++ b/components/devtools/actor.rs
@@ -159,7 +159,7 @@ impl ActorRegistry {
             None => debug!("message received for unknown actor \"{}\"", to),
             Some(actor) => {
                 let msg_type = msg.get("type").unwrap().as_str().unwrap();
-                if try!(actor.handle_message(self, msg_type, msg, stream))
+                if actor.handle_message(self, msg_type, msg, stream)?
                         != ActorMessageStatus::Processed {
                     debug!("unexpected message type \"{}\" found for actor \"{}\"",
                              msg_type, to);
diff --git a/components/devtools/actors/console.rs b/components/devtools/actors/console.rs
index 498426684ca..c94c9860156 100644
--- a/components/devtools/actors/console.rs
+++ b/components/devtools/actors/console.rs
@@ -115,7 +115,7 @@ impl Actor for ConsoleActor {
                 let (chan, port) = ipc::channel().unwrap();
                 self.script_chan.send(DevtoolScriptControlMsg::GetCachedMessages(
                     self.pipeline, message_types, chan)).unwrap();
-                let messages = try!(port.recv().map_err(|_| ())).into_iter().map(|message| {
+                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()
@@ -179,7 +179,7 @@ impl Actor for ConsoleActor {
                     self.pipeline, input.clone(), chan)).unwrap();
 
                 //TODO: extract conversion into protocol module or some other useful place
-                let result = match try!(port.recv().map_err(|_| ())) {
+                let result = match port.recv().map_err(|_| ())? {
                     VoidValue => {
                         let mut m = Map::new();
                         m.insert("type".to_owned(), Value::String("undefined".to_owned()));
diff --git a/components/devtools/actors/inspector.rs b/components/devtools/actors/inspector.rs
index 9749b69e813..370d90128cb 100644
--- a/components/devtools/actors/inspector.rs
+++ b/components/devtools/actors/inspector.rs
@@ -289,7 +289,7 @@ impl Actor for WalkerActor {
             "documentElement" => {
                 let (tx, rx) = ipc::channel().unwrap();
                 self.script_chan.send(GetDocumentElement(self.pipeline, tx)).unwrap();
-                let doc_elem_info = try!(rx.recv().unwrap().ok_or(()));
+                let doc_elem_info = rx.recv().unwrap().ok_or(())?;
                 let node = doc_elem_info.encode(registry, true, self.script_chan.clone(), self.pipeline);
 
                 let msg = DocumentElementReply {
@@ -315,7 +315,7 @@ impl Actor for WalkerActor {
                                                   registry.actor_to_script(target.to_owned()),
                                                   tx))
                                 .unwrap();
-                let children = try!(rx.recv().unwrap().ok_or(()));
+                let children = rx.recv().unwrap().ok_or(())?;
 
                 let msg = ChildrenReply {
                     hasFirst: true,
@@ -489,7 +489,7 @@ impl Actor for PageStyleActor {
                     borderTopWidth, borderRightWidth, borderBottomWidth, borderLeftWidth,
                     paddingTop, paddingRight, paddingBottom, paddingLeft,
                     width, height,
-                } = try!(rx.recv().unwrap().ok_or(()));
+                } = rx.recv().unwrap().ok_or(())?;
 
                 let auto_margins = msg.get("autoMargins")
                     .and_then(&Value::as_bool).unwrap_or(false);
@@ -563,7 +563,7 @@ impl Actor for InspectorActor {
 
                 let (tx, rx) = ipc::channel().unwrap();
                 self.script_chan.send(GetRootNode(self.pipeline, tx)).unwrap();
-                let root_info = try!(rx.recv().unwrap().ok_or(()));
+                let root_info = rx.recv().unwrap().ok_or(())?;
 
                 let node = root_info.encode(registry, false, self.script_chan.clone(), self.pipeline);
 
diff --git a/components/gfx/font_context.rs b/components/gfx/font_context.rs
index 2e91e549611..20c89f61382 100644
--- a/components/gfx/font_context.rs
+++ b/components/gfx/font_context.rs
@@ -88,9 +88,9 @@ impl FontContext {
             font_variant_caps::T::normal => pt_size,
         };
 
-        let handle = try!(FontHandle::new_from_template(&self.platform_handle,
+        let handle = FontHandle::new_from_template(&self.platform_handle,
                                                         template,
-                                                        Some(actual_pt_size)));
+                                                        Some(actual_pt_size))?;
 
         Ok(Font::new(handle, variant, descriptor, pt_size, actual_pt_size, font_key))
     }
diff --git a/components/gfx/font_template.rs b/components/gfx/font_template.rs
index b8e45a3e922..6a46834901b 100644
--- a/components/gfx/font_template.rs
+++ b/components/gfx/font_template.rs
@@ -80,7 +80,7 @@ impl Debug for FontTemplate {
 impl FontTemplate {
     pub fn new(identifier: Atom, maybe_bytes: Option<Vec<u8>>) -> Result<FontTemplate, IoError> {
         let maybe_data = match maybe_bytes {
-            Some(_) => Some(try!(FontTemplateData::new(identifier.clone(), maybe_bytes))),
+            Some(_) => Some(FontTemplateData::new(identifier.clone(), maybe_bytes)?),
             None => None,
         };
 
@@ -167,12 +167,12 @@ impl FontTemplate {
             return Err(())
         }
 
-        let data = try!(self.data().map_err(|_| ()));
+        let data = self.data().map_err(|_| ())?;
         let handle: Result<FontHandle, ()> = FontHandleMethods::new_from_template(font_context,
                                                                                   data,
                                                                                   None);
         self.is_valid = handle.is_ok();
-        let handle = try!(handle);
+        let handle = handle?;
         self.descriptor = Some(FontTemplateDescriptor::new(handle.boldness(),
                                                            handle.stretchiness(),
                                                            handle.is_italic()));
@@ -202,7 +202,7 @@ impl FontTemplate {
         }
 
         assert!(self.strong_ref.is_none());
-        let template_data = Arc::new(try!(FontTemplateData::new(self.identifier.clone(), None)));
+        let template_data = Arc::new(FontTemplateData::new(self.identifier.clone(), None)?);
         self.weak_ref = Some(Arc::downgrade(&template_data));
         Ok(template_data)
     }
diff --git a/components/gfx/platform/freetype/android/font_list.rs b/components/gfx/platform/freetype/android/font_list.rs
index 358b9a2104b..2ff8be5a325 100644
--- a/components/gfx/platform/freetype/android/font_list.rs
+++ b/components/gfx/platform/freetype/android/font_list.rs
@@ -235,9 +235,9 @@ impl FontList {
 
 
     fn load_file(path: &str) -> Result<String, io::Error> {
-        let mut file = try!(File::open(path));
+        let mut file = File::open(path)?;
         let mut content = String::new();
-        try!(file.read_to_string(&mut content));
+        file.read_to_string(&mut content)?;
 
         Ok(content)
     }
diff --git a/components/gfx/platform/freetype/font.rs b/components/gfx/platform/freetype/font.rs
index be4d6aae036..6a2b948be7e 100644
--- a/components/gfx/platform/freetype/font.rs
+++ b/components/gfx/platform/freetype/font.rs
@@ -99,7 +99,7 @@ impl FontHandleMethods for FontHandle {
                     return Err(());
                 }
                 if let Some(s) = pt_size {
-                    try!(FontHandle::set_char_size(face, s).or(Err(())))
+                    FontHandle::set_char_size(face, s).or(Err(()))?
                 }
                 Ok(face)
             }
diff --git a/components/gfx/platform/freetype/font_template.rs b/components/gfx/platform/freetype/font_template.rs
index 32ab52097d2..7fab5b9741e 100644
--- a/components/gfx/platform/freetype/font_template.rs
+++ b/components/gfx/platform/freetype/font_template.rs
@@ -25,7 +25,7 @@ impl FontTemplateData {
             },
             None => {
                 // TODO: Handle file load failure!
-                let mut file = try!(File::open(&*identifier));
+                let mut file = File::open(&*identifier)?;
                 let mut buffer = vec![];
                 file.read_to_end(&mut buffer).unwrap();
                 buffer
diff --git a/components/gfx/platform/windows/font.rs b/components/gfx/platform/windows/font.rs
index 5746739a107..1778c9a603f 100644
--- a/components/gfx/platform/windows/font.rs
+++ b/components/gfx/platform/windows/font.rs
@@ -47,7 +47,7 @@ fn make_tag(tag_bytes: &[u8]) -> FontTableTag {
     unsafe { *(tag_bytes.as_ptr() as *const FontTableTag) }
 }
 
-macro_rules! try_lossy(($result:expr) => (try!($result.map_err(|_| (())))));
+macro_rules! try_lossy(($result:expr) => ($result.map_err(|_| (()))?));
 
 // Given a set of records, figure out the string indices for the family and face
 // names.  We want name_id 1 and 2, and we need to use platform_id == 1 and
@@ -262,12 +262,12 @@ impl FontHandleMethods for FontHandle {
             }
 
             let face = font_file.unwrap().create_face(0, dwrote::DWRITE_FONT_SIMULATIONS_NONE);
-            let info = try!(FontInfo::new_from_face(&face));
+            let info = FontInfo::new_from_face(&face)?;
             (info, face)
         } else {
             let font = font_from_atom(&template.identifier);
             let face = font.create_font_face();
-            let info = try!(FontInfo::new_from_font(&font));
+            let info = FontInfo::new_from_font(&font)?;
             (info, face)
         };
 
diff --git a/components/gfx/text/glyph.rs b/components/gfx/text/glyph.rs
index 2229bbbecd8..90e899c3daa 100644
--- a/components/gfx/text/glyph.rs
+++ b/components/gfx/text/glyph.rs
@@ -665,27 +665,27 @@ impl<'a> GlyphStore {
 
 impl fmt::Debug for GlyphStore {
     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        try!(write!(formatter, "GlyphStore:\n"));
+        write!(formatter, "GlyphStore:\n")?;
         let mut detailed_buffer = self.detail_store.detail_buffer.iter();
         for entry in self.entry_buffer.iter() {
             if entry.is_simple() {
-                try!(write!(formatter,
+                write!(formatter,
                             "  simple id={:?} advance={:?}\n",
                             entry.id(),
-                            entry.advance()));
+                            entry.advance())?;
                 continue
             }
             if entry.is_initial() {
                 continue
             }
-            try!(write!(formatter, "  complex..."));
+            write!(formatter, "  complex...")?;
             if detailed_buffer.next().is_none() {
                 continue
             }
-            try!(write!(formatter,
+            write!(formatter,
                         "  detailed id={:?} advance={:?}\n",
                         entry.id(),
-                        entry.advance()));
+                        entry.advance())?;
         }
         Ok(())
     }
diff --git a/components/layout/floats.rs b/components/layout/floats.rs
index 43d05e4bad4..1fc28e9750a 100644
--- a/components/layout/floats.rs
+++ b/components/layout/floats.rs
@@ -78,9 +78,9 @@ impl FloatList {
 
 impl fmt::Debug for FloatList {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(write!(f, "max_block_start={:?} floats={}", self.max_block_start, self.floats.len()));
+        write!(f, "max_block_start={:?} floats={}", self.max_block_start, self.floats.len())?;
         for float in self.floats.iter() {
-            try!(write!(f, " {:?}", float));
+            write!(f, " {:?}", float)?;
         }
         Ok(())
     }
diff --git a/components/layout/flow.rs b/components/layout/flow.rs
index 5930df5dd81..f87fe4c9ef8 100644
--- a/components/layout/flow.rs
+++ b/components/layout/flow.rs
@@ -1011,14 +1011,12 @@ impl fmt::Debug for BaseFlow {
 
 impl Serialize for BaseFlow {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let mut serializer = try!(serializer.serialize_struct("base", 5));
-        try!(serializer.serialize_field("id", &self.debug_id()));
-        try!(serializer.serialize_field("stacking_relative_position",
-                                        &self.stacking_relative_position));
-        try!(serializer.serialize_field("intrinsic_inline_sizes",
-                                        &self.intrinsic_inline_sizes));
-        try!(serializer.serialize_field("position", &self.position));
-        try!(serializer.serialize_field("children", &self.children));
+        let mut serializer = serializer.serialize_struct("base", 5)?;
+        serializer.serialize_field("id", &self.debug_id())?;
+        serializer.serialize_field("stacking_relative_position", &self.stacking_relative_position)?;
+        serializer.serialize_field("intrinsic_inline_sizes", &self.intrinsic_inline_sizes)?;
+        serializer.serialize_field("position", &self.position)?;
+        serializer.serialize_field("children", &self.children)?;
         serializer.end()
     }
 }
diff --git a/components/layout/flow_list.rs b/components/layout/flow_list.rs
index 60423bad154..97fd6dbc89f 100644
--- a/components/layout/flow_list.rs
+++ b/components/layout/flow_list.rs
@@ -24,7 +24,7 @@ pub struct FlowList {
 
 impl Serialize for FlowList {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let mut serializer = try!(serializer.serialize_seq(Some(self.len())));
+        let mut serializer = serializer.serialize_seq(Some(self.len()))?;
         for f in self.iter() {
             let mut flow_val = Map::new();
             flow_val.insert("class".to_owned(), to_value(f.class()).unwrap());
@@ -43,7 +43,7 @@ impl Serialize for FlowList {
                 }
             };
             flow_val.insert("data".to_owned(), data);
-            try!(serializer.serialize_element(&flow_val));
+            serializer.serialize_element(&flow_val)?;
         }
         serializer.end()
     }
diff --git a/components/layout/fragment.rs b/components/layout/fragment.rs
index 3eb403b98a9..818717343ec 100644
--- a/components/layout/fragment.rs
+++ b/components/layout/fragment.rs
@@ -143,10 +143,10 @@ pub struct Fragment {
 
 impl Serialize for Fragment {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let mut serializer = try!(serializer.serialize_struct("fragment", 3));
-        try!(serializer.serialize_field("id", &self.debug_id));
-        try!(serializer.serialize_field("border_box", &self.border_box));
-        try!(serializer.serialize_field("margin", &self.margin));
+        let mut serializer = serializer.serialize_struct("fragment", 3)?;
+        serializer.serialize_field("id", &self.debug_id)?;
+        serializer.serialize_field("border_box", &self.border_box)?;
+        serializer.serialize_field("margin", &self.margin)?;
         serializer.end()
     }
 }
diff --git a/components/layout_thread/lib.rs b/components/layout_thread/lib.rs
index d53fa05a37f..ce3a7e28b7d 100644
--- a/components/layout_thread/lib.rs
+++ b/components/layout_thread/lib.rs
@@ -1662,7 +1662,7 @@ fn get_root_flow_background_color(flow: &mut Flow) -> webrender_traits::ColorF {
 fn get_ua_stylesheets() -> Result<UserAgentStylesheets, &'static str> {
     fn parse_ua_stylesheet(shared_lock: &SharedRwLock, filename: &'static str)
                            -> Result<Stylesheet, &'static str> {
-        let res = try!(read_resource_file(filename).map_err(|_| filename));
+        let res = read_resource_file(filename).map_err(|_| filename)?;
         Ok(Stylesheet::from_bytes(
             &res,
             ServoUrl::parse(&format!("chrome://resources/{:?}", filename)).unwrap(),
@@ -1681,7 +1681,7 @@ fn get_ua_stylesheets() -> Result<UserAgentStylesheets, &'static str> {
     // FIXME: presentational-hints.css should be at author origin with zero specificity.
     //        (Does it make a difference?)
     for &filename in &["user-agent.css", "servo.css", "presentational-hints.css"] {
-        user_or_user_agent_stylesheets.push(try!(parse_ua_stylesheet(&shared_lock, filename)));
+        user_or_user_agent_stylesheets.push(parse_ua_stylesheet(&shared_lock, filename)?);
     }
     for &(ref contents, ref url) in &opts::get().user_stylesheets {
         user_or_user_agent_stylesheets.push(Stylesheet::from_bytes(
@@ -1689,7 +1689,7 @@ fn get_ua_stylesheets() -> Result<UserAgentStylesheets, &'static str> {
             shared_lock.clone(), None, &RustLogReporter, QuirksMode::NoQuirks));
     }
 
-    let quirks_mode_stylesheet = try!(parse_ua_stylesheet(&shared_lock, "quirks-mode.css"));
+    let quirks_mode_stylesheet = parse_ua_stylesheet(&shared_lock, "quirks-mode.css")?;
 
     Ok(UserAgentStylesheets {
         shared_lock: shared_lock,
diff --git a/components/net/connector.rs b/components/net/connector.rs
index 50d8c11a6c5..659fb4b6ad9 100644
--- a/components/net/connector.rs
+++ b/components/net/connector.rs
@@ -36,7 +36,7 @@ impl NetworkConnector for HttpsConnector {
 
         // Perform host replacement when making the actual TCP connection.
         let addr = &(&*replace_host(host), port);
-        let stream = HttpStream(try!(TcpStream::connect(addr)));
+        let stream = HttpStream(TcpStream::connect(addr)?);
 
         if scheme == "http" {
             Ok(HttpsStream::Http(stream))
diff --git a/components/net/filemanager_thread.rs b/components/net/filemanager_thread.rs
index 4af2d868025..393613d1a7b 100644
--- a/components/net/filemanager_thread.rs
+++ b/components/net/filemanager_thread.rs
@@ -357,14 +357,14 @@ impl FileManagerStore {
     fn create_entry(&self, file_path: &Path, origin: &str) -> Result<SelectedFile, FileManagerThreadError> {
         use net_traits::filemanager_thread::FileManagerThreadError::FileSystemError;
 
-        let file = try!(File::open(file_path).map_err(|e| FileSystemError(e.to_string())));
-        let metadata = try!(file.metadata().map_err(|e| FileSystemError(e.to_string())));
-        let modified = try!(metadata.modified().map_err(|e| FileSystemError(e.to_string())));
-        let elapsed = try!(modified.elapsed().map_err(|e| FileSystemError(e.to_string())));
+        let file = File::open(file_path).map_err(|e| FileSystemError(e.to_string()))?;
+        let metadata = file.metadata().map_err(|e| FileSystemError(e.to_string()))?;
+        let modified = metadata.modified().map_err(|e| FileSystemError(e.to_string()))?;
+        let elapsed = modified.elapsed().map_err(|e| FileSystemError(e.to_string()))?;
         // Unix Epoch: https://doc.servo.org/std/time/constant.UNIX_EPOCH.html
         let modified_epoch = elapsed.as_secs() * 1000 + elapsed.subsec_nanos() as u64 / 1000000;
         let file_size = metadata.len();
-        let file_name = try!(file_path.file_name().ok_or(FileSystemError("Invalid filepath".to_string())));
+        let file_name = file_path.file_name().ok_or(FileSystemError("Invalid filepath".to_string()))?;
 
         let file_impl = FileImpl::MetaDataOnly(FileMetaData {
             path: file_path.to_path_buf(),
@@ -400,7 +400,7 @@ impl FileManagerStore {
     fn get_blob_buf(&self, sender: &IpcSender<FileManagerResult<ReadFileProgress>>,
                     id: &Uuid, origin_in: &FileOrigin, rel_pos: RelativePos,
                     check_url_validity: bool) -> Result<(), BlobURLStoreError> {
-        let file_impl = try!(self.get_impl(id, origin_in, check_url_validity));
+        let file_impl = self.get_impl(id, origin_in, check_url_validity)?;
         match file_impl {
             FileImpl::Memory(buf) => {
                 let range = rel_pos.to_abs_range(buf.size as usize);
@@ -430,10 +430,10 @@ impl FileManagerStore {
                 let mime = guess_mime_type_opt(metadata.path.clone());
                 let range = rel_pos.to_abs_range(metadata.size as usize);
 
-                let mut file = try!(File::open(&metadata.path)
-                                   .map_err(|e| BlobURLStoreError::External(e.to_string())));
-                let seeked_start = try!(file.seek(SeekFrom::Start(range.start as u64))
-                                       .map_err(|e| BlobURLStoreError::External(e.to_string())));
+                let mut file = File::open(&metadata.path)
+                                   .map_err(|e| BlobURLStoreError::External(e.to_string()))?;
+                let seeked_start = file.seek(SeekFrom::Start(range.start as u64))
+                                       .map_err(|e| BlobURLStoreError::External(e.to_string()))?;
 
                 if seeked_start == (range.start as u64) {
                     let type_string = match mime {
diff --git a/components/net/http_loader.rs b/components/net/http_loader.rs
index 570144e43de..5489a49594b 100644
--- a/components/net/http_loader.rs
+++ b/components/net/http_loader.rs
@@ -317,7 +317,7 @@ impl StreamedResponse {
     fn from_http_response(response: WrappedHttpResponse) -> io::Result<StreamedResponse> {
         let decoder = match response.content_encoding() {
             Some(Encoding::Gzip) => {
-                Decoder::Gzip(try!(GzDecoder::new(response)))
+                Decoder::Gzip(GzDecoder::new(response)?)
             }
             Some(Encoding::Deflate) => {
                 Decoder::Deflate(DeflateDecoder::new(response))
@@ -1340,7 +1340,7 @@ fn cors_check(request: &Request, response: &Response) -> Result<(), ()> {
     let origin = response.headers.get::<AccessControlAllowOrigin>().cloned();
 
     // Step 2
-    let origin = try!(origin.ok_or(()));
+    let origin = origin.ok_or(())?;
 
     // Step 3
     if request.credentials_mode != CredentialsMode::Include &&
diff --git a/components/net/image_cache.rs b/components/net/image_cache.rs
index 3842537f8ba..516101f7b34 100644
--- a/components/net/image_cache.rs
+++ b/components/net/image_cache.rs
@@ -53,9 +53,9 @@ fn decode_bytes_sync(key: LoadKey, bytes: &[u8]) -> DecoderMsg {
 }
 
 fn get_placeholder_image(webrender_api: &webrender_traits::RenderApi, path: &PathBuf) -> io::Result<Arc<Image>> {
-    let mut file = try!(File::open(path));
+    let mut file = File::open(path)?;
     let mut image_data = vec![];
-    try!(file.read_to_end(&mut image_data));
+    file.read_to_end(&mut image_data)?;
     let mut image = load_from_memory(&image_data).unwrap();
     set_webrender_image_key(webrender_api, &mut image);
     Ok(Arc::new(image))
diff --git a/components/net/mime_classifier.rs b/components/net/mime_classifier.rs
index e4e1d7c0093..95ad0b543c0 100644
--- a/components/net/mime_classifier.rs
+++ b/components/net/mime_classifier.rs
@@ -169,14 +169,14 @@ impl MimeClassifier {
     }
 
     pub fn validate(&self) -> Result<(), String> {
-        try!(self.image_classifier.validate());
-        try!(self.audio_video_classifier.validate());
-        try!(self.scriptable_classifier.validate());
-        try!(self.plaintext_classifier.validate());
-        try!(self.archive_classifier.validate());
-        try!(self.binary_or_plaintext.validate());
-        try!(self.feeds_classifier.validate());
-        try!(self.font_classifier.validate());
+        self.image_classifier.validate()?;
+        self.audio_video_classifier.validate()?;
+        self.scriptable_classifier.validate()?;
+        self.plaintext_classifier.validate()?;
+        self.archive_classifier.validate()?;
+        self.binary_or_plaintext.validate()?;
+        self.feeds_classifier.validate()?;
+        self.font_classifier.validate()?;
         Ok(())
     }
 
@@ -547,7 +547,7 @@ impl MIMEChecker for GroupedClassifier {
 
     fn validate(&self) -> Result<(), String> {
         for byte_matcher in &self.byte_matchers {
-            try!(byte_matcher.validate())
+            byte_matcher.validate()?
         }
         Ok(())
     }
diff --git a/components/net_traits/blob_url_store.rs b/components/net_traits/blob_url_store.rs
index 0357b0fec08..d171234cac4 100644
--- a/components/net_traits/blob_url_store.rs
+++ b/components/net_traits/blob_url_store.rs
@@ -36,11 +36,11 @@ pub struct BlobBuf {
 /// Parse URL as Blob URL scheme's definition
 /// https://w3c.github.io/FileAPI/#DefinitionOfScheme
 pub fn parse_blob_url(url: &ServoUrl) -> Result<(Uuid, FileOrigin), ()> {
-    let url_inner = try!(Url::parse(url.path()).map_err(|_| ()));
+    let url_inner = Url::parse(url.path()).map_err(|_| ())?;
     let id = {
-        let mut segs = try!(url_inner.path_segments().ok_or(()));
-        let id = try!(segs.nth(0).ok_or(()));
-        try!(Uuid::from_str(id).map_err(|_| ()))
+        let mut segs = url_inner.path_segments().ok_or(())?;
+        let id = segs.nth(0).ok_or(())?;
+        Uuid::from_str(id).map_err(|_| ())?
     };
     Ok((id, get_blob_origin(&ServoUrl::from_url(url_inner))))
 }
diff --git a/components/script_traits/lib.rs b/components/script_traits/lib.rs
index 44c269c61d1..1eb94f59ae2 100644
--- a/components/script_traits/lib.rs
+++ b/components/script_traits/lib.rs
@@ -96,7 +96,7 @@ impl Serialize for UntrustedNodeAddress {
 
 impl<'de> Deserialize<'de> for UntrustedNodeAddress {
     fn deserialize<D: Deserializer<'de>>(d: D) -> Result<UntrustedNodeAddress, D::Error> {
-        let value: usize = try!(Deserialize::deserialize(d));
+        let value: usize = Deserialize::deserialize(d)?;
         Ok(UntrustedNodeAddress::from_id(value))
     }
 }
diff --git a/components/selectors/parser.rs b/components/selectors/parser.rs
index 783ba0cafbc..7877486d21c 100644
--- a/components/selectors/parser.rs
+++ b/components/selectors/parser.rs
@@ -1819,7 +1819,7 @@ pub mod tests {
                                                     -> Result<PseudoClass,
                                                               ParseError<'i, SelectorParseError<'i, ()>>> {
             match_ignore_ascii_case! { &name,
-                "lang" => Ok(PseudoClass::Lang(try!(parser.expect_ident_or_string()).into_owned())),
+                "lang" => Ok(PseudoClass::Lang(parser.expect_ident_or_string()?.into_owned())),
                 _ => Err(SelectorParseError::Custom(()).into())
             }
         }
diff --git a/components/style_traits/viewport.rs b/components/style_traits/viewport.rs
index 23802789c7c..6a353f1370c 100644
--- a/components/style_traits/viewport.rs
+++ b/components/style_traits/viewport.rs
@@ -95,18 +95,18 @@ impl ToCss for ViewportConstraints {
     fn to_css<W>(&self, dest: &mut W) -> fmt::Result
         where W: fmt::Write
     {
-        try!(write!(dest, "@viewport {{"));
-        try!(write!(dest, " width: {}px;", self.size.width));
-        try!(write!(dest, " height: {}px;", self.size.height));
-        try!(write!(dest, " zoom: {};", self.initial_zoom.get()));
+        write!(dest, "@viewport {{")?;
+        write!(dest, " width: {}px;", self.size.width)?;
+        write!(dest, " height: {}px;", self.size.height)?;
+        write!(dest, " zoom: {};", self.initial_zoom.get())?;
         if let Some(min_zoom) = self.min_zoom {
-            try!(write!(dest, " min-zoom: {};", min_zoom.get()));
+            write!(dest, " min-zoom: {};", min_zoom.get())?;
         }
         if let Some(max_zoom) = self.max_zoom {
-            try!(write!(dest, " max-zoom: {};", max_zoom.get()));
+            write!(dest, " max-zoom: {};", max_zoom.get())?;
         }
-        try!(write!(dest, " user-zoom: ")); try!(self.user_zoom.to_css(dest));
-        try!(write!(dest, "; orientation: ")); try!(self.orientation.to_css(dest));
+        write!(dest, " user-zoom: ")?; self.user_zoom.to_css(dest)?;
+        write!(dest, "; orientation: ")?; self.orientation.to_css(dest)?;
         write!(dest, "; }}")
     }
 }
@@ -144,7 +144,7 @@ impl Zoom {
         use cssparser::Token;
         use values::specified::AllowedLengthType::NonNegative;
 
-        match try!(input.next()) {
+        match input.next()? {
             // TODO: This parse() method should take ParserContext as an
             // argument, and pass ParsingMode owned by the ParserContext to
             // is_ok() instead of using PARSING_MODE_DEFAULT directly.
diff --git a/components/url/lib.rs b/components/url/lib.rs
index 98a88bb1cf6..b862e312bc2 100644
--- a/components/url/lib.rs
+++ b/components/url/lib.rs
@@ -150,7 +150,7 @@ impl ServoUrl {
     }
 
     pub fn from_file_path<P: AsRef<Path>>(path: P) -> Result<Self, ()> {
-        Ok(Self::from_url(try!(Url::from_file_path(path))))
+        Ok(Self::from_url(Url::from_file_path(path)?))
     }
 }
 
diff --git a/components/webdriver_server/keys.rs b/components/webdriver_server/keys.rs
index 8d78270acea..ce516411c75 100644
--- a/components/webdriver_server/keys.rs
+++ b/components/webdriver_server/keys.rs
@@ -172,8 +172,7 @@ pub fn keycodes_to_keys(key_codes: &[char]) -> Result<Vec<(Key, KeyModifiers, Ke
     let mut rv = vec![];
 
     for char_code in key_codes.iter() {
-        let (key, with_shift) = try!(
-            key_from_char(char_code).ok_or(format!("Unsupported character code {}", char_code)));
+        let (key, with_shift) = key_from_char(char_code).ok_or(format!("Unsupported character code {}", char_code))?;
         let modifiers = if with_shift {
             SHIFT
         } else {
diff --git a/components/webdriver_server/lib.rs b/components/webdriver_server/lib.rs
index f6e81fd5a33..bd2f667f989 100644
--- a/components/webdriver_server/lib.rs
+++ b/components/webdriver_server/lib.rs
@@ -155,15 +155,15 @@ impl WebDriverExtensionRoute for ServoExtensionRoute {
                body_data: &Json) -> WebDriverResult<WebDriverCommand<ServoExtensionCommand>> {
         let command = match *self {
             ServoExtensionRoute::GetPrefs => {
-                let parameters: GetPrefsParameters = try!(Parameters::from_json(&body_data));
+                let parameters: GetPrefsParameters = Parameters::from_json(&body_data)?;
                 ServoExtensionCommand::GetPrefs(parameters)
             }
             ServoExtensionRoute::SetPrefs => {
-                let parameters: SetPrefsParameters = try!(Parameters::from_json(&body_data));
+                let parameters: SetPrefsParameters = Parameters::from_json(&body_data)?;
                 ServoExtensionCommand::SetPrefs(parameters)
             }
             ServoExtensionRoute::ResetPrefs => {
-                let parameters: GetPrefsParameters = try!(Parameters::from_json(&body_data));
+                let parameters: GetPrefsParameters = Parameters::from_json(&body_data)?;
                 ServoExtensionCommand::ResetPrefs(parameters)
             }
         };
@@ -195,19 +195,19 @@ struct GetPrefsParameters {
 
 impl Parameters for GetPrefsParameters {
     fn from_json(body: &Json) -> WebDriverResult<GetPrefsParameters> {
-        let data = try!(body.as_object().ok_or(
+        let data = body.as_object().ok_or(
             WebDriverError::new(ErrorStatus::InvalidArgument,
-                                "Message body was not an object")));
-        let prefs_value = try!(data.get("prefs").ok_or(
+                                "Message body was not an object"))?;
+        let prefs_value = data.get("prefs").ok_or(
             WebDriverError::new(ErrorStatus::InvalidArgument,
-                                "Missing prefs key")));
-        let items = try!(prefs_value.as_array().ok_or(
+                                "Missing prefs key"))?;
+        let items = prefs_value.as_array().ok_or(
             WebDriverError::new(
                 ErrorStatus::InvalidArgument,
-                "prefs was not an array")));
-        let params = try!(items.iter().map(|x| x.as_string().map(|y| y.to_owned()).ok_or(
+                "prefs was not an array"))?;
+        let params = items.iter().map(|x| x.as_string().map(|y| y.to_owned()).ok_or(
             WebDriverError::new(ErrorStatus::InvalidArgument,
-                                "Pref is not a string"))).collect::<Result<Vec<_>, _>>());
+                                "Pref is not a string"))).collect::<Result<Vec<_>, _>>()?;
         Ok(GetPrefsParameters {
             prefs: params
         })
@@ -229,20 +229,20 @@ struct SetPrefsParameters {
 
 impl Parameters for SetPrefsParameters {
     fn from_json(body: &Json) -> WebDriverResult<SetPrefsParameters> {
-        let data = try!(body.as_object().ok_or(
+        let data = body.as_object().ok_or(
             WebDriverError::new(ErrorStatus::InvalidArgument,
-                                "Message body was not an object")));
-        let items = try!(try!(data.get("prefs").ok_or(
+                                "Message body was not an object"))?;
+        let items = data.get("prefs").ok_or(
             WebDriverError::new(ErrorStatus::InvalidArgument,
-                                "Missing prefs key"))).as_object().ok_or(
+                                "Missing prefs key"))?.as_object().ok_or(
             WebDriverError::new(
                 ErrorStatus::InvalidArgument,
-                "prefs was not an array")));
+                "prefs was not an array"))?;
         let mut params = Vec::with_capacity(items.len());
         for (name, val) in items.iter() {
-            let value = try!(PrefValue::from_json(val.clone()).or(
+            let value = PrefValue::from_json(val.clone()).or(
                 Err(WebDriverError::new(ErrorStatus::InvalidArgument,
-                                        "Pref is not a boolean or string"))));
+                                        "Pref is not a boolean or string")))?;
             let key = name.to_owned();
             params.push((key, value));
         }
@@ -702,9 +702,9 @@ impl Handler {
     fn handle_set_timeouts(&mut self,
                            parameters: &TimeoutsParameters)
                            -> WebDriverResult<WebDriverResponse> {
-        let mut session = try!(self.session
+        let mut session = self.session
             .as_mut()
-            .ok_or(WebDriverError::new(ErrorStatus::SessionNotCreated, "")));
+            .ok_or(WebDriverError::new(ErrorStatus::SessionNotCreated, ""))?;
 
         session.script_timeout = parameters.script;
         session.load_timeout = parameters.page_load;
@@ -776,11 +776,11 @@ impl Handler {
         self.constellation_chan.send(ConstellationMsg::WebDriverCommand(cmd_msg)).unwrap();
 
         // TODO: distinguish the not found and not focusable cases
-        try!(receiver.recv().unwrap().or_else(|_| Err(WebDriverError::new(
-            ErrorStatus::StaleElementReference, "Element not found or not focusable"))));
+        receiver.recv().unwrap().or_else(|_| Err(WebDriverError::new(
+            ErrorStatus::StaleElementReference, "Element not found or not focusable")))?;
 
-        let keys = try!(keycodes_to_keys(&keys.value).or_else(|_|
-            Err(WebDriverError::new(ErrorStatus::UnsupportedOperation, "Failed to convert keycodes"))));
+        let keys = keycodes_to_keys(&keys.value).or_else(|_|
+            Err(WebDriverError::new(ErrorStatus::UnsupportedOperation, "Failed to convert keycodes")))?;
 
         // TODO: there's a race condition caused by the focus command and the
         // send keys command being two separate messages,
@@ -870,7 +870,7 @@ impl WebDriverHandler<ServoExtensionRoute> for Handler {
         match msg.command {
             WebDriverCommand::NewSession(_) => {},
             _ => {
-                try!(self.session());
+                self.session()?;
             }
         }
 
diff --git a/tests/unit/net/mime_classifier.rs b/tests/unit/net/mime_classifier.rs
index c5393b46d9e..e8622b94b84 100644
--- a/tests/unit/net/mime_classifier.rs
+++ b/tests/unit/net/mime_classifier.rs
@@ -11,10 +11,10 @@ use std::io::{self, Read};
 use std::path::{self, PathBuf};
 
 fn read_file(path: &path::Path) -> io::Result<Vec<u8>> {
-    let mut file = try!(File::open(path));
+    let mut file = File::open(path)?;
     let mut buffer = Vec::new();
 
-    try!(file.read_to_end(&mut buffer));
+    file.read_to_end(&mut buffer)?;
 
     Ok(buffer)
 }