Implement WebBluetooth descriptor.readValue()

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 79 matching lines @@
 const char kHeartRateMeasurementUUID[] = "2a37";
 const char kSerialNumberStringUUID[] = "2a25";
 const char kPeripheralPrivacyFlagUUID[] = "2a02";
 // Descriptors:
 const char kUserDescriptionUUID[] = "2901";
 // Client Config is in our blocklist.  It must not be writable
 const char kClientConfigUUID[] = "2902";
 // Blocklisted descriptor
 const char kBlocklistedDescriptorUUID[] =
     "bad2ddcf-60db-45cd-bef9-fd72b153cf7c";
+const char kBlocklistedReadDescriptorUUID[] =
+    "bad3ec61-3cc3-4954-9702-7977df514114";
+const char kCharacteristicUserDescription[] =
+    "gatt.characteristic_user_description";
 
 // 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 43 matching lines @@
     observer.GattServicesDiscovered(adapter, device);
 }
 
 // Notifies the adapter's observers that a device has changed.
 void NotifyDeviceChanged(MockBluetoothAdapter* adapter,
                          MockBluetoothDevice* device) {
   for (auto& observer : adapter->GetObservers())
     observer.DeviceChanged(adapter, device);
 }
 
-void PerformReadValue(
+void PerformCharacteristicReadValue(
     MockBluetoothAdapter* adapter,
     MockBluetoothGattCharacteristic* characteristic,
     const BluetoothRemoteGattCharacteristic::ValueCallback& callback,
     const std::vector<uint8_t>& value) {
   for (auto& observer : adapter->GetObservers()) {
     observer.GattCharacteristicValueChanged(adapter, characteristic, value);
   }
   callback.Run(value);
 }
 
+void PerformDescriptorReadValue(
+    MockBluetoothAdapter* adapter,
+    MockBluetoothGattDescriptor* descriptor,
+    const BluetoothRemoteGattDescriptor::ValueCallback& callback,
+    const std::vector<uint8_t>& value) {
+  for (auto& observer : adapter->GetObservers()) {
+    observer.GattDescriptorValueChanged(adapter, descriptor, value);
+  }
+  callback.Run(value);
+}
+
 }  // namespace
 
 namespace content {
 
 // static
 scoped_refptr<BluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetBluetoothAdapter(
     const std::string& fake_adapter_name) {
   if (fake_adapter_name == "BaseAdapter")
     return GetBaseAdapter();
@@ skipping 25 matching lines @@
     return GetNoNameDeviceAdapter();
   if (fake_adapter_name == "EmptyNameHeartRateAdapter")
     return GetEmptyNameHeartRateAdapter();
   if (fake_adapter_name == "NoNameHeartRateAdapter")
     return GetNoNameHeartRateAdapter();
   if (fake_adapter_name == "TwoHeartRateServicesAdapter")
     return GetTwoHeartRateServicesAdapter();
   if (fake_adapter_name == "DisconnectingHeartRateAdapter")
     return GetDisconnectingHeartRateAdapter();
   if (fake_adapter_name == "DisconnectingHealthThermometerAdapter")
-    return GetDisconnectingHealthThermometer();
+    return GetDisconnectingHealthThermometer(true);
+  if (fake_adapter_name ==
+      "MissingDescriptorsDisconnectingHealthThermometerAdapter")
+    return GetDisconnectingHealthThermometer(false);
   if (fake_adapter_name == "DisconnectingDuringServiceRetrievalAdapter")
     return GetServicesDiscoveredAfterReconnectionAdapter(true /* disconnect */);
   if (fake_adapter_name == "ServicesDiscoveredAfterReconnectionAdapter")
     return GetServicesDiscoveredAfterReconnectionAdapter(
         false /* disconnect */);
   if (fake_adapter_name == "DisconnectingDuringSuccessGATTOperationAdapter") {
     return GetGATTOperationFinishesAfterReconnectionAdapter(
         true /* disconnect */, true /* succeeds */);
   }
   if (fake_adapter_name == "DisconnectingDuringFailureGATTOperationAdapter") {
@@ skipping 442 matching lines @@
   // 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() {
+LayoutTestBluetoothAdapterProvider::GetDisconnectingHealthThermometer(
+    bool add_descriptors) {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
   NiceMockBluetoothAdapter* adapter_ptr = adapter.get();
 
   auto device(GetConnectableDevice(
       adapter_ptr, "Disconnecting Health Thermometer",
       std::vector<BluetoothUUID>({BluetoothUUID(kGenericAccessServiceUUID),
                                   BluetoothUUID(kHealthThermometerUUID)})));
 
   device->AddMockService(GetGenericAccessService(device.get()));
   device->AddMockService(GetDisconnectingService(adapter.get(), device.get()));
@@ skipping 24 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());
           }));
 
