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

components/autofill/core/browser/phone_number_i18n.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 "components/autofill/core/browser/phone_number_i18n.h"
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 48 matching lines @@
   PhoneNumberUtil::PhoneNumberFormat format =
       country_code.empty() ?
       PhoneNumberUtil::NATIONAL :
       PhoneNumberUtil::INTERNATIONAL;
 
   PhoneNumberUtil* phone_util = PhoneNumberUtil::GetInstance();
   std::string processed_number;
   phone_util->Format(number, format, &processed_number);
 
   if (formatted_number)
-    *formatted_number = UTF8ToUTF16(processed_number);
+    *formatted_number = base::UTF8ToUTF16(processed_number);
 
   if (normalized_number) {
     phone_util->NormalizeDigitsOnly(&processed_number);
-    *normalized_number = UTF8ToUTF16(processed_number);
+    *normalized_number = base::UTF8ToUTF16(processed_number);
   }
 }
 
 }  // namespace
 
 namespace i18n {
 
 // Parses the number stored in |value| as it should be interpreted in the given
 // |region|, and stores the results into the remaining arguments.  The |region|
 // should be sanitized prior to calling this function.
 bool ParsePhoneNumber(const base::string16& value,
                       const std::string& region,
                       base::string16* country_code,
                       base::string16* city_code,
                       base::string16* number,
                       PhoneNumber* i18n_number) {
   country_code->clear();
   city_code->clear();
   number->clear();
   *i18n_number = PhoneNumber();
 
-  std::string number_text(UTF16ToUTF8(value));
+  std::string number_text(base::UTF16ToUTF8(value));
 
   // Parse phone number based on the region.
   PhoneNumberUtil* phone_util = PhoneNumberUtil::GetInstance();
 
   // The |region| should already be sanitized.
   DCHECK_EQ(2U, region.size());
   if (phone_util->Parse(number_text, region.c_str(), i18n_number) !=
           PhoneNumberUtil::NO_PARSING_ERROR) {
     return false;
   }
@@ skipping 15 matching lines @@
     area_length = destination_length;
 
   std::string area_code;
   std::string subscriber_number;
   if (area_length > 0) {
     area_code = national_significant_number.substr(0, area_length);
     subscriber_number = national_significant_number.substr(area_length);
   } else {
     subscriber_number = national_significant_number;
   }
-  *number = UTF8ToUTF16(subscriber_number);
-  *city_code = UTF8ToUTF16(area_code);
+  *number = base::UTF8ToUTF16(subscriber_number);
+  *city_code = base::UTF8ToUTF16(area_code);
   *country_code = base::string16();
 
   phone_util->NormalizeDigitsOnly(&number_text);
-  base::string16 normalized_number(UTF8ToUTF16(number_text));
+  base::string16 normalized_number(base::UTF8ToUTF16(number_text));
 
   // Check if parsed number has a country code that was not inferred from the
   // region.
   if (i18n_number->has_country_code()) {
-    *country_code = UTF8ToUTF16(
+    *country_code = base::UTF8ToUTF16(
         base::StringPrintf("%d", i18n_number->country_code()));
     if (normalized_number.length() <= national_significant_number.length() &&
         !StartsWith(normalized_number, *country_code,
                     true /* case_sensitive */)) {
       country_code->clear();
     }
   }
 
   return true;
 }
@@ skipping 41 matching lines @@
                        const base::string16& number_b,
                        const std::string& raw_region,
                        const std::string& app_locale) {
   // Sanitize the provided |raw_region| before trying to use it for parsing.
   const std::string region = SanitizeRegion(raw_region, app_locale);
 
   PhoneNumberUtil* phone_util = PhoneNumberUtil::GetInstance();
 
   // Parse phone numbers based on the region
   PhoneNumber i18n_number1;
-  if (phone_util->Parse(UTF16ToUTF8(number_a), region.c_str(), &i18n_number1) !=
-          PhoneNumberUtil::NO_PARSING_ERROR) {
+  if (phone_util->Parse(
+          base::UTF16ToUTF8(number_a), region.c_str(), &i18n_number1) !=
+              PhoneNumberUtil::NO_PARSING_ERROR) {
     return false;
   }
 
   PhoneNumber i18n_number2;
-  if (phone_util->Parse(UTF16ToUTF8(number_b), region.c_str(), &i18n_number2) !=
-          PhoneNumberUtil::NO_PARSING_ERROR) {
+  if (phone_util->Parse(
+          base::UTF16ToUTF8(number_b), region.c_str(), &i18n_number2) !=
+              PhoneNumberUtil::NO_PARSING_ERROR) {
     return false;
   }
 
   switch (phone_util->IsNumberMatch(i18n_number1, i18n_number2)) {
     case PhoneNumberUtil::INVALID_NUMBER:
     case PhoneNumberUtil::NO_MATCH:
       return false;
     case PhoneNumberUtil::SHORT_NSN_MATCH:
       return false;
     case PhoneNumberUtil::NSN_MATCH:
@@ skipping 76 matching lines @@
   number_ = other.number_;
 
   formatted_number_ = other.formatted_number_;
   whole_number_ = other.whole_number_;
 
   return *this;
 }
 
 }  // namespace i18n
 }  // namespace autofill