Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-06-06 16:45:39 +00:00
Code Issues Projects Releases Packages Wiki Activity

Untry

Browse source
This commit is contained in:
Simon Sapin 2017-06-18 13:21:04 +02:00
parent 7af5a7fd54
commit 316cd35767
34 changed files with 261 additions and 264 deletions
Download patch file Download diff file Expand all files Collapse all files

16
components/bluetooth/lib.rs
View file

@ -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 {

250
components/bluetooth/test.rs
View file

@ -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())),
}

8
components/canvas/webgl_paint_thread.rs
View file

@ -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);

12
components/config/prefs.rs
View file

@ -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)
}

10
components/config/resource_files.rs
View file

@ -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)
}

4
components/constellation/pipeline.rs
View file

@ -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(())
}

2
components/devtools/actor.rs
View file

@ -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);

4
components/devtools/actors/console.rs
View file

@ -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()));

8
components/devtools/actors/inspector.rs
View file

@ -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);

4
components/gfx/font_context.rs
View file

@ -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))
}

8
components/gfx/font_template.rs
View file

@ -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)
}

4
components/gfx/platform/freetype/android/font_list.rs
View file

@ -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)
}

2
components/gfx/platform/freetype/font.rs
View file

@ -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)
}

2
components/gfx/platform/freetype/font_template.rs
View file

@ -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

6
components/gfx/platform/windows/font.rs
View file

@ -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)
};

12
components/gfx/text/glyph.rs
View file

@ -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(())
}

4
components/layout/floats.rs
View file

@ -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(())
}

14
components/layout/flow.rs
View file

@ -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()
}
}

4
components/layout/flow_list.rs
View file

@ -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()
}

8
components/layout/fragment.rs
View file

@ -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()
}
}

6
components/layout_thread/lib.rs
View file

@ -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,

2
components/net/connector.rs
View file

@ -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))

20
components/net/filemanager_thread.rs
View file

@ -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 {

4
components/net/http_loader.rs
View file

@ -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 &&

4
components/net/image_cache.rs
View file

@ -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))

18
components/net/mime_classifier.rs
View file

@ -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(())
}

8
components/net_traits/blob_url_store.rs
View file

@ -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))))
}

2
components/script_traits/lib.rs
View file

@ -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))
}
}

2
components/selectors/parser.rs
View file

@ -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())
}
}

18
components/style_traits/viewport.rs
View file

@ -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.

2
components/url/lib.rs
View file

@ -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)?))
}
}

3
components/webdriver_server/keys.rs
View file

@ -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 {

50
components/webdriver_server/lib.rs
View file

@ -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()?;
}
}

4
tests/unit/net/mime_classifier.rs
View file

@ -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)
}