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

chrome/browser/extensions/api/identity/experimental_identity_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 "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/identity/experimental_identity_api.h"
 #include "chrome/browser/extensions/api/identity/identity_api.h"
 #include "chrome/browser/extensions/api/identity/web_auth_flow.h"
@@ skipping 301 matching lines @@
   EXPECT_TRUE(StartsWithASCII(error, errors::kAuthFailure, false));
   EXPECT_FALSE(func->login_ui_shown());
   EXPECT_FALSE(func->install_ui_shown());
 }
 
 IN_PROC_BROWSER_TEST_F(ExperimentalGetAuthTokenFunctionTest,
                        NonInteractiveMintAdviceSuccess) {
   scoped_refptr<const Extension> extension(CreateExtension(CLIENT_ID | SCOPES));
   scoped_refptr<ExperimentalMockGetAuthTokenFunction> func(
       new ExperimentalMockGetAuthTokenFunction());
-  func->set_extension(extension);
+  func->set_extension(extension.get());
   EXPECT_CALL(*func.get(), HasLoginToken()).WillOnce(Return(true));
   TestOAuth2MintTokenFlow* flow = new TestOAuth2MintTokenFlow(
       TestOAuth2MintTokenFlow::ISSUE_ADVICE_SUCCESS, func.get());
   EXPECT_CALL(*func.get(), CreateMintTokenFlow(_)).WillOnce(Return(flow));
   std::string error =
       utils::RunFunctionAndReturnError(func.get(), "[{}]", browser());
   EXPECT_EQ(std::string(errors::kNoGrant), error);
   EXPECT_FALSE(func->login_ui_shown());
   EXPECT_FALSE(func->install_ui_shown());
 
-  const OAuth2Info& oauth2_info = OAuth2Info::GetOAuth2Info(extension);
+  const OAuth2Info& oauth2_info = OAuth2Info::GetOAuth2Info(extension.get());
   EXPECT_EQ(
       IdentityTokenCacheValue::CACHE_STATUS_NOTFOUND,
       id_api()->GetCachedToken(extension->id(), oauth2_info.scopes).status());
 }
 
 IN_PROC_BROWSER_TEST_F(ExperimentalGetAuthTokenFunctionTest,
                        NonInteractiveMintBadCredentials) {
   scoped_refptr<ExperimentalMockGetAuthTokenFunction> func(
       new ExperimentalMockGetAuthTokenFunction());
   func->set_extension(CreateExtension(CLIENT_ID | SCOPES));
   EXPECT_CALL(*func.get(), HasLoginToken()).WillOnce(Return(true));
   TestOAuth2MintTokenFlow* flow = new TestOAuth2MintTokenFlow(
       TestOAuth2MintTokenFlow::MINT_TOKEN_BAD_CREDENTIALS, func.get());
   EXPECT_CALL(*func.get(), CreateMintTokenFlow(_)).WillOnce(Return(flow));
   std::string error =
       utils::RunFunctionAndReturnError(func.get(), "[{}]", browser());
   EXPECT_TRUE(StartsWithASCII(error, errors::kAuthFailure, false));
   EXPECT_FALSE(func->login_ui_shown());
   EXPECT_FALSE(func->install_ui_shown());
 }
 
 IN_PROC_BROWSER_TEST_F(ExperimentalGetAuthTokenFunctionTest,
                        NonInteractiveSuccess) {
   scoped_refptr<ExperimentalMockGetAuthTokenFunction> func(
       new ExperimentalMockGetAuthTokenFunction());
   scoped_refptr<const Extension> extension(CreateExtension(CLIENT_ID | SCOPES));
-  func->set_extension(extension);
-  const OAuth2Info& oauth2_info = OAuth2Info::GetOAuth2Info(extension);
+  func->set_extension(extension.get());
+  const OAuth2Info& oauth2_info = OAuth2Info::GetOAuth2Info(extension.get());
   EXPECT_CALL(*func.get(), HasLoginToken()).WillOnce(Return(true));
   TestOAuth2MintTokenFlow* flow = new TestOAuth2MintTokenFlow(
       TestOAuth2MintTokenFlow::MINT_TOKEN_SUCCESS, func.get());
   EXPECT_CALL(*func.get(), CreateMintTokenFlow(_)).WillOnce(Return(flow));
   scoped_ptr<base::Value> value(
       utils::RunFunctionAndReturnSingleResult(func.get(), "[{}]", browser()));
   std::string access_token;
   EXPECT_TRUE(value->GetAsString(&access_token));
   EXPECT_EQ(std::string(kAccessToken), access_token);
   EXPECT_FALSE(func->login_ui_shown());
@@ skipping 122 matching lines @@
   EXPECT_TRUE(StartsWithASCII(error, errors::kAuthFailure, false));
   EXPECT_TRUE(func->login_ui_shown());
   EXPECT_TRUE(func->install_ui_shown());
 }
 
 IN_PROC_BROWSER_TEST_F(ExperimentalGetAuthTokenFunctionTest,
                        InteractiveLoginSuccessApprovalDoneMintSuccess) {
   scoped_refptr<ExperimentalMockGetAuthTokenFunction> func(
       new ExperimentalMockGetAuthTokenFunction());
   scoped_refptr<const Extension> extension(CreateExtension(CLIENT_ID | SCOPES));
-  func->set_extension(extension);
-  const OAuth2Info& oauth2_info = OAuth2Info::GetOAuth2Info(extension);
+  func->set_extension(extension.get());
+  const OAuth2Info& oauth2_info = OAuth2Info::GetOAuth2Info(extension.get());
   EXPECT_CALL(*func.get(), HasLoginToken()).WillOnce(Return(false));
   func->set_login_ui_result(true);
   TestOAuth2MintTokenFlow* flow1 = new TestOAuth2MintTokenFlow(
       TestOAuth2MintTokenFlow::ISSUE_ADVICE_SUCCESS, func.get());
   TestOAuth2MintTokenFlow* flow2 = new TestOAuth2MintTokenFlow(
       TestOAuth2MintTokenFlow::MINT_TOKEN_SUCCESS, func.get());
   EXPECT_CALL(*func.get(), CreateMintTokenFlow(_)).WillOnce(Return(flow1))
       .WillOnce(Return(flow2));
 
   func->set_install_ui_result(true);
@@ skipping 83 matching lines @@
         content::NotificationService::AllSources());
 
     scoped_refptr<ExperimentalIdentityLaunchWebAuthFlowFunction> function(
         new ExperimentalIdentityLaunchWebAuthFlowFunction());
 
     std::string args = base::StringPrintf(
         "[{\"interactive\": true, \"url\": \"data:text/html,auth\"%s%s}]",
         extra_params.length() ? "," : "",
         extra_params.c_str());
 
