bluetooth: Implement Service.getCharacteristics

content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/shell/browser/layout_test/layout_test_bluetooth_adapter_provider.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 706 matching lines @@
 
 // static
 scoped_ptr<NiceMockBluetoothGattService>
 LayoutTestBluetoothAdapterProvider::GetBlacklistTestService(
     device::MockBluetoothDevice* device) {
   scoped_ptr<NiceMockBluetoothGattService> blacklist_test_service(
       GetBaseGATTService(device, kBlacklistTestServiceUUID));
 
   scoped_ptr<NiceMockBluetoothGattCharacteristic>
       blacklist_exclude_reads_characteristic(GetBaseGATTCharacteristic(
-          blacklist_test_service.get(),
+          "Excluded Reads Characteristic", blacklist_test_service.get(),
           kBlacklistExcludeReadsCharacteristicUUID,
           BluetoothGattCharacteristic::PROPERTY_READ |
               BluetoothGattCharacteristic::PROPERTY_WRITE));
 
   // Crash if ReadRemoteCharacteristic called. Not using GoogleMock's Expect
   // because this is used in layout tests that may not report a mock expectation
   // error correctly as a layout test failure.
   ON_CALL(*blacklist_exclude_reads_characteristic,
           ReadRemoteCharacteristic(_, _))
       .WillByDefault(
@@ skipping 14 matching lines @@
 }
 
 // static
 scoped_ptr<NiceMockBluetoothGattService>
 LayoutTestBluetoothAdapterProvider::GetDeviceInformationService(
     device::MockBluetoothDevice* device) {
   scoped_ptr<NiceMockBluetoothGattService> device_information(
       GetBaseGATTService(device, kDeviceInformationServiceUUID));
 
   scoped_ptr<NiceMockBluetoothGattCharacteristic> serial_number_string(
-      GetBaseGATTCharacteristic(device_information.get(),
-                                kSerialNumberStringUUID,
-                                BluetoothGattCharacteristic::PROPERTY_READ));
+      GetBaseGATTCharacteristic(
+          "Serial Number String", device_information.get(),
+          kSerialNumberStringUUID, BluetoothGattCharacteristic::PROPERTY_READ));
 
   // Crash if ReadRemoteCharacteristic called. Not using GoogleMock's Expect
   // because this is used in layout tests that may not report a mock expectation
   // error correctly as a layout test failure.
   ON_CALL(*serial_number_string, ReadRemoteCharacteristic(_, _))
       .WillByDefault(
           Invoke([](const BluetoothGattCharacteristic::ValueCallback&,
                     const BluetoothGattCharacteristic::ErrorCallback&) {
             NOTREACHED();
           }));
 
   device_information->AddMockCharacteristic(std::move(serial_number_string));
 
   return device_information;
 }
 
 // static
 scoped_ptr<NiceMockBluetoothGattService>
 LayoutTestBluetoothAdapterProvider::GetGenericAccessService(
     device::MockBluetoothDevice* device) {
   scoped_ptr<NiceMockBluetoothGattService> generic_access(
       GetBaseGATTService(device, kGenericAccessServiceUUID));
 
   {  // Device Name:
     scoped_ptr<NiceMockBluetoothGattCharacteristic> device_name(
         GetBaseGATTCharacteristic(
-            generic_access.get(), kDeviceNameUUID,
+            "Device Name", generic_access.get(), kDeviceNameUUID,
             BluetoothGattCharacteristic::PROPERTY_READ |
                 BluetoothGattCharacteristic::PROPERTY_WRITE));
 
     // Read response.
     std::string device_name_str = device->GetDeviceName();
     std::vector<uint8_t> device_name_value(device_name_str.begin(),
                                            device_name_str.end());
 
     ON_CALL(*device_name, ReadRemoteCharacteristic(_, _))
         .WillByDefault(RunCallback<0>(device_name_value));
 
     // Write response.
     ON_CALL(*device_name, WriteRemoteCharacteristic(_, _, _))
         .WillByDefault(RunCallback<1 /* success callback */>());
 
     generic_access->AddMockCharacteristic(std::move(device_name));
   }
 
   {  // Peripheral Privacy Flag:
     scoped_ptr<NiceMockBluetoothGattCharacteristic> peripheral_privacy_flag(
         GetBaseGATTCharacteristic(
-            generic_access.get(), kPeripheralPrivacyFlagUUID,
+            "Peripheral Privacy Flag", generic_access.get(),
+            kPeripheralPrivacyFlagUUID,
             BluetoothGattCharacteristic::PROPERTY_READ |
                 BluetoothGattCharacteristic::PROPERTY_WRITE));
 
     // Read response.
     std::vector<uint8_t> value(1);
     value[0] = false;
 
     ON_CALL(*peripheral_privacy_flag, ReadRemoteCharacteristic(_, _))
         .WillByDefault(RunCallback<0>(value));
 
@@ skipping 16 matching lines @@
 // static
 scoped_ptr<NiceMockBluetoothGattService>
 LayoutTestBluetoothAdapterProvider::GetHeartRateService(
     MockBluetoothAdapter* adapter,
     MockBluetoothDevice* device) {
   scoped_ptr<NiceMockBluetoothGattService> heart_rate(
       GetBaseGATTService(device, kHeartRateServiceUUID));
 
   // Heart Rate Measurement
   scoped_ptr<NiceMockBluetoothGattCharacteristic> heart_rate_measurement(
-      GetBaseGATTCharacteristic(heart_rate.get(), kHeartRateMeasurementUUID,
+      GetBaseGATTCharacteristic("Heart Rate Measurement", heart_rate.get(),
+                                kHeartRateMeasurementUUID,
                                 BluetoothGattCharacteristic::PROPERTY_NOTIFY));
   NiceMockBluetoothGattCharacteristic* measurement_ptr =
       heart_rate_measurement.get();
 
   ON_CALL(*heart_rate_measurement, StartNotifySession(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
           [adapter, measurement_ptr]() {
             scoped_ptr<NiceMockBluetoothGattNotifySession> notify_session(
                 GetBaseGATTNotifySession(measurement_ptr->GetIdentifier()));
 
             std::vector<uint8_t> rate(1 /* size */);
             rate[0] = 60;
 
             notify_session->StartTestNotifications(adapter, measurement_ptr,
                                                    rate);
 
             return notify_session;
           }));
 
-  // Body Sensor Location Characteristic
-  scoped_ptr<NiceMockBluetoothGattCharacteristic> body_sensor_location(
-      GetBaseGATTCharacteristic(heart_rate.get(), kBodySensorLocation,
+  // Body Sensor Location Characteristic (Chest)
+  scoped_ptr<NiceMockBluetoothGattCharacteristic> body_sensor_location_chest(
+      GetBaseGATTCharacteristic("Body Sensor Location Chest", heart_rate.get(),
+                                kBodySensorLocation,
                                 BluetoothGattCharacteristic::PROPERTY_READ));
-  BluetoothGattCharacteristic* location_ptr = body_sensor_location.get();
+  BluetoothGattCharacteristic* location_chest_ptr =
+      body_sensor_location_chest.get();
 
-  ON_CALL(*body_sensor_location, ReadRemoteCharacteristic(_, _))
+  ON_CALL(*body_sensor_location_chest, ReadRemoteCharacteristic(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
-          [adapter, location_ptr]() {
+          [adapter, location_chest_ptr]() {
             std::vector<uint8_t> location(1 /* size */);
             location[0] = 1;  // Chest
             // Read a characteristic has a side effect of
             // GattCharacteristicValueChanged being called.
             FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
                               adapter->GetObservers(),
                               GattCharacteristicValueChanged(
-                                  adapter, location_ptr, location));
+                                  adapter, location_chest_ptr, location));
+            return location;
+          }));
+
+  // Body Sensor Location Characteristic (Wrist)
+  scoped_ptr<NiceMockBluetoothGattCharacteristic> body_sensor_location_wrist(
+      GetBaseGATTCharacteristic("Body Sensor Location Wrist", heart_rate.get(),
+                                kBodySensorLocation,
+                                BluetoothGattCharacteristic::PROPERTY_READ));
+  BluetoothGattCharacteristic* location_wrist_ptr =
+      body_sensor_location_wrist.get();
+
+  ON_CALL(*body_sensor_location_wrist, ReadRemoteCharacteristic(_, _))
+      .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
+          [adapter, location_wrist_ptr]() {
+            std::vector<uint8_t> location(1 /* size */);
+            location[0] = 2;  // Wrist
+            // Read a characteristic has a side effect of
+            // GattCharacteristicValueChanged being called.
+            FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
+                              adapter->GetObservers(),
+                              GattCharacteristicValueChanged(
+                                  adapter, location_wrist_ptr, location));
             return location;
           }));
 
   heart_rate->AddMockCharacteristic(std::move(heart_rate_measurement));
-  heart_rate->AddMockCharacteristic(std::move(body_sensor_location));
+  heart_rate->AddMockCharacteristic(std::move(body_sensor_location_chest));
+  heart_rate->AddMockCharacteristic(std::move(body_sensor_location_wrist));
 
   return heart_rate;
 }
 
 // Characteristics
 
 // static
 scoped_ptr<NiceMockBluetoothGattCharacteristic>
 LayoutTestBluetoothAdapterProvider::GetBaseGATTCharacteristic(
+    const std::string& identifier,
     MockBluetoothGattService* service,
     const std::string& uuid,
     BluetoothGattCharacteristic::Properties properties) {
   return make_scoped_ptr(new NiceMockBluetoothGattCharacteristic(
-      service, uuid + " Identifier", BluetoothUUID(uuid), false /* is_local */,
+      service, identifier, BluetoothUUID(uuid), false /* is_local */,
       properties, NULL /* permissions */));
 }
 
 // static
 scoped_ptr<NiceMockBluetoothGattCharacteristic>
 LayoutTestBluetoothAdapterProvider::GetErrorCharacteristic(
     MockBluetoothGattService* service,
     BluetoothGattService::GattErrorCode error_code) {
   uint32_t error_alias = error_code + 0xA1;  // Error UUIDs start at 0xA1.
   scoped_ptr<NiceMockBluetoothGattCharacteristic> characteristic(
       GetBaseGATTCharacteristic(
-          service,
+          // Use the UUID to generate unique identifiers.
+          "Error Characteristic " + errorUUID(error_alias), service,
           errorUUID(error_alias),
           BluetoothGattCharacteristic::PROPERTY_READ |
-          BluetoothGattCharacteristic::PROPERTY_WRITE |
-          BluetoothGattCharacteristic::PROPERTY_INDICATE));
-
+              BluetoothGattCharacteristic::PROPERTY_WRITE |
+              BluetoothGattCharacteristic::PROPERTY_INDICATE));
 
   // Read response.
   ON_CALL(*characteristic, ReadRemoteCharacteristic(_, _))
       .WillByDefault(RunCallback<1 /* error_callback */>(error_code));
 
   // Write response.
   ON_CALL(*characteristic, WriteRemoteCharacteristic(_, _, _))
       .WillByDefault(RunCallback<2 /* error_callback */>(error_code));
 
   // StartNotifySession response
@@ skipping 74 matching lines @@
   return BluetoothUUID();
 }
 
 // static
 std::string LayoutTestBluetoothAdapterProvider::makeMACAddress(uint64_t addr) {
   return BluetoothDevice::CanonicalizeAddress(
       base::StringPrintf("%012" PRIx64, addr));
 }
 
 }  // namespace content