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

extensions/common/manifest_handlers/shared_module_info.cc

 // Copyright 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/manifest_handlers/shared_module_info.h"
 
 #include "base/lazy_instance.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 95 matching lines @@
 }
 
 bool SharedModuleInfo::Parse(const Extension* extension,
                              base::string16* error) {
   bool has_import = extension->manifest()->HasKey(keys::kImport);
   bool has_export = extension->manifest()->HasKey(keys::kExport);
   if (!has_import && !has_export)
     return true;
 
   if (has_import && has_export) {
-    *error = ASCIIToUTF16(errors::kInvalidImportAndExport);
+    *error = base::ASCIIToUTF16(errors::kInvalidImportAndExport);
     return false;
   }
 
   if (has_export) {
     const base::DictionaryValue* export_value = NULL;
     if (!extension->manifest()->GetDictionary(keys::kExport, &export_value)) {
-      *error = ASCIIToUTF16(errors::kInvalidExport);
+      *error = base::ASCIIToUTF16(errors::kInvalidExport);
       return false;
     }
     const base::ListValue* resources_list = NULL;
     if (!export_value->GetList(keys::kResources, &resources_list)) {
-      *error = ASCIIToUTF16(errors::kInvalidExportResources);
+      *error = base::ASCIIToUTF16(errors::kInvalidExportResources);
       return false;
     }
     for (size_t i = 0; i < resources_list->GetSize(); ++i) {
       std::string resource_path;
       if (!resources_list->GetString(i, &resource_path)) {
         *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidExportResourcesString, base::IntToString(i));
         return false;
       }
       const GURL& resolved_path = extension->url().Resolve(resource_path);
       if (!resolved_path.is_valid()) {
         *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidExportResourcesString, base::IntToString(i));
         return false;
       }
       exported_set_.AddPattern(
           URLPattern(URLPattern::SCHEME_EXTENSION, resolved_path.spec()));
     }
   }
 
   if (has_import) {
     const base::ListValue* import_list = NULL;
     if (!extension->manifest()->GetList(keys::kImport, &import_list)) {
-      *error = ASCIIToUTF16(errors::kInvalidImport);
+      *error = base::ASCIIToUTF16(errors::kInvalidImport);
       return false;
     }
     for (size_t i = 0; i < import_list->GetSize(); ++i) {
       const base::DictionaryValue* import_entry = NULL;
       if (!import_list->GetDictionary(i, &import_entry)) {
-        *error = ASCIIToUTF16(errors::kInvalidImport);
+        *error = base::ASCIIToUTF16(errors::kInvalidImport);
         return false;
       }
       std::string extension_id;
       imports_.push_back(ImportInfo());
       if (!import_entry->GetString(keys::kId, &extension_id) ||
           !Extension::IdIsValid(extension_id)) {
         *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidImportId, base::IntToString(i));
         return false;
       }
@@ skipping 50 matching lines @@
 
 const std::vector<std::string> SharedModuleHandler::Keys() const {
   static const char* keys[] = {
     keys::kExport,
     keys::kImport
   };
   return std::vector<std::string>(keys, keys + arraysize(keys));
 }
 
 }  // namespace extensions