Update some uses of UTF conversions in chrome/browser to use the base:: 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 997 matching lines @@
     const base::string16& frame_xpath,
     const base::string16& script,
     IPC::Message* reply_message,
     RenderViewHost* render_view_host) {
   // Set the routing id of this message with the controller.
   // This routing id needs to be remembered for the reverse
   // communication while sending back the response of
   // this javascript execution.
   render_view_host->ExecuteJavascriptInWebFrame(
       frame_xpath,
-      UTF8ToUTF16("window.domAutomationController.setAutomationId(0);"));
+      base::ASCIIToUTF16("window.domAutomationController.setAutomationId(0);"));
   render_view_host->ExecuteJavascriptInWebFrame(
       frame_xpath, script);
 }
 
 void TestingAutomationProvider::ExecuteJavascript(
     int handle,
     const std::wstring& frame_xpath,
     const std::wstring& script,
     IPC::Message* reply_message) {
   WebContents* web_contents = GetWebContentsForHandle(handle, NULL);
   if (!web_contents) {
     AutomationMsg_DomOperation::WriteReplyParams(reply_message, std::string());
     Send(reply_message);
     return;
   }
 
   new DomOperationMessageSender(this, reply_message, false);
   ExecuteJavascriptInRenderViewFrame(WideToUTF16Hack(frame_xpath),
                                      WideToUTF16Hack(script), reply_message,
                                      web_contents->GetRenderViewHost());
 }
 
 // Sample json input: { "command": "OpenNewBrowserWindowWithNewProfile" }
 // Sample output: {}
 void TestingAutomationProvider::OpenNewBrowserWindowWithNewProfile(
     base::DictionaryValue* args, IPC::Message* reply_message) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   new BrowserOpenedWithNewProfileNotificationObserver(this, reply_message);
   profile_manager->CreateMultiProfileAsync(
-      base::string16(), base::string16(), ProfileManager::CreateCallback(), std::string());
+      base::string16(), base::string16(),
+      ProfileManager::CreateCallback(), std::string());
 }
 
 // Sample json input: { "command": "GetMultiProfileInfo" }
 // See GetMultiProfileInfo() in pyauto.py for sample output.
 void TestingAutomationProvider::GetMultiProfileInfo(
     base::DictionaryValue* args, IPC::Message* reply_message) {
   scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   const ProfileInfoCache& profile_info_cache =
       profile_manager->GetProfileInfoCache();
@@ skipping 1620 matching lines @@
     IPC::Message* reply_message) {
   TemplateURLService* url_model =
       TemplateURLServiceFactory::GetForProfile(browser->profile());
   scoped_ptr<base::DictionaryValue> return_value(new base::DictionaryValue);
   base::ListValue* search_engines = new base::ListValue;
   TemplateURLService::TemplateURLVector template_urls =
       url_model->GetTemplateURLs();
   for (TemplateURLService::TemplateURLVector::const_iterator it =
        template_urls.begin(); it != template_urls.end(); ++it) {
     base::DictionaryValue* search_engine = new base::DictionaryValue;
-    search_engine->SetString("short_name", UTF16ToUTF8((*it)->short_name()));
-    search_engine->SetString("keyword", UTF16ToUTF8((*it)->keyword()));
+    search_engine->SetString("short_name",
+                             base::UTF16ToUTF8((*it)->short_name()));
+    search_engine->SetString("keyword", base::UTF16ToUTF8((*it)->keyword()));
     search_engine->SetBoolean("in_default_list", (*it)->ShowInDefaultList());
     search_engine->SetBoolean("is_default",
         (*it) == url_model->GetDefaultSearchProvider());
     search_engine->SetBoolean("is_valid", (*it)->url_ref().IsValid());
     search_engine->SetBoolean("supports_replacement",
                               (*it)->url_ref().SupportsReplacement());
     search_engine->SetString("url", (*it)->url());
     search_engine->SetString("host", (*it)->url_ref().GetHost());
     search_engine->SetString("path", (*it)->url_ref().GetPath());
     search_engine->SetString("display_url",
-                             UTF16ToUTF8((*it)->url_ref().DisplayURL()));
+                             base::UTF16ToUTF8((*it)->url_ref().DisplayURL()));
     search_engines->Append(search_engine);
   }
   return_value->Set("search_engines", search_engines);
   AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
 }
 
 // Refer to pyauto.py for sample JSON input.
 void TestingAutomationProvider::AddOrEditSearchEngine(
     Browser* browser,
     base::DictionaryValue* args,
     IPC::Message* reply_message) {
   TemplateURLService* url_model =
       TemplateURLServiceFactory::GetForProfile(browser->profile());
   base::string16 new_title;
   base::string16 new_keyword;
   std::string new_url;
   std::string keyword;
   if (!args->GetString("new_title", &new_title) ||
       !args->GetString("new_keyword", &new_keyword) ||
       !args->GetString("new_url", &new_url)) {
     AutomationJSONReply(this, reply_message).SendError(
         "One or more inputs invalid");
     return;
   }
   std::string new_ref_url = TemplateURLRef::DisplayURLToURLRef(
-      UTF8ToUTF16(new_url));
+      base::UTF8ToUTF16(new_url));
   scoped_ptr<KeywordEditorController> controller(
       new KeywordEditorController(browser->profile()));
   if (args->GetString("keyword", &keyword)) {
     TemplateURL* template_url =
-        url_model->GetTemplateURLForKeyword(UTF8ToUTF16(keyword));
+        url_model->GetTemplateURLForKeyword(base::UTF8ToUTF16(keyword));
     if (template_url == NULL) {
       AutomationJSONReply(this, reply_message).SendError(
           "No match for keyword: " + keyword);
       return;
     }
     url_model->AddObserver(new AutomationProviderSearchEngineObserver(
         this, browser->profile(), reply_message));
     controller->ModifyTemplateURL(template_url, new_title, new_keyword,
                                   new_ref_url);
   } else {
@@ skipping 13 matching lines @@
       TemplateURLServiceFactory::GetForProfile(browser->profile());
   std::string keyword;
   std::string action;
   if (!args->GetString("keyword", &keyword) ||
       !args->GetString("action", &action)) {
     AutomationJSONReply(this, reply_message).SendError(
         "One or more inputs invalid");
     return;
   }
   TemplateURL* template_url =
-      url_model->GetTemplateURLForKeyword(UTF8ToUTF16(keyword));
+      url_model->GetTemplateURLForKeyword(base::UTF8ToUTF16(keyword));
   if (template_url == NULL) {
     AutomationJSONReply(this, reply_message).SendError(
         "No match for keyword: " + keyword);
     return;
   }
   if (action == "delete") {
     url_model->AddObserver(new AutomationProviderSearchEngineObserver(
       this, browser->profile(), reply_message));
     url_model->Remove(template_url);
   } else if (action == "default") {
@@ skipping 1430 matching lines @@
 void TestingAutomationProvider::GetAppModalDialogMessage(
     base::DictionaryValue* args, IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   std::string error_msg;
   JavaScriptAppModalDialog* dialog = GetActiveJavaScriptModalDialog(&error_msg);
   if (!dialog) {
     reply.SendError(error_msg);
     return;
   }
   base::DictionaryValue result_dict;
-  result_dict.SetString("message", UTF16ToUTF8(dialog->message_text()));
+  result_dict.SetString("message", base::UTF16ToUTF8(dialog->message_text()));
   reply.SendSuccess(&result_dict);
 }
 
 void TestingAutomationProvider::AcceptOrDismissAppModalDialog(
     base::DictionaryValue* args, IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   bool accept;
   if (!args->GetBoolean("accept", &accept)) {
     reply.SendError("Missing or invalid 'accept'");
     return;
   }
 
   std::string error_msg;
   JavaScriptAppModalDialog* dialog = GetActiveJavaScriptModalDialog(&error_msg);
   if (!dialog) {
     reply.SendError(error_msg);
     return;
   }
   if (accept) {
     std::string prompt_text;
     if (args->GetString("prompt_text", &prompt_text))
-      dialog->SetOverridePromptText(UTF8ToUTF16(prompt_text));
+      dialog->SetOverridePromptText(base::UTF8ToUTF16(prompt_text));
     dialog->native_dialog()->AcceptAppModalDialog();
   } else {
     dialog->native_dialog()->CancelAppModalDialog();
   }
   reply.SendSuccess(NULL);
 }
 
 // Sample JSON input: { "command": "LaunchApp",
 //                      "id": "ahfgeienlihckogmohjhadlkjgocpleb" }
 // Sample JSON output: {}
@@ skipping 1212 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);
 }