Remove implicit conversions from scoped_refptr to T* in chrome/browser/extensions/api/

chrome/browser/extensions/api/bluetooth/bluetooth_private_apitest.cc

 // Copyright 2014 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 "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_event_router.h"
 #include "chrome/browser/extensions/extension_apitest.h"
@@ skipping 37 matching lines @@
     CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         extensions::switches::kWhitelistedExtensionID, kTestExtensionId);
     mock_adapter_ = new NiceMock<MockBluetoothAdapter>();
     event_router()->SetAdapterForTest(mock_adapter_.get());
     mock_device_.reset(new NiceMock<MockBluetoothDevice>(mock_adapter_.get(),
                                                          0,
                                                          kDeviceName,
                                                          "11:12:13:14:15:16",
                                                          false,
                                                          false));
-    ON_CALL(*mock_adapter_, GetDevice(mock_device_->GetAddress()))
+    ON_CALL(*mock_adapter_.get(), GetDevice(mock_device_->GetAddress()))

[Jeffrey Yasskin, 2014/08/26 01:14:16]

Adding .get() shouldn't affect how this works, since it's getting dereferenced
either way.

[dcheng, 2014/08/26 01:26:00]

Before anything else, I'd like to say that I really hate macros.

I think this is actually necessary due to the way the gtest macro is
constructed:
#define GMOCK_ON_CALL_IMPL_(obj, call) \
    ((obj).gmock_##call).InternalDefaultActionSetAt(__FILE__, __LINE__, \
                                                    #obj, #call)
#define ON_CALL(obj, call) GMOCK_ON_CALL_IMPL_(obj, call)

(Un?)fortunately, scoped_refptr does not currently implement operator*, so I
think it's necessary to explicitly call .get() to unwrap the scoped_refptr so we
can pass a T& to gmock.

         .WillByDefault(Return(mock_device_.get()));
-    ON_CALL(*mock_adapter_, IsPresent())
-        .WillByDefault(Return(true));
+    ON_CALL(*mock_adapter_.get(), IsPresent()).WillByDefault(Return(true));
   }
 
   virtual void TearDownOnMainThread() OVERRIDE {}
 
   extensions::BluetoothEventRouter* event_router() {
     return extensions::BluetoothAPI::Get(browser()->profile())
         ->event_router();
   }
 
   void SetName(const std::string& name, const base::Closure& callback) {
@@ skipping 42 matching lines @@
  protected:
   std::string adapter_name_;
   bool adapter_powered_;
   bool adapter_discoverable_;
 
   scoped_refptr<NiceMock<MockBluetoothAdapter> > mock_adapter_;
   scoped_ptr<NiceMock<MockBluetoothDevice> > mock_device_;
 };
 
 IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest, SetAdapterState) {
-  ON_CALL(*mock_adapter_, GetName())
+  ON_CALL(*mock_adapter_.get(), GetName())
       .WillByDefault(ReturnPointee(&adapter_name_));
-  ON_CALL(*mock_adapter_, IsPowered())
+  ON_CALL(*mock_adapter_.get(), IsPowered())
       .WillByDefault(ReturnPointee(&adapter_powered_));
-  ON_CALL(*mock_adapter_, IsDiscoverable())
+  ON_CALL(*mock_adapter_.get(), IsDiscoverable())
       .WillByDefault(ReturnPointee(&adapter_discoverable_));
 
-  EXPECT_CALL(*mock_adapter_, SetName("Dome", _, _)).WillOnce(
+  EXPECT_CALL(*mock_adapter_.get(), SetName("Dome", _, _)).WillOnce(
       WithArgs<0, 1>(Invoke(this, &BluetoothPrivateApiTest::SetName)));
-  EXPECT_CALL(*mock_adapter_, SetPowered(true, _, _)).WillOnce(
+  EXPECT_CALL(*mock_adapter_.get(), SetPowered(true, _, _)).WillOnce(
       WithArgs<0, 1>(Invoke(this, &BluetoothPrivateApiTest::SetPowered)));
-  EXPECT_CALL(*mock_adapter_, SetDiscoverable(true, _, _)).WillOnce(
+  EXPECT_CALL(*mock_adapter_.get(), SetDiscoverable(true, _, _)).WillOnce(
       WithArgs<0, 1>(Invoke(this, &BluetoothPrivateApiTest::SetDiscoverable)));
 
   ASSERT_TRUE(RunComponentExtensionTest("bluetooth_private/adapter_state"))
       << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest, NoBluetoothAdapter) {
-  ON_CALL(*mock_adapter_, IsPresent())
-      .WillByDefault(Return(false));
+  ON_CALL(*mock_adapter_.get(), IsPresent()).WillByDefault(Return(false));
   ASSERT_TRUE(RunComponentExtensionTest("bluetooth_private/no_adapter"))
       << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest, CancelPairing) {
   InSequence s;
-  EXPECT_CALL(*mock_adapter_,
+  EXPECT_CALL(*mock_adapter_.get(),
               AddPairingDelegate(
                   _, device::BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH))
       .WillOnce(WithoutArgs(Invoke(
           this, &BluetoothPrivateApiTest::DispatchAuthorizePairingEvent)));
   EXPECT_CALL(*mock_device_, ExpectingConfirmation())
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_device_, CancelPairing());
   ASSERT_TRUE(RunComponentExtensionTest("bluetooth_private/cancel_pairing"))
       << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest, PincodePairing) {
-  EXPECT_CALL(*mock_adapter_,
+  EXPECT_CALL(*mock_adapter_.get(),
               AddPairingDelegate(
                   _, device::BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH))
       .WillOnce(WithoutArgs(
           Invoke(this, &BluetoothPrivateApiTest::DispatchPincodePairingEvent)));
   EXPECT_CALL(*mock_device_, ExpectingPinCode()).WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_device_, SetPinCode("abbbbbbk"));
   ASSERT_TRUE(RunComponentExtensionTest("bluetooth_private/pincode_pairing"))
       << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest, PasskeyPairing) {
-  EXPECT_CALL(*mock_adapter_,
+  EXPECT_CALL(*mock_adapter_.get(),
               AddPairingDelegate(
                   _, device::BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH))
       .WillOnce(WithoutArgs(
           Invoke(this, &BluetoothPrivateApiTest::DispatchPasskeyPairingEvent)));
   EXPECT_CALL(*mock_device_, ExpectingPasskey()).WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_device_, SetPasskey(900531));
   ASSERT_TRUE(RunComponentExtensionTest("bluetooth_private/passkey_pairing"))
       << message_;
 }