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

components/autofill/core/browser/autofill_merge_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 <map>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
@@ skipping 52 matching lines @@
   for (size_t i = 0; i < profiles.size(); ++i) {
     result += kProfileSeparator;
     result += "\n";
     for (size_t j = 0; j < arraysize(kProfileFieldTypes); ++j) {
       ServerFieldType type = kProfileFieldTypes[j];
       std::vector<base::string16> values;
       profiles[i]->GetRawMultiInfo(type, &values);
       for (size_t k = 0; k < values.size(); ++k) {
         result += AutofillType(type).ToString();
         result += kFieldSeparator;
-        result += UTF16ToUTF8(values[k]);
+        result += base::UTF16ToUTF8(values[k]);
         result += "\n";
       }
     }
   }
 
   return result;
 }
 
 class PersonalDataManagerMock : public PersonalDataManager {
  public:
@@ skipping 94 matching lines @@
   MergeProfiles(input, output);
 }
 
 void AutofillMergeTest::MergeProfiles(const std::string& profiles,
                                       std::string* merged_profiles) {
   // Start with no saved profiles.
   personal_data_.Reset();
 
   // Create a test form.
   FormData form;
-  form.name = ASCIIToUTF16("MyTestForm");
-  form.method = ASCIIToUTF16("POST");
+  form.name = base::ASCIIToUTF16("MyTestForm");
+  form.method = base::ASCIIToUTF16("POST");
   form.origin = GURL("https://www.example.com/origin.html");
   form.action = GURL("https://www.example.com/action.html");
   form.user_submitted = true;
 
   // Parse the input line by line.
   std::vector<std::string> lines;
   Tokenize(profiles, "\n", &lines);
   for (size_t i = 0; i < lines.size(); ++i) {
     std::string line = lines[i];
 
     if (line != kProfileSeparator) {
       // Add a field to the current profile.
       size_t separator_pos = line.find(kFieldSeparator);
       ASSERT_NE(std::string::npos, separator_pos);
-      base::string16 field_type = UTF8ToUTF16(line.substr(0, separator_pos));
+      base::string16 field_type =
+          base::UTF8ToUTF16(line.substr(0, separator_pos));
       base::string16 value =
-          UTF8ToUTF16(line.substr(separator_pos + kFieldOffset));
+          base::UTF8ToUTF16(line.substr(separator_pos + kFieldOffset));
 
       FormFieldData field;
       field.label = field_type;
       field.name = field_type;
       field.value = value;
       field.form_control_type = "text";
       form.fields.push_back(field);
     }
 
     // The first line is always a profile separator, and the last profile is not
     // followed by an explicit separator.
     if ((i > 0 && line == kProfileSeparator) || i == lines.size() - 1) {
       // Reached the end of a profile.  Try to import it.
       FormStructure form_structure(form);
       for (size_t i = 0; i < form_structure.field_count(); ++i) {
         // Set the heuristic type for each field, which is currently serialized
         // into the field's name.
         AutofillField* field =
             const_cast<AutofillField*>(form_structure.field(i));
-        ServerFieldType type = StringToFieldType(UTF16ToUTF8(field->name));
+        ServerFieldType type =
+            StringToFieldType(base::UTF16ToUTF8(field->name));
         field->set_heuristic_type(type);
       }
 
       // Import the profile.
       scoped_ptr<CreditCard> imported_credit_card;
       personal_data_.ImportFormData(form_structure, &imported_credit_card);
       EXPECT_EQ(static_cast<CreditCard*>(NULL), imported_credit_card.get());
 
       // Clear the |form| to start a new profile.
       form.fields.clear();
     }
   }
 
   *merged_profiles = SerializeProfiles(personal_data_.web_profiles());
 }
 
 ServerFieldType AutofillMergeTest::StringToFieldType(const std::string& str) {
   return string_to_field_type_map_[str];
 }
 
 TEST_F(AutofillMergeTest, DataDrivenMergeProfiles) {
   RunDataDrivenTest(GetInputDirectory(kTestName), GetOutputDirectory(kTestName),
                     kFileNamePattern);
 }
 
 }  // namespace autofill