Implement WebBluetooth descriptor.writeValue()

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 741 matching lines @@
 
     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);
         }));
 
+    ON_CALL(*user_description, WriteRemoteDescriptor(_, _, _))
+        .WillByDefault(RunCallback<1 /* success_callback */>());
+
     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);
 
+   // Crash if WriteRemoteDescriptor called. Not using GoogleMock's Expect
+   // because this is used in layout tests that may not report a mock
+   // expectation.
+    ON_CALL(*client_config, WriteRemoteDescriptor(_, _, _))
+        .WillByDefault(
+            Invoke([](const std::vector<uint8_t>&, const base::Closure&,
+                      const BluetoothRemoteGattDescriptor::ErrorCallback&) {
+              NOTREACHED();
+            }));
+
     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();
             }));
@@ skipping 338 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));
         }
       }));
 
+  ON_CALL(*user_descriptor, WriteRemoteDescriptor(_, _, _))
+      .WillByDefault(Invoke([adapter_ptr, device_ptr, user_descriptor_ptr,
+                             disconnect, succeeds](
+          const std::vector<uint8_t>& value, const base::Closure& callback,
+          const BluetoothRemoteGattDescriptor::ErrorCallback& error_callback) {
+        base::Closure pending;
+        if (succeeds) {
+          pending = callback;
+        } 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::
@@ skipping 579 matching lines @@
 
   // 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));
 
+  ON_CALL(*error_descriptor, WriteRemoteDescriptor(_, _, _))
+      .WillByDefault(RunCallback<2 /* error_callback */>(error_code));
+
   characteristic->AddMockDescriptor(std::move(error_descriptor));
 
   return characteristic;
 }
 
 // Notify sessions
 
 // static
 std::unique_ptr<NiceMockBluetoothGattNotifySession>
 LayoutTestBluetoothAdapterProvider::GetBaseGATTNotifySession(
@@ skipping 63 matching lines @@
   return BluetoothUUID();
 }
 
 // static
 std::string LayoutTestBluetoothAdapterProvider::makeMACAddress(uint64_t addr) {
   return BluetoothDevice::CanonicalizeAddress(
       base::StringPrintf("%012" PRIx64, addr));
 }
 
 }  // namespace content