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

components/autofill/core/browser/form_structure.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/form_structure.h"
 
 #include <utility>
 
 #include "base/basictypes.h"
 #include "base/command_line.h"
@@ skipping 128 matching lines @@
   for (ServerFieldTypeSet::iterator field_type = types.begin();
        field_type != types.end(); ++field_type) {
     buzz::XmlElement *field_element = new buzz::XmlElement(
         buzz::QName(kXMLElementFields));
 
     field_element->SetAttr(buzz::QName(kAttributeFieldID),
                            field.FieldSignature());
     field_element->SetAttr(buzz::QName(kAttributeFieldType),
                            base::IntToString(*field_type));
     field_element->SetAttr(buzz::QName(kAttributeName),
-                           UTF16ToUTF8(field.name));
+                           base::UTF16ToUTF8(field.name));
     parent->AddElement(field_element);
   }
 }
 
 // Returns |true| iff the |token| is a type hint for a contact field, as
 // specified in the implementation section of http://is.gd/whatwg_autocomplete
 // Note that "fax" and "pager" are intentionally ignored, as Chrome does not
 // support filling either type of information.
 bool IsContactTypeHint(const std::string& token) {
   return token == "home" || token == "work" || token == "mobile";
@@ skipping 141 matching lines @@
                          (icu_pattern, UREGEX_CASE_INSENSITIVE, status));
   DCHECK_EQ(status, U_ZERO_ERROR);
 
   icu::UnicodeString icu_input(input.data(), input.length());
   matcher.reset(icu_input);
 
   icu::UnicodeString replaced_string = matcher.replaceAll("", status);
 
   std::string return_string;
   status = U_ZERO_ERROR;
-  UTF16ToUTF8(replaced_string.getBuffer(),
-              static_cast<size_t>(replaced_string.length()),
-              &return_string);
+  base::UTF16ToUTF8(replaced_string.getBuffer(),
+                    static_cast<size_t>(replaced_string.length()),
+                    &return_string);
   if (status != U_ZERO_ERROR) {
-    DVLOG(1) << "Couldn't strip digits in " << UTF16ToUTF8(input);
-    return UTF16ToUTF8(input);
+    DVLOG(1) << "Couldn't strip digits in " << base::UTF16ToUTF8(input);
+    return base::UTF16ToUTF8(input);
   }
 
   return return_string;
 }
 
 }  // namespace
 
 FormStructure::FormStructure(const FormData& form)
     : form_name_(form.name),
       source_url_(form.origin),
@@ skipping 17 matching lines @@
       ++active_field_count_;
     }
 
     // Generate a unique name for this field by appending a counter to the name.
     // Make sure to prepend the counter with a non-numeric digit so that we are
     // guaranteed to avoid collisions.
     if (!unique_names.count(field->name))
       unique_names[field->name] = 1;
     else
       ++unique_names[field->name];
-    base::string16 unique_name = field->name + ASCIIToUTF16("_") +
+    base::string16 unique_name = field->name + base::ASCIIToUTF16("_") +
         base::IntToString16(unique_names[field->name]);
     fields_.push_back(new AutofillField(*field, unique_name));
   }
 
-  std::string method = UTF16ToUTF8(form.method);
+  std::string method = base::UTF16ToUTF8(form.method);
   if (StringToLowerASCII(method) == kFormMethodPost) {
     method_ = POST;
   } else {
     // Either the method is 'get', or we don't know.  In this case we default
     // to GET.
     method_ = GET;
   }
 }
 
 FormStructure::~FormStructure() {}
@@ skipping 237 matching lines @@
 void FormStructure::GetFieldTypePredictions(
     const std::vector<FormStructure*>& form_structures,
     std::vector<FormDataPredictions>* forms) {
   forms->clear();
   forms->reserve(form_structures.size());
   for (size_t i = 0; i < form_structures.size(); ++i) {
     FormStructure* form_structure = form_structures[i];
     FormDataPredictions form;
     form.data.name = form_structure->form_name_;
     form.data.method =
-        ASCIIToUTF16((form_structure->method_ == POST) ? "POST" : "GET");
+        base::ASCIIToUTF16((form_structure->method_ == POST) ? "POST" : "GET");
     form.data.origin = form_structure->source_url_;
     form.data.action = form_structure->target_url_;
     form.signature = form_structure->FormSignature();
     form.experiment_id = form_structure->server_experiment_id_;
 
     for (std::vector<AutofillField*>::const_iterator field =
              form_structure->fields_.begin();
          field != form_structure->fields_.end(); ++field) {
       form.data.fields.push_back(FormFieldData(**field));
 
@@ skipping 16 matching lines @@
   std::string host(target_url_.host());
 
   // If target host or scheme is empty, set scheme and host of source url.
   // This is done to match the Toolbar's behavior.
   if (scheme.empty() || host.empty()) {
     scheme = source_url_.scheme();
     host = source_url_.host();
   }
 
   std::string form_string = scheme + "://" + host + "&" +
-                            UTF16ToUTF8(form_name_) +
+                            base::UTF16ToUTF8(form_name_) +
                             form_signature_field_names_;
 
   return Hash64Bit(form_string);
 }
 
 bool FormStructure::ShouldSkipField(const FormFieldData& field) const {
   return field.is_checkable;
 }
 
 bool FormStructure::IsAutofillable(bool require_method_post) const {
@@ skipping 290 matching lines @@
 std::string FormStructure::server_experiment_id() const {
   return server_experiment_id_;
 }
 
 FormData FormStructure::ToFormData() const {
   // |data.user_submitted| will always be false.
   FormData data;
   data.name = form_name_;
   data.origin = source_url_;
   data.action = target_url_;
-  data.method = ASCIIToUTF16(method_ == POST ? "POST" : "GET");
+  data.method = base::ASCIIToUTF16(method_ == POST ? "POST" : "GET");
 
   for (size_t i = 0; i < fields_.size(); ++i) {
     data.fields.push_back(FormFieldData(*fields_[i]));
   }
 
   return data;
 }
 
 bool FormStructure::operator==(const FormData& form) const {
   // TODO(jhawkins): Is this enough to differentiate a form?
@@ skipping 212 matching lines @@
 
       previous_type = current_type;
 
       if (current_type != UNKNOWN_TYPE && already_saw_current_type) {
         // We reached the end of a section, so start a new section.
         seen_types.clear();
         current_section = (*field)->unique_name();
       }
 
       seen_types.insert(current_type);
-      (*field)->set_section(UTF16ToUTF8(current_section));
+      (*field)->set_section(base::UTF16ToUTF8(current_section));
     }
   }
 
   // Ensure that credit card and address fields are in separate sections.
   // This simplifies the section-aware logic in autofill_manager.cc.
   for (std::vector<AutofillField*>::iterator field = fields_.begin();
        field != fields_.end(); ++field) {
     FieldTypeGroup field_type_group = (*field)->Type().group();
     if (field_type_group == CREDIT_CARD)
       (*field)->set_section((*field)->section() + "-cc");
     else
       (*field)->set_section((*field)->section() + "-default");
   }
 }
 
 }  // namespace autofill