bluetooth: Subscribe to notifications

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"
 #include "base/strings/stringprintf.h"
 #include "base/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_notify_session.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothDevice;
+using device::BluetoothGattCharacteristic;
 using device::BluetoothGattService;
 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::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 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 50 matching lines @@
   else if (fake_adapter_name == "FailStartDiscoveryAdapter")
     return GetFailStartDiscoveryAdapter();
   else if (fake_adapter_name == "GlucoseHeartRateAdapter")
     return GetGlucoseHeartRateAdapter();
   else if (fake_adapter_name == "MissingServiceGenericAccessAdapter")
     return GetMissingServiceGenericAccessAdapter();
   else if (fake_adapter_name == "MissingCharacteristicGenericAccessAdapter")
     return GetMissingCharacteristicGenericAccessAdapter();
   else if (fake_adapter_name == "GenericAccessAdapter")
     return GetGenericAccessAdapter();
+  else if (fake_adapter_name == "HeartRateAdapter")
+    return GetHeartRateAdapter();
   else if (fake_adapter_name == "FailingConnectionsAdapter")
     return GetFailingConnectionsAdapter();
   else if (fake_adapter_name == "FailingGATTOperationsAdapter")
     return GetFailingGATTOperationsAdapter();
   else if (fake_adapter_name == "SecondDiscoveryFindsHeartRateAdapter")
     return GetSecondDiscoveryFindsHeartRateAdapter();
   else if (fake_adapter_name == "")
     return NULL;
 
   NOTREACHED() << fake_adapter_name;
@@ skipping 211 matching lines @@
 
   generic_access->AddMockCharacteristic(device_name.Pass());
   device->AddMockService(generic_access.Pass());
   adapter->AddMockDevice(device.Pass());
 
   return adapter.Pass();
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
+LayoutTestBluetoothAdapterProvider::GetHeartRateAdapter() {
+  scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
+  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
+  scoped_ptr<NiceMockBluetoothGattCharacteristic> heart_rate_measurement(
+      GetBaseGATTCharacteristic(heart_rate.get(), kHeartRateMeasurementUUID));
+  BluetoothGattCharacteristic* measurement_ptr = heart_rate_measurement.get();
+  ON_CALL(*heart_rate_measurement, StartNotifySession(_, _))
+      .WillByDefault(
+          RunCallbackWithResult<0 /* success_callback */>([measurement_ptr]() {
+            return GetBaseGATTNotifySession(measurement_ptr->GetIdentifier());
+          }));
+
+  heart_rate->AddMockCharacteristic(heart_rate_measurement.Pass());
+  device->AddMockService(heart_rate.Pass());
+  adapter->AddMockDevice(device.Pass());
+
+  return adapter.Pass();
+}
+
+// static
+scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetFailingConnectionsAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
 
   for (int error = BluetoothDevice::ERROR_UNKNOWN;
        error <= BluetoothDevice::ERROR_UNSUPPORTED_DEVICE; error++) {
     adapter->AddMockDevice(GetUnconnectableDevice(
         adapter.get(), static_cast<BluetoothDevice::ConnectErrorCode>(error)));
   }
+
   return adapter.Pass();
 }
 
 // static
 scoped_refptr<NiceMockBluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetFailingGATTOperationsAdapter() {
   scoped_refptr<NiceMockBluetoothAdapter> adapter(GetEmptyAdapter());
 
   const std::string errorsServiceUUID = errorUUID(0xA0);
 
@@ skipping 94 matching lines @@
 }
 
 // static
 scoped_ptr<NiceMockBluetoothDevice>
 LayoutTestBluetoothAdapterProvider::GetHeartRateDevice(
     MockBluetoothAdapter* adapter) {
   BluetoothDevice::UUIDList uuids;
   uuids.push_back(BluetoothUUID(kGenericAccessServiceUUID));
   uuids.push_back(BluetoothUUID(kHeartRateServiceUUID));
 
-  return GetBaseDevice(adapter, "Heart Rate Device", uuids,
-                       makeMACAddress(0x3));
+  return GetConnectableDevice(adapter, "Heart Rate Device", uuids,
+                              makeMACAddress(0x3));
 }
 
 // static
 scoped_ptr<NiceMockBluetoothDevice>
 LayoutTestBluetoothAdapterProvider::GetConnectableDevice(
     device::MockBluetoothAdapter* adapter,
     const std::string& device_name,
-    BluetoothDevice::UUIDList uuids) {
+    BluetoothDevice::UUIDList uuids,
+    const std::string& address) {
   scoped_ptr<NiceMockBluetoothDevice> device(
-      GetBaseDevice(adapter, device_name, uuids));
+      GetBaseDevice(adapter, device_name, uuids, address));
 
   BluetoothDevice* device_ptr = device.get();
 
   ON_CALL(*device, CreateGattConnection(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
           [adapter, device_ptr]() {
             return make_scoped_ptr(new NiceMockBluetoothGattConnection(
                 adapter, device_ptr->GetAddress()));
           }));
 
@@ skipping 74 matching lines @@
       GetBaseGATTCharacteristic(service, errorUUID(error_alias)));
 
   // Read response.
   ON_CALL(*characteristic, ReadRemoteCharacteristic(_, _))
       .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));
+
   return characteristic.Pass();
 }
 
+// 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>());
+
+  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