bluetooth: Refactor LayoutTestBluetoothAdapterProvider.

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 "testing/gmock/include/gmock/gmock.h"
 
 using device::BluetoothAdapter;
 using device::BluetoothAdapterFactory;
 using device::BluetoothDevice;
 using device::BluetoothDiscoverySession;
 using device::BluetoothUUID;
 using device::MockBluetoothAdapter;
 using device::MockBluetoothDevice;
 using device::MockBluetoothDiscoverySession;
 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 ::std::tr1::get<k>(args).Run();

[scheib, 2015/05/20 04:17:06]

First time I've seen "::std::tr1". Is that better than "::testing::get<k>" as
from GMOCK docs? If equivalent, the latter surprises me less name wise.

[ortuno, 2015/05/20 16:44:04]

Done.

+}
+
+// Invokes Run() on the k-th argument of the function with the result
+// of |func| as an argument. This is done to get around the lack of support

[Jeffrey Yasskin, 2015/05/20 00:27:28]

I think you can remove the "This is done" explanation. This is just uniformly
better, since it doesn't constrain the number of calls.

[ortuno, 2015/05/20 16:44:04]

Done.

+// for scoped_ptr in gmock.
+ACTION_TEMPLATE(RunCallbackWithResult,
+                HAS_1_TEMPLATE_PARAMS(int, k),
+                AND_1_VALUE_PARAMS(func)) {
+  return ::std::tr1::get<k>(args).Run(func());
+}
+}
+
 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 == "") {
     return NULL;
   }
   NOTREACHED();
   return NULL;
 }
 
 // static
 scoped_refptr<NiceMock<MockBluetoothAdapter>>
 LayoutTestBluetoothAdapterProvider::GetEmptyAdapter() {
   scoped_refptr<NiceMock<MockBluetoothAdapter>> adapter(
       new NiceMock<MockBluetoothAdapter>());
 
+  scoped_ptr<NiceMock<MockBluetoothDiscoverySession>> discovery_session(

[scheib, 2015/05/20 04:17:05]

Is 'discovery_session' used? The anon function below doesn't close over it,
right? Or am I miss-reading?

[ortuno, 2015/05/20 16:44:04]

Done.

+      GetDiscoverySession());
+
   ON_CALL(*adapter, StartDiscoverySession(_, _))
-      .WillByDefault(Invoke(
-          &LayoutTestBluetoothAdapterProvider::SuccessfulDiscoverySession));
+      .WillByDefault(RunCallbackWithResult<0 /* success_callback */>([]() {
+        scoped_ptr<NiceMock<MockBluetoothDiscoverySession>> discovery_session(
+            GetDiscoverySession());
+        return discovery_session.Pass();

[Jeffrey Yasskin, 2015/05/20 00:27:28]

In this particular function, you don't even need the local variable. "return
GetDiscoverySession();" should work.

[ortuno, 2015/05/20 16:44:04]

Done.

+      }));
 
   ON_CALL(*adapter, GetDevices())
-      .WillByDefault(Return(adapter->GetMockDevices()));
+      .WillByDefault(

[scheib, 2015/05/20 04:17:05]

Explain in comment here why. E.g. 
// 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
::GetMockDevices, returning all devices added up to that time.

[ortuno, 2015/05/20 16:44:04]

Done.

[scheib, 2015/05/20 16:57:49]

Not as done as I think you think I thought you would think it would be done.

+          Invoke(adapter.get(), &MockBluetoothAdapter::GetMockDevices));
 
   return adapter.Pass();
 }
 
 // static
 scoped_refptr<NiceMock<MockBluetoothAdapter>>
 LayoutTestBluetoothAdapterProvider::GetSingleEmptyDeviceAdapter() {
-  scoped_refptr<NiceMock<MockBluetoothAdapter>> adapter(
-      new NiceMock<MockBluetoothAdapter>());
-
-  ON_CALL(*adapter, StartDiscoverySession(_, _))
-      .WillByDefault(Invoke(
-          &LayoutTestBluetoothAdapterProvider::SuccessfulDiscoverySession));
+  scoped_refptr<NiceMock<MockBluetoothAdapter>> adapter(GetEmptyAdapter());
 
   adapter->AddMockDevice(GetEmptyDevice(adapter.get()));
 
-  ON_CALL(*adapter, GetDevices())
-      .WillByDefault(Return(adapter->GetMockDevices()));
-
   return adapter.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
-void LayoutTestBluetoothAdapterProvider::SuccessfulDiscoverySession(
-    const BluetoothAdapter::DiscoverySessionCallback& callback,
-    const BluetoothAdapter::ErrorCallback& error_callback) {
+scoped_ptr<NiceMock<MockBluetoothDiscoverySession>>
+LayoutTestBluetoothAdapterProvider::GetDiscoverySession() {
   scoped_ptr<NiceMock<MockBluetoothDiscoverySession>> discovery_session(
       new NiceMock<MockBluetoothDiscoverySession>());
 
   ON_CALL(*discovery_session, Stop(_, _))
-      .WillByDefault(Invoke(
-          &LayoutTestBluetoothAdapterProvider::SuccessfulDiscoverySessionStop));
+      .WillByDefault(RunCallback<0 /* success_callback */>());
 
-  callback.Run(discovery_session.Pass());
-}
-
-// static
-void LayoutTestBluetoothAdapterProvider::SuccessfulDiscoverySessionStop(
-    const base::Closure& callback,
-    const base::Closure& error_callback) {
-  callback.Run();
+  return discovery_session.Pass();
 }
 
 }  // namespace content