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

chrome/browser/extensions/api/tabs/tabs_test.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>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_service.h"
@@ skipping 618 matching lines @@
 };
 
 void ExtensionTabsZoomTest::SetUpOnMainThread() {
   ExtensionTabsTest::SetUpOnMainThread();
   extension_ = utils::CreateEmptyExtension();
 }
 
 bool ExtensionTabsZoomTest::RunSetZoom(int tab_id, double zoom_factor) {
   scoped_refptr<TabsSetZoomFunction> set_zoom_function(
       new TabsSetZoomFunction());
-  set_zoom_function->set_extension(extension_);
+  set_zoom_function->set_extension(extension_.get());
   set_zoom_function->set_has_callback(true);
 
   return utils::RunFunction(
       set_zoom_function.get(),
       base::StringPrintf("[%u, %lf]", tab_id, zoom_factor),
       browser(),
       extension_function_test_utils::NONE);
 }
 
 testing::AssertionResult ExtensionTabsZoomTest::RunGetZoom(
     int tab_id,
     double* zoom_factor) {
   scoped_refptr<TabsGetZoomFunction> get_zoom_function(
       new TabsGetZoomFunction());
-  get_zoom_function->set_extension(extension_);
+  get_zoom_function->set_extension(extension_.get());
   get_zoom_function->set_has_callback(true);
 
   scoped_ptr<base::Value> get_zoom_result(
       utils::RunFunctionAndReturnSingleResult(
           get_zoom_function.get(),
           base::StringPrintf("[%u]", tab_id),
           browser()));
 
   if (!get_zoom_result)
     return testing::AssertionFailure() << "no result";
   if (!get_zoom_result->GetAsDouble(zoom_factor))
     return testing::AssertionFailure() << "result was not a double";
 
   return testing::AssertionSuccess();
 }
 
 bool ExtensionTabsZoomTest::RunSetZoomSettings(int tab_id,
                                                const char* mode,
                                                const char* scope) {
   scoped_refptr<TabsSetZoomSettingsFunction> set_zoom_settings_function(
       new TabsSetZoomSettingsFunction());
-  set_zoom_settings_function->set_extension(extension_);
+  set_zoom_settings_function->set_extension(extension_.get());
 
   std::string args;
   if (scope) {
     args = base::StringPrintf("[%u, {\"mode\": \"%s\", \"scope\": \"%s\"}]",
                               tab_id, mode, scope);
   } else {
     args = base::StringPrintf("[%u, {\"mode\": \"%s\"}]", tab_id, mode);
   }
 
   return utils::RunFunction(set_zoom_settings_function.get(),
                             args,
                             browser(),
                             extension_function_test_utils::NONE);
 }
 
 testing::AssertionResult ExtensionTabsZoomTest::RunGetZoomSettings(
     int tab_id,
     std::string* mode,
     std::string* scope) {
   DCHECK(mode);
   DCHECK(scope);
   scoped_refptr<TabsGetZoomSettingsFunction> get_zoom_settings_function(
       new TabsGetZoomSettingsFunction());
-  get_zoom_settings_function->set_extension(extension_);
+  get_zoom_settings_function->set_extension(extension_.get());
   get_zoom_settings_function->set_has_callback(true);
 
   scoped_ptr<base::DictionaryValue> get_zoom_settings_result(
       utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
           get_zoom_settings_function.get(),
           base::StringPrintf("[%u]", tab_id),
           browser())));
 
   if (!get_zoom_settings_result)
     return testing::AssertionFailure() << "no result";
 
   *mode = utils::GetString(get_zoom_settings_result.get(), "mode");
   *scope = utils::GetString(get_zoom_settings_result.get(), "scope");
 
   return testing::AssertionSuccess();
 }
 
 std::string ExtensionTabsZoomTest::RunSetZoomExpectError(int tab_id,
                                                          double zoom_factor) {
   scoped_refptr<TabsSetZoomFunction> set_zoom_function(
       new TabsSetZoomFunction());
-  set_zoom_function->set_extension(extension_);
+  set_zoom_function->set_extension(extension_.get());
   set_zoom_function->set_has_callback(true);
 
   return utils::RunFunctionAndReturnError(
       set_zoom_function.get(),
       base::StringPrintf("[%u, %lf]", tab_id, zoom_factor),
       browser());
 }
 
 std::string ExtensionTabsZoomTest::RunSetZoomSettingsExpectError(
     int tab_id,
     const char* mode,
     const char* scope) {
   scoped_refptr<TabsSetZoomSettingsFunction> set_zoom_settings_function(
       new TabsSetZoomSettingsFunction());
-  set_zoom_settings_function->set_extension(extension_);
+  set_zoom_settings_function->set_extension(extension_.get());
 
   return utils::RunFunctionAndReturnError(set_zoom_settings_function.get(),
                                           base::StringPrintf(
                                               "[%u, {\"mode\": \"%s\", "
                                               "\"scope\": \"%s\"}]",
                                               tab_id,
                                               mode,
                                               scope),
                                           browser());
 }
@@ skipping 156 matching lines @@
   // Test chrome.tabs.setZoom().
   error = RunSetZoomExpectError(tab_id, 3.14159);
   EXPECT_TRUE(MatchPattern(error, manifest_errors::kCannotAccessChromeUrl));
 
   // chrome.tabs.setZoomSettings().
   error = RunSetZoomSettingsExpectError(tab_id, "manual", "per-tab");
   EXPECT_TRUE(MatchPattern(error, manifest_errors::kCannotAccessChromeUrl));
 }
 
 }  // namespace extensions