Update uses of UTF conversions in content/ to use the base:: namespace.

content/browser/accessibility/accessibility_tree_formatter_win.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 "content/browser/accessibility/accessibility_tree_formatter.h"
 
 #include <oleacc.h>
 
 #include <string>
 
@@ skipping 72 matching lines @@
   // and the position of the mouse cursor.
   ia_state &= ~STATE_SYSTEM_HOTTRACKED;
   ia_state &= ~STATE_SYSTEM_OFFSCREEN;
 
   IAccessibleStateToStringVector(ia_state, &state_strings);
   IAccessible2StateToStringVector(acc_obj->ia2_state(), &state_strings);
   base::ListValue* states = new base::ListValue;
   for (std::vector<base::string16>::const_iterator it = state_strings.begin();
        it != state_strings.end();
        ++it) {
-    states->AppendString(UTF16ToUTF8(*it));
+    states->AppendString(base::UTF16ToUTF8(*it));
   }
   dict->Set("states", states);
 
   const std::vector<base::string16>& ia2_attributes = acc_obj->ia2_attributes();
   base::ListValue* attributes = new base::ListValue;
   for (std::vector<base::string16>::const_iterator it = ia2_attributes.begin();
        it != ia2_attributes.end();
        ++it) {
-    attributes->AppendString(UTF16ToUTF8(*it));
+    attributes->AppendString(base::UTF16ToUTF8(*it));
   }
   dict->Set("attributes", attributes);
 
   dict->SetString("role_name", acc_obj->role_name());
 
   VARIANT currentValue;
   if (acc_obj->get_currentValue(&currentValue) == S_OK)
     dict->SetDouble("currentValue", V_R8(&currentValue));
 
   VARIANT minimumValue;
@@ skipping 86 matching lines @@
   }
 }
 
 base::string16 AccessibilityTreeFormatter::ToString(
     const base::DictionaryValue& dict,
     const base::string16& indent) {
   base::string16 line;
 
   base::string16 role_value;
   dict.GetString("role", &role_value);
-  WriteAttribute(true, UTF16ToUTF8(role_value), &line);
+  WriteAttribute(true, base::UTF16ToUTF8(role_value), &line);
 
   base::string16 name_value;
   dict.GetString("name", &name_value);
   WriteAttribute(true, base::StringPrintf(L"name='%ls'", name_value.c_str()),
                  &line);
 
   for (int i = 0; i < arraysize(ALL_ATTRIBUTES); i++) {
     const char* attribute_name = ALL_ATTRIBUTES[i];
     const base::Value* value;
     if (!dict.Get(attribute_name, &value))
       continue;
 
     switch (value->GetType()) {
       case base::Value::TYPE_STRING: {
         base::string16 string_value;
         value->GetAsString(&string_value);
         WriteAttribute(false,
                        StringPrintf(L"%ls='%ls'",
-                                    UTF8ToUTF16(attribute_name).c_str(),
+                                    base::UTF8ToUTF16(attribute_name).c_str(),
                                     string_value.c_str()),
                        &line);
         break;
       }
       case base::Value::TYPE_INTEGER: {
         int int_value;
         value->GetAsInteger(&int_value);
         WriteAttribute(false,
                        base::StringPrintf(L"%ls=%d",
-                                          UTF8ToUTF16(attribute_name).c_str(),
+                                          base::UTF8ToUTF16(
+                                              attribute_name).c_str(),
                                           int_value),
                        &line);
         break;
       }
       case base::Value::TYPE_DOUBLE: {
         double double_value;
         value->GetAsDouble(&double_value);
         WriteAttribute(false,
                        base::StringPrintf(L"%ls=%.2f",
-                                          UTF8ToUTF16(attribute_name).c_str(),
+                                          base::UTF8ToUTF16(
+                                              attribute_name).c_str(),
                                           double_value),
                        &line);
         break;
       }
       case base::Value::TYPE_LIST: {
         // Currently all list values are string and are written without
         // attribute names.
         const base::ListValue* list_value;
         value->GetAsList(&list_value);
         for (base::ListValue::const_iterator it = list_value->begin();
@@ skipping 21 matching lines @@
                          &line);
         }
         break;
       }
       default:
         NOTREACHED();
         break;
     }
   }
 
-  return indent + line + ASCIIToUTF16("\n");
+  return indent + line + base::ASCIIToUTF16("\n");
 }
 
 // static
 const base::FilePath::StringType
 AccessibilityTreeFormatter::GetActualFileSuffix() {
   return FILE_PATH_LITERAL("-actual-win.txt");
 }
 
 // static
 const base::FilePath::StringType
@@ skipping 10 matching lines @@
 const std::string AccessibilityTreeFormatter::GetAllowString() {
   return "@WIN-ALLOW:";
 }
 
 // static
 const std::string AccessibilityTreeFormatter::GetDenyString() {
   return "@WIN-DENY:";
 }
 
 }  // namespace content