Update chrome/ to use scoped_refptr<T>::get() rather than implicit "operator T*"

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

 // Copyright (c) 2012 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 <string.h>
 
 #include "base/stringprintf.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_api.h"
 #include "chrome/browser/extensions/api/bluetooth/bluetooth_event_router.h"
 #include "chrome/browser/extensions/api/permissions/permissions_api.h"
@@ skipping 150 matching lines @@
   callback.Run(GetOutOfBandPairingData());
 }
 
 }  // namespace
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, Profiles) {
   EXPECT_CALL(*profile1_, SetConnectionCallback(testing::_));
   scoped_refptr<TestBluetoothAddProfileFunction> add_profile_function;
   add_profile_function = setupFunction(
       new TestBluetoothAddProfileFunction(profile1_.get()));
-  std::string error(
-      utils::RunFunctionAndReturnError(
-          add_profile_function,
-          "[{\"uuid\": \"1234\"}]",
-          browser()));
+  std::string error(utils::RunFunctionAndReturnError(
+      add_profile_function.get(), "[{\"uuid\": \"1234\"}]", browser()));
   ASSERT_TRUE(error.empty());
 
   // Registering the profile for the same uuid again will throw an error.
   add_profile_function = setupFunction(
       new TestBluetoothAddProfileFunction(profile2_.get()));
   error = utils::RunFunctionAndReturnError(
-      add_profile_function,
-      "[{\"uuid\": \"1234\"}]",
-      browser());
+      add_profile_function.get(), "[{\"uuid\": \"1234\"}]", browser());
   ASSERT_FALSE(error.empty());
 
   add_profile_function = setupFunction(
       new TestBluetoothAddProfileFunction(profile2_.get()));
   error = utils::RunFunctionAndReturnError(
-      add_profile_function,
-      "[{\"uuid\": \"5678\"}]",
-      browser());
+      add_profile_function.get(), "[{\"uuid\": \"5678\"}]", browser());
   ASSERT_TRUE(error.empty());
 
   scoped_refptr<api::BluetoothRemoveProfileFunction> remove_profile_function;
   remove_profile_function = setupFunction(
       new api::BluetoothRemoveProfileFunction());
   error = utils::RunFunctionAndReturnError(
-      remove_profile_function,
-      "[{\"uuid\": \"1234\"}]",
-      browser());
+      remove_profile_function.get(), "[{\"uuid\": \"1234\"}]", browser());
   ASSERT_TRUE(error.empty());
 
   remove_profile_function = setupFunction(
       new api::BluetoothRemoveProfileFunction());
   error = utils::RunFunctionAndReturnError(
-      remove_profile_function,
-      "[{\"uuid\": \"5678\"}]",
-      browser());
+      remove_profile_function.get(), "[{\"uuid\": \"5678\"}]", browser());
   ASSERT_TRUE(error.empty());
 
   // Removing the same profile again will throw an error.
   remove_profile_function = setupFunction(
       new api::BluetoothRemoveProfileFunction());
   error = utils::RunFunctionAndReturnError(
-      remove_profile_function,
-      "[{\"uuid\": \"5678\"}]",
-      browser());
+      remove_profile_function.get(), "[{\"uuid\": \"5678\"}]", browser());
   ASSERT_FALSE(error.empty());
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, GetAdapterState) {
   EXPECT_CALL(*mock_adapter_, GetAddress())
       .WillOnce(testing::Return(kAdapterAddress));
   EXPECT_CALL(*mock_adapter_, GetName())
       .WillOnce(testing::Return(kName));
   EXPECT_CALL(*mock_adapter_, IsPresent())
       .WillOnce(testing::Return(false));
   EXPECT_CALL(*mock_adapter_, IsPowered())
       .WillOnce(testing::Return(true));
   EXPECT_CALL(*mock_adapter_, IsDiscovering())
       .WillOnce(testing::Return(false));
 
   scoped_refptr<api::BluetoothGetAdapterStateFunction> get_adapter_state;
   get_adapter_state = setupFunction(new api::BluetoothGetAdapterStateFunction);
 
   scoped_ptr<base::Value> result(utils::RunFunctionAndReturnSingleResult(
-        get_adapter_state, "[]", browser()));
+      get_adapter_state.get(), "[]", browser()));
   ASSERT_TRUE(result.get() != NULL);
   api::bluetooth::AdapterState state;
   ASSERT_TRUE(api::bluetooth::AdapterState::Populate(*result, &state));
 
   EXPECT_FALSE(state.available);
   EXPECT_TRUE(state.powered);
   EXPECT_FALSE(state.discovering);
   EXPECT_EQ(kName, state.name);
   EXPECT_EQ(kAdapterAddress, state.address);
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, GetLocalOutOfBandPairingData) {
   EXPECT_CALL(*mock_adapter_,
               ReadLocalOutOfBandPairingData(testing::_, testing::_))
       .WillOnce(testing::Invoke(CallOutOfBandPairingDataCallback));
 
   scoped_refptr<api::BluetoothGetLocalOutOfBandPairingDataFunction>
       get_oob_function(setupFunction(
             new api::BluetoothGetLocalOutOfBandPairingDataFunction));
 
   scoped_ptr<base::Value> result(utils::RunFunctionAndReturnSingleResult(
-      get_oob_function, "[]", browser()));
+      get_oob_function.get(), "[]", browser()));
 
   base::DictionaryValue* dict;
   EXPECT_TRUE(result->GetAsDictionary(&dict));
 
   base::BinaryValue* binary_value;
   EXPECT_TRUE(dict->GetBinary("hash", &binary_value));
   EXPECT_STREQ(kOutOfBandPairingDataHash,
       std::string(binary_value->GetBuffer(), binary_value->GetSize()).c_str());
   EXPECT_TRUE(dict->GetBinary("randomizer", &binary_value));
   EXPECT_STREQ(kOutOfBandPairingDataRandomizer,
       std::string(binary_value->GetBuffer(), binary_value->GetSize()).c_str());
 
   // Try again with an error
   testing::Mock::VerifyAndClearExpectations(mock_adapter_);
   EXPECT_CALL(*mock_adapter_,
               ReadLocalOutOfBandPairingData(
                   testing::_,
                   testing::Truly(CallClosure)));
 
   get_oob_function =
       setupFunction(new api::BluetoothGetLocalOutOfBandPairingDataFunction);
 
