bluetooth: Browser-side implementation of getCharacteristic

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 "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 "testing/gmock/include/gmock/gmock.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothAdapterFactory;
 using device::BluetoothDevice;
 using device::BluetoothDiscoverySession;
 using device::BluetoothGattConnection;
 using device::BluetoothGattService;
 using device::BluetoothUUID;
 using device::MockBluetoothAdapter;
 using device::MockBluetoothDevice;
 using device::MockBluetoothDiscoverySession;
+using device::MockBluetoothGattCharacteristic;
 using device::MockBluetoothGattConnection;
 using device::MockBluetoothGattService;
 using testing::Between;
 using testing::Invoke;
 using testing::Return;
 using testing::NiceMock;
 using testing::_;
 
 namespace {
 // Invokes Run() on the k-th argument of the function with no arguments.
@@ skipping 21 matching lines @@
 // Function to iterate over the adapter's devices and return the one
 // that matches the address.
 ACTION_P(GetMockDevice, adapter) {
   std::string address = arg0;
   for (BluetoothDevice* device : adapter->GetMockDevices()) {
     if (device->GetAddress() == address)
       return device;
   }
   return NULL;
 }
+
+// Function to iterate over the device's services and return the one
+// that matches the identifier.
+ACTION_P(GetMockService, device) {
+  std::string identifier = arg0;
+  for (BluetoothGattService* service : device->GetMockServices()) {
+    if (service->GetIdentifier() == identifier)
+      return service;
+  }
+  return NULL;
 }
 
+}  // namespace
+
 namespace content {
 
 // static
 scoped_refptr<BluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetBluetoothAdapter(
     const std::string& fake_adapter_name) {
   if (fake_adapter_name == "EmptyAdapter")
     return GetEmptyAdapter();
   else if (fake_adapter_name == "SingleEmptyDeviceAdapter")
     return GetSingleEmptyDeviceAdapter();
@@ skipping 88 matching lines @@
       .WillByDefault(Return(BluetoothDevice::VENDOR_ID_BLUETOOTH));
   ON_CALL(*empty_device, GetVendorID()).WillByDefault(Return(0xFFFF));
   ON_CALL(*empty_device, GetProductID()).WillByDefault(Return(1));
   ON_CALL(*empty_device, GetDeviceID()).WillByDefault(Return(2));
 
   BluetoothDevice::UUIDList list;
   list.push_back(BluetoothUUID("1800"));
   list.push_back(BluetoothUUID("1801"));
   ON_CALL(*empty_device, GetUUIDs()).WillByDefault(Return(list));
 
-  empty_device->AddMockService(
+  scoped_ptr<NiceMock<MockBluetoothGattService>> generic_access(
       GetMockService(empty_device.get(), "1800" /* Generic Access */));
-  empty_device->AddMockService(
+  generic_access->AddMockCharacteristic(
+      GetMockCharacteristic(generic_access.get(), "2A00" /* Device Name */));
+
+  scoped_ptr<NiceMock<MockBluetoothGattService>> generic_attribute(
       GetMockService(empty_device.get(), "1801" /* Generic Attribute */));
+  generic_attribute->AddMockCharacteristic(GetMockCharacteristic(
+      generic_attribute.get(), "2A05" /* Service Changed */));
+
+  empty_device->AddMockService(generic_access.Pass());
+  empty_device->AddMockService(generic_attribute.Pass());
 
   // Using Invoke allows the device returned from this method to be futher
   // modified and have more services added to it. The call to ::GetGattServices
   // will invoke ::GetMockServices, returning all services added up to that
   // time.
   ON_CALL(*empty_device, GetGattServices())
       .WillByDefault(
           Invoke(empty_device.get(), &MockBluetoothDevice::GetMockServices));
 
+  // The call to BluetoothDevice::GetService will invoke ::GetMockService
+  // which returns a service matching the identifier provided if the service
+  // was added to the mock.
+  ON_CALL(*empty_device, GetGattService(_))
+      .WillByDefault(::GetMockService(empty_device.get()));

[Jeffrey Yasskin, 2015/06/02 22:12:29]

I'm unhappy with the name collision between the ::GetMockService action and
LayoutTestBluetoothAdapterProvider::GetMockService. Maybe call the action
"GetMockServiceWithin" or similar? You should change GetMockDevice to match.

[ortuno, 2015/06/03 20:27:23]

What about changing LayoutTestBluetoothAdapterProvider::GetMockService to
GetService instead?

[Jeffrey Yasskin, 2015/06/03 22:56:24]

Sure.

+
   return empty_device.Pass();
 }
 
 // static
 scoped_ptr<NiceMock<MockBluetoothDevice>>
 LayoutTestBluetoothAdapterProvider::GetConnectableDevice(
     MockBluetoothAdapter* adapter) {
   scoped_ptr<NiceMock<MockBluetoothDevice>> device(GetEmptyDevice(adapter));
 
   BluetoothDevice* device_ptr = device.get();
@@ skipping 18 matching lines @@
       .WillByDefault(
           RunCallback<1 /* error_callback */>(BluetoothDevice::ERROR_FAILED));
 
   return device.Pass();
 }
 
 // static
 scoped_ptr<NiceMock<MockBluetoothGattService>>
 LayoutTestBluetoothAdapterProvider::GetMockService(MockBluetoothDevice* device,
                                                    const std::string& uuid) {
-  return make_scoped_ptr(new NiceMock<MockBluetoothGattService>(
-      device, uuid /* identifier */, BluetoothUUID(uuid), true /* is_primary */,
-      false /* is_local */));
+  scoped_ptr<NiceMock<MockBluetoothGattService>> service(
+      new NiceMock<MockBluetoothGattService>(
+          device, uuid /* identifier */, BluetoothUUID(uuid),
+          true /* is_primary */, false /* is_local */));
+
+  ON_CALL(*service, GetCharacteristics())
+      .WillByDefault(Invoke(service.get(),
+                            &MockBluetoothGattService::GetMockCharacteristics));
+  return service.Pass();
+}
+
+// static
+scoped_ptr<NiceMock<MockBluetoothGattCharacteristic>>
+LayoutTestBluetoothAdapterProvider::GetMockCharacteristic(
+    MockBluetoothGattService* service,
+    const std::string& uuid) {
+  return make_scoped_ptr(new NiceMock<MockBluetoothGattCharacteristic>(
+      service, uuid /* identifier */, BluetoothUUID(uuid), false /* is_local */,
+      NULL /* properties */, NULL /* permissions */));
 }
 
 }  // namespace content