Add explicit base namespace to string16 users.

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"
 #include "extensions/common/manifest.h"
 #include "extensions/common/manifest_constants.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace extensions {
 
 namespace keys = manifest_keys;
 namespace errors = manifest_errors;
 
 namespace {
 
 bool LoadImages(const base::DictionaryValue* theme_value,
-                string16* error,
+                base::string16* error,
                 ThemeInfo* theme_info) {
   const base::DictionaryValue* images_value = NULL;
   if (theme_value->GetDictionary(keys::kThemeImages, &images_value)) {
     // Validate that the images are all strings.
     for (base::DictionaryValue::Iterator iter(*images_value); !iter.IsAtEnd();
          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)) {
@@ skipping 14 matching lines @@
         *error = ASCIIToUTF16(errors::kInvalidThemeImages);
         return false;
       }
     }
     theme_info->theme_images_.reset(images_value->DeepCopy());
   }
   return true;
 }
 
 bool LoadColors(const base::DictionaryValue* theme_value,
-                string16* error,
+                base::string16* error,
                 ThemeInfo* theme_info) {
   const base::DictionaryValue* colors_value = NULL;
   if (theme_value->GetDictionary(keys::kThemeColors, &colors_value)) {
     // Validate that the colors are RGB or RGBA lists.
     for (base::DictionaryValue::Iterator iter(*colors_value); !iter.IsAtEnd();
          iter.Advance()) {
       const base::ListValue* color_list = NULL;
       double alpha = 0.0;
       int color = 0;
       // The color must be a list...
@@ skipping 11 matching lines @@
         *error = ASCIIToUTF16(errors::kInvalidThemeColors);
         return false;
       }
     }
     theme_info->theme_colors_.reset(colors_value->DeepCopy());
   }
   return true;
 }
 
 bool LoadTints(const base::DictionaryValue* theme_value,
-               string16* error,
+               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);
       return false;
     }
   }
   theme_info->theme_tints_.reset(tints_value->DeepCopy());
   return true;
 }
 
 bool LoadDisplayProperties(const base::DictionaryValue* theme_value,
-                           string16* error,
+                           base::string16* error,
                            ThemeInfo* theme_info) {
   const base::DictionaryValue* display_properties_value = NULL;
   if (theme_value->GetDictionary(keys::kThemeDisplayProperties,
                                  &display_properties_value)) {
     theme_info->theme_display_properties_.reset(
         display_properties_value->DeepCopy());
   }
   return true;
 }
 
@@ skipping 33 matching lines @@
   const ThemeInfo* theme_info = GetInfo(extension);
   return theme_info ? theme_info->theme_display_properties_.get() : NULL;
 }
 
 ThemeHandler::ThemeHandler() {
 }
 
 ThemeHandler::~ThemeHandler() {
 }
 
-bool ThemeHandler::Parse(Extension* extension, string16* error) {
+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);
     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()))
@@ skipping 32 matching lines @@
     }
   }
   return true;
 }
 
 const std::vector<std::string> ThemeHandler::Keys() const {
   return SingleKey(keys::kTheme);
 }
 
 }  // namespace extensions