[Cleanup] Remove StringPrintf from global namespace

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 192 matching lines @@
 void DidEnablePlugin(base::WeakPtr<AutomationProvider> automation,
                      IPC::Message* reply_message,
                      const base::FilePath::StringType& path,
                      const std::string& error_msg,
                      bool did_enable) {
   if (did_enable) {
     SendSuccessReply(automation, reply_message);
   } else {
     if (automation) {
       AutomationJSONReply(automation.get(), reply_message).SendError(
-          StringPrintf(error_msg.c_str(), path.c_str()));
+          base::StringPrintf(error_msg.c_str(), path.c_str()));
     }
   }
 }
 
 // Helper to resolve the overloading of PostTask.
 void PostTask(BrowserThread::ID id, const base::Closure& callback) {
   BrowserThread::PostTask(id, FROM_HERE, callback);
 }
 
 class AutomationInterstitialPage : public content::InterstitialPageDelegate {
@@ skipping 929 matching lines @@
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   base::FilePath::StringType path;
   if (!args->GetString("path", &path)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Invalid or missing arg: 'path'");
     return;
   }
   Profile* profile = profile_manager->GetProfileByPath(base::FilePath(path));
   if (!profile) {
     AutomationJSONReply(this, reply_message).SendError(
-        StringPrintf("Invalid profile path: %s", path.c_str()));
+        base::StringPrintf("Invalid profile path: %s", path.c_str()));
     return;
   }
   int num_loads;
   if (!args->GetInteger("num_loads", &num_loads)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Invalid or missing arg: 'num_loads'");
     return;
   }
   new BrowserOpenedWithExistingProfileNotificationObserver(
       this, reply_message, num_loads);
