[Extensions] Code Cleanup - Remove redundant smart-ptr get()s

extensions/browser/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 <memory>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "build/build_config.h"
@@ skipping 49 matching lines @@
 
   ~BluetoothPrivateApiTest() override {}
 
   void SetUpOnMainThread() override {
     base::CommandLine::ForCurrentProcess()->AppendSwitchASCII(
         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, kDeviceAddress, false, false));
-    ON_CALL(*mock_adapter_.get(), GetDevice(kDeviceAddress))
+    ON_CALL(*mock_adapter_, GetDevice(kDeviceAddress))
         .WillByDefault(Return(mock_device_.get()));
-    ON_CALL(*mock_adapter_.get(), IsPresent()).WillByDefault(Return(true));
+    ON_CALL(*mock_adapter_, IsPresent()).WillByDefault(Return(true));
   }
 
   void TearDownOnMainThread() override {}
 
   BluetoothEventRouter* event_router() {
     return BluetoothAPI::Get(browser()->profile())->event_router();
   }
 
   void SetName(const std::string& name, const base::Closure& callback) {
     adapter_name_ = name;
@@ skipping 70 matching lines @@
   NiceMock<MockBluetoothDiscoverySession>* mock_discovery_session_;
 };
 
 ACTION_TEMPLATE(InvokeCallbackArgument,
                 HAS_1_TEMPLATE_PARAMS(int, k),
                 AND_0_VALUE_PARAMS()) {
   ::std::tr1::get<k>(args).Run();
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest, SetAdapterState) {
-  ON_CALL(*mock_adapter_.get(), GetName())
+  ON_CALL(*mock_adapter_, GetName())
       .WillByDefault(ReturnPointee(&adapter_name_));
-  ON_CALL(*mock_adapter_.get(), IsPowered())
+  ON_CALL(*mock_adapter_, IsPowered())
       .WillByDefault(ReturnPointee(&adapter_powered_));
-  ON_CALL(*mock_adapter_.get(), IsDiscoverable())
+  ON_CALL(*mock_adapter_, IsDiscoverable())
       .WillByDefault(ReturnPointee(&adapter_discoverable_));
 
-  EXPECT_CALL(*mock_adapter_.get(), SetName("Dome", _, _)).WillOnce(
-      WithArgs<0, 1>(Invoke(this, &BluetoothPrivateApiTest::SetName)));
-  EXPECT_CALL(*mock_adapter_.get(), SetPowered(true, _, _)).WillOnce(
-      WithArgs<0, 1>(Invoke(this, &BluetoothPrivateApiTest::SetPowered)));
-  EXPECT_CALL(*mock_adapter_.get(), SetDiscoverable(true, _, _)).WillOnce(
-      WithArgs<0, 1>(Invoke(this, &BluetoothPrivateApiTest::SetDiscoverable)));
+  EXPECT_CALL(*mock_adapter_, SetName("Dome", _, _))
+      .WillOnce(
+          WithArgs<0, 1>(Invoke(this, &BluetoothPrivateApiTest::SetName)));
+  EXPECT_CALL(*mock_adapter_, SetPowered(true, _, _))
+      .WillOnce(
+          WithArgs<0, 1>(Invoke(this, &BluetoothPrivateApiTest::SetPowered)));
+  EXPECT_CALL(*mock_adapter_, 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_.get(), IsPresent()).WillByDefault(Return(false));
+  ON_CALL(*mock_adapter_, 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_.get(),
+  EXPECT_CALL(*mock_adapter_,
               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_.get(),
+  EXPECT_CALL(*mock_adapter_,
               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_.get(),
+  EXPECT_CALL(*mock_adapter_,
               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_;
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest, DisconnectAll) {
   EXPECT_CALL(*mock_device_, IsConnected())
       .Times(6)
       .WillOnce(Return(false))
       .WillOnce(Return(true))
       .WillOnce(Return(false))
       .WillRepeatedly(Return(true));
   EXPECT_CALL(*mock_device_, Disconnect(_, _))
       .Times(3)
       .WillOnce(InvokeCallbackArgument<1>())
       .WillOnce(InvokeCallbackArgument<1>())
       .WillOnce(InvokeCallbackArgument<0>());
   ASSERT_TRUE(RunComponentExtensionTest("bluetooth_private/disconnect"))
       << message_;
 }
 
 // Device::Forget not implemented on OSX.
 #if !defined(OS_MACOSX)
 IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest, ForgetDevice) {
-  EXPECT_CALL(*mock_device_.get(), Forget(_, _))
+  EXPECT_CALL(*mock_device_, Forget(_, _))
       .WillOnce(
           WithArgs<0>(Invoke(this, &BluetoothPrivateApiTest::ForgetDevice)));
   ASSERT_TRUE(RunComponentExtensionTest("bluetooth_private/forget_device"))
       << message_;
 }
 #endif
 
 IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest, DiscoveryFilter) {
   mock_discovery_session_ = new NiceMock<MockBluetoothDiscoverySession>();
 
   BluetoothDiscoveryFilter discovery_filter(device::BLUETOOTH_TRANSPORT_LE);
   discovery_filter.SetPathloss(50);
   discovery_filter.AddUUID(BluetoothUUID("cafe"));
   discovery_filter.AddUUID(
       BluetoothUUID("0000bebe-0000-1000-8000-00805f9b34fb"));
 
-  EXPECT_CALL(*mock_adapter_.get(), StartDiscoverySessionWithFilterRaw(
-                                        IsFilterEqual(&discovery_filter), _, _))
+  EXPECT_CALL(*mock_adapter_, StartDiscoverySessionWithFilterRaw(
+                                  IsFilterEqual(&discovery_filter), _, _))
       .Times(1)
       .WillOnce(WithArgs<1>(Invoke(
           this, &BluetoothPrivateApiTest::CallSetDiscoveryFilterCallback)));
   EXPECT_CALL(*mock_discovery_session_, IsActive())
       .Times(1)
       .WillOnce(Return(true));
   EXPECT_CALL(*mock_discovery_session_,
               SetDiscoveryFilterRaw(Eq(nullptr), _, _))
       .Times(1)
       .WillOnce(InvokeCallbackArgument<1>());
   ASSERT_TRUE(RunComponentExtensionTest("bluetooth_private/discovery_filter"))
       << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest, Connect) {
-  EXPECT_CALL(*mock_device_.get(), IsConnected())
+  EXPECT_CALL(*mock_device_, IsConnected())
       .Times(2)
       .WillOnce(Return(false))
       .WillOnce(Return(true));
-  EXPECT_CALL(*mock_device_.get(), Connect(_, _, _))
+  EXPECT_CALL(*mock_device_, Connect(_, _, _))
       .WillOnce(InvokeCallbackArgument<1>());
   ASSERT_TRUE(RunComponentExtensionTest("bluetooth_private/connect"))
       << message_;
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothPrivateApiTest, Pair) {
-  EXPECT_CALL(*mock_adapter_.get(),
+  EXPECT_CALL(*mock_adapter_,
               AddPairingDelegate(
                   _, device::BluetoothAdapter::PAIRING_DELEGATE_PRIORITY_HIGH));
   EXPECT_CALL(*mock_device_, ExpectingConfirmation())
       .WillRepeatedly(Return(true));
-  EXPECT_CALL(*mock_device_.get(), Pair(_, _, _))
+  EXPECT_CALL(*mock_device_, Pair(_, _, _))
       .WillOnce(DoAll(
           WithoutArgs(Invoke(
               this,
               &BluetoothPrivateApiTest::DispatchConfirmPasskeyPairingEvent)),
           InvokeCallbackArgument<1>()));
   ASSERT_TRUE(RunComponentExtensionTest("bluetooth_private/pair")) << message_;
 }
 
 }  // namespace extensions