bluetooth: Browser-side implementation of connectGATT.

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::BluetoothUUID;
 using device::MockBluetoothAdapter;
 using device::MockBluetoothDevice;
 using device::MockBluetoothDiscoverySession;
+using device::MockBluetoothGattConnection;
+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.
 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.
+ACTION_TEMPLATE(RunCallback,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_1_VALUE_PARAMS(p0)) {
+  return ::std::tr1::get<k>(args).Run(p0);
+}
+
 // Invokes Run() on the k-th argument of the function with the result
 // of |func| as an argument.
 ACTION_TEMPLATE(RunCallbackWithResult,
                 HAS_1_TEMPLATE_PARAMS(int, k),
                 AND_1_VALUE_PARAMS(func)) {
   return ::testing::get<k>(args).Run(func());
 }
+
+ACTION_P(GetMockDevice, adapter) {

[scheib, 2015/05/20 20:14:08]

Comment

[ortuno, 2015/05/20 20:54:47]

Done.

+  std::string address = arg0;
+  for (auto& device : adapter->GetMockDevices()) {
+    if (device->GetAddress() == address)
+      return device;
+  }
+  return NULL;
+}
 }
 
 namespace content {
 
 // static
 scoped_refptr<BluetoothAdapter>
 LayoutTestBluetoothAdapterProvider::GetBluetoothAdapter(
     const std::string& fake_adapter_name) {
   // TODO(ortuno): Remove RejectRequestDevice once LayoutTests are modified
   if (fake_adapter_name == "RejectRequestDevice_NotFoundError" ||
       fake_adapter_name == "EmptyAdapter") {
     return GetEmptyAdapter();
   }
   // TODO(ortuno): Remove "Single Empty Device" once LayoutTests are modified
   else if (fake_adapter_name == "Single Empty Device" ||
            fake_adapter_name == "SingleEmptyDeviceAdapter") {
     return GetSingleEmptyDeviceAdapter();
+  } else if (fake_adapter_name == "ConnectableDeviceAdapter") {
+    return GetConnectableDeviceAdapter();
+  } else if (fake_adapter_name == "UnconnectableDeviceAdapter") {
+    return GetUnconnectableDeviceAdapter();
   } else if (fake_adapter_name == "") {
     return NULL;
   }
   NOTREACHED();
   return NULL;
 }
 
 // static
 scoped_refptr<NiceMock<MockBluetoothAdapter>>
 LayoutTestBluetoothAdapterProvider::GetEmptyAdapter() {
   scoped_refptr<NiceMock<MockBluetoothAdapter>> adapter(
       new NiceMock<MockBluetoothAdapter>());
 
   ON_CALL(*adapter, StartDiscoverySession(_, _))
       .WillByDefault(RunCallbackWithResult<0 /* success_callback */>(
           []() { return GetDiscoverySession(); }));
 
   // Using Invoke allows the adapter returned from this method to be futher
   // modified and have devices added to it. The call to ::GetDevices will
   // invoke ::GetConstMockDevices, returning all devices added up to that time.
   ON_CALL(*adapter, GetDevices())
       .WillByDefault(
           Invoke(adapter.get(), &MockBluetoothAdapter::GetConstMockDevices));
 
+  ON_CALL(*adapter, GetDevice(_)).WillByDefault(GetMockDevice(adapter.get()));
+
   return adapter.Pass();
 }
 
 // static
 scoped_refptr<NiceMock<MockBluetoothAdapter>>
 LayoutTestBluetoothAdapterProvider::GetSingleEmptyDeviceAdapter() {
   scoped_refptr<NiceMock<MockBluetoothAdapter>> adapter(GetEmptyAdapter());
 
   adapter->AddMockDevice(GetEmptyDevice(adapter.get()));
 
   return adapter.Pass();
 }
 
 // static
+scoped_refptr<NiceMock<MockBluetoothAdapter>>
+LayoutTestBluetoothAdapterProvider::GetConnectableDeviceAdapter() {
+  scoped_refptr<NiceMock<MockBluetoothAdapter>> adapter(GetEmptyAdapter());
+
+  adapter->AddMockDevice(GetConnectableDevice(adapter.get()));
+
+  return adapter.Pass();
+}
+
+// static
+scoped_refptr<NiceMock<MockBluetoothAdapter>>
+LayoutTestBluetoothAdapterProvider::GetUnconnectableDeviceAdapter() {
+  scoped_refptr<NiceMock<MockBluetoothAdapter>> adapter(GetEmptyAdapter());
+
+  adapter->AddMockDevice(GetUnconnectableDevice(adapter.get()));
+
+  return adapter.Pass();
+}
+
+// static
+scoped_ptr<NiceMock<MockBluetoothDiscoverySession>>
+LayoutTestBluetoothAdapterProvider::GetDiscoverySession() {
+  scoped_ptr<NiceMock<MockBluetoothDiscoverySession>> discovery_session(
+      new NiceMock<MockBluetoothDiscoverySession>());
+
+  ON_CALL(*discovery_session, Stop(_, _))
+      .WillByDefault(RunCallback<0 /* success_callback */>());
+
+  return discovery_session.Pass();
+}
+
+// static
 scoped_ptr<NiceMock<MockBluetoothDevice>>
 LayoutTestBluetoothAdapterProvider::GetEmptyDevice(
     MockBluetoothAdapter* adapter) {
   scoped_ptr<NiceMock<MockBluetoothDevice>> empty_device(
       new NiceMock<MockBluetoothDevice>(
           adapter, 0x1F00 /* Bluetooth Class */, "Empty Mock Device name",
           "Empty Mock Device instanceID", true /* Paired */,
           true /* Connected */));
 
   ON_CALL(*empty_device, GetVendorIDSource())
       .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));
   return empty_device.Pass();
 }
 
 // static
