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

chrome/browser/sessions/restore_on_startup_policy_handler_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <string>
 
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_value_map.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 35 matching lines @@
 };
 
 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_FailsTypeCheck) {
   // Handler expects an int; pass it a bool.
   SetPolicyValue(key::kRestoreOnStartup, new base::FundamentalValue(false));
   // Checking should fail and add an error to the error map.
   EXPECT_FALSE(CheckPolicySettings());
   EXPECT_EQ(1U, errors().size());
   EXPECT_EQ(l10n_util::GetStringFUTF16(
                 IDS_POLICY_TYPE_ERROR,
-                ASCIIToUTF16(ConfigurationPolicyHandler::ValueTypeToString(
-                    base::Value::TYPE_INTEGER))),
+                base::ASCIIToUTF16(
+                    ConfigurationPolicyHandler::ValueTypeToString(
+                        base::Value::TYPE_INTEGER))),
             errors().begin()->second);
 }
 
 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_Unspecified) {
   // Don't specify a value for the policy.
   // Checking should succeed with no errors.
   EXPECT_TRUE(CheckPolicySettings());
   EXPECT_EQ(0U, errors().size());
 }
 
 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_UnknownValue) {
   // Specify an unknown value for the policy.
   int impossible_value = SessionStartupPref::kPrefValueHomePage +
                          SessionStartupPref::kPrefValueLast +
                          SessionStartupPref::kPrefValueURLs +
                          SessionStartupPref::kPrefValueNewTab;
   SetPolicyValue(key::kRestoreOnStartup,
                  new base::FundamentalValue(impossible_value));
   // Checking should succeed but add an error to the error map.
   EXPECT_TRUE(CheckPolicySettings());
   EXPECT_EQ(1U, errors().size());
   EXPECT_EQ(l10n_util::GetStringFUTF16(
                 IDS_POLICY_OUT_OF_RANGE_ERROR,
-                ASCIIToUTF16(base::IntToString(impossible_value))),
+                base::ASCIIToUTF16(base::IntToString(impossible_value))),
             errors().begin()->second);
 }
 
 TEST_F(RestoreOnStartupPolicyHandlerTest, CheckPolicySettings_HomePage) {
   // Specify the HomePage value.
   SetPolicyValue(
       key::kRestoreOnStartup,
       new base::FundamentalValue(SessionStartupPref::kPrefValueHomePage));
   // Checking should succeed but add an error to the error map.
   EXPECT_TRUE(CheckPolicySettings());
   EXPECT_EQ(1U, errors().size());
   EXPECT_EQ(l10n_util::GetStringUTF16(IDS_POLICY_VALUE_DEPRECATED),
             errors().begin()->second);
 }
 
 TEST_F(RestoreOnStartupPolicyHandlerTest,
        CheckPolicySettings_RestoreLastSession_SessionCookies) {
   // Specify the Last value and the Session-Only Cookies value.
   SetPolicyValue(
       key::kRestoreOnStartup,
       new base::FundamentalValue(SessionStartupPref::kPrefValueLast));
   scoped_ptr<base::ListValue> urls(new base::ListValue);
   urls->AppendString("http://foo.com");
   SetPolicyValue(key::kCookiesSessionOnlyForUrls, urls.release());
   // Checking should succeed but add an error to the error map.
   EXPECT_TRUE(CheckPolicySettings());
   EXPECT_EQ(1U, errors().size());
   EXPECT_TRUE(key::kCookiesSessionOnlyForUrls == errors().begin()->first);
-  EXPECT_EQ(l10n_util::GetStringFUTF16(IDS_POLICY_OVERRIDDEN,
-                                       ASCIIToUTF16(key::kRestoreOnStartup)),
+  EXPECT_EQ(l10n_util::GetStringFUTF16(
+                IDS_POLICY_OVERRIDDEN,
+                base::ASCIIToUTF16(key::kRestoreOnStartup)),
             errors().begin()->second);
 }
 
 TEST_F(RestoreOnStartupPolicyHandlerTest,
        CheckPolicySettings_RestoreLastSession_ClearDataOnExit) {
   // Specify the Last value and the Clear-Data-On-Exit value.
   SetPolicyValue(
       key::kRestoreOnStartup,
       new base::FundamentalValue(SessionStartupPref::kPrefValueLast));
   SetPolicyValue(key::kClearSiteDataOnExit, new base::FundamentalValue(true));
   // Checking should succeed but add an error to the error map.
   EXPECT_TRUE(CheckPolicySettings());
   EXPECT_EQ(1U, errors().size());
   EXPECT_TRUE(key::kClearSiteDataOnExit == errors().begin()->first);
-  EXPECT_EQ(l10n_util::GetStringFUTF16(IDS_POLICY_OVERRIDDEN,
-                                       ASCIIToUTF16(key::kRestoreOnStartup)),
+  EXPECT_EQ(l10n_util::GetStringFUTF16(
+                IDS_POLICY_OVERRIDDEN,
+                base::ASCIIToUTF16(key::kRestoreOnStartup)),
             errors().begin()->second);
 }
 
 TEST_F(RestoreOnStartupPolicyHandlerTest,
        CheckPolicySettings_RestoreLastSession) {
   // Specify the Last value without the conflicts.
   SetPolicyValue(
       key::kRestoreOnStartup,
       new base::FundamentalValue(SessionStartupPref::kPrefValueLast));
   // Checking should succeed with no errors.
@@ skipping 141 matching lines @@
   EXPECT_TRUE(prefs().GetValue(prefs::kURLsToRestoreOnStartup, &url_result));
   base::ListValue* url_list_result;
   EXPECT_TRUE(url_result->GetAsList(&url_list_result));
   EXPECT_EQ(1U, url_list_result->GetSize());
   std::string expected_url;
   EXPECT_TRUE(url_list_result->GetString(0, &expected_url));
   EXPECT_EQ(std::string("http://foo.com"), expected_url);
 }
 
 }  // namespace policy