Update some uses of UTF conversions in chrome/browser to use the base:: namespace.

BUG=330556
TEST=no change
TBR=ben@chromium.org

Review URL: https://codereview.chromium.org/120953002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@242450 0039d316-1c4b-4281-b951-d872f2087c98

140 files changed, 490 insertions, 440 deletions

diff --git a/chrome/browser/devtools/devtools_adb_bridge.cc b/chrome/browser/devtools/devtools_adb_bridge.cc
index 93d0217..a9c06b8 100644
--- a/chrome/browser/devtools/devtools_adb_bridge.cc
+++ b/chrome/browser/devtools/devtools_adb_bridge.cc
@@ -869,7 +869,7 @@ RemotePageTarget::RemotePageTarget(
   value.GetString("url", &url);
   url_ = GURL(url);
   value.GetString("title", &title_);
-  title_ = UTF16ToUTF8(net::UnescapeForHTML(UTF8ToUTF16(title_)));
+  title_ = base::UTF16ToUTF8(net::UnescapeForHTML(base::UTF8ToUTF16(title_)));
   value.GetString("description", &description_);
   std::string favicon_url;
   value.GetString("faviconUrl", &favicon_url);
diff --git a/chrome/browser/devtools/devtools_file_helper.cc b/chrome/browser/devtools/devtools_file_helper.cc
index 68bafef..46ae915 100644
--- a/chrome/browser/devtools/devtools_file_helper.cc
+++ b/chrome/browser/devtools/devtools_file_helper.cc
@@ -353,7 +353,7 @@ void DevToolsFileHelper::InnerAddFileSystem(
   std::string path_display_name = path.AsEndingWithSeparator().AsUTF8Unsafe();
   base::string16 message = l10n_util::GetStringFUTF16(
       IDS_DEV_TOOLS_CONFIRM_ADD_FILE_SYSTEM_MESSAGE,
-      UTF8ToUTF16(path_display_name));
+      base::UTF8ToUTF16(path_display_name));
   show_info_bar_callback.Run(
       message,
       Bind(&DevToolsFileHelper::AddUserConfirmedFileSystem,
diff --git a/chrome/browser/devtools/devtools_target_impl.cc b/chrome/browser/devtools/devtools_target_impl.cc
index 8bf1df5..8a406c9 100644
--- a/chrome/browser/devtools/devtools_target_impl.cc
+++ b/chrome/browser/devtools/devtools_target_impl.cc
@@ -64,7 +64,7 @@ RenderViewHostTarget::RenderViewHostTarget(RenderViewHost* rvh, bool is_tab) {
   if (!web_contents)
     return;  // Orphan RVH will show up with no title/url/icon in clients.
 
-  title_ = UTF16ToUTF8(web_contents->GetTitle());
+  title_ = base::UTF16ToUTF8(web_contents->GetTitle());
   url_ = web_contents->GetURL();
   content::NavigationController& controller = web_contents->GetController();
   content::NavigationEntry* entry = controller.GetActiveEntry();
@@ -164,7 +164,7 @@ WorkerTarget::WorkerTarget(const WorkerService::WorkerInfo& worker) {
       DevToolsAgentHost::GetForWorker(worker.process_id, worker.route_id);
   id_ = agent_host_->GetId();
   type_ = kTargetTypeWorker;
-  title_ = UTF16ToUTF8(worker.name);
+  title_ = base::UTF16ToUTF8(worker.name);
   description_ =
       base::StringPrintf("Worker pid:%d", base::GetProcId(worker.handle));
   url_ = worker.url;
diff --git a/chrome/browser/devtools/devtools_window.cc b/chrome/browser/devtools/devtools_window.cc
index cc8e7494..15aba3a 100644
--- a/chrome/browser/devtools/devtools_window.cc
+++ b/chrome/browser/devtools/devtools_window.cc
@@ -1471,7 +1471,8 @@ void DevToolsWindow::CallClientFunction(const std::string& function_name,
       }
     }
   }
-  base::string16 javascript = ASCIIToUTF16(function_name + "(" + params + ");");
+  base::string16 javascript =
+      base::ASCIIToUTF16(function_name + "(" + params + ");");
   web_contents_->GetRenderViewHost()->ExecuteJavascriptInWebFrame(
       base::string16(), javascript);
 }
diff --git a/chrome/browser/diagnostics/diagnostics_writer.cc b/chrome/browser/diagnostics/diagnostics_writer.cc
index 84451cc..7e75d10 100644
--- a/chrome/browser/diagnostics/diagnostics_writer.cc
+++ b/chrome/browser/diagnostics/diagnostics_writer.cc
@@ -148,7 +148,7 @@ class PosixConsole : public SimpleConsole {
 
   virtual bool Write(const base::string16& text) OVERRIDE {
     // We're assuming that the terminal is using UTF-8 encoding.
-    printf("%s", UTF16ToUTF8(text).c_str());
+    printf("%s", base::UTF16ToUTF8(text).c_str());
     return true;
   }
 
@@ -216,7 +216,7 @@ bool DiagnosticsWriter::WriteInfoLine(const std::string& info_text) {
   } else {
     if (console_.get()) {
       console_->SetColor(SimpleConsole::DEFAULT);
-      console_->Write(UTF8ToUTF16(info_text + "\n"));
+      console_->Write(base::UTF8ToUTF16(info_text + "\n"));
     }
   }
   return true;
@@ -266,7 +266,7 @@ bool DiagnosticsWriter::WriteResult(bool success,
   if (format_ != LOG) {
     if (console_.get()) {
       console_->SetColor(color);
-      console_->Write(ASCIIToUTF16(result));
+      console_->Write(base::ASCIIToUTF16(result));
     }
     if (format_ == MACHINE) {
       return WriteInfoLine(base::StringPrintf(
diff --git a/chrome/browser/diagnostics/recon_diagnostics.cc b/chrome/browser/diagnostics/recon_diagnostics.cc
index e305f7d..7e235ec 100644
--- a/chrome/browser/diagnostics/recon_diagnostics.cc
+++ b/chrome/browser/diagnostics/recon_diagnostics.cc
@@ -305,7 +305,8 @@ class PathTest : public DiagnosticsTest {
     if (!base::PathExists(dir_or_file)) {
       RecordFailure(
           DIAG_RECON_PATH_NOT_FOUND,
-          "Path not found: " + UTF16ToUTF8(dir_or_file.LossyDisplayName()));
+          "Path not found: " +
+              base::UTF16ToUTF8(dir_or_file.LossyDisplayName()));
       return true;
     }
 
@@ -318,7 +319,7 @@ class PathTest : public DiagnosticsTest {
     if (!dir_or_file_size && !path_info_.is_optional) {
       RecordFailure(DIAG_RECON_CANNOT_OBTAIN_SIZE,
                     "Cannot obtain size for: " +
-                        UTF16ToUTF8(dir_or_file.LossyDisplayName()));
+                        base::UTF16ToUTF8(dir_or_file.LossyDisplayName()));
       return true;
     }
     std::string printable_size = base::Int64ToString(dir_or_file_size);
@@ -327,7 +328,7 @@ class PathTest : public DiagnosticsTest {
       if (dir_or_file_size > path_info_.max_size) {
         RecordFailure(DIAG_RECON_FILE_TOO_LARGE,
                       "Path contents too large (" + printable_size + ") for: " +
-                          UTF16ToUTF8(dir_or_file.LossyDisplayName()));
+                          base::UTF16ToUTF8(dir_or_file.LossyDisplayName()));
         return true;
       }
     }
@@ -338,7 +339,7 @@ class PathTest : public DiagnosticsTest {
     if (!base::PathIsWritable(dir_or_file)) {
       RecordFailure(DIAG_RECON_NOT_WRITABLE,
                     "Path is not writable: " +
-                        UTF16ToUTF8(dir_or_file.LossyDisplayName()));
+                        base::UTF16ToUTF8(dir_or_file.LossyDisplayName()));
       return true;
     }
     RecordSuccess("Path exists and is writable: " + printable_size);
diff --git a/chrome/browser/do_not_track_browsertest.cc b/chrome/browser/do_not_track_browsertest.cc
index 934ab86..a3eef7a 100644
--- a/chrome/browser/do_not_track_browsertest.cc
+++ b/chrome/browser/do_not_track_browsertest.cc
@@ -28,7 +28,7 @@ IN_PROC_BROWSER_TEST_F(DoNotTrackTest, Simple) {
 
   int matches = ui_test_utils::FindInPage(
       browser()->tab_strip_model()->GetActiveWebContents(),
-      base::string16(ASCIIToUTF16("1")),
+      base::ASCIIToUTF16("1"),
       true /* forward */, false /* match case */, NULL /* ordinal */,
       NULL /* selection_rect */);
 
@@ -49,7 +49,7 @@ IN_PROC_BROWSER_TEST_F(DoNotTrackTest, Redirect) {
 
   int matches = ui_test_utils::FindInPage(
       browser()->tab_strip_model()->GetActiveWebContents(),
-      base::string16(ASCIIToUTF16("1")),
+      base::ASCIIToUTF16("1"),
       true /* forward */, false /* match case */, NULL /* ordinal */,
       NULL /* selection_rect */);
 
diff --git a/chrome/browser/download/download_browsertest.cc b/chrome/browser/download/download_browsertest.cc
index bff746c..7f43391 100644
--- a/chrome/browser/download/download_browsertest.cc
+++ b/chrome/browser/download/download_browsertest.cc
@@ -742,9 +742,9 @@ class DownloadTest : public InProcessBrowserTest {
     base::FilePath filename;
     net::FileURLToFilePath(url, &filename);
     base::string16 expected_title_in_progress(
-        ASCIIToUTF16(partial_indication) + filename.LossyDisplayName());
+        base::ASCIIToUTF16(partial_indication) + filename.LossyDisplayName());
     base::string16 expected_title_finished(
-        ASCIIToUTF16(total_indication) + filename.LossyDisplayName());
+        base::ASCIIToUTF16(total_indication) + filename.LossyDisplayName());
 
     // Download a partial web page in a background tab and wait.
     // The mock system will not complete until it gets a special URL.
@@ -2378,7 +2378,7 @@ IN_PROC_BROWSER_TEST_F(DownloadTest, SavePageNonHTMLViaPost) {
   content::RenderViewHost* render_view_host = web_contents->GetRenderViewHost();
   ASSERT_TRUE(render_view_host != NULL);
   render_view_host->ExecuteJavascriptInWebFrame(
-        base::string16(), ASCIIToUTF16("SubmitForm()"));
+        base::string16(), base::ASCIIToUTF16("SubmitForm()"));
   observer.Wait();
   EXPECT_EQ(jpeg_url, web_contents->GetURL());
 
@@ -2897,8 +2897,8 @@ IN_PROC_BROWSER_TEST_F(DownloadTest, DownloadTest_CrazyFilenames) {
     base::string16 crazy16;
     std::string crazy8;
     const wchar_t* crazy_w = kCrazyFilenames[index];
-    ASSERT_TRUE(WideToUTF8(crazy_w, wcslen(crazy_w), &crazy8));
-    ASSERT_TRUE(WideToUTF16(crazy_w, wcslen(crazy_w), &crazy16));
+    ASSERT_TRUE(base::WideToUTF8(crazy_w, wcslen(crazy_w), &crazy8));
+    ASSERT_TRUE(base::WideToUTF16(crazy_w, wcslen(crazy_w), &crazy16));
     base::FilePath file_path(DestinationFile(browser(), origin.Append(
 #if defined(OS_WIN)
             crazy16
diff --git a/chrome/browser/download/download_danger_prompt.cc b/chrome/browser/download/download_danger_prompt.cc
index 0478de3..dee04f0 100644
--- a/chrome/browser/download/download_danger_prompt.cc
+++ b/chrome/browser/download/download_danger_prompt.cc
@@ -158,7 +158,7 @@ base::string16 DownloadDangerPromptImpl::GetMessage() {
       case content::DOWNLOAD_DANGER_TYPE_DANGEROUS_HOST: {
         return l10n_util::GetStringUTF16(
             IDS_PROMPT_CONFIRM_KEEP_MALICIOUS_DOWNLOAD_LEAD) +
-            ASCIIToUTF16("\n\n") +
+            base::ASCIIToUTF16("\n\n") +
             l10n_util::GetStringUTF16(
                 IDS_PROMPT_CONFIRM_KEEP_MALICIOUS_DOWNLOAD_BODY);
       }
diff --git a/chrome/browser/download/download_item_model.cc b/chrome/browser/download/download_item_model.cc
index 2b25d2f..385f07f 100644
--- a/chrome/browser/download/download_item_model.cc
+++ b/chrome/browser/download/download_item_model.cc
@@ -345,7 +345,7 @@ base::string16 DownloadItemModel::GetTooltipText(const gfx::FontList& font_list,
   content::DownloadInterruptReason reason = download_->GetLastReason();
   if (download_->GetState() == DownloadItem::INTERRUPTED &&
       reason != content::DOWNLOAD_INTERRUPT_REASON_USER_CANCELED) {
-    tooltip += ASCIIToUTF16("\n");
+    tooltip += base::ASCIIToUTF16("\n");
     tooltip += gfx::ElideText(InterruptReasonStatusMessage(reason),
                              font_list, max_width, gfx::ELIDE_AT_END);
   }
diff --git a/chrome/browser/download/download_item_model_unittest.cc b/chrome/browser/download/download_item_model_unittest.cc
index 4bab2d5..1571cb2 100644
--- a/chrome/browser/download/download_item_model_unittest.cc
+++ b/chrome/browser/download/download_item_model_unittest.cc
@@ -175,7 +175,7 @@ TEST_F(DownloadItemModelTest, InterruptedStatus) {
     const TestCase& test_case = kTestCases[i];
     SetupInterruptedDownloadItem(test_case.reason);
     EXPECT_STREQ(test_case.expected_status,
-                 UTF16ToUTF8(model().GetStatusText()).c_str());
+                 base::UTF16ToUTF8(model().GetStatusText()).c_str());
   }
 }
 
@@ -261,15 +261,15 @@ TEST_F(DownloadItemModelTest, InterruptTooltip) {
     // large enough to accomodate all the strings.
     EXPECT_STREQ(
         test_case.expected_tooltip,
-        UTF16ToUTF8(model().GetTooltipText(font_list,
-                                           kLargeTooltipWidth)).c_str());
+        base::UTF16ToUTF8(model().GetTooltipText(font_list,
+                                                 kLargeTooltipWidth)).c_str());
 
     // Check that if the width is small, the returned tooltip only contains
     // lines of the given width or smaller.
     std::vector<base::string16> lines;
     base::string16 truncated_tooltip =
         model().GetTooltipText(font_list, kSmallTooltipWidth);
-    Tokenize(truncated_tooltip, ASCIIToUTF16("\n"), &lines);
+    Tokenize(truncated_tooltip, base::ASCIIToUTF16("\n"), &lines);
     for (unsigned i = 0; i < lines.size(); ++i)
       EXPECT_GE(kSmallTooltipWidth, gfx::GetStringWidth(lines[i], font_list));
   }
@@ -343,7 +343,7 @@ TEST_F(DownloadItemModelTest, InProgressStatus) {
         .WillRepeatedly(Return(test_case.is_paused));
 
     EXPECT_STREQ(test_case.expected_status,
-                 UTF16ToUTF8(model().GetStatusText()).c_str());
+                 base::UTF16ToUTF8(model().GetStatusText()).c_str());
   }
 }
 
diff --git a/chrome/browser/download/download_prefs.cc b/chrome/browser/download/download_prefs.cc
index 04a9502..385356f 100644
--- a/chrome/browser/download/download_prefs.cc
+++ b/chrome/browser/download/download_prefs.cc
@@ -155,7 +155,7 @@ DownloadPrefs::DownloadPrefs(Profile* profile) : profile_(profile) {
 #if defined(OS_POSIX)
     base::FilePath path(extensions[i]);
 #elif defined(OS_WIN)
-    base::FilePath path(UTF8ToWide(extensions[i]));
+    base::FilePath path(base::UTF8ToWide(extensions[i]));
 #endif
     if (!extensions[i].empty() &&
         download_util::GetFileDangerLevel(path) == download_util::NOT_DANGEROUS)
diff --git a/chrome/browser/download/download_query.cc b/chrome/browser/download/download_query.cc
index abebc6a..456f4cc 100644
--- a/chrome/browser/download/download_query.cc
+++ b/chrome/browser/download/download_query.cc
@@ -73,7 +73,7 @@ static bool MatchesQuery(
     const std::vector<base::string16>& query_terms,
     const DownloadItem& item) {
   DCHECK(!query_terms.empty());
-  base::string16 url_raw(UTF8ToUTF16(item.GetOriginalUrl().spec()));
+  base::string16 url_raw(base::UTF8ToUTF16(item.GetOriginalUrl().spec()));
   base::string16 url_formatted = url_raw;
   if (item.GetBrowserContext()) {
     Profile* profile = Profile::FromBrowserContext(item.GetBrowserContext());
@@ -139,7 +139,7 @@ static base::string16 GetFilename(const DownloadItem& item) {
 }
 
 static std::string GetFilenameUTF8(const DownloadItem& item) {
-  return UTF16ToUTF8(GetFilename(item));
+  return base::UTF16ToUTF8(GetFilename(item));
 }
 
 static std::string GetUrl(const DownloadItem& item) {
diff --git a/chrome/browser/drive/drive_api_util.cc b/chrome/browser/drive/drive_api_util.cc
index dd3b182..1034589 100644
--- a/chrome/browser/drive/drive_api_util.cc
+++ b/chrome/browser/drive/drive_api_util.cc
@@ -160,7 +160,7 @@ std::string EscapeQueryStringValue(const std::string& str) {
 
 std::string TranslateQuery(const std::string& original_query) {
   // In order to handle non-ascii white spaces correctly, convert to UTF16.
-  base::string16 query = UTF8ToUTF16(original_query);
+  base::string16 query = base::UTF8ToUTF16(original_query);
   const base::string16 kDelimiter(
       base::kWhitespaceUTF16 + base::string16(1, static_cast<char16>('"')));
 
@@ -218,7 +218,7 @@ std::string TranslateQuery(const std::string& original_query) {
         &result,
         "%sfullText contains \'%s\'",
         is_exclusion ? "not " : "",
-        EscapeQueryStringValue(UTF16ToUTF8(token)).c_str());
+        EscapeQueryStringValue(base::UTF16ToUTF8(token)).c_str());
   }
 
   return result;
diff --git a/chrome/browser/enumerate_modules_model_unittest_win.cc b/chrome/browser/enumerate_modules_model_unittest_win.cc
index d7bed9c..4c15a0a 100644
--- a/chrome/browser/enumerate_modules_model_unittest_win.cc
+++ b/chrome/browser/enumerate_modules_model_unittest_win.cc
@@ -215,10 +215,11 @@ const struct CollapsePathList {
   base::string16 test_case;
 } kCollapsePathList[] = {
   // Negative testing (should not collapse this path).
-  { ASCIIToUTF16("c:\\a\\a.dll"), ASCIIToUTF16("c:\\a\\a.dll") },
+  { base::ASCIIToUTF16("c:\\a\\a.dll"), base::ASCIIToUTF16("c:\\a\\a.dll") },
   // These two are to test that we select the maximum collapsed path.
-  { ASCIIToUTF16("%foo%\\a.dll"), ASCIIToUTF16("c:\\foo\\a.dll") },
-  { ASCIIToUTF16("%x%\\a.dll"), ASCIIToUTF16("c:\\foo\\bar\\a.dll") },
+  { base::ASCIIToUTF16("%foo%\\a.dll"), base::ASCIIToUTF16("c:\\foo\\a.dll") },
+  { base::ASCIIToUTF16("%x%\\a.dll"),
+    base::ASCIIToUTF16("c:\\foo\\bar\\a.dll") },
 };
 
 TEST_F(EnumerateModulesTest, CollapsePath) {
diff --git a/chrome/browser/enumerate_modules_model_win.cc b/chrome/browser/enumerate_modules_model_win.cc
index be2e42f..746cc07 100644
--- a/chrome/browser/enumerate_modules_model_win.cc
+++ b/chrome/browser/enumerate_modules_model_win.cc
@@ -375,8 +375,8 @@ ModuleEnumerator::ModuleStatus ModuleEnumerator::Match(
   }
 
   std::string filename_hash, location_hash;
-  GenerateHash(WideToUTF8(module.name), &filename_hash);
-  GenerateHash(WideToUTF8(module.location), &location_hash);
+  GenerateHash(base::WideToUTF8(module.name), &filename_hash);
+  GenerateHash(base::WideToUTF8(module.location), &location_hash);
 
   // Filenames are mandatory. Location is mandatory if given.
   if (filename_hash == blacklisted.filename &&
@@ -404,8 +404,8 @@ ModuleEnumerator::ModuleStatus ModuleEnumerator::Match(
 
       std::string desc_or_signer(blacklisted.desc_or_signer);
       std::string signer_hash, description_hash;
-      GenerateHash(WideToUTF8(module.digital_signer), &signer_hash);
-      GenerateHash(WideToUTF8(module.description), &description_hash);
+      GenerateHash(base::WideToUTF8(module.digital_signer), &signer_hash);
+      GenerateHash(base::WideToUTF8(module.description), &description_hash);
 
       // If signatures match (or both are empty), then we have a winner.
       if (signer_hash == desc_or_signer)
@@ -646,7 +646,7 @@ void ModuleEnumerator::PreparePathMappings() {
     std::string path;
     if (environment->GetVar(WideToASCII(*variable).c_str(), &path)) {
       path_mapping_.push_back(
-          std::make_pair(base::i18n::ToLower(UTF8ToUTF16(path)) + L"\\",
+          std::make_pair(base::i18n::ToLower(base::UTF8ToUTF16(path)) + L"\\",
                          L"%" + base::i18n::ToLower(*variable) + L"%"));
     }
   }
@@ -879,16 +879,16 @@ base::ListValue* EnumerateModulesModel::GetModuleList() const {
     if ((module->type & ModuleEnumerator::LOADED_MODULE) == 0) {
       // Module is not loaded, denote type of module.
       if (module->type & ModuleEnumerator::SHELL_EXTENSION)
-        type_string = ASCIIToWide("Shell Extension");
+        type_string = base::ASCIIToWide("Shell Extension");
       if (module->type & ModuleEnumerator::WINSOCK_MODULE_REGISTRATION) {
         if (!type_string.empty())
-          type_string += ASCIIToWide(", ");
-        type_string += ASCIIToWide("Winsock");
+          type_string += base::ASCIIToWide(", ");
+        type_string += base::ASCIIToWide("Winsock");
       }
       // Must be one of the above type.
       DCHECK(!type_string.empty());
       if (!limited_mode_) {
-        type_string += ASCIIToWide(" -- ");
+        type_string += base::ASCIIToWide(" -- ");
         type_string += l10n_util::GetStringUTF16(IDS_CONFLICTS_NOT_LOADED_YET);
       }
     }
@@ -904,9 +904,10 @@ base::ListValue* EnumerateModulesModel::GetModuleList() const {
     if (!limited_mode_) {
       // Figure out the possible resolution help string.
       base::string16 actions;
-      base::string16 separator = ASCIIToWide(" ") + l10n_util::GetStringUTF16(
-          IDS_CONFLICTS_CHECK_POSSIBLE_ACTION_SEPERATOR) +
-          ASCIIToWide(" ");
+      base::string16 separator = base::ASCIIToWide(" ") +
+          l10n_util::GetStringUTF16(
+              IDS_CONFLICTS_CHECK_POSSIBLE_ACTION_SEPERATOR) +
+          base::ASCIIToWide(" ");
 
       if (module->recommended_action & ModuleEnumerator::NONE) {
         actions = l10n_util::GetStringUTF16(
@@ -930,9 +931,11 @@ base::ListValue* EnumerateModulesModel::GetModuleList() const {
         actions += l10n_util::GetStringUTF16(
             IDS_CONFLICTS_CHECK_POSSIBLE_ACTION_DISABLE);
       }
-      base::string16 possible_resolution = actions.empty() ? ASCIIToWide("") :
-          l10n_util::GetStringUTF16(IDS_CONFLICTS_CHECK_POSSIBLE_ACTIONS) +
-          ASCIIToWide(" ") +
+      base::string16 possible_resolution =
+          actions.empty() ? base::ASCIIToWide("")
+                          : l10n_util::GetStringUTF16(
+                                IDS_CONFLICTS_CHECK_POSSIBLE_ACTIONS) +
+          base::ASCIIToWide(" ") +
           actions;
       data->SetString("possibleResolution", possible_resolution);
       data->SetString("help_url",
@@ -1056,14 +1059,14 @@ GURL EnumerateModulesModel::ConstructHelpCenterUrl(
 
   // Construct the needed hashes.
   std::string filename, location, description, signer;
-  GenerateHash(WideToUTF8(module.name), &filename);
-  GenerateHash(WideToUTF8(module.location), &location);
-  GenerateHash(WideToUTF8(module.description), &description);
-  GenerateHash(WideToUTF8(module.digital_signer), &signer);
+  GenerateHash(base::WideToUTF8(module.name), &filename);
+  GenerateHash(base::WideToUTF8(module.location), &location);
+  GenerateHash(base::WideToUTF8(module.description), &description);
+  GenerateHash(base::WideToUTF8(module.digital_signer), &signer);
 
   base::string16 url =
       l10n_util::GetStringFUTF16(IDS_HELP_CENTER_VIEW_CONFLICTS,
-          ASCIIToUTF16(filename), ASCIIToUTF16(location),
-          ASCIIToUTF16(description), ASCIIToUTF16(signer));
-  return GURL(UTF16ToUTF8(url));
+          base::ASCIIToUTF16(filename), base::ASCIIToUTF16(location),
+          base::ASCIIToUTF16(description), base::ASCIIToUTF16(signer));
+  return GURL(base::UTF16ToUTF8(url));
 }
diff --git a/chrome/browser/errorpage_browsertest.cc b/chrome/browser/errorpage_browsertest.cc
index 9c83298..e2afcbf 100644
--- a/chrome/browser/errorpage_browsertest.cc
+++ b/chrome/browser/errorpage_browsertest.cc
@@ -55,12 +55,13 @@ class ErrorPageTest : public InProcessBrowserTest {
                                     int num_navigations) {
     content::TitleWatcher title_watcher(
         browser()->tab_strip_model()->GetActiveWebContents(),
-        ASCIIToUTF16(expected_title));
+        base::ASCIIToUTF16(expected_title));
 
     ui_test_utils::NavigateToURLBlockUntilNavigationsComplete(
         browser(), url, num_navigations);
 
-    EXPECT_EQ(ASCIIToUTF16(expected_title), title_watcher.WaitAndGetTitle());
+    EXPECT_EQ(base::ASCIIToUTF16(expected_title),
+              title_watcher.WaitAndGetTitle());
   }
 
   // Navigates back in the history and waits for |num_navigations| to occur, and
@@ -101,7 +102,7 @@ class ErrorPageTest : public InProcessBrowserTest {
                                       HistoryNavigationDirection direction) {
     content::TitleWatcher title_watcher(
         browser()->tab_strip_model()->GetActiveWebContents(),
-        ASCIIToUTF16(expected_title));
+        base::ASCIIToUTF16(expected_title));
 
     content::TestNavigationObserver test_navigation_observer(
         browser()->tab_strip_model()->GetActiveWebContents(),
@@ -115,7 +116,8 @@ class ErrorPageTest : public InProcessBrowserTest {
     }
     test_navigation_observer.Wait();
 
-    EXPECT_EQ(title_watcher.WaitAndGetTitle(), ASCIIToUTF16(expected_title));
+    EXPECT_EQ(title_watcher.WaitAndGetTitle(),
+              base::ASCIIToUTF16(expected_title));
   }
 };
 
@@ -304,7 +306,7 @@ IN_PROC_BROWSER_TEST_F(ErrorPageTest, IFrameDNSError_JavaScript) {
         content::NOTIFICATION_LOAD_STOP,
         content::Source<NavigationController>(&wc->GetController()));
     wc->GetRenderViewHost()->ExecuteJavascriptInWebFrame(
-        base::string16(), ASCIIToUTF16(script));
+        base::string16(), base::ASCIIToUTF16(script));
     load_observer.Wait();
 
     // Ensure we saw the expected failure.
@@ -325,7 +327,7 @@ IN_PROC_BROWSER_TEST_F(ErrorPageTest, IFrameDNSError_JavaScript) {
         content::NOTIFICATION_LOAD_STOP,
         content::Source<NavigationController>(&wc->GetController()));
     wc->GetRenderViewHost()->ExecuteJavascriptInWebFrame(
-        base::string16(), ASCIIToUTF16(script));
+        base::string16(), base::ASCIIToUTF16(script));
     load_observer.Wait();
   }
 
@@ -337,7 +339,7 @@ IN_PROC_BROWSER_TEST_F(ErrorPageTest, IFrameDNSError_JavaScript) {
         content::NOTIFICATION_LOAD_STOP,
         content::Source<NavigationController>(&wc->GetController()));
     wc->GetRenderViewHost()->ExecuteJavascriptInWebFrame(
-        base::string16(), ASCIIToUTF16(script));
+        base::string16(), base::ASCIIToUTF16(script));
     load_observer.Wait();
 
     EXPECT_EQ(fail_url, fail_observer.fail_url());
diff --git a/chrome/browser/extensions/alert_apitest.cc b/chrome/browser/extensions/alert_apitest.cc
index 14a1424..8ac6eab 100644
--- a/chrome/browser/extensions/alert_apitest.cc
+++ b/chrome/browser/extensions/alert_apitest.cc
@@ -23,7 +23,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionApiTest, AlertBasic) {
           process_manager()->GetBackgroundHostForExtension(extension->id());
   ASSERT_TRUE(host);
   host->render_view_host()->ExecuteJavascriptInWebFrame(base::string16(),
-      ASCIIToUTF16("alert('This should not crash.');"));
+      base::ASCIIToUTF16("alert('This should not crash.');"));
 
   AppModalDialog* alert = ui_test_utils::WaitForAppModalDialog();
   ASSERT_TRUE(alert);
diff --git a/chrome/browser/extensions/api/bluetooth/bluetooth_api_utils.cc b/chrome/browser/extensions/api/bluetooth/bluetooth_api_utils.cc
index 29c3714..d38ff2f 100644
--- a/chrome/browser/extensions/api/bluetooth/bluetooth_api_utils.cc
+++ b/chrome/browser/extensions/api/bluetooth/bluetooth_api_utils.cc
@@ -17,7 +17,7 @@ namespace bluetooth {
 void BluetoothDeviceToApiDevice(const device::BluetoothDevice& device,
                                 Device* out) {
   out->address = device.GetAddress();
-  out->name.reset(new std::string(UTF16ToUTF8(device.GetName())));
+  out->name.reset(new std::string(base::UTF16ToUTF8(device.GetName())));
   out->paired.reset(new bool(device.IsPaired()));
   out->connected.reset(new bool(device.IsConnected()));
 }
diff --git a/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_apitest.cc b/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_apitest.cc
index c2984c6..6a0b3e3 100644
--- a/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_apitest.cc
+++ b/chrome/browser/extensions/api/bookmark_manager_private/bookmark_manager_private_apitest.cc
@@ -35,9 +35,12 @@ IN_PROC_BROWSER_TEST_F(ExtensionApiTest, BookmarkManagerEditDisabled) {
   BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile);
   test::WaitForBookmarkModelToLoad(model);
   const BookmarkNode* bar = model->bookmark_bar_node();
-  const BookmarkNode* folder = model->AddFolder(bar, 0, ASCIIToUTF16("Folder"));
-  model->AddURL(bar, 1, ASCIIToUTF16("AAA"), GURL("http://aaa.example.com"));
-  model->AddURL(folder, 0, ASCIIToUTF16("BBB"), GURL("http://bbb.example.com"));
+  const BookmarkNode* folder =
+      model->AddFolder(bar, 0, base::ASCIIToUTF16("Folder"));
+  model->AddURL(bar, 1, base::ASCIIToUTF16("AAA"),
+                GURL("http://aaa.example.com"));
+  model->AddURL(folder, 0, base::ASCIIToUTF16("BBB"),
+                GURL("http://bbb.example.com"));
 
   PrefService* prefs = user_prefs::UserPrefs::Get(profile);
   prefs->SetBoolean(prefs::kEditBookmarksEnabled, false);
diff --git a/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.cc b/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.cc
index 5df23d9..47920e5 100644
--- a/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.cc
+++ b/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers.cc
@@ -61,7 +61,7 @@ BookmarkTreeNode* GetBookmarkTreeNode(const BookmarkNode* node,
     }
   }
 
-  bookmark_tree_node->title = UTF16ToUTF8(node->GetTitle());
+  bookmark_tree_node->title = base::UTF16ToUTF8(node->GetTitle());
   if (!node->date_added().is_null()) {
     // Javascript Date wants milliseconds since the epoch, ToDoubleT is seconds.
     bookmark_tree_node->date_added.reset(
diff --git a/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers_unittest.cc b/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers_unittest.cc
index efb54a75..ee0eaaf 100644
--- a/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers_unittest.cc
+++ b/chrome/browser/extensions/api/bookmarks/bookmark_api_helpers_unittest.cc
@@ -23,16 +23,18 @@ class ExtensionBookmarksTest : public testing::Test {
  public:
   virtual void SetUp() OVERRIDE {
     model_.reset(new BookmarkModel(NULL));
-    model_->AddURL(model_->other_node(), 0, ASCIIToUTF16("Digg"),
+    model_->AddURL(model_->other_node(), 0, base::ASCIIToUTF16("Digg"),
                      GURL("http://www.reddit.com"));
-    model_->AddURL(model_->other_node(), 0, ASCIIToUTF16("News"),
+    model_->AddURL(model_->other_node(), 0, base::ASCIIToUTF16("News"),
                      GURL("http://www.foxnews.com"));
     folder_ = model_->AddFolder(
-        model_->other_node(), 0, ASCIIToUTF16("outer folder"));
-    model_->AddFolder(folder_, 0, ASCIIToUTF16("inner folder 1"));
-    model_->AddFolder(folder_, 0, ASCIIToUTF16("inner folder 2"));
-    model_->AddURL(folder_, 0, ASCIIToUTF16("Digg"), GURL("http://reddit.com"));
-    model_->AddURL(folder_, 0, ASCIIToUTF16("CNet"), GURL("http://cnet.com"));
+        model_->other_node(), 0, base::ASCIIToUTF16("outer folder"));
+    model_->AddFolder(folder_, 0, base::ASCIIToUTF16("inner folder 1"));
+    model_->AddFolder(folder_, 0, base::ASCIIToUTF16("inner folder 2"));
+    model_->AddURL(
+        folder_, 0, base::ASCIIToUTF16("Digg"), GURL("http://reddit.com"));
+    model_->AddURL(
+        folder_, 0, base::ASCIIToUTF16("CNet"), GURL("http://cnet.com"));
   }
 
   scoped_ptr<BookmarkModel> model_;
diff --git a/chrome/browser/extensions/api/bookmarks/bookmarks_api.cc b/chrome/browser/extensions/api/bookmarks/bookmarks_api.cc
index f9b253a..32068e1 100644
--- a/chrome/browser/extensions/api/bookmarks/bookmarks_api.cc
+++ b/chrome/browser/extensions/api/bookmarks/bookmarks_api.cc
@@ -441,7 +441,7 @@ bool BookmarksSearchFunction::RunImpl() {
   if (params->query.as_string) {
     bookmark_utils::QueryFields query;
     query.word_phrase_query.reset(
-        new base::string16(UTF8ToUTF16(*params->query.as_string)));
+        new base::string16(base::UTF8ToUTF16(*params->query.as_string)));
     bookmark_utils::GetBookmarksMatchingProperties(
         BookmarkModelFactory::GetForProfile(GetProfile()),
         query,
@@ -455,12 +455,12 @@ bool BookmarksSearchFunction::RunImpl() {
     bookmark_utils::QueryFields query;
     if (object.query) {
       query.word_phrase_query.reset(
-          new base::string16(UTF8ToUTF16(*object.query)));
+          new base::string16(base::UTF8ToUTF16(*object.query)));
     }
     if (object.url)
-      query.url.reset(new base::string16(UTF8ToUTF16(*object.url)));
+      query.url.reset(new base::string16(base::UTF8ToUTF16(*object.url)));
     if (object.title)
-      query.title.reset(new base::string16(UTF8ToUTF16(*object.title)));
+      query.title.reset(new base::string16(base::UTF8ToUTF16(*object.title)));
     bookmark_utils::GetBookmarksMatchingProperties(
         BookmarkModelFactory::GetForProfile(GetProfile()),
         query,
@@ -558,7 +558,7 @@ bool BookmarksCreateFunction::RunImpl() {
 
   base::string16 title;  // Optional.
   if (params->bookmark.title.get())
-    title = UTF8ToUTF16(*params->bookmark.title.get());
+    title = base::UTF8ToUTF16(*params->bookmark.title.get());
 
   std::string url_string;  // Optional.
   if (params->bookmark.url.get())
@@ -675,7 +675,7 @@ bool BookmarksUpdateFunction::RunImpl() {
   base::string16 title;
   bool has_title = false;
   if (params->changes.title.get()) {
-    title = UTF8ToUTF16(*params->changes.title);
+    title = base::UTF8ToUTF16(*params->changes.title);
     has_title = true;
   }
 
@@ -753,7 +753,7 @@ class CreateBookmarkBucketMapper : public BookmarkBucketMapper<std::string> {
     if (!parent)
       return;
 
-    std::string bucket_id = UTF16ToUTF8(parent->GetTitle());
+    std::string bucket_id = base::UTF16ToUTF8(parent->GetTitle());
     std::string title;
     json->GetString(keys::kTitleKey, &title);
     std::string url_string;
@@ -790,8 +790,8 @@ class RemoveBookmarksBucketMapper : public BookmarkBucketMapper<std::string> {
         return;
 
       std::string bucket_id;
-      bucket_id += UTF16ToUTF8(node->parent()->GetTitle());
-      bucket_id += UTF16ToUTF8(node->GetTitle());
+      bucket_id += base::UTF16ToUTF8(node->parent()->GetTitle());
+      bucket_id += base::UTF16ToUTF8(node->GetTitle());
       bucket_id += node->url().spec();
       buckets->push_back(GetBucket(base::SHA1HashString(bucket_id)));
     }
diff --git a/chrome/browser/extensions/api/content_settings/content_settings_apitest.cc b/chrome/browser/extensions/api/content_settings/content_settings_apitest.cc
index e17de51..698a4ca 100644
--- a/chrome/browser/extensions/api/content_settings/content_settings_apitest.cc
+++ b/chrome/browser/extensions/api/content_settings/content_settings_apitest.cc
@@ -218,16 +218,16 @@ IN_PROC_BROWSER_TEST_F(ExtensionContentSettingsApiTest,
   const char* kBarName = "Bar Plugin";
 
   content::PluginService::GetInstance()->RegisterInternalPlugin(
-      content::WebPluginInfo(ASCIIToUTF16(kFooName),
+      content::WebPluginInfo(base::ASCIIToUTF16(kFooName),
                              base::FilePath(kFooPath),
-                             ASCIIToUTF16("1.2.3"),
-                             ASCIIToUTF16("foo")),
+                             base::ASCIIToUTF16("1.2.3"),
+                             base::ASCIIToUTF16("foo")),
       false);
   content::PluginService::GetInstance()->RegisterInternalPlugin(
-    content::WebPluginInfo(ASCIIToUTF16(kBarName),
+    content::WebPluginInfo(base::ASCIIToUTF16(kBarName),
                            base::FilePath(kBarPath),
-                           ASCIIToUTF16("2.3.4"),
-                           ASCIIToUTF16("bar")),
+                           base::ASCIIToUTF16("2.3.4"),
+                           base::ASCIIToUTF16("bar")),
       false);
 
   EXPECT_TRUE(RunExtensionTest("content_settings/getresourceidentifiers"))
diff --git a/chrome/browser/extensions/api/cookies/cookies_helpers.cc b/chrome/browser/extensions/api/cookies/cookies_helpers.cc
index 954bbe9..750bd1e 100644
--- a/chrome/browser/extensions/api/cookies/cookies_helpers.cc
+++ b/chrome/browser/extensions/api/cookies/cookies_helpers.cc
@@ -69,8 +69,9 @@ scoped_ptr<Cookie> CreateCookie(
 
   // A cookie is a raw byte sequence. By explicitly parsing it as UTF-8, we
   // apply error correction, so the string can be safely passed to the renderer.
-  cookie->name = UTF16ToUTF8(UTF8ToUTF16(canonical_cookie.Name()));
-  cookie->value = UTF16ToUTF8(UTF8ToUTF16(canonical_cookie.Value()));
+  cookie->name = base::UTF16ToUTF8(base::UTF8ToUTF16(canonical_cookie.Name()));
+  cookie->value =
+      base::UTF16ToUTF8(base::UTF8ToUTF16(canonical_cookie.Value()));
   cookie->domain = canonical_cookie.Domain();
   cookie->host_only = net::cookie_util::DomainIsHostOnly(
       canonical_cookie.Domain());
diff --git a/chrome/browser/extensions/api/debugger/debugger_api.cc b/chrome/browser/extensions/api/debugger/debugger_api.cc
index 6a21a3f..ec07c42 100644
--- a/chrome/browser/extensions/api/debugger/debugger_api.cc
+++ b/chrome/browser/extensions/api/debugger/debugger_api.cc
@@ -216,7 +216,7 @@ bool ExtensionDevToolsInfoBarDelegate::ShouldExpireInternal(
 
 base::string16 ExtensionDevToolsInfoBarDelegate::GetMessageText() const {
   return l10n_util::GetStringFUTF16(IDS_DEV_TOOLS_INFOBAR_LABEL,
-                                    UTF8ToUTF16(client_name_));
+                                    base::UTF8ToUTF16(client_name_));
 }
 
 int ExtensionDevToolsInfoBarDelegate::GetButtons() const {
diff --git a/chrome/browser/extensions/api/desktop_capture/desktop_capture_api.cc b/chrome/browser/extensions/api/desktop_capture/desktop_capture_api.cc
index 9cd24f25..3a67a6a 100644
--- a/chrome/browser/extensions/api/desktop_capture/desktop_capture_api.cc
+++ b/chrome/browser/extensions/api/desktop_capture/desktop_capture_api.cc
@@ -186,7 +186,7 @@ bool DesktopCaptureChooseDesktopMediaFunction::RunImpl() {
       &DesktopCaptureChooseDesktopMediaFunction::OnPickerDialogResults, this);
 
   picker_->Show(parent_window, parent_window,
-                UTF8ToUTF16(GetExtension()->name()),
+                base::UTF8ToUTF16(GetExtension()->name()),
                 media_list.Pass(), callback);
   return true;
 }
diff --git a/chrome/browser/extensions/api/developer_private/developer_private_api.cc b/chrome/browser/extensions/api/developer_private/developer_private_api.cc
index d89cc9c..b12ce87 100644
--- a/chrome/browser/extensions/api/developer_private/developer_private_api.cc
+++ b/chrome/browser/extensions/api/developer_private/developer_private_api.cc
@@ -320,7 +320,7 @@ scoped_ptr<developer::ItemInfo>
 
   if (Manifest::IsUnpackedLocation(item.location())) {
     info->path.reset(
-        new std::string(UTF16ToUTF8(item.path().LossyDisplayName())));
+        new std::string(base::UTF16ToUTF8(item.path().LossyDisplayName())));
     for (std::vector<extensions::InstallWarning>::const_iterator it =
              item.install_warnings().begin();
          it != item.install_warnings().end(); ++it) {
@@ -769,7 +769,7 @@ void DeveloperPrivateEnableFunction::OnRequirementsChecked(
     service->EnableExtension(extension_id);
   } else {
     ExtensionErrorReporter::GetInstance()->ReportError(
-        UTF8ToUTF16(JoinString(requirements_errors, ' ')),
+        base::UTF8ToUTF16(JoinString(requirements_errors, ' ')),
         true /* be noisy */);
   }
   Release();
@@ -877,8 +877,8 @@ void DeveloperPrivatePackDirectoryFunction::OnPackSuccess(
     const base::FilePath& crx_file,
     const base::FilePath& pem_file) {
   developer::PackDirectoryResponse response;
-  response.message =
-      UTF16ToUTF8(PackExtensionJob::StandardSuccessMessage(crx_file, pem_file));
+  response.message = base::UTF16ToUTF8(
+      PackExtensionJob::StandardSuccessMessage(crx_file, pem_file));
   response.status = developer::PACK_STATUS_SUCCESS;
   results_ = developer::PackDirectory::Results::Create(response);
   SendResponse(true);
@@ -1210,7 +1210,7 @@ bool DeveloperPrivateChoosePathFunction::RunImpl() {
 
 void DeveloperPrivateChoosePathFunction::FileSelected(
     const base::FilePath& path) {
-  SetResult(new base::StringValue(UTF16ToUTF8(path.LossyDisplayName())));
+  SetResult(new base::StringValue(base::UTF16ToUTF8(path.LossyDisplayName())));
   SendResponse(true);
   Release();
 }
diff --git a/chrome/browser/extensions/api/file_system/file_system_api.cc b/chrome/browser/extensions/api/file_system/file_system_api.cc
index d76f697..0e9c267 100644
--- a/chrome/browser/extensions/api/file_system/file_system_api.cc
+++ b/chrome/browser/extensions/api/file_system/file_system_api.cc
@@ -191,7 +191,7 @@ bool GetFileTypesFromAcceptOption(
       std::string extension = *iter;
       StringToLowerASCII(&extension);
 #if defined(OS_WIN)
-      extension_set.insert(UTF8ToWide(*iter));
+      extension_set.insert(base::UTF8ToWide(*iter));
 #else
       extension_set.insert(*iter);
 #endif
@@ -203,7 +203,7 @@ bool GetFileTypesFromAcceptOption(
     return false;
 
   if (accept_option.description.get())
-    *description = UTF8ToUTF16(*accept_option.description.get());
+    *description = base::UTF8ToUTF16(*accept_option.description.get());
   else if (description_id)
     *description = l10n_util::GetStringUTF16(description_id);
 
@@ -731,7 +731,7 @@ void FileSystemChooseEntryFunction::ConfirmDirectoryAccessOnFileThread(
           base::Bind(
               CreateDirectoryAccessConfirmationDialog,
               app_file_handler_util::HasFileSystemWritePermission(extension_),
-              UTF8ToUTF16(extension_->name()),
+              base::UTF8ToUTF16(extension_->name()),
               web_contents,
               base::Bind(
                   &FileSystemChooseEntryFunction::OnDirectoryAccessConfirmed,
diff --git a/chrome/browser/extensions/api/file_system/file_system_api_unittest.cc b/chrome/browser/extensions/api/file_system/file_system_api_unittest.cc
index 6c7ab46..ba2fd95 100644
--- a/chrome/browser/extensions/api/file_system/file_system_api_unittest.cc
+++ b/chrome/browser/extensions/api/file_system/file_system_api_unittest.cc
@@ -47,7 +47,7 @@ AcceptOption* BuildAcceptOption(std::string description,
 }
 
 #if defined(OS_WIN)
-#define ToStringType UTF8ToWide
+#define ToStringType base::UTF8ToWide
 #else
 #define ToStringType
 #endif
@@ -150,7 +150,7 @@ TEST_F(FileSystemApiUnitTest, FileSystemChooseEntryFunctionFileTypeInfoTest) {
   FileSystemChooseEntryFunction::BuildFileTypeInfo(&file_type_info,
       base::FilePath::StringType(), &options, &acceptsAllTypes);
   EXPECT_EQ(file_type_info.extension_description_overrides[0],
-      UTF8ToUTF16("File Types 101"));
+      base::UTF8ToUTF16("File Types 101"));
 }
 
 TEST_F(FileSystemApiUnitTest, FileSystemChooseEntryFunctionSuggestionTest) {
diff --git a/chrome/browser/extensions/api/history/history_api.cc b/chrome/browser/extensions/api/history/history_api.cc
index 6504afe..8ea8cd7 100644
--- a/chrome/browser/extensions/api/history/history_api.cc
+++ b/chrome/browser/extensions/api/history/history_api.cc
@@ -66,7 +66,7 @@ scoped_ptr<HistoryItem> GetHistoryItem(const history::URLRow& row) {
 
   history_item->id = base::Int64ToString(row.id());
   history_item->url.reset(new std::string(row.url().spec()));
-  history_item->title.reset(new std::string(UTF16ToUTF8(row.title())));
+  history_item->title.reset(new std::string(base::UTF16ToUTF8(row.title())));
   history_item->last_visit_time.reset(
       new double(MilliSecondsFromTime(row.last_visit())));
   history_item->typed_count.reset(new int(row.typed_count()));
@@ -334,7 +334,7 @@ bool HistorySearchFunction::RunAsyncImpl() {
   scoped_ptr<Search::Params> params(Search::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  base::string16 search_text = UTF8ToUTF16(params->query.text);
+  base::string16 search_text = base::UTF8ToUTF16(params->query.text);
 
   history::QueryOptions options;
   options.SetRecentDayRange(1);
diff --git a/chrome/browser/extensions/api/i18n/i18n_apitest.cc b/chrome/browser/extensions/api/i18n/i18n_apitest.cc
index 93e3b54..d0f3fa5 100644
--- a/chrome/browser/extensions/api/i18n/i18n_apitest.cc
+++ b/chrome/browser/extensions/api/i18n/i18n_apitest.cc
@@ -48,7 +48,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionApiTest, I18NUpdate) {
 
   base::string16 title;
   ui_test_utils::GetCurrentTabTitle(browser(), &title);
-  EXPECT_EQ(std::string("FIRSTMESSAGE"), UTF16ToUTF8(title));
+  EXPECT_EQ(std::string("FIRSTMESSAGE"), base::UTF16ToUTF8(title));
 
   // Change messages.json file and reload extension.
   base::CopyFile(
@@ -64,5 +64,5 @@ IN_PROC_BROWSER_TEST_F(ExtensionApiTest, I18NUpdate) {
   EXPECT_TRUE(catcher.GetNextResult());
 
   ui_test_utils::GetCurrentTabTitle(browser(), &title);
-  EXPECT_EQ(std::string("SECONDMESSAGE"), UTF16ToUTF8(title));
+  EXPECT_EQ(std::string("SECONDMESSAGE"), base::UTF16ToUTF8(title));
 }
diff --git a/chrome/browser/extensions/api/identity/web_auth_flow.cc b/chrome/browser/extensions/api/identity/web_auth_flow.cc
index 01a284c..21973824cf 100644
--- a/chrome/browser/extensions/api/identity/web_auth_flow.cc
+++ b/chrome/browser/extensions/api/identity/web_auth_flow.cc
@@ -192,7 +192,7 @@ void WebAuthFlow::Observe(int type,
 
         if (title->first) {
           delegate_->OnAuthFlowTitleChange(
-              UTF16ToUTF8(title->first->GetTitle()));
+              base::UTF16ToUTF8(title->first->GetTitle()));
         }
         break;
       }
diff --git a/chrome/browser/extensions/api/management/management_api.cc b/chrome/browser/extensions/api/management/management_api.cc
index 76f308c..eb45dfa 100644
--- a/chrome/browser/extensions/api/management/management_api.cc
+++ b/chrome/browser/extensions/api/management/management_api.cc
@@ -83,7 +83,7 @@ std::vector<std::string> CreateWarningsList(const Extension* extension) {
       PermissionsData::GetPermissionMessages(extension);
   for (PermissionMessages::const_iterator iter = warnings.begin();
        iter != warnings.end(); ++iter) {
-    warnings_list.push_back(UTF16ToUTF8(iter->message()));
+    warnings_list.push_back(base::UTF16ToUTF8(iter->message()));
   }
 
   return warnings_list;
diff --git a/chrome/browser/extensions/api/media_galleries/media_galleries_apitest.cc b/chrome/browser/extensions/api/media_galleries/media_galleries_apitest.cc
index effdcf1..477ebb19 100644
--- a/chrome/browser/extensions/api/media_galleries/media_galleries_apitest.cc
+++ b/chrome/browser/extensions/api/media_galleries/media_galleries_apitest.cc
@@ -109,7 +109,7 @@ class MediaGalleriesPlatformAppBrowserTest : public PlatformAppBrowserTest {
 
     StorageMonitor::GetInstance()->receiver()->ProcessAttach(
         StorageInfo(device_id_, base::string16(), kDevicePath,
-                    ASCIIToUTF16(kDeviceName), base::string16(),
+                    base::ASCIIToUTF16(kDeviceName), base::string16(),
                     base::string16(), 0));
     content::RunAllPendingInMessageLoop();
   }
diff --git a/chrome/browser/extensions/api/media_galleries_private/media_galleries_private_apitest.cc b/chrome/browser/extensions/api/media_galleries_private/media_galleries_private_apitest.cc
index 4eaa393..e6757f2 100644
--- a/chrome/browser/extensions/api/media_galleries_private/media_galleries_private_apitest.cc
+++ b/chrome/browser/extensions/api/media_galleries_private/media_galleries_private_apitest.cc
@@ -78,7 +78,7 @@ class MediaGalleriesPrivateApiTest : public ExtensionApiTest {
                       const std::string& ok_message) {
     ExtensionTestMessageListener listener(ok_message, false  /* no reply */);
     host->ExecuteJavascriptInWebFrame(base::string16(),
-                                      ASCIIToUTF16(js_command));
+                                      base::ASCIIToUTF16(js_command));
     EXPECT_TRUE(listener.WaitUntilSatisfied());
   }
 
@@ -89,7 +89,7 @@ class MediaGalleriesPrivateApiTest : public ExtensionApiTest {
 
   void Attach() {
     DCHECK(StorageMonitor::GetInstance()->IsInitialized());
-    StorageInfo info(device_id_, ASCIIToUTF16(kDeviceName), kDevicePath,
+    StorageInfo info(device_id_, base::ASCIIToUTF16(kDeviceName), kDevicePath,
                      base::string16(), base::string16(), base::string16(), 0);
     StorageMonitor::GetInstance()->receiver()->ProcessAttach(info);
     content::RunAllPendingInMessageLoop();
diff --git a/chrome/browser/extensions/api/media_galleries_private/media_galleries_private_event_router.cc b/chrome/browser/extensions/api/media_galleries_private/media_galleries_private_event_router.cc
index b924116..9a7e007 100644
--- a/chrome/browser/extensions/api/media_galleries_private/media_galleries_private_event_router.cc
+++ b/chrome/browser/extensions/api/media_galleries_private/media_galleries_private_event_router.cc
@@ -101,7 +101,7 @@ void MediaGalleriesPrivateEventRouter::OnRemovableStorageAttached(
   pref_info.volume_metadata_valid = true;
 
   DeviceAttachmentDetails details;
-  details.device_name = UTF16ToUTF8(pref_info.GetGalleryDisplayName());
+  details.device_name = base::UTF16ToUTF8(pref_info.GetGalleryDisplayName());
   details.device_id = GetTransientIdForDeviceId(info.device_id());
 
   scoped_ptr<base::ListValue> args(new base::ListValue());
diff --git a/chrome/browser/extensions/api/media_galleries_private/media_galleries_watch_apitest.cc b/chrome/browser/extensions/api/media_galleries_private/media_galleries_watch_apitest.cc
index 3dcf12d..9f83c21 100644
--- a/chrome/browser/extensions/api/media_galleries_private/media_galleries_watch_apitest.cc
+++ b/chrome/browser/extensions/api/media_galleries_private/media_galleries_watch_apitest.cc
@@ -90,7 +90,7 @@ class MediaGalleriesPrivateGalleryWatchApiTest : public ExtensionApiTest {
                               const std::string& ok_message) {
     ExtensionTestMessageListener listener(ok_message, false);
     host->ExecuteJavascriptInWebFrame(base::string16(),
-                                      ASCIIToUTF16(js_command));
+                                      base::ASCIIToUTF16(js_command));
     EXPECT_TRUE(listener.WaitUntilSatisfied());
   }
 
diff --git a/chrome/browser/extensions/api/messaging/incognito_connectability.cc b/chrome/browser/extensions/api/messaging/incognito_connectability.cc
index 09a8f05..14fb252 100644
--- a/chrome/browser/extensions/api/messaging/incognito_connectability.cc
+++ b/chrome/browser/extensions/api/messaging/incognito_connectability.cc
@@ -81,8 +81,8 @@ bool IncognitoConnectability::Query(const Extension* extension,
                        : NULL,
           base::string16(),  // no title
           l10n_util::GetStringFUTF16(template_id,
-                                     UTF8ToUTF16(origin.spec()),
-                                     UTF8ToUTF16(extension->name())),
+                                     base::UTF8ToUTF16(origin.spec()),
+                                     base::UTF8ToUTF16(extension->name())),
           chrome::MESSAGE_BOX_TYPE_QUESTION);
       break;
     }
diff --git a/chrome/browser/extensions/api/messaging/native_process_launcher_win.cc b/chrome/browser/extensions/api/messaging/native_process_launcher_win.cc
index c47f041..4856627 100644
--- a/chrome/browser/extensions/api/messaging/native_process_launcher_win.cc
+++ b/chrome/browser/extensions/api/messaging/native_process_launcher_win.cc
@@ -49,7 +49,7 @@ base::string16 GetManifestPath(const base::string16& native_host_name,
 base::FilePath NativeProcessLauncher::FindManifest(
     const std::string& native_host_name,
     std::string* error_message) {
-  base::string16 native_host_name_wide = UTF8ToUTF16(native_host_name);
+  base::string16 native_host_name_wide = base::UTF8ToUTF16(native_host_name);
 
   // First check 32-bit registry and then try 64-bit.
   base::string16 manifest_path_str =
diff --git a/chrome/browser/extensions/api/notifications/notifications_api.cc b/chrome/browser/extensions/api/notifications/notifications_api.cc
index b9d97d2..5b266e8 100644
--- a/chrome/browser/extensions/api/notifications/notifications_api.cc
+++ b/chrome/browser/extensions/api/notifications/notifications_api.cc
@@ -248,8 +248,8 @@ bool NotificationsApiFunction::CreateNotification(
   // Extract required fields: type, title, message, and icon.
   message_center::NotificationType type =
       MapApiTemplateTypeToType(options->type);
-  const base::string16 title(UTF8ToUTF16(*options->title));
-  const base::string16 message(UTF8ToUTF16(*options->message));
+  const base::string16 title(base::UTF8ToUTF16(*options->title));
+  const base::string16 message(base::UTF8ToUTF16(*options->message));
   gfx::Image icon;
 
   // TODO(dewittj): Return error if this fails.
@@ -271,7 +271,7 @@ bool NotificationsApiFunction::CreateNotification(
 
       for (size_t i = 0; i < number_of_buttons; i++) {
         message_center::ButtonInfo info(
-            UTF8ToUTF16((*options->buttons)[i]->title));
+            base::UTF8ToUTF16((*options->buttons)[i]->title));
         NotificationBitmapToGfxImage((*options->buttons)[i]->icon_bitmap.get(),
                                      &info.icon);
         optional_fields.buttons.push_back(info);
@@ -280,11 +280,13 @@ bool NotificationsApiFunction::CreateNotification(
 
     if (options->expanded_message.get()) {
       optional_fields.expanded_message =
-          UTF8ToUTF16(*options->expanded_message);
+          base::UTF8ToUTF16(*options->expanded_message);
     }
 
-    if (options->context_message)
-      optional_fields.context_message = UTF8ToUTF16(*options->context_message);
+    if (options->context_message) {
+      optional_fields.context_message =
+          base::UTF8ToUTF16(*options->context_message);
+    }
 
     bool has_image = NotificationBitmapToGfxImage(options->image_bitmap.get(),
                                                   &optional_fields.image);
@@ -315,8 +317,9 @@ bool NotificationsApiFunction::CreateNotification(
       using api::notifications::NotificationItem;
       std::vector<linked_ptr<NotificationItem> >::iterator i;
       for (i = options->items->begin(); i != options->items->end(); ++i) {
-        message_center::NotificationItem item(UTF8ToUTF16(i->get()->title),
-                                              UTF8ToUTF16(i->get()->message));
+        message_center::NotificationItem item(
+            base::UTF8ToUTF16(i->get()->title),
+            base::UTF8ToUTF16(i->get()->message));
         optional_fields.items.push_back(item);
       }
     }
@@ -337,8 +340,8 @@ bool NotificationsApiFunction::CreateNotification(
                             message_center::NotifierId(
                                 message_center::NotifierId::APPLICATION,
                                 extension_->id()),
-                            UTF8ToUTF16(extension_->name()),
-                            UTF8ToUTF16(api_delegate->id()),
+                            base::UTF8ToUTF16(extension_->name()),
+                            base::UTF8ToUTF16(api_delegate->id()),
                             optional_fields,
                             api_delegate);
 
@@ -354,9 +357,9 @@ bool NotificationsApiFunction::UpdateNotification(
   if (options->type != api::notifications::TEMPLATE_TYPE_NONE)
     notification->set_type(MapApiTemplateTypeToType(options->type));
   if (options->title)
-    notification->set_title(UTF8ToUTF16(*options->title));
+    notification->set_title(base::UTF8ToUTF16(*options->title));
   if (options->message)
-    notification->set_message(UTF8ToUTF16(*options->message));
+    notification->set_message(base::UTF8ToUTF16(*options->message));
 
   // TODO(dewittj): Return error if this fails.
   if (options->icon_bitmap) {
@@ -380,7 +383,7 @@ bool NotificationsApiFunction::UpdateNotification(
       std::vector<message_center::ButtonInfo> buttons;
       for (size_t i = 0; i < number_of_buttons; i++) {
         message_center::ButtonInfo button(
-            UTF8ToUTF16((*options->buttons)[i]->title));
+            base::UTF8ToUTF16((*options->buttons)[i]->title));
         NotificationBitmapToGfxImage((*options->buttons)[i]->icon_bitmap.get(),
                                      &button.icon);
         buttons.push_back(button);
@@ -388,12 +391,14 @@ bool NotificationsApiFunction::UpdateNotification(
       notification->set_buttons(buttons);
     }
 
-    if (options->context_message)
-      notification->set_context_message(UTF8ToUTF16(*options->context_message));
+    if (options->context_message) {
+      notification->set_context_message(
+          base::UTF8ToUTF16(*options->context_message));
+    }
 
     if (options->expanded_message) {
       notification->set_expanded_message(
-          UTF8ToUTF16(*options->expanded_message));
+          base::UTF8ToUTF16(*options->expanded_message));
     }
 
     gfx::Image image;
@@ -428,8 +433,9 @@ bool NotificationsApiFunction::UpdateNotification(
       using api::notifications::NotificationItem;
       std::vector<linked_ptr<NotificationItem> >::iterator i;
       for (i = options->items->begin(); i != options->items->end(); ++i) {
-        message_center::NotificationItem item(UTF8ToUTF16(i->get()->title),
-                                              UTF8ToUTF16(i->get()->message));
+        message_center::NotificationItem item(
+            base::UTF8ToUTF16(i->get()->title),
+            base::UTF8ToUTF16(i->get()->message));
         items.push_back(item);
       }
       notification->set_items(items);
diff --git a/chrome/browser/extensions/api/notifications/notifications_apitest.cc b/chrome/browser/extensions/api/notifications/notifications_apitest.cc
index 59d597f..286d0b7 100644
--- a/chrome/browser/extensions/api/notifications/notifications_apitest.cc
+++ b/chrome/browser/extensions/api/notifications/notifications_apitest.cc
@@ -720,8 +720,8 @@ IN_PROC_BROWSER_TEST_F(NotificationsApiTest, MAYBE_TestPartialUpdate) {
       g_browser_process->message_center()->GetVisibleNotifications();
   ASSERT_EQ(1u, notifications.size());
   message_center::Notification* notification = *(notifications.begin());
-  EXPECT_EQ(ASCIIToUTF16(kNewTitle), notification->title());
-  EXPECT_EQ(ASCIIToUTF16(kNewMessage), notification->message());
+  EXPECT_EQ(base::ASCIIToUTF16(kNewTitle), notification->title());
+  EXPECT_EQ(base::ASCIIToUTF16(kNewMessage), notification->message());
   EXPECT_EQ(kNewPriority, notification->priority());
   EXPECT_EQ(0u, notification->buttons().size());
 }
diff --git a/chrome/browser/extensions/api/omnibox/omnibox_api.cc b/chrome/browser/extensions/api/omnibox/omnibox_api.cc
index f1d7421..8380703 100644
--- a/chrome/browser/extensions/api/omnibox/omnibox_api.cc
+++ b/chrome/browser/extensions/api/omnibox/omnibox_api.cc
@@ -317,7 +317,7 @@ ACMatchClassifications StyleTypesToACMatchClassifications(
     const omnibox::SuggestResult &suggestion) {
   ACMatchClassifications match_classifications;
   if (suggestion.description_styles) {
-    base::string16 description = UTF8ToUTF16(suggestion.description);
+    base::string16 description = base::UTF8ToUTF16(suggestion.description);
     std::vector<int> styles(description.length(), 0);
 
     for (std::vector<linked_ptr<omnibox::SuggestResult::DescriptionStylesType> >
@@ -377,10 +377,10 @@ void ApplyDefaultSuggestionForExtensionKeyword(
   if (!suggestion || suggestion->description.empty())
     return;  // fall back to the universal default
 
-  const base::string16 kPlaceholderText(ASCIIToUTF16("%s"));
-  const base::string16 kReplacementText(ASCIIToUTF16("<input>"));
+  const base::string16 kPlaceholderText(base::ASCIIToUTF16("%s"));
+  const base::string16 kReplacementText(base::ASCIIToUTF16("<input>"));
 
-  base::string16 description = UTF8ToUTF16(suggestion->description);
+  base::string16 description = base::UTF8ToUTF16(suggestion->description);
   ACMatchClassifications& description_styles = match->contents_class;
   description_styles = StyleTypesToACMatchClassifications(*suggestion);
 
diff --git a/chrome/browser/extensions/api/omnibox/omnibox_api_browsertest.cc b/chrome/browser/extensions/api/omnibox/omnibox_api_browsertest.cc
index ef2b413..6042557 100644
--- a/chrome/browser/extensions/api/omnibox/omnibox_api_browsertest.cc
+++ b/chrome/browser/extensions/api/omnibox/omnibox_api_browsertest.cc
@@ -17,6 +17,8 @@
 #include "chrome/test/base/ui_test_utils.h"
 #include "ui/base/window_open_disposition.h"
 
+using base::ASCIIToUTF16;
+
 IN_PROC_BROWSER_TEST_F(OmniboxApiTest, Basic) {
   ASSERT_TRUE(RunExtensionTest("omnibox")) << message_;
 
diff --git a/chrome/browser/extensions/api/omnibox/omnibox_api_interactive_test.cc b/chrome/browser/extensions/api/omnibox/omnibox_api_interactive_test.cc
index d8b68c2..164a2a9 100644
--- a/chrome/browser/extensions/api/omnibox/omnibox_api_interactive_test.cc
+++ b/chrome/browser/extensions/api/omnibox/omnibox_api_interactive_test.cc
@@ -26,7 +26,7 @@ IN_PROC_BROWSER_TEST_F(OmniboxApiTest, PopupStaysClosed) {
 
   // Input a keyword query and wait for suggestions from the extension.
   omnibox_view->OnBeforePossibleChange();
-  omnibox_view->SetUserText(ASCIIToUTF16("keyword comman"));
+  omnibox_view->SetUserText(base::ASCIIToUTF16("keyword comman"));
   omnibox_view->OnAfterPossibleChange();
   WaitForAutocompleteDone(autocomplete_controller);
   EXPECT_TRUE(autocomplete_controller->done());
@@ -41,9 +41,10 @@ IN_PROC_BROWSER_TEST_F(OmniboxApiTest, PopupStaysClosed) {
   // directly, figure out how to send it via the proper calls to
   // location_bar or location_bar->().
   autocomplete_controller->Start(
-      AutocompleteInput(ASCIIToUTF16("keyword command"), base::string16::npos,
-                        base::string16(), GURL(), AutocompleteInput::NTP,
-                        true, false, true, AutocompleteInput::ALL_MATCHES));
+      AutocompleteInput(base::ASCIIToUTF16("keyword command"),
+                        base::string16::npos, base::string16(), GURL(),
+                        AutocompleteInput::NTP, true, false, true,
+                        AutocompleteInput::ALL_MATCHES));
   location_bar->AcceptInput();
   WaitForAutocompleteDone(autocomplete_controller);
   EXPECT_TRUE(autocomplete_controller->done());
diff --git a/chrome/browser/extensions/api/omnibox/omnibox_api_testbase.h b/chrome/browser/extensions/api/omnibox/omnibox_api_testbase.h
index 169ca90..27029e9 100644
--- a/chrome/browser/extensions/api/omnibox/omnibox_api_testbase.h
+++ b/chrome/browser/extensions/api/omnibox/omnibox_api_testbase.h
@@ -49,11 +49,12 @@ class OmniboxApiTest : public ExtensionApiTest {
     for (size_t i = 0; i < result.size(); ++i) {
       AutocompleteMatch match = result.match_at(i);
       std::string provider_name = match.provider->GetName();
-      output.append(base::StringPrintf("[\"%s\" by \"%s\"] ",
-                                       UTF16ToUTF8(match.contents).c_str(),
-                                       provider_name.c_str()));
+      output.append(
+          base::StringPrintf("[\"%s\" by \"%s\"] ",
+                             base::UTF16ToUTF8(match.contents).c_str(),
+                             provider_name.c_str()));
     }
-    return UTF8ToUTF16(output);
+    return base::UTF8ToUTF16(output);
   }
 };
 
diff --git a/chrome/browser/extensions/api/proxy/proxy_api.cc b/chrome/browser/extensions/api/proxy/proxy_api.cc
index 3f43260..c61d6ed 100644
--- a/chrome/browser/extensions/api/proxy/proxy_api.cc
+++ b/chrome/browser/extensions/api/proxy/proxy_api.cc
@@ -65,10 +65,11 @@ void ProxyEventRouter::OnPACScriptError(
                   net::ErrorToString(net::ERR_PAC_SCRIPT_FAILED));
   std::string error_msg;
   if (line_number != -1) {
-    base::SStringPrintf(
-        &error_msg, "line: %d: %s", line_number, UTF16ToUTF8(error).c_str());
+    base::SStringPrintf(&error_msg,
+                        "line: %d: %s",
+                        line_number, base::UTF16ToUTF8(error).c_str());
   } else {
-    error_msg = UTF16ToUTF8(error);
+    error_msg = base::UTF16ToUTF8(error);
   }
   dict->SetString(keys::kProxyEventDetails, error_msg);
   args->Append(dict);
diff --git a/chrome/browser/extensions/api/proxy/proxy_api_helpers.cc b/chrome/browser/extensions/api/proxy/proxy_api_helpers.cc
index 69d9ccb..e9d0806 100644
--- a/chrome/browser/extensions/api/proxy/proxy_api_helpers.cc
+++ b/chrome/browser/extensions/api/proxy/proxy_api_helpers.cc
@@ -173,7 +173,7 @@ bool GetProxyServer(const base::DictionaryValue* proxy_server,
     *error = ErrorUtils::FormatErrorMessage(
         "Invalid 'rules.???.host' entry '*'. 'host' field supports only ASCII "
         "URLs (encode URLs in Punycode format).",
-        UTF16ToUTF8(host16));
+        base::UTF16ToUTF8(host16));
     return false;
   }
   std::string host = UTF16ToASCII(host16);
diff --git a/chrome/browser/extensions/api/push_messaging/push_messaging_canary_test.cc b/chrome/browser/extensions/api/push_messaging/push_messaging_canary_test.cc
index f86684c..aa34756 100644
--- a/chrome/browser/extensions/api/push_messaging/push_messaging_canary_test.cc
+++ b/chrome/browser/extensions/api/push_messaging/push_messaging_canary_test.cc
@@ -156,7 +156,7 @@ IN_PROC_BROWSER_TEST_F(PushMessagingCanaryTest, MANUAL_ReceivesPush) {
   const std::string& client_secret = sync_setup_helper()->client_secret();
   const std::string& refresh_token = sync_setup_helper()->refresh_token();
 
-  const base::string16& script_string = UTF8ToUTF16(base::StringPrintf(
+  const base::string16& script_string = base::UTF8ToUTF16(base::StringPrintf(
       "startTestWithCredentials('%s', '%s', '%s');",
       client_id.c_str(), client_secret.c_str(), refresh_token.c_str()));
 
diff --git a/chrome/browser/extensions/api/sessions/sessions_api.cc b/chrome/browser/extensions/api/sessions/sessions_api.cc
index 9bd68b1..2e45123 100644
--- a/chrome/browser/extensions/api/sessions/sessions_api.cc
+++ b/chrome/browser/extensions/api/sessions/sessions_api.cc
@@ -78,7 +78,7 @@ scoped_ptr<tabs::Tab> CreateTabModelHelper(
   scoped_ptr<tabs::Tab> tab_struct(new tabs::Tab);
 
   GURL gurl = current_navigation.virtual_url();
-  std::string title = UTF16ToUTF8(current_navigation.title());
+  std::string title = base::UTF16ToUTF8(current_navigation.title());
 
   tab_struct->session_id.reset(new std::string(session_id));
   tab_struct->url.reset(new std::string(gurl.spec()));
@@ -87,7 +87,7 @@ scoped_ptr<tabs::Tab> CreateTabModelHelper(
   } else {
     const std::string languages =
         profile->GetPrefs()->GetString(prefs::kAcceptLanguages);
-    tab_struct->title.reset(new std::string(UTF16ToUTF8(
+    tab_struct->title.reset(new std::string(base::UTF16ToUTF8(
         net::FormatUrl(gurl, languages))));
   }
   tab_struct->index = index;
diff --git a/chrome/browser/extensions/api/settings_overrides/settings_overrides_api.cc b/chrome/browser/extensions/api/settings_overrides/settings_overrides_api.cc
index 6ed3b95..ea2f468 100644
--- a/chrome/browser/extensions/api/settings_overrides/settings_overrides_api.cc
+++ b/chrome/browser/extensions/api/settings_overrides/settings_overrides_api.cc
@@ -35,8 +35,8 @@ TemplateURLData ConvertSearchProvider(
     const ChromeSettingsOverrides::Search_provider& search_provider) {
   TemplateURLData data;
 
-  data.short_name = UTF8ToUTF16(search_provider.name);
-  data.SetKeyword(UTF8ToUTF16(search_provider.keyword));
+  data.short_name = base::UTF8ToUTF16(search_provider.name);
+  data.SetKeyword(base::UTF8ToUTF16(search_provider.keyword));
   data.SetURL(search_provider.search_url);
   if (search_provider.suggest_url)
     data.suggestions_url = *search_provider.suggest_url;
diff --git a/chrome/browser/extensions/api/settings_overrides/settings_overrides_browsertest.cc b/chrome/browser/extensions/api/settings_overrides/settings_overrides_browsertest.cc
index 4c478ed..c647a5c 100644
--- a/chrome/browser/extensions/api/settings_overrides/settings_overrides_browsertest.cc
+++ b/chrome/browser/extensions/api/settings_overrides/settings_overrides_browsertest.cc
@@ -79,8 +79,8 @@ IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, OverrideSettings) {
   TemplateURL* extension_provider = url_service->GetDefaultSearchProvider();
   EXPECT_EQ(TemplateURL::NORMAL_CONTROLLED_BY_EXTENSION,
             extension_provider->GetType());
-  EXPECT_EQ(ASCIIToUTF16("name.de"), extension_provider->short_name());
-  EXPECT_EQ(ASCIIToUTF16("keyword.de"), extension_provider->keyword());
+  EXPECT_EQ(base::ASCIIToUTF16("name.de"), extension_provider->short_name());
+  EXPECT_EQ(base::ASCIIToUTF16("keyword.de"), extension_provider->keyword());
   EXPECT_EQ("http://www.foo.de/s?q={searchTerms}", extension_provider->url());
   EXPECT_EQ(GURL("http://www.foo.de/favicon.ico"),
             extension_provider->favicon_url());
diff --git a/chrome/browser/extensions/api/system_display/display_info_provider_win.cc b/chrome/browser/extensions/api/system_display/display_info_provider_win.cc
index f68de6a..ab8fd83 100644
--- a/chrome/browser/extensions/api/system_display/display_info_provider_win.cc
+++ b/chrome/browser/extensions/api/system_display/display_info_provider_win.cc
@@ -39,8 +39,9 @@ BOOL CALLBACK EnumMonitorCallback(HMONITOR monitor,
     return FALSE;
 
   gfx::Size dpi(gfx::GetDPI());
-  unit->id = base::Int64ToString(base::Hash(WideToUTF8(monitor_info.szDevice)));
-  unit->name = WideToUTF8(device.DeviceString);
+  unit->id = base::Int64ToString(
+      base::Hash(base::WideToUTF8(monitor_info.szDevice)));
+  unit->name = base::WideToUTF8(device.DeviceString);
   unit->dpi_x = dpi.width();
   unit->dpi_y = dpi.height();
   all_displays->push_back(unit);
diff --git a/chrome/browser/extensions/api/system_indicator/system_indicator_manager.cc b/chrome/browser/extensions/api/system_indicator/system_indicator_manager.cc
index fc6e8b0..1950805 100644
--- a/chrome/browser/extensions/api/system_indicator/system_indicator_manager.cc
+++ b/chrome/browser/extensions/api/system_indicator/system_indicator_manager.cc
@@ -112,7 +112,7 @@ ExtensionIndicatorIcon::ExtensionIndicatorIcon(const Extension* extension,
   // used as the tool tip.
   gfx::ImageSkia icon_image =
       icon_factory_.GetIcon(ExtensionAction::kDefaultTabId).AsImageSkia();
-  base::string16 tool_tip = UTF8ToUTF16(extension_->name());
+  base::string16 tool_tip = base::UTF8ToUTF16(extension_->name());
 
   icon_ = status_tray_->CreateStatusIcon(
       StatusTray::OTHER_ICON, icon_image, tool_tip);
diff --git a/chrome/browser/extensions/api/system_storage/storage_api_test_util.cc b/chrome/browser/extensions/api/system_storage/storage_api_test_util.cc
index 930efb3..3432768 100644
--- a/chrome/browser/extensions/api/system_storage/storage_api_test_util.cc
+++ b/chrome/browser/extensions/api/system_storage/storage_api_test_util.cc
@@ -17,7 +17,7 @@ StorageInfo BuildStorageInfoFromTestStorageUnitInfo(
     const TestStorageUnitInfo& unit) {
   return StorageInfo(
       unit.device_id,
-      UTF8ToUTF16(unit.name),
+      base::UTF8ToUTF16(unit.name),
       base::FilePath::StringType(), /* no location */
       base::string16(), /* no storage label */
       base::string16(), /* no storage vendor */
diff --git a/chrome/browser/extensions/api/system_storage/storage_info_provider.cc b/chrome/browser/extensions/api/system_storage/storage_info_provider.cc
index 5cdc469..e045e80 100644
--- a/chrome/browser/extensions/api/system_storage/storage_info_provider.cc
+++ b/chrome/browser/extensions/api/system_storage/storage_info_provider.cc
@@ -24,7 +24,7 @@ void BuildStorageUnitInfo(const StorageInfo& info,
                           StorageUnitInfo* unit) {
   unit->id = StorageMonitor::GetInstance()->GetTransientIdForDeviceId(
                  info.device_id());
-  unit->name = UTF16ToUTF8(info.name());
+  unit->name = base::UTF16ToUTF8(info.name());
   // TODO(hmin): Might need to take MTP device into consideration.
   unit->type = StorageInfo::IsRemovableDevice(info.device_id()) ?
       STORAGE_UNIT_TYPE_REMOVABLE : STORAGE_UNIT_TYPE_FIXED;
diff --git a/chrome/browser/extensions/api/system_storage/system_storage_eject_apitest.cc b/chrome/browser/extensions/api/system_storage/system_storage_eject_apitest.cc
index 1e8e7ac..b4adbe0 100644
--- a/chrome/browser/extensions/api/system_storage/system_storage_eject_apitest.cc
+++ b/chrome/browser/extensions/api/system_storage/system_storage_eject_apitest.cc
@@ -51,7 +51,7 @@ class SystemStorageEjectApiTest : public ExtensionApiTest {
                                const std::string& ok_message) {
     ExtensionTestMessageListener listener(ok_message, false);
     host->ExecuteJavascriptInWebFrame(base::string16(),
-                                      ASCIIToUTF16(js_command));
+                                      base::ASCIIToUTF16(js_command));
     EXPECT_TRUE(listener.WaitUntilSatisfied());
   }
 
diff --git a/chrome/browser/extensions/api/tabs/tabs_api.cc b/chrome/browser/extensions/api/tabs/tabs_api.cc
index 541ef9d..a6a9753 100644
--- a/chrome/browser/extensions/api/tabs/tabs_api.cc
+++ b/chrome/browser/extensions/api/tabs/tabs_api.cc
@@ -927,7 +927,7 @@ bool TabsQueryFunction::RunImpl() {
       }
 
       if (!title.empty() && !MatchPattern(web_contents->GetTitle(),
-                                          UTF8ToUTF16(title)))
+                                          base::UTF8ToUTF16(title)))
         continue;
 
       if (!url_pattern.MatchesURL(web_contents->GetURL()))
diff --git a/chrome/browser/extensions/api/web_navigation/web_navigation_apitest.cc b/chrome/browser/extensions/api/web_navigation/web_navigation_apitest.cc
index a2e53b1..191e2ef 100644
--- a/chrome/browser/extensions/api/web_navigation/web_navigation_apitest.cc
+++ b/chrome/browser/extensions/api/web_navigation/web_navigation_apitest.cc
@@ -203,7 +203,8 @@ class DelayLoadStartAndExecuteJavascript
     if (validated_url != delay_url_ || !rvh_)
       return;
 
-    rvh_->ExecuteJavascriptInWebFrame(base::string16(), UTF8ToUTF16(script_));
+    rvh_->ExecuteJavascriptInWebFrame(base::string16(),
+                                      base::UTF8ToUTF16(script_));
     script_was_executed_ = true;
   }
 
diff --git a/chrome/browser/extensions/api/web_request/web_request_api.cc b/chrome/browser/extensions/api/web_request/web_request_api.cc
index f3abdcb..e3f4f55 100644
--- a/chrome/browser/extensions/api/web_request/web_request_api.cc
+++ b/chrome/browser/extensions/api/web_request/web_request_api.cc
@@ -1183,7 +1183,7 @@ bool ExtensionWebRequestEventRouter::DispatchEvent(
       if (num_handlers_blocking == 0) {
         std::string delegate_info =
             l10n_util::GetStringFUTF8(IDS_LOAD_STATE_PARAMETER_EXTENSION,
-                                      UTF8ToUTF16((*it)->extension_name));
+                                      base::UTF8ToUTF16((*it)->extension_name));
         // LobAndReport allows extensions that block requests to be displayed in
         // the load status bar.
         request->LogAndReportBlockedBy(delegate_info.c_str());
@@ -1662,7 +1662,8 @@ scoped_ptr<base::DictionaryValue> SummarizeResponseDelta(
   }
   if (delta.auth_credentials) {
     details->SetString(activitylog::kAuthCredentialsKey,
-                       UTF16ToUTF8(delta.auth_credentials->username()) + ":*");
+                       base::UTF16ToUTF8(
+                           delta.auth_credentials->username()) + ":*");
   }
 
   if (!delta.response_cookie_modifications.empty()) {
@@ -1766,7 +1767,7 @@ void ExtensionWebRequestEventRouter::DecrementBlockCount(
         continue;
       std::string delegate_info =
           l10n_util::GetStringFUTF8(IDS_LOAD_STATE_PARAMETER_EXTENSION,
-                                    UTF8ToUTF16(it->extension_name));
+                                    base::UTF8ToUTF16(it->extension_name));
       blocked_request.request->LogAndReportBlockedBy(delegate_info.c_str());
       break;
     }
diff --git a/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc b/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc
index fde07f9..9ee55a7 100644
--- a/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc
+++ b/chrome/browser/extensions/api/web_request/web_request_api_unittest.cc
@@ -1295,8 +1295,8 @@ TEST(ExtensionWebRequestHelpersTest, TestCalculateOnHeadersReceivedDelta) {
 TEST(ExtensionWebRequestHelpersTest, TestCalculateOnAuthRequiredDelta) {
   const bool cancel = true;
 
-  base::string16 username = ASCIIToUTF16("foo");
-  base::string16 password = ASCIIToUTF16("bar");
+  base::string16 username = base::ASCIIToUTF16("foo");
+  base::string16 password = base::ASCIIToUTF16("bar");
   scoped_ptr<net::AuthCredentials> credentials(
       new net::AuthCredentials(username, password));
 
@@ -2068,9 +2068,9 @@ TEST(ExtensionWebRequestHelpersTest, TestMergeOnAuthRequiredResponses) {
   net::BoundNetLog net_log = capturing_net_log.bound();
   ExtensionWarningSet warning_set;
   EventResponseDeltas deltas;
-  base::string16 username = ASCIIToUTF16("foo");
-  base::string16 password = ASCIIToUTF16("bar");
-  base::string16 password2 = ASCIIToUTF16("baz");
+  base::string16 username = base::ASCIIToUTF16("foo");
+  base::string16 password = base::ASCIIToUTF16("bar");
+  base::string16 password2 = base::ASCIIToUTF16("baz");
 
   // Check that we can handle if not returning credentials.
   linked_ptr<EventResponseDelta> d0(
diff --git a/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_browsertest.cc b/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_browsertest.cc
index 563efca..abb18c1 100644
--- a/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_browsertest.cc
+++ b/chrome/browser/extensions/api/webrtc_audio_private/webrtc_audio_private_browsertest.cc
@@ -372,10 +372,10 @@ IN_PROC_BROWSER_TEST_F(HangoutServicesBrowserTest,
 
   ASSERT_TRUE(content::ExecuteScript(tab, "browsertestRunAllTests();"));
 
-  content::TitleWatcher title_watcher(tab, ASCIIToUTF16("success"));
-  title_watcher.AlsoWaitForTitle(ASCIIToUTF16("failure"));
+  content::TitleWatcher title_watcher(tab, base::ASCIIToUTF16("success"));
+  title_watcher.AlsoWaitForTitle(base::ASCIIToUTF16("failure"));
   base::string16 result = title_watcher.WaitAndGetTitle();
-  EXPECT_EQ(ASCIIToUTF16("success"), result);
+  EXPECT_EQ(base::ASCIIToUTF16("success"), result);
 }
 #endif  // defined(GOOGLE_CHROME_BUILD)
 
diff --git a/chrome/browser/extensions/api/webstore_private/webstore_private_apitest.cc b/chrome/browser/extensions/api/webstore_private/webstore_private_apitest.cc
index 925d235..d2b4757e 100644
--- a/chrome/browser/extensions/api/webstore_private/webstore_private_apitest.cc
+++ b/chrome/browser/extensions/api/webstore_private/webstore_private_apitest.cc
@@ -151,8 +151,8 @@ IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest,
                        DISABLED_FrameWebstorePageBlocked) {
   content::WebContents* contents =
       browser()->tab_strip_model()->GetActiveWebContents();
-  base::string16 expected_title = UTF8ToUTF16("PASS: about:blank");
-  base::string16 failure_title = UTF8ToUTF16("FAIL");
+  base::string16 expected_title = base::UTF8ToUTF16("PASS: about:blank");
+  base::string16 failure_title = base::UTF8ToUTF16("FAIL");
   content::TitleWatcher watcher(contents, expected_title);
   watcher.AlsoWaitForTitle(failure_title);
   GURL url = test_server()->GetURL(
@@ -168,8 +168,8 @@ IN_PROC_BROWSER_TEST_F(ExtensionWebstorePrivateApiTest,
                        DISABLED_FrameErrorPageBlocked) {
   content::WebContents* contents =
       browser()->tab_strip_model()->GetActiveWebContents();
-  base::string16 expected_title = UTF8ToUTF16("PASS: about:blank");
-  base::string16 failure_title = UTF8ToUTF16("FAIL");
+  base::string16 expected_title = base::UTF8ToUTF16("PASS: about:blank");
+  base::string16 failure_title = base::UTF8ToUTF16("FAIL");
   content::TitleWatcher watcher(contents, expected_title);
   watcher.AlsoWaitForTitle(failure_title);
   GURL url = test_server()->GetURL(
diff --git a/chrome/browser/extensions/app_background_page_apitest.cc b/chrome/browser/extensions/app_background_page_apitest.cc
index aa14346..90db425 100644
--- a/chrome/browser/extensions/app_background_page_apitest.cc
+++ b/chrome/browser/extensions/app_background_page_apitest.cc
@@ -28,6 +28,7 @@
 #include "base/mac/scoped_nsautorelease_pool.h"
 #endif
 
+using base::ASCIIToUTF16;
 using extensions::Extension;
 
 class AppBackgroundPageApiTest : public ExtensionApiTest {
diff --git a/chrome/browser/extensions/browser_action_apitest.cc b/chrome/browser/extensions/browser_action_apitest.cc
index c09a3d2..181f409 100644
--- a/chrome/browser/extensions/browser_action_apitest.cc
+++ b/chrome/browser/extensions/browser_action_apitest.cc
@@ -19,12 +19,13 @@ IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, TitleLocalizationBrowserAction) {
 
   ASSERT_EQ(size_before + 1, service->extensions()->size());
 
-  EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur: l10n browser action").c_str(),
+  EXPECT_STREQ(base::WideToUTF8(
+                   L"Hreggvi\u00F0ur: l10n browser action").c_str(),
                extension->description().c_str());
-  EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur is my name").c_str(),
+  EXPECT_STREQ(base::WideToUTF8(L"Hreggvi\u00F0ur is my name").c_str(),
                extension->name().c_str());
   int tab_id = ExtensionTabUtil::GetTabId(
       browser()->tab_strip_model()->GetActiveWebContents());
-  EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur").c_str(),
+  EXPECT_STREQ(base::WideToUTF8(L"Hreggvi\u00F0ur").c_str(),
                extension->browser_action()->GetTitle(tab_id).c_str());
 }
diff --git a/chrome/browser/extensions/bundle_installer.cc b/chrome/browser/extensions/bundle_installer.cc
index 3b29cd5..88cf239 100644
--- a/chrome/browser/extensions/bundle_installer.cc
+++ b/chrome/browser/extensions/bundle_installer.cc
@@ -97,7 +97,7 @@ void BundleInstaller::SetAutoApproveForTesting(bool auto_approve) {
 BundleInstaller::Item::Item() : state(STATE_PENDING) {}
 
 base::string16 BundleInstaller::Item::GetNameForDisplay() {
-  base::string16 name = UTF8ToUTF16(localized_name);
+  base::string16 name = base::UTF8ToUTF16(localized_name);
   base::i18n::AdjustStringForLocaleDirection(&name);
   return l10n_util::GetStringFUTF16(IDS_EXTENSION_PERMISSION_LINE, name);
 }
diff --git a/chrome/browser/extensions/context_menu_matcher.cc b/chrome/browser/extensions/context_menu_matcher.cc
index 6f03d6a..28f3449 100644
--- a/chrome/browser/extensions/context_menu_matcher.cc
+++ b/chrome/browser/extensions/context_menu_matcher.cc
@@ -65,7 +65,7 @@ void ContextMenuMatcher::AppendExtensionItems(
     MenuItem::List submenu_items;
 
     if (items.size() > 1 || items[0]->type() != MenuItem::NORMAL) {
-      title = UTF8ToUTF16(extension->name());
+      title = base::UTF8ToUTF16(extension->name());
       submenu_items = items;
     } else {
       MenuItem* item = items[0];
@@ -109,7 +109,7 @@ base::string16 ContextMenuMatcher::GetTopLevelContextMenuTitle(
   if (items.empty() ||
       items.size() > 1 ||
       items[0]->type() != MenuItem::NORMAL) {
-    title = UTF8ToUTF16(extension->name());
+    title = base::UTF8ToUTF16(extension->name());
   } else {
     MenuItem* item = items[0];
     title = item->TitleWithReplacement(
diff --git a/chrome/browser/extensions/convert_user_script.cc b/chrome/browser/extensions/convert_user_script.cc
index 0aa8910..933bcc5 100644
--- a/chrome/browser/extensions/convert_user_script.cc
+++ b/chrome/browser/extensions/convert_user_script.cc
@@ -35,32 +35,33 @@ scoped_refptr<Extension> ConvertUserScriptToExtension(
     const base::FilePath& extensions_dir, base::string16* error) {
   std::string content;
   if (!base::ReadFileToString(user_script_path, &content)) {
-    *error = ASCIIToUTF16("Could not read source file.");
+    *error = base::ASCIIToUTF16("Could not read source file.");
     return NULL;
   }
 
   if (!IsStringUTF8(content)) {
-    *error = ASCIIToUTF16("User script must be UTF8 encoded.");
+    *error = base::ASCIIToUTF16("User script must be UTF8 encoded.");
     return NULL;
   }
 
   UserScript script;
   if (!UserScriptMaster::ScriptReloader::ParseMetadataHeader(content,
                                                              &script)) {
-    *error = ASCIIToUTF16("Invalid script header.");
+    *error = base::ASCIIToUTF16("Invalid script header.");
     return NULL;
   }
 
   base::FilePath install_temp_dir =
       extension_file_util::GetInstallTempDir(extensions_dir);
   if (install_temp_dir.empty()) {
-    *error = ASCIIToUTF16("Could not get path to profile temporary directory.");
+    *error = base::ASCIIToUTF16(
+        "Could not get path to profile temporary directory.");
     return NULL;
   }
 
   base::ScopedTempDir temp_dir;
   if (!temp_dir.CreateUniqueTempDirUnderPath(install_temp_dir)) {
-    *error = ASCIIToUTF16("Could not create temporary directory.");
+    *error = base::ASCIIToUTF16("Could not create temporary directory.");
     return NULL;
   }
 
@@ -159,14 +160,14 @@ scoped_refptr<Extension> ConvertUserScriptToExtension(
   base::FilePath manifest_path = temp_dir.path().Append(kManifestFilename);
   JSONFileValueSerializer serializer(manifest_path);
   if (!serializer.Serialize(*root)) {
-    *error = ASCIIToUTF16("Could not write JSON.");
+    *error = base::ASCIIToUTF16("Could not write JSON.");
     return NULL;
   }
 
   // Write the script file.
   if (!base::CopyFile(user_script_path,
                       temp_dir.path().AppendASCII("script.js"))) {
-    *error = ASCIIToUTF16("Could not copy script file.");
+    *error = base::ASCIIToUTF16("Could not copy script file.");
     return NULL;
   }
 
@@ -179,7 +180,7 @@ scoped_refptr<Extension> ConvertUserScriptToExtension(
       *root,
       Extension::NO_FLAGS,
       &utf8_error);
-  *error = UTF8ToUTF16(utf8_error);
+  *error = base::UTF8ToUTF16(utf8_error);
   if (!extension.get()) {
     NOTREACHED() << "Could not init extension " << *error;
     return NULL;
diff --git a/chrome/browser/extensions/convert_user_script_unittest.cc b/chrome/browser/extensions/convert_user_script_unittest.cc
index 9b45d2b..e5da419 100644
--- a/chrome/browser/extensions/convert_user_script_unittest.cc
+++ b/chrome/browser/extensions/convert_user_script_unittest.cc
@@ -149,7 +149,7 @@ TEST_F(ExtensionFromUserScript, NotUTF8) {
       extensions_dir.path(), &error));
 
   ASSERT_FALSE(extension.get());
-  EXPECT_EQ(ASCIIToUTF16("User script must be UTF8 encoded."), error);
+  EXPECT_EQ(base::ASCIIToUTF16("User script must be UTF8 encoded."), error);
 }
 
 TEST_F(ExtensionFromUserScript, RunAtDocumentStart) {
diff --git a/chrome/browser/extensions/convert_web_app.cc b/chrome/browser/extensions/convert_web_app.cc
index 54fe5dd..a324976 100644
--- a/chrome/browser/extensions/convert_web_app.cc
+++ b/chrome/browser/extensions/convert_web_app.cc
@@ -111,9 +111,9 @@ scoped_refptr<Extension> ConvertWebAppToExtension(
   if (web_app.is_offline_enabled)
     root->SetBoolean(keys::kOfflineEnabled, true);
 
-  root->SetString(keys::kName, UTF16ToUTF8(web_app.title));
+  root->SetString(keys::kName, base::UTF16ToUTF8(web_app.title));
   root->SetString(keys::kVersion, ConvertTimeToExtensionVersion(create_time));
-  root->SetString(keys::kDescription, UTF16ToUTF8(web_app.description));
+  root->SetString(keys::kDescription, base::UTF16ToUTF8(web_app.description));
   root->SetString(keys::kLaunchWebURL, web_app.app_url.spec());
 
   if (!web_app.launch_container.empty())
diff --git a/chrome/browser/extensions/convert_web_app_unittest.cc b/chrome/browser/extensions/convert_web_app_unittest.cc
index f2e550d..fcf8f9f 100644
--- a/chrome/browser/extensions/convert_web_app_unittest.cc
+++ b/chrome/browser/extensions/convert_web_app_unittest.cc
@@ -99,8 +99,9 @@ TEST(ExtensionFromWebApp, Basic) {
 
   WebApplicationInfo web_app;
   web_app.manifest_url = GURL("http://aaronboodman.com/gearpad/manifest.json");
-  web_app.title = ASCIIToUTF16("Gearpad");
-  web_app.description = ASCIIToUTF16("The best text editor in the universe!");
+  web_app.title = base::ASCIIToUTF16("Gearpad");
+  web_app.description =
+      base::ASCIIToUTF16("The best text editor in the universe!");
   web_app.app_url = GURL("http://aaronboodman.com/gearpad/");
   web_app.permissions.push_back("geolocation");
   web_app.permissions.push_back("notifications");
@@ -129,8 +130,8 @@ TEST(ExtensionFromWebApp, Basic) {
             extension->public_key());
   EXPECT_EQ("ncnbaadanljoanockmphfdkimpdedemj", extension->id());
   EXPECT_EQ("1978.12.11.0", extension->version()->GetString());
-  EXPECT_EQ(UTF16ToUTF8(web_app.title), extension->name());
-  EXPECT_EQ(UTF16ToUTF8(web_app.description), extension->description());
+  EXPECT_EQ(base::UTF16ToUTF8(web_app.title), extension->name());
+  EXPECT_EQ(base::UTF16ToUTF8(web_app.description), extension->description());
   EXPECT_EQ(web_app.app_url, AppLaunchInfo::GetFullLaunchURL(extension.get()));
   EXPECT_EQ(2u, extension->GetActivePermissions()->apis().size());
   EXPECT_TRUE(extension->HasAPIPermission("geolocation"));
@@ -160,7 +161,7 @@ TEST(ExtensionFromWebApp, Minimal) {
 
   WebApplicationInfo web_app;
   web_app.manifest_url = GURL("http://aaronboodman.com/gearpad/manifest.json");
-  web_app.title = ASCIIToUTF16("Gearpad");
+  web_app.title = base::ASCIIToUTF16("Gearpad");
   web_app.app_url = GURL("http://aaronboodman.com/gearpad/");
 
   scoped_refptr<Extension> extension = ConvertWebAppToExtension(
@@ -179,7 +180,7 @@ TEST(ExtensionFromWebApp, Minimal) {
             extension->public_key());
   EXPECT_EQ("ncnbaadanljoanockmphfdkimpdedemj", extension->id());
   EXPECT_EQ("1978.12.11.0", extension->version()->GetString());
-  EXPECT_EQ(UTF16ToUTF8(web_app.title), extension->name());
+  EXPECT_EQ(base::UTF16ToUTF8(web_app.title), extension->name());
   EXPECT_EQ("", extension->description());
   EXPECT_EQ(web_app.app_url, AppLaunchInfo::GetFullLaunchURL(extension.get()));
   EXPECT_EQ(0u, IconsInfo::GetIcons(extension.get()).map().size());
diff --git a/chrome/browser/extensions/crx_installer.cc b/chrome/browser/extensions/crx_installer.cc
index 5516970..b4189a6 100644
--- a/chrome/browser/extensions/crx_installer.cc
+++ b/chrome/browser/extensions/crx_installer.cc
@@ -255,8 +255,8 @@ CrxInstallerError CrxInstaller::AllowInstall(const Extension* extension) {
       expected_id_ != extension->id()) {
     return CrxInstallerError(
         l10n_util::GetStringFUTF16(IDS_EXTENSION_INSTALL_UNEXPECTED_ID,
-                                   ASCIIToUTF16(expected_id_),
-                                   ASCIIToUTF16(extension->id())));
+                                   base::ASCIIToUTF16(expected_id_),
+                                   base::ASCIIToUTF16(extension->id())));
   }
 
   if (expected_version_.get()) {
@@ -265,16 +265,16 @@ CrxInstallerError CrxInstaller::AllowInstall(const Extension* extension) {
         return CrxInstallerError(
             l10n_util::GetStringFUTF16(
               IDS_EXTENSION_INSTALL_UNEXPECTED_VERSION,
-              ASCIIToUTF16(expected_version_->GetString()),
-              ASCIIToUTF16(extension->version()->GetString())));
+              base::ASCIIToUTF16(expected_version_->GetString()),
+              base::ASCIIToUTF16(extension->version()->GetString())));
       }
     } else {
       if (extension->version()->CompareTo(*expected_version_) < 0) {
         return CrxInstallerError(
             l10n_util::GetStringFUTF16(
               IDS_EXTENSION_INSTALL_UNEXPECTED_VERSION,
-              ASCIIToUTF16(expected_version_->GetString() + "+"),
-              ASCIIToUTF16(extension->version()->GetString())));
+              base::ASCIIToUTF16(expected_version_->GetString() + "+"),
+              base::ASCIIToUTF16(extension->version()->GetString())));
       }
     }
   }
@@ -377,7 +377,7 @@ CrxInstallerError CrxInstaller::AllowInstall(const Extension* extension) {
       return CrxInstallerError(
           l10n_util::GetStringFUTF16(
               IDS_EXTENSION_INSTALL_INCORRECT_APP_CONTENT_TYPE,
-              ASCIIToUTF16(Extension::kMimeType)));
+              base::ASCIIToUTF16(Extension::kMimeType)));
     }
 
     // If the client_ is NULL, then the app is either being installed via
@@ -490,7 +490,7 @@ void CrxInstaller::CheckImportsAndRequirements() {
         ReportFailureFromUIThread(
             CrxInstallerError(l10n_util::GetStringFUTF16(
                 IDS_EXTENSION_INSTALL_DEPENDENCY_NOT_SHARED_MODULE,
-                ASCIIToUTF16(i->extension_id))));
+                base::ASCIIToUTF16(i->extension_id))));
         return;
       }
     }
@@ -508,7 +508,7 @@ void CrxInstaller::OnRequirementsChecked(
   if (!requirement_errors.empty()) {
     if (error_on_unsupported_requirements_) {
       ReportFailureFromUIThread(CrxInstallerError(
-          UTF8ToUTF16(JoinString(requirement_errors, ' '))));
+          base::UTF8ToUTF16(JoinString(requirement_errors, ' '))));
       return;
     }
     has_requirement_errors_ = true;
@@ -534,7 +534,7 @@ void CrxInstaller::OnBlacklistChecked(
     // refuse to install it.
     ReportFailureFromUIThread(extensions::CrxInstallerError(
         l10n_util::GetStringFUTF16(IDS_EXTENSION_IS_BLACKLISTED,
-                                   UTF8ToUTF16(extension()->name()))));
+                                   base::UTF8ToUTF16(extension()->name()))));
     UMA_HISTOGRAM_ENUMERATION("ExtensionBlacklist.BlockCRX",
                               extension()->location(),
                               Manifest::NUM_LOCATIONS);
@@ -591,7 +591,7 @@ void CrxInstaller::ConfirmInstall() {
         CrxInstallerError(
             l10n_util::GetStringFUTF16(
                 IDS_EXTENSION_OVERLAPPING_WEB_EXTENT,
-                UTF8ToUTF16(overlapping_extension->name()))));
+                base::UTF8ToUTF16(overlapping_extension->name()))));
     return;
   }
 
@@ -710,7 +710,7 @@ void CrxInstaller::CompleteInstall() {
     ReportSuccessFromFileThread();
   } else {
     LOG(ERROR) << error << " " << extension_id << " " << download_url_;
-    ReportFailureFromFileThread(CrxInstallerError(UTF8ToUTF16(error)));
+    ReportFailureFromFileThread(CrxInstallerError(base::UTF8ToUTF16(error)));
   }
 
 }
diff --git a/chrome/browser/extensions/error_console/error_console_browsertest.cc b/chrome/browser/extensions/error_console/error_console_browsertest.cc
index 27c549b..fbdef80 100644
--- a/chrome/browser/extensions/error_console/error_console_browsertest.cc
+++ b/chrome/browser/extensions/error_console/error_console_browsertest.cc
@@ -47,8 +47,8 @@ const StackTrace& GetStackTraceFromError(const ExtensionError* error) {
 void CheckStackFrame(const StackFrame& frame,
                      const std::string& source,
                      const std::string& function) {
-  EXPECT_EQ(UTF8ToUTF16(source), frame.source);
-  EXPECT_EQ(UTF8ToUTF16(function), frame.function);
+  EXPECT_EQ(base::UTF8ToUTF16(source), frame.source);
+  EXPECT_EQ(base::UTF8ToUTF16(function), frame.function);
 }
 
 // Verify that all properties of a given |frame| are correct. Overloaded because
@@ -74,9 +74,9 @@ void CheckError(const ExtensionError* error,
   ASSERT_TRUE(error);
   EXPECT_EQ(type, error->type());
   EXPECT_EQ(id, error->extension_id());
-  EXPECT_EQ(UTF8ToUTF16(source), error->source());
+  EXPECT_EQ(base::UTF8ToUTF16(source), error->source());
   EXPECT_EQ(from_incognito, error->from_incognito());
-  EXPECT_EQ(UTF8ToUTF16(message), error->message());
+  EXPECT_EQ(base::UTF8ToUTF16(message), error->message());
 }
 
 // Verify that all properties of a JS runtime error are correct.
@@ -116,8 +116,8 @@ void CheckManifestError(const ExtensionError* error,
 
   const ManifestError* manifest_error =
       static_cast<const ManifestError*>(error);
-  EXPECT_EQ(UTF8ToUTF16(manifest_key), manifest_error->manifest_key());
-  EXPECT_EQ(UTF8ToUTF16(manifest_specific),
+  EXPECT_EQ(base::UTF8ToUTF16(manifest_key), manifest_error->manifest_key());
+  EXPECT_EQ(base::UTF8ToUTF16(manifest_specific),
             manifest_error->manifest_specific());
 }
 
@@ -295,7 +295,7 @@ IN_PROC_BROWSER_TEST_F(ErrorConsoleBrowserTest, ReportManifestErrors) {
   const char kFakeKey[] = "not_a_real_key";
   for (size_t i = 0; i < errors.size(); ++i) {
     ASSERT_EQ(ExtensionError::MANIFEST_ERROR, errors[i]->type());
-    std::string utf8_key = UTF16ToUTF8(
+    std::string utf8_key = base::UTF16ToUTF8(
         (static_cast<const ManifestError*>(errors[i]))->manifest_key());
     if (utf8_key == manifest_keys::kPermissions)
       permissions_error = errors[i];
diff --git a/chrome/browser/extensions/extension_context_menu_browsertest.cc b/chrome/browser/extensions/extension_context_menu_browsertest.cc
index 77bd71f..2585602 100644
--- a/chrome/browser/extensions/extension_context_menu_browsertest.cc
+++ b/chrome/browser/extensions/extension_context_menu_browsertest.cc
@@ -205,8 +205,8 @@ class ExtensionContextMenuBrowserTest : public ExtensionBrowserTest {
   }
 
  bool MenuHasExtensionItemWithLabel(TestRenderViewContextMenu* menu,
-                                     const std::string& label) {
-    base::string16 label16 = UTF8ToUTF16(label);
+                                    const std::string& label) {
+    base::string16 label16 = base::UTF8ToUTF16(label);
     std::map<int, MenuItem::Id>::iterator i;
     for (i = menu->extension_items().extension_item_map_.begin();
          i != menu->extension_items().extension_item_map_.end(); ++i) {
@@ -391,16 +391,16 @@ IN_PROC_BROWSER_TEST_F(ExtensionContextMenuBrowserTest, MAYBE_TopLevel) {
 
   ASSERT_TRUE(menu->GetMenuModelAndItemIndex(
       IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST, &model, &index));
-  EXPECT_EQ(UTF8ToUTF16("An Extension with multiple Context Menus"),
-                        model->GetLabelAt(index++));
-  EXPECT_EQ(UTF8ToUTF16("Context Menu #1 - Extension #2"),
-                        model->GetLabelAt(index++));
-  EXPECT_EQ(UTF8ToUTF16("Context Menu #2 - Extension #3"),
-                        model->GetLabelAt(index++));
-  EXPECT_EQ(UTF8ToUTF16("Context Menu #3 - Extension #1"),
-                        model->GetLabelAt(index++));
-  EXPECT_EQ(UTF8ToUTF16("Ze Extension with multiple Context Menus"),
-                        model->GetLabelAt(index++));
+  EXPECT_EQ(base::UTF8ToUTF16("An Extension with multiple Context Menus"),
+                              model->GetLabelAt(index++));
+  EXPECT_EQ(base::UTF8ToUTF16("Context Menu #1 - Extension #2"),
+                              model->GetLabelAt(index++));
+  EXPECT_EQ(base::UTF8ToUTF16("Context Menu #2 - Extension #3"),
+                              model->GetLabelAt(index++));
+  EXPECT_EQ(base::UTF8ToUTF16("Context Menu #3 - Extension #1"),
+                              model->GetLabelAt(index++));
+  EXPECT_EQ(base::UTF8ToUTF16("Ze Extension with multiple Context Menus"),
+                              model->GetLabelAt(index++));
 }
 
 // Checks that in |menu|, the item at |index| has type |expected_type| and a
@@ -410,7 +410,7 @@ static void ExpectLabelAndType(const char* expected_label,
                                const MenuModel& menu,
                                int index) {
   EXPECT_EQ(expected_type, menu.GetTypeAt(index));
-  EXPECT_EQ(UTF8ToUTF16(expected_label), menu.GetLabelAt(index));
+  EXPECT_EQ(base::UTF8ToUTF16(expected_label), menu.GetLabelAt(index));
 }
 
 // In the separators test we build a submenu with items and separators in two
@@ -476,7 +476,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionContextMenuBrowserTest, Separators) {
   base::string16 label;
   ASSERT_TRUE(menu->GetMenuModelAndItemIndex(
       IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST, &model, &index));
-  EXPECT_EQ(UTF8ToUTF16(extension->name()), model->GetLabelAt(index));
+  EXPECT_EQ(base::UTF8ToUTF16(extension->name()), model->GetLabelAt(index));
   ASSERT_EQ(MenuModel::TYPE_SUBMENU, model->GetTypeAt(index));
 
   // Get the submenu and verify the items there.
@@ -493,7 +493,7 @@ IN_PROC_BROWSER_TEST_F(ExtensionContextMenuBrowserTest, Separators) {
   menu.reset(CreateMenu(browser(), url, GURL(), GURL()));
   ASSERT_TRUE(menu->GetMenuModelAndItemIndex(
       IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST, &model, &index));
-  EXPECT_EQ(UTF8ToUTF16("parent"), model->GetLabelAt(index));
+  EXPECT_EQ(base::UTF8ToUTF16("parent"), model->GetLabelAt(index));
   submenu = model->GetSubmenuModelAt(index);
   ASSERT_TRUE(submenu != NULL);
   VerifyMenuForSeparatorsTest(*submenu);
diff --git a/chrome/browser/extensions/extension_context_menu_model.cc b/chrome/browser/extensions/extension_context_menu_model.cc
index 0a578b9..c2addc1 100644
--- a/chrome/browser/extensions/extension_context_menu_model.cc
+++ b/chrome/browser/extensions/extension_context_menu_model.cc
@@ -170,7 +170,7 @@ void ExtensionContextMenuModel::InitMenu(const Extension* extension) {
   // Ampersands need to be escaped to avoid being treated like
   // mnemonics in the menu.
   base::ReplaceChars(extension_name, "&", "&&", &extension_name);
-  AddItem(NAME, UTF8ToUTF16(extension_name));
+  AddItem(NAME, base::UTF8ToUTF16(extension_name));
   AddSeparator(ui::NORMAL_SEPARATOR);
   AddItemWithStringId(CONFIGURE, IDS_EXTENSIONS_OPTIONS_MENU_ITEM);
   AddItem(UNINSTALL, l10n_util::GetStringUTF16(IDS_EXTENSIONS_UNINSTALL));
diff --git a/chrome/browser/extensions/extension_disabled_ui.cc b/chrome/browser/extensions/extension_disabled_ui.cc
index 32b540321..b4fb4fb 100644
--- a/chrome/browser/extensions/extension_disabled_ui.cc
+++ b/chrome/browser/extensions/extension_disabled_ui.cc
@@ -236,7 +236,7 @@ int ExtensionDisabledGlobalError::MenuItemCommandID() {
 
 base::string16 ExtensionDisabledGlobalError::MenuItemLabel() {
   return l10n_util::GetStringFUTF16(IDS_EXTENSION_DISABLED_ERROR_TITLE,
-                                    UTF8ToUTF16(extension_->name()));
+                                    base::UTF8ToUTF16(extension_->name()));
 }
 
 void ExtensionDisabledGlobalError::ExecuteMenuItem(Browser* browser) {
@@ -249,7 +249,7 @@ gfx::Image ExtensionDisabledGlobalError::GetBubbleViewIcon() {
 
 base::string16 ExtensionDisabledGlobalError::GetBubbleViewTitle() {
   return l10n_util::GetStringFUTF16(IDS_EXTENSION_DISABLED_ERROR_TITLE,
-                                    UTF8ToUTF16(extension_->name()));
+                                    base::UTF8ToUTF16(extension_->name()));
 }
 
 std::vector<base::string16>
@@ -258,7 +258,7 @@ ExtensionDisabledGlobalError::GetBubbleViewMessages() {
   messages.push_back(l10n_util::GetStringFUTF16(
       extension_->is_app() ?
       IDS_APP_DISABLED_ERROR_LABEL : IDS_EXTENSION_DISABLED_ERROR_LABEL,
-      UTF8ToUTF16(extension_->name())));
+      base::UTF8ToUTF16(extension_->name())));
   messages.push_back(l10n_util::GetStringUTF16(
       IDS_EXTENSION_PROMPT_WILL_NOW_HAVE_ACCESS_TO));
   std::vector<base::string16> permission_warnings =
diff --git a/chrome/browser/extensions/extension_error_reporter.cc b/chrome/browser/extensions/extension_error_reporter.cc
index dcbe45f..eb9b595 100644
--- a/chrome/browser/extensions/extension_error_reporter.cc
+++ b/chrome/browser/extensions/extension_error_reporter.cc
@@ -56,7 +56,7 @@ void ExtensionErrorReporter::ReportError(const base::string16& message,
   LOG(WARNING) << "Extension error: " << message;
 
   if (enable_noisy_errors_ && be_noisy) {
-    chrome::ShowMessageBox(NULL, ASCIIToUTF16("Extension error"), message,
+    chrome::ShowMessageBox(NULL, base::ASCIIToUTF16("Extension error"), message,
                            chrome::MESSAGE_BOX_TYPE_WARNING);
   }
 }
diff --git a/chrome/browser/extensions/extension_error_ui.cc b/chrome/browser/extensions/extension_error_ui.cc
index d908812..9dca279 100644
--- a/chrome/browser/extensions/extension_error_ui.cc
+++ b/chrome/browser/extensions/extension_error_ui.cc
@@ -48,7 +48,7 @@ base::string16 ExtensionErrorUI::GenerateMessageSection(
         extension_service_->GetInstalledExtension(*iter);
     message += l10n_util::GetStringFUTF16(
         e->is_app() ? app_template_message_id : extension_template_message_id,
-        UTF8ToUTF16(e->name())) + char16('\n');
+        base::UTF8ToUTF16(e->name())) + char16('\n');
   }
   return message;
 }
diff --git a/chrome/browser/extensions/extension_install_prompt.cc b/chrome/browser/extensions/extension_install_prompt.cc
index db6c471..c104f97 100644
--- a/chrome/browser/extensions/extension_install_prompt.cc
+++ b/chrome/browser/extensions/extension_install_prompt.cc
@@ -246,7 +246,7 @@ void ExtensionInstallPrompt::Prompt::SetOAuthIssueAdvice(
 void ExtensionInstallPrompt::Prompt::SetUserNameFromProfile(Profile* profile) {
   // |profile| can be NULL in unit tests.
   if (profile) {
-    oauth_user_name_ = UTF8ToUTF16(profile->GetPrefs()->GetString(
+    oauth_user_name_ = base::UTF8ToUTF16(profile->GetPrefs()->GetString(
         prefs::kGoogleServicesUsername));
   } else {
     oauth_user_name_.clear();
@@ -277,7 +277,7 @@ base::string16 ExtensionInstallPrompt::Prompt::GetDialogTitle() const {
       resource_id = IDS_EXTENSION_INSTALL_EXTENSION_PROMPT_TITLE;
   } else if (type_ == EXTERNAL_INSTALL_PROMPT) {
     return l10n_util::GetStringFUTF16(
-        resource_id, UTF8ToUTF16(extension_->name()));
+        resource_id, base::UTF8ToUTF16(extension_->name()));
   }
 
   return l10n_util::GetStringUTF16(resource_id);
@@ -285,7 +285,7 @@ base::string16 ExtensionInstallPrompt::Prompt::GetDialogTitle() const {
 
 base::string16 ExtensionInstallPrompt::Prompt::GetHeading() const {
   if (type_ == INLINE_INSTALL_PROMPT) {
-    return UTF8ToUTF16(extension_->name());
+    return base::UTF8ToUTF16(extension_->name());
   } else if (type_ == BUNDLE_INSTALL_PROMPT) {
     return bundle_->GetHeadingTextFor(BundleInstaller::Item::STATE_PENDING);
   } else if (type_ == EXTERNAL_INSTALL_PROMPT) {
@@ -299,7 +299,7 @@ base::string16 ExtensionInstallPrompt::Prompt::GetHeading() const {
     return l10n_util::GetStringUTF16(resource_id);
   } else {
     return l10n_util::GetStringFUTF16(
-        kHeadingIds[type_], UTF8ToUTF16(extension_->name()));
+        kHeadingIds[type_], base::UTF8ToUTF16(extension_->name()));
   }
 }
 
diff --git a/chrome/browser/extensions/extension_message_bubble_controller.cc b/chrome/browser/extensions/extension_message_bubble_controller.cc
index 1cf7e4f..895dc78 100644
--- a/chrome/browser/extensions/extension_message_bubble_controller.cc
+++ b/chrome/browser/extensions/extension_message_bubble_controller.cc
@@ -55,10 +55,10 @@ ExtensionMessageBubbleController::GetExtensionList() {
        it != list->end(); ++it) {
     const Extension* extension = service_->GetInstalledExtension(*it);
     if (extension) {
-      return_value.push_back(UTF8ToUTF16(extension->name()));
+      return_value.push_back(base::UTF8ToUTF16(extension->name()));
     } else {
       return_value.push_back(
-          ASCIIToUTF16(std::string("(unknown name) ") + *it));
+          base::ASCIIToUTF16(std::string("(unknown name) ") + *it));
       // TODO(finnur): Add this as a string to the grd, for next milestone.
     }
   }
diff --git a/chrome/browser/extensions/extension_message_bubble_controller_unittest.cc b/chrome/browser/extensions/extension_message_bubble_controller_unittest.cc
index 169b45a..dbefb7b 100644
--- a/chrome/browser/extensions/extension_message_bubble_controller_unittest.cc
+++ b/chrome/browser/extensions/extension_message_bubble_controller_unittest.cc
@@ -277,7 +277,7 @@ TEST_F(ExtensionMessageBubbleTest, MAYBE_WipeoutControllerTest) {
   EXPECT_TRUE(controller->ShouldShow());
   suspicious_extensions = controller->GetExtensionList();
   ASSERT_EQ(1U, suspicious_extensions.size());
-  EXPECT_TRUE(ASCIIToUTF16("Extension 1") == suspicious_extensions[0]);
+  EXPECT_TRUE(base::ASCIIToUTF16("Extension 1") == suspicious_extensions[0]);
   controller->Show(&bubble);  // Simulate showing the bubble.
   EXPECT_EQ(0U, controller->link_click_count());
   EXPECT_EQ(1U, controller->dismiss_click_count());
@@ -299,8 +299,8 @@ TEST_F(ExtensionMessageBubbleTest, MAYBE_WipeoutControllerTest) {
   EXPECT_TRUE(controller->ShouldShow());
   suspicious_extensions = controller->GetExtensionList();
   ASSERT_EQ(2U, suspicious_extensions.size());
-  EXPECT_TRUE(ASCIIToUTF16("Extension 1") == suspicious_extensions[1]);
-  EXPECT_TRUE(ASCIIToUTF16("Extension 2") == suspicious_extensions[0]);
+  EXPECT_TRUE(base::ASCIIToUTF16("Extension 1") == suspicious_extensions[1]);
+  EXPECT_TRUE(base::ASCIIToUTF16("Extension 2") == suspicious_extensions[0]);
   controller->Show(&bubble);  // Simulate showing the bubble.
   EXPECT_EQ(1U, controller->link_click_count());
   EXPECT_EQ(0U, controller->dismiss_click_count());
@@ -329,8 +329,8 @@ TEST_F(ExtensionMessageBubbleTest, MAYBE_DevModeControllerTest) {
   std::vector<base::string16> dev_mode_extensions =
       controller->GetExtensionList();
   ASSERT_EQ(2U, dev_mode_extensions.size());
-  EXPECT_TRUE(ASCIIToUTF16("Extension 2") == dev_mode_extensions[0]);
-  EXPECT_TRUE(ASCIIToUTF16("Extension 1") == dev_mode_extensions[1]);
+  EXPECT_TRUE(base::ASCIIToUTF16("Extension 2") == dev_mode_extensions[0]);
+  EXPECT_TRUE(base::ASCIIToUTF16("Extension 1") == dev_mode_extensions[1]);
   EXPECT_EQ(0U, controller->link_click_count());
   EXPECT_EQ(0U, controller->dismiss_click_count());
   EXPECT_EQ(0U, controller->action_click_count());
diff --git a/chrome/browser/extensions/extension_service.cc b/chrome/browser/extensions/extension_service.cc
index 7617254..ee9f6c3 100644
--- a/chrome/browser/extensions/extension_service.cc
+++ b/chrome/browser/extensions/extension_service.cc
@@ -2500,8 +2500,8 @@ void ExtensionService::ReportExtensionLoadError(
       content::Source<Profile>(profile_),
       content::Details<const std::string>(&error));
 
-  std::string path_str = UTF16ToUTF8(extension_path.LossyDisplayName());
-  base::string16 message = UTF8ToUTF16(base::StringPrintf(
+  std::string path_str = base::UTF16ToUTF8(extension_path.LossyDisplayName());
+  base::string16 message = base::UTF8ToUTF16(base::StringPrintf(
       "Could not load extension from '%s'. %s",
       path_str.c_str(), error.c_str()));
   ExtensionErrorReporter::GetInstance()->ReportError(message, be_noisy);
diff --git a/chrome/browser/extensions/extension_service_unittest.cc b/chrome/browser/extensions/extension_service_unittest.cc
index 2dbf5c7..bf5bed9 100644
--- a/chrome/browser/extensions/extension_service_unittest.cc
+++ b/chrome/browser/extensions/extension_service_unittest.cc
@@ -193,7 +193,7 @@ static std::vector<base::string16> GetErrors() {
 
   for (std::vector<base::string16>::const_iterator iter = errors->begin();
        iter != errors->end(); ++iter) {
-    std::string utf8_error = UTF16ToUTF8(*iter);
+    std::string utf8_error = base::UTF16ToUTF8(*iter);
     if (utf8_error.find(".svn") == std::string::npos) {
       ret_val.push_back(*iter);
     }
@@ -1436,25 +1436,25 @@ TEST_F(ExtensionServiceTest, LoadAllExtensionsFromDirectoryFail) {
   ASSERT_EQ(4u, GetErrors().size());
   ASSERT_EQ(0u, loaded_.size());
 
-  EXPECT_TRUE(MatchPattern(UTF16ToUTF8(GetErrors()[0]),
+  EXPECT_TRUE(MatchPattern(base::UTF16ToUTF8(GetErrors()[0]),
       std::string("Could not load extension from '*'. ") +
       extensions::manifest_errors::kManifestUnreadable)) <<
-      UTF16ToUTF8(GetErrors()[0]);
+      base::UTF16ToUTF8(GetErrors()[0]);
 
-  EXPECT_TRUE(MatchPattern(UTF16ToUTF8(GetErrors()[1]),
+  EXPECT_TRUE(MatchPattern(base::UTF16ToUTF8(GetErrors()[1]),
       std::string("Could not load extension from '*'. ") +
       extensions::manifest_errors::kManifestUnreadable)) <<
-      UTF16ToUTF8(GetErrors()[1]);
+      base::UTF16ToUTF8(GetErrors()[1]);
 
-  EXPECT_TRUE(MatchPattern(UTF16ToUTF8(GetErrors()[2]),
+  EXPECT_TRUE(MatchPattern(base::UTF16ToUTF8(GetErrors()[2]),
       std::string("Could not load extension from '*'. ") +
       extensions::manifest_errors::kMissingFile)) <<
-      UTF16ToUTF8(GetErrors()[2]);
+      base::UTF16ToUTF8(GetErrors()[2]);
 
-  EXPECT_TRUE(MatchPattern(UTF16ToUTF8(GetErrors()[3]),
+  EXPECT_TRUE(MatchPattern(base::UTF16ToUTF8(GetErrors()[3]),
       std::string("Could not load extension from '*'. ") +
       extensions::manifest_errors::kManifestUnreadable)) <<
-      UTF16ToUTF8(GetErrors()[3]);
+      base::UTF16ToUTF8(GetErrors()[3]);
 };
 
 // Test that partially deleted extensions are cleaned up during startup
@@ -4275,8 +4275,8 @@ TEST_F(ExtensionServiceTest, ClearExtensionData) {
   webkit_database::DatabaseTracker* db_tracker =
       BrowserContext::GetDefaultStoragePartition(profile_.get())->
           GetDatabaseTracker();
-  base::string16 db_name = UTF8ToUTF16("db");
-  base::string16 description = UTF8ToUTF16("db_description");
+  base::string16 db_name = base::UTF8ToUTF16("db");
+  base::string16 description = base::UTF8ToUTF16("db_description");
   int64 size;
   db_tracker->DatabaseOpened(origin_id, db_name, description, 1, &size);
   db_tracker->DatabaseClosed(origin_id, db_name);
@@ -4391,8 +4391,8 @@ TEST_F(ExtensionServiceTest, ClearAppData) {
   webkit_database::DatabaseTracker* db_tracker =
       BrowserContext::GetDefaultStoragePartition(profile_.get())->
           GetDatabaseTracker();
-  base::string16 db_name = UTF8ToUTF16("db");
-  base::string16 description = UTF8ToUTF16("db_description");
+  base::string16 db_name = base::UTF8ToUTF16("db");
+  base::string16 description = base::UTF8ToUTF16("db_description");
   int64 size;
   db_tracker->DatabaseOpened(origin_id, db_name, description, 1, &size);
   db_tracker->DatabaseClosed(origin_id, db_name);
@@ -4539,8 +4539,9 @@ TEST_F(ExtensionServiceTest, UnpackedValidatesLocales) {
   base::FilePath ms_messages_file = bad_locale.AppendASCII("_locales")
                                               .AppendASCII("ms")
                                               .AppendASCII("messages.json");
-  EXPECT_THAT(UTF16ToUTF8(GetErrors()[0]), testing::AllOf(
-       testing::HasSubstr(UTF16ToUTF8(ms_messages_file.LossyDisplayName())),
+  EXPECT_THAT(base::UTF16ToUTF8(GetErrors()[0]), testing::AllOf(
+       testing::HasSubstr(
+           base::UTF16ToUTF8(ms_messages_file.LossyDisplayName())),
        testing::HasSubstr("Dictionary keys must be quoted.")));
   ASSERT_EQ(0u, loaded_.size());
 }
diff --git a/chrome/browser/extensions/extension_url_rewrite_browsertest.cc b/chrome/browser/extensions/extension_url_rewrite_browsertest.cc
index 240dab5..6f36384 100644
--- a/chrome/browser/extensions/extension_url_rewrite_browsertest.cc
+++ b/chrome/browser/extensions/extension_url_rewrite_browsertest.cc
@@ -33,7 +33,7 @@ class ExtensionURLRewriteBrowserTest : public ExtensionBrowserTest {
 
  protected:
   std::string GetLocationBarText() const {
-    return UTF16ToUTF8(
+    return base::UTF16ToUTF8(
         browser()->window()->GetLocationBar()->GetOmniboxView()->GetText());
   }
 
diff --git a/chrome/browser/extensions/extension_warning_set.cc b/chrome/browser/extensions/extension_warning_set.cc
index 1c4df71..a58fe84 100644
--- a/chrome/browser/extensions/extension_warning_set.cc
+++ b/chrome/browser/extensions/extension_warning_set.cc
@@ -165,9 +165,10 @@ ExtensionWarning ExtensionWarning::CreateDownloadFilenameConflictWarning(
     const base::FilePath& losing_filename,
     const base::FilePath& winning_filename) {
   std::vector<std::string> message_parameters;
-  message_parameters.push_back(UTF16ToUTF8(losing_filename.LossyDisplayName()));
+  message_parameters.push_back(base::UTF16ToUTF8(
+      losing_filename.LossyDisplayName()));
   message_parameters.push_back(kTranslate + winning_extension_id);
-  message_parameters.push_back(UTF16ToUTF8(
+  message_parameters.push_back(base::UTF16ToUTF8(
       winning_filename.LossyDisplayName()));
   return ExtensionWarning(
       kDownloadFilenameConflict,
@@ -192,7 +193,7 @@ std::string ExtensionWarning::GetLocalizedMessage(
           extensions->GetByID(extension_id);
       message = extension ? extension->name() : extension_id;
     }
-    final_parameters.push_back(UTF8ToUTF16(net::EscapeForHTML(message)));
+    final_parameters.push_back(base::UTF8ToUTF16(net::EscapeForHTML(message)));
   }
 
   COMPILE_ASSERT(kMaxNumberOfParameters == 4u, YouNeedToAddMoreCaseStatements);
diff --git a/chrome/browser/extensions/external_install_ui.cc b/chrome/browser/extensions/external_install_ui.cc
index d723182..7d4936b 100644
--- a/chrome/browser/extensions/external_install_ui.cc
+++ b/chrome/browser/extensions/external_install_ui.cc
@@ -271,7 +271,7 @@ base::string16 ExternalInstallMenuAlert::MenuItemLabel() {
     id = IDS_EXTENSION_EXTERNAL_INSTALL_ALERT_THEME;
   else
     id = IDS_EXTENSION_EXTERNAL_INSTALL_ALERT_EXTENSION;
-  return l10n_util::GetStringFUTF16(id, UTF8ToUTF16(extension_->name()));
+  return l10n_util::GetStringFUTF16(id, base::UTF8ToUTF16(extension_->name()));
 }
 
 void ExternalInstallMenuAlert::ExecuteMenuItem(Browser* browser) {
diff --git a/chrome/browser/extensions/external_pref_loader.cc b/chrome/browser/extensions/external_pref_loader.cc
index 81b68e6..27461af 100644
--- a/chrome/browser/extensions/external_pref_loader.cc
+++ b/chrome/browser/extensions/external_pref_loader.cc
@@ -41,7 +41,7 @@ std::set<base::FilePath> GetPrefsCandidateFilesFromFolder(
       false,  // Recursive.
       base::FileEnumerator::FILES);
 #if defined(OS_WIN)
-  base::FilePath::StringType extension = UTF8ToWide(std::string(".json"));
+  base::FilePath::StringType extension = base::UTF8ToWide(std::string(".json"));
 #elif defined(OS_POSIX)
   base::FilePath::StringType extension(".json");
 #endif
diff --git a/chrome/browser/extensions/external_registry_loader_win.cc b/chrome/browser/extensions/external_registry_loader_win.cc
index c6ee0ad..95eab90 100644
--- a/chrome/browser/extensions/external_registry_loader_win.cc
+++ b/chrome/browser/extensions/external_registry_loader_win.cc
@@ -59,11 +59,11 @@ void ExternalRegistryLoader::LoadOnFileThread() {
   // A map of IDs, to weed out duplicates between HKCU and HKLM.
   std::set<base::string16> keys;
   base::win::RegistryKeyIterator iterator_machine_key(
-      HKEY_LOCAL_MACHINE, ASCIIToWide(kRegistryExtensions).c_str());
+      HKEY_LOCAL_MACHINE, base::ASCIIToWide(kRegistryExtensions).c_str());
   for (; iterator_machine_key.Valid(); ++iterator_machine_key)
     keys.insert(iterator_machine_key.Name());
   base::win::RegistryKeyIterator iterator_user_key(
-      HKEY_CURRENT_USER, ASCIIToWide(kRegistryExtensions).c_str());
+      HKEY_CURRENT_USER, base::ASCIIToWide(kRegistryExtensions).c_str());
   for (; iterator_user_key.Valid(); ++iterator_user_key)
     keys.insert(iterator_user_key.Name());
 
@@ -73,7 +73,7 @@ void ExternalRegistryLoader::LoadOnFileThread() {
   for (std::set<base::string16>::const_iterator it = keys.begin();
        it != keys.end(); ++it) {
     base::win::RegKey key;
-    base::string16 key_path = ASCIIToWide(kRegistryExtensions);
+    base::string16 key_path = base::ASCIIToWide(kRegistryExtensions);
     key_path.append(L"\\");
     key_path.append(*it);
     if (key.Open(HKEY_LOCAL_MACHINE,
diff --git a/chrome/browser/extensions/lazy_background_page_apitest.cc b/chrome/browser/extensions/lazy_background_page_apitest.cc
index 4020ed7..10943cc 100644
--- a/chrome/browser/extensions/lazy_background_page_apitest.cc
+++ b/chrome/browser/extensions/lazy_background_page_apitest.cc
@@ -395,7 +395,7 @@ IN_PROC_BROWSER_TEST_F(LazyBackgroundPageApiTest, MAYBE_IncognitoSplitMode) {
     test::WaitForBookmarkModelToLoad(bookmark_model);
     const BookmarkNode* parent = bookmark_model->bookmark_bar_node();
     bookmark_model->AddURL(
-        parent, 0, ASCIIToUTF16("Title"), GURL("about:blank"));
+        parent, 0, base::ASCIIToUTF16("Title"), GURL("about:blank"));
     page_complete.Wait();
     page2_complete.Wait();
 
@@ -511,8 +511,9 @@ IN_PROC_BROWSER_TEST_F(LazyBackgroundPageApiTest, EventDispatchToTab) {
   BookmarkModel* bookmark_model =
       BookmarkModelFactory::GetForProfile(browser()->profile());
   test::WaitForBookmarkModelToLoad(bookmark_model);
-  bookmark_utils::AddIfNotBookmarked(
-      bookmark_model, GURL("http://www.google.com"), UTF8ToUTF16("Google"));
+  bookmark_utils::AddIfNotBookmarked(bookmark_model,
+                                     GURL("http://www.google.com"),
+                                     base::UTF8ToUTF16("Google"));
 
   EXPECT_TRUE(event_page_ready.WaitUntilSatisfied());
 
diff --git a/chrome/browser/extensions/menu_manager.cc b/chrome/browser/extensions/menu_manager.cc
index 7223cad..ee997994 100644
--- a/chrome/browser/extensions/menu_manager.cc
+++ b/chrome/browser/extensions/menu_manager.cc
@@ -169,10 +169,10 @@ std::set<MenuItem::Id> MenuItem::RemoveAllDescendants() {
 
 base::string16 MenuItem::TitleWithReplacement(const base::string16& selection,
                                               size_t max_length) const {
-  base::string16 result = UTF8ToUTF16(title_);
+  base::string16 result = base::UTF8ToUTF16(title_);
   // TODO(asargent) - Change this to properly handle %% escaping so you can
   // put "%s" in titles that won't get substituted.
-  ReplaceSubstringsAfterOffset(&result, 0, ASCIIToUTF16("%s"), selection);
+  ReplaceSubstringsAfterOffset(&result, 0, base::ASCIIToUTF16("%s"), selection);
 
   if (result.length() > max_length)
     result = gfx::TruncateString(result, max_length);
diff --git a/chrome/browser/extensions/menu_manager_unittest.cc b/chrome/browser/extensions/menu_manager_unittest.cc
index 70dafe9..9d24755 100644
--- a/chrome/browser/extensions/menu_manager_unittest.cc
+++ b/chrome/browser/extensions/menu_manager_unittest.cc
@@ -562,7 +562,7 @@ TEST_F(MenuManagerTest, ExecuteCommand) {
   params.media_type = blink::WebContextMenuData::MediaTypeImage;
   params.src_url = GURL("http://foo.bar/image.png");
   params.page_url = GURL("http://foo.bar");
-  params.selection_text = ASCIIToUTF16("Hello World");
+  params.selection_text = base::ASCIIToUTF16("Hello World");
   params.is_editable = false;
 
   Extension* extension = AddExtension("test");
diff --git a/chrome/browser/extensions/page_action_browsertest.cc b/chrome/browser/extensions/page_action_browsertest.cc
index 39b58bc..6da021a 100644
--- a/chrome/browser/extensions/page_action_browsertest.cc
+++ b/chrome/browser/extensions/page_action_browsertest.cc
@@ -190,13 +190,13 @@ IN_PROC_BROWSER_TEST_F(ExtensionBrowserTest, TitleLocalizationPageAction) {
 
   ASSERT_EQ(size_before + 1, service->extensions()->size());
 
-  EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur: l10n page action").c_str(),
+  EXPECT_STREQ(base::WideToUTF8(L"Hreggvi\u00F0ur: l10n page action").c_str(),
                extension->description().c_str());
-  EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur is my name").c_str(),
+  EXPECT_STREQ(base::WideToUTF8(L"Hreggvi\u00F0ur is my name").c_str(),
                extension->name().c_str());
   int tab_id = ExtensionTabUtil::GetTabId(
       browser()->tab_strip_model()->GetActiveWebContents());
-  EXPECT_STREQ(WideToUTF8(L"Hreggvi\u00F0ur").c_str(),
+  EXPECT_STREQ(base::WideToUTF8(L"Hreggvi\u00F0ur").c_str(),
                ExtensionActionManager::Get(browser()->profile())->
                GetPageAction(*extension)->
                GetTitle(tab_id).c_str());
diff --git a/chrome/browser/extensions/plugin_manager.cc b/chrome/browser/extensions/plugin_manager.cc
index 98a67b6..bc2e3ec 100644
--- a/chrome/browser/extensions/plugin_manager.cc
+++ b/chrome/browser/extensions/plugin_manager.cc
@@ -167,9 +167,10 @@ void PluginManager::UpdatePluginListWithNaClModules() {
         // manifest file.
         content::WebPluginMimeType mime_type_info;
         mime_type_info.mime_type = iter->mime_type;
-        mime_type_info.additional_param_names.push_back(UTF8ToUTF16("nacl"));
+        mime_type_info.additional_param_names.push_back(
+            base::UTF8ToUTF16("nacl"));
         mime_type_info.additional_param_values.push_back(
-            UTF8ToUTF16(iter->url.spec()));
+            base::UTF8ToUTF16(iter->url.spec()));
         info.mime_types.push_back(mime_type_info);
       }
 
diff --git a/chrome/browser/extensions/sandboxed_unpacker.cc b/chrome/browser/extensions/sandboxed_unpacker.cc
index eb264fd..6647a8a 100644
--- a/chrome/browser/extensions/sandboxed_unpacker.cc
+++ b/chrome/browser/extensions/sandboxed_unpacker.cc
@@ -41,6 +41,7 @@
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/codec/png_codec.h"
 
+using base::ASCIIToUTF16;
 using content::BrowserThread;
 using content::UtilityProcessHost;
 
@@ -380,7 +381,7 @@ void SandboxedUnpacker::OnUnpackExtensionSucceeded(
         COULD_NOT_LOCALIZE_EXTENSION,
         l10n_util::GetStringFUTF16(
             IDS_EXTENSION_PACKAGE_ERROR_MESSAGE,
-            UTF8ToUTF16(utf8_error)));
+            base::UTF8ToUTF16(utf8_error)));
     return;
   }
 
diff --git a/chrome/browser/extensions/startup_helper.cc b/chrome/browser/extensions/startup_helper.cc
index 9e87260..3719251 100644
--- a/chrome/browser/extensions/startup_helper.cc
+++ b/chrome/browser/extensions/startup_helper.cc
@@ -45,7 +45,7 @@ void StartupHelper::OnPackSuccess(
     const base::FilePath& output_private_key_path) {
   pack_job_succeeded_ = true;
   PrintPackExtensionMessage(
-      UTF16ToUTF8(
+      base::UTF16ToUTF8(
           PackExtensionJob::StandardSuccessMessage(crx_path,
                                                    output_private_key_path)));
 }
@@ -191,7 +191,7 @@ bool StartupHelper::ValidateCrx(const CommandLine& cmd_line,
 
   bool success = helper->success();
   if (!success)
-    *error = UTF16ToUTF8(helper->error());
+    *error = base::UTF16ToUTF8(helper->error());
   return success;
 }
 
diff --git a/chrome/browser/extensions/suspicious_extension_bubble_controller.cc b/chrome/browser/extensions/suspicious_extension_bubble_controller.cc
index 560e4a4..736acd9 100644
--- a/chrome/browser/extensions/suspicious_extension_bubble_controller.cc
+++ b/chrome/browser/extensions/suspicious_extension_bubble_controller.cc
@@ -99,8 +99,8 @@ base::string16 SuspiciousExtensionBubbleController::GetOverflowText(
   // Just before string freeze, we checked in # as a substitution value for
   // this string, whereas we should have used $1. It was discovered too late,
   // so we do the substitution by hand in that case.
-  if (overflow_string.find(ASCIIToUTF16("#")) != base::string16::npos) {
-    base::ReplaceChars(overflow_string, ASCIIToUTF16("#").c_str(),
+  if (overflow_string.find(base::ASCIIToUTF16("#")) != base::string16::npos) {
+    base::ReplaceChars(overflow_string, base::ASCIIToUTF16("#").c_str(),
                        overflow_count, &new_string);
   } else {
     new_string = l10n_util::GetStringFUTF16(
diff --git a/chrome/browser/extensions/tab_helper.cc b/chrome/browser/extensions/tab_helper.cc
index d26c213..ba26a96 100644
--- a/chrome/browser/extensions/tab_helper.cc
+++ b/chrome/browser/extensions/tab_helper.cc
@@ -319,7 +319,7 @@ void TabHelper::FinishCreateHostedApp(
   if (install_info.title.empty())
     install_info.title = web_contents()->GetTitle();
   if (install_info.title.empty())
-    install_info.title = UTF8ToUTF16(install_info.app_url.spec());
+    install_info.title = base::UTF8ToUTF16(install_info.app_url.spec());
 
   install_info.urls.push_back(install_info.app_url);
   install_info.is_bookmark_app = true;
diff --git a/chrome/browser/extensions/theme_installed_infobar_delegate.cc b/chrome/browser/extensions/theme_installed_infobar_delegate.cc
index 2f020ec..986250e 100644
--- a/chrome/browser/extensions/theme_installed_infobar_delegate.cc
+++ b/chrome/browser/extensions/theme_installed_infobar_delegate.cc
@@ -117,7 +117,7 @@ ThemeInstalledInfoBarDelegate*
 
 base::string16 ThemeInstalledInfoBarDelegate::GetMessageText() const {
   return l10n_util::GetStringFUTF16(IDS_THEME_INSTALL_INFOBAR_LABEL,
-                                    UTF8ToUTF16(name_));
+                                    base::UTF8ToUTF16(name_));
 }
 
 int ThemeInstalledInfoBarDelegate::GetButtons() const {
diff --git a/chrome/browser/extensions/unpacked_installer.cc b/chrome/browser/extensions/unpacked_installer.cc
index f73f0a3..b23e018 100644
--- a/chrome/browser/extensions/unpacked_installer.cc
+++ b/chrome/browser/extensions/unpacked_installer.cc
@@ -286,7 +286,7 @@ void UnpackedInstaller::ConfirmInstall() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::string16 error = installer_.CheckManagementPolicy();
   if (!error.empty()) {
-    ReportExtensionLoadError(UTF16ToUTF8(error));
+    ReportExtensionLoadError(base::UTF16ToUTF8(error));
     return;
   }
 
diff --git a/chrome/browser/extensions/webstore_installer.cc b/chrome/browser/extensions/webstore_installer.cc
index 50cd3fc1..5325bcf 100644
--- a/chrome/browser/extensions/webstore_installer.cc
+++ b/chrome/browser/extensions/webstore_installer.cc
@@ -385,7 +385,7 @@ void WebstoreInstaller::Observe(int type,
       // replacing with base::string16. See crbug.com/71980.
       const base::string16* error =
           content::Details<const base::string16>(details).ptr();
-      const std::string utf8_error = UTF16ToUTF8(*error);
+      const std::string utf8_error = base::UTF16ToUTF8(*error);
       if (download_url_ == crx_installer->original_download_url())
         ReportFailure(utf8_error, FAILURE_REASON_OTHER);
       break;
diff --git a/chrome/browser/extensions/webstore_installer_test.cc b/chrome/browser/extensions/webstore_installer_test.cc
index 26d3549..d43b362 100644
--- a/chrome/browser/extensions/webstore_installer_test.cc
+++ b/chrome/browser/extensions/webstore_installer_test.cc
@@ -122,6 +122,6 @@ void WebstoreInstallerTest::RunTestAsync(
       "%s('%s')", test_function_name.c_str(), test_gallery_url_.c_str());
   browser()->tab_strip_model()->GetActiveWebContents()->GetRenderViewHost()->
       ExecuteJavascriptInWebFrame(
-          UTF8ToUTF16(std::string()),
-          UTF8ToUTF16(script));
+          base::UTF8ToUTF16(std::string()),
+          base::UTF8ToUTF16(script));
 }
diff --git a/chrome/browser/external_extension_browsertest.cc b/chrome/browser/external_extension_browsertest.cc
index 37a28e6..0445c78 100644
--- a/chrome/browser/external_extension_browsertest.cc
+++ b/chrome/browser/external_extension_browsertest.cc
@@ -70,11 +70,11 @@ class SearchProviderTest : public InProcessBrowserTest {
       const IsSearchProviderTestData& data) {
     base::string16 title = data.tab->GetTitle();
     if (title.empty()) {
-      content::TitleWatcher title_watcher(data.tab, ASCIIToUTF16("OK"));
-      title_watcher.AlsoWaitForTitle(ASCIIToUTF16("FAIL"));
+      content::TitleWatcher title_watcher(data.tab, base::ASCIIToUTF16("OK"));
+      title_watcher.AlsoWaitForTitle(base::ASCIIToUTF16("FAIL"));
       title = title_watcher.WaitAndGetTitle();
     }
-    EXPECT_EQ(ASCIIToUTF16("OK"), title);
+    EXPECT_EQ(base::ASCIIToUTF16("OK"), title);
   }
 
   GURL search_provider_test_url_;
diff --git a/chrome/browser/first_run/first_run.cc b/chrome/browser/first_run/first_run.cc
index 5201512..232752c 100644
--- a/chrome/browser/first_run/first_run.cc
+++ b/chrome/browser/first_run/first_run.cc
@@ -262,7 +262,7 @@ void ImportFromFile(Profile* profile,
 
   const base::FilePath::StringType& import_bookmarks_path_str =
 #if defined(OS_WIN)
-      UTF8ToUTF16(import_bookmarks_path);
+      base::UTF8ToUTF16(import_bookmarks_path);
 #else
       import_bookmarks_path;
 #endif
diff --git a/chrome/browser/geolocation/access_token_store_browsertest.cc b/chrome/browser/geolocation/access_token_store_browsertest.cc
index c10e536..38223ae 100644
--- a/chrome/browser/geolocation/access_token_store_browsertest.cc
+++ b/chrome/browser/geolocation/access_token_store_browsertest.cc
@@ -104,8 +104,9 @@ void GeolocationAccessTokenStoreTest::OnAccessTokenStoresLoaded(
 }
 
 IN_PROC_BROWSER_TEST_F(GeolocationAccessTokenStoreTest, SetAcrossInstances) {
-  const base::string16 ref_token1 = ASCIIToUTF16("jksdfo90,'s#\"#1*(");
-  const base::string16 ref_token2 = ASCIIToUTF16("\1\2\3\4\5\6\7\10\11\12=023");
+  const base::string16 ref_token1 = base::ASCIIToUTF16("jksdfo90,'s#\"#1*(");
+  const base::string16 ref_token2 =
+      base::ASCIIToUTF16("\1\2\3\4\5\6\7\10\11\12=023");
   ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DoTestStepAndWaitForResults(kRefServerUrl1, NULL, &ref_token1);
@@ -122,7 +123,7 @@ IN_PROC_BROWSER_TEST_F(GeolocationAccessTokenStoreTest, SetAcrossInstances) {
 }
 
 IN_PROC_BROWSER_TEST_F(GeolocationAccessTokenStoreTest, OldUrlRemoval) {
-  const base::string16 ref_token1 = ASCIIToUTF16("jksdfo90,'s#\"#1*(");
+  const base::string16 ref_token1 = base::ASCIIToUTF16("jksdfo90,'s#\"#1*(");
   ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Set a token for the old default network provider url.
diff --git a/chrome/browser/geolocation/geolocation_browsertest.cc b/chrome/browser/geolocation/geolocation_browsertest.cc
index 1a6ff11..dd8e659 100644
--- a/chrome/browser/geolocation/geolocation_browsertest.cc
+++ b/chrome/browser/geolocation/geolocation_browsertest.cc
@@ -90,7 +90,7 @@ IFrameLoader::IFrameLoader(Browser* browser, int iframe_id, const GURL& url)
       "window.domAutomationController.send(addIFrame(%d, \"%s\"));",
       iframe_id, url.spec().c_str()));
   web_contents->GetRenderViewHost()->ExecuteJavascriptInWebFrame(
-      base::string16(), UTF8ToUTF16(script));
+      base::string16(), base::UTF8ToUTF16(script));
   content::RunMessageLoop();
 
   EXPECT_EQ(base::StringPrintf("\"%d\"", iframe_id), javascript_response_);
@@ -212,8 +212,8 @@ void GeolocationNotificationObserver::AddWatchAndWaitForNotification(
   std::string script(
       "window.domAutomationController.setAutomationId(0);"
       "window.domAutomationController.send(geoStart());");
-  render_view_host->ExecuteJavascriptInWebFrame(UTF8ToUTF16(iframe_xpath),
-                                                UTF8ToUTF16(script));
+  render_view_host->ExecuteJavascriptInWebFrame(base::UTF8ToUTF16(iframe_xpath),
+                                                base::UTF8ToUTF16(script));
   content::RunMessageLoop();
   registrar_.RemoveAll();
   LOG(WARNING) << "got geolocation watch" << javascript_response_;
diff --git a/chrome/browser/geolocation/geolocation_infobar_delegate_android.cc b/chrome/browser/geolocation/geolocation_infobar_delegate_android.cc
index 755d20f..9dae643 100644
--- a/chrome/browser/geolocation/geolocation_infobar_delegate_android.cc
+++ b/chrome/browser/geolocation/geolocation_infobar_delegate_android.cc
@@ -70,6 +70,7 @@ bool GeolocationInfoBarDelegateAndroid::Accept() {
 base::string16 GeolocationInfoBarDelegateAndroid::GetButtonLabel(
     InfoBarButton button) const {
   return (button == BUTTON_OK) ?
-      UTF8ToUTF16(google_location_settings_helper_->GetAcceptButtonLabel()) :
+      base::UTF8ToUTF16(
+          google_location_settings_helper_->GetAcceptButtonLabel()) :
       l10n_util::GetStringUTF16(IDS_GEOLOCATION_DENY_BUTTON);
 }
diff --git a/chrome/browser/history/android/android_cache_database_unittest.cc b/chrome/browser/history/android/android_cache_database_unittest.cc
index e56e3e9..5e14aa7 100644
--- a/chrome/browser/history/android/android_cache_database_unittest.cc
+++ b/chrome/browser/history/android/android_cache_database_unittest.cc
@@ -73,7 +73,7 @@ TEST_F(AndroidCacheDatabaseTest, InitAndroidCacheDatabase) {
 TEST_F(AndroidCacheDatabaseTest, SearchTermsTable) {
   // Test AddSearchTerm.
   Time search_time1 = Time::Now() - TimeDelta::FromDays(1);
-  base::string16 search_term1(UTF8ToUTF16("search term 1"));
+  base::string16 search_term1(base::UTF8ToUTF16("search term 1"));
   SearchTermID id1 = history_db_.AddSearchTerm(search_term1, search_time1);
   ASSERT_TRUE(id1);
   SearchTermRow row1;
@@ -85,7 +85,7 @@ TEST_F(AndroidCacheDatabaseTest, SearchTermsTable) {
 
   // Test UpdateSearchTerm.
   SearchTermRow update_row1;
-  update_row1.term = (UTF8ToUTF16("update search term1"));
+  update_row1.term = (base::UTF8ToUTF16("update search term1"));
   update_row1.last_visit_time = Time::Now();
   ASSERT_TRUE(history_db_.UpdateSearchTerm(id1, update_row1));
   EXPECT_EQ(id1, history_db_.GetSearchTerm(update_row1.term, &row1));
@@ -95,7 +95,7 @@ TEST_F(AndroidCacheDatabaseTest, SearchTermsTable) {
   EXPECT_EQ(id1, row1.id);
 
   Time search_time2 = Time::Now() - TimeDelta::FromHours(1);
-  base::string16 search_term2(UTF8ToUTF16("search term 2"));
+  base::string16 search_term2(base::UTF8ToUTF16("search term 2"));
   SearchTermID id2 = history_db_.AddSearchTerm(search_term2, search_time2);
   ASSERT_TRUE(id2);
   ASSERT_TRUE(history_db_.SetKeywordSearchTermsForURL(1, 1, search_term2));
diff --git a/chrome/browser/history/android/android_history_provider_service_unittest.cc b/chrome/browser/history/android/android_history_provider_service_unittest.cc
index 0f48c23..b03b0bb 100644
--- a/chrome/browser/history/android/android_history_provider_service_unittest.cc
+++ b/chrome/browser/history/android/android_history_provider_service_unittest.cc
@@ -207,7 +207,7 @@ TEST_F(AndroidHistoryProviderServiceTest, TestHistoryAndBookmark) {
 
 TEST_F(AndroidHistoryProviderServiceTest, TestSearchTerm) {
   SearchRow search_row;
-  search_row.set_search_term(UTF8ToUTF16("google"));
+  search_row.set_search_term(base::UTF8ToUTF16("google"));
   search_row.set_url(GURL("http://google.com"));
   search_row.set_template_url_id(1);
   search_row.set_search_time(Time::Now());
diff --git a/chrome/browser/history/android/android_provider_backend_unittest.cc b/chrome/browser/history/android/android_provider_backend_unittest.cc
index 25a022a..c851d3b 100644
--- a/chrome/browser/history/android/android_provider_backend_unittest.cc
+++ b/chrome/browser/history/android/android_provider_backend_unittest.cc
@@ -32,6 +32,7 @@
 
 using base::Time;
 using base::TimeDelta;
+using base::UTF8ToUTF16;
 using content::BrowserThread;
 
 namespace history {
diff --git a/chrome/browser/history/android/bookmark_model_sql_handler_unittest.cc b/chrome/browser/history/android/bookmark_model_sql_handler_unittest.cc
index df3deb2..cc221fd 100644
--- a/chrome/browser/history/android/bookmark_model_sql_handler_unittest.cc
+++ b/chrome/browser/history/android/bookmark_model_sql_handler_unittest.cc
@@ -80,7 +80,7 @@ TEST_F(BookmarkModelSQLHandlerTest, InsertIntoMobileFolder) {
   HistoryAndBookmarkRow row;
   row.set_raw_url("http://bookmark.com");
   row.set_url(GURL("http://bookmark.com"));
-  row.set_title(UTF8ToUTF16("Bookmark Title"));
+  row.set_title(base::UTF8ToUTF16("Bookmark Title"));
   row.set_is_bookmark(true);
 
   BookmarkModelSQLHandler handler(&history_db_);
@@ -99,7 +99,7 @@ TEST_F(BookmarkModelSQLHandlerTest, InsertIntoSpecificFolder) {
   HistoryAndBookmarkRow row;
   row.set_raw_url("http://bookmark.com");
   row.set_url(GURL("http://bookmark.com"));
-  row.set_title(UTF8ToUTF16("Bookmark Title"));
+  row.set_title(base::UTF8ToUTF16("Bookmark Title"));
   row.set_is_bookmark(true);
   // Set other folder as parent.
   row.set_parent_id(bookmark_model_->other_node()->id());
@@ -119,7 +119,7 @@ TEST_F(BookmarkModelSQLHandlerTest, InsertIntoSpecificFolder) {
 TEST_F(BookmarkModelSQLHandlerTest, UpdateHistoryToBookmark) {
   // Added a row in url database.
   URLRow url_row(GURL("http://www.google.com"));
-  url_row.set_title(UTF8ToUTF16("Google"));
+  url_row.set_title(base::UTF8ToUTF16("Google"));
   URLID url_id = history_db_.AddURL(url_row);
   ASSERT_TRUE(url_id);
 
@@ -182,7 +182,7 @@ TEST_F(BookmarkModelSQLHandlerTest, UpdateHistoryToBookmark) {
   EXPECT_EQ(row.parent_id(), parent1->id());
 
   // Only update the title.
-  url_row.set_title(UTF8ToUTF16("Google Inc."));
+  url_row.set_title(base::UTF8ToUTF16("Google Inc."));
   history_db_.UpdateURLRow(url_id, url_row);
   HistoryAndBookmarkRow update_title;
   update_title.set_title(url_row.title());
@@ -212,7 +212,7 @@ TEST_F(BookmarkModelSQLHandlerTest, Delete) {
   GURL url1 = GURL("http://bookmark.com");
   row.set_raw_url("http://bookmark.com");
   row.set_url(url1);
-  row.set_title(UTF8ToUTF16("Bookmark Title"));
+  row.set_title(base::UTF8ToUTF16("Bookmark Title"));
   row.set_is_bookmark(true);
 
   BookmarkModelSQLHandler handler(&history_db_);
diff --git a/chrome/browser/history/android/sqlite_cursor_unittest.cc b/chrome/browser/history/android/sqlite_cursor_unittest.cc
index 9279026..56e47a8 100644
--- a/chrome/browser/history/android/sqlite_cursor_unittest.cc
+++ b/chrome/browser/history/android/sqlite_cursor_unittest.cc
@@ -161,7 +161,7 @@ TEST_F(SQLiteCursorTest, Run) {
   row.set_favicon(data_bytes);
   row.set_last_visit_time(Time::Now());
   row.set_visit_count(2);
-  row.set_title(UTF8ToUTF16("cnn"));
+  row.set_title(base::UTF8ToUTF16("cnn"));
   scoped_refptr<CallbackHelper> callback(new CallbackHelper());
 
   // Insert a row and verify it succeeded.
diff --git a/chrome/browser/history/android/urls_sql_handler_unittest.cc b/chrome/browser/history/android/urls_sql_handler_unittest.cc
index f69f4f3..e3ccaf0 100644
--- a/chrome/browser/history/android/urls_sql_handler_unittest.cc
+++ b/chrome/browser/history/android/urls_sql_handler_unittest.cc
@@ -110,7 +110,7 @@ TEST_F(UrlsSQLHandlerTest, InsertURLWithCreatedTime) {
   HistoryAndBookmarkRow row;
   row.set_raw_url("http://google.com");
   row.set_url(GURL("http://google.com"));
-  row.set_title(UTF8ToUTF16("Google"));
+  row.set_title(base::UTF8ToUTF16("Google"));
   row.set_created(Time::Now());
 
   ASSERT_TRUE(urls_sql_handler_.Insert(&row));
@@ -150,7 +150,7 @@ TEST_F(UrlsSQLHandlerTest, Insert) {
   row.set_url(GURL("http://google.com"));
   row.set_visit_count(10);
   row.set_last_visit_time(Time::Now());
-  row.set_title(UTF8ToUTF16("Google"));
+  row.set_title(base::UTF8ToUTF16("Google"));
 
   ASSERT_TRUE(urls_sql_handler_.Insert(&row));
   URLRow url_row;
@@ -167,7 +167,7 @@ TEST_F(UrlsSQLHandlerTest, Update) {
   HistoryAndBookmarkRow row;
   row.set_raw_url("http://google.com");
   row.set_url(GURL("http://google.com"));
-  row.set_title(UTF8ToUTF16("Google"));
+  row.set_title(base::UTF8ToUTF16("Google"));
   row.set_visit_count(10);
   row.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
 
@@ -182,7 +182,7 @@ TEST_F(UrlsSQLHandlerTest, Update) {
   HistoryAndBookmarkRow update_row;
   update_row.set_last_visit_time(Time::Now());
   update_row.set_visit_count(1);
-  update_row.set_title(UTF8ToUTF16("Google Inc"));
+  update_row.set_title(base::UTF8ToUTF16("Google Inc"));
   TableIDRow id;
   id.url_id = url_row.id();
   TableIDRows ids;
@@ -200,7 +200,7 @@ TEST_F(UrlsSQLHandlerTest, UpdateLastBothTime) {
   HistoryAndBookmarkRow row;
   row.set_raw_url("http://google.com");
   row.set_url(GURL("http://google.com"));
-  row.set_title(UTF8ToUTF16("Google"));
+  row.set_title(base::UTF8ToUTF16("Google"));
   row.set_visit_count(10);
   row.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
 
diff --git a/chrome/browser/history/android/visit_sql_handler_unittest.cc b/chrome/browser/history/android/visit_sql_handler_unittest.cc
index 9556724..de37ec8 100644
--- a/chrome/browser/history/android/visit_sql_handler_unittest.cc
+++ b/chrome/browser/history/android/visit_sql_handler_unittest.cc
@@ -92,7 +92,7 @@ TEST_F(VisitSQLHandlerTest, InsertURLWithCreatedTime) {
   HistoryAndBookmarkRow row;
   row.set_raw_url("http://google.com");
   row.set_url(GURL("http://google.com"));
-  row.set_title(UTF8ToUTF16("Google"));
+  row.set_title(base::UTF8ToUTF16("Google"));
   row.set_created(Time::Now());
 
   ASSERT_TRUE(urls_sql_handler_.Insert(&row));
@@ -157,7 +157,7 @@ TEST_F(VisitSQLHandlerTest, UpdateVisitTimeAndVisitCount) {
   HistoryAndBookmarkRow row;
   row.set_raw_url("http://google.com");
   row.set_url(GURL("http://google.com"));
-  row.set_title(UTF8ToUTF16("Google"));
+  row.set_title(base::UTF8ToUTF16("Google"));
   row.set_visit_count(10);
   row.set_last_visit_time(Time::Now() - TimeDelta::FromDays(10));
 
diff --git a/chrome/browser/history/history_backend.cc b/chrome/browser/history/history_backend.cc
index c78b575..19b3d00 100644
--- a/chrome/browser/history/history_backend.cc
+++ b/chrome/browser/history/history_backend.cc
@@ -934,7 +934,7 @@ void HistoryBackend::AddPageNoVisitForBookmark(const GURL& url,
   if (!title.empty()) {
     url_info.set_title(title);
   } else {
-    url_info.set_title(UTF8ToUTF16(url.spec()));
+    url_info.set_title(base::UTF8ToUTF16(url.spec()));
   }
 
   url_info.set_last_visit(Time::Now());
diff --git a/chrome/browser/history/history_backend_unittest.cc b/chrome/browser/history/history_backend_unittest.cc
index 2253ea0..9a12517 100644
--- a/chrome/browser/history/history_backend_unittest.cc
+++ b/chrome/browser/history/history_backend_unittest.cc
@@ -600,7 +600,7 @@ TEST_F(HistoryBackendTest, DeleteAllThenAddData) {
   ASSERT_EQ(0U, all_visits.size());
 
   // Try and set the title.
-  backend_->SetPageTitle(url, UTF8ToUTF16("Title"));
+  backend_->SetPageTitle(url, base::UTF8ToUTF16("Title"));
 
   // The row should still be deleted.
   EXPECT_FALSE(backend_->db_->GetRowForURL(url, &outrow));
@@ -2612,7 +2612,7 @@ TEST_F(HistoryBackendTest, AddPageNoVisitForBookmark) {
   ASSERT_TRUE(backend_.get());
 
   GURL url("http://www.google.com");
-  base::string16 title(UTF8ToUTF16("Bookmark title"));
+  base::string16 title(base::UTF8ToUTF16("Bookmark title"));
   backend_->AddPageNoVisitForBookmark(url, title);
 
   URLRow row;
@@ -2625,7 +2625,7 @@ TEST_F(HistoryBackendTest, AddPageNoVisitForBookmark) {
   backend_->AddPageNoVisitForBookmark(url, base::string16());
   backend_->GetURL(url, &row);
   EXPECT_EQ(url, row.url());
-  EXPECT_EQ(UTF8ToUTF16(url.spec()), row.title());
+  EXPECT_EQ(base::UTF8ToUTF16(url.spec()), row.title());
   EXPECT_EQ(0, row.visit_count());
 }
 
@@ -2753,7 +2753,7 @@ TEST_F(HistoryBackendTest, DeleteMatchingUrlsForKeyword) {
   EXPECT_NE(0, url1_id);
 
   TemplateURLID keyword_id = 1;
-  base::string16 keyword = UTF8ToUTF16("bar");
+  base::string16 keyword = base::UTF8ToUTF16("bar");
   ASSERT_TRUE(backend_->db()->SetKeywordSearchTermsForURL(
       url1_id, keyword_id, keyword));
 
diff --git a/chrome/browser/history/history_browsertest.cc b/chrome/browser/history/history_browsertest.cc
index 5f2a050..7010dea 100644
--- a/chrome/browser/history/history_browsertest.cc
+++ b/chrome/browser/history/history_browsertest.cc
@@ -101,10 +101,10 @@ class HistoryBrowserTest : public InProcessBrowserTest {
   }
 
   void LoadAndWaitForURL(const GURL& url) {
-    base::string16 expected_title(ASCIIToUTF16("OK"));
+    base::string16 expected_title(base::ASCIIToUTF16("OK"));
     content::TitleWatcher title_watcher(
         browser()->tab_strip_model()->GetActiveWebContents(), expected_title);
-    title_watcher.AlsoWaitForTitle(ASCIIToUTF16("FAIL"));
+    title_watcher.AlsoWaitForTitle(base::ASCIIToUTF16("FAIL"));
     ui_test_utils::NavigateToURL(browser(), url);
     EXPECT_EQ(expected_title, title_watcher.WaitAndGetTitle());
   }
@@ -279,10 +279,10 @@ IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, MAYBE_HistorySearchXSS) {
   // Should a race condition ever trigger, it won't result in flakiness.
   int num = ui_test_utils::FindInPage(
       browser()->tab_strip_model()->GetActiveWebContents(),
-      ASCIIToUTF16("<img"), true,
+      base::ASCIIToUTF16("<img"), true,
       true, NULL, NULL);
   EXPECT_GT(num, 0);
-  EXPECT_EQ(ASCIIToUTF16("History"),
+  EXPECT_EQ(base::ASCIIToUTF16("History"),
             browser()->tab_strip_model()->GetActiveWebContents()->GetTitle());
 }
 
@@ -466,7 +466,7 @@ IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, SubmitFormAddsTargetPage) {
 
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
-  base::string16 expected_title(ASCIIToUTF16("Target Page"));
+  base::string16 expected_title(base::ASCIIToUTF16("Target Page"));
   content::TitleWatcher title_watcher(
       browser()->tab_strip_model()->GetActiveWebContents(), expected_title);
   ASSERT_TRUE(content::ExecuteScript(
@@ -488,7 +488,7 @@ IN_PROC_BROWSER_TEST_F(HistoryBrowserTest, OneHistoryTabPerWindow) {
   // 'Loading...' for a brief time while the history page loads.
   content::WebContents* web_contents =
       browser()->tab_strip_model()->GetActiveWebContents();
-  base::string16 expected_title(ASCIIToUTF16("History"));
+  base::string16 expected_title(base::ASCIIToUTF16("History"));
   content::TitleWatcher title_watcher(web_contents, expected_title);
   chrome::ExecuteCommand(browser(), IDC_SHOW_HISTORY);
   EXPECT_EQ(expected_title, title_watcher.WaitAndGetTitle());
diff --git a/chrome/browser/history/history_querying_unittest.cc b/chrome/browser/history/history_querying_unittest.cc
index c0ea369..41a4d55 100644
--- a/chrome/browser/history/history_querying_unittest.cc
+++ b/chrome/browser/history/history_querying_unittest.cc
@@ -63,7 +63,8 @@ bool NthResultIs(const QueryResults& results,
 
   // Now check the URL & title.
   return result.url() == GURL(test_entries[test_entry_index].url) &&
-         result.title() == UTF8ToUTF16(test_entries[test_entry_index].title);
+         result.title() ==
+             base::UTF8ToUTF16(test_entries[test_entry_index].title);
 }
 
 }  // namespace
@@ -78,7 +79,7 @@ class HistoryQueryTest : public testing::Test {
                     const QueryOptions& options,
                     QueryResults* results) {
     history_->QueryHistory(
-        UTF8ToUTF16(text_query), options, &consumer_,
+        base::UTF8ToUTF16(text_query), options, &consumer_,
         base::Bind(&HistoryQueryTest::QueryHistoryComplete,
                    base::Unretained(this)));
     // Will go until ...Complete calls Quit.
@@ -152,7 +153,7 @@ class HistoryQueryTest : public testing::Test {
     history_->AddPage(url, entry.time, id_scope, page_id_++, GURL(),
                       history::RedirectList(), content::PAGE_TRANSITION_LINK,
                       history::SOURCE_BROWSED, false);
-    history_->SetPageTitle(url, UTF8ToUTF16(entry.title));
+    history_->SetPageTitle(url, base::UTF8ToUTF16(entry.title));
   }
 
  private:
@@ -391,12 +392,12 @@ TEST_F(HistoryQueryTest, TextSearchArchived) {
   URLRows urls_to_add;
 
   URLRow row1(GURL("http://foo.bar/"));
-  row1.set_title(UTF8ToUTF16("archived title same"));
+  row1.set_title(base::UTF8ToUTF16("archived title same"));
   row1.set_last_visit(Time::Now() - TimeDelta::FromDays(365));
   urls_to_add.push_back(row1);
 
   URLRow row2(GURL("http://foo.bar/"));
-  row2.set_title(UTF8ToUTF16("nonarchived title same"));
+  row2.set_title(base::UTF8ToUTF16("nonarchived title same"));
   row2.set_last_visit(Time::Now());
   urls_to_add.push_back(row2);
 
diff --git a/chrome/browser/history/history_types_unittest.cc b/chrome/browser/history/history_types_unittest.cc
index bc3fa3b..af68f84 100644
--- a/chrome/browser/history/history_types_unittest.cc
+++ b/chrome/browser/history/history_types_unittest.cc
@@ -119,7 +119,7 @@ TEST(HistoryQueryResult, RowSignificance) {
   const base::Time& threshold(AutocompleteAgeThreshold());
   const GURL url("http://www.google.com/");
   URLRow url_row(url);
-  url_row.set_title(UTF8ToUTF16("Google"));
+  url_row.set_title(base::UTF8ToUTF16("Google"));
   EXPECT_FALSE(RowQualifiesAsSignificant(url_row, threshold));
   EXPECT_FALSE(RowQualifiesAsSignificant(url_row, base::Time()));
   url_row.set_visit_count(kLowQualityMatchVisitLimit);
diff --git a/chrome/browser/history/history_unittest.cc b/chrome/browser/history/history_unittest.cc
index d28fada..a3140eb 100644
--- a/chrome/browser/history/history_unittest.cc
+++ b/chrome/browser/history/history_unittest.cc
@@ -1274,7 +1274,7 @@ TEST_F(HistoryTest, SetTitle) {
       existing_url, base::Time::Now(), history::SOURCE_BROWSED);
 
   // Set some title.
-  const base::string16 existing_title = UTF8ToUTF16("Google");
+  const base::string16 existing_title = base::UTF8ToUTF16("Google");
   history_service_->SetPageTitle(existing_url, existing_title);
 
   // Make sure the title got set.
@@ -1283,7 +1283,7 @@ TEST_F(HistoryTest, SetTitle) {
 
   // set a title on a nonexistent page
   const GURL nonexistent_url("http://news.google.com/");
-  const base::string16 nonexistent_title = UTF8ToUTF16("Google News");
+  const base::string16 nonexistent_title = base::UTF8ToUTF16("Google News");
   history_service_->SetPageTitle(nonexistent_url, nonexistent_title);
 
   // Make sure nothing got written.
@@ -1826,7 +1826,7 @@ TEST_F(HistoryBackendDBTest, MigratePresentations) {
   const URLID url_id = 3;
   const GURL url("http://www.foo.com");
   const std::string url_name(VisitSegmentDatabase::ComputeSegmentName(url));
-  const base::string16 title(ASCIIToUTF16("Title1"));
+  const base::string16 title(base::ASCIIToUTF16("Title1"));
   const Time segment_time(Time::Now());
 
   {
diff --git a/chrome/browser/history/in_memory_database.cc b/chrome/browser/history/in_memory_database.cc
index 61e2570..5a7cfe6 100644
--- a/chrome/browser/history/in_memory_database.cc
+++ b/chrome/browser/history/in_memory_database.cc
@@ -72,7 +72,7 @@ bool InMemoryDatabase::InitFromDisk(const base::FilePath& history_name) {
 #if defined(OS_POSIX)
   attach.BindString(0, history_name.value());
 #else
-  attach.BindString(0, WideToUTF8(history_name.value()));
+  attach.BindString(0, base::WideToUTF8(history_name.value()));
 #endif
   if (!attach.Run())
     return false;
diff --git a/chrome/browser/history/in_memory_url_index_types_unittest.cc b/chrome/browser/history/in_memory_url_index_types_unittest.cc
index f31348b..82f995f 100644
--- a/chrome/browser/history/in_memory_url_index_types_unittest.cc
+++ b/chrome/browser/history/in_memory_url_index_types_unittest.cc
@@ -9,6 +9,8 @@
 #include "chrome/browser/history/in_memory_url_index_types.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using base::UTF8ToUTF16;
+
 namespace history {
 
 // Helper function for verifying that the contents of a C++ iterable container
@@ -30,7 +32,8 @@ class InMemoryURLIndexTypesTest : public testing::Test {
 
 TEST_F(InMemoryURLIndexTypesTest, StaticFunctions) {
   // Test String16VectorFromString16
-  base::string16 string_a(ASCIIToUTF16("http://www.google.com/ frammy  the brammy"));
+  base::string16 string_a(
+      base::UTF8ToUTF16("http://www.google.com/ frammy  the brammy"));
   WordStarts actual_starts_a;
   String16Vector string_vec =
       String16VectorFromString16(string_a, false, &actual_starts_a);
@@ -60,7 +63,7 @@ TEST_F(InMemoryURLIndexTypesTest, StaticFunctions) {
   EXPECT_TRUE(IntArraysEqual(expected_starts_b, arraysize(expected_starts_b),
                              actual_starts_b));
 
-  base::string16 string_c(ASCIIToUTF16(
+  base::string16 string_c(base::ASCIIToUTF16(
       " funky%20string-with=@strange   sequences, intended(to exceed)"));
   WordStarts actual_starts_c;
   string_vec = String16VectorFromString16(string_c, false, &actual_starts_c);
@@ -71,7 +74,7 @@ TEST_F(InMemoryURLIndexTypesTest, StaticFunctions) {
                              actual_starts_c));
 
   // Test String16SetFromString16
-  base::string16 string_d(ASCIIToUTF16(
+  base::string16 string_d(base::ASCIIToUTF16(
       "http://web.google.com/search Google Web Search"));
   WordStarts actual_starts_d;
   String16Set string_set = String16SetFromString16(string_d, &actual_starts_d);
diff --git a/chrome/browser/history/in_memory_url_index_unittest.cc b/chrome/browser/history/in_memory_url_index_unittest.cc
index 9be82cf3..830fb24 100644
--- a/chrome/browser/history/in_memory_url_index_unittest.cc
+++ b/chrome/browser/history/in_memory_url_index_unittest.cc
@@ -34,6 +34,7 @@
 #include "sql/transaction.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using base::ASCIIToUTF16;
 using content::BrowserThread;
 
 // The test version of the history url database table ('url') is contained in
diff --git a/chrome/browser/history/multipart_browsertest.cc b/chrome/browser/history/multipart_browsertest.cc
index 13bf191..4d0b565 100644
--- a/chrome/browser/history/multipart_browsertest.cc
+++ b/chrome/browser/history/multipart_browsertest.cc
@@ -39,7 +39,7 @@ IN_PROC_BROWSER_TEST_F(MultipartResponseTest, DISABLED_SingleVisit) {
   Observe(browser()->tab_strip_model()->GetActiveWebContents());
   ui_test_utils::NavigateToURL(browser(), test_server()->GetURL("multipart"));
 
-  EXPECT_EQ(ASCIIToUTF16("page 9"),
+  EXPECT_EQ(base::ASCIIToUTF16("page 9"),
             browser()->tab_strip_model()->GetActiveWebContents()->GetTitle());
   EXPECT_EQ(1, update_history_count_);
   EXPECT_GT(did_navigate_any_frame_count_, update_history_count_);
diff --git a/chrome/browser/history/query_parser_unittest.cc b/chrome/browser/history/query_parser_unittest.cc
index fe4a505..969708d 100644
--- a/chrome/browser/history/query_parser_unittest.cc
+++ b/chrome/browser/history/query_parser_unittest.cc
@@ -25,8 +25,8 @@ class QueryParserTest : public testing::Test {
 // convenience) to a SQLite query string.
 std::string QueryParserTest::QueryToString(const std::string& query) {
   base::string16 sqlite_query;
-  query_parser_.ParseQuery(UTF8ToUTF16(query), &sqlite_query);
-  return UTF16ToUTF8(sqlite_query);
+  query_parser_.ParseQuery(base::UTF8ToUTF16(query), &sqlite_query);
+  return base::UTF16ToUTF8(sqlite_query);
 }
 
 // Basic multi-word queries, including prefix matching.
@@ -39,12 +39,12 @@ TEST_F(QueryParserTest, SimpleQueries) {
   // the minimum is 2 while for other scripts, it's 3.
   EXPECT_EQ("f b", QueryToString(" f b"));
   // KA JANG
-  EXPECT_EQ(WideToUTF8(L"\xAC00 \xC7A5"),
-            QueryToString(WideToUTF8(L" \xAC00 \xC7A5")));
+  EXPECT_EQ(base::WideToUTF8(L"\xAC00 \xC7A5"),
+            QueryToString(base::WideToUTF8(L" \xAC00 \xC7A5")));
   EXPECT_EQ("foo* bar*", QueryToString(" foo   bar "));
   // KA-JANG BICH-GO
-  EXPECT_EQ(WideToUTF8(L"\xAC00\xC7A5* \xBE5B\xACE0*"),
-            QueryToString(WideToUTF8(L"\xAC00\xC7A5 \xBE5B\xACE0")));
+  EXPECT_EQ(base::WideToUTF8(L"\xAC00\xC7A5* \xBE5B\xACE0*"),
+            QueryToString(base::WideToUTF8(L"\xAC00\xC7A5 \xBE5B\xACE0")));
 }
 
 // Quoted substring parsing.
@@ -82,7 +82,7 @@ TEST_F(QueryParserTest, NumWords) {
   for (size_t i = 0; i < arraysize(data); ++i) {
     base::string16 query_string;
     EXPECT_EQ(data[i].expected_word_count,
-              query_parser_.ParseQuery(UTF8ToUTF16(data[i].input),
+              query_parser_.ParseQuery(base::UTF8ToUTF16(data[i].input),
                                        &query_string));
   }
 }
@@ -117,10 +117,11 @@ TEST_F(QueryParserTest, ParseQueryNodesAndMatch) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
     QueryParser parser;
     ScopedVector<QueryNode> query_nodes;
-    parser.ParseQueryNodes(UTF8ToUTF16(data[i].query), &query_nodes.get());
+    parser.ParseQueryNodes(base::UTF8ToUTF16(data[i].query),
+                           &query_nodes.get());
     Snippet::MatchPositions match_positions;
     ASSERT_EQ(data[i].matches,
-              parser.DoesQueryMatch(UTF8ToUTF16(data[i].text),
+              parser.DoesQueryMatch(base::UTF8ToUTF16(data[i].text),
                                     query_nodes.get(),
                                     &match_positions));
     size_t offset = 0;
@@ -154,12 +155,12 @@ TEST_F(QueryParserTest, ParseQueryWords) {
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(data); ++i) {
     std::vector<base::string16> results;
     QueryParser parser;
-    parser.ParseQueryWords(UTF8ToUTF16(data[i].text), &results);
+    parser.ParseQueryWords(base::UTF8ToUTF16(data[i].text), &results);
     ASSERT_EQ(data[i].word_count, results.size());
-    EXPECT_EQ(data[i].w1, UTF16ToUTF8(results[0]));
+    EXPECT_EQ(data[i].w1, base::UTF16ToUTF8(results[0]));
     if (results.size() == 2)
-      EXPECT_EQ(data[i].w2, UTF16ToUTF8(results[1]));
+      EXPECT_EQ(data[i].w2, base::UTF16ToUTF8(results[1]));
     if (results.size() == 3)
-      EXPECT_EQ(data[i].w3, UTF16ToUTF8(results[2]));
+      EXPECT_EQ(data[i].w3, base::UTF16ToUTF8(results[2]));
   }
 }
diff --git a/chrome/browser/history/redirect_browsertest.cc b/chrome/browser/history/redirect_browsertest.cc
index 885f999..0a85700 100644
--- a/chrome/browser/history/redirect_browsertest.cc
+++ b/chrome/browser/history/redirect_browsertest.cc
@@ -236,7 +236,7 @@ IN_PROC_BROWSER_TEST_F(RedirectTest, NoHttpToFile) {
   ui_test_utils::NavigateToURL(browser(), initial_url);
   // We make sure the title doesn't match the title from the file, because the
   // nav should not have taken place.
-  EXPECT_NE(ASCIIToUTF16("File!"),
+  EXPECT_NE(base::ASCIIToUTF16("File!"),
             browser()->tab_strip_model()->GetActiveWebContents()->GetTitle());
 }
 
@@ -291,7 +291,7 @@ IN_PROC_BROWSER_TEST_F(RedirectTest,
 
   // Check to make sure the navigation did in fact take place and we are
   // at the expected page.
-  EXPECT_EQ(ASCIIToUTF16("Title Of Awesomeness"),
+  EXPECT_EQ(base::ASCIIToUTF16("Title Of Awesomeness"),
             browser()->tab_strip_model()->GetActiveWebContents()->GetTitle());
 
   bool final_navigation_not_redirect = true;
diff --git a/chrome/browser/history/scored_history_match.cc b/chrome/browser/history/scored_history_match.cc
index 2c97565..c462df9 100644
--- a/chrome/browser/history/scored_history_match.cc
+++ b/chrome/browser/history/scored_history_match.cc
@@ -106,7 +106,7 @@ ScoredHistoryMatch::ScoredHistoryMatch(const URLRow& row,
   // typing "w" will inline "ashington..." instead of "ww.washington...".
   const URLPrefix* best_inlineable_prefix =
       (!url_matches_.empty() && (terms.size() == 1)) ?
-      URLPrefix::BestURLPrefix(UTF8ToUTF16(gurl.spec()), terms[0]) :
+      URLPrefix::BestURLPrefix(base::UTF8ToUTF16(gurl.spec()), terms[0]) :
       NULL;
   can_inline_ = (best_inlineable_prefix != NULL) &&
       !IsWhitespace(*(lower_string.rbegin()));
@@ -133,8 +133,8 @@ ScoredHistoryMatch::ScoredHistoryMatch(const URLRow& row,
     //
     // Now, the code that implements this.
     // The deepest prefix for this URL regardless of where the match is.
-    const URLPrefix* best_prefix =
-        URLPrefix::BestURLPrefix(UTF8ToUTF16(gurl.spec()), base::string16());
+    const URLPrefix* best_prefix = URLPrefix::BestURLPrefix(
+        base::UTF8ToUTF16(gurl.spec()), base::string16());
     DCHECK(best_prefix != NULL);
     const int num_components_in_best_prefix = best_prefix->num_components;
     // If the URL is inlineable, we must have a match.  Note the prefix that
@@ -171,7 +171,7 @@ ScoredHistoryMatch::ScoredHistoryMatch(const URLRow& row,
     // (because the URL-that-you-typed will go first and everything
     // else will be assigned one minus the previous score, as coded
     // at the end of HistoryURLProvider::DoAutocomplete().
-    if (UTF8ToUTF16(gurl.host()) == terms[0])
+    if (base::UTF8ToUTF16(gurl.host()) == terms[0])
       hup_like_score = HistoryURLProvider::kScoreForBestInlineableResult;
 
     // HistoryURLProvider has the function PromoteOrCreateShorterSuggestion()
diff --git a/chrome/browser/history/scored_history_match_unittest.cc b/chrome/browser/history/scored_history_match_unittest.cc
index 7ce6c79..bc8c88f 100644
--- a/chrome/browser/history/scored_history_match_unittest.cc
+++ b/chrome/browser/history/scored_history_match_unittest.cc
@@ -11,6 +11,8 @@
 #include "chrome/browser/history/scored_history_match.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using base::ASCIIToUTF16;
+
 namespace history {
 
 // Returns a VisitInfoVector that includes |num_visits| spread over the
diff --git a/chrome/browser/history/shortcuts_backend_unittest.cc b/chrome/browser/history/shortcuts_backend_unittest.cc
index 30abe74..8bd0eec 100644
--- a/chrome/browser/history/shortcuts_backend_unittest.cc
+++ b/chrome/browser/history/shortcuts_backend_unittest.cc
@@ -34,7 +34,7 @@ ShortcutsBackend::Shortcut::MatchCore MatchCoreForTesting(
     const std::string& url) {
   AutocompleteMatch match;
   match.destination_url = GURL(url);
-  match.contents = ASCIIToUTF16("test");
+  match.contents = base::ASCIIToUTF16("test");
   return ShortcutsBackend::Shortcut::MatchCore(match);
 }
 
@@ -134,7 +134,7 @@ TEST_F(ShortcutsBackendTest, AddAndUpdateShortcut) {
   InitBackend();
   EXPECT_FALSE(changed_notified_);
   ShortcutsBackend::Shortcut shortcut(
-      "BD85DBA2-8C29-49F9-84AE-48E1E90880DF", ASCIIToUTF16("goog"),
+      "BD85DBA2-8C29-49F9-84AE-48E1E90880DF", base::ASCIIToUTF16("goog"),
       MatchCoreForTesting("http://www.google.com"), base::Time::Now(), 100);
   EXPECT_TRUE(backend_->AddShortcut(shortcut));
   EXPECT_TRUE(changed_notified_);
@@ -145,7 +145,7 @@ TEST_F(ShortcutsBackendTest, AddAndUpdateShortcut) {
   EXPECT_EQ(shortcut.id, shortcuts.find(shortcut.text)->second.id);
   EXPECT_EQ(shortcut.match_core.contents,
             shortcuts.find(shortcut.text)->second.match_core.contents);
-  shortcut.match_core.contents = ASCIIToUTF16("Google Web Search");
+  shortcut.match_core.contents = base::ASCIIToUTF16("Google Web Search");
   EXPECT_TRUE(backend_->UpdateShortcut(shortcut));
   EXPECT_TRUE(changed_notified_);
   EXPECT_EQ(shortcut.id, shortcuts.find(shortcut.text)->second.id);
@@ -156,22 +156,22 @@ TEST_F(ShortcutsBackendTest, AddAndUpdateShortcut) {
 TEST_F(ShortcutsBackendTest, DeleteShortcuts) {
   InitBackend();
   ShortcutsBackend::Shortcut shortcut1(
-      "BD85DBA2-8C29-49F9-84AE-48E1E90880DF", ASCIIToUTF16("goog"),
+      "BD85DBA2-8C29-49F9-84AE-48E1E90880DF", base::ASCIIToUTF16("goog"),
       MatchCoreForTesting("http://www.google.com"), base::Time::Now(), 100);
   EXPECT_TRUE(backend_->AddShortcut(shortcut1));
 
   ShortcutsBackend::Shortcut shortcut2(
-      "BD85DBA2-8C29-49F9-84AE-48E1E90880E0", ASCIIToUTF16("gle"),
+      "BD85DBA2-8C29-49F9-84AE-48E1E90880E0", base::ASCIIToUTF16("gle"),
       MatchCoreForTesting("http://www.google.com"), base::Time::Now(), 100);
   EXPECT_TRUE(backend_->AddShortcut(shortcut2));
 
   ShortcutsBackend::Shortcut shortcut3(
-      "BD85DBA2-8C29-49F9-84AE-48E1E90880E1", ASCIIToUTF16("sp"),
+      "BD85DBA2-8C29-49F9-84AE-48E1E90880E1", base::ASCIIToUTF16("sp"),
       MatchCoreForTesting("http://www.sport.com"), base::Time::Now(), 10);
   EXPECT_TRUE(backend_->AddShortcut(shortcut3));
 
   ShortcutsBackend::Shortcut shortcut4(
-      "BD85DBA2-8C29-49F9-84AE-48E1E90880E2", ASCIIToUTF16("mov"),
+      "BD85DBA2-8C29-49F9-84AE-48E1E90880E2", base::ASCIIToUTF16("mov"),
       MatchCoreForTesting("http://www.film.com"), base::Time::Now(), 10);
   EXPECT_TRUE(backend_->AddShortcut(shortcut4));
 
diff --git a/chrome/browser/history/shortcuts_database_unittest.cc b/chrome/browser/history/shortcuts_database_unittest.cc
index c95847f..bc270c3 100644
--- a/chrome/browser/history/shortcuts_database_unittest.cc
+++ b/chrome/browser/history/shortcuts_database_unittest.cc
@@ -17,6 +17,7 @@
 
 #include "testing/gtest/include/gtest/gtest.h"
 
+using base::ASCIIToUTF16;
 
 // Helpers --------------------------------------------------------------------
 
diff --git a/chrome/browser/history/snippet.cc b/chrome/browser/history/snippet.cc
index f73f56e..ba56911 100644
--- a/chrome/browser/history/snippet.cc
+++ b/chrome/browser/history/snippet.cc
@@ -211,7 +211,7 @@ void Snippet::ComputeSnippet(const MatchPositions& match_positions,
   // The length of snippets we try to produce.
   // We can generate longer snippets but stop once we cross kSnippetMaxLength.
   const size_t kSnippetMaxLength = 200;
-  const base::string16 kEllipsis = ASCIIToUTF16(" ... ");
+  const base::string16 kEllipsis = base::ASCIIToUTF16(" ... ");
 
   UText* document_utext = NULL;
   UErrorCode status = U_ZERO_ERROR;
@@ -247,13 +247,13 @@ void Snippet::ComputeSnippet(const MatchPositions& match_positions,
         snippet += kEllipsis;
       // Switch to DCHECK after debugging http://crbug.com/15261.
       CHECK(start < document.size());
-      snippet += UTF8ToUTF16(document.substr(start, match_start - start));
+      snippet += base::UTF8ToUTF16(document.substr(start, match_start - start));
     }
 
     // Add the match.
     const size_t first = snippet.size();
-    snippet += UTF8ToUTF16(document.substr(match_start,
-                                          match_end - match_start));
+    snippet += base::UTF8ToUTF16(document.substr(match_start,
+                                                 match_end - match_start));
     matches_.push_back(std::make_pair(first, snippet.size()));
 
     // Compute the context, if any, to show after the match.
@@ -268,7 +268,7 @@ void Snippet::ComputeSnippet(const MatchPositions& match_positions,
       // Switch to DCHECK after debugging http://crbug.com/15261.
       CHECK(end >= match_end);
       CHECK(end <= document.size());
-      snippet += UTF8ToUTF16(document.substr(match_end, end - match_end));
+      snippet += base::UTF8ToUTF16(document.substr(match_end, end - match_end));
     } else {
       // No, there's either no next match or the next match is too far away.
       end = match_end;
@@ -276,7 +276,7 @@ void Snippet::ComputeSnippet(const MatchPositions& match_positions,
       // Switch to DCHECK after debugging http://crbug.com/15261.
       CHECK(end >= match_end);
       CHECK(end <= document.size());
-      snippet += UTF8ToUTF16(document.substr(match_end, end - match_end));
+      snippet += base::UTF8ToUTF16(document.substr(match_end, end - match_end));
       if (end < document.size())
         snippet += kEllipsis;
     }
diff --git a/chrome/browser/history/snippet_unittest.cc b/chrome/browser/history/snippet_unittest.cc
index 15941e1..3d98046 100644
--- a/chrome/browser/history/snippet_unittest.cc
+++ b/chrome/browser/history/snippet_unittest.cc
@@ -126,10 +126,10 @@ base::string16 BuildSnippet(const std::string& document,
   for (match = snippet.matches().begin();
        match != snippet.matches().end(); ++match) {
     star_snippet += snippet.text().substr(pos, match->first - pos);
-    star_snippet += UTF8ToUTF16("**");
+    star_snippet += base::UTF8ToUTF16("**");
     star_snippet += snippet.text().substr(match->first,
                                           match->second - match->first);
-    star_snippet += UTF8ToUTF16("**");
+    star_snippet += base::UTF8ToUTF16("**");
     pos = match->second;
   }
   star_snippet += snippet.text().substr(pos);
@@ -143,7 +143,7 @@ TEST(Snippets, SimpleQuery) {
             "Goo ...  ... way, Mountain View, CA 94043, United States. This "
             "**document** explains how the agreement is made up, and sets "
             "o ... ",
-            UTF16ToUTF8(BuildSnippet(kSampleDocument, "document")));
+            base::UTF16ToUTF8(BuildSnippet(kSampleDocument, "document")));
 }
 
 // Test that two words that are near each other don't produce two elided bits.
@@ -151,7 +151,7 @@ TEST(Snippets, NearbyWords) {
   ASSERT_EQ(" ... lace of business is at 1600 Amphitheatre Parkway, "
             "**Mountain** **View**, CA 94043, United States. This "
             "document explains  ... ",
-            UTF16ToUTF8(BuildSnippet(kSampleDocument, "mountain view")));
+            base::UTF16ToUTF8(BuildSnippet(kSampleDocument, "mountain view")));
 }
 
 // The above tests already test that we get byte offsets correct, but here's
@@ -160,7 +160,7 @@ TEST(Snippets, UTF8) {
   ASSERT_EQ(" ... ogle\xe2\x84\xa2 Terms of Service Welcome to Google! "
             "1. Your **relationship** with Google 1.1 Your use of Google's "
             "products, so ... ",
-            UTF16ToUTF8(BuildSnippet(kSampleDocument, "relationship")));
+            base::UTF16ToUTF8(BuildSnippet(kSampleDocument, "relationship")));
 }
 
 TEST(Snippets, ThaiUTF8) {
@@ -219,7 +219,7 @@ TEST(Snippets, ThaiUTF8) {
             "\xE0\xB8\xA3\xE0\xB8\xB1\xE0\xB8\x9A\xE0\xB9\x81\xE0\xB8\x95"
             "\xE0\xB9\x88\xE0\xB8\x87\xE0\xB9\x80\xE0\xB8\x99\xE0\xB8\xB7"
             "\xE0\xB9\x89\xE0\xB8\xAD\xE0\xB8\xAB\xE0\xB8\xB2",
-            UTF16ToUTF8(BuildSnippet(kThaiSample,
+            base::UTF16ToUTF8(BuildSnippet(kThaiSample,
                                      "\xE0\xB9\x83\xE0\xB8\xAB\xE0\xB9\x89")));
 }
 
diff --git a/chrome/browser/history/top_sites_cache_unittest.cc b/chrome/browser/history/top_sites_cache_unittest.cc
index 89ee386..899f924 100644
--- a/chrome/browser/history/top_sites_cache_unittest.cc
+++ b/chrome/browser/history/top_sites_cache_unittest.cc
@@ -50,7 +50,7 @@ void TopSitesCacheTest::BuildTopSites(const char** spec, size_t size) {
       NOTREACHED() << "Duplicate URL found: " << spec_item;
     urls_seen.insert(spec_item);
     if (spec_item == spec[i]) {  // No indent: add new MostVisitedURL.
-      base::string16 title(ASCIIToUTF16("Title ") +
+      base::string16 title(base::ASCIIToUTF16("Title ") +
                      base::Uint64ToString16(top_sites_.size() + 1));
       top_sites_.push_back(MostVisitedURL(GURL(spec_item), title));
     }
diff --git a/chrome/browser/history/top_sites_database_unittest.cc b/chrome/browser/history/top_sites_database_unittest.cc
index f801afd..9ec6719 100644
--- a/chrome/browser/history/top_sites_database_unittest.cc
+++ b/chrome/browser/history/top_sites_database_unittest.cc
@@ -360,7 +360,7 @@ TEST_F(TopSitesDatabaseTest, AddRemoveEditThumbnails) {
 
   // Add a new URL, not forced, rank = 1.
   GURL mapsUrl = GURL("http://maps.google.com/");
-  MostVisitedURL url1(mapsUrl, ASCIIToUTF16("Google Maps"));
+  MostVisitedURL url1(mapsUrl, base::ASCIIToUTF16("Google Maps"));
   db.SetPageThumbnail(url1, 1, Images());
 
   MostVisitedURLList urls;
@@ -373,7 +373,7 @@ TEST_F(TopSitesDatabaseTest, AddRemoveEditThumbnails) {
 
   // Add a new URL, forced.
   GURL driveUrl = GURL("http://drive.google.com/");
-  MostVisitedURL url2(driveUrl, ASCIIToUTF16("Google Drive"));
+  MostVisitedURL url2(driveUrl, base::ASCIIToUTF16("Google Drive"));
   url2.last_forced_time = base::Time::FromJsTime(789714000000);  // 10/1/1995
   db.SetPageThumbnail(url2, TopSitesDatabase::kRankOfForcedURL, Images());
 
@@ -386,7 +386,7 @@ TEST_F(TopSitesDatabaseTest, AddRemoveEditThumbnails) {
 
   // Add a new URL, forced (earlier).
   GURL plusUrl = GURL("http://plus.google.com/");
-  MostVisitedURL url3(plusUrl, ASCIIToUTF16("Google Plus"));
+  MostVisitedURL url3(plusUrl, base::ASCIIToUTF16("Google Plus"));
   url3.last_forced_time = base::Time::FromJsTime(787035600000);  // 10/12/1994
   db.SetPageThumbnail(url3, TopSitesDatabase::kRankOfForcedURL, Images());
 
diff --git a/chrome/browser/history/top_sites_impl_unittest.cc b/chrome/browser/history/top_sites_impl_unittest.cc
index 8c6a253..69364fa 100644
--- a/chrome/browser/history/top_sites_impl_unittest.cc
+++ b/chrome/browser/history/top_sites_impl_unittest.cc
@@ -649,11 +649,11 @@ TEST_F(TopSitesImplTest, GetMostVisited) {
 TEST_F(TopSitesImplTest, SaveToDB) {
   MostVisitedURL url;
   GURL asdf_url("http://asdf.com");
-  base::string16 asdf_title(ASCIIToUTF16("ASDF"));
+  base::string16 asdf_title(base::ASCIIToUTF16("ASDF"));
   GURL google_url("http://google.com");
-  base::string16 google_title(ASCIIToUTF16("Google"));
+  base::string16 google_title(base::ASCIIToUTF16("Google"));
   GURL news_url("http://news.google.com");
-  base::string16 news_title(ASCIIToUTF16("Google News"));
+  base::string16 news_title(base::ASCIIToUTF16("Google News"));
 
   // Add asdf_url to history.
   AddPageToHistory(asdf_url, asdf_title);
@@ -713,16 +713,16 @@ TEST_F(TopSitesImplTest, SaveToDB) {
 TEST_F(TopSitesImplTest, SaveForcedToDB) {
   MostVisitedURL url;
   GURL asdf_url("http://asdf.com");
-  base::string16 asdf_title(ASCIIToUTF16("ASDF"));
+  base::string16 asdf_title(base::ASCIIToUTF16("ASDF"));
   GURL google_url("http://google.com");
-  base::string16 google_title(ASCIIToUTF16("Google"));
+  base::string16 google_title(base::ASCIIToUTF16("Google"));
   GURL news_url("http://news.google.com");
-  base::string16 news_title(ASCIIToUTF16("Google News"));
+  base::string16 news_title(base::ASCIIToUTF16("Google News"));
 
   // Add a number of forced URLs.
   std::vector<MostVisitedURL> list;
   AppendForcedMostVisitedURL(&list, GURL("http://forced1"), 1000);
-  list[0].title = ASCIIToUTF16("forced1");
+  list[0].title = base::ASCIIToUTF16("forced1");
   AppendForcedMostVisitedURL(&list, GURL("http://forced2"), 2000);
   AppendForcedMostVisitedURL(&list, GURL("http://forced3"), 3000);
   AppendForcedMostVisitedURL(&list, GURL("http://forced4"), 4000);
@@ -749,7 +749,7 @@ TEST_F(TopSitesImplTest, SaveForcedToDB) {
 
   ASSERT_EQ(4u + GetPrepopulatePages().size(), querier.urls().size());
   EXPECT_EQ(GURL("http://forced1"), querier.urls()[0].url);
-  EXPECT_EQ(ASCIIToUTF16("forced1"), querier.urls()[0].title);
+  EXPECT_EQ(base::ASCIIToUTF16("forced1"), querier.urls()[0].title);
   SkBitmap thumbnail = GetThumbnail(GURL("http://forced1"));
   ASSERT_EQ(orig_thumbnail.getSize(), thumbnail.getSize());
   orig_thumbnail.lockPixels();
@@ -773,13 +773,13 @@ TEST_F(TopSitesImplTest, SaveForcedToDB) {
 TEST_F(TopSitesImplTest, RealDatabase) {
   MostVisitedURL url;
   GURL asdf_url("http://asdf.com");
-  base::string16 asdf_title(ASCIIToUTF16("ASDF"));
+  base::string16 asdf_title(base::ASCIIToUTF16("ASDF"));
   GURL google1_url("http://google.com");
   GURL google2_url("http://google.com/redirect");
   GURL google3_url("http://www.google.com");
-  base::string16 google_title(ASCIIToUTF16("Google"));
+  base::string16 google_title(base::ASCIIToUTF16("Google"));
   GURL news_url("http://news.google.com");
-  base::string16 news_title(ASCIIToUTF16("Google News"));
+  base::string16 news_title(base::ASCIIToUTF16("Google News"));
 
   url.url = asdf_url;
   url.title = asdf_title;
@@ -887,9 +887,9 @@ TEST_F(TopSitesImplTest, DeleteNotifications) {
   GURL google1_url("http://google.com");
   GURL google2_url("http://google.com/redirect");
   GURL google3_url("http://www.google.com");
-  base::string16 google_title(ASCIIToUTF16("Google"));
+  base::string16 google_title(base::ASCIIToUTF16("Google"));
   GURL news_url("http://news.google.com");
-  base::string16 news_title(ASCIIToUTF16("Google News"));
+  base::string16 news_title(base::ASCIIToUTF16("Google News"));
 
   AddPageToHistory(google1_url, google_title);
   AddPageToHistory(news_url, news_title);
diff --git a/chrome/browser/history/typed_url_syncable_service.cc b/chrome/browser/history/typed_url_syncable_service.cc
index fcb3cfa..7fc26dd 100644
--- a/chrome/browser/history/typed_url_syncable_service.cc
+++ b/chrome/browser/history/typed_url_syncable_service.cc
@@ -331,7 +331,7 @@ void TypedUrlSyncableService::WriteToTypedUrlSpecifics(
             visits.back().visit_time.ToInternalValue());
 
   typed_url->set_url(url.url().spec());
-  typed_url->set_title(UTF16ToUTF8(url.title()));
+  typed_url->set_title(base::UTF16ToUTF8(url.title()));
   typed_url->set_hidden(url.hidden());
 
   DCHECK(CheckVisitOrdering(visits));
diff --git a/chrome/browser/history/typed_url_syncable_service_unittest.cc b/chrome/browser/history/typed_url_syncable_service_unittest.cc
index f5919ad..1e6aa1a 100644
--- a/chrome/browser/history/typed_url_syncable_service_unittest.cc
+++ b/chrome/browser/history/typed_url_syncable_service_unittest.cc
@@ -143,7 +143,7 @@ class TypedUrlSyncableServiceTest : public testing::Test {
   static bool URLsEqual(URLRow& row,
                         sync_pb::TypedUrlSpecifics& specifics) {
     return ((row.url().spec().compare(specifics.url()) == 0) &&
-            (UTF16ToUTF8(row.title()).compare(specifics.title()) == 0) &&
+            (base::UTF16ToUTF8(row.title()).compare(specifics.title()) == 0) &&
             (row.hidden() == specifics.hidden()));
   }
 
@@ -185,7 +185,7 @@ URLRow TypedUrlSyncableServiceTest::MakeTypedUrlRow(
   static int unique_url_id = 0;
   GURL gurl(url);
   URLRow history_url(gurl, ++unique_url_id);
-  history_url.set_title(UTF8ToUTF16(title));
+  history_url.set_title(base::UTF8ToUTF16(title));
   history_url.set_typed_count(typed_count);
   history_url.set_hidden(hidden);
 
diff --git a/chrome/browser/history/url_database_unittest.cc b/chrome/browser/history/url_database_unittest.cc
index 0f71dd4..3dbdf1fc 100644
--- a/chrome/browser/history/url_database_unittest.cc
+++ b/chrome/browser/history/url_database_unittest.cc
@@ -71,7 +71,7 @@ TEST_F(URLDatabaseTest, AddURL) {
   // First, add two URLs.
   const GURL url1("http://www.google.com/");
   URLRow url_info1(url1);
-  url_info1.set_title(UTF8ToUTF16("Google"));
+  url_info1.set_title(base::UTF8ToUTF16("Google"));
   url_info1.set_visit_count(4);
   url_info1.set_typed_count(2);
   url_info1.set_last_visit(Time::Now() - TimeDelta::FromDays(1));
@@ -80,7 +80,7 @@ TEST_F(URLDatabaseTest, AddURL) {
 
   const GURL url2("http://mail.google.com/");
   URLRow url_info2(url2);
-  url_info2.set_title(UTF8ToUTF16("Google Mail"));
+  url_info2.set_title(base::UTF8ToUTF16("Google Mail"));
   url_info2.set_visit_count(3);
   url_info2.set_typed_count(0);
   url_info2.set_last_visit(Time::Now() - TimeDelta::FromDays(2));
@@ -96,7 +96,7 @@ TEST_F(URLDatabaseTest, AddURL) {
   EXPECT_TRUE(IsURLRowEqual(url_info2, info));
 
   // Update the second.
-  url_info2.set_title(UTF8ToUTF16("Google Mail Too"));
+  url_info2.set_title(base::UTF8ToUTF16("Google Mail Too"));
   url_info2.set_visit_count(4);
   url_info2.set_typed_count(1);
   url_info2.set_typed_count(91011);
@@ -124,7 +124,7 @@ TEST_F(URLDatabaseTest, AddURL) {
 // Tests adding, querying and deleting keyword visits.
 TEST_F(URLDatabaseTest, KeywordSearchTermVisit) {
   URLRow url_info1(GURL("http://www.google.com/"));
-  url_info1.set_title(UTF8ToUTF16("Google"));
+  url_info1.set_title(base::UTF8ToUTF16("Google"));
   url_info1.set_visit_count(4);
   url_info1.set_typed_count(2);
   url_info1.set_last_visit(Time::Now() - TimeDelta::FromDays(1));
@@ -134,7 +134,7 @@ TEST_F(URLDatabaseTest, KeywordSearchTermVisit) {
 
   // Add a keyword visit.
   TemplateURLID keyword_id = 100;
-  base::string16 keyword = UTF8ToUTF16("visit");
+  base::string16 keyword = base::UTF8ToUTF16("visit");
   ASSERT_TRUE(SetKeywordSearchTermsForURL(url_id, keyword_id, keyword));
 
   // Make sure we get it back.
@@ -163,7 +163,7 @@ TEST_F(URLDatabaseTest, KeywordSearchTermVisit) {
 // Make sure deleting a URL also deletes a keyword visit.
 TEST_F(URLDatabaseTest, DeleteURLDeletesKeywordSearchTermVisit) {
   URLRow url_info1(GURL("http://www.google.com/"));
-  url_info1.set_title(UTF8ToUTF16("Google"));
+  url_info1.set_title(base::UTF8ToUTF16("Google"));
   url_info1.set_visit_count(4);
   url_info1.set_typed_count(2);
   url_info1.set_last_visit(Time::Now() - TimeDelta::FromDays(1));
@@ -172,14 +172,15 @@ TEST_F(URLDatabaseTest, DeleteURLDeletesKeywordSearchTermVisit) {
   ASSERT_NE(0, url_id);
 
   // Add a keyword visit.
-  ASSERT_TRUE(SetKeywordSearchTermsForURL(url_id, 1, UTF8ToUTF16("visit")));
+  ASSERT_TRUE(
+      SetKeywordSearchTermsForURL(url_id, 1, base::UTF8ToUTF16("visit")));
 
   // Delete the url.
   ASSERT_TRUE(DeleteURLRow(url_id));
 
   // Make sure the keyword visit was deleted.
   std::vector<KeywordSearchTermVisit> matches;
-  GetMostRecentKeywordSearchTerms(1, UTF8ToUTF16("visit"), 10, &matches);
+  GetMostRecentKeywordSearchTerms(1, base::UTF8ToUTF16("visit"), 10, &matches);
   ASSERT_EQ(0U, matches.size());
 }
 
@@ -223,7 +224,7 @@ TEST_F(URLDatabaseTest, EnumeratorForSignificant) {
 // Test GetKeywordSearchTermRows and DeleteSearchTerm
 TEST_F(URLDatabaseTest, GetAndDeleteKeywordSearchTermByTerm) {
   URLRow url_info1(GURL("http://www.google.com/"));
-  url_info1.set_title(UTF8ToUTF16("Google"));
+  url_info1.set_title(base::UTF8ToUTF16("Google"));
   url_info1.set_visit_count(4);
   url_info1.set_typed_count(2);
   url_info1.set_last_visit(Time::Now() - TimeDelta::FromDays(1));
@@ -233,11 +234,11 @@ TEST_F(URLDatabaseTest, GetAndDeleteKeywordSearchTermByTerm) {
 
   // Add a keyword visit.
   TemplateURLID keyword_id = 100;
-  base::string16 keyword = UTF8ToUTF16("visit");
+  base::string16 keyword = base::UTF8ToUTF16("visit");
   ASSERT_TRUE(SetKeywordSearchTermsForURL(url_id1, keyword_id, keyword));
 
   URLRow url_info2(GURL("https://www.google.com/"));
-  url_info2.set_title(UTF8ToUTF16("Google"));
+  url_info2.set_title(base::UTF8ToUTF16("Google"));
   url_info2.set_visit_count(4);
   url_info2.set_typed_count(2);
   url_info2.set_last_visit(Time::Now() - TimeDelta::FromDays(1));
@@ -249,14 +250,14 @@ TEST_F(URLDatabaseTest, GetAndDeleteKeywordSearchTermByTerm) {
 
   // Add another URL for different keyword.
   URLRow url_info3(GURL("https://www.google.com/search"));
-  url_info3.set_title(UTF8ToUTF16("Google"));
+  url_info3.set_title(base::UTF8ToUTF16("Google"));
   url_info3.set_visit_count(4);
   url_info3.set_typed_count(2);
   url_info3.set_last_visit(Time::Now() - TimeDelta::FromDays(1));
   url_info3.set_hidden(false);
   URLID url_id3 = AddURL(url_info3);
   ASSERT_NE(0, url_id3);
-  base::string16 keyword2 = UTF8ToUTF16("Search");
+  base::string16 keyword2 = base::UTF8ToUTF16("Search");
 
   ASSERT_TRUE(SetKeywordSearchTermsForURL(url_id3, keyword_id, keyword2));
 
diff --git a/chrome/browser/history/url_index_private_data.cc b/chrome/browser/history/url_index_private_data.cc
index a17b0a4..1e11e2ef 100644
--- a/chrome/browser/history/url_index_private_data.cc
+++ b/chrome/browser/history/url_index_private_data.cc
@@ -162,7 +162,7 @@ ScoredHistoryMatches URLIndexPrivateData::HistoryItemsForTerms(
   if ((cursor_position != base::string16::npos) &&
       (cursor_position < search_string.length()) &&
       (cursor_position > 0)) {
-    search_string.insert(cursor_position, ASCIIToUTF16(" "));
+    search_string.insert(cursor_position, base::ASCIIToUTF16(" "));
   }
   pre_filter_item_count_ = 0;
   post_filter_item_count_ = 0;
@@ -932,7 +932,7 @@ void URLIndexPrivateData::SaveWordList(InMemoryURLIndexCacheItem* cache) const {
   list_item->set_word_count(word_list_.size());
   for (String16Vector::const_iterator iter = word_list_.begin();
        iter != word_list_.end(); ++iter)
-    list_item->add_word(UTF16ToUTF8(*iter));
+    list_item->add_word(base::UTF16ToUTF8(*iter));
 }
 
 void URLIndexPrivateData::SaveWordMap(InMemoryURLIndexCacheItem* cache) const {
@@ -943,7 +943,7 @@ void URLIndexPrivateData::SaveWordMap(InMemoryURLIndexCacheItem* cache) const {
   for (WordMap::const_iterator iter = word_map_.begin();
        iter != word_map_.end(); ++iter) {
     WordMapEntry* map_entry = map_item->add_word_map_entry();
-    map_entry->set_word(UTF16ToUTF8(iter->first));
+    map_entry->set_word(base::UTF16ToUTF8(iter->first));
     map_entry->set_word_id(iter->second);
   }
 }
@@ -1002,7 +1002,7 @@ void URLIndexPrivateData::SaveHistoryInfoMap(
     map_entry->set_typed_count(url_row.typed_count());
     map_entry->set_last_visit(url_row.last_visit().ToInternalValue());
     map_entry->set_url(url_row.url().spec());
-    map_entry->set_title(UTF16ToUTF8(url_row.title()));
+    map_entry->set_title(base::UTF16ToUTF8(url_row.title()));
     const VisitInfoVector& visits(iter->second.visits);
     for (VisitInfoVector::const_iterator visit_iter = visits.begin();
          visit_iter != visits.end(); ++visit_iter) {
@@ -1083,7 +1083,7 @@ bool URLIndexPrivateData::RestoreWordList(
   const RepeatedPtrField<std::string>& words(list_item.word());
   for (RepeatedPtrField<std::string>::const_iterator iter = words.begin();
        iter != words.end(); ++iter)
-    word_list_.push_back(UTF8ToUTF16(*iter));
+    word_list_.push_back(base::UTF8ToUTF16(*iter));
   return true;
 }
 
@@ -1099,7 +1099,7 @@ bool URLIndexPrivateData::RestoreWordMap(
   const RepeatedPtrField<WordMapEntry>& entries(list_item.word_map_entry());
   for (RepeatedPtrField<WordMapEntry>::const_iterator iter = entries.begin();
        iter != entries.end(); ++iter)
-    word_map_[UTF8ToUTF16(iter->word())] = iter->word_id();
+    word_map_[base::UTF8ToUTF16(iter->word())] = iter->word_id();
   return true;
 }
 
@@ -1181,7 +1181,7 @@ bool URLIndexPrivateData::RestoreHistoryInfoMap(
     url_row.set_typed_count(iter->typed_count());
     url_row.set_last_visit(base::Time::FromInternalValue(iter->last_visit()));
     if (iter->has_title()) {
-      base::string16 title(UTF8ToUTF16(iter->title()));
+      base::string16 title(base::UTF8ToUTF16(iter->title()));
       url_row.set_title(title);
     }
     history_info_map_[history_id].url_row = url_row;
diff --git a/chrome/browser/history/web_history_service.cc b/chrome/browser/history/web_history_service.cc
index c88bd8f7..ab14eb8 100644
--- a/chrome/browser/history/web_history_service.cc
+++ b/chrome/browser/history/web_history_service.cc
@@ -258,7 +258,7 @@ GURL GetQueryUrl(const base::string16& text_query,
   }
 
   if (!text_query.empty())
-    url = net::AppendQueryParameter(url, "q", UTF16ToUTF8(text_query));
+    url = net::AppendQueryParameter(url, "q", base::UTF16ToUTF8(text_query));
 
   if (!version_info.empty())
     url = net::AppendQueryParameter(url, "kvi", version_info);
diff --git a/chrome/browser/iframe_browsertest.cc b/chrome/browser/iframe_browsertest.cc
index 941cb3f..e0853f6 100644
--- a/chrome/browser/iframe_browsertest.cc
+++ b/chrome/browser/iframe_browsertest.cc
@@ -18,7 +18,7 @@ class IFrameTest : public InProcessBrowserTest {
         base::FilePath(), base::FilePath().AppendASCII(file));
 
     ui_test_utils::NavigateToURL(browser(), url);
-    EXPECT_EQ(ASCIIToUTF16(page_title),
+    EXPECT_EQ(base::ASCIIToUTF16(page_title),
               browser()->tab_strip_model()->GetActiveWebContents()->GetTitle());
   }
 };