-  auto user_description = base::MakeUnique<NiceMockBluetoothGattDescriptor>(
-      measurement_interval.get(), "gatt.characteristic_user_description",
-      BluetoothUUID(kUserDescriptionUUID), false,
-      device::BluetoothRemoteGattCharacteristic::PROPERTY_READ);
+  if (add_descriptors) {
+    const std::string descriptorName = kCharacteristicUserDescription;
+    auto user_description = base::MakeUnique<NiceMockBluetoothGattDescriptor>(
+        measurement_interval.get(), descriptorName,
+        BluetoothUUID(kUserDescriptionUUID), false /* is_local */,
+        device::BluetoothRemoteGattCharacteristic::PROPERTY_READ);
 
-  auto client_config = base::MakeUnique<NiceMockBluetoothGattDescriptor>(
-      measurement_interval.get(), "gatt.client_characteristic_configuration",
-      BluetoothUUID(kClientConfigUUID), false,
-      device::BluetoothRemoteGattCharacteristic::PROPERTY_READ |
-          device::BluetoothRemoteGattCharacteristic::PROPERTY_WRITE);
+    ON_CALL(*user_description, ReadRemoteDescriptor(_, _))
+        .WillByDefault(Invoke([descriptorName](
+            const BluetoothRemoteGattDescriptor::ValueCallback& callback,
+            const BluetoothRemoteGattDescriptor::ErrorCallback&) {
+          std::vector<uint8_t> value(descriptorName.begin(),
+                                     descriptorName.end());
+          callback.Run(value);
+        }));
 
-  // Add it here with full permission as the blocklist should prevent us from
-  // accessing this descriptor
-  auto blocklisted_descriptor =
-      base::MakeUnique<NiceMockBluetoothGattDescriptor>(
-          measurement_interval.get(), "bad2ddcf-60db-45cd-bef9-fd72b153cf7c",
-          BluetoothUUID(kBlocklistedDescriptorUUID), false,
-          device::BluetoothRemoteGattCharacteristic::PROPERTY_READ |
-              device::BluetoothRemoteGattCharacteristic::PROPERTY_WRITE);
+    auto client_config = base::MakeUnique<NiceMockBluetoothGattDescriptor>(
+        measurement_interval.get(), "gatt.client_characteristic_configuration",
+        BluetoothUUID(kClientConfigUUID), false /* is_local */,
+        device::BluetoothRemoteGattCharacteristic::PROPERTY_READ |
+            device::BluetoothRemoteGattCharacteristic::PROPERTY_WRITE);
 
-  measurement_interval->AddMockDescriptor(std::move(user_description));
-  measurement_interval->AddMockDescriptor(std::move(client_config));
-  measurement_interval->AddMockDescriptor(std::move(blocklisted_descriptor));
+    auto no_read_descriptor = base::MakeUnique<NiceMockBluetoothGattDescriptor>(
+        measurement_interval.get(), kBlocklistedReadDescriptorUUID,
+        BluetoothUUID(kBlocklistedReadDescriptorUUID), false,
+        device::BluetoothRemoteGattCharacteristic::PROPERTY_READ |
+            device::BluetoothRemoteGattCharacteristic::PROPERTY_WRITE);
 
+    std::vector<uint8_t> value(1);
+    value[0] = false;
+
+    // Crash if ReadRemoteDescriptor 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(*no_read_descriptor, ReadRemoteDescriptor(_, _))
+        .WillByDefault(
+            Invoke([](const BluetoothRemoteGattDescriptor::ValueCallback&,
+                      const BluetoothRemoteGattDescriptor::ErrorCallback&) {
+              NOTREACHED();
+            }));
+
+    // Add it here with full permission as the blocklist should prevent us from
+    // accessing this descriptor
+    auto blocklisted_descriptor =
+        base::MakeUnique<NiceMockBluetoothGattDescriptor>(

[dcheng, 2017/01/24 10:21:02]

FWIW, I think this would be more clearly written with explicit test fakes,
rather than using the magic boilerplate gmock generates, especially since we
don't use any of the EXPECT_CALL magic.

P.S. I'm not too sure what the current thinking on gmock is. One previous thread
is
https://groups.google.com/a/chromium.org/forum/#!msg/chromium-dev/-KH_IP0rIWQ....

[dougt, 2017/01/24 16:14:29]

I agree. There is a plan to move these tests to Web Platform tests. Until that
works starts, we're going to continue using this framework.

[scheib, 2017/01/24 17:43:57]

I've been happy with GMOCK, it's much less code to generate fakes, even simple
ones, and the moment you need to add even some trivial behavior to the fake
there's a good way to it with gmock. Over the years it has been discussed some,
and like many tools it can be used poorly, but I wouldn't move away from it and
I think the system build up in device/bluetooth/test is done fairly well.

BTW, when we move layout tests to web platform tests we'll still need to build
dynamic fakes. It's pretty likely we'll continue to use & extend the
device/bluetooth/test fakes to do that.

+            measurement_interval.get(), kBlocklistedDescriptorUUID,
+            BluetoothUUID(kBlocklistedDescriptorUUID), false,
+            device::BluetoothRemoteGattCharacteristic::PROPERTY_READ |
+                device::BluetoothRemoteGattCharacteristic::PROPERTY_WRITE);
+
+    measurement_interval->AddMockDescriptor(std::move(user_description));
+    measurement_interval->AddMockDescriptor(std::move(client_config));
+    measurement_interval->AddMockDescriptor(std::move(blocklisted_descriptor));
+    measurement_interval->AddMockDescriptor(std::move(no_read_descriptor));
+  }
   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 219 matching lines @@
       measurement_interval.get();
 
   ON_CALL(*measurement_interval, ReadRemoteCharacteristic(_, _))
       .WillByDefault(Invoke([adapter_ptr, device_ptr, measurement_ptr,
                              disconnect, succeeds](
           const BluetoothRemoteGattCharacteristic::ValueCallback& callback,
           const BluetoothRemoteGattCharacteristic::ErrorCallback&
               error_callback) {
         base::Closure pending;
         if (succeeds) {
-          pending =
-              base::Bind(&PerformReadValue, base::RetainedRef(adapter_ptr),
-                         measurement_ptr, callback, std::vector<uint8_t>({1}));
+          pending = base::Bind(&PerformCharacteristicReadValue,
+                               base::RetainedRef(adapter_ptr), measurement_ptr,
+                               callback, std::vector<uint8_t>({1}));
         } else {
           pending = base::Bind(error_callback,
                                BluetoothRemoteGattService::GATT_ERROR_FAILED);
         }
         device_ptr->PushPendingCallback(pending);
         if (disconnect) {
           device_ptr->SetConnected(false);
           base::ThreadTaskRunnerHandle::Get()->PostTask(
               FROM_HERE,
               base::Bind(&NotifyDeviceChanged, base::RetainedRef(adapter_ptr),
@@ skipping 41 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));
         }
       }));
 
