Call scoped_refptr<T>::get() rather than relying on implicit "operator T*"

chrome/browser/automation/testing_automation_provider.cc

 // Copyright 2013 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 "chrome/browser/automation/testing_automation_provider.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 1268 matching lines @@
   }
   BookmarkModel* bookmark_model =
       BookmarkModelFactory::GetForProfile(browser->profile());
   if (!bookmark_model->loaded()) {
     reply.SendError("Bookmark model is not loaded");
     return;
   }
   scoped_refptr<BookmarkStorage> storage(
       new BookmarkStorage(browser->profile(),
                           bookmark_model,
-                          browser->profile()->GetIOTaskRunner()));
+                          browser->profile()->GetIOTaskRunner().get()));
   if (!storage->SerializeData(&bookmarks_as_json)) {
     reply.SendError("Failed to serialize bookmarks");
     return;
   }
   DictionaryValue dict;
   dict.SetString("bookmarks_as_json", bookmarks_as_json);
   reply.SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::WaitForBookmarkModelToLoad(
@@ skipping 1802 matching lines @@
   PluginService::GetInstance()->GetPlugins(
       base::Bind(&TestingAutomationProvider::GetPluginsInfoCallback,
           this, browser, args, reply_message));
 }
 
 void TestingAutomationProvider::GetPluginsInfoCallback(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message,
     const std::vector<webkit::WebPluginInfo>& plugins) {
-  PluginPrefs* plugin_prefs = PluginPrefs::GetForProfile(browser->profile());
+  PluginPrefs* plugin_prefs =
+      PluginPrefs::GetForProfile(browser->profile()).get();
   ListValue* items = new ListValue;
   for (std::vector<webkit::WebPluginInfo>::const_iterator it =
            plugins.begin();
        it != plugins.end();
        ++it) {
     DictionaryValue* item = new DictionaryValue;
     item->SetString("name", it->name);
     item->SetString("path", it->path.value());
     item->SetString("version", it->version);
     item->SetString("desc", it->desc);
@@ skipping 32 matching lines @@
 //    { "command": "EnablePlugin",
 //      "path": "/Library/Internet Plug-Ins/Flash Player.plugin" }
 void TestingAutomationProvider::EnablePlugin(Browser* browser,
                                              DictionaryValue* args,
                                              IPC::Message* reply_message) {
   base::FilePath::StringType path;
   if (!args->GetString("path", &path)) {
     AutomationJSONReply(this, reply_message).SendError("path not specified.");
     return;
   }
-  PluginPrefs* plugin_prefs = PluginPrefs::GetForProfile(browser->profile());
-  plugin_prefs->EnablePlugin(true, base::FilePath(path),
-      base::Bind(&DidEnablePlugin, AsWeakPtr(), reply_message,
-                 path, "Could not enable plugin for path %s."));
+  PluginPrefs* plugin_prefs =
+      PluginPrefs::GetForProfile(browser->profile()).get();
+  plugin_prefs->EnablePlugin(
+      true,
+      base::FilePath(path),
+      base::Bind(&DidEnablePlugin,
+                 AsWeakPtr(),
+                 reply_message,
+                 path,
+                 "Could not enable plugin for path %s."));
 }
 
 // Sample json input:
 //    { "command": "DisablePlugin",
 //      "path": "/Library/Internet Plug-Ins/Flash Player.plugin" }
 void TestingAutomationProvider::DisablePlugin(Browser* browser,
                                               DictionaryValue* args,
                                               IPC::Message* reply_message) {
   base::FilePath::StringType path;
   if (!args->GetString("path", &path)) {
     AutomationJSONReply(this, reply_message).SendError("path not specified.");
     return;
   }
-  PluginPrefs* plugin_prefs = PluginPrefs::GetForProfile(browser->profile());
-  plugin_prefs->EnablePlugin(false, base::FilePath(path),
-      base::Bind(&DidEnablePlugin, AsWeakPtr(), reply_message,
-                 path, "Could not disable plugin for path %s."));
+  PluginPrefs* plugin_prefs =
+      PluginPrefs::GetForProfile(browser->profile()).get();
+  plugin_prefs->EnablePlugin(
+      false,
+      base::FilePath(path),
+      base::Bind(&DidEnablePlugin,
+                 AsWeakPtr(),
+                 reply_message,
+                 path,
+                 "Could not disable plugin for path %s."));
 }
 
 // Sample json input:
 //    { "command": "SaveTabContents",
 //      "tab_index": 0,
 //      "filename": <a full pathname> }
 // Sample json output:
 //    {}
 void TestingAutomationProvider::SaveTabContents(
     Browser* browser,
@@ skipping 158 matching lines @@
     AutomationJSONReply(this, reply_message).SendError(
         "Password must include a value for 'signon_realm.'");
     return;
   }
 
   content::PasswordForm new_password =
       GetPasswordFormFromDict(*password_dict);
 
   // Use IMPLICIT_ACCESS since new passwords aren't added in incognito mode.
   PasswordStore* password_store = PasswordStoreFactory::GetForProfile(
-      browser->profile(), Profile::IMPLICIT_ACCESS);
+      browser->profile(), Profile::IMPLICIT_ACCESS).get();
 
   // The password store does not exist for an incognito window.
   if (password_store == NULL) {
     scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
     return_value->SetBoolean("password_added", false);
     AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
     return;
   }
 
   // This observer will delete itself.
@@ skipping 25 matching lines @@
   if (!password_dict->HasKey("signon_realm")) {
     AutomationJSONReply(this, reply_message).SendError(
         "Password must include a value for 'signon_realm.'");
     return;
   }
   content::PasswordForm to_remove =
       GetPasswordFormFromDict(*password_dict);
 
   // Use EXPLICIT_ACCESS since passwords can be removed in incognito mode.
   PasswordStore* password_store = PasswordStoreFactory::GetForProfile(
-      browser->profile(), Profile::EXPLICIT_ACCESS);
+      browser->profile(), Profile::EXPLICIT_ACCESS).get();
   if (password_store == NULL) {
     AutomationJSONReply(this, reply_message).SendError(
         "Unable to get password store.");
     return;
   }
 
   // This observer will delete itself.
   PasswordStoreLoginsChangedObserver* observer =
       new PasswordStoreLoginsChangedObserver(
           this, reply_message, PasswordStoreChange::REMOVE, std::string());
   observer->Init();
 
   password_store->RemoveLogin(to_remove);
 }
 
 // Sample json input: { "command": "GetSavedPasswords" }
 // Refer to GetSavedPasswords() in chrome/test/pyautolib/pyauto.py for sample
 // json output.
 void TestingAutomationProvider::GetSavedPasswords(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   // Use EXPLICIT_ACCESS since saved passwords can be retrieved in
   // incognito mode.
   PasswordStore* password_store = PasswordStoreFactory::GetForProfile(
-      browser->profile(), Profile::EXPLICIT_ACCESS);
+      browser->profile(), Profile::EXPLICIT_ACCESS).get();
 
   if (password_store == NULL) {
     AutomationJSONReply reply(this, reply_message);
     reply.SendError("Unable to get password store.");
     return;
   }
   password_store->GetAutofillableLogins(
       new AutomationProviderGetPasswordsObserver(this, reply_message));
   // Observer deletes itself after sending the result.
 }
@@ skipping 2238 matching lines @@
   if (g_browser_process)
     g_browser_process->GetAutomationProviderList()->RemoveProvider(this);
 }
 
 void TestingAutomationProvider::EnsureTabSelected(Browser* browser,
                                                   WebContents* tab) {
   TabStripModel* tab_strip = browser->tab_strip_model();
   if (tab_strip->GetActiveWebContents() != tab)
     tab_strip->ActivateTabAt(tab_strip->GetIndexOfWebContents(tab), true);
 }