@@ skipping 810 matching lines @@
         "The browser window does not exist.");
   }
 }
 
 void TestingAutomationProvider::SendJSONRequestWithBrowserIndex(
     int index,
     const std::string& json_request,
     IPC::Message* reply_message) {
   Browser* browser = index < 0 ? NULL : automation_util::GetBrowserAt(index);
   if (!browser && index >= 0) {
-    AutomationJSONReply(this, reply_message).SendError(
-        StringPrintf("Browser window with index=%d does not exist.", index));
+    AutomationJSONReply(this, reply_message).SendError(base::StringPrintf(
+        "Browser window with index=%d does not exist.", index));
   } else {
     SendJSONRequest(browser, json_request, reply_message);
   }
 }
 
 void TestingAutomationProvider::SendJSONRequest(Browser* browser,
                                                 const std::string& json_request,
                                                 IPC::Message* reply_message) {
   std::string command, error_string;
   scoped_ptr<DictionaryValue> dict_value(
       ParseJSONRequestCommand(json_request, &command, &error_string));
   if (!dict_value.get() || command.empty()) {
     AutomationJSONReply(this, reply_message).SendError(error_string);
     return;
   }
 
   if (handler_map_.empty() || browser_handler_map_.empty())
     BuildJSONHandlerMaps();
 
   // Look for command in handlers that take a Browser.
   if (browser_handler_map_.find(std::string(command)) !=
       browser_handler_map_.end() && browser) {
     (this->*browser_handler_map_[command])(browser, dict_value.get(),
                                            reply_message);
   // Look for command in handlers that don't take a Browser.
   } else if (handler_map_.find(std::string(command)) != handler_map_.end()) {
     (this->*handler_map_[command])(dict_value.get(), reply_message);
   // Command has no handler.
   } else {
-    error_string = StringPrintf("Unknown command '%s'. Options: ",
-                                command.c_str());
+    error_string = base::StringPrintf("Unknown command '%s'. Options: ",
+                                      command.c_str());
     for (std::map<std::string, JsonHandler>::const_iterator it =
          handler_map_.begin(); it != handler_map_.end(); ++it) {
       error_string += it->first + ", ";
     }
     for (std::map<std::string, BrowserJsonHandler>::const_iterator it =
          browser_handler_map_.begin(); it != browser_handler_map_.end(); ++it) {
       error_string += it->first + ", ";
     }
     AutomationJSONReply(this, reply_message).SendError(error_string);
   }
@@ skipping 107 matching lines @@
   if (!args->GetInteger("tab_index", &tab_index) ||
       !args->GetInteger("infobar_index", &infobar_index_int) ||
       !args->GetString("action", &action)) {
     reply.SendError("Invalid or missing args");
     return;
   }
 
   WebContents* web_contents =
       browser->tab_strip_model()->GetWebContentsAt(tab_index);
   if (!web_contents) {
-    reply.SendError(StringPrintf("No such tab at index %d", tab_index));
+    reply.SendError(base::StringPrintf("No such tab at index %d", tab_index));
     return;
   }
   InfoBarService* infobar_service =
       InfoBarService::FromWebContents(web_contents);
 
   InfoBarDelegate* infobar = NULL;
   size_t infobar_index = static_cast<size_t>(infobar_index_int);
   if (infobar_index >= infobar_service->GetInfoBarCount()) {
-    reply.SendError(StringPrintf("No such infobar at index %" PRIuS,
-                                 infobar_index));
+    reply.SendError(base::StringPrintf("No such infobar at index %" PRIuS,
+                                       infobar_index));
     return;
   }
   infobar = infobar_service->GetInfoBarDelegateAt(infobar_index);
 
   if ("dismiss" == action) {
     infobar->InfoBarDismissed();
     infobar_service->RemoveInfoBar(infobar);
     reply.SendSuccess(NULL);
     return;
   }
@@ skipping 378 matching lines @@
 }
 
 void TestingAutomationProvider::WaitForAllDownloadsToComplete(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   ListValue* pre_download_ids = NULL;
 
   if (!args->GetList("pre_download_ids", &pre_download_ids)) {
     AutomationJSONReply(this, reply_message)
-        .SendError(StringPrintf("List of IDs of previous downloads required."));
+        .SendError(
+            base::StringPrintf("List of IDs of previous downloads required."));
     return;
   }
 
   DownloadService* download_service =
       DownloadServiceFactory::GetForProfile(browser->profile());
   if (!download_service->HasCreatedDownloadManager()) {
     // No download manager, so no downloads to wait for.
     AutomationJSONReply(this, reply_message).SendSuccess(NULL);
     return;
   }
@@ skipping 24 matching lines @@
     AutomationJSONReply(this, reply_message)
         .SendError("Must include int id and string action.");
     return;
   }
 
   DownloadManager* download_manager =
       BrowserContext::GetDownloadManager(browser->profile());
   DownloadItem* selected_item = download_manager->GetDownload(id);
   if (!selected_item) {
     AutomationJSONReply(this, reply_message)
-        .SendError(StringPrintf("No download with an id of %d\n", id));
+        .SendError(base::StringPrintf("No download with an id of %d\n", id));
     return;
   }
 
   // We need to be IN_PROGRESS for these actions.
   if ((action == "pause" || action == "resume" || action == "cancel") &&
       !selected_item->IsInProgress()) {
     AutomationJSONReply(this, reply_message)
         .SendError("Selected DownloadItem is not in progress.");
   }
 
