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

components/policy/core/common/policy_loader_win_unittest.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 "components/policy/core/common/policy_loader_win.h"
 
 #include <windows.h>
 #include <userenv.h>
 
 #include <algorithm>
@@ skipping 19 matching lines @@
 #include "base/win/registry.h"
 #include "components/policy/core/common/async_policy_provider.h"
 #include "components/policy/core/common/configuration_policy_provider_test.h"
 #include "components/policy/core/common/external_data_fetcher.h"
 #include "components/policy/core/common/policy_bundle.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/core/common/preg_parser_win.h"
 #include "components/policy/core/common/schema_map.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using base::UTF8ToUTF16;
 using base::win::RegKey;
 
 namespace policy {
 
 namespace {
 
 // Constants for registry key names.
 const wchar_t kPathSep[] = L"\\";
 const wchar_t kThirdParty[] = L"3rdparty";
 const wchar_t kMandatory[] = L"policy";
@@ skipping 236 matching lines @@
   base::FilePath preg_file_path_;
   GROUP_POLICY_OBJECT gpo_;
 
   DISALLOW_COPY_AND_ASSIGN(PRegTestHarness);
 };
 
 ScopedGroupPolicyRegistrySandbox::ScopedGroupPolicyRegistrySandbox() {
   // Generate a unique registry key for the override for each test. This
   // makes sure that tests executing in parallel won't delete each other's
   // key, at DeleteKeys().
-  key_name_ = ASCIIToWide(base::StringPrintf(
+  key_name_ = base::ASCIIToWide(base::StringPrintf(
         "SOFTWARE\\chromium unittest %d",
         base::Process::Current().pid()));
   std::wstring hklm_key_name = key_name_ + L"\\HKLM";
   std::wstring hkcu_key_name = key_name_ + L"\\HKCU";
 
   // Create the subkeys to hold the overridden HKLM and HKCU
   // policy settings.
   temp_hklm_hive_key_.Create(HKEY_CURRENT_USER,
                              hklm_key_name.c_str(),
                              KEY_ALL_ACCESS);
@@ skipping 68 matching lines @@
   RegKey key(hive_, kTestPolicyKey, KEY_ALL_ACCESS);
   ASSERT_TRUE(key.Valid());
   key.WriteValue(UTF8ToUTF16(policy_name).c_str(),
                  static_cast<DWORD>(policy_value));
 }
 
 void RegistryTestHarness::InstallStringListPolicy(
     const std::string& policy_name,
     const base::ListValue* policy_value) {
   RegKey key(hive_,
-             (base::string16(kTestPolicyKey) + ASCIIToUTF16("\\") +
+             (base::string16(kTestPolicyKey) + base::ASCIIToUTF16("\\") +
               UTF8ToUTF16(policy_name)).c_str(),
              KEY_ALL_ACCESS);
   ASSERT_TRUE(key.Valid());
   int index = 1;
   for (base::ListValue::const_iterator element(policy_value->begin());
        element != policy_value->end();
        ++element) {
     std::string element_value;
     if (!(*element)->GetAsString(&element_value))
       continue;
@@ skipping 417 matching lines @@
       "  \"type\": \"object\","
       "  \"properties\": {"
       "    \"a\": { \"type\": \"string\" },"
       "    \"b\": { \"type\": \"string\" },"
       "    \"c\": { \"type\": \"string\" },"
       "    \"d\": { \"type\": \"string\" }"
       "  }"
       "}"));
 
   const base::string16 kPathSuffix =
-      kTestPolicyKey + ASCIIToUTF16("\\3rdparty\\extensions\\merge");
+      kTestPolicyKey + base::ASCIIToUTF16("\\3rdparty\\extensions\\merge");
 
   const char kUserMandatory[] = "user-mandatory";
   const char kUserRecommended[] = "user-recommended";
   const char kMachineMandatory[] = "machine-mandatory";
   const char kMachineRecommended[] = "machine-recommended";
 
   base::DictionaryValue policy;
   policy.SetString("a", kMachineMandatory);
   EXPECT_TRUE(InstallValue(policy, HKEY_LOCAL_MACHINE,
                            kPathSuffix, kMandatory));
@@ skipping 68 matching lines @@
   ASSERT_FALSE(encoded_list.empty());
   base::DictionaryValue encoded_policy;
   encoded_policy.SetString("null", "");
   encoded_policy.SetString("bool", "1");
   encoded_policy.SetString("int", "-123");
   encoded_policy.SetString("double", "456.78e9");
   encoded_policy.SetString("list", encoded_list);
   encoded_policy.SetString("dict", encoded_dict);
 
   const base::string16 kPathSuffix =
-      kTestPolicyKey + ASCIIToUTF16("\\3rdparty\\extensions\\string");
+      kTestPolicyKey + base::ASCIIToUTF16("\\3rdparty\\extensions\\string");
   EXPECT_TRUE(
       InstallValue(encoded_policy, HKEY_CURRENT_USER, kPathSuffix, kMandatory));
 
   PolicyBundle expected;
   expected.Get(ns).LoadFrom(&policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
   EXPECT_TRUE(Matches(expected));
 }
 
 TEST_F(PolicyLoaderWinTest, LoadIntegerEncodedValues) {
   const PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, "int");
   ASSERT_TRUE(RegisterSchema(
       ns,
       "{"
       "  \"type\": \"object\","
       "  \"properties\": {"
       "    \"bool\": { \"type\": \"boolean\" },"
       "    \"int\": { \"type\": \"integer\" },"
       "    \"double\": { \"type\": \"number\" }"
       "  }"
       "}"));
 
   base::DictionaryValue encoded_policy;
   encoded_policy.SetInteger("bool", 1);
   encoded_policy.SetInteger("int", 123);
   encoded_policy.SetInteger("double", 456);
 
   const base::string16 kPathSuffix =
-      kTestPolicyKey + ASCIIToUTF16("\\3rdparty\\extensions\\int");
+      kTestPolicyKey + base::ASCIIToUTF16("\\3rdparty\\extensions\\int");
   EXPECT_TRUE(
       InstallValue(encoded_policy, HKEY_CURRENT_USER, kPathSuffix, kMandatory));
 
   base::DictionaryValue policy;
   policy.SetBoolean("bool", true);
   policy.SetInteger("int", 123);
   policy.SetDouble("double", 456.0);
   PolicyBundle expected;
   expected.Get(ns).LoadFrom(&policy, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
   EXPECT_TRUE(Matches(expected));
@@ skipping 26 matching lines @@
   policy.SetInteger("special-int1", 123);
   policy.SetString("special-int2", "-456");
   // Other values default to be loaded as doubles.
   policy.SetInteger("double1", 789.0);
   policy.SetString("double2", "123.456e7");
   policy.SetString("invalid", "omg");
   base::DictionaryValue all_policies;
   all_policies.Set("policy", policy.DeepCopy());
 
   const base::string16 kPathSuffix =
-      kTestPolicyKey + ASCIIToUTF16("\\3rdparty\\extensions\\test");
+      kTestPolicyKey + base::ASCIIToUTF16("\\3rdparty\\extensions\\test");
   EXPECT_TRUE(
       InstallValue(all_policies, HKEY_CURRENT_USER, kPathSuffix, kMandatory));
 
   base::DictionaryValue expected_policy;
   expected_policy.SetInteger("special-int1", 123);
   expected_policy.SetInteger("special-int2", -456);
   expected_policy.SetDouble("double1", 789.0);
   expected_policy.SetDouble("double2", 123.456e7);
   base::DictionaryValue expected_policies;
   expected_policies.Set("policy", expected_policy.DeepCopy());
@@ skipping 156 matching lines @@
   const char kIncompleteSchema[] =
       "{"
        "  \"type\": \"object\","
        "  \"properties\": {"
        "    \"url_list\": { \"type\": \"array\" },"
        "    \"url_greylist\": { \"type\": \"array\" }"
        "  }"
       "}";
 
   const base::string16 kPathSuffix =
-      kTestPolicyKey + ASCIIToUTF16("\\3rdparty\\extensions");
+      kTestPolicyKey + base::ASCIIToUTF16("\\3rdparty\\extensions");
 
   base::ListValue list;
   list.AppendString("youtube.com");
   base::DictionaryValue policy;
   policy.Set("url_list", list.DeepCopy());
   policy.SetString("alternative_browser_path", "c:\\legacy\\browser.exe");
   base::DictionaryValue root;
-  root.Set(UTF16ToUTF8(kMandatory), policy.DeepCopy());
+  root.Set(base::UTF16ToUTF8(kMandatory), policy.DeepCopy());
   root.SetString(kSchema, kIncompleteSchema);
   EXPECT_TRUE(InstallValue(root, HKEY_LOCAL_MACHINE,
-                           kPathSuffix, ASCIIToUTF16(ns.component_id)));
+                           kPathSuffix, base::ASCIIToUTF16(ns.component_id)));
 
   PolicyBundle expected;
   PolicyMap& expected_policy = expected.Get(ns);
   expected_policy.Set("alternative_browser_path",
                       POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                       new base::StringValue("c:\\legacy\\browser.exe"), NULL);
   expected_policy.Set("url_list", POLICY_LEVEL_MANDATORY, POLICY_SCOPE_MACHINE,
                       list.DeepCopy(), NULL);
   EXPECT_TRUE(Matches(expected));
 }
 
 }  // namespace policy