Update uses of UTF conversions in chrome_frame/, chromeos/, components/ to use the base:: namespace.

chrome_frame/policy_settings.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome_frame/policy_settings.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
@@ skipping 54 matching lines @@
     std::vector<std::wstring>* renderer_exclusion_list) {
   DCHECK(default_renderer);
   DCHECK(renderer_exclusion_list);
 
   *default_renderer = RENDERER_NOT_SPECIFIED;
   renderer_exclusion_list->clear();
 
   base::win::RegKey config_key;
   DWORD value = RENDERER_NOT_SPECIFIED;
   std::wstring settings_value(
-      ASCIIToWide(policy::key::kChromeFrameRendererSettings));
+      base::ASCIIToWide(policy::key::kChromeFrameRendererSettings));
   for (int i = 0; i < arraysize(kRootKeys); ++i) {
     if ((config_key.Open(kRootKeys[i], policy::kRegistryChromePolicyKey,
                          KEY_READ) == ERROR_SUCCESS) &&
         (config_key.ReadValueDW(settings_value.c_str(),
                                 &value) == ERROR_SUCCESS)) {
         break;
     }
   }
 
   DCHECK(value == RENDERER_NOT_SPECIFIED ||
          value == RENDER_IN_HOST ||
          value == RENDER_IN_CHROME_FRAME)
       << "invalid default renderer setting: " << value;
 
   if (value != RENDER_IN_HOST && value != RENDER_IN_CHROME_FRAME) {
     DVLOG(1) << "default renderer not specified via policy";
   } else {
     *default_renderer = static_cast<RendererForUrl>(value);
     const char* exclusion_list_name = (*default_renderer == RENDER_IN_HOST) ?
         policy::key::kRenderInChromeFrameList :
         policy::key::kRenderInHostList;
 
     EnumerateKeyValues(config_key.Handle(),
-        ASCIIToWide(exclusion_list_name).c_str(), renderer_exclusion_list);
+                       base::ASCIIToWide(exclusion_list_name).c_str(),
+                       renderer_exclusion_list);
 
     DVLOG(1) << "Default renderer as specified via policy: "
              << *default_renderer
              << " exclusion list size: " << renderer_exclusion_list->size();
   }
 }
 
 // static
 void PolicySettings::ReadMetadataCheckSettings(
     SkipMetadataCheck* skip_metadata_check) {
   DCHECK(skip_metadata_check);
 
   *skip_metadata_check = SKIP_METADATA_CHECK_NOT_SPECIFIED;
 
   base::win::RegKey config_key;
   DWORD value = SKIP_METADATA_CHECK_NOT_SPECIFIED;
-  base::string16 settings_value(ASCIIToWide(policy::key::kSkipMetadataCheck));
+  base::string16 settings_value(
+      base::ASCIIToWide(policy::key::kSkipMetadataCheck));
   for (int i = 0; i < arraysize(kRootKeys); ++i) {
     if ((config_key.Open(kRootKeys[i], policy::kRegistryChromePolicyKey,
                          KEY_READ) == ERROR_SUCCESS) &&
         (config_key.ReadValueDW(settings_value.c_str(),
                                 &value) == ERROR_SUCCESS)) {
       break;
     }
   }
 
   DCHECK(value == SKIP_METADATA_CHECK_NOT_SPECIFIED ||
@@ skipping 10 matching lines @@
   }
 }
 
 // static
 void PolicySettings::ReadContentTypeSetting(
     std::vector<std::wstring>* content_type_list) {
   DCHECK(content_type_list);
 
   std::wstring sub_key(policy::kRegistryChromePolicyKey);
   sub_key += L"\\";
-  sub_key += ASCIIToWide(policy::key::kChromeFrameContentTypes);
+  sub_key += base::ASCIIToWide(policy::key::kChromeFrameContentTypes);
 
   content_type_list->clear();
   for (int i = 0; i < arraysize(kRootKeys) && content_type_list->empty();
        ++i) {
     EnumerateKeyValues(kRootKeys[i], sub_key.c_str(), content_type_list);
   }
 }
 
 // static
 void PolicySettings::ReadStringSetting(const char* value_name,
                                        std::wstring* value) {
   DCHECK(value);
   value->clear();
   base::win::RegKey config_key;
-  std::wstring value_name_str(ASCIIToWide(value_name));
+  std::wstring value_name_str(base::ASCIIToWide(value_name));
   for (int i = 0; i < arraysize(kRootKeys); ++i) {
     if ((config_key.Open(kRootKeys[i], policy::kRegistryChromePolicyKey,
                          KEY_READ) == ERROR_SUCCESS) &&
         (config_key.ReadValue(value_name_str.c_str(),
                               value) == ERROR_SUCCESS)) {
       break;
     }
   }
 }
 
 // static
 void PolicySettings::ReadBoolSetting(const char* value_name, bool* value) {
   DCHECK(value);
   base::win::RegKey config_key;
-  base::string16 value_name_str(ASCIIToWide(value_name));
+  base::string16 value_name_str(base::ASCIIToWide(value_name));
   DWORD dword_value = 0;
   for (int i = 0; i < arraysize(kRootKeys); ++i) {
     if ((config_key.Open(kRootKeys[i], policy::kRegistryChromePolicyKey,
                          KEY_QUERY_VALUE) == ERROR_SUCCESS) &&
         (config_key.ReadValueDW(value_name_str.c_str(),
                                 &dword_value) == ERROR_SUCCESS)) {
       *value = (dword_value != 0);
       break;
     }
   }
@@ skipping 33 matching lines @@
   swap(content_type_list_, content_type_list);
   swap(application_locale_, application_locale);
   swap(additional_launch_parameters_, additional_launch_parameters);
   swap(suppress_turndown_prompt_, suppress_turndown_prompt);
 }
 
 // static
 PolicySettings* PolicySettings::GetInstance() {
   return Singleton<PolicySettings>::get();
 }