@@ skipping 54 matching lines @@
       selected_item->AddObserver(new AutomationProviderDownloadUpdatedObserver(
           this, reply_message, false, browser->profile()->IsOffTheRecord()));
       selected_item->Resume();
     }
   } else if (action == "cancel") {
     selected_item->AddObserver(new AutomationProviderDownloadUpdatedObserver(
         this, reply_message, false, browser->profile()->IsOffTheRecord()));
     selected_item->Cancel(true);
   } else {
     AutomationJSONReply(this, reply_message)
-        .SendError(StringPrintf("Invalid action '%s' given.", action.c_str()));
+        .SendError(
+            base::StringPrintf("Invalid action '%s' given.", action.c_str()));
   }
 }
 
 void TestingAutomationProvider::SetDownloadShelfVisibleJSON(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   std::string error_msg;
   bool is_visible;
@@ skipping 756 matching lines @@
                                     std::string* error_message) {
   int tab_index;
   if (!args->GetInteger("tab_index", &tab_index)) {
     *error_message = "Must include tab_index.";
     return NULL;
   }
 
   WebContents* web_contents =
       browser->tab_strip_model()->GetWebContentsAt(tab_index);
   if (!web_contents) {
-    *error_message = StringPrintf("No tab at index %d.", tab_index);
+    *error_message = base::StringPrintf("No tab at index %d.", tab_index);
     return NULL;
   }
   return web_contents;
 }
 
 }  // namespace
 
 void TestingAutomationProvider::FindInPage(
     Browser* browser,
     DictionaryValue* args,
@@ skipping 426 matching lines @@
   for (int i = 0; i < num_browser_actions; ++i) {
     if (extension->id() == browser_actions.GetExtensionId(i)) {
       action_index = i;
       break;
     }
   }
 #else
   // TODO(kkania): Implement the platform-specific GetExtensionId() in
   // BrowserActionTestUtil.
   if (num_browser_actions != 1) {
-    AutomationJSONReply(this, reply_message).SendError(StringPrintf(
+    AutomationJSONReply(this, reply_message).SendError(base::StringPrintf(
         "Found %d browser actions. Only one browser action must be active.",
         num_browser_actions));
     return;
   }
   // This extension has a browser action, and there's only one action, so this
   // must be the first one.
   action_index = 0;
 #endif
   if (action_index == -1) {
     AutomationJSONReply(this, reply_message).SendError(
@@ skipping 225 matching lines @@
         .SendError("'index' missing or invalid.");
     return;
   }
   BalloonNotificationUIManager* manager =
       BalloonNotificationUIManager::GetInstanceForTesting();
   BalloonCollection* collection = manager->balloon_collection();
   const BalloonCollection::Balloons& balloons = collection->GetActiveBalloons();
   int balloon_count = static_cast<int>(balloons.size());
   if (index < 0 || index >= balloon_count) {
     AutomationJSONReply(this, reply_message)
-        .SendError(StringPrintf("No notification at index %d", index));
+        .SendError(base::StringPrintf("No notification at index %d", index));
     return;
   }
   std::vector<const Notification*> queued_notes;
   manager->GetQueuedNotificationsForTesting(&queued_notes);
   if (queued_notes.empty()) {
     new OnNotificationBalloonCountObserver(
         this, reply_message, balloon_count - 1);
   } else {
     new NewNotificationBalloonObserver(this, reply_message);
   }
@@ skipping 429 matching lines @@
   if (!service) {
     AutomationJSONReply(this, reply_message).SendError(
         "No extensions service.");
     return;
   }
 
   const Extension* extension = service->GetExtensionById(
       id, false  /* do not include disabled extensions */);
   if (!extension) {
     AutomationJSONReply(this, reply_message).SendError(
-        StringPrintf("Extension with ID '%s' doesn't exist or is disabled.",
-                     id.c_str()));
+        base::StringPrintf(
+            "Extension with ID '%s' doesn't exist or is disabled.",
+            id.c_str()));
     return;
   }
 
   WebContents* old_contents =
       browser->tab_strip_model()->GetActiveWebContents();
   if (!old_contents) {
     AutomationJSONReply(this, reply_message).SendError(
         "Cannot identify selected tab contents.");
     return;
   }
@@ skipping 30 matching lines @@
   ExtensionService* service = extensions::ExtensionSystem::Get(
       browser->profile())->extension_service();
   if (!service) {
     reply.SendError("No extensions service.");
     return;
   }
 
   const Extension* extension = service->GetExtensionById(
       id, true  /* include disabled extensions */);
   if (!extension) {
-    reply.SendError(
-        StringPrintf("Extension with ID '%s' doesn't exist.", id.c_str()));
+    reply.SendError(base::StringPrintf(
+        "Extension with ID '%s' doesn't exist.", id.c_str()));
     return;
   }
 
   extensions::ExtensionPrefs::LaunchType launch_type;
   if (launch_type_str == "pinned") {
     launch_type = extensions::ExtensionPrefs::LAUNCH_PINNED;
   } else if (launch_type_str == "regular") {
     launch_type = extensions::ExtensionPrefs::LAUNCH_REGULAR;
   } else if (launch_type_str == "fullscreen") {
     launch_type = extensions::ExtensionPrefs::LAUNCH_FULLSCREEN;
   } else if (launch_type_str == "window") {
     launch_type = extensions::ExtensionPrefs::LAUNCH_WINDOW;
   } else {
-    reply.SendError(
-        StringPrintf("Unexpected launch type '%s'.", launch_type_str.c_str()));
+    reply.SendError(base::StringPrintf(
+        "Unexpected launch type '%s'.", launch_type_str.c_str()));
     return;
   }
 
   service->extension_prefs()->SetLaunchType(extension->id(), launch_type);
   reply.SendSuccess(NULL);
 }
 
 // Sample json input: { "command": "GetV8HeapStats",
 //                      "tab_index": 0 }
 // Refer to GetV8HeapStats() in chrome/test/pyautolib/pyauto.py for
 // sample json output.
 void TestingAutomationProvider::GetV8HeapStats(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   WebContents* web_contents;
   int tab_index;
   std::string error;
 
   if (!args->GetInteger("tab_index", &tab_index)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Missing 'tab_index' argument.");
     return;
   }
 
   web_contents = browser->tab_strip_model()->GetWebContentsAt(tab_index);
   if (!web_contents) {
-    AutomationJSONReply(this, reply_message).SendError(
-        StringPrintf("Could not get WebContents at tab index %d", tab_index));
+    AutomationJSONReply(this, reply_message).SendError(base::StringPrintf(
+        "Could not get WebContents at tab index %d", tab_index));
     return;
   }
 
   RenderViewHost* render_view = web_contents->GetRenderViewHost();
 
   // This observer will delete itself.
   new V8HeapStatsObserver(
       this, reply_message,
       base::GetProcId(render_view->GetProcess()->GetHandle()));
   render_view->Send(new ChromeViewMsg_GetV8HeapStats);
@@ skipping 12 matching lines @@
   std::string error;
 
   if (!args->GetInteger("tab_index", &tab_index)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Missing 'tab_index' argument.");
     return;
   }
 
   web_contents = browser->tab_strip_model()->GetWebContentsAt(tab_index);
   if (!web_contents) {
-    AutomationJSONReply(this, reply_message).SendError(
-        StringPrintf("Could not get WebContents at tab index %d", tab_index));
+    AutomationJSONReply(this, reply_message).SendError(base::StringPrintf(
+        "Could not get WebContents at tab index %d", tab_index));
     return;
   }
 
   RenderViewHost* render_view = web_contents->GetRenderViewHost();
   int routing_id = render_view->GetRoutingID();
 
   // This observer will delete itself.
   new FPSObserver(
       this, reply_message,
       base::GetProcId(render_view->GetProcess()->GetHandle()),
@@ skipping 510 matching lines @@
   std::string error;
   if (!GetBrowserFromJSONArgs(args, &browser, &error)) {
     reply.SendError(error);
     return;
   }
   if (!args->GetInteger("accelerator", &command)) {
     reply.SendError("'accelerator' missing or invalid.");
     return;
   }
   if (!chrome::SupportsCommand(browser, command)) {
-    reply.SendError(StringPrintf("Browser does not support command=%d.",
-                                 command));
+    reply.SendError(base::StringPrintf("Browser does not support command=%d.",
+                                       command));
     return;
   }
   if (!chrome::IsCommandEnabled(browser, command)) {
-    reply.SendError(StringPrintf("Browser command=%d not enabled.", command));
+    reply.SendError(base::StringPrintf(
+        "Browser command=%d not enabled.", command));
     return;
   }
   chrome::ExecuteCommand(browser, command);
   reply.SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::ExecuteBrowserCommandJSON(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   int command;
   Browser* browser;
   std::string error;
   if (!GetBrowserFromJSONArgs(args, &browser, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   if (!args->GetInteger("accelerator", &command)) {
     AutomationJSONReply(this, reply_message).SendError(
         "'accelerator' missing or invalid.");
     return;
   }
   if (!chrome::SupportsCommand(browser, command)) {
     AutomationJSONReply(this, reply_message).SendError(
-        StringPrintf("Browser does not support command=%d.", command));
+        base::StringPrintf("Browser does not support command=%d.", command));
     return;
   }
   if (!chrome::IsCommandEnabled(browser, command)) {
     AutomationJSONReply(this, reply_message).SendError(
-        StringPrintf("Browser command=%d not enabled.", command));
+        base::StringPrintf("Browser command=%d not enabled.", command));
     return;
   }
   // First check if we can handle the command without using an observer.
   for (size_t i = 0; i < arraysize(kSynchronousCommands); i++) {
     if (command == kSynchronousCommands[i]) {
       chrome::ExecuteCommand(browser, command);
       AutomationJSONReply(this, reply_message).SendSuccess(NULL);
       return;
     }
   }
   // Use an observer if we have one, otherwise fail.
   if (ExecuteBrowserCommandObserver::CreateAndRegisterObserver(
       this, browser, command, reply_message, true)) {
     chrome::ExecuteCommand(browser, command);
     return;
   }
-  AutomationJSONReply(this, reply_message).SendError(
-        StringPrintf("Unable to register observer for browser command=%d.",
-                     command));
+  AutomationJSONReply(this, reply_message).SendError(base::StringPrintf(
+      "Unable to register observer for browser command=%d.", command));
 }
 
 void TestingAutomationProvider::IsMenuCommandEnabledJSON(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   int command;
   Browser* browser;
   std::string error;
   if (!GetBrowserFromJSONArgs(args, &browser, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
@@ skipping 158 matching lines @@
     return;
   }
   GURL url(url_string);
   if (!url.is_valid()) {
     reply.SendError("Invalid url.");
     return;
   }
   automation_util::GetCookies(url, web_contents, &value_size, &value);
   if (value_size == -1) {
     reply.SendError(
-        StringPrintf("Unable to retrieve cookies for url=%s.",
-                     url_string.c_str()));
+        base::StringPrintf("Unable to retrieve cookies for url=%s.",
+                           url_string.c_str()));
     return;
   }
   DictionaryValue dict;
   dict.SetString("cookies", value);
   reply.SendSuccess(&dict);
 }
 
 void TestingAutomationProvider::DeleteCookieInBrowserContext(
     DictionaryValue* args,
     IPC::Message* reply_message) {
@@ skipping 20 matching lines @@
     return;
   }
   GURL url(url_string);
   if (!url.is_valid()) {
     reply.SendError("Invalid url.");
     return;
   }
   automation_util::DeleteCookie(url, cookie_name, web_contents, &success);
   if (!success) {
     reply.SendError(
-        StringPrintf("Failed to delete cookie with name=%s for url=%s.",
-                     cookie_name.c_str(), url_string.c_str()));
+        base::StringPrintf("Failed to delete cookie with name=%s for url=%s.",
+                           cookie_name.c_str(), url_string.c_str()));
     return;
   }
   reply.SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::SetCookieInBrowserContext(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   WebContents* web_contents;
@@ skipping 16 matching lines @@
     reply.SendError("'url' missing or invalid.");
     return;
   }
   GURL url(url_string);
   if (!url.is_valid()) {
     reply.SendError("Invalid url.");
     return;
   }
   automation_util::SetCookie(url, value, web_contents, &response_value);
   if (response_value != 1) {
-    reply.SendError(
-        StringPrintf("Unable set cookie for url=%s.", url_string.c_str()));
+    reply.SendError(base::StringPrintf(
+        "Unable set cookie for url=%s.", url_string.c_str()));
     return;
   }
   reply.SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::GetTabIds(
     DictionaryValue* args, IPC::Message* reply_message) {
   ListValue* id_list = new ListValue();
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     Browser* browser = *it;
@@ skipping 326 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);
 }