bluetooth: Add characteristicvaluechanged event

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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/format_macros.h"
 #include "base/location.h"
@@ skipping 16 matching lines @@
 using device::BluetoothUUID;
 using device::MockBluetoothAdapter;
 using device::MockBluetoothDevice;
 using device::MockBluetoothDiscoverySession;
 using device::MockBluetoothGattCharacteristic;
 using device::MockBluetoothGattConnection;
 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<MockBluetoothGattCharacteristic>
     NiceMockBluetoothGattCharacteristic;
 typedef testing::NiceMock<MockBluetoothGattConnection>
     NiceMockBluetoothGattConnection;
 typedef testing::NiceMock<MockBluetoothGattService>
     NiceMockBluetoothGattService;
 typedef testing::NiceMock<MockBluetoothGattNotifySession>
     NiceMockBluetoothGattNotifySession;
 
 namespace {
 // Bluetooth UUIDs suitable to pass to BluetoothUUID().
 const char kBatteryServiceUUID[] = "180f";
 const char kGenericAccessServiceUUID[] = "1800";
 const char kGlucoseServiceUUID[] = "1808";
 const char kHeartRateServiceUUID[] = "180d";
 const char kHeartRateMeasurementUUID[] = "2a37";
+const char kBodySensorLocation[] = "2a38";
 const char kDeviceNameUUID[] = "2a00";
 
 // 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.
@@ skipping 285 matching lines @@
   device->AddMockService(generic_access.Pass());
   adapter->AddMockDevice(device.Pass());
 
   return adapter.Pass();
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetHeartRateAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
+  // Used by lambdas that need the adapter.
+  NiceMockBluetoothAdapter* adapter_ptr = adapter.get();
+
   scoped_ptr<NiceMockBluetoothDevice> device(GetHeartRateDevice(adapter.get()));
   scoped_ptr<NiceMockBluetoothGattService> heart_rate(
       GetBaseGATTService(device.get(), kHeartRateServiceUUID));
 
   // TODO(ortuno): Implement the rest of the service's characteristics
   // See: http://crbug.com/529975
+
+  // Body Sensor Location Characteristic
+  scoped_ptr<NiceMockBluetoothGattCharacteristic> body_sensor_location(
+      GetBaseGATTCharacteristic(heart_rate.get(), kBodySensorLocation));
+  BluetoothGattCharacteristic* location_ptr = body_sensor_location.get();
+
+  ON_CALL(*body_sensor_location, ReadRemoteCharacteristic(_, _))
+      .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
+          [adapter_ptr, location_ptr]() {
+            std::vector<uint8_t> location(1 /* size */);
+            location[0] = 1;  // Chest
+            // Read a characteristic has a side effect of
+            // GattCharacteristicValueChanged being called.
+            FOR_EACH_OBSERVER(BluetoothAdapter::Observer,
+                              adapter_ptr->GetObservers(),
+                              GattCharacteristicValueChanged(
+                                  adapter_ptr, location_ptr, location));
+            return location;
+          }));
+
+  // Heart Rate Measurement Characteristic
   scoped_ptr<NiceMockBluetoothGattCharacteristic> heart_rate_measurement(
       GetBaseGATTCharacteristic(heart_rate.get(), kHeartRateMeasurementUUID));
-  BluetoothGattCharacteristic* measurement_ptr = heart_rate_measurement.get();
+  NiceMockBluetoothGattCharacteristic* measurement_ptr =
+      heart_rate_measurement.get();
+
   ON_CALL(*heart_rate_measurement, StartNotifySession(_, _))
-      .WillByDefault(
-          RunCallbackWithResult<0 /* success_callback */>([measurement_ptr]() {
-            return GetBaseGATTNotifySession(measurement_ptr->GetIdentifier());
+      .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
+          [adapter_ptr, measurement_ptr]() {
+            scoped_ptr<NiceMockBluetoothGattNotifySession> notify_session(
+                GetBaseGATTNotifySession(measurement_ptr->GetIdentifier()));
+
+            std::vector<uint8_t> rate(1 /* size */);
+            rate[0] = 60;
+
+            notify_session->StartTestNotifications(adapter_ptr, measurement_ptr,
+                                                   rate);
+
+            return notify_session.Pass();
           }));
 
   heart_rate->AddMockCharacteristic(heart_rate_measurement.Pass());
+  heart_rate->AddMockCharacteristic(body_sensor_location.Pass());
   device->AddMockService(heart_rate.Pass());
   adapter->AddMockDevice(device.Pass());
 
   return adapter.Pass();
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetFailingConnectionsAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
@@ skipping 234 matching lines @@
 
 // Notify sessions
 
 // static
 scoped_ptr<NiceMockBluetoothGattNotifySession>
 LayoutTestBluetoothAdapterProvider::GetBaseGATTNotifySession(
     const std::string& characteristic_identifier) {
   scoped_ptr<NiceMockBluetoothGattNotifySession> session(
       new NiceMockBluetoothGattNotifySession(characteristic_identifier));
 
-  ON_CALL(*session, Stop(_)).WillByDefault(RunCallback<0>());
+  ON_CALL(*session, Stop(_))
+      .WillByDefault(testing::DoAll(
+          InvokeWithoutArgs(
+              session.get(),
+              &MockBluetoothGattNotifySession::StopTestNotifications),
+          RunCallback<0>()));
 
   return session.Pass();
 }
 
 // Helper functions
 
 // static
 std::string LayoutTestBluetoothAdapterProvider::errorUUID(uint32_t alias) {
   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