-  std::string error(
-      utils::RunFunctionAndReturnError(get_oob_function, "[]", browser()));
+  std::string error(utils::RunFunctionAndReturnError(
+      get_oob_function.get(), "[]", browser()));
   EXPECT_FALSE(error.empty());
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, SetOutOfBandPairingData) {
   EXPECT_CALL(*mock_adapter_, GetDevice(device1_->GetAddress()))
       .WillOnce(testing::Return(device1_.get()));
   EXPECT_CALL(*device1_,
               ClearOutOfBandPairingData(testing::Truly(CallClosure),
                                         testing::_));
 
   std::string params = base::StringPrintf(
       "[{\"deviceAddress\":\"%s\"}]", device1_->GetAddress().c_str());
 
   scoped_refptr<api::BluetoothSetOutOfBandPairingDataFunction> set_oob_function;
   set_oob_function = setupFunction(
       new api::BluetoothSetOutOfBandPairingDataFunction);
   // There isn't actually a result.
-  (void)utils::RunFunctionAndReturnSingleResult(
-      set_oob_function, params, browser());
+  (void) utils::RunFunctionAndReturnSingleResult(
+      set_oob_function.get(), params, browser());
 
   // Try again with an error
   testing::Mock::VerifyAndClearExpectations(mock_adapter_);
   testing::Mock::VerifyAndClearExpectations(device1_.get());
   EXPECT_CALL(*mock_adapter_, GetDevice(device1_->GetAddress()))
       .WillOnce(testing::Return(device1_.get()));
   EXPECT_CALL(*device1_,
               ClearOutOfBandPairingData(testing::_,
                                         testing::Truly(CallClosure)));
 
   set_oob_function = setupFunction(
       new api::BluetoothSetOutOfBandPairingDataFunction);
-  std::string error(
-      utils::RunFunctionAndReturnError(set_oob_function, params, browser()));
+  std::string error(utils::RunFunctionAndReturnError(
+      set_oob_function.get(), params, browser()));
   EXPECT_FALSE(error.empty());
 
   // TODO(bryeung): Also test setting the data when there is support for
   // ArrayBuffers in the arguments to the RunFunctionAnd* methods.
   // crbug.com/132796
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, Discovery) {
   // Try with a failure to start
   EXPECT_CALL(*mock_adapter_, StartDiscovering(testing::_, testing::_))
       .WillOnce(testing::Invoke(CallDiscoveryErrorCallback));
   // StartDiscovery failure will remove the adapter that is no longer used.
   EXPECT_CALL(*mock_adapter_, RemoveObserver(testing::_));
   scoped_refptr<api::BluetoothStartDiscoveryFunction> start_function;
   start_function = setupFunction(new api::BluetoothStartDiscoveryFunction);
   std::string error(
-      utils::RunFunctionAndReturnError(start_function, "[]", browser()));
+      utils::RunFunctionAndReturnError(start_function.get(), "[]", browser()));
   ASSERT_FALSE(error.empty());
 
   // Reset for a successful start
   SetUpMockAdapter();
   EXPECT_CALL(*mock_adapter_, StartDiscovering(testing::_, testing::_))
       .WillOnce(testing::Invoke(CallDiscoveryCallback));
 
   start_function = setupFunction(new api::BluetoothStartDiscoveryFunction);
-  (void)utils::RunFunctionAndReturnError(start_function, "[]", browser());
+  (void)
+      utils::RunFunctionAndReturnError(start_function.get(), "[]", browser());
 
   // Reset to try stopping
   testing::Mock::VerifyAndClearExpectations(mock_adapter_);
   EXPECT_CALL(*mock_adapter_, StopDiscovering(testing::_, testing::_))
       .WillOnce(testing::Invoke(CallDiscoveryCallback));
   // StopDiscovery success will remove the adapter that is no longer used.
   EXPECT_CALL(*mock_adapter_, RemoveObserver(testing::_));
   scoped_refptr<api::BluetoothStopDiscoveryFunction> stop_function;
   stop_function = setupFunction(new api::BluetoothStopDiscoveryFunction);
-  (void)utils::RunFunctionAndReturnSingleResult(stop_function, "[]", browser());
+  (void) utils::RunFunctionAndReturnSingleResult(
+      stop_function.get(), "[]", browser());
 
   // Reset to try stopping with an error
   SetUpMockAdapter();
   EXPECT_CALL(*mock_adapter_, StopDiscovering(testing::_, testing::_))
       .WillOnce(testing::Invoke(CallDiscoveryErrorCallback));
   EXPECT_CALL(*mock_adapter_, RemoveObserver(testing::_));
   stop_function = setupFunction(new api::BluetoothStopDiscoveryFunction);
-  error = utils::RunFunctionAndReturnError(stop_function, "[]", browser());
+  error =
+      utils::RunFunctionAndReturnError(stop_function.get(), "[]", browser());
   ASSERT_FALSE(error.empty());
   SetUpMockAdapter();
 }
 
 IN_PROC_BROWSER_TEST_F(BluetoothApiTest, DiscoveryCallback) {
   EXPECT_CALL(*mock_adapter_, StartDiscovering(testing::_, testing::_))
       .WillOnce(testing::Invoke(CallDiscoveryCallback));
   EXPECT_CALL(*mock_adapter_, StopDiscovering(testing::_, testing::_))
       .WillOnce(testing::Invoke(CallDiscoveryCallback));
 
@@ skipping 218 matching lines @@
       "00001101-0000-1000-8000-00805f9b34fb", profile1_.get());
 
   EXPECT_CALL(*mock_adapter_, GetDevice(device1_->GetAddress()))
       .WillOnce(testing::Return(device1_.get()));
   EXPECT_CALL(*device1_,
               ConnectToProfile(testing::_, testing::_, testing::_))
       .WillOnce(testing::Invoke(CallConnectToProfileCallback));
 
   EXPECT_TRUE(RunExtensionTest("bluetooth/permissions")) << message_;
 }