Implement WebBluetooth getDescriptor[s]

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"
 #include "base/format_macros.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_device.h"
 #include "device/bluetooth/bluetooth_discovery_session.h"
 #include "device/bluetooth/bluetooth_uuid.h"
 #include "device/bluetooth/test/mock_bluetooth_adapter.h"
 #include "device/bluetooth/test/mock_bluetooth_discovery_session.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_connection.h"
+#include "device/bluetooth/test/mock_bluetooth_gatt_descriptor.h"
 #include "device/bluetooth/test/mock_bluetooth_gatt_notify_session.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using base::StringPiece;
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
+using device::BluetoothGattCharacteristic;
 using device::BluetoothRemoteGattCharacteristic;
+using device::BluetoothRemoteGattDescriptor;
 using device::BluetoothRemoteGattService;
 using device::BluetoothUUID;
 using device::MockBluetoothAdapter;
 using device::MockBluetoothDevice;
 using device::MockBluetoothDiscoverySession;
 using device::MockBluetoothGattCharacteristic;
 using device::MockBluetoothGattConnection;
+using device::MockBluetoothGattDescriptor;
 using device::MockBluetoothGattNotifySession;
 using device::MockBluetoothGattService;
 using testing::ElementsAre;
 using testing::Invoke;
 using testing::InvokeWithoutArgs;
 using testing::ResultOf;
 using testing::Return;
 using testing::_;
 
 typedef testing::NiceMock<MockBluetoothAdapter> NiceMockBluetoothAdapter;
 typedef testing::NiceMock<MockBluetoothDevice> NiceMockBluetoothDevice;
 typedef testing::NiceMock<MockBluetoothDiscoverySession>
     NiceMockBluetoothDiscoverySession;
+typedef testing::NiceMock<MockBluetoothGattDescriptor>
+    NiceMockBluetoothGattDescriptor;
 typedef testing::NiceMock<MockBluetoothGattCharacteristic>
     NiceMockBluetoothGattCharacteristic;
 typedef testing::NiceMock<MockBluetoothGattConnection>
     NiceMockBluetoothGattConnection;
 typedef testing::NiceMock<MockBluetoothGattService>
     NiceMockBluetoothGattService;
 typedef testing::NiceMock<MockBluetoothGattNotifySession>
     NiceMockBluetoothGattNotifySession;
 
 namespace {
@@ skipping 14 matching lines @@
 const char kBlacklistExcludeReadsCharacteristicUUID[] =
     "bad1c9a2-9a5b-4015-8b60-1579bbbf2135";
 const char kRequestDisconnectionCharacteristicUUID[] =
     "01d7d88a-7451-419f-aeb8-d65e7b9277af";
 const char kBodySensorLocation[] = "2a38";
 const char kDeviceNameUUID[] = "2a00";
 const char kMeasurementIntervalUUID[] = "2a21";
 const char kHeartRateMeasurementUUID[] = "2a37";
 const char kSerialNumberStringUUID[] = "2a25";
 const char kPeripheralPrivacyFlagUUID[] = "2a02";
+// Descriptors:
+const char kUserDescriptionUUID[] = "2901";
+// client config is in our blacklist.  it must not be writable

[ortuno, 2016/11/21 03:34:08]

s/client/Client/ and s/it/It/

[dougt, 2016/11/22 01:47:16]

Acknowledged.

+const char kClientConfigUUID[] = "00002902-0000-1000-8000-00805f9b34fb";

[ortuno, 2016/11/21 03:34:08]

Since it's a standard service you don't need the suffix; 2902 should be enough.

[dougt, 2016/11/22 01:47:16]

Acknowledged.

 
 // Invokes Run() on the k-th argument of the function with no arguments.
 ACTION_TEMPLATE(RunCallback,
                 HAS_1_TEMPLATE_PARAMS(int, k),
                 AND_0_VALUE_PARAMS()) {
   return ::testing::get<k>(args).Run();
 }
 
 // Invokes Run() on the k-th argument of the function with 1 argument.
 ACTION_TEMPLATE(RunCallback,
@@ skipping 546 matching lines @@
 LayoutTestBluetoothAdapterProvider::GetHeartRateAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
   std::unique_ptr<NiceMockBluetoothDevice> device(
       GetHeartRateDevice(adapter.get()));
 
   // TODO(ortuno): Implement the rest of the service's characteristics
   // See: http://crbug.com/529975
 
   device->AddMockService(GetGenericAccessService(device.get()));
   device->AddMockService(GetHeartRateService(adapter.get(), device.get()));
-
   adapter->AddMockDevice(std::move(device));
-
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetDisconnectingHealthThermometer() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
   NiceMockBluetoothAdapter* adapter_ptr = adapter.get();
 
   std::unique_ptr<NiceMockBluetoothDevice> device(GetConnectableDevice(
@@ skipping 442 matching lines @@
     error++) {
     adapter->AddMockDevice(GetUnconnectableDevice(
         adapter.get(), static_cast<BluetoothDevice::ConnectErrorCode>(error)));
   }
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetFailingGATTOperationsAdapter() {

[ortuno, 2016/11/21 03:34:08]

Also add descriptors to the device in this adapter.

   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
 
   const std::string errorsServiceUUID = errorUUID(0xA0);
 
   BluetoothDevice::UUIDList uuids;
   uuids.push_back(BluetoothUUID(errorsServiceUUID));
 
   std::unique_ptr<NiceMockBluetoothDevice> device(
       GetConnectableDevice(adapter.get(), "Errors Device", uuids));
 
@@ skipping 316 matching lines @@
 
             std::vector<uint8_t> rate(1 /* size */);
             rate[0] = 60;
 
             notify_session->StartTestNotifications(adapter, measurement_ptr,
                                                    rate);
 
             return notify_session;
           }));
 
+  // Enable descriptors on the heart_rate_measurement
+  ON_CALL(*heart_rate_measurement, GetDescriptors())
+      .WillByDefault(
+          Invoke(measurement_ptr,
+                 &MockBluetoothGattCharacteristic::GetMockDescriptors));
+
+  ON_CALL(*heart_rate_measurement, GetDescriptor(_))
+      .WillByDefault(
+          Invoke(measurement_ptr,
+                 &MockBluetoothGattCharacteristic::GetMockDescriptor));
+
   // Body Sensor Location Characteristic (Chest)
   std::unique_ptr<NiceMockBluetoothGattCharacteristic>
       body_sensor_location_chest(GetBaseGATTCharacteristic(
           "Body Sensor Location Chest", heart_rate.get(), kBodySensorLocation,
           BluetoothRemoteGattCharacteristic::PROPERTY_READ));
   BluetoothRemoteGattCharacteristic* location_chest_ptr =
       body_sensor_location_chest.get();
 
   ON_CALL(*body_sensor_location_chest, ReadRemoteCharacteristic(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
@@ skipping 24 matching lines @@
             location[0] = 2;  // Wrist
             // Read a characteristic has a side effect of
             // GattCharacteristicValueChanged being called.
             for (auto& observer : adapter->GetObservers()) {
               observer.GattCharacteristicValueChanged(
                   adapter, location_wrist_ptr, location);
             }
             return location;
           }));
 
