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 kBlocklistExcludeReadsCharacteristicUUID[] =
     "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/12/02 06:14:50]

s/blacklist/blocklist/

[dougt, 2016/12/02 18:31:28]

Done.

+const char kClientConfigUUID[] = "2902";
 
 // 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
+void LayoutTestBluetoothAdapterProvider::AddDescriptorsToCharacteristic(

[ortuno, 2016/12/02 06:14:50]

Given that this will only be used in one place (see note below), I think we
should just inline it.

[dougt, 2016/12/02 18:31:28]

Acknowledged.

I was thinking that it might be needed in more places as we implemented
read|write.  I can add a inline if you think it matters.

[ortuno, 2016/12/07 08:05:12]

hmm I can't see us using this but maybe I'm missing something. So there are
three adapters that will need descriptors:

1. GetDisconnectingHealthThermometer
2. GetGATTOperationFinishesAfterReconnectionAdapter
3. GetFailingGATTOperationsAdapter

The descriptors in the those adapters are pretty different. The first one needs
write/read to succeed and the second needs to queue the requests and run them
after reconnection and the third one needs read/writes to fail.

+    device::MockBluetoothGattCharacteristic* characteristic) {
+  std::unique_ptr<NiceMockBluetoothGattDescriptor> user_description(
+      new NiceMockBluetoothGattDescriptor(
+          characteristic, "user_description",
+          BluetoothUUID(kUserDescriptionUUID), false,
+          device::BluetoothGattCharacteristic::Permission::PERMISSION_READ));
 
-  adapter->AddMockDevice(std::move(device));
+  std::unique_ptr<NiceMockBluetoothGattDescriptor> client_config(
+      new NiceMockBluetoothGattDescriptor(
+          characteristic, "client_characteristic_configuration",
+          BluetoothUUID(kClientConfigUUID), false,
+          device::BluetoothGattCharacteristic::Permission::PERMISSION_WRITE));
 
-  return adapter;
+  ON_CALL(*client_config, ReadRemoteDescriptor(_, _))

[ortuno, 2016/12/02 06:14:50]

No need for Write/Read yet.

[dougt, 2016/12/02 18:31:28]

Done.

+      .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(_, _, _))

[ortuno, 2016/12/02 06:14:50]

Rather than succeeding this should DCHECK. See other blocklisted operations.

[dougt, 2016/12/02 18:31:28]

Acknowledged.  Removing as we're not doing write in this cl.

+      .WillByDefault(RunCallback<1 /* success callback */>());
+
+  ON_CALL(*characteristic, GetDescriptors())

[ortuno, 2016/12/02 06:14:50]

Add these to GetBaseGATTCharacteristic so that all characteristics have these
methods.

[dougt, 2016/12/02 18:31:28]

Done.

+      .WillByDefault(
+          Invoke(characteristic,
+                 &MockBluetoothGattCharacteristic::GetMockDescriptors));
+
+  ON_CALL(*characteristic, GetDescriptor(_))
+      .WillByDefault(Invoke(
+          characteristic, &MockBluetoothGattCharacteristic::GetMockDescriptor));
+
+  characteristic->AddMockDescriptor(std::move(user_description));
+  characteristic->AddMockDescriptor(std::move(client_config));
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetDisconnectingHealthThermometer() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
   NiceMockBluetoothAdapter* adapter_ptr = adapter.get();
 
   std::unique_ptr<NiceMockBluetoothDevice> device(GetConnectableDevice(
       adapter_ptr, "Disconnecting Health Thermometer",
@@ skipping 31 matching lines @@
 
   ON_CALL(*measurement_interval, WriteRemoteCharacteristic(_, _, _))
       .WillByDefault(RunCallback<1 /* success_callback */>());
 
   ON_CALL(*measurement_interval, StartNotifySession(_, _))
       .WillByDefault(
           RunCallbackWithResult<0 /* success_callback */>([measurement_ptr]() {
             return GetBaseGATTNotifySession(measurement_ptr->GetWeakPtr());
           }));
 
+  AddDescriptorsToCharacteristic(measurement_interval.get());
+
   health_thermometer->AddMockCharacteristic(std::move(measurement_interval));
   device->AddMockService(std::move(health_thermometer));
 
   adapter->AddMockDevice(std::move(device));
 
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
@@ skipping 274 matching lines @@
         device_ptr->PushPendingCallback(pending);
         if (disconnect) {
           device_ptr->SetConnected(false);
           base::ThreadTaskRunnerHandle::Get()->PostTask(
               FROM_HERE,
               base::Bind(&NotifyDeviceChanged, base::RetainedRef(adapter_ptr),
                          device_ptr));
         }
       }));
 
+  AddDescriptorsToCharacteristic(measurement_interval.get());

[ortuno, 2016/12/02 06:14:50]

I don't think this applies here. When you read/write to a descriptor in this
adapter the callback gets queued. Once you disconnect and then reconnect we
succeed/fail the request.

[dougt, 2016/12/02 18:31:28]

Done.

+
   health_thermometer->AddMockCharacteristic(std::move(measurement_interval));
   device->AddMockService(std::move(health_thermometer));
   adapter->AddMockDevice(std::move(device));
   return adapter;
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter> LayoutTestBluetoothAdapterProvider::
     GetStopNotifySessionFinishesAfterReconnectionAdapter(bool disconnect) {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
@@ skipping 654 matching lines @@
   return BluetoothUUID();
 }
 
 // static
 std::string LayoutTestBluetoothAdapterProvider::makeMACAddress(uint64_t addr) {
   return BluetoothDevice::CanonicalizeAddress(
       base::StringPrintf("%012" PRIx64, addr));
 }
 
 }  // namespace content