Update uses of UTF conversions in courgette/, device/, extensions/, google_apis/, gpu/, ipc/, media…

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 99 matching lines @@
                                            int flags,
                                            const std::string& explicit_id,
                                            std::string* utf8_error) {
   DCHECK(utf8_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);
+    *utf8_error = base::UTF16ToUTF8(error);
     return NULL;
   }
 
   std::vector<InstallWarning> install_warnings;
   if (!manifest->ValidateManifest(utf8_error, &install_warnings)) {
     return NULL;
   }
 
   scoped_refptr<Extension> extension = new Extension(path, manifest.Pass());
   extension->install_warnings_.swap(install_warnings);
 
   if (!extension->InitFromValue(flags, &error)) {
-    *utf8_error = UTF16ToUTF8(error);
+    *utf8_error = base::UTF16ToUTF8(error);
     return NULL;
   }
 
   return extension;
 }
 
 // static
 bool Extension::IdIsValid(const std::string& id) {
   // Verify that the id is legal.
   if (id.size() != (id_util::kIdSize * 2))
@@ skipping 328 matching lines @@
   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)) {
-      *error = ASCIIToUTF16(errors::kInvalidKey);
+      *error = base::ASCIIToUTF16(errors::kInvalidKey);
       return false;
     }
     std::string extension_id = id_util::GenerateId(public_key_bytes);
     manifest->set_extension_id(extension_id);
     return true;
   }
 
   if (creation_flags & REQUIRE_KEY) {
-    *error = ASCIIToUTF16(errors::kInvalidKey);
+    *error = base::ASCIIToUTF16(errors::kInvalidKey);
     return false;
   } else {
     // If there is a path, we generate the ID from it. This is useful for
     // development mode, because it keeps the ID stable across restarts and
     // reloading the extension.
     std::string extension_id = id_util::GenerateIdForPath(path);
     if (extension_id.empty()) {
       NOTREACHED() << "Could not create ID from path.";
       return false;
     }
@@ skipping 66 matching lines @@
 bool Extension::LoadRequiredFeatures(base::string16* error) {
   if (!LoadName(error) ||
       !LoadVersion(error))
     return false;
   return true;
 }
 
 bool Extension::LoadName(base::string16* error) {
   base::string16 localized_name;
   if (!manifest_->GetString(keys::kName, &localized_name)) {
-    *error = ASCIIToUTF16(errors::kInvalidName);
+    *error = base::ASCIIToUTF16(errors::kInvalidName);
     return false;
   }
-  non_localized_name_ = UTF16ToUTF8(localized_name);
+  non_localized_name_ = base::UTF16ToUTF8(localized_name);
   base::i18n::AdjustStringForLocaleDirection(&localized_name);
-  name_ = UTF16ToUTF8(localized_name);
+  name_ = base::UTF16ToUTF8(localized_name);
   return true;
 }
 
 bool Extension::LoadVersion(base::string16* error) {
   std::string version_str;
   if (!manifest_->GetString(keys::kVersion, &version_str)) {
-    *error = ASCIIToUTF16(errors::kInvalidVersion);
+    *error = base::ASCIIToUTF16(errors::kInvalidVersion);
     return false;
   }
   version_.reset(new base::Version(version_str));
   if (!version_->IsValid() || version_->components().size() > 4) {
-    *error = ASCIIToUTF16(errors::kInvalidVersion);
+    *error = base::ASCIIToUTF16(errors::kInvalidVersion);
     return false;
   }
   return true;
 }
 
 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);
+    *error = base::ASCIIToUTF16(errors::kInvalidDisplayInLauncher);
     return false;
   }
   if (manifest_->HasKey(keys::kDisplayInNewTabPage)) {
     if (!manifest_->GetBoolean(keys::kDisplayInNewTabPage,
                                &display_in_new_tab_page_)) {
-      *error = ASCIIToUTF16(errors::kInvalidDisplayInNewTabPage);
+      *error = base::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,
                            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);
+    *error = base::ASCIIToUTF16(list_error);
     return false;
   }
 
   for (size_t i = 0; i < pattern_list->GetSize(); ++i) {
     std::string pattern_string;
     if (!pattern_list->GetString(i, &pattern_string)) {
       *error = ErrorUtils::FormatErrorMessageUTF16(value_error,
                                                    base::UintToString(i),
                                                    errors::kExpectString);
       return false;
@@ skipping 54 matching lines @@
       !ManifestHandler::ParseExtension(this, error) ||
       !LoadShortName(error))
     return false;
 
   return true;
 }
 
 bool Extension::LoadDescription(base::string16* error) {
   if (manifest_->HasKey(keys::kDescription) &&
       !manifest_->GetString(keys::kDescription, &description_)) {
-    *error = ASCIIToUTF16(errors::kInvalidDescription);
+    *error = base::ASCIIToUTF16(errors::kInvalidDescription);
     return false;
   }
   return true;
 }
 
 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);
+      *error = base::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(base::string16* error) {
   if (manifest_->HasKey(keys::kShortName)) {
     base::string16 localized_short_name;
     if (!manifest_->GetString(keys::kShortName, &localized_short_name) ||
         localized_short_name.empty()) {
-      *error = ASCIIToUTF16(errors::kInvalidShortName);
+      *error = base::ASCIIToUTF16(errors::kInvalidShortName);
       return false;
     }
 
     base::i18n::AdjustStringForLocaleDirection(&localized_short_name);
-    short_name_ = UTF16ToUTF8(localized_short_name);
+    short_name_ = base::UTF16ToUTF8(localized_short_name);
   } else {
     short_name_ = name_;
   }
   return true;
 }
 
 ExtensionInfo::ExtensionInfo(const base::DictionaryValue* manifest,
                              const std::string& id,
                              const base::FilePath& path,
                              Manifest::Location location)
@@ skipping 22 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions