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

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

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

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

63 files changed, 219 insertions, 206 deletions

diff --git a/chrome/common/badge_util.cc b/chrome/common/badge_util.cc
index 81bb6f3..1421041 100644
--- a/chrome/common/badge_util.cc
+++ b/chrome/common/badge_util.cc
@@ -103,7 +103,7 @@ SkBitmap DrawBadgeIconOverlay(const SkBitmap& icon,
   paint->setTextSize(SkFloatToScalar(font_size));
   paint->setColor(SK_ColorWHITE);
 
-  std::string badge_text = UTF16ToUTF8(text);
+  std::string badge_text = base::UTF16ToUTF8(text);
 
   // See if the text will fit - otherwise use a default.
   SkScalar text_width = paint->measureText(badge_text.c_str(),
@@ -111,7 +111,7 @@ SkBitmap DrawBadgeIconOverlay(const SkBitmap& icon,
 
   if (SkScalarRound(text_width) > (icon.width() - kMinPadding * 2)) {
     // String is too large - use the alternate text.
-    badge_text = UTF16ToUTF8(fallback);
+    badge_text = base::UTF16ToUTF8(fallback);
     text_width = paint->measureText(badge_text.c_str(), badge_text.size());
   }
 
diff --git a/chrome/common/child_process_logging_win.cc b/chrome/common/child_process_logging_win.cc
index 0fe9e82..4cf9b0a 100644
--- a/chrome/common/child_process_logging_win.cc
+++ b/chrome/common/child_process_logging_win.cc
@@ -34,8 +34,10 @@ void SetCrashKeyValueTrampoline(const base::StringPiece& key,
         GetProcAddress(exe_module, "SetCrashKeyValueImpl"));
   }
 
-  if (set_crash_key)
-    (set_crash_key)(UTF8ToWide(key).data(), UTF8ToWide(value).data());
+  if (set_crash_key) {
+    (set_crash_key)(base::UTF8ToWide(key).data(),
+                    base::UTF8ToWide(value).data());
+  }
 }
 
 void ClearCrashKeyValueTrampoline(const base::StringPiece& key) {
@@ -49,7 +51,7 @@ void ClearCrashKeyValueTrampoline(const base::StringPiece& key) {
   }
 
   if (clear_crash_key)
-    (clear_crash_key)(UTF8ToWide(key).data());
+    (clear_crash_key)(base::UTF8ToWide(key).data());
 }
 
 }  // namespace
diff --git a/chrome/common/chrome_version_info.cc b/chrome/common/chrome_version_info.cc
index 7671a3d..5daa6d1 100644
--- a/chrome/common/chrome_version_info.cc
+++ b/chrome/common/chrome_version_info.cc
@@ -42,19 +42,19 @@ bool VersionInfo::is_valid() const {
 std::string VersionInfo::Name() const {
   if (!is_valid())
     return std::string();
-  return UTF16ToUTF8(version_info_->product_name());
+  return base::UTF16ToUTF8(version_info_->product_name());
 }
 
 std::string VersionInfo::Version() const {
   if (!is_valid())
     return std::string();
-  return UTF16ToUTF8(version_info_->product_version());
+  return base::UTF16ToUTF8(version_info_->product_version());
 }
 
 std::string VersionInfo::LastChange() const {
   if (!is_valid())
     return std::string();
-  return UTF16ToUTF8(version_info_->last_change());
+  return base::UTF16ToUTF8(version_info_->last_change());
 }
 
 bool VersionInfo::IsOfficialBuild() const {
diff --git a/chrome/common/content_settings_helper.cc b/chrome/common/content_settings_helper.cc
index ea6226b..9fa5607 100644
--- a/chrome/common/content_settings_helper.cc
+++ b/chrome/common/content_settings_helper.cc
@@ -23,7 +23,7 @@ std::string OriginToString(const GURL& origin) {
 }
 
 base::string16 OriginToString16(const GURL& origin) {
-  return UTF8ToUTF16(OriginToString(origin));
+  return base::UTF8ToUTF16(OriginToString(origin));
 }
 
 }  // namespace content_settings_helper
diff --git a/chrome/common/content_settings_helper_unittest.cc b/chrome/common/content_settings_helper_unittest.cc
index 8ea861c..bea446c 100644
--- a/chrome/common/content_settings_helper_unittest.cc
+++ b/chrome/common/content_settings_helper_unittest.cc
@@ -24,24 +24,24 @@ TEST(ContentSettingsHelperTest, OriginToString16) {
   const GURL kUrl7("https://foo.com:81/bar");
 
   // Now check the first group of urls with just "http":
-  EXPECT_EQ(ASCIIToUTF16("www.foo.com"),
+  EXPECT_EQ(base::ASCIIToUTF16("www.foo.com"),
             content_settings_helper::OriginToString16(kUrl0));
-  EXPECT_EQ(ASCIIToUTF16("foo.com"),
+  EXPECT_EQ(base::ASCIIToUTF16("foo.com"),
             content_settings_helper::OriginToString16(kUrl1));
 
-  EXPECT_EQ(ASCIIToUTF16("www.foo.com:81"),
+  EXPECT_EQ(base::ASCIIToUTF16("www.foo.com:81"),
             content_settings_helper::OriginToString16(kUrl2));
-  EXPECT_EQ(ASCIIToUTF16("foo.com:81"),
+  EXPECT_EQ(base::ASCIIToUTF16("foo.com:81"),
             content_settings_helper::OriginToString16(kUrl3));
 
   // Now check the second group of urls with "https":
-  EXPECT_EQ(ASCIIToUTF16("https://www.foo.com"),
+  EXPECT_EQ(base::ASCIIToUTF16("https://www.foo.com"),
             content_settings_helper::OriginToString16(kUrl4));
-  EXPECT_EQ(ASCIIToUTF16("https://foo.com"),
+  EXPECT_EQ(base::ASCIIToUTF16("https://foo.com"),
             content_settings_helper::OriginToString16(kUrl5));
 
-  EXPECT_EQ(ASCIIToUTF16("https://www.foo.com:81"),
+  EXPECT_EQ(base::ASCIIToUTF16("https://www.foo.com:81"),
             content_settings_helper::OriginToString16(kUrl6));
-  EXPECT_EQ(ASCIIToUTF16("https://foo.com:81"),
+  EXPECT_EQ(base::ASCIIToUTF16("https://foo.com:81"),
             content_settings_helper::OriginToString16(kUrl7));
 }
diff --git a/chrome/common/extensions/api/commands/commands_handler.cc b/chrome/common/extensions/api/commands/commands_handler.cc
index 9232649..4874ce2 100644
--- a/chrome/common/extensions/api/commands/commands_handler.cc
+++ b/chrome/common/extensions/api/commands/commands_handler.cc
@@ -72,7 +72,7 @@ bool CommandsHandler::Parse(Extension* extension, base::string16* error) {
 
   const base::DictionaryValue* dict = NULL;
   if (!extension->manifest()->GetDictionary(keys::kCommands, &dict)) {
-    *error = ASCIIToUTF16(manifest_errors::kInvalidCommandsKey);
+    *error = base::ASCIIToUTF16(manifest_errors::kInvalidCommandsKey);
     return false;
   }
 
diff --git a/chrome/common/extensions/api/extension_action/action_info.cc b/chrome/common/extensions/api/extension_action/action_info.cc
index f2b4540..c41ae6f 100644
--- a/chrome/common/extensions/api/extension_action/action_info.cc
+++ b/chrome/common/extensions/api/extension_action/action_info.cc
@@ -69,7 +69,7 @@ scoped_ptr<ActionInfo> ActionInfo::Load(const Extension* extension,
       if (iter == icons->end() ||
           !(*iter)->GetAsString(&path) ||
           !manifest_handler_helpers::NormalizeAndValidatePath(&path)) {
-        *error = ASCIIToUTF16(errors::kInvalidPageActionIconPath);
+        *error = base::ASCIIToUTF16(errors::kInvalidPageActionIconPath);
         return scoped_ptr<ActionInfo>();
       }
       result->default_icon.Add(extension_misc::EXTENSION_ICON_ACTION, path);
@@ -78,7 +78,7 @@ scoped_ptr<ActionInfo> ActionInfo::Load(const Extension* extension,
     std::string id;
     if (dict->HasKey(keys::kPageActionId)) {
       if (!dict->GetString(keys::kPageActionId, &id)) {
-        *error = ASCIIToUTF16(errors::kInvalidPageActionId);
+        *error = base::ASCIIToUTF16(errors::kInvalidPageActionId);
         return scoped_ptr<ActionInfo>();
       }
       result->id = id;
@@ -106,7 +106,7 @@ scoped_ptr<ActionInfo> ActionInfo::Load(const Extension* extension,
       result->default_icon.Add(extension_misc::EXTENSION_ICON_ACTION,
                                default_icon);
     } else {
-      *error = ASCIIToUTF16(errors::kInvalidPageActionIconPath);
+      *error = base::ASCIIToUTF16(errors::kInvalidPageActionIconPath);
       return scoped_ptr<ActionInfo>();
     }
   }
@@ -116,12 +116,12 @@ scoped_ptr<ActionInfo> ActionInfo::Load(const Extension* extension,
   if (dict->HasKey(keys::kPageActionDefaultTitle)) {
     if (!dict->GetString(keys::kPageActionDefaultTitle,
                          &result->default_title)) {
-      *error = ASCIIToUTF16(errors::kInvalidPageActionDefaultTitle);
+      *error = base::ASCIIToUTF16(errors::kInvalidPageActionDefaultTitle);
       return scoped_ptr<ActionInfo>();
     }
   } else if (extension->manifest_version() == 1 && dict->HasKey(keys::kName)) {
     if (!dict->GetString(keys::kName, &result->default_title)) {
-      *error = ASCIIToUTF16(errors::kInvalidPageActionName);
+      *error = base::ASCIIToUTF16(errors::kInvalidPageActionName);
       return scoped_ptr<ActionInfo>();
     }
   }
@@ -157,7 +157,7 @@ scoped_ptr<ActionInfo> ActionInfo::Load(const Extension* extension,
         return scoped_ptr<ActionInfo>();
       }
     } else {
-      *error = ASCIIToUTF16(errors::kInvalidPageActionPopup);
+      *error = base::ASCIIToUTF16(errors::kInvalidPageActionPopup);
       return scoped_ptr<ActionInfo>();
     }
 
diff --git a/chrome/common/extensions/api/extension_action/browser_action_handler.cc b/chrome/common/extensions/api/extension_action/browser_action_handler.cc
index 1cf6b8b..9b449b2 100644
--- a/chrome/common/extensions/api/extension_action/browser_action_handler.cc
+++ b/chrome/common/extensions/api/extension_action/browser_action_handler.cc
@@ -28,7 +28,7 @@ bool BrowserActionHandler::Parse(Extension* extension,
   const base::DictionaryValue* dict = NULL;
   if (!extension->manifest()->GetDictionary(
           manifest_keys::kBrowserAction, &dict)) {
-    *error = ASCIIToUTF16(manifest_errors::kInvalidBrowserAction);
+    *error = base::ASCIIToUTF16(manifest_errors::kInvalidBrowserAction);
     return false;
   }
 
diff --git a/chrome/common/extensions/api/extension_action/page_action_handler.cc b/chrome/common/extensions/api/extension_action/page_action_handler.cc
index 7f87e6c..a9d2ea8 100644
--- a/chrome/common/extensions/api/extension_action/page_action_handler.cc
+++ b/chrome/common/extensions/api/extension_action/page_action_handler.cc
@@ -30,7 +30,7 @@ bool PageActionHandler::Parse(Extension* extension, base::string16* error) {
   if (extension->manifest()->HasKey(keys::kPageActions)) {
     const base::ListValue* list_value = NULL;
     if (!extension->manifest()->GetList(keys::kPageActions, &list_value)) {
-      *error = ASCIIToUTF16(errors::kInvalidPageActionsList);
+      *error = base::ASCIIToUTF16(errors::kInvalidPageActionsList);
       return false;
     }
 
@@ -41,24 +41,24 @@ bool PageActionHandler::Parse(Extension* extension, base::string16* error) {
       // a page_actions key in the manifest.  Don't set |page_action_value|.
     } else if (list_value_length == 1u) {
       if (!list_value->GetDictionary(0, &page_action_value)) {
-        *error = ASCIIToUTF16(errors::kInvalidPageAction);
+        *error = base::ASCIIToUTF16(errors::kInvalidPageAction);
         return false;
       }
     } else {  // list_value_length > 1u.
-      *error = ASCIIToUTF16(errors::kInvalidPageActionsListSize);
+      *error = base::ASCIIToUTF16(errors::kInvalidPageActionsListSize);
       return false;
     }
   } else if (extension->manifest()->HasKey(keys::kPageAction)) {
     if (!extension->manifest()->GetDictionary(keys::kPageAction,
                                               &page_action_value)) {
-      *error = ASCIIToUTF16(errors::kInvalidPageAction);
+      *error = base::ASCIIToUTF16(errors::kInvalidPageAction);
       return false;
     }
   }
 
   // An extension cannot have both browser and page actions.
   if (extension->manifest()->HasKey(keys::kBrowserAction)) {
-    *error = ASCIIToUTF16(errors::kOneUISurfaceOnly);
+    *error = base::ASCIIToUTF16(errors::kOneUISurfaceOnly);
     return false;
   }
 
diff --git a/chrome/common/extensions/api/extension_action/script_badge_handler.cc b/chrome/common/extensions/api/extension_action/script_badge_handler.cc
index 97c9b58..9f5552a 100644
--- a/chrome/common/extensions/api/extension_action/script_badge_handler.cc
+++ b/chrome/common/extensions/api/extension_action/script_badge_handler.cc
@@ -50,7 +50,7 @@ bool ScriptBadgeHandler::Parse(Extension* extension, base::string16* error) {
 
   const base::DictionaryValue* dict = NULL;
   if (!extension->manifest()->GetDictionary(keys::kScriptBadge, &dict)) {
-    *error = ASCIIToUTF16(errors::kInvalidScriptBadge);
+    *error = base::ASCIIToUTF16(errors::kInvalidScriptBadge);
     return false;
   }
 
diff --git a/chrome/common/extensions/api/file_browser_handlers/file_browser_handler.cc b/chrome/common/extensions/api/file_browser_handlers/file_browser_handler.cc
index 6729874..284d3b8 100644
--- a/chrome/common/extensions/api/file_browser_handlers/file_browser_handler.cc
+++ b/chrome/common/extensions/api/file_browser_handlers/file_browser_handler.cc
@@ -141,7 +141,7 @@ FileBrowserHandler* LoadFileBrowserHandler(
   // Read the file action |id| (mandatory).
   if (!file_browser_handler->HasKey(keys::kPageActionId) ||
       !file_browser_handler->GetString(keys::kPageActionId, &handler_id)) {
-    *error = ASCIIToUTF16(errors::kInvalidPageActionId);
+    *error = base::ASCIIToUTF16(errors::kInvalidPageActionId);
     return NULL;
   }
   result->set_id(handler_id);
@@ -150,7 +150,7 @@ FileBrowserHandler* LoadFileBrowserHandler(
   std::string title;
   if (!file_browser_handler->HasKey(keys::kPageActionDefaultTitle) ||
       !file_browser_handler->GetString(keys::kPageActionDefaultTitle, &title)) {
-    *error = ASCIIToUTF16(errors::kInvalidPageActionDefaultTitle);
+    *error = base::ASCIIToUTF16(errors::kInvalidPageActionDefaultTitle);
     return NULL;
   }
   result->set_title(title);
@@ -161,7 +161,7 @@ FileBrowserHandler* LoadFileBrowserHandler(
     if (!file_browser_handler->GetList(keys::kFileAccessList,
                                        &access_list_value) ||
         access_list_value->empty()) {
-      *error = ASCIIToUTF16(errors::kInvalidFileAccessList);
+      *error = base::ASCIIToUTF16(errors::kInvalidFileAccessList);
       return NULL;
     }
     for (size_t i = 0; i < access_list_value->GetSize(); ++i) {
@@ -175,7 +175,7 @@ FileBrowserHandler* LoadFileBrowserHandler(
     }
   }
   if (!result->ValidateFileAccessPermissions()) {
-    *error = ASCIIToUTF16(errors::kInvalidFileAccessList);
+    *error = base::ASCIIToUTF16(errors::kInvalidFileAccessList);
     return NULL;
   }
 
@@ -185,7 +185,7 @@ FileBrowserHandler* LoadFileBrowserHandler(
     const base::ListValue* file_filters = NULL;
     if (!file_browser_handler->HasKey(keys::kFileFilters) ||
         !file_browser_handler->GetList(keys::kFileFilters, &file_filters)) {
-      *error = ASCIIToUTF16(errors::kInvalidFileFiltersList);
+      *error = base::ASCIIToUTF16(errors::kInvalidFileFiltersList);
       return NULL;
     }
     for (size_t i = 0; i < file_filters->GetSize(); ++i) {
@@ -231,7 +231,7 @@ FileBrowserHandler* LoadFileBrowserHandler(
     if (!file_browser_handler->GetString(
             keys::kPageActionDefaultIcon, &default_icon) ||
         default_icon.empty()) {
-      *error = ASCIIToUTF16(errors::kInvalidPageActionIconPath);
+      *error = base::ASCIIToUTF16(errors::kInvalidPageActionIconPath);
       return NULL;
     }
     result->set_icon_path(default_icon);
@@ -250,7 +250,7 @@ bool LoadFileBrowserHandlers(
        iter != extension_actions->end();
        ++iter) {
     if (!(*iter)->IsType(base::Value::TYPE_DICTIONARY)) {
-      *error = ASCIIToUTF16(errors::kInvalidFileBrowserHandler);
+      *error = base::ASCIIToUTF16(errors::kInvalidFileBrowserHandler);
       return false;
     }
     scoped_ptr<FileBrowserHandler> action(
@@ -271,7 +271,7 @@ bool FileBrowserHandlerParser::Parse(extensions::Extension* extension,
   const base::ListValue* file_browser_handlers_value = NULL;
   if (!extension->manifest()->GetList(keys::kFileBrowserHandlers,
                                       &file_browser_handlers_value)) {
-    *error = ASCIIToUTF16(errors::kInvalidFileBrowserHandler);
+    *error = base::ASCIIToUTF16(errors::kInvalidFileBrowserHandler);
     return false;
   }
   scoped_ptr<FileBrowserHandlerInfo> info(new FileBrowserHandlerInfo);
diff --git a/chrome/common/extensions/api/file_handlers/file_handlers_parser.cc b/chrome/common/extensions/api/file_handlers/file_handlers_parser.cc
index 70a8917..74a0864 100644
--- a/chrome/common/extensions/api/file_handlers/file_handlers_parser.cc
+++ b/chrome/common/extensions/api/file_handlers/file_handlers_parser.cc
@@ -74,7 +74,7 @@ bool LoadFileHandler(const std::string& handler_id,
 
   if (handler_info.HasKey(keys::kFileHandlerTitle) &&
       !handler_info.GetString(keys::kFileHandlerTitle, &handler.title)) {
-    *error = ASCIIToUTF16(errors::kInvalidFileHandlerTitle);
+    *error = base::ASCIIToUTF16(errors::kInvalidFileHandlerTitle);
     return false;
   }
 
@@ -115,7 +115,7 @@ bool FileHandlersParser::Parse(Extension* extension, base::string16* error) {
   const base::DictionaryValue* all_handlers = NULL;
   if (!extension->manifest()->GetDictionary(keys::kFileHandlers,
                                             &all_handlers)) {
-    *error = ASCIIToUTF16(errors::kInvalidFileHandlers);
+    *error = base::ASCIIToUTF16(errors::kInvalidFileHandlers);
     return false;
   }
 
@@ -129,7 +129,7 @@ bool FileHandlersParser::Parse(Extension* extension, base::string16* error) {
       if (!LoadFileHandler(iter.key(), *handler, &info->file_handlers, error))
         return false;
     } else {
-      *error = ASCIIToUTF16(errors::kInvalidFileHandlers);
+      *error = base::ASCIIToUTF16(errors::kInvalidFileHandlers);
       return false;
     }
   }
@@ -144,7 +144,7 @@ bool FileHandlersParser::Parse(Extension* extension, base::string16* error) {
   }
 
   if (filterCount > kMaxTypeAndExtensionHandlers) {
-    *error = ASCIIToUTF16(
+    *error = base::ASCIIToUTF16(
         errors::kInvalidFileHandlersTooManyTypesAndExtensions);
     return false;
   }
diff --git a/chrome/common/extensions/api/i18n/default_locale_handler.cc b/chrome/common/extensions/api/i18n/default_locale_handler.cc
index 5bf98a5..1f0c304 100644
--- a/chrome/common/extensions/api/i18n/default_locale_handler.cc
+++ b/chrome/common/extensions/api/i18n/default_locale_handler.cc
@@ -41,7 +41,7 @@ bool DefaultLocaleHandler::Parse(Extension* extension, base::string16* error) {
   if (!extension->manifest()->GetString(keys::kDefaultLocale,
                                         &info->default_locale) ||
       !l10n_util::IsValidLocaleSyntax(info->default_locale)) {
-    *error = ASCIIToUTF16(manifest_errors::kInvalidDefaultLocale);
+    *error = base::ASCIIToUTF16(manifest_errors::kInvalidDefaultLocale);
     return false;
   }
   extension->SetManifestData(keys::kDefaultLocale, info.release());
@@ -90,7 +90,7 @@ bool DefaultLocaleHandler::Validate(
     if (!base::PathExists(messages_path)) {
       *error = base::StringPrintf(
           "%s %s", errors::kLocalesMessagesFileMissing,
-          UTF16ToUTF8(messages_path.LossyDisplayName()).c_str());
+          base::UTF16ToUTF8(messages_path.LossyDisplayName()).c_str());
       return false;
     }
 
diff --git a/chrome/common/extensions/api/identity/oauth2_manifest_handler.cc b/chrome/common/extensions/api/identity/oauth2_manifest_handler.cc
index e4af424..0d4f304 100644
--- a/chrome/common/extensions/api/identity/oauth2_manifest_handler.cc
+++ b/chrome/common/extensions/api/identity/oauth2_manifest_handler.cc
@@ -49,7 +49,7 @@ bool OAuth2ManifestHandler::Parse(Extension* extension,
   scoped_ptr<OAuth2Info> info(new OAuth2Info);
   const base::DictionaryValue* dict = NULL;
   if (!extension->manifest()->GetDictionary(keys::kOAuth2, &dict)) {
-    *error = ASCIIToUTF16(errors::kInvalidOAuth2ClientId);
+    *error = base::ASCIIToUTF16(errors::kInvalidOAuth2ClientId);
     return false;
   }
 
@@ -59,7 +59,7 @@ bool OAuth2ManifestHandler::Parse(Extension* extension,
   // duplicate checking.
   if (extension->manifest()->HasPath(keys::kOAuth2AutoApprove) &&
       !dict->GetBoolean(kAutoApprove, &info->auto_approve)) {
-    *error = ASCIIToUTF16(errors::kInvalidOAuth2AutoApprove);
+    *error = base::ASCIIToUTF16(errors::kInvalidOAuth2AutoApprove);
     return false;
   }
 
@@ -68,20 +68,20 @@ bool OAuth2ManifestHandler::Parse(Extension* extension,
   if ((!dict->GetString(kClientId, &info->client_id) ||
        info->client_id.empty()) &&
       (extension->location() != Manifest::COMPONENT || !info->auto_approve)) {
-    *error = ASCIIToUTF16(errors::kInvalidOAuth2ClientId);
+    *error = base::ASCIIToUTF16(errors::kInvalidOAuth2ClientId);
     return false;
   }
 
   const base::ListValue* list = NULL;
   if (!dict->GetList(kScopes, &list)) {
-    *error = ASCIIToUTF16(errors::kInvalidOAuth2Scopes);
+    *error = base::ASCIIToUTF16(errors::kInvalidOAuth2Scopes);
     return false;
   }
 
   for (size_t i = 0; i < list->GetSize(); ++i) {
     std::string scope;
     if (!list->GetString(i, &scope)) {
-      *error = ASCIIToUTF16(errors::kInvalidOAuth2Scopes);
+      *error = base::ASCIIToUTF16(errors::kInvalidOAuth2Scopes);
       return false;
     }
     info->scopes.push_back(scope);
diff --git a/chrome/common/extensions/api/input_ime/input_components_handler.cc b/chrome/common/extensions/api/input_ime/input_components_handler.cc
index fa869cc..67a1c95 100644
--- a/chrome/common/extensions/api/input_ime/input_components_handler.cc
+++ b/chrome/common/extensions/api/input_ime/input_components_handler.cc
@@ -51,7 +51,7 @@ bool InputComponentsHandler::Parse(Extension* extension,
   scoped_ptr<InputComponents> info(new InputComponents);
   const base::ListValue* list_value = NULL;
   if (!extension->manifest()->GetList(keys::kInputComponents, &list_value)) {
-    *error = ASCIIToUTF16(errors::kInvalidInputComponents);
+    *error = base::ASCIIToUTF16(errors::kInvalidInputComponents);
     return false;
   }
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
@@ -69,7 +69,7 @@ bool InputComponentsHandler::Parse(Extension* extension,
     bool shortcut_shift = false;
 
     if (!list_value->GetDictionary(i, &module_value)) {
-      *error = ASCIIToUTF16(errors::kInvalidInputComponents);
+      *error = base::ASCIIToUTF16(errors::kInvalidInputComponents);
       return false;
     }
 
diff --git a/chrome/common/extensions/api/managed_mode_private/managed_mode_handler.cc b/chrome/common/extensions/api/managed_mode_private/managed_mode_handler.cc
index 1fbebd0..90905bb 100644
--- a/chrome/common/extensions/api/managed_mode_private/managed_mode_handler.cc
+++ b/chrome/common/extensions/api/managed_mode_private/managed_mode_handler.cc
@@ -52,7 +52,7 @@ bool ManagedModeHandler::Parse(Extension* extension, base::string16* error) {
   const base::DictionaryValue* content_pack_value = NULL;
   if (!extension->manifest()->GetDictionary(keys::kContentPack,
                                             &content_pack_value)) {
-    *error = ASCIIToUTF16(manifest_errors::kInvalidContentPack);
+    *error = base::ASCIIToUTF16(manifest_errors::kInvalidContentPack);
     return false;
   }
 
@@ -79,7 +79,7 @@ bool ManagedModeHandler::LoadSites(
   base::FilePath::StringType site_list_string;
   if (!content_pack_value->GetString(keys::kContentPackSites,
                                      &site_list_string)) {
-    *error = ASCIIToUTF16(manifest_errors::kInvalidContentPackSites);
+    *error = base::ASCIIToUTF16(manifest_errors::kInvalidContentPackSites);
     return false;
   }
 
diff --git a/chrome/common/extensions/api/media_galleries_private/media_galleries_handler.cc b/chrome/common/extensions/api/media_galleries_private/media_galleries_handler.cc
index 00bef60..a973036 100644
--- a/chrome/common/extensions/api/media_galleries_private/media_galleries_handler.cc
+++ b/chrome/common/extensions/api/media_galleries_private/media_galleries_handler.cc
@@ -44,7 +44,7 @@ MediaGalleriesHandler* LoadMediaGalleriesHandler(
   // Read the file action |id| (mandatory).
   if (!media_galleries_handler->HasKey(keys::kPageActionId) ||
       !media_galleries_handler->GetString(keys::kPageActionId, &handler_id)) {
-    *error = ASCIIToUTF16(errors::kInvalidPageActionId);
+    *error = base::ASCIIToUTF16(errors::kInvalidPageActionId);
     return NULL;
   }
   result->set_id(handler_id);
@@ -54,7 +54,7 @@ MediaGalleriesHandler* LoadMediaGalleriesHandler(
   if (!media_galleries_handler->HasKey(keys::kPageActionDefaultTitle) ||
       !media_galleries_handler->GetString(keys::kPageActionDefaultTitle,
                                           &title)) {
-    *error = ASCIIToUTF16(errors::kInvalidPageActionDefaultTitle);
+    *error = base::ASCIIToUTF16(errors::kInvalidPageActionDefaultTitle);
     return NULL;
   }
   result->set_title(title);
@@ -65,7 +65,7 @@ MediaGalleriesHandler* LoadMediaGalleriesHandler(
     if (!media_galleries_handler->GetString(
             keys::kPageActionDefaultIcon, &default_icon) ||
         default_icon.empty()) {
-      *error = ASCIIToUTF16(errors::kInvalidPageActionIconPath);
+      *error = base::ASCIIToUTF16(errors::kInvalidPageActionIconPath);
       return NULL;
     }
     result->set_icon_path(default_icon);
@@ -85,7 +85,7 @@ bool LoadMediaGalleriesHandlers(
        iter != extension_actions->end();
        ++iter) {
     if (!(*iter)->IsType(base::Value::TYPE_DICTIONARY)) {
-      *error = ASCIIToUTF16(errors::kInvalidMediaGalleriesHandler);
+      *error = base::ASCIIToUTF16(errors::kInvalidMediaGalleriesHandler);
       return false;
     }
     scoped_ptr<MediaGalleriesHandler> action(
@@ -128,7 +128,7 @@ bool MediaGalleriesHandlerParser::Parse(extensions::Extension* extension,
   const base::ListValue* media_galleries_handlers_value = NULL;
   if (!extension->manifest()->GetList(keys::kMediaGalleriesHandlers,
                                       &media_galleries_handlers_value)) {
-    *error = ASCIIToUTF16(errors::kInvalidMediaGalleriesHandler);
+    *error = base::ASCIIToUTF16(errors::kInvalidMediaGalleriesHandler);
     return false;
   }
   scoped_ptr<MediaGalleriesHandlerInfo> info(new MediaGalleriesHandlerInfo);
diff --git a/chrome/common/extensions/api/omnibox/omnibox_handler.cc b/chrome/common/extensions/api/omnibox/omnibox_handler.cc
index e43a5a6..a934e70 100644
--- a/chrome/common/extensions/api/omnibox/omnibox_handler.cc
+++ b/chrome/common/extensions/api/omnibox/omnibox_handler.cc
@@ -41,7 +41,7 @@ bool OmniboxHandler::Parse(Extension* extension, base::string16* error) {
                                             &dict) ||
       !dict->GetString(kKeyword, &info->keyword) ||
       info->keyword.empty()) {
-    *error = ASCIIToUTF16(manifest_errors::kInvalidOmniboxKeyword);
+    *error = base::ASCIIToUTF16(manifest_errors::kInvalidOmniboxKeyword);
     return false;
   }
   extension->SetManifestData(manifest_keys::kOmnibox, info.release());
diff --git a/chrome/common/extensions/api/plugins/plugins_handler.cc b/chrome/common/extensions/api/plugins/plugins_handler.cc
index e7834c1..6e8c77f 100644
--- a/chrome/common/extensions/api/plugins/plugins_handler.cc
+++ b/chrome/common/extensions/api/plugins/plugins_handler.cc
@@ -69,7 +69,7 @@ const std::vector<std::string> PluginsHandler::Keys() const {
 bool PluginsHandler::Parse(Extension* extension, base::string16* error) {
   const base::ListValue* list_value = NULL;
   if (!extension->manifest()->GetList(keys::kPlugins, &list_value)) {
-    *error = ASCIIToUTF16(manifest_errors::kInvalidPlugins);
+    *error = base::ASCIIToUTF16(manifest_errors::kInvalidPlugins);
     return false;
   }
 
@@ -78,7 +78,7 @@ bool PluginsHandler::Parse(Extension* extension, base::string16* error) {
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
     const base::DictionaryValue* plugin_value = NULL;
     if (!list_value->GetDictionary(i, &plugin_value)) {
-      *error = ASCIIToUTF16(manifest_errors::kInvalidPlugins);
+      *error = base::ASCIIToUTF16(manifest_errors::kInvalidPlugins);
       return false;
     }
     // Get plugins[i].path.
diff --git a/chrome/common/extensions/api/sockets/sockets_manifest_permission.cc b/chrome/common/extensions/api/sockets/sockets_manifest_permission.cc
index 6819861..61dc719 100644
--- a/chrome/common/extensions/api/sockets/sockets_manifest_permission.cc
+++ b/chrome/common/extensions/api/sockets/sockets_manifest_permission.cc
@@ -324,7 +324,7 @@ void SocketsManifestPermission::AddSubdomainHostMessage(
   for (SocketPermissionEntrySet::const_iterator it = permissions_.begin();
       it != permissions_.end(); ++it) {
     if (it->GetHostType() == SocketPermissionEntry::HOSTS_IN_DOMAINS)
-      domains.insert(UTF8ToUTF16(it->pattern().host));
+      domains.insert(base::UTF8ToUTF16(it->pattern().host));
   }
   if (!domains.empty()) {
     int id = (domains.size() == 1) ?
@@ -346,7 +346,7 @@ void SocketsManifestPermission::AddSpecificHostMessage(
   for (SocketPermissionEntrySet::const_iterator it = permissions_.begin();
     it != permissions_.end(); ++it) {
     if (it->GetHostType() == SocketPermissionEntry::SPECIFIC_HOSTS)
-      hostnames.insert(UTF8ToUTF16(it->pattern().host));
+      hostnames.insert(base::UTF8ToUTF16(it->pattern().host));
   }
   if (!hostnames.empty()) {
     int id = (hostnames.size() == 1) ?
diff --git a/chrome/common/extensions/api/speech/tts_engine_manifest_handler.cc b/chrome/common/extensions/api/speech/tts_engine_manifest_handler.cc
index 0dd93fb..9919962 100644
--- a/chrome/common/extensions/api/speech/tts_engine_manifest_handler.cc
+++ b/chrome/common/extensions/api/speech/tts_engine_manifest_handler.cc
@@ -52,7 +52,7 @@ bool TtsEngineManifestHandler::Parse(Extension* extension,
   scoped_ptr<TtsVoices> info(new TtsVoices);
   const base::DictionaryValue* tts_dict = NULL;
   if (!extension->manifest()->GetDictionary(keys::kTtsEngine, &tts_dict)) {
-    *error = ASCIIToUTF16(errors::kInvalidTts);
+    *error = base::ASCIIToUTF16(errors::kInvalidTts);
     return false;
   }
 
@@ -61,14 +61,14 @@ bool TtsEngineManifestHandler::Parse(Extension* extension,
 
   const base::ListValue* tts_voices = NULL;
   if (!tts_dict->GetList(keys::kTtsVoices, &tts_voices)) {
-    *error = ASCIIToUTF16(errors::kInvalidTtsVoices);
+    *error = base::ASCIIToUTF16(errors::kInvalidTtsVoices);
     return false;
   }
 
   for (size_t i = 0; i < tts_voices->GetSize(); i++) {
     const base::DictionaryValue* one_tts_voice = NULL;
     if (!tts_voices->GetDictionary(i, &one_tts_voice)) {
-      *error = ASCIIToUTF16(errors::kInvalidTtsVoices);
+      *error = base::ASCIIToUTF16(errors::kInvalidTtsVoices);
       return false;
     }
 
@@ -76,7 +76,7 @@ bool TtsEngineManifestHandler::Parse(Extension* extension,
     if (one_tts_voice->HasKey(keys::kTtsVoicesVoiceName)) {
       if (!one_tts_voice->GetString(
               keys::kTtsVoicesVoiceName, &voice_data.voice_name)) {
-        *error = ASCIIToUTF16(errors::kInvalidTtsVoicesVoiceName);
+        *error = base::ASCIIToUTF16(errors::kInvalidTtsVoicesVoiceName);
         return false;
       }
     }
@@ -84,7 +84,7 @@ bool TtsEngineManifestHandler::Parse(Extension* extension,
       if (!one_tts_voice->GetString(
               keys::kTtsVoicesLang, &voice_data.lang) ||
           !l10n_util::IsValidLocaleSyntax(voice_data.lang)) {
-        *error = ASCIIToUTF16(errors::kInvalidTtsVoicesLang);
+        *error = base::ASCIIToUTF16(errors::kInvalidTtsVoicesLang);
         return false;
       }
     }
@@ -93,14 +93,14 @@ bool TtsEngineManifestHandler::Parse(Extension* extension,
               keys::kTtsVoicesGender, &voice_data.gender) ||
           (voice_data.gender != keys::kTtsGenderMale &&
            voice_data.gender != keys::kTtsGenderFemale)) {
-        *error = ASCIIToUTF16(errors::kInvalidTtsVoicesGender);
+        *error = base::ASCIIToUTF16(errors::kInvalidTtsVoicesGender);
         return false;
       }
     }
     if (one_tts_voice->HasKey(keys::kTtsVoicesRemote)) {
       if (!one_tts_voice->GetBoolean(
               keys::kTtsVoicesRemote, &voice_data.remote)) {
-        *error = ASCIIToUTF16(errors::kInvalidTtsVoicesRemote);
+        *error = base::ASCIIToUTF16(errors::kInvalidTtsVoicesRemote);
         return false;
       }
     }
@@ -109,14 +109,14 @@ bool TtsEngineManifestHandler::Parse(Extension* extension,
       if (!one_tts_voice->GetList(
               keys::kTtsVoicesEventTypes,
               &event_types_list)) {
-        *error = ASCIIToUTF16(
+        *error = base::ASCIIToUTF16(
             errors::kInvalidTtsVoicesEventTypes);
         return false;
       }
       for (size_t i = 0; i < event_types_list->GetSize(); i++) {
         std::string event_type;
         if (!event_types_list->GetString(i, &event_type)) {
-          *error = ASCIIToUTF16(errors::kInvalidTtsVoicesEventTypes);
+          *error = base::ASCIIToUTF16(errors::kInvalidTtsVoicesEventTypes);
           return false;
         }
         if (event_type != keys::kTtsVoicesEventTypeEnd &&
@@ -125,12 +125,12 @@ bool TtsEngineManifestHandler::Parse(Extension* extension,
             event_type != keys::kTtsVoicesEventTypeSentence &&
             event_type != keys::kTtsVoicesEventTypeStart &&
             event_type != keys::kTtsVoicesEventTypeWord) {
-          *error = ASCIIToUTF16(errors::kInvalidTtsVoicesEventTypes);
+          *error = base::ASCIIToUTF16(errors::kInvalidTtsVoicesEventTypes);
           return false;
         }
         if (voice_data.event_types.find(event_type) !=
             voice_data.event_types.end()) {
-          *error = ASCIIToUTF16(errors::kInvalidTtsVoicesEventTypes);
+          *error = base::ASCIIToUTF16(errors::kInvalidTtsVoicesEventTypes);
           return false;
         }
         voice_data.event_types.insert(event_type);
diff --git a/chrome/common/extensions/api/spellcheck/spellcheck_handler.cc b/chrome/common/extensions/api/spellcheck/spellcheck_handler.cc
index 1ca1479..53d4acf 100644
--- a/chrome/common/extensions/api/spellcheck/spellcheck_handler.cc
+++ b/chrome/common/extensions/api/spellcheck/spellcheck_handler.cc
@@ -28,7 +28,7 @@ bool SpellcheckHandler::Parse(Extension* extension, base::string16* error) {
   const base::DictionaryValue* spellcheck_value = NULL;
   if (!extension->manifest()->GetDictionary(keys::kSpellcheck,
                                             &spellcheck_value)) {
-    *error = ASCIIToUTF16(errors::kInvalidSpellcheck);
+    *error = base::ASCIIToUTF16(errors::kInvalidSpellcheck);
     return false;
   }
   scoped_ptr<SpellcheckDictionaryInfo> spellcheck_info(
@@ -36,25 +36,25 @@ bool SpellcheckHandler::Parse(Extension* extension, base::string16* error) {
   if (!spellcheck_value->HasKey(keys::kSpellcheckDictionaryLanguage) ||
       !spellcheck_value->GetString(keys::kSpellcheckDictionaryLanguage,
                                   &spellcheck_info->language)) {
-    *error = ASCIIToUTF16(errors::kInvalidSpellcheckDictionaryLanguage);
+    *error = base::ASCIIToUTF16(errors::kInvalidSpellcheckDictionaryLanguage);
     return false;
   }
   if (!spellcheck_value->HasKey(keys::kSpellcheckDictionaryLocale) ||
       !spellcheck_value->GetString(keys::kSpellcheckDictionaryLocale,
                                   &spellcheck_info->locale)) {
-    *error = ASCIIToUTF16(errors::kInvalidSpellcheckDictionaryLocale);
+    *error = base::ASCIIToUTF16(errors::kInvalidSpellcheckDictionaryLocale);
     return false;
   }
   if (!spellcheck_value->HasKey(keys::kSpellcheckDictionaryFormat) ||
       !spellcheck_value->GetString(keys::kSpellcheckDictionaryFormat,
                                   &spellcheck_info->format)) {
-    *error = ASCIIToUTF16(errors::kInvalidSpellcheckDictionaryFormat);
+    *error = base::ASCIIToUTF16(errors::kInvalidSpellcheckDictionaryFormat);
     return false;
   }
   if (!spellcheck_value->HasKey(keys::kSpellcheckDictionaryPath) ||
       !spellcheck_value->GetString(keys::kSpellcheckDictionaryPath,
                                   &spellcheck_info->path)) {
-    *error = ASCIIToUTF16(errors::kInvalidSpellcheckDictionaryPath);
+    *error = base::ASCIIToUTF16(errors::kInvalidSpellcheckDictionaryPath);
     return false;
   }
   extension->SetManifestData(keys::kSpellcheck, spellcheck_info.release());
diff --git a/chrome/common/extensions/api/storage/storage_schema_manifest_handler.cc b/chrome/common/extensions/api/storage/storage_schema_manifest_handler.cc
index ca99da1..bbb8164 100644
--- a/chrome/common/extensions/api/storage/storage_schema_manifest_handler.cc
+++ b/chrome/common/extensions/api/storage/storage_schema_manifest_handler.cc
@@ -66,7 +66,7 @@ bool StorageSchemaManifestHandler::Parse(Extension* extension,
                                          base::string16* error) {
   std::string path;
   if (!extension->manifest()->GetString(kStorageManagedSchema, &path)) {
-    *error = ASCIIToUTF16(
+    *error = base::ASCIIToUTF16(
         base::StringPrintf("%s must be a string", kStorageManagedSchema));
     return false;
   }
diff --git a/chrome/common/extensions/api/system_indicator/system_indicator_handler.cc b/chrome/common/extensions/api/system_indicator/system_indicator_handler.cc
index 28db8cc..f3fcdf0 100644
--- a/chrome/common/extensions/api/system_indicator/system_indicator_handler.cc
+++ b/chrome/common/extensions/api/system_indicator/system_indicator_handler.cc
@@ -26,7 +26,7 @@ bool SystemIndicatorHandler::Parse(Extension* extension,
   const base::DictionaryValue* system_indicator_value = NULL;
   if (!extension->manifest()->GetDictionary(
           manifest_keys::kSystemIndicator, &system_indicator_value)) {
-    *error = ASCIIToUTF16(manifest_errors::kInvalidSystemIndicator);
+    *error = base::ASCIIToUTF16(manifest_errors::kInvalidSystemIndicator);
     return false;
   }
 
diff --git a/chrome/common/extensions/api/url_handlers/url_handlers_parser.cc b/chrome/common/extensions/api/url_handlers/url_handlers_parser.cc
index aa1cd3b..898547f 100644
--- a/chrome/common/extensions/api/url_handlers/url_handlers_parser.cc
+++ b/chrome/common/extensions/api/url_handlers/url_handlers_parser.cc
@@ -98,7 +98,7 @@ bool ParseUrlHandler(const std::string& handler_id,
   handler.id = handler_id;
 
   if (!handler_info.GetString(mkeys::kUrlHandlerTitle, &handler.title)) {
-    *error = ASCIIToUTF16(merrors::kInvalidURLHandlerTitle);
+    *error = base::ASCIIToUTF16(merrors::kInvalidURLHandlerTitle);
     return false;
   }
 
@@ -137,7 +137,7 @@ bool UrlHandlersParser::Parse(Extension* extension, base::string16* error) {
   const base::DictionaryValue* all_handlers = NULL;
   if (!extension->manifest()->GetDictionary(
         mkeys::kUrlHandlers, &all_handlers)) {
-    *error = ASCIIToUTF16(merrors::kInvalidURLHandlers);
+    *error = base::ASCIIToUTF16(merrors::kInvalidURLHandlers);
     return false;
   }
 
@@ -148,7 +148,7 @@ bool UrlHandlersParser::Parse(Extension* extension, base::string16* error) {
     // A URL handler entry is a title and a list of URL patterns to handle.
     const base::DictionaryValue* handler = NULL;
     if (!iter.value().GetAsDictionary(&handler)) {
-      *error = ASCIIToUTF16(merrors::kInvalidURLHandlerPatternElement);
+      *error = base::ASCIIToUTF16(merrors::kInvalidURLHandlerPatternElement);
       return false;
     }
 
diff --git a/chrome/common/extensions/extension_file_util.cc b/chrome/common/extensions/extension_file_util.cc
index bbc3e88..7272879 100644
--- a/chrome/common/extensions/extension_file_util.cc
+++ b/chrome/common/extensions/extension_file_util.cc
@@ -247,7 +247,7 @@ bool ValidateExtensionIconSet(const ExtensionIconSet& icon_set,
         extension->GetResource(iter->second).GetFilePath();
     if (!ValidateFilePath(path)) {
       *error = l10n_util::GetStringFUTF8(error_message_id,
-                                         UTF8ToUTF16(iter->second));
+                                         base::UTF8ToUTF16(iter->second));
       return false;
     }
   }
diff --git a/chrome/common/extensions/extension_file_util_unittest.cc b/chrome/common/extensions/extension_file_util_unittest.cc
index 71db8c9..bf54149 100644
--- a/chrome/common/extensions/extension_file_util_unittest.cc
+++ b/chrome/common/extensions/extension_file_util_unittest.cc
@@ -311,7 +311,8 @@ TEST_F(ExtensionFileUtilTest, BackgroundScriptsMustExist) {
   EXPECT_FALSE(extension_file_util::ValidateExtension(
       extension.get(), &error, &warnings));
   EXPECT_EQ(l10n_util::GetStringFUTF8(
-      IDS_EXTENSION_LOAD_BACKGROUND_SCRIPT_FAILED, ASCIIToUTF16("foo.js")),
+      IDS_EXTENSION_LOAD_BACKGROUND_SCRIPT_FAILED,
+      base::ASCIIToUTF16("foo.js")),
            error);
   EXPECT_EQ(0U, warnings.size());
 
@@ -327,7 +328,7 @@ TEST_F(ExtensionFileUtilTest, BackgroundScriptsMustExist) {
       extension.get(), &error, &warnings));
   EXPECT_EQ(l10n_util::GetStringFUTF8(
       IDS_EXTENSION_LOAD_BACKGROUND_SCRIPT_FAILED,
-      ASCIIToUTF16("http://google.com/foo.js")),
+      base::ASCIIToUTF16("http://google.com/foo.js")),
            error);
   EXPECT_EQ(0U, warnings.size());
 }
diff --git a/chrome/common/extensions/extension_l10n_util.cc b/chrome/common/extensions/extension_l10n_util.cc
index d946e19..bc3c229 100644
--- a/chrome/common/extensions/extension_l10n_util.cc
+++ b/chrome/common/extensions/extension_l10n_util.cc
@@ -50,7 +50,7 @@ base::DictionaryValue* LoadMessageFile(const base::FilePath& locale_path,
     } else {
       *error = extensions::ErrorUtils::FormatErrorMessage(
           errors::kLocalesInvalidLocale,
-          UTF16ToUTF8(file.LossyDisplayName()),
+          base::UTF16ToUTF8(file.LossyDisplayName()),
           *error);
     }
   }
diff --git a/chrome/common/extensions/extension_l10n_util_unittest.cc b/chrome/common/extensions/extension_l10n_util_unittest.cc
index 031a0f0..74f4645 100644
--- a/chrome/common/extensions/extension_l10n_util_unittest.cc
+++ b/chrome/common/extensions/extension_l10n_util_unittest.cc
@@ -48,7 +48,7 @@ TEST(ExtensionL10nUtil, ValidateLocalesWithBadLocale) {
       temp.path(), &manifest, &error));
   EXPECT_THAT(error,
               testing::HasSubstr(
-                  UTF16ToUTF8(messages_file.LossyDisplayName())));
+                  base::UTF16ToUTF8(messages_file.LossyDisplayName())));
 }
 
 TEST(ExtensionL10nUtil, GetValidLocalesEmptyLocaleFolder) {
diff --git a/chrome/common/extensions/manifest_handlers/app_isolation_info.cc b/chrome/common/extensions/manifest_handlers/app_isolation_info.cc
index 212f7c2..74de087 100644
--- a/chrome/common/extensions/manifest_handlers/app_isolation_info.cc
+++ b/chrome/common/extensions/manifest_handlers/app_isolation_info.cc
@@ -59,7 +59,7 @@ bool AppIsolationHandler::Parse(Extension* extension, base::string16* error) {
 
   const base::ListValue* isolation_list = NULL;
   if (!extension->manifest()->GetList(keys::kIsolation, &isolation_list)) {
-    *error = ASCIIToUTF16(manifest_errors::kInvalidIsolation);
+    *error = base::ASCIIToUTF16(manifest_errors::kInvalidIsolation);
     return false;
   }
 
diff --git a/chrome/common/extensions/manifest_handlers/app_launch_info.cc b/chrome/common/extensions/manifest_handlers/app_launch_info.cc
index 1a09122..a3b3ac5 100644
--- a/chrome/common/extensions/manifest_handlers/app_launch_info.cc
+++ b/chrome/common/extensions/manifest_handlers/app_launch_info.cc
@@ -118,12 +118,12 @@ bool AppLaunchInfo::LoadLaunchURL(Extension* extension, base::string16* error) {
   // web URL.
   if (extension->manifest()->Get(keys::kLaunchLocalPath, &temp)) {
     if (extension->manifest()->Get(keys::kLaunchWebURL, NULL)) {
-      *error = ASCIIToUTF16(errors::kLaunchPathAndURLAreExclusive);
+      *error = base::ASCIIToUTF16(errors::kLaunchPathAndURLAreExclusive);
       return false;
     }
 
     if (extension->manifest()->Get(keys::kWebURLs, NULL)) {
-      *error = ASCIIToUTF16(errors::kLaunchPathAndExtentAreExclusive);
+      *error = base::ASCIIToUTF16(errors::kLaunchPathAndExtentAreExclusive);
       return false;
     }
 
@@ -166,7 +166,7 @@ bool AppLaunchInfo::LoadLaunchURL(Extension* extension, base::string16* error) {
 
     launch_web_url_ = url;
   } else if (extension->is_legacy_packaged_app()) {
-    *error = ASCIIToUTF16(errors::kLaunchURLRequired);
+    *error = base::ASCIIToUTF16(errors::kLaunchURLRequired);
     return false;
   }
 
@@ -233,7 +233,7 @@ bool AppLaunchInfo::LoadLaunchContainer(Extension* extension,
 
   std::string launch_container_string;
   if (!tmp_launcher_container->GetAsString(&launch_container_string)) {
-    *error = ASCIIToUTF16(errors::kInvalidLaunchContainer);
+    *error = base::ASCIIToUTF16(errors::kInvalidLaunchContainer);
     return false;
   }
 
@@ -242,7 +242,7 @@ bool AppLaunchInfo::LoadLaunchContainer(Extension* extension,
   } else if (launch_container_string == values::kLaunchContainerTab) {
     launch_container_ = LAUNCH_CONTAINER_TAB;
   } else {
-    *error = ASCIIToUTF16(errors::kInvalidLaunchContainer);
+    *error = base::ASCIIToUTF16(errors::kInvalidLaunchContainer);
     return false;
   }
 
diff --git a/chrome/common/extensions/manifest_handlers/content_scripts_handler.cc b/chrome/common/extensions/manifest_handlers/content_scripts_handler.cc
index 9147772..bd4d6cd 100644
--- a/chrome/common/extensions/manifest_handlers/content_scripts_handler.cc
+++ b/chrome/common/extensions/manifest_handlers/content_scripts_handler.cc
@@ -384,7 +384,7 @@ bool ContentScriptsHandler::Parse(Extension* extension, base::string16* error) {
   scoped_ptr<ContentScriptsInfo> content_scripts_info(new ContentScriptsInfo);
   const base::ListValue* scripts_list = NULL;
   if (!extension->manifest()->GetList(keys::kContentScripts, &scripts_list)) {
-    *error = ASCIIToUTF16(errors::kInvalidContentScriptsList);
+    *error = base::ASCIIToUTF16(errors::kInvalidContentScriptsList);
     return false;
   }
 
diff --git a/chrome/common/extensions/manifest_handlers/icons_handler.cc b/chrome/common/extensions/manifest_handlers/icons_handler.cc
index 779d59d..797562c 100644
--- a/chrome/common/extensions/manifest_handlers/icons_handler.cc
+++ b/chrome/common/extensions/manifest_handlers/icons_handler.cc
@@ -77,7 +77,7 @@ bool IconsHandler::Parse(Extension* extension, base::string16* error) {
   scoped_ptr<IconsInfo> icons_info(new IconsInfo);
   const base::DictionaryValue* icons_dict = NULL;
   if (!extension->manifest()->GetDictionary(keys::kIcons, &icons_dict)) {
-    *error = ASCIIToUTF16(manifest_errors::kInvalidIcons);
+    *error = base::ASCIIToUTF16(manifest_errors::kInvalidIcons);
     return false;
   }
 
diff --git a/chrome/common/extensions/manifest_handlers/minimum_chrome_version_checker.cc b/chrome/common/extensions/manifest_handlers/minimum_chrome_version_checker.cc
index e9d8cee..8f63db6 100644
--- a/chrome/common/extensions/manifest_handlers/minimum_chrome_version_checker.cc
+++ b/chrome/common/extensions/manifest_handlers/minimum_chrome_version_checker.cc
@@ -29,13 +29,13 @@ bool MinimumChromeVersionChecker::Parse(Extension* extension,
   std::string minimum_version_string;
   if (!extension->manifest()->GetString(keys::kMinimumChromeVersion,
                                         &minimum_version_string)) {
-    *error = ASCIIToUTF16(errors::kInvalidMinimumChromeVersion);
+    *error = base::ASCIIToUTF16(errors::kInvalidMinimumChromeVersion);
     return false;
   }
 
   base::Version minimum_version(minimum_version_string);
   if (!minimum_version.IsValid()) {
-    *error = ASCIIToUTF16(errors::kInvalidMinimumChromeVersion);
+    *error = base::ASCIIToUTF16(errors::kInvalidMinimumChromeVersion);
     return false;
   }
 
diff --git a/chrome/common/extensions/manifest_handlers/nacl_modules_handler.cc b/chrome/common/extensions/manifest_handlers/nacl_modules_handler.cc
index 9adae29..b6968b8 100644
--- a/chrome/common/extensions/manifest_handlers/nacl_modules_handler.cc
+++ b/chrome/common/extensions/manifest_handlers/nacl_modules_handler.cc
@@ -43,7 +43,7 @@ NaClModulesHandler::~NaClModulesHandler() {
 bool NaClModulesHandler::Parse(Extension* extension, base::string16* error) {
   const base::ListValue* list_value = NULL;
   if (!extension->manifest()->GetList(keys::kNaClModules, &list_value)) {
-    *error = ASCIIToUTF16(errors::kInvalidNaClModules);
+    *error = base::ASCIIToUTF16(errors::kInvalidNaClModules);
     return false;
   }
 
@@ -52,7 +52,7 @@ bool NaClModulesHandler::Parse(Extension* extension, base::string16* error) {
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
     const base::DictionaryValue* module_value = NULL;
     if (!list_value->GetDictionary(i, &module_value)) {
-      *error = ASCIIToUTF16(errors::kInvalidNaClModules);
+      *error = base::ASCIIToUTF16(errors::kInvalidNaClModules);
       return false;
     }
 
diff --git a/chrome/common/extensions/manifest_handlers/settings_overrides_handler.cc b/chrome/common/extensions/manifest_handlers/settings_overrides_handler.cc
index 844c981..33d4731 100644
--- a/chrome/common/extensions/manifest_handlers/settings_overrides_handler.cc
+++ b/chrome/common/extensions/manifest_handlers/settings_overrides_handler.cc
@@ -246,7 +246,8 @@ bool SettingsOverridesHandler::Parse(Extension* extension,
   info->startup_pages = ParseStartupPage(*settings, error);
   if (!info->bookmarks_ui && !info->homepage &&
       !info->search_engine && info->startup_pages.empty()) {
-    *error = ASCIIToUTF16(manifest_errors::kInvalidEmptySettingsOverrides);
+    *error =
+        base::ASCIIToUTF16(manifest_errors::kInvalidEmptySettingsOverrides);
     return false;
   }
   info->manifest_permission.reset(new ManifestPermissionImpl(
diff --git a/chrome/common/extensions/manifest_handlers/theme_handler.cc b/chrome/common/extensions/manifest_handlers/theme_handler.cc
index 6d1c536..139cfdd 100644
--- a/chrome/common/extensions/manifest_handlers/theme_handler.cc
+++ b/chrome/common/extensions/manifest_handlers/theme_handler.cc
@@ -37,16 +37,16 @@ bool LoadImages(const base::DictionaryValue* theme_value,
           for (base::DictionaryValue::Iterator inner_iter(*inner_value);
                !inner_iter.IsAtEnd(); inner_iter.Advance()) {
             if (!inner_iter.value().IsType(base::Value::TYPE_STRING)) {
-              *error = ASCIIToUTF16(errors::kInvalidThemeImages);
+              *error = base::ASCIIToUTF16(errors::kInvalidThemeImages);
               return false;
             }
           }
         } else {
-          *error = ASCIIToUTF16(errors::kInvalidThemeImages);
+          *error = base::ASCIIToUTF16(errors::kInvalidThemeImages);
           return false;
         }
       } else if (!iter.value().IsType(base::Value::TYPE_STRING)) {
-        *error = ASCIIToUTF16(errors::kInvalidThemeImages);
+        *error = base::ASCIIToUTF16(errors::kInvalidThemeImages);
         return false;
       }
     }
@@ -78,7 +78,7 @@ bool LoadColors(const base::DictionaryValue* theme_value,
           !color_list->GetInteger(0, &color) ||
           !color_list->GetInteger(1, &color) ||
           !color_list->GetInteger(2, &color)) {
-        *error = ASCIIToUTF16(errors::kInvalidThemeColors);
+        *error = base::ASCIIToUTF16(errors::kInvalidThemeColors);
         return false;
       }
     }
@@ -104,7 +104,7 @@ bool LoadTints(const base::DictionaryValue* theme_value,
         !tint_list->GetDouble(0, &v) ||
         !tint_list->GetDouble(1, &v) ||
         !tint_list->GetDouble(2, &v)) {
-      *error = ASCIIToUTF16(errors::kInvalidThemeTints);
+      *error = base::ASCIIToUTF16(errors::kInvalidThemeTints);
       return false;
     }
   }
@@ -170,7 +170,7 @@ ThemeHandler::~ThemeHandler() {
 bool ThemeHandler::Parse(Extension* extension, base::string16* error) {
   const base::DictionaryValue* theme_value = NULL;
   if (!extension->manifest()->GetDictionary(keys::kTheme, &theme_value)) {
-    *error = ASCIIToUTF16(errors::kInvalidTheme);
+    *error = base::ASCIIToUTF16(errors::kInvalidTheme);
     return false;
   }
 
diff --git a/chrome/common/extensions/manifest_tests/extension_manifests_initvalue_unittest.cc b/chrome/common/extensions/manifest_tests/extension_manifests_initvalue_unittest.cc
index f7fbab9..d47296f 100644
--- a/chrome/common/extensions/manifest_tests/extension_manifests_initvalue_unittest.cc
+++ b/chrome/common/extensions/manifest_tests/extension_manifests_initvalue_unittest.cc
@@ -153,16 +153,16 @@ TEST_F(InitValueManifestTest, InitFromValueValidNameInRTL) {
   scoped_refptr<Extension> extension(LoadAndExpectSuccess(
       "init_valid_name_no_rtl.json"));
 
-  base::string16 localized_name(ASCIIToUTF16("Dictionary (by Google)"));
+  base::string16 localized_name(base::ASCIIToUTF16("Dictionary (by Google)"));
   base::i18n::AdjustStringForLocaleDirection(&localized_name);
-  EXPECT_EQ(localized_name, UTF8ToUTF16(extension->name()));
+  EXPECT_EQ(localized_name, base::UTF8ToUTF16(extension->name()));
 
   // Strong RTL characters in name.
   extension = LoadAndExpectSuccess("init_valid_name_strong_rtl.json");
 
-  localized_name = WideToUTF16(L"Dictionary (\x05D1\x05D2" L" Google)");
+  localized_name = base::WideToUTF16(L"Dictionary (\x05D1\x05D2" L" Google)");
   base::i18n::AdjustStringForLocaleDirection(&localized_name);
-  EXPECT_EQ(localized_name, UTF8ToUTF16(extension->name()));
+  EXPECT_EQ(localized_name, base::UTF8ToUTF16(extension->name()));
 
   // Reset locale.
 #if defined(TOOLKIT_GTK)
diff --git a/chrome/common/extensions/manifest_url_handler.cc b/chrome/common/extensions/manifest_url_handler.cc
index e464c39..b1c1134 100644
--- a/chrome/common/extensions/manifest_url_handler.cc
+++ b/chrome/common/extensions/manifest_url_handler.cc
@@ -120,7 +120,7 @@ bool DevToolsPageHandler::Parse(Extension* extension, base::string16* error) {
   scoped_ptr<ManifestURL> manifest_url(new ManifestURL);
   std::string devtools_str;
   if (!extension->manifest()->GetString(keys::kDevToolsPage, &devtools_str)) {
-    *error = ASCIIToUTF16(errors::kInvalidDevToolsPage);
+    *error = base::ASCIIToUTF16(errors::kInvalidDevToolsPage);
     return false;
   }
   manifest_url->url_ = extension->GetResourceURL(devtools_str);
@@ -206,7 +206,7 @@ bool OptionsPageHandler::Parse(Extension* extension, base::string16* error) {
   scoped_ptr<ManifestURL> manifest_url(new ManifestURL);
   std::string options_str;
   if (!extension->manifest()->GetString(keys::kOptionsPage, &options_str)) {
-    *error = ASCIIToUTF16(errors::kInvalidOptionsPage);
+    *error = base::ASCIIToUTF16(errors::kInvalidOptionsPage);
     return false;
   }
 
@@ -215,19 +215,20 @@ bool OptionsPageHandler::Parse(Extension* extension, base::string16* error) {
     GURL options_url(options_str);
     if (!options_url.is_valid() ||
         !options_url.SchemeIsHTTPOrHTTPS()) {
-      *error = ASCIIToUTF16(errors::kInvalidOptionsPageInHostedApp);
+      *error = base::ASCIIToUTF16(errors::kInvalidOptionsPageInHostedApp);
       return false;
     }
     manifest_url->url_ = options_url;
   } else {
     GURL absolute(options_str);
     if (absolute.is_valid()) {
-      *error = ASCIIToUTF16(errors::kInvalidOptionsPageExpectUrlInPackage);
+      *error =
+          base::ASCIIToUTF16(errors::kInvalidOptionsPageExpectUrlInPackage);
       return false;
     }
     manifest_url->url_ = extension->GetResourceURL(options_str);
     if (!manifest_url->url_.is_valid()) {
-      *error = ASCIIToUTF16(errors::kInvalidOptionsPage);
+      *error = base::ASCIIToUTF16(errors::kInvalidOptionsPage);
       return false;
     }
   }
@@ -273,7 +274,7 @@ bool URLOverridesHandler::Parse(Extension* extension, base::string16* error) {
   const base::DictionaryValue* overrides = NULL;
   if (!extension->manifest()->GetDictionary(keys::kChromeURLOverrides,
                                             &overrides)) {
-    *error = ASCIIToUTF16(errors::kInvalidChromeURLOverrides);
+    *error = base::ASCIIToUTF16(errors::kInvalidChromeURLOverrides);
     return false;
   }
   scoped_ptr<URLOverrides> url_overrides(new URLOverrides);
@@ -300,7 +301,7 @@ bool URLOverridesHandler::Parse(Extension* extension, base::string16* error) {
 #endif
 
     if (is_override || !iter.value().GetAsString(&val)) {
-      *error = ASCIIToUTF16(errors::kInvalidChromeURLOverrides);
+      *error = base::ASCIIToUTF16(errors::kInvalidChromeURLOverrides);
       return false;
     }
     // Replace the entry with a fully qualified chrome-extension:// URL.
@@ -323,7 +324,7 @@ bool URLOverridesHandler::Parse(Extension* extension, base::string16* error) {
 
   // An extension may override at most one page.
   if (overrides->size() > 1) {
-    *error = ASCIIToUTF16(errors::kMultipleOverrides);
+    *error = base::ASCIIToUTF16(errors::kMultipleOverrides);
     return false;
   }
   extension->SetManifestData(keys::kChromeURLOverrides,
diff --git a/chrome/common/extensions/mime_types_handler.cc b/chrome/common/extensions/mime_types_handler.cc
index a4a664c..0fa2dcd 100644
--- a/chrome/common/extensions/mime_types_handler.cc
+++ b/chrome/common/extensions/mime_types_handler.cc
@@ -90,7 +90,7 @@ bool MimeTypesHandlerParser::Parse(extensions::Extension* extension,
   const base::ListValue* mime_types_value = NULL;
   if (!extension->manifest()->GetList(keys::kMIMETypes,
                                       &mime_types_value)) {
-    *error = ASCIIToUTF16(errors::kInvalidMimeTypesHandler);
+    *error = base::ASCIIToUTF16(errors::kInvalidMimeTypesHandler);
     return false;
   }
 
@@ -99,7 +99,7 @@ bool MimeTypesHandlerParser::Parse(extensions::Extension* extension,
   for (size_t i = 0; i < mime_types_value->GetSize(); ++i) {
     std::string filter;
     if (!mime_types_value->GetString(i, &filter)) {
-      *error = ASCIIToUTF16(errors::kInvalidMIMETypes);
+      *error = base::ASCIIToUTF16(errors::kInvalidMIMETypes);
       return false;
     }
     info->handler_.AddMIMEType(filter);
diff --git a/chrome/common/extensions/permissions/permission_message_util.cc b/chrome/common/extensions/permissions/permission_message_util.cc
index a5d925e..d7e0f78 100644
--- a/chrome/common/extensions/permissions/permission_message_util.cc
+++ b/chrome/common/extensions/permissions/permission_message_util.cc
@@ -48,20 +48,20 @@ PermissionMessage CreateFromHostList(const std::set<std::string>& hosts) {
     case 1:
       message_id = PermissionMessage::kHosts1;
       message = l10n_util::GetStringFUTF16(IDS_EXTENSION_PROMPT_WARNING_1_HOST,
-                                           UTF8ToUTF16(host_list[0]));
+                                           base::UTF8ToUTF16(host_list[0]));
       break;
     case 2:
       message_id = PermissionMessage::kHosts2;
       message = l10n_util::GetStringFUTF16(IDS_EXTENSION_PROMPT_WARNING_2_HOSTS,
-                                           UTF8ToUTF16(host_list[0]),
-                                           UTF8ToUTF16(host_list[1]));
+                                           base::UTF8ToUTF16(host_list[0]),
+                                           base::UTF8ToUTF16(host_list[1]));
       break;
     case 3:
       message_id = PermissionMessage::kHosts3;
       message = l10n_util::GetStringFUTF16(IDS_EXTENSION_PROMPT_WARNING_3_HOSTS,
-                                           UTF8ToUTF16(host_list[0]),
-                                           UTF8ToUTF16(host_list[1]),
-                                           UTF8ToUTF16(host_list[2]));
+                                           base::UTF8ToUTF16(host_list[0]),
+                                           base::UTF8ToUTF16(host_list[1]),
+                                           base::UTF8ToUTF16(host_list[2]));
       break;
     default:
       message_id = PermissionMessage::kHosts4OrMore;
@@ -82,10 +82,10 @@ PermissionMessage CreateFromHostList(const std::set<std::string>& hosts) {
 
       for (size_t i = 0; i < host_list.size(); ++i) {
         if (i > 0)
-          details += ASCIIToUTF16("\n");
+          details += base::ASCIIToUTF16("\n");
         details += l10n_util::GetStringFUTF16(
             IDS_EXTENSION_PROMPT_WARNING_HOST_LIST_ENTRY,
-            UTF8ToUTF16(host_list[i]));
+            base::UTF8ToUTF16(host_list[i]));
       }
   }
 
diff --git a/chrome/common/extensions/permissions/permission_set_unittest.cc b/chrome/common/extensions/permissions/permission_set_unittest.cc
index 3ef9ed5..8b448be 100644
--- a/chrome/common/extensions/permissions/permission_set_unittest.cc
+++ b/chrome/common/extensions/permissions/permission_set_unittest.cc
@@ -36,7 +36,7 @@ static void AddPattern(URLPatternSet* extent, const std::string& pattern) {
 size_t IndexOf(const std::vector<base::string16>& warnings,
                const std::string& warning) {
   for (size_t i = 0; i < warnings.size(); ++i) {
-    if (warnings[i] == ASCIIToUTF16(warning))
+    if (warnings[i] == base::ASCIIToUTF16(warning))
       return i;
   }
 
@@ -877,7 +877,7 @@ TEST(PermissionsTest, GetWarningMessages_ManyHosts) {
       PermissionsData::GetPermissionMessageStrings(extension.get());
   ASSERT_EQ(1u, warnings.size());
   EXPECT_EQ("Access your data on encrypted.google.com and www.google.com",
-            UTF16ToUTF8(warnings[0]));
+            base::UTF16ToUTF8(warnings[0]));
 }
 
 TEST(PermissionsTest, GetWarningMessages_Plugins) {
@@ -894,7 +894,7 @@ TEST(PermissionsTest, GetWarningMessages_Plugins) {
 #else
   ASSERT_EQ(1u, warnings.size());
   EXPECT_EQ("Access all data on your computer and the websites you visit",
-            UTF16ToUTF8(warnings[0]));
+            base::UTF16ToUTF8(warnings[0]));
 #endif
 }
 
@@ -1007,11 +1007,11 @@ TEST(PermissionsTest, GetWarningMessages_Socket_OneDomainTwoHostnames) {
   EXPECT_EQ(2u, warnings.size());
   if (warnings.size() > 0)
     EXPECT_EQ(warnings[0],
-              UTF8ToUTF16("Exchange data with any computer in the domain "
+              base::UTF8ToUTF16("Exchange data with any computer in the domain "
                           "example.org"));
   if (warnings.size() > 1)
     EXPECT_EQ(warnings[1],
-              UTF8ToUTF16("Exchange data with the computers named: "
+              base::UTF8ToUTF16("Exchange data with the computers named: "
                           "b\xC3\xA5r.example.com foo.example.com"));
                           // "\xC3\xA5" = UTF-8 for lowercase A with ring above
 }
@@ -1032,12 +1032,12 @@ TEST(PermissionsTest, GetWarningMessages_Socket_TwoDomainsOneHostname) {
   EXPECT_EQ(2u, warnings.size());
   if (warnings.size() > 0)
     EXPECT_EQ(warnings[0],
-              UTF8ToUTF16("Exchange data with any computer in the domains: "
-                           "example.com foo.example.org"));
+              base::UTF8ToUTF16("Exchange data with any computer in the "
+                                "domains: example.com foo.example.org"));
   if (warnings.size() > 1)
     EXPECT_EQ(warnings[1],
-              UTF8ToUTF16("Exchange data with the computer named "
-                           "bar.example.org"));
+              base::UTF8ToUTF16("Exchange data with the computer named "
+                                "bar.example.org"));
 }
 
 TEST(PermissionsTest, GetWarningMessages_PlatformApppHosts) {
diff --git a/chrome/common/extensions/permissions/settings_override_permission.cc b/chrome/common/extensions/permissions/settings_override_permission.cc
index 65f3f26..f5bf946 100644
--- a/chrome/common/extensions/permissions/settings_override_permission.cc
+++ b/chrome/common/extensions/permissions/settings_override_permission.cc
@@ -46,7 +46,8 @@ PermissionMessages SettingsOverrideAPIPermission::GetMessages() const {
   PermissionMessages result;
   result.push_back(PermissionMessage(
       info()->message_id(),
-      l10n_util::GetStringFUTF16(string_id, UTF8ToUTF16(setting_value_))));
+      l10n_util::GetStringFUTF16(string_id,
+                                 base::UTF8ToUTF16(setting_value_))));
   return result;
 }
 
diff --git a/chrome/common/extensions/permissions/settings_override_permission_unittest.cc b/chrome/common/extensions/permissions/settings_override_permission_unittest.cc
index d9e115e..6061759 100644
--- a/chrome/common/extensions/permissions/settings_override_permission_unittest.cc
+++ b/chrome/common/extensions/permissions/settings_override_permission_unittest.cc
@@ -71,7 +71,7 @@ TEST_F(SettingsOverridePermissionTest, HomePage) {
       PermissionsData::GetPermissionMessageStrings(extension.get());
   ASSERT_EQ(1u, warnings.size());
   EXPECT_EQ("Change your home page to: google.com/",
-            UTF16ToUTF8(warnings[0]));
+            base::UTF16ToUTF8(warnings[0]));
 
   EXPECT_FALSE(permission_set->HasAPIPermission(APIPermission::kStartupPages));
   EXPECT_FALSE(permission_set->HasAPIPermission(
@@ -88,7 +88,7 @@ TEST_F(SettingsOverridePermissionTest, SartupPages) {
       PermissionsData::GetPermissionMessageStrings(extension.get());
   ASSERT_EQ(1u, warnings.size());
   EXPECT_EQ("Change your start page to: startup.com/startup.html",
-            UTF16ToUTF8(warnings[0]));
+            base::UTF16ToUTF8(warnings[0]));
 
   EXPECT_FALSE(permission_set->HasAPIPermission(APIPermission::kHomepage));
   EXPECT_FALSE(permission_set->HasAPIPermission(
@@ -105,7 +105,7 @@ TEST_F(SettingsOverridePermissionTest, SearchSettings) {
       PermissionsData::GetPermissionMessageStrings(extension.get());
   ASSERT_EQ(1u, warnings.size());
   EXPECT_EQ("Change your search settings to: google.com",
-            UTF16ToUTF8(warnings[0]));
+            base::UTF16ToUTF8(warnings[0]));
 
   EXPECT_FALSE(permission_set->HasAPIPermission(APIPermission::kHomepage));
   EXPECT_FALSE(permission_set->HasAPIPermission(APIPermission::kStartupPages));
diff --git a/chrome/common/extensions/permissions/socket_permission.cc b/chrome/common/extensions/permissions/socket_permission.cc
index 5e8fd64..6c08127 100644
--- a/chrome/common/extensions/permissions/socket_permission.cc
+++ b/chrome/common/extensions/permissions/socket_permission.cc
@@ -55,7 +55,7 @@ void SocketPermission::AddSubdomainHostMessage(
   std::set<SocketPermissionData>::const_iterator i;
   for (i = data_set_.begin(); i != data_set_.end(); ++i) {
     if (i->entry().GetHostType() == SocketPermissionEntry::HOSTS_IN_DOMAINS)
-      domains.insert(UTF8ToUTF16(i->entry().pattern().host));
+      domains.insert(base::UTF8ToUTF16(i->entry().pattern().host));
   }
   if (!domains.empty()) {
     int id = (domains.size() == 1) ?
@@ -77,7 +77,7 @@ void SocketPermission::AddSpecificHostMessage(
   std::set<SocketPermissionData>::const_iterator i;
   for (i = data_set_.begin(); i != data_set_.end(); ++i) {
     if (i->entry().GetHostType() == SocketPermissionEntry::SPECIFIC_HOSTS)
-      hostnames.insert(UTF8ToUTF16(i->entry().pattern().host));
+      hostnames.insert(base::UTF8ToUTF16(i->entry().pattern().host));
   }
   if (!hostnames.empty()) {
     int id = (hostnames.size() == 1) ?
diff --git a/chrome/common/extensions/permissions/usb_device_permission.cc b/chrome/common/extensions/permissions/usb_device_permission.cc
index 3c13936..ee010ac 100644
--- a/chrome/common/extensions/permissions/usb_device_permission.cc
+++ b/chrome/common/extensions/permissions/usb_device_permission.cc
@@ -48,14 +48,14 @@ PermissionMessages UsbDevicePermission::GetMessages() const {
             PermissionMessage::kUsbDevice,
             l10n_util::GetStringFUTF16(
                 IDS_EXTENSION_PROMPT_WARNING_USB_DEVICE,
-                ASCIIToUTF16(product),
-                ASCIIToUTF16(vendor))));
+                base::ASCIIToUTF16(product),
+                base::ASCIIToUTF16(vendor))));
       } else {
         result.push_back(PermissionMessage(
             PermissionMessage::kUsbDevice,
             l10n_util::GetStringFUTF16(
                 IDS_EXTENSION_PROMPT_WARNING_USB_DEVICE_MISSING_PRODUCT,
-                ASCIIToUTF16(vendor))));
+                base::ASCIIToUTF16(vendor))));
       }
     } else {
       result.push_back(PermissionMessage(
diff --git a/chrome/common/extensions/permissions/usb_device_permission_unittest.cc b/chrome/common/extensions/permissions/usb_device_permission_unittest.cc
index a42ad3b..bb3ea70e 100644
--- a/chrome/common/extensions/permissions/usb_device_permission_unittest.cc
+++ b/chrome/common/extensions/permissions/usb_device_permission_unittest.cc
@@ -55,9 +55,9 @@ TEST(USBDevicePermissionTest, MAYBE_PermissionMessage) {
 
   PermissionMessages messages = permission.GetMessages();
   ASSERT_EQ(3U, messages.size());
-  EXPECT_EQ(ASCIIToUTF16(kMessages[0]), messages.at(0).message());
-  EXPECT_EQ(ASCIIToUTF16(kMessages[1]), messages.at(1).message());
-  EXPECT_EQ(ASCIIToUTF16(kMessages[2]), messages.at(2).message());
+  EXPECT_EQ(base::ASCIIToUTF16(kMessages[0]), messages.at(0).message());
+  EXPECT_EQ(base::ASCIIToUTF16(kMessages[1]), messages.at(1).message());
+  EXPECT_EQ(base::ASCIIToUTF16(kMessages[2]), messages.at(2).message());
 }
 
 }  // namespace extensions
diff --git a/chrome/common/extensions/web_accessible_resources_handler.cc b/chrome/common/extensions/web_accessible_resources_handler.cc
index fdd6e0e..bda7eca 100644
--- a/chrome/common/extensions/web_accessible_resources_handler.cc
+++ b/chrome/common/extensions/web_accessible_resources_handler.cc
@@ -67,7 +67,7 @@ bool WebAccessibleResourcesHandler::Parse(Extension* extension,
   const base::ListValue* list_value = NULL;
   if (!extension->manifest()->GetList(keys::kWebAccessibleResources,
                                       &list_value)) {
-    *error = ASCIIToUTF16(errors::kInvalidWebAccessibleResourcesList);
+    *error = base::ASCIIToUTF16(errors::kInvalidWebAccessibleResourcesList);
     return false;
   }
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
diff --git a/chrome/common/extensions/webview_handler.cc b/chrome/common/extensions/webview_handler.cc
index a5279a2..ef8b241 100644
--- a/chrome/common/extensions/webview_handler.cc
+++ b/chrome/common/extensions/webview_handler.cc
@@ -72,14 +72,14 @@ bool WebviewHandler::Parse(Extension* extension, base::string16* error) {
   const base::DictionaryValue* dict_value = NULL;
   if (!extension->manifest()->GetDictionary(keys::kWebview,
                                             &dict_value)) {
-    *error = ASCIIToUTF16(errors::kInvalidWebview);
+    *error = base::ASCIIToUTF16(errors::kInvalidWebview);
     return false;
   }
 
   const base::ListValue* url_list = NULL;
   if (!dict_value->GetList(keys::kWebviewAccessibleResources,
                            &url_list)) {
-    *error = ASCIIToUTF16(errors::kInvalidWebviewAccessibleResourcesList);
+    *error = base::ASCIIToUTF16(errors::kInvalidWebviewAccessibleResourcesList);
     return false;
   }
 
@@ -105,7 +105,7 @@ bool WebviewHandler::Parse(Extension* extension, base::string16* error) {
   const base::ListValue* partition_list = NULL;
   if (!dict_value->GetList(keys::kWebviewPrivilegedPartitions,
                            &partition_list)) {
-    *error = ASCIIToUTF16(errors::kInvalidWebviewPrivilegedPartitionList);
+    *error = base::ASCIIToUTF16(errors::kInvalidWebviewPrivilegedPartitionList);
     return false;
   }
   for (size_t i = 0; i < partition_list->GetSize(); ++i) {
diff --git a/chrome/common/importer/firefox_importer_utils.cc b/chrome/common/importer/firefox_importer_utils.cc
index cd7bf17..86d9bcb 100644
--- a/chrome/common/importer/firefox_importer_utils.cc
+++ b/chrome/common/importer/firefox_importer_utils.cc
@@ -33,7 +33,7 @@ base::FilePath GetProfilePath(const base::DictionaryValue& root,
 
 #if defined(OS_WIN)
   ReplaceSubstringsAfterOffset(
-      &path16, 0, ASCIIToUTF16("/"), ASCIIToUTF16("\\"));
+      &path16, 0, base::ASCIIToUTF16("/"), base::ASCIIToUTF16("\\"));
 #endif
   base::FilePath path = base::FilePath::FromUTF16Unsafe(path16);
 
diff --git a/chrome/common/importer/ie_importer_test_registry_overrider_win.cc b/chrome/common/importer/ie_importer_test_registry_overrider_win.cc
index 552a1d7..e84cb65 100644
--- a/chrome/common/importer/ie_importer_test_registry_overrider_win.cc
+++ b/chrome/common/importer/ie_importer_test_registry_overrider_win.cc
@@ -30,7 +30,7 @@ bool GetTestKeyFromEnvironment(base::string16* key) {
   std::string value;
   bool result = env->GetVar(kTestHKCUOverrideEnvironmentVariable, &value);
   if (result)
-    *key = UTF8ToUTF16(value);
+    *key = base::UTF8ToUTF16(value);
   return result;
 }
 
@@ -41,12 +41,12 @@ bool GetTestKeyFromEnvironment(base::string16* key) {
 
 IEImporterTestRegistryOverrider::IEImporterTestRegistryOverrider()
     : temporary_key_(kTestHKCUOverrideKeyPrefix +
-                     UTF8ToUTF16(base::GenerateGUID())) {
+                     base::UTF8ToUTF16(base::GenerateGUID())) {
   DCHECK(!GetTestKeyFromEnvironment(NULL));
 
   scoped_ptr<base::Environment> env(base::Environment::Create());
   bool success = env->SetVar(kTestHKCUOverrideEnvironmentVariable,
-                             UTF16ToUTF8(temporary_key_));
+                             base::UTF16ToUTF8(temporary_key_));
   DCHECK(success);
 }
 
diff --git a/chrome/common/localized_error.cc b/chrome/common/localized_error.cc
index 86280a5..d85428c 100644
--- a/chrome/common/localized_error.cc
+++ b/chrome/common/localized_error.cc
@@ -574,11 +574,11 @@ void LocalizedError::GetStrings(int error_code,
     std::string ascii_error_string = net::ErrorToString(error_code);
     // Remove the leading "net::" from the returned string.
     base::RemoveChars(ascii_error_string, "net:", &ascii_error_string);
-    error_string = ASCIIToUTF16(ascii_error_string);
+    error_string = base::ASCIIToUTF16(ascii_error_string);
   } else if (error_domain == chrome_common_net::kDnsProbeErrorDomain) {
     std::string ascii_error_string =
         chrome_common_net::DnsProbeStatusToString(error_code);
-    error_string = ASCIIToUTF16(ascii_error_string);
+    error_string = base::ASCIIToUTF16(ascii_error_string);
   } else {
     DCHECK_EQ(LocalizedError::kHttpErrorDomain, error_domain);
     error_string = base::IntToString16(error_code);
@@ -795,7 +795,7 @@ void LocalizedError::GetAppErrorStrings(
   bool rtl = LocaleIsRTL();
   error_strings->SetString("textdirection", rtl ? "rtl" : "ltr");
 
-  base::string16 failed_url(ASCIIToUTF16(display_url.spec()));
+  base::string16 failed_url(base::ASCIIToUTF16(display_url.spec()));
   // URLs are always LTR.
   if (rtl)
     base::i18n::WrapStringWithLTRFormatting(&failed_url);
diff --git a/chrome/common/logging_chrome.cc b/chrome/common/logging_chrome.cc
index 59019c5..3587cbb 100644
--- a/chrome/common/logging_chrome.cc
+++ b/chrome/common/logging_chrome.cc
@@ -436,7 +436,7 @@ size_t GetFatalAssertions(AssertionList* assertions) {
   while (!log_file.eof()) {
     getline(log_file, utf8_line);
     if (utf8_line.find(":FATAL:") != std::string::npos) {
-      wide_line = UTF8ToWide(utf8_line);
+      wide_line = base::UTF8ToWide(utf8_line);
       if (assertions)
         assertions->push_back(wide_line);
       ++assertion_count;
diff --git a/chrome/common/metrics/variations/experiment_labels.cc b/chrome/common/metrics/variations/experiment_labels.cc
index e0e036b..489c9c3 100644
--- a/chrome/common/metrics/variations/experiment_labels.cc
+++ b/chrome/common/metrics/variations/experiment_labels.cc
@@ -26,14 +26,14 @@ base::string16 CreateSingleExperimentLabel(int count, VariationID id,
                                            const base::Time& current_time) {
   // Build the parts separately so they can be validated.
   const base::string16 key =
-      ASCIIToUTF16(kVariationPrefix) + base::IntToString16(count);
+      base::ASCIIToUTF16(kVariationPrefix) + base::IntToString16(count);
   DCHECK_LE(key.size(), 8U);
   const base::string16 value = base::IntToString16(id);
   DCHECK_LE(value.size(), 8U);
   base::string16 label(key);
-  label += ASCIIToUTF16("=");
+  label += base::ASCIIToUTF16("=");
   label += value;
-  label += ASCIIToUTF16("|");
+  label += base::ASCIIToUTF16("|");
   label += installer::BuildExperimentDateString(current_time);
   return label;
 }
@@ -56,8 +56,10 @@ base::string16 BuildGoogleUpdateExperimentLabel(
     if (id == EMPTY_ID)
       continue;
 
-    if (!experiment_labels.empty())
-      experiment_labels += ASCIIToUTF16(google_update::kExperimentLabelSep);
+    if (!experiment_labels.empty()) {
+      experiment_labels +=
+          base::ASCIIToUTF16(google_update::kExperimentLabelSep);
+    }
     experiment_labels += CreateSingleExperimentLabel(++counter, id,
                                                      current_time);
   }
@@ -67,7 +69,7 @@ base::string16 BuildGoogleUpdateExperimentLabel(
 
 base::string16 ExtractNonVariationLabels(const base::string16& labels) {
   const base::string16 separator =
-      ASCIIToUTF16(google_update::kExperimentLabelSep);
+      base::ASCIIToUTF16(google_update::kExperimentLabelSep);
   base::string16 non_variation_labels;
 
   // First, split everything by the label separator.
@@ -77,8 +79,10 @@ base::string16 ExtractNonVariationLabels(const base::string16& labels) {
   // For each label, keep the ones that do not look like a Variations label.
   for (std::vector<base::string16>::const_iterator it = entries.begin();
        it != entries.end(); ++it) {
-    if (it->empty() || StartsWith(*it, ASCIIToUTF16(kVariationPrefix), false))
+    if (it->empty() ||
+        StartsWith(*it, base::ASCIIToUTF16(kVariationPrefix), false)) {
       continue;
+    }
 
     // Dump the whole thing, including the timestamp.
     if (!non_variation_labels.empty())
@@ -92,7 +96,7 @@ base::string16 ExtractNonVariationLabels(const base::string16& labels) {
 base::string16 CombineExperimentLabels(const base::string16& variation_labels,
                                        const base::string16& other_labels) {
   const base::string16 separator =
-      ASCIIToUTF16(google_update::kExperimentLabelSep);
+      base::ASCIIToUTF16(google_update::kExperimentLabelSep);
   DCHECK(!StartsWith(variation_labels, separator, false));
   DCHECK(!EndsWith(variation_labels, separator, false));
   DCHECK(!StartsWith(other_labels, separator, false));
diff --git a/chrome/common/metrics/variations/experiment_labels_unittest.cc b/chrome/common/metrics/variations/experiment_labels_unittest.cc
index 977d81e..942174d 100644
--- a/chrome/common/metrics/variations/experiment_labels_unittest.cc
+++ b/chrome/common/metrics/variations/experiment_labels_unittest.cc
@@ -71,7 +71,7 @@ TEST(ExperimentLabelsTest, BuildGoogleUpdateExperimentLabel) {
     std::vector<std::string> expected_ids_list;
     base::SplitString(test_cases[i].expected_ids, '#', &expected_ids_list);
 
-    std::string experiment_labels_string = UTF16ToUTF8(
+    std::string experiment_labels_string = base::UTF16ToUTF8(
         BuildGoogleUpdateExperimentLabel(groups));
 
     // Split the VariationIDs from the labels for verification below.
@@ -127,9 +127,9 @@ TEST(ExperimentLabelsTest, CombineExperimentLabels) {
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
-    std::string result = UTF16ToUTF8(CombineExperimentLabels(
-        ASCIIToUTF16(test_cases[i].variations_labels),
-        ASCIIToUTF16(test_cases[i].other_labels)));
+    std::string result = base::UTF16ToUTF8(CombineExperimentLabels(
+        base::ASCIIToUTF16(test_cases[i].variations_labels),
+        base::ASCIIToUTF16(test_cases[i].other_labels)));
     EXPECT_EQ(test_cases[i].expected_label, result);
   }
 }
@@ -183,8 +183,9 @@ TEST(ExperimentLabelsTest, ExtractNonVariationLabels) {
   };
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
-    std::string non_variation_labels = UTF16ToUTF8(
-        ExtractNonVariationLabels(ASCIIToUTF16(test_cases[i].input_label)));
+    std::string non_variation_labels = base::UTF16ToUTF8(
+        ExtractNonVariationLabels(
+            base::ASCIIToUTF16(test_cases[i].input_label)));
     EXPECT_EQ(test_cases[i].expected_output, non_variation_labels);
   }
 }
diff --git a/chrome/common/multi_process_lock_win.cc b/chrome/common/multi_process_lock_win.cc
index e2a7cb9..31922b2 100644
--- a/chrome/common/multi_process_lock_win.cc
+++ b/chrome/common/multi_process_lock_win.cc
@@ -30,7 +30,7 @@ class MultiProcessLockWin : public MultiProcessLock {
       return false;
     }
 
-    base::string16 wname = UTF8ToUTF16(name_);
+    base::string16 wname = base::UTF8ToUTF16(name_);
     event_.Set(CreateEvent(NULL, FALSE, FALSE, wname.c_str()));
     if (event_.Get() && GetLastError() != ERROR_ALREADY_EXISTS) {
       return true;
diff --git a/chrome/common/net/url_fixer_upper.cc b/chrome/common/net/url_fixer_upper.cc
index 54407c6..bc3ea91 100644
--- a/chrome/common/net/url_fixer_upper.cc
+++ b/chrome/common/net/url_fixer_upper.cc
@@ -41,8 +41,8 @@ url_parse::Component UTF8ComponentToUTF16Component(
   std::string component_string = text_utf8.substr(component_utf8.begin,
                                                   component_utf8.len);
   base::string16 before_component_string_16 =
-      UTF8ToUTF16(before_component_string);
-  base::string16 component_string_16 = UTF8ToUTF16(component_string);
+      base::UTF8ToUTF16(before_component_string);
+  base::string16 component_string_16 = base::UTF8ToUTF16(component_string);
   url_parse::Component component_16(before_component_string_16.length(),
                                     component_string_16.length());
   return component_16;
@@ -81,10 +81,10 @@ TrimPositions TrimWhitespaceUTF8(const std::string& input,
   // twice. Please feel free to file a bug if this function hurts the
   // performance of Chrome.
   DCHECK(IsStringUTF8(input));
-  base::string16 input16 = UTF8ToUTF16(input);
+  base::string16 input16 = base::UTF8ToUTF16(input);
   base::string16 output16;
   TrimPositions result = TrimWhitespace(input16, positions, &output16);
-  *output = UTF16ToUTF8(output16);
+  *output = base::UTF16ToUTF8(output16);
   return result;
 }
 
@@ -155,7 +155,7 @@ std::string FixupPath(const std::string& text) {
 
   base::FilePath::StringType filename;
 #if defined(OS_WIN)
-  base::FilePath input_path(UTF8ToWide(text));
+  base::FilePath input_path(base::UTF8ToWide(text));
   PrepareStringForFileOps(input_path, &filename);
 
   // Fixup Windows-style drive letters, where "C:" gets rewritten to "C|".
@@ -171,7 +171,7 @@ std::string FixupPath(const std::string& text) {
   // Here, we know the input looks like a file.
   GURL file_url = net::FilePathToFileURL(base::FilePath(filename));
   if (file_url.is_valid()) {
-    return UTF16ToUTF8(net::FormatUrl(file_url, std::string(),
+    return base::UTF16ToUTF8(net::FormatUrl(file_url, std::string(),
         net::kFormatUrlOmitUsernamePassword, net::UnescapeRule::NORMAL, NULL,
         NULL, NULL));
   }
@@ -486,11 +486,11 @@ std::string URLFixerUpper::SegmentURL(const std::string& text,
 
 base::string16 URLFixerUpper::SegmentURL(const base::string16& text,
                                          url_parse::Parsed* parts) {
-  std::string text_utf8 = UTF16ToUTF8(text);
+  std::string text_utf8 = base::UTF16ToUTF8(text);
   url_parse::Parsed parts_utf8;
   std::string scheme_utf8 = SegmentURL(text_utf8, &parts_utf8);
   UTF8PartsToUTF16Parts(text_utf8, parts_utf8, parts);
-  return UTF8ToUTF16(scheme_utf8);
+  return base::UTF8ToUTF16(scheme_utf8);
 }
 
 GURL URLFixerUpper::FixupURL(const std::string& text,
@@ -597,8 +597,8 @@ GURL URLFixerUpper::FixupRelativeFile(const base::FilePath& base_dir,
     // escaped things. We need to go through 8-bit since the escaped values
     // only represent 8-bit values.
 #if defined(OS_WIN)
-    std::wstring unescaped = UTF8ToWide(net::UnescapeURLComponent(
-        WideToUTF8(trimmed),
+    std::wstring unescaped = base::UTF8ToWide(net::UnescapeURLComponent(
+        base::WideToUTF8(trimmed),
         net::UnescapeRule::SPACES | net::UnescapeRule::URL_SPECIAL_CHARS));
 #elif defined(OS_POSIX)
     std::string unescaped = net::UnescapeURLComponent(
@@ -617,7 +617,7 @@ GURL URLFixerUpper::FixupRelativeFile(const base::FilePath& base_dir,
   if (is_file) {
     GURL file_url = net::FilePathToFileURL(full_path);
     if (file_url.is_valid())
-      return GURL(UTF16ToUTF8(net::FormatUrl(file_url, std::string(),
+      return GURL(base::UTF16ToUTF8(net::FormatUrl(file_url, std::string(),
           net::kFormatUrlOmitUsernamePassword, net::UnescapeRule::NORMAL, NULL,
           NULL, NULL)));
     // Invalid files fall through to regular processing.
@@ -625,7 +625,7 @@ GURL URLFixerUpper::FixupRelativeFile(const base::FilePath& base_dir,
 
   // Fall back on regular fixup for this input.
 #if defined(OS_WIN)
-  std::string text_utf8 = WideToUTF8(text.value());
+  std::string text_utf8 = base::WideToUTF8(text.value());
 #elif defined(OS_POSIX)
   std::string text_utf8 = text.value();
 #endif
diff --git a/chrome/common/net/url_fixer_upper_unittest.cc b/chrome/common/net/url_fixer_upper_unittest.cc
index ea80c73..46d41c6 100644
--- a/chrome/common/net/url_fixer_upper_unittest.cc
+++ b/chrome/common/net/url_fixer_upper_unittest.cc
@@ -379,7 +379,7 @@ TEST(URLFixerUpperTest, FixupFile) {
 
   // c:\foo\bar.txt -> file:///c:/foo/bar.txt (basic)
 #if defined(OS_WIN)
-  GURL fixedup(URLFixerUpper::FixupURL(WideToUTF8(original.value()),
+  GURL fixedup(URLFixerUpper::FixupURL(base::WideToUTF8(original.value()),
                                        std::string()));
 #elif defined(OS_POSIX)
   GURL fixedup(URLFixerUpper::FixupURL(original.value(), std::string()));
@@ -389,7 +389,7 @@ TEST(URLFixerUpperTest, FixupFile) {
   // TODO(port): Make some equivalent tests for posix.
 #if defined(OS_WIN)
   // c|/foo\bar.txt -> file:///c:/foo/bar.txt (pipe allowed instead of colon)
-  std::string cur(WideToUTF8(original.value()));
+  std::string cur(base::WideToUTF8(original.value()));
   EXPECT_EQ(':', cur[1]);
   cur[1] = '|';
   EXPECT_EQ(golden, URLFixerUpper::FixupURL(cur, std::string()));
diff --git a/chrome/common/net/url_util.cc b/chrome/common/net/url_util.cc
index 3015a17..0228379 100644
--- a/chrome/common/net/url_util.cc
+++ b/chrome/common/net/url_util.cc
@@ -22,7 +22,7 @@ void WriteURLToClipboard(const GURL& url,
   // Unescaping path and query is not a good idea because other applications
   // may not encode non-ASCII characters in UTF-8.  See crbug.com/2820.
   base::string16 text = url.SchemeIs(content::kMailToScheme) ?
-      ASCIIToUTF16(url.path()) :
+      base::ASCIIToUTF16(url.path()) :
       net::FormatUrl(url, languages, net::kFormatUrlOmitNothing,
                      net::UnescapeRule::NONE, NULL, NULL, NULL);
 
diff --git a/chrome/common/service_process_util.cc b/chrome/common/service_process_util.cc
index 83ad89c..6773fab 100644
--- a/chrome/common/service_process_util.cc
+++ b/chrome/common/service_process_util.cc
@@ -105,7 +105,7 @@ std::string GetServiceProcessScopedName(const std::string& append_str) {
   base::FilePath user_data_dir;
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
 #if defined(OS_WIN)
-  std::string user_data_dir_path = WideToUTF8(user_data_dir.value());
+  std::string user_data_dir_path = base::WideToUTF8(user_data_dir.value());
 #elif defined(OS_POSIX)
   std::string user_data_dir_path = user_data_dir.value();
 #endif  // defined(OS_WIN)
diff --git a/chrome/common/service_process_util_unittest.cc b/chrome/common/service_process_util_unittest.cc
index f7153fe..d1ca2c4 100644
--- a/chrome/common/service_process_util_unittest.cc
+++ b/chrome/common/service_process_util_unittest.cc
@@ -126,7 +126,7 @@ TEST_F(ServiceProcessStateTest, AutoRun) {
   std::string value_name = GetServiceProcessScopedName("_service_run");
   base::string16 value;
   EXPECT_TRUE(base::win::ReadCommandFromAutoRun(HKEY_CURRENT_USER,
-                                                UTF8ToWide(value_name),
+                                                base::UTF8ToWide(value_name),
                                                 &value));
   autorun_command_line.reset(new CommandLine(CommandLine::FromString(value)));
 #elif defined(OS_POSIX) && !defined(OS_MACOSX)
@@ -156,7 +156,7 @@ TEST_F(ServiceProcessStateTest, AutoRun) {
   ASSERT_TRUE(state.RemoveFromAutoRun());
 #if defined(OS_WIN)
   EXPECT_FALSE(base::win::ReadCommandFromAutoRun(HKEY_CURRENT_USER,
-                                                 UTF8ToWide(value_name),
+                                                 base::UTF8ToWide(value_name),
                                                  &value));
 #elif defined(OS_POSIX) && !defined(OS_MACOSX)
   EXPECT_FALSE(AutoStart::GetAutostartFileValue(
diff --git a/chrome/common/service_process_util_win.cc b/chrome/common/service_process_util_win.cc
index 7e7754d..fca7aa6 100644
--- a/chrome/common/service_process_util_win.cc
+++ b/chrome/common/service_process_util_win.cc
@@ -23,12 +23,12 @@ namespace {
 const char* kTerminateEventSuffix = "_service_terminate_evt";
 
 base::string16 GetServiceProcessReadyEventName() {
-  return UTF8ToWide(
+  return base::UTF8ToWide(
       GetServiceProcessScopedVersionedName("_service_ready"));
 }
 
 base::string16 GetServiceProcessTerminateEventName() {
-  return UTF8ToWide(
+  return base::UTF8ToWide(
       GetServiceProcessScopedVersionedName(kTerminateEventSuffix));
 }
 
@@ -41,7 +41,7 @@ std::string GetServiceProcessAutoRunKey() {
 std::string GetObsoleteServiceProcessAutoRunKey() {
   base::FilePath user_data_dir;
   PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
-  std::string scoped_name = WideToUTF8(user_data_dir.value());
+  std::string scoped_name = base::WideToUTF8(user_data_dir.value());
   std::replace(scoped_name.begin(), scoped_name.end(), '\\', '!');
   std::replace(scoped_name.begin(), scoped_name.end(), '/', '!');
   scoped_name.append("_service_run");
@@ -88,7 +88,7 @@ bool ForceServiceProcessShutdown(const std::string& version,
   std::string versioned_name = version;
   versioned_name.append(kTerminateEventSuffix);
   base::string16 event_name =
-      UTF8ToWide(GetServiceProcessScopedName(versioned_name));
+      base::UTF8ToWide(GetServiceProcessScopedName(versioned_name));
   terminate_event.Set(OpenEvent(EVENT_MODIFY_STATE, FALSE, event_name.c_str()));
   if (!terminate_event.IsValid())
     return false;
@@ -153,10 +153,11 @@ bool ServiceProcessState::AddToAutoRun() {
   // Remove the old autorun value first because we changed the naming scheme
   // for the autorun value name.
   base::win::RemoveCommandFromAutoRun(
-      HKEY_CURRENT_USER, UTF8ToWide(GetObsoleteServiceProcessAutoRunKey()));
+      HKEY_CURRENT_USER,
+      base::UTF8ToWide(GetObsoleteServiceProcessAutoRunKey()));
   return base::win::AddCommandToAutoRun(
       HKEY_CURRENT_USER,
-      UTF8ToWide(GetServiceProcessAutoRunKey()),
+      base::UTF8ToWide(GetServiceProcessAutoRunKey()),
       autorun_command_line_->GetCommandLineString());
 }
 
@@ -164,9 +165,10 @@ bool ServiceProcessState::RemoveFromAutoRun() {
   // Remove the old autorun value first because we changed the naming scheme
   // for the autorun value name.
   base::win::RemoveCommandFromAutoRun(
-      HKEY_CURRENT_USER, UTF8ToWide(GetObsoleteServiceProcessAutoRunKey()));
+      HKEY_CURRENT_USER,
+      base::UTF8ToWide(GetObsoleteServiceProcessAutoRunKey()));
   return base::win::RemoveCommandFromAutoRun(
-      HKEY_CURRENT_USER, UTF8ToWide(GetServiceProcessAutoRunKey()));
+      HKEY_CURRENT_USER, base::UTF8ToWide(GetServiceProcessAutoRunKey()));
 }
 
 void ServiceProcessState::TearDownState() {
diff --git a/chrome/common/time_format_browsertest.cc b/chrome/common/time_format_browsertest.cc
index 9269652..bdd820c 100644
--- a/chrome/common/time_format_browsertest.cc
+++ b/chrome/common/time_format_browsertest.cc
@@ -36,5 +36,5 @@ IN_PROC_BROWSER_TEST_F(TimeFormatBrowserTest, DecimalPointNotDot) {
 
   base::string16 one_min =
       ui::TimeFormat::TimeRemainingShort(TimeDelta::FromMinutes(1));
-  EXPECT_EQ(ASCIIToUTF16("1 min"), one_min);
+  EXPECT_EQ(base::ASCIIToUTF16("1 min"), one_min);
 }