-scoped_ptr<NiceMock<MockBluetoothDiscoverySession>>
-LayoutTestBluetoothAdapterProvider::GetDiscoverySession() {
-  scoped_ptr<NiceMock<MockBluetoothDiscoverySession>> discovery_session(
-      new NiceMock<MockBluetoothDiscoverySession>());
+scoped_ptr<NiceMock<MockBluetoothDevice>>
+LayoutTestBluetoothAdapterProvider::GetConnectableDevice(
+    MockBluetoothAdapter* adapter) {
+  scoped_ptr<NiceMock<MockBluetoothDevice>> device(GetEmptyDevice(adapter));
 
-  ON_CALL(*discovery_session, Stop(_, _))
-      .WillByDefault(RunCallback<0 /* success_callback */>());
+  BluetoothDevice* device_ptr = device.get();

[scheib, 2015/05/20 20:14:08]

This is OK, but it may be simpler to read the block below by extracting the
device address here closing over it instead of the device and then extracting
the address inside the closure.

[ortuno, 2015/05/20 20:54:47]

Hmm this way we avoid creating a copy of the address though.

[Jeffrey Yasskin, 2015/05/20 21:14:07]

To elaborate, we have to capture the address by value because capturing it by
reference is only valid if a particular C++ defect is resolved in the right way:
http://open-std.org/jtc1/sc22/wg21/docs/cwg_active.html#2011.

I suggested that we always close over the effective "this" pointer in ON_CALL
expressions instead of trying to pick the right fields to extract from it
separately at each use, but I'm not dead set on that.

[scheib, 2015/05/20 21:32:13]

I'm fine either way. I thought capturing the address string by value would be
just fine (I don't think it'll change, and I don't think the copy is excessive
to do). I figured it would simplify the code a bit in the closure, thinking that
it's short enough and nested in this code blob below, that the shorter we make
it the easier it is to read.

If multiple fields are used I agree it seems simpler to close over just the
object pointer and extract inline.

Anyhoo, it would save a line in this somewhat dense and hard to read bit. Also,
we can return the scope_ptr directly:

device_ptr:
 ON_CALL(*device, CreateGattConnection(_, _))
     .WillByDefault(
         RunCallbackWithResult<0 /* success_callback */>([device_ptr]() {
           return scoped_ptr<NiceMock<MockBluetoothGattConnection>> (
               new NiceMock<MockBluetoothGattConnection>(
                   device_ptr->GetAddress()));
         }));

address:
 ON_CALL(*device, CreateGattConnection(_, _))
     .WillByDefault(
         RunCallbackWithResult<0 /* success_callback */>([address]() {
           return scoped_ptr<NiceMock<MockBluetoothGattConnection>> (
               new NiceMock<MockBluetoothGattConnection>(address));
         }));

[Jeffrey Yasskin, 2015/05/20 22:29:25]

make_scoped_ptr() would also make this shorter:
https://code.google.com/p/chromium/codesearch/#chromium/src/base/memory/scope...

It might also be more readable to put the [whatever]() on the next line, so that
it's clearer we're writing a function here.

[ortuno, 2015/05/20 23:35:19]

Done.
I tried to but git cl format always puts it in the same line.

[Jeffrey Yasskin, 2015/05/21 00:12:00]

Good point. I don't think it's worth diverging from `git cl format`.

 
-  return discovery_session.Pass();
+  ON_CALL(*device, CreateGattConnection(_, _))
+      .WillByDefault(
+          RunCallbackWithResult<0 /* success_callback */>([device_ptr]() {
+            scoped_ptr<NiceMock<MockBluetoothGattConnection>> connection(
+                new NiceMock<MockBluetoothGattConnection>(
+                    device_ptr->GetAddress()));
+            return connection.Pass();
+          }));
+
+  return device.Pass();
+}
+
+// static
+scoped_ptr<NiceMock<MockBluetoothDevice>>
+LayoutTestBluetoothAdapterProvider::GetUnconnectableDevice(
+    MockBluetoothAdapter* adapter) {
+  scoped_ptr<NiceMock<MockBluetoothDevice>> device(GetEmptyDevice(adapter));
+
+  ON_CALL(*device, CreateGattConnection(_, _))
+      .WillByDefault(
+          RunCallback<1 /* error_callback */>(BluetoothDevice::ERROR_FAILED));
+
+  return device.Pass();
 }
 
 }  // namespace content