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

chrome/common/extensions/manifest_handlers/theme_handler.cc

 // Copyright (c) 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 "chrome/common/extensions/manifest_handlers/theme_handler.h"
 
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
@@ skipping 19 matching lines @@
          iter.Advance()) {
       // The value may be a dictionary of scales and files paths.
       // Or the value may be a file path, in which case a scale
       // of 100% is assumed.
       if (iter.value().IsType(base::Value::TYPE_DICTIONARY)) {
         const base::DictionaryValue* inner_value = NULL;
         if (iter.value().GetAsDictionary(&inner_value)) {
           for (base::DictionaryValue::Iterator inner_iter(*inner_value);
                !inner_iter.IsAtEnd(); inner_iter.Advance()) {
             if (!inner_iter.value().IsType(base::Value::TYPE_STRING)) {
-              *error = ASCIIToUTF16(errors::kInvalidThemeImages);
+              *error = base::ASCIIToUTF16(errors::kInvalidThemeImages);
               return false;
             }
           }
         } else {
-          *error = ASCIIToUTF16(errors::kInvalidThemeImages);
+          *error = base::ASCIIToUTF16(errors::kInvalidThemeImages);
           return false;
         }
       } else if (!iter.value().IsType(base::Value::TYPE_STRING)) {
-        *error = ASCIIToUTF16(errors::kInvalidThemeImages);
+        *error = base::ASCIIToUTF16(errors::kInvalidThemeImages);
         return false;
       }
     }
     theme_info->theme_images_.reset(images_value->DeepCopy());
   }
   return true;
 }
 
 bool LoadColors(const base::DictionaryValue* theme_value,
                 base::string16* error,
@@ skipping 11 matching lines @@
           // ... and either 3 items (RGB) or 4 (RGBA).
           ((color_list->GetSize() != 3) &&
            ((color_list->GetSize() != 4) ||
             // For RGBA, the fourth item must be a real or int alpha value.
             // Note that GetDouble() can get an integer value.
             !color_list->GetDouble(3, &alpha))) ||
           // For both RGB and RGBA, the first three items must be ints (R,G,B).
           !color_list->GetInteger(0, &color) ||
           !color_list->GetInteger(1, &color) ||
           !color_list->GetInteger(2, &color)) {
-        *error = ASCIIToUTF16(errors::kInvalidThemeColors);
+        *error = base::ASCIIToUTF16(errors::kInvalidThemeColors);
         return false;
       }
     }
     theme_info->theme_colors_.reset(colors_value->DeepCopy());
   }
   return true;
 }
 
 bool LoadTints(const base::DictionaryValue* theme_value,
                base::string16* error,
                ThemeInfo* theme_info) {
   const base::DictionaryValue* tints_value = NULL;
   if (!theme_value->GetDictionary(keys::kThemeTints, &tints_value))
     return true;
 
   // Validate that the tints are all reals.
   for (base::DictionaryValue::Iterator iter(*tints_value); !iter.IsAtEnd();
        iter.Advance()) {
     const base::ListValue* tint_list = NULL;
     double v = 0.0;
     if (!iter.value().GetAsList(&tint_list) ||
         tint_list->GetSize() != 3 ||
         !tint_list->GetDouble(0, &v) ||
         !tint_list->GetDouble(1, &v) ||
         !tint_list->GetDouble(2, &v)) {
-      *error = ASCIIToUTF16(errors::kInvalidThemeTints);
+      *error = base::ASCIIToUTF16(errors::kInvalidThemeTints);
       return false;
     }
   }
   theme_info->theme_tints_.reset(tints_value->DeepCopy());
   return true;
 }
 
 bool LoadDisplayProperties(const base::DictionaryValue* theme_value,
                            base::string16* error,
                            ThemeInfo* theme_info) {
@@ skipping 45 matching lines @@
 
 ThemeHandler::ThemeHandler() {
 }
 
 ThemeHandler::~ThemeHandler() {
 }
 
 bool ThemeHandler::Parse(Extension* extension, base::string16* error) {
   const base::DictionaryValue* theme_value = NULL;
   if (!extension->manifest()->GetDictionary(keys::kTheme, &theme_value)) {
-    *error = ASCIIToUTF16(errors::kInvalidTheme);
+    *error = base::ASCIIToUTF16(errors::kInvalidTheme);
     return false;
   }
 
   scoped_ptr<ThemeInfo> theme_info(new ThemeInfo);
   if (!LoadImages(theme_value, error, theme_info.get()))
     return false;
   if (!LoadColors(theme_value, error, theme_info.get()))
     return false;
   if (!LoadTints(theme_value, error, theme_info.get()))
     return false;
@@ skipping 29 matching lines @@
     }
   }
   return true;
 }
 
 const std::vector<std::string> ThemeHandler::Keys() const {
   return SingleKey(keys::kTheme);
 }
 
 }  // namespace extensions