-    RunFunctionAsync(function, args);
+    RunFunctionAsync(function.get(), args);
 
     observer.Wait();
 
     Browser* web_auth_flow_browser =
         content::Source<Browser>(observer.source()).ptr();
     EXPECT_EQ(expected_x, web_auth_flow_browser->override_bounds().x());
     EXPECT_EQ(expected_y, web_auth_flow_browser->override_bounds().y());
     EXPECT_EQ(expected_width, web_auth_flow_browser->override_bounds().width());
     EXPECT_EQ(expected_height,
               web_auth_flow_browser->override_bounds().height());
@@ skipping 17 matching lines @@
 IN_PROC_BROWSER_TEST_F(ExperimentalLaunchWebAuthFlowFunctionTest,
                        UserCloseWindow) {
   content::WindowedNotificationObserver observer(
       chrome::NOTIFICATION_BROWSER_WINDOW_READY,
       content::NotificationService::AllSources());
 
   scoped_refptr<ExperimentalIdentityLaunchWebAuthFlowFunction> function(
       new ExperimentalIdentityLaunchWebAuthFlowFunction());
 
   RunFunctionAsync(
-      function, "[{\"interactive\": true, \"url\": \"data:text/html,auth\"}]");
+      function.get(),
+      "[{\"interactive\": true, \"url\": \"data:text/html,auth\"}]");
 
   observer.Wait();
   Browser* web_auth_flow_browser =
       content::Source<Browser>(observer.source()).ptr();
   web_auth_flow_browser->window()->Close();
 
