bluetooth: Match real ReadRemoteCharacteristic's behavior

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 146 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 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 518 matching lines @@
   auto measurement_interval(GetBaseGATTCharacteristic(
       "Measurement Interval", health_thermometer.get(),
       kMeasurementIntervalUUID,
       BluetoothRemoteGattCharacteristic::PROPERTY_READ |
           BluetoothRemoteGattCharacteristic::PROPERTY_WRITE |
           BluetoothRemoteGattCharacteristic::PROPERTY_NOTIFY));
   NiceMockBluetoothGattCharacteristic* measurement_ptr =
       measurement_interval.get();
 
   ON_CALL(*measurement_interval, ReadRemoteCharacteristic(_, _))
-      .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
-          [adapter_ptr, measurement_ptr]() {
-            std::vector<uint8_t> interval({1});
-            for (auto& observer : adapter_ptr->GetObservers()) {
-              observer.GattCharacteristicValueChanged(
-                  adapter_ptr, measurement_ptr, interval);
-            }
-            return interval;
-          }));
+      .WillByDefault(
+          RunCallback<0 /* success_callback */>(std::vector<uint8_t>({1})));
 
   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());
           }));
 
@@ skipping 295 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(&PerformCharacteristicReadValue,
-                               base::RetainedRef(adapter_ptr), measurement_ptr,
-                               callback, std::vector<uint8_t>({1}));
+          pending = base::Bind(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 54 matching lines @@
       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}));
+          pending = base::Bind(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 465 matching lines @@
                                                    rate);
 
             return notify_session;
           }));
 
   // 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 */>(
-          [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 (auto& observer : adapter->GetObservers()) {
-              observer.GattCharacteristicValueChanged(
-                  adapter, location_chest_ptr, location);
-            }
-            return location;
-          }));
+      .WillByDefault(RunCallback<0 /* success_callback */>(
+          std::vector<uint8_t>({1} /* Chest */)));
 
   // Body Sensor Location Characteristic (Wrist)
   std::unique_ptr<NiceMockBluetoothGattCharacteristic>
       body_sensor_location_wrist(GetBaseGATTCharacteristic(
           "Body Sensor Location Wrist", heart_rate.get(), kBodySensorLocation,
           BluetoothRemoteGattCharacteristic::PROPERTY_READ));
-  BluetoothRemoteGattCharacteristic* 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 (auto& observer : adapter->GetObservers()) {
-              observer.GattCharacteristicValueChanged(
-                  adapter, location_wrist_ptr, location);
-            }
-            return location;
-          }));
+      .WillByDefault(RunCallback<0 /* success_callback */>(
+          std::vector<uint8_t>({2} /* Wrist */)));
 
   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>
@@ skipping 132 matching lines @@
   return base::StringPrintf("%08x-97e5-4cd7-b9f1-f5a427670c59", alias);
 }
 
 // static
 std::string LayoutTestBluetoothAdapterProvider::makeMACAddress(uint64_t addr) {
   return BluetoothDevice::CanonicalizeAddress(
       base::StringPrintf("%012" PRIx64, addr));
 }
 
 }  // namespace content