+  auto user_descriptor = base::MakeUnique<NiceMockBluetoothGattDescriptor>(
+      measurement_interval.get(), kCharacteristicUserDescription,
+      BluetoothUUID(kUserDescriptionUUID), false,
+      device::BluetoothRemoteGattCharacteristic::PROPERTY_READ);
+
+  NiceMockBluetoothGattDescriptor* user_descriptor_ptr = user_descriptor.get();
+  ON_CALL(*user_descriptor, ReadRemoteDescriptor(_, _))
+      .WillByDefault(Invoke([adapter_ptr, device_ptr, user_descriptor_ptr,
+                             disconnect, succeeds](
+          const BluetoothRemoteGattDescriptor::ValueCallback& callback,
+          const BluetoothRemoteGattDescriptor::ErrorCallback& error_callback) {
+        base::Closure pending;
+        if (succeeds) {
+          pending = base::Bind(
+              &PerformDescriptorReadValue, base::RetainedRef(adapter_ptr),
+              user_descriptor_ptr, callback, std::vector<uint8_t>({1}));
+        } else {
+          pending = base::Bind(error_callback,
+                               BluetoothRemoteGattService::GATT_ERROR_FAILED);
+        }
+        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));
+        }
+      }));
+
+  measurement_interval->AddMockDescriptor(std::move(user_descriptor));
+
   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 568 matching lines @@
       .WillByDefault(RunCallback<1 /* error_callback */>(error_code));
 
   // Write response.
   ON_CALL(*characteristic, WriteRemoteCharacteristic(_, _, _))
       .WillByDefault(RunCallback<2 /* error_callback */>(error_code));
 
   // StartNotifySession response
   ON_CALL(*characteristic, StartNotifySession(_, _))
       .WillByDefault(RunCallback<1 /* error_callback */>(error_code));
 
+  // Add error descriptor to |characteristic|
+  auto error_descriptor = base::MakeUnique<NiceMockBluetoothGattDescriptor>(
+      characteristic.get(), kCharacteristicUserDescription,
+      BluetoothUUID(kUserDescriptionUUID), false,
+      device::BluetoothRemoteGattCharacteristic::PROPERTY_READ);
+
+  ON_CALL(*error_descriptor, ReadRemoteDescriptor(_, _))
+      .WillByDefault(RunCallback<1 /* error_callback */>(error_code));
+
+  characteristic->AddMockDescriptor(std::move(error_descriptor));
+
   return characteristic;
 }
 
 // Notify sessions
 
 // static
 std::unique_ptr<NiceMockBluetoothGattNotifySession>
 LayoutTestBluetoothAdapterProvider::GetBaseGATTNotifySession(
     base::WeakPtr<device::BluetoothRemoteGattCharacteristic> characteristic) {
   auto session =
@@ skipping 60 matching lines @@
   NOTREACHED();
   return BluetoothUUID();
 }
 
 // static
 std::string LayoutTestBluetoothAdapterProvider::makeMACAddress(uint64_t addr) {
   return BluetoothDevice::CanonicalizeAddress(
       base::StringPrintf("%012" PRIx64, addr));
 }
 
-}  // namespace content
+}  // namespace content