+  // Add two descriptors on the heart rate.  One for user description, and one

[ortuno, 2016/11/21 03:34:08]

I would add these to DisconnectingHealthThermometer instead. 

1. We started with heart rate adapter which had one characteristic for read, one
for write and one for notifications. But we then found out about health
thermometer which has a single characteristic that does read, write and
notifications. I want to eventually move all tests to use health thermometer
device.
2. You will need the disconnection characteristic for some tests.

Also instead of user description I would use valid_range which is an actual
descriptor of measurement interval.

Also don't forget to update the docs in the .h file!

[dougt, 2016/11/29 22:50:48]

Done.

+  // for client configuration.  Client configuration is blacklisted for writes.
+  std::unique_ptr<NiceMockBluetoothGattDescriptor> user_description(
+      new NiceMockBluetoothGattDescriptor(
+          heart_rate_measurement.get(), "user_description",
+          BluetoothUUID(kUserDescriptionUUID), false,
+          device::BluetoothGattCharacteristic::Permission::PERMISSION_READ));
+
+  // this descriptor is not allowed to be written.
+  std::unique_ptr<NiceMockBluetoothGattDescriptor> client_config(
+      new NiceMockBluetoothGattDescriptor(
+          heart_rate_measurement.get(), "client_characteristic_configuration",
+          BluetoothUUID(kClientConfigUUID), false,
+          device::BluetoothGattCharacteristic::Permission::PERMISSION_WRITE));
+
+  ON_CALL(*client_config, ReadRemoteDescriptor(_, _))
+      .WillByDefault(Invoke(
+          [](const BluetoothRemoteGattDescriptor::ValueCallback& callback,
+             const BluetoothRemoteGattDescriptor::ErrorCallback&) {
+            std::vector<uint8_t> value({1});
+            callback.Run(value);
+          }));
+
+  // Default write that returns success.  This is used to test blacklist
+  // handling of writes.
+  ON_CALL(*client_config, WriteRemoteDescriptor(_, _, _))
+      .WillByDefault(RunCallback<1 /* success callback */>());
+
+  heart_rate_measurement->AddMockDescriptor(std::move(user_description));
+  heart_rate_measurement->AddMockDescriptor(std::move(client_config));
+
   heart_rate->AddMockCharacteristic(std::move(heart_rate_measurement));
   heart_rate->AddMockCharacteristic(std::move(body_sensor_location_chest));
   heart_rate->AddMockCharacteristic(std::move(body_sensor_location_wrist));
 
   return heart_rate;
 }
 
 // static
 std::unique_ptr<NiceMockBluetoothGattService>
 LayoutTestBluetoothAdapterProvider::GetDisconnectingService(
@@ skipping 157 matching lines @@
   return BluetoothUUID();
 }
 
 // static
 std::string LayoutTestBluetoothAdapterProvider::makeMACAddress(uint64_t addr) {
   return BluetoothDevice::CanonicalizeAddress(
       base::StringPrintf("%012" PRIx64, addr));
 }
 
 }  // namespace content