-  EXPECT_EQ(std::string(errors::kUserRejected), WaitForError(function));
+  EXPECT_EQ(std::string(errors::kUserRejected), WaitForError(function.get()));
 }
 
 IN_PROC_BROWSER_TEST_F(ExperimentalLaunchWebAuthFlowFunctionTest,
                        InteractionRequired) {
   scoped_refptr<ExperimentalIdentityLaunchWebAuthFlowFunction> function(
       new ExperimentalIdentityLaunchWebAuthFlowFunction());
   scoped_refptr<Extension> empty_extension(utils::CreateEmptyExtension());
   function->set_extension(empty_extension.get());
 
   std::string error = utils::RunFunctionAndReturnError(
-      function,
+      function.get(),
       "[{\"interactive\": false, \"url\": \"data:text/html,auth\"}]",
       browser());
 
   EXPECT_EQ(std::string(errors::kInteractionRequired), error);
 }
 
 IN_PROC_BROWSER_TEST_F(ExperimentalLaunchWebAuthFlowFunctionTest,
                        NonInteractiveSuccess) {
   scoped_refptr<ExperimentalIdentityLaunchWebAuthFlowFunction> function(
       new ExperimentalIdentityLaunchWebAuthFlowFunction());
   scoped_refptr<Extension> empty_extension(utils::CreateEmptyExtension());
   function->set_extension(empty_extension.get());
 
   function->InitFinalRedirectURLPrefixesForTest("abcdefghij");
   scoped_ptr<base::Value> value(utils::RunFunctionAndReturnSingleResult(
-      function,
+      function.get(),
       "[{\"interactive\": false,"
       "\"url\": \"https://abcdefghij.chromiumapp.org/callback#test\"}]",
       browser()));
 
   std::string url;
   EXPECT_TRUE(value->GetAsString(&url));
   EXPECT_EQ(std::string("https://abcdefghij.chromiumapp.org/callback#test"),
             url);
 }
 
 IN_PROC_BROWSER_TEST_F(ExperimentalLaunchWebAuthFlowFunctionTest,
                        InteractiveFirstNavigationSuccess) {
   scoped_refptr<ExperimentalIdentityLaunchWebAuthFlowFunction> function(
       new ExperimentalIdentityLaunchWebAuthFlowFunction());
   scoped_refptr<Extension> empty_extension(utils::CreateEmptyExtension());
   function->set_extension(empty_extension.get());
 
   function->InitFinalRedirectURLPrefixesForTest("abcdefghij");
   scoped_ptr<base::Value> value(utils::RunFunctionAndReturnSingleResult(
-      function,
+      function.get(),
       "[{\"interactive\": true,"
       "\"url\": \"https://abcdefghij.chromiumapp.org/callback#test\"}]",
       browser()));
 
   std::string url;
   EXPECT_TRUE(value->GetAsString(&url));
   EXPECT_EQ(std::string("https://abcdefghij.chromiumapp.org/callback#test"),
             url);
 }
 
 IN_PROC_BROWSER_TEST_F(ExperimentalLaunchWebAuthFlowFunctionTest,
                        InteractiveSecondNavigationSuccess) {
   scoped_refptr<ExperimentalIdentityLaunchWebAuthFlowFunction> function(
       new ExperimentalIdentityLaunchWebAuthFlowFunction());
   scoped_refptr<Extension> empty_extension(utils::CreateEmptyExtension());
   function->set_extension(empty_extension.get());
 
   function->InitFinalRedirectURLPrefixesForTest("abcdefghij");
   scoped_ptr<base::Value> value(utils::RunFunctionAndReturnSingleResult(
-      function,
+      function.get(),
       "[{\"interactive\": true,"
       "\"url\": \"data:text/html,<script>window.location.replace('"
       "https://abcdefghij.chromiumapp.org/callback#test')</script>\"}]",
       browser()));
 
   std::string url;
   EXPECT_TRUE(value->GetAsString(&url));
   EXPECT_EQ(std::string("https://abcdefghij.chromiumapp.org/callback#test"),
             url);
 }
 
 }  // namespace extensions