Add base:: to string16 in extensions/.

extensions/common/extension.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 "extensions/common/extension.h"
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
@@ skipping 85 matching lines @@
                                            std::string* utf8_error) {
   return Extension::Create(path,
                            location,
                            value,
                            flags,
                            std::string(),  // ID is ignored if empty.
                            utf8_error);
 }
 
 // TODO(sungguk): Continue removing std::string errors and replacing
-// with string16. See http://crbug.com/71980.
+// with base::string16. See http://crbug.com/71980.
 scoped_refptr<Extension> Extension::Create(const base::FilePath& path,
                                            Manifest::Location location,
                                            const base::DictionaryValue& value,
                                            int flags,
                                            const std::string& explicit_id,
                                            std::string* utf8_error) {
   DCHECK(utf8_error);
-  string16 error;
+  base::string16 error;
   scoped_ptr<extensions::Manifest> manifest(
       new extensions::Manifest(
           location, scoped_ptr<base::DictionaryValue>(value.DeepCopy())));
 
   if (!InitExtensionID(manifest.get(), path, explicit_id, flags, &error)) {
     *utf8_error = UTF16ToUTF8(error);
     return NULL;
   }
 
   std::vector<InstallWarning> install_warnings;
@@ skipping 336 matching lines @@
 
 bool Extension::is_theme() const {
   return manifest()->is_theme();
 }
 
 // static
 bool Extension::InitExtensionID(extensions::Manifest* manifest,
                                 const base::FilePath& path,
                                 const std::string& explicit_id,
                                 int creation_flags,
-                                string16* error) {
+                                base::string16* error) {
   if (!explicit_id.empty()) {
     manifest->set_extension_id(explicit_id);
     return true;
   }
 
   if (manifest->HasKey(keys::kPublicKey)) {
     std::string public_key;
     std::string public_key_bytes;
     if (!manifest->GetString(keys::kPublicKey, &public_key) ||
         !ParsePEMKeyBytes(public_key, &public_key_bytes)) {
@@ skipping 32 matching lines @@
       display_in_new_tab_page_(true),
       wants_file_access_(false),
       creation_flags_(0) {
   DCHECK(path.empty() || path.IsAbsolute());
   path_ = id_util::MaybeNormalizePath(path);
 }
 
 Extension::~Extension() {
 }
 
-bool Extension::InitFromValue(int flags, string16* error) {
+bool Extension::InitFromValue(int flags, base::string16* error) {
   DCHECK(error);
 
   creation_flags_ = flags;
 
   // Important to load manifest version first because many other features
   // depend on its value.
   if (!LoadManifestVersion(error))
     return false;
 
   if (!LoadRequiredFeatures(error))
@@ skipping 23 matching lines @@
     return false;
 
   finished_parsing_manifest_ = true;
 
   permissions_data_->InitializeManifestPermissions(this);
   permissions_data_->FinalizePermissions(this);
 
   return true;
 }
 
-bool Extension::LoadRequiredFeatures(string16* error) {
+bool Extension::LoadRequiredFeatures(base::string16* error) {
   if (!LoadName(error) ||
       !LoadVersion(error))
     return false;
   return true;
 }
 
-bool Extension::LoadName(string16* error) {
-  string16 localized_name;
+bool Extension::LoadName(base::string16* error) {
+  base::string16 localized_name;
   if (!manifest_->GetString(keys::kName, &localized_name)) {
     *error = ASCIIToUTF16(errors::kInvalidName);
     return false;
   }
   non_localized_name_ = UTF16ToUTF8(localized_name);
   base::i18n::AdjustStringForLocaleDirection(&localized_name);
   name_ = UTF16ToUTF8(localized_name);
   return true;
 }
 
-bool Extension::LoadVersion(string16* error) {
+bool Extension::LoadVersion(base::string16* error) {
   std::string version_str;
   if (!manifest_->GetString(keys::kVersion, &version_str)) {
     *error = ASCIIToUTF16(errors::kInvalidVersion);
     return false;
   }
   version_.reset(new Version(version_str));
   if (!version_->IsValid() || version_->components().size() > 4) {
     *error = ASCIIToUTF16(errors::kInvalidVersion);
     return false;
   }
   return true;
 }
 
-bool Extension::LoadAppFeatures(string16* error) {
+bool Extension::LoadAppFeatures(base::string16* error) {
   if (!LoadExtent(keys::kWebURLs, &extent_,
                   errors::kInvalidWebURLs, errors::kInvalidWebURL, error)) {
     return false;
   }
   if (manifest_->HasKey(keys::kDisplayInLauncher) &&
       !manifest_->GetBoolean(keys::kDisplayInLauncher, &display_in_launcher_)) {
     *error = ASCIIToUTF16(errors::kInvalidDisplayInLauncher);
     return false;
   }
   if (manifest_->HasKey(keys::kDisplayInNewTabPage)) {
     if (!manifest_->GetBoolean(keys::kDisplayInNewTabPage,
                                &display_in_new_tab_page_)) {
       *error = ASCIIToUTF16(errors::kInvalidDisplayInNewTabPage);
       return false;
     }
   } else {
     // Inherit default from display_in_launcher property.
     display_in_new_tab_page_ = display_in_launcher_;
   }
   return true;
 }
 
 bool Extension::LoadExtent(const char* key,
                            URLPatternSet* extent,
                            const char* list_error,
                            const char* value_error,
-                           string16* error) {
+                           base::string16* error) {
   const base::Value* temp_pattern_value = NULL;
   if (!manifest_->Get(key, &temp_pattern_value))
     return true;
 
   const base::ListValue* pattern_list = NULL;
   if (!temp_pattern_value->GetAsList(&pattern_list)) {
     *error = ASCIIToUTF16(list_error);
     return false;
   }
 
@@ skipping 49 matching lines @@
       return false;
     }
     pattern.SetPath(pattern.path() + '*');
 
     extent->AddPattern(pattern);
   }
 
   return true;
 }
 
-bool Extension::LoadSharedFeatures(string16* error) {
+bool Extension::LoadSharedFeatures(base::string16* error) {
   if (!LoadDescription(error) ||
       !ManifestHandler::ParseExtension(this, error) ||
       !LoadShortName(error))
     return false;
 
   return true;
 }
 
-bool Extension::LoadDescription(string16* error) {
+bool Extension::LoadDescription(base::string16* error) {
   if (manifest_->HasKey(keys::kDescription) &&
       !manifest_->GetString(keys::kDescription, &description_)) {
     *error = ASCIIToUTF16(errors::kInvalidDescription);
     return false;
   }
   return true;
 }
 
-bool Extension::LoadManifestVersion(string16* error) {
+bool Extension::LoadManifestVersion(base::string16* error) {
   // Get the original value out of the dictionary so that we can validate it
   // more strictly.
   if (manifest_->value()->HasKey(keys::kManifestVersion)) {
     int manifest_version = 1;
     if (!manifest_->GetInteger(keys::kManifestVersion, &manifest_version) ||
         manifest_version < 1) {
       *error = ASCIIToUTF16(errors::kInvalidManifestVersion);
       return false;
     }
   }
 
   manifest_version_ = manifest_->GetManifestVersion();
   if (manifest_version_ < kModernManifestVersion &&
       ((creation_flags_ & REQUIRE_MODERN_MANIFEST_VERSION &&
         !CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kAllowLegacyExtensionManifests)) ||
        GetType() == Manifest::TYPE_PLATFORM_APP)) {
     *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidManifestVersionOld,
         base::IntToString(kModernManifestVersion),
         is_platform_app() ? "apps" : "extensions");
     return false;
   }
 
   return true;
 }
 
-bool Extension::LoadShortName(string16* error) {
+bool Extension::LoadShortName(base::string16* error) {
   if (manifest_->HasKey(keys::kShortName)) {
-    string16 localized_short_name;
+    base::string16 localized_short_name;
     if (!manifest_->GetString(keys::kShortName, &localized_short_name) ||
         localized_short_name.empty()) {
       *error = ASCIIToUTF16(errors::kInvalidShortName);
       return false;
     }
 
     base::i18n::AdjustStringForLocaleDirection(&localized_short_name);
     short_name_ = UTF16ToUTF8(localized_short_name);
   } else {
     short_name_ = name_;
@@ skipping 30 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions