Issue 71980: Extensions code should use UTF-16 for user-visible Unicode strings

chrome/common/extensions/extension.cc

 // Copyright (c) 2011 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/extension.h"
 
 #include <algorithm>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
@@ skipping 209 matching lines @@
 
 //
 // Extension
 //
 
 // static
 scoped_refptr<Extension> Extension::Create(const FilePath& path,
                                            Location location,
                                            const DictionaryValue& value,
                                            int flags,
-                                           std::string* error) {
-  DCHECK(error);
+                                           std::string* utf8_error) {
+  DCHECK(utf8_error);
+  string16 error;
   scoped_refptr<Extension> extension = new Extension(path, location);
 
   if (!extension->InitFromValue(new extensions::Manifest(value.DeepCopy()),
-                                flags, error))
+                                flags, &error)) {
+    *utf8_error = UTF16ToUTF8(error);
     return NULL;
+  }
   return extension;
 }
 
 scoped_refptr<Extension> Extension::CreateWithId(const FilePath& path,
                                                  Location location,
                                                  const DictionaryValue& value,
                                                  int flags,
                                                  const std::string& explicit_id,
                                                  std::string* error) {
   scoped_refptr<Extension> extension = Create(
@@ skipping 130 matching lines @@
   ConvertHexadecimalToIDAlphabet(output);
 
   return true;
 }
 
 // Helper method that loads a UserScript object from a dictionary in the
 // content_script list of the manifest.
 bool Extension::LoadUserScriptHelper(const DictionaryValue* content_script,
                                      int definition_index,
                                      int flags,
-                                     std::string* error,
+                                     string16* error,
                                      UserScript* result) {
   // When strict error checks are enabled, make URL pattern parsing strict.
   URLPattern::ParseOption parse_option =
       (flags & STRICT_ERROR_CHECKS ? URLPattern::ERROR_ON_PORTS
                                    : URLPattern::IGNORE_PORTS);
 
   // run_at
   if (content_script->HasKey(keys::kRunAt)) {
     std::string run_location;
     if (!content_script->GetString(keys::kRunAt, &run_location)) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidRunAt,
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+          errors::kInvalidRunAt,
           base::IntToString(definition_index));
       return false;
     }
 
     if (run_location == values::kRunAtDocumentStart) {
       result->set_run_location(UserScript::DOCUMENT_START);
     } else if (run_location == values::kRunAtDocumentEnd) {
       result->set_run_location(UserScript::DOCUMENT_END);
     } else if (run_location == values::kRunAtDocumentIdle) {
       result->set_run_location(UserScript::DOCUMENT_IDLE);
     } else {
-      *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidRunAt,
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+          errors::kInvalidRunAt,
           base::IntToString(definition_index));
       return false;
     }
   }
 
   // all frames
   if (content_script->HasKey(keys::kAllFrames)) {
     bool all_frames = false;
     if (!content_script->GetBoolean(keys::kAllFrames, &all_frames)) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidAllFrames, base::IntToString(definition_index));
       return false;
     }
     result->set_match_all_frames(all_frames);
   }
 
   // matches (required)
   ListValue* matches = NULL;
   if (!content_script->GetList(keys::kMatches, &matches)) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidMatches,
+    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        errors::kInvalidMatches,
         base::IntToString(definition_index));
     return false;
   }
 
   if (matches->GetSize() == 0) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidMatchCount,
+    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        errors::kInvalidMatchCount,
         base::IntToString(definition_index));
     return false;
   }
   for (size_t j = 0; j < matches->GetSize(); ++j) {
     std::string match_str;
     if (!matches->GetString(j, &match_str)) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidMatch,
           base::IntToString(definition_index),
           base::IntToString(j),
           errors::kExpectString);
       return false;
     }
 
     URLPattern pattern(parse_option, UserScript::kValidUserScriptSchemes);
     if (CanExecuteScriptEverywhere())
       pattern.SetValidSchemes(URLPattern::SCHEME_ALL);
 
     URLPattern::ParseResult parse_result = pattern.Parse(match_str);
     if (parse_result != URLPattern::PARSE_SUCCESS) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidMatch,
           base::IntToString(definition_index),
           base::IntToString(j),
           URLPattern::GetParseResultString(parse_result));
       return false;
     }
 
     if (pattern.MatchesScheme(chrome::kFileScheme) &&
         !CanExecuteScriptEverywhere()) {
       wants_file_access_ = true;
       if (!(flags & ALLOW_FILE_ACCESS))
         pattern.SetValidSchemes(
             pattern.valid_schemes() & ~URLPattern::SCHEME_FILE);
     }
 
     result->add_url_pattern(pattern);
   }
 
   // exclude_matches
   if (content_script->HasKey(keys::kExcludeMatches)) {  // optional
     ListValue* exclude_matches = NULL;
     if (!content_script->GetList(keys::kExcludeMatches, &exclude_matches)) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidExcludeMatches,
           base::IntToString(definition_index));
       return false;
     }
 
     for (size_t j = 0; j < exclude_matches->GetSize(); ++j) {
       std::string match_str;
       if (!exclude_matches->GetString(j, &match_str)) {
-        *error = ExtensionErrorUtils::FormatErrorMessage(
+        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidExcludeMatch,
             base::IntToString(definition_index),
             base::IntToString(j),
             errors::kExpectString);
         return false;
       }
 
       URLPattern pattern(parse_option, UserScript::kValidUserScriptSchemes);
       if (CanExecuteScriptEverywhere())
         pattern.SetValidSchemes(URLPattern::SCHEME_ALL);
       URLPattern::ParseResult parse_result = pattern.Parse(match_str);
       if (parse_result != URLPattern::PARSE_SUCCESS) {
-        *error = ExtensionErrorUtils::FormatErrorMessage(
+        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidExcludeMatch,
             base::IntToString(definition_index), base::IntToString(j),
             URLPattern::GetParseResultString(parse_result));
         return false;
       }
 
       result->add_exclude_url_pattern(pattern);
     }
   }
 
   // include/exclude globs (mostly for Greasemonkey compatibility)
   if (!LoadGlobsHelper(content_script, definition_index, keys::kIncludeGlobs,
                        error, &UserScript::add_glob, result)) {
       return false;
   }
 
   if (!LoadGlobsHelper(content_script, definition_index, keys::kExcludeGlobs,
                        error, &UserScript::add_exclude_glob, result)) {
       return false;
   }
 
   // js and css keys
   ListValue* js = NULL;
   if (content_script->HasKey(keys::kJs) &&
       !content_script->GetList(keys::kJs, &js)) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidJsList,
+    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        errors::kInvalidJsList,
         base::IntToString(definition_index));
     return false;
   }
 
   ListValue* css = NULL;
   if (content_script->HasKey(keys::kCss) &&
       !content_script->GetList(keys::kCss, &css)) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidCssList,
+    *error = ExtensionErrorUtils::
+        FormatErrorMessageUTF16(errors::kInvalidCssList,
         base::IntToString(definition_index));
     return false;
   }
 
   // The manifest needs to have at least one js or css user script definition.
   if (((js ? js->GetSize() : 0) + (css ? css->GetSize() : 0)) == 0) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(errors::kMissingFile,
+    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        errors::kMissingFile,
         base::IntToString(definition_index));
     return false;
   }
 
   if (js) {
     for (size_t script_index = 0; script_index < js->GetSize();
          ++script_index) {
       Value* value;
       std::string relative;
       if (!js->Get(script_index, &value) || !value->GetAsString(&relative)) {
-        *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidJs,
+        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+            errors::kInvalidJs,
             base::IntToString(definition_index),
             base::IntToString(script_index));
         return false;
       }
       GURL url = GetResourceURL(relative);
       ExtensionResource resource = GetResource(relative);
       result->js_scripts().push_back(UserScript::File(
           resource.extension_root(), resource.relative_path(), url));
     }
   }
 
   if (css) {
     for (size_t script_index = 0; script_index < css->GetSize();
          ++script_index) {
       Value* value;
       std::string relative;
       if (!css->Get(script_index, &value) || !value->GetAsString(&relative)) {
-        *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidCss,
+        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+            errors::kInvalidCss,
             base::IntToString(definition_index),
             base::IntToString(script_index));
         return false;
       }
       GURL url = GetResourceURL(relative);
       ExtensionResource resource = GetResource(relative);
       result->css_scripts().push_back(UserScript::File(
           resource.extension_root(), resource.relative_path(), url));
     }
   }
 
   return true;
 }
 
 bool Extension::LoadGlobsHelper(
     const DictionaryValue* content_script,
     int content_script_index,
     const char* globs_property_name,
-    std::string* error,
+    string16* error,
     void(UserScript::*add_method)(const std::string& glob),
     UserScript *instance) {
   if (!content_script->HasKey(globs_property_name))
     return true;  // they are optional
 
   ListValue* list = NULL;
   if (!content_script->GetList(globs_property_name, &list)) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidGlobList,
+    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        errors::kInvalidGlobList,
         base::IntToString(content_script_index),
         globs_property_name);
     return false;
   }
 
   for (size_t i = 0; i < list->GetSize(); ++i) {
     std::string glob;
     if (!list->GetString(i, &glob)) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(errors::kInvalidGlob,
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+          errors::kInvalidGlob,
           base::IntToString(content_script_index),
           globs_property_name,
           base::IntToString(i));
       return false;
     }
 
     (instance->*add_method)(glob);
   }
 
   return true;
 }
 
 ExtensionAction* Extension::LoadExtensionActionHelper(
-    const DictionaryValue* extension_action, std::string* error) {
+    const DictionaryValue* extension_action, string16* error) {
   scoped_ptr<ExtensionAction> result(new ExtensionAction());
   result->set_extension_id(id());
 
   // Page actions are hidden by default, and browser actions ignore
   // visibility.
   result->SetIsVisible(ExtensionAction::kDefaultTabId, false);
 
   // TODO(EXTENSIONS_DEPRECATED): icons list is obsolete.
   ListValue* icons = NULL;
   if (extension_action->HasKey(keys::kPageActionIcons) &&
       extension_action->GetList(keys::kPageActionIcons, &icons)) {
     for (ListValue::const_iterator iter = icons->begin();
          iter != icons->end(); ++iter) {
       std::string path;
       if (!(*iter)->GetAsString(&path) || path.empty()) {
-        *error = errors::kInvalidPageActionIconPath;
+        *error = ASCIIToUTF16(errors::kInvalidPageActionIconPath);
         return NULL;
       }
 
       result->icon_paths()->push_back(path);
     }
   }
 
   // TODO(EXTENSIONS_DEPRECATED): Read the page action |id| (optional).
   std::string id;
   if (extension_action->HasKey(keys::kPageActionId)) {
     if (!extension_action->GetString(keys::kPageActionId, &id)) {
-      *error = errors::kInvalidPageActionId;
+      *error = ASCIIToUTF16(errors::kInvalidPageActionId);
       return NULL;
     }
     result->set_id(id);
   }
 
   std::string default_icon;
   // Read the page action |default_icon| (optional).
   if (extension_action->HasKey(keys::kPageActionDefaultIcon)) {
     if (!extension_action->GetString(keys::kPageActionDefaultIcon,
                                      &default_icon) ||
         default_icon.empty()) {
-      *error = errors::kInvalidPageActionIconPath;
+      *error = ASCIIToUTF16(errors::kInvalidPageActionIconPath);
       return NULL;
     }
     result->set_default_icon_path(default_icon);
   }
 
   // Read the page action title from |default_title| if present, |name| if not
   // (both optional).
   std::string title;
   if (extension_action->HasKey(keys::kPageActionDefaultTitle)) {
     if (!extension_action->GetString(keys::kPageActionDefaultTitle, &title)) {
-      *error = errors::kInvalidPageActionDefaultTitle;
+      *error = ASCIIToUTF16(errors::kInvalidPageActionDefaultTitle);
       return NULL;
     }
   } else if (extension_action->HasKey(keys::kName)) {
     if (!extension_action->GetString(keys::kName, &title)) {
-      *error = errors::kInvalidPageActionName;
+      *error = ASCIIToUTF16(errors::kInvalidPageActionName);
       return NULL;
     }
   }
   result->SetTitle(ExtensionAction::kDefaultTabId, title);
 
   // Read the action's |popup| (optional).
   const char* popup_key = NULL;
   if (extension_action->HasKey(keys::kPageActionDefaultPopup))
     popup_key = keys::kPageActionDefaultPopup;
 
   // For backward compatibility, alias old key "popup" to new
   // key "default_popup".
   if (extension_action->HasKey(keys::kPageActionPopup)) {
     if (popup_key) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidPageActionOldAndNewKeys,
           keys::kPageActionDefaultPopup,
           keys::kPageActionPopup);
       return NULL;
     }
     popup_key = keys::kPageActionPopup;
   }
 
   if (popup_key) {
     DictionaryValue* popup = NULL;
     std::string url_str;
 
     if (extension_action->GetString(popup_key, &url_str)) {
       // On success, |url_str| is set.  Nothing else to do.
     } else if (extension_action->GetDictionary(popup_key, &popup)) {
       // TODO(EXTENSIONS_DEPRECATED): popup is now a string only.
       // Support the old dictionary format for backward compatibility.
       if (!popup->GetString(keys::kPageActionPopupPath, &url_str)) {
-        *error = ExtensionErrorUtils::FormatErrorMessage(
+        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidPageActionPopupPath, "<missing>");
         return NULL;
       }
     } else {
-      *error = errors::kInvalidPageActionPopup;
+      *error = ASCIIToUTF16(errors::kInvalidPageActionPopup);
       return NULL;
     }
 
     if (!url_str.empty()) {
       // An empty string is treated as having no popup.
       GURL url = GetResourceURL(url_str);
       if (!url.is_valid()) {
-        *error = ExtensionErrorUtils::FormatErrorMessage(
+        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidPageActionPopupPath, url_str);
         return NULL;
       }
       result->SetPopupUrl(ExtensionAction::kDefaultTabId, url);
     } else {
       DCHECK(!result->HasPopup(ExtensionAction::kDefaultTabId))
           << "Shouldn't be possible for the popup to be set.";
     }
   }
 
   return result.release();
 }
 
 Extension::FileBrowserHandlerList* Extension::LoadFileBrowserHandlers(
-    const ListValue* extension_actions, std::string* error) {
+    const ListValue* extension_actions, string16* error) {
   scoped_ptr<FileBrowserHandlerList> result(
       new FileBrowserHandlerList());
   for (ListValue::const_iterator iter = extension_actions->begin();
        iter != extension_actions->end();
        ++iter) {
     if (!(*iter)->IsType(Value::TYPE_DICTIONARY)) {
-      *error = errors::kInvalidFileBrowserHandler;
+      *error = ASCIIToUTF16(errors::kInvalidFileBrowserHandler);
       return NULL;
     }
     scoped_ptr<FileBrowserHandler> action(
         LoadFileBrowserHandler(
             reinterpret_cast<DictionaryValue*>(*iter), error));
     if (!action.get())
       return NULL;  // Failed to parse file browser action definition.
     result->push_back(linked_ptr<FileBrowserHandler>(action.release()));
   }
   return result.release();
 }
 
 FileBrowserHandler* Extension::LoadFileBrowserHandler(
-    const DictionaryValue* file_browser_handler, std::string* error) {
+    const DictionaryValue* file_browser_handler, string16* error) {
   scoped_ptr<FileBrowserHandler> result(
       new FileBrowserHandler());
   result->set_extension_id(id());
 
   std::string id;
   // Read the file action |id| (mandatory).
   if (!file_browser_handler->HasKey(keys::kPageActionId) ||
       !file_browser_handler->GetString(keys::kPageActionId, &id)) {
-    *error = errors::kInvalidPageActionId;
+    *error = ASCIIToUTF16(errors::kInvalidPageActionId);
     return NULL;
   }
   result->set_id(id);
 
   // Read the page action title from |default_title| (mandatory).
   std::string title;
   if (!file_browser_handler->HasKey(keys::kPageActionDefaultTitle) ||
       !file_browser_handler->GetString(keys::kPageActionDefaultTitle, &title)) {
-    *error = errors::kInvalidPageActionDefaultTitle;
+    *error = ASCIIToUTF16(errors::kInvalidPageActionDefaultTitle);
     return NULL;
   }
   result->set_title(title);
 
   // Initialize file filters (mandatory).
   ListValue* list_value = NULL;
   if (!file_browser_handler->HasKey(keys::kFileFilters) ||
       !file_browser_handler->GetList(keys::kFileFilters, &list_value) ||
       list_value->empty()) {
-    *error = errors::kInvalidFileFiltersList;
+    *error = ASCIIToUTF16(errors::kInvalidFileFiltersList);
     return NULL;
   }
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
     std::string filter;
     if (!list_value->GetString(i, &filter)) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidFileFilterValue, base::IntToString(i));
       return NULL;
     }
     StringToLowerASCII(&filter);
     URLPattern pattern(URLPattern::USE_PORTS, URLPattern::SCHEME_FILESYSTEM);
     if (pattern.Parse(filter) != URLPattern::PARSE_SUCCESS) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidURLPatternError, filter);
       return NULL;
     }
     std::string path = pattern.path();
     bool allowed = path == "*" || path == "*.*" ||
         (path.compare(0, 2, "*.") == 0 &&
          path.find_first_of('*', 2) == std::string::npos);
     if (!allowed) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidURLPatternError, filter);
       return NULL;
     }
     result->AddPattern(pattern);
   }
 
   std::string default_icon;
   // Read the file browser action |default_icon| (optional).
   if (file_browser_handler->HasKey(keys::kPageActionDefaultIcon)) {
     if (!file_browser_handler->GetString(
             keys::kPageActionDefaultIcon,&default_icon) ||
         default_icon.empty()) {
-      *error = errors::kInvalidPageActionIconPath;
+      *error = ASCIIToUTF16(errors::kInvalidPageActionIconPath);
       return NULL;
     }
     result->set_icon_path(default_icon);
   }
 
   return result.release();
 }
 
 ExtensionSidebarDefaults* Extension::LoadExtensionSidebarDefaults(
-    const DictionaryValue* extension_sidebar, std::string* error) {
+    const DictionaryValue* extension_sidebar, string16* error) {
   scoped_ptr<ExtensionSidebarDefaults> result(new ExtensionSidebarDefaults());
 
   std::string default_icon;
   // Read sidebar's |default_icon| (optional).
   if (extension_sidebar->HasKey(keys::kSidebarDefaultIcon)) {
     if (!extension_sidebar->GetString(keys::kSidebarDefaultIcon,
                                       &default_icon) ||
         default_icon.empty()) {
-      *error = errors::kInvalidSidebarDefaultIconPath;
+      *error = ASCIIToUTF16(errors::kInvalidSidebarDefaultIconPath);
       return NULL;
     }
     result->set_default_icon_path(default_icon);
   }
 
   // Read sidebar's |default_title| (optional).
   string16 default_title;
   if (extension_sidebar->HasKey(keys::kSidebarDefaultTitle)) {
     if (!extension_sidebar->GetString(keys::kSidebarDefaultTitle,
                                       &default_title)) {
-      *error = errors::kInvalidSidebarDefaultTitle;
+      *error = ASCIIToUTF16(errors::kInvalidSidebarDefaultTitle);
       return NULL;
     }
   }
   result->set_default_title(default_title);
 
   // Read sidebar's |default_page| (optional).
+  // TODO(rdevlin.cronin): Continue removing std::string errors and replace
+  //  with string16
   std::string default_page;
+  std::string utf8_error;
   if (extension_sidebar->HasKey(keys::kSidebarDefaultPage)) {
     if (!extension_sidebar->GetString(keys::kSidebarDefaultPage,
                                       &default_page) ||
         default_page.empty()) {
-      *error = errors::kInvalidSidebarDefaultPage;
+      *error = ASCIIToUTF16(errors::kInvalidSidebarDefaultPage);
       return NULL;
     }
     GURL url = extension_sidebar_utils::ResolveRelativePath(
-        default_page, this, error);
+        default_page, this, &utf8_error);
+    *error = UTF8ToUTF16(utf8_error);
     if (!url.is_valid())
       return NULL;
     result->set_default_page(url);
   }
 
   return result.release();
 }
 
 bool Extension::LoadExtent(const extensions::Manifest* manifest,
                            const char* key,
                            URLPatternSet* extent,
                            const char* list_error,
                            const char* value_error,
                            URLPattern::ParseOption parse_option,
-                           std::string* error) {
+                           string16* error) {
   Value* temp = NULL;
   if (!manifest->Get(key, &temp))
     return true;
 
   if (temp->GetType() != Value::TYPE_LIST) {
-    *error = list_error;
+    *error = ASCIIToUTF16(list_error);
     return false;
   }
 
   ListValue* pattern_list = static_cast<ListValue*>(temp);
   for (size_t i = 0; i < pattern_list->GetSize(); ++i) {
     std::string pattern_string;
     if (!pattern_list->GetString(i, &pattern_string)) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(value_error,
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(value_error,
                                                        base::UintToString(i),
                                                        errors::kExpectString);
       return false;
     }
 
     URLPattern pattern(parse_option, kValidWebExtentSchemes);
     URLPattern::ParseResult parse_result = pattern.Parse(pattern_string);
     if (parse_result == URLPattern::PARSE_ERROR_EMPTY_PATH) {
       pattern_string += "/";
       parse_result = pattern.Parse(pattern_string);
     }
 
     if (parse_result != URLPattern::PARSE_SUCCESS) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           value_error,
           base::UintToString(i),
           URLPattern::GetParseResultString(parse_result));
       return false;
     }
 
     // Do not allow authors to claim "<all_urls>".
     if (pattern.match_all_urls()) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           value_error,
           base::UintToString(i),
           errors::kCannotClaimAllURLsInExtent);
       return false;
     }
 
     // Do not allow authors to claim "*" for host.
     if (pattern.host().empty()) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           value_error,
           base::UintToString(i),
           errors::kCannotClaimAllHostsInExtent);
       return false;
     }
 
     // We do not allow authors to put wildcards in their paths. Instead, we
     // imply one at the end.
     if (pattern.path().find('*') != std::string::npos) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           value_error,
           base::UintToString(i),
           errors::kNoWildCardsInPaths);
       return false;
     }
     pattern.SetPath(pattern.path() + '*');
 
     extent->AddPattern(pattern);
   }
 
   return true;
 }
 
 bool Extension::LoadLaunchURL(const extensions::Manifest* manifest,
-                              std::string* error) {
+                              string16* error) {
   Value* temp = NULL;
 
   // launch URL can be either local (to chrome-extension:// root) or an absolute
   // web URL.
   if (manifest->Get(keys::kLaunchLocalPath, &temp)) {
     if (manifest->Get(keys::kLaunchWebURL, NULL)) {
-      *error = errors::kLaunchPathAndURLAreExclusive;
+      *error = ASCIIToUTF16(errors::kLaunchPathAndURLAreExclusive);
       return false;
     }
 
     if (manifest->Get(keys::kWebURLs, NULL)) {
-      *error = errors::kLaunchPathAndExtentAreExclusive;
+      *error = ASCIIToUTF16(errors::kLaunchPathAndExtentAreExclusive);
       return false;
     }
 
     std::string launch_path;
     if (!temp->GetAsString(&launch_path)) {
-      *error = errors::kInvalidLaunchLocalPath;
+      *error = ASCIIToUTF16(errors::kInvalidLaunchLocalPath);
       return false;
     }
 
     // Ensure the launch path is a valid relative URL.
     GURL resolved = url().Resolve(launch_path);
     if (!resolved.is_valid() || resolved.GetOrigin() != url()) {
-      *error = errors::kInvalidLaunchLocalPath;
+      *error = ASCIIToUTF16(errors::kInvalidLaunchLocalPath);
       return false;
     }
 
     launch_local_path_ = launch_path;
   } else if (manifest->Get(keys::kLaunchWebURL, &temp)) {
     std::string launch_url;
     if (!temp->GetAsString(&launch_url)) {
-      *error = errors::kInvalidLaunchWebURL;
+      *error = ASCIIToUTF16(errors::kInvalidLaunchWebURL);
       return false;
     }
 
     // Ensure the launch URL is a valid absolute URL and web extent scheme.
     GURL url(launch_url);
     URLPattern pattern(URLPattern::USE_PORTS, kValidWebExtentSchemes);
     if (!url.is_valid() || !pattern.SetScheme(url.scheme())) {
-      *error = errors::kInvalidLaunchWebURL;
+      *error = ASCIIToUTF16(errors::kInvalidLaunchWebURL);
       return false;
     }
 
     launch_web_url_ = launch_url;
   } else if (is_app()) {
-    *error = errors::kLaunchURLRequired;
+    *error = ASCIIToUTF16(errors::kLaunchURLRequired);
     return false;
   }
 
   // If there is no extent, we default the extent based on the launch URL.
   if (web_extent().is_empty() && !launch_web_url().empty()) {
     GURL launch_url(launch_web_url());
     URLPattern pattern(URLPattern::USE_PORTS, kValidWebExtentSchemes);
     if (!pattern.SetScheme("*")) {
-      *error = errors::kInvalidLaunchWebURL;
+      *error = ASCIIToUTF16(errors::kInvalidLaunchWebURL);
       return false;
     }
     pattern.SetHost(launch_url.host());
     pattern.SetPath("/*");
     extent_.AddPattern(pattern);
   }
 
   // In order for the --apps-gallery-url switch to work with the gallery
   // process isolation, we must insert any provided value into the component
   // app's launch url and web extent.
@@ skipping 21 matching lines @@
       replacements.SetPathStr(path);
       GURL cloud_print_enable_connector_url =
           cloud_print_service_url.ReplaceComponents(replacements);
       OverrideLaunchUrl(cloud_print_enable_connector_url);
     }
   }
   return true;
 }
 
 bool Extension::LoadLaunchContainer(const extensions::Manifest* manifest,
-                                    std::string* error) {
+                                    string16* error) {
   Value* temp = NULL;
   if (!manifest->Get(keys::kLaunchContainer, &temp))
     return true;
 
   std::string launch_container_string;
   if (!temp->GetAsString(&launch_container_string)) {
-    *error = errors::kInvalidLaunchContainer;
+    *error = ASCIIToUTF16(errors::kInvalidLaunchContainer);
     return false;
   }
 
   if (launch_container_string == values::kLaunchContainerShell) {
     launch_container_ = extension_misc::LAUNCH_SHELL;
   } else if (launch_container_string == values::kLaunchContainerPanel) {
     launch_container_ = extension_misc::LAUNCH_PANEL;
   } else if (launch_container_string == values::kLaunchContainerTab) {
     launch_container_ = extension_misc::LAUNCH_TAB;
   } else {
-    *error = errors::kInvalidLaunchContainer;
+    *error = ASCIIToUTF16(errors::kInvalidLaunchContainer);
     return false;
   }
 
   // Validate the container width if present.
   if (manifest->Get(keys::kLaunchWidth, &temp)) {
     if (launch_container() != extension_misc::LAUNCH_PANEL &&
         launch_container() != extension_misc::LAUNCH_WINDOW) {
-      *error = errors::kInvalidLaunchWidthContainer;
+      *error = ASCIIToUTF16(errors::kInvalidLaunchWidthContainer);
       return false;
     }
     if (!temp->GetAsInteger(&launch_width_) ||
         launch_width_ < 0) {
       launch_width_ = 0;
-      *error = errors::kInvalidLaunchWidth;
+      *error = ASCIIToUTF16(errors::kInvalidLaunchWidth);
       return false;
     }
   }
 
   // Validate container height if present.
   if (manifest->Get(keys::kLaunchHeight, &temp)) {
     if (launch_container() != extension_misc::LAUNCH_PANEL &&
         launch_container() != extension_misc::LAUNCH_WINDOW) {
-      *error = errors::kInvalidLaunchHeightContainer;
+      *error = ASCIIToUTF16(errors::kInvalidLaunchHeightContainer);
       return false;
     }
     if (!temp->GetAsInteger(&launch_height_) || launch_height_ < 0) {
       launch_height_ = 0;
-      *error = errors::kInvalidLaunchHeight;
+      *error = ASCIIToUTF16(errors::kInvalidLaunchHeight);
       return false;
     }
   }
 
   return true;
 }
 
 bool Extension::LoadAppIsolation(const extensions::Manifest* manifest,
-                                 std::string* error) {
+                                 string16* error) {
   Value* temp = NULL;
   if (!manifest->Get(keys::kIsolation, &temp))
     return true;
 
   if (temp->GetType() != Value::TYPE_LIST) {
-    *error = errors::kInvalidIsolation;
+    *error = ASCIIToUTF16(errors::kInvalidIsolation);
     return false;
   }
 
   ListValue* isolation_list = static_cast<ListValue*>(temp);
   for (size_t i = 0; i < isolation_list->GetSize(); ++i) {
     std::string isolation_string;
     if (!isolation_list->GetString(i, &isolation_string)) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidIsolationValue,
           base::UintToString(i));
       return false;
     }
 
     // Check for isolated storage.
     if (isolation_string == values::kIsolatedStorage) {
       is_storage_isolated_ = true;
     } else {
       DLOG(WARNING) << "Did not recognize isolation type: "
                     << isolation_string;
     }
   }
   return true;
 }
 
 bool Extension::LoadWebIntentServices(const extensions::Manifest* manifest,
-                                      std::string* error) {
+                                      string16* error) {
   DCHECK(error);
 
   if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableWebIntents))
     return true;
 
   if (!manifest->HasKey(keys::kIntents))
     return true;
 
   DictionaryValue* all_services = NULL;
   if (!manifest->GetDictionary(keys::kIntents, &all_services)) {
-    *error = errors::kInvalidIntents;
+    *error = ASCIIToUTF16(errors::kInvalidIntents);
     return false;
   }
 
   std::string value;
   for (DictionaryValue::key_iterator iter(all_services->begin_keys());
        iter != all_services->end_keys(); ++iter) {
     webkit_glue::WebIntentServiceData service;
 
     DictionaryValue* one_service = NULL;
     if (!all_services->GetDictionaryWithoutPathExpansion(*iter, &one_service)) {
-      *error = errors::kInvalidIntent;
+      *error = ASCIIToUTF16(errors::kInvalidIntent);
       return false;
     }
     service.action = UTF8ToUTF16(*iter);
 
     // TODO(groby): Support an array of types.
     if (one_service->HasKey(keys::kIntentType) &&
         !one_service->GetString(keys::kIntentType, &service.type)) {
-      *error = errors::kInvalidIntentType;
+      *error = ASCIIToUTF16(errors::kInvalidIntentType);
       return false;
     }
 
     if (one_service->HasKey(keys::kIntentPath)) {
       if (!one_service->GetString(keys::kIntentPath, &value)) {
-        *error = errors::kInvalidIntentPath;
+        *error = ASCIIToUTF16(errors::kInvalidIntentPath);
         return false;
       }
       service.service_url = GetResourceURL(value);
     }
 
     if (one_service->HasKey(keys::kIntentTitle) &&
         !one_service->GetString(keys::kIntentTitle, &service.title)) {
-      *error = errors::kInvalidIntentTitle;
+      *error = ASCIIToUTF16(errors::kInvalidIntentTitle);
       return false;
     }
 
     if (one_service->HasKey(keys::kIntentDisposition)) {
       if (!one_service->GetString(keys::kIntentDisposition, &value) ||
           (value != values::kIntentDispositionWindow &&
            value != values::kIntentDispositionInline)) {
-        *error = errors::kInvalidIntentDisposition;
+        *error = ASCIIToUTF16(errors::kInvalidIntentDisposition);
         return false;
       }
       if (value == values::kIntentDispositionInline) {
         service.disposition =
             webkit_glue::WebIntentServiceData::DISPOSITION_INLINE;
       } else {
         service.disposition =
             webkit_glue::WebIntentServiceData::DISPOSITION_WINDOW;
       }
     }
@@ skipping 167 matching lines @@
         IDR_EXTENSION_DEFAULT_ICON);
   }
 }
 
 GURL Extension::GetBaseURLFromExtensionId(const std::string& extension_id) {
   return GURL(std::string(chrome::kExtensionScheme) +
               chrome::kStandardSchemeSeparator + extension_id + "/");
 }
 
 bool Extension::InitFromValue(extensions::Manifest* manifest, int flags,
-                              std::string* error) {
+                              string16* error) {
   DCHECK(error);
   base::AutoLock auto_lock(runtime_data_lock_);
   manifest_.reset(manifest);
 
   if (!manifest->ValidateManifest(error))
     return false;
 
   // When strict error checks are enabled, make URL pattern parsing strict.
   URLPattern::ParseOption parse_option =
       (flags & STRICT_ERROR_CHECKS ? URLPattern::ERROR_ON_PORTS
                                    : URLPattern::IGNORE_PORTS);
 
   // Initialize permissions with an empty, default permission set.
   runtime_data_.SetActivePermissions(new ExtensionPermissionSet());
   optional_permission_set_ = new ExtensionPermissionSet();
   required_permission_set_ = new ExtensionPermissionSet();
 
   if (manifest->HasKey(keys::kManifestVersion)) {
     int manifest_version = 0;
     if (!manifest->GetInteger(keys::kManifestVersion, &manifest_version) ||
         manifest_version < 1) {
-      *error = errors::kInvalidManifestVersion;
+      *error = ASCIIToUTF16(errors::kInvalidManifestVersion);
       return false;
     }
     manifest_version_ = manifest_version;
   } else {
     // Version 1 was the original version, which lacked a version indicator.
     manifest_version_ = 1;
   }
 
   if (flags & REQUIRE_MODERN_MANIFEST_VERSION &&
       manifest_version() < kModernManifestVersion &&
       !CommandLine::ForCurrentProcess()->HasSwitch(
                 switches::kAllowLegacyExtensionManifests)) {
-    *error = errors::kInvalidManifestVersion;
+    *error = ASCIIToUTF16(errors::kInvalidManifestVersion);
     return false;
   }
 
   if (manifest->HasKey(keys::kPublicKey)) {
     std::string public_key_bytes;
     if (!manifest->GetString(keys::kPublicKey,
                          &public_key_) ||
         !ParsePEMKeyBytes(public_key_,
                           &public_key_bytes) ||
         !GenerateId(public_key_bytes, &id_)) {
-      *error = errors::kInvalidKey;
+      *error = ASCIIToUTF16(errors::kInvalidKey);
       return false;
     }
   } else if (flags & REQUIRE_KEY) {
-    *error = errors::kInvalidKey;
+    *error = 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.
     id_ = Extension::GenerateIdForPath(path());
     if (id_.empty()) {
       NOTREACHED() << "Could not create ID from path.";
       return false;
     }
   }
 
   creation_flags_ = flags;
 
   // Initialize the URL.
   extension_url_ = Extension::GetBaseURLFromExtensionId(id());
 
   // Initialize version.
   std::string version_str;
   if (!manifest->GetString(keys::kVersion, &version_str)) {
-    *error = errors::kInvalidVersion;
+    *error = ASCIIToUTF16(errors::kInvalidVersion);
     return false;
   }
   version_.reset(Version::GetVersionFromString(version_str));
   if (!version_.get() ||
       version_->components().size() > 4) {
-    *error = errors::kInvalidVersion;
+    *error = ASCIIToUTF16(errors::kInvalidVersion);
     return false;
   }
 
   // Initialize name.
   string16 localized_name;
   if (!manifest->GetString(keys::kName, &localized_name)) {
-    *error = errors::kInvalidName;
+    *error = ASCIIToUTF16(errors::kInvalidName);
     return false;
   }
   base::i18n::AdjustStringForLocaleDirection(&localized_name);
   name_ = UTF16ToUTF8(localized_name);
 
   // Load App settings. LoadExtent at least has to be done before
   // ParsePermissions(), because the valid permissions depend on what type of
   // package this is.
   if (is_app() &&
       (!LoadExtent(manifest_.get(), keys::kWebURLs,
                    &extent_,
                    errors::kInvalidWebURLs, errors::kInvalidWebURL,
                    parse_option, error) ||
        !LoadLaunchURL(manifest_.get(), error) ||
        !LoadLaunchContainer(manifest_.get(), error))) {
     return false;
   }
 
   if (is_platform_app()) {
     if (launch_container() != extension_misc::LAUNCH_SHELL) {
-      *error = errors::kInvalidLaunchContainerForPlatform;
+      *error = ASCIIToUTF16(errors::kInvalidLaunchContainerForPlatform);
       return false;
     }
   } else if (launch_container() == extension_misc::LAUNCH_SHELL) {
-    *error = errors::kInvalidLaunchContainerForNonPlatform;
+    *error = ASCIIToUTF16(errors::kInvalidLaunchContainerForNonPlatform);
     return false;
   }
 
   // Initialize the permissions (optional).
   ExtensionAPIPermissionSet api_permissions;
   URLPatternSet host_permissions;
   if (!ParsePermissions(manifest_.get(),
                         keys::kPermissions,
                         flags,
                         error,
@@ skipping 11 matching lines @@
                         error,
                         &optional_api_permissions,
                         &optional_host_permissions)) {
     return false;
   }
 
   // Initialize description (if present).
   if (manifest->HasKey(keys::kDescription)) {
     if (!manifest->GetString(keys::kDescription,
                           &description_)) {
-      *error = errors::kInvalidDescription;
+      *error = ASCIIToUTF16(errors::kInvalidDescription);
       return false;
     }
   }
 
   // Initialize homepage url (if present).
   if (manifest->HasKey(keys::kHomepageURL)) {
     std::string tmp;
     if (!manifest->GetString(keys::kHomepageURL, &tmp)) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidHomepageURL, "");
       return false;
     }
     homepage_url_ = GURL(tmp);
     if (!homepage_url_.is_valid() ||
         (!homepage_url_.SchemeIs("http") &&
             !homepage_url_.SchemeIs("https"))) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidHomepageURL, tmp);
       return false;
     }
   }
 
   // Initialize update url (if present).
   if (manifest->HasKey(keys::kUpdateURL)) {
     std::string tmp;
     if (!manifest->GetString(keys::kUpdateURL, &tmp)) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidUpdateURL, "");
       return false;
     }
     update_url_ = GURL(tmp);
     if (!update_url_.is_valid() ||
         update_url_.has_ref()) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidUpdateURL, tmp);
       return false;
     }
   }
 
   // Validate minimum Chrome version (if present). We don't need to store this,
   // since the extension is not valid if it is incorrect.
   if (manifest->HasKey(keys::kMinimumChromeVersion)) {
     std::string minimum_version_string;
     if (!manifest->GetString(keys::kMinimumChromeVersion,
                           &minimum_version_string)) {
-      *error = errors::kInvalidMinimumChromeVersion;
+      *error = ASCIIToUTF16(errors::kInvalidMinimumChromeVersion);
       return false;
     }
 
     scoped_ptr<Version> minimum_version(
         Version::GetVersionFromString(minimum_version_string));
     if (!minimum_version.get()) {
-      *error = errors::kInvalidMinimumChromeVersion;
+      *error = ASCIIToUTF16(errors::kInvalidMinimumChromeVersion);
       return false;
     }
 
     chrome::VersionInfo current_version_info;
     if (!current_version_info.is_valid()) {
       NOTREACHED();
       return false;
     }
 
     scoped_ptr<Version> current_version(
         Version::GetVersionFromString(current_version_info.Version()));
     if (!current_version.get()) {
       DCHECK(false);
       return false;
     }
 
     if (current_version->CompareTo(*minimum_version) < 0) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kChromeVersionTooLow,
           l10n_util::GetStringUTF8(IDS_PRODUCT_NAME),
           minimum_version_string);
       return false;
     }
   }
 
   // Initialize converted_from_user_script (if present)
   if (manifest->HasKey(keys::kConvertedFromUserScript))
     manifest->GetBoolean(keys::kConvertedFromUserScript,
                         &converted_from_user_script_);
 
   // Initialize icons (if present).
   if (manifest->HasKey(keys::kIcons)) {
     DictionaryValue* icons_value = NULL;
     if (!manifest->GetDictionary(keys::kIcons, &icons_value)) {
-      *error = errors::kInvalidIcons;
+      *error = ASCIIToUTF16(errors::kInvalidIcons);
       return false;
     }
 
     for (size_t i = 0; i < arraysize(kIconSizes); ++i) {
       std::string key = base::IntToString(kIconSizes[i]);
       if (icons_value->HasKey(key)) {
         std::string icon_path;
         if (!icons_value->GetString(key, &icon_path)) {
-          *error = ExtensionErrorUtils::FormatErrorMessage(
+          *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
               errors::kInvalidIconPath, key);
           return false;
         }
 
         if (!icon_path.empty() && icon_path[0] == '/')
           icon_path = icon_path.substr(1);
 
         if (icon_path.empty()) {
-          *error = ExtensionErrorUtils::FormatErrorMessage(
+          *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
               errors::kInvalidIconPath, key);
           return false;
         }
 
         icons_.Add(kIconSizes[i], icon_path);
       }
     }
   }
 
   // Initialize themes (if present).
   if (manifest->HasKey(keys::kTheme)) {
     DictionaryValue* theme_value = NULL;
     if (!manifest->GetDictionary(keys::kTheme, &theme_value)) {
-      *error = errors::kInvalidTheme;
+      *error = ASCIIToUTF16(errors::kInvalidTheme);
       return false;
     }
 
     DictionaryValue* images_value = NULL;
     if (theme_value->GetDictionary(keys::kThemeImages, &images_value)) {
       // Validate that the images are all strings
       for (DictionaryValue::key_iterator iter = images_value->begin_keys();
            iter != images_value->end_keys(); ++iter) {
         std::string val;
         if (!images_value->GetString(*iter, &val)) {
-          *error = errors::kInvalidThemeImages;
+          *error = ASCIIToUTF16(errors::kInvalidThemeImages);
           return false;
         }
       }
       theme_images_.reset(images_value->DeepCopy());
     }
 
     DictionaryValue* colors_value = NULL;
     if (theme_value->GetDictionary(keys::kThemeColors, &colors_value)) {
       // Validate that the colors are RGB or RGBA lists
       for (DictionaryValue::key_iterator iter = colors_value->begin_keys();
            iter != colors_value->end_keys(); ++iter) {
         ListValue* color_list = NULL;
         double alpha = 0.0;
         int color = 0;
         // The color must be a list
         if (!colors_value->GetListWithoutPathExpansion(*iter, &color_list) ||
             // 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 = errors::kInvalidThemeColors;
+          *error = ASCIIToUTF16(errors::kInvalidThemeColors);
           return false;
         }
       }
       theme_colors_.reset(colors_value->DeepCopy());
     }
 
     DictionaryValue* tints_value = NULL;
     if (theme_value->GetDictionary(keys::kThemeTints, &tints_value)) {
       // Validate that the tints are all reals.
       for (DictionaryValue::key_iterator iter = tints_value->begin_keys();
            iter != tints_value->end_keys(); ++iter) {
         ListValue* tint_list = NULL;
         double v = 0.0;
         if (!tints_value->GetListWithoutPathExpansion(*iter, &tint_list) ||
             tint_list->GetSize() != 3 ||
             !tint_list->GetDouble(0, &v) ||
             !tint_list->GetDouble(1, &v) ||
             !tint_list->GetDouble(2, &v)) {
-          *error = errors::kInvalidThemeTints;
+          *error = ASCIIToUTF16(errors::kInvalidThemeTints);
           return false;
         }
       }
       theme_tints_.reset(tints_value->DeepCopy());
     }
 
     DictionaryValue* display_properties_value = NULL;
     if (theme_value->GetDictionary(keys::kThemeDisplayProperties,
         &display_properties_value)) {
       theme_display_properties_.reset(
           display_properties_value->DeepCopy());
     }
 
     return true;
   }
 
   // Initialize plugins (optional).
   if (manifest->HasKey(keys::kPlugins)) {
     ListValue* list_value = NULL;
     if (!manifest->GetList(keys::kPlugins, &list_value)) {
-      *error = errors::kInvalidPlugins;
+      *error = ASCIIToUTF16(errors::kInvalidPlugins);
       return false;
     }
 
     for (size_t i = 0; i < list_value->GetSize(); ++i) {
       DictionaryValue* plugin_value = NULL;
       std::string path_str;
       bool is_public = false;
 
       if (!list_value->GetDictionary(i, &plugin_value)) {
-        *error = errors::kInvalidPlugins;
+        *error = ASCIIToUTF16(errors::kInvalidPlugins);
         return false;
       }
 
       // Get plugins[i].path.
       if (!plugin_value->GetString(keys::kPluginsPath, &path_str)) {
-        *error = ExtensionErrorUtils::FormatErrorMessage(
+        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidPluginsPath, base::IntToString(i));
         return false;
       }
 
       // Get plugins[i].content (optional).
       if (plugin_value->HasKey(keys::kPluginsPublic)) {
         if (!plugin_value->GetBoolean(keys::kPluginsPublic, &is_public)) {
-          *error = ExtensionErrorUtils::FormatErrorMessage(
+          *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
               errors::kInvalidPluginsPublic, base::IntToString(i));
           return false;
         }
       }
 
       // We don't allow extension plugins to run on Chrome OS. We still
       // parse the manifest entry so that error messages are consistently
       // displayed across platforms.
 #if !defined(OS_CHROMEOS)
       plugins_.push_back(PluginInfo());
       plugins_.back().path = path().Append(FilePath::FromUTF8Unsafe(path_str));
       plugins_.back().is_public = is_public;
 #endif
     }
   }
 
   if (manifest->HasKey(keys::kNaClModules)) {
     ListValue* list_value = NULL;
     if (!manifest->GetList(keys::kNaClModules, &list_value)) {
-      *error = errors::kInvalidNaClModules;
+      *error = ASCIIToUTF16(errors::kInvalidNaClModules);
       return false;
     }
 
     for (size_t i = 0; i < list_value->GetSize(); ++i) {
       DictionaryValue* module_value = NULL;
       std::string path_str;
       std::string mime_type;
 
       if (!list_value->GetDictionary(i, &module_value)) {
-        *error = errors::kInvalidNaClModules;
+        *error = ASCIIToUTF16(errors::kInvalidNaClModules);
         return false;
       }
 
       // Get nacl_modules[i].path.
       if (!module_value->GetString(keys::kNaClModulesPath, &path_str)) {
-        *error = ExtensionErrorUtils::FormatErrorMessage(
+        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidNaClModulesPath, base::IntToString(i));
         return false;
       }
 
       // Get nacl_modules[i].mime_type.
       if (!module_value->GetString(keys::kNaClModulesMIMEType, &mime_type)) {
-        *error = ExtensionErrorUtils::FormatErrorMessage(
+        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidNaClModulesMIMEType, base::IntToString(i));
         return false;
       }
 
       nacl_modules_.push_back(NaClModuleInfo());
       nacl_modules_.back().url = GetResourceURL(path_str);
       nacl_modules_.back().mime_type = mime_type;
     }
   }
 
   // Initialize content scripts (optional).
   if (manifest->HasKey(keys::kContentScripts)) {
     ListValue* list_value;
     if (!manifest->GetList(keys::kContentScripts, &list_value)) {
-      *error = errors::kInvalidContentScriptsList;
+      *error = ASCIIToUTF16(errors::kInvalidContentScriptsList);
       return false;
     }
 
     for (size_t i = 0; i < list_value->GetSize(); ++i) {
       DictionaryValue* content_script = NULL;
       if (!list_value->GetDictionary(i, &content_script)) {
-        *error = ExtensionErrorUtils::FormatErrorMessage(
+        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidContentScript, base::IntToString(i));
         return false;
       }
 
       UserScript script;
       if (!LoadUserScriptHelper(content_script, i, flags, error, &script))
         return false;  // Failed to parse script context definition.
       script.set_extension_id(id());
       if (converted_from_user_script_) {
         script.set_emulate_greasemonkey(true);
         script.set_match_all_frames(true);  // Greasemonkey matches all frames.
       }
       content_scripts_.push_back(script);
     }
   }
 
   // Initialize page action (optional).
   DictionaryValue* page_action_value = NULL;
 
   if (manifest->HasKey(keys::kPageActions)) {
     ListValue* list_value = NULL;
     if (!manifest->GetList(keys::kPageActions, &list_value)) {
-      *error = errors::kInvalidPageActionsList;
+      *error = ASCIIToUTF16(errors::kInvalidPageActionsList);
       return false;
     }
 
     size_t list_value_length = list_value->GetSize();
 
     if (list_value_length == 0u) {
       // A list with zero items is allowed, and is equivalent to not having
       // a page_actions key in the manifest.  Don't set |page_action_value|.
     } else if (list_value_length == 1u) {
       if (!list_value->GetDictionary(0, &page_action_value)) {
-        *error = errors::kInvalidPageAction;
+        *error = ASCIIToUTF16(errors::kInvalidPageAction);
         return false;
       }
     } else {  // list_value_length > 1u.
-      *error = errors::kInvalidPageActionsListSize;
+      *error = ASCIIToUTF16(errors::kInvalidPageActionsListSize);
       return false;
     }
   } else if (manifest->HasKey(keys::kPageAction)) {
     if (!manifest->GetDictionary(keys::kPageAction, &page_action_value)) {
-      *error = errors::kInvalidPageAction;
+      *error = ASCIIToUTF16(errors::kInvalidPageAction);
       return false;
     }
   }
 
   // If page_action_value is not NULL, then there was a valid page action.
   if (page_action_value) {
     page_action_.reset(
         LoadExtensionActionHelper(page_action_value, error));
     if (!page_action_.get())
       return false;  // Failed to parse page action definition.
   }
 
   // Initialize browser action (optional).
   if (manifest->HasKey(keys::kBrowserAction)) {
     DictionaryValue* browser_action_value = NULL;
     if (!manifest->GetDictionary(keys::kBrowserAction, &browser_action_value)) {
-      *error = errors::kInvalidBrowserAction;
+      *error = ASCIIToUTF16(errors::kInvalidBrowserAction);
       return false;
     }
 
     browser_action_.reset(
         LoadExtensionActionHelper(browser_action_value, error));
     if (!browser_action_.get())
       return false;  // Failed to parse browser action definition.
   }
 
   // Initialize file browser actions (optional).
   if (manifest->HasKey(keys::kFileBrowserHandlers)) {
     ListValue* file_browser_handlers_value = NULL;
     if (!manifest->GetList(keys::kFileBrowserHandlers,
                               &file_browser_handlers_value)) {
-      *error = errors::kInvalidFileBrowserHandler;
+      *error = ASCIIToUTF16(errors::kInvalidFileBrowserHandler);
       return false;
     }
 
     file_browser_handlers_.reset(
         LoadFileBrowserHandlers(file_browser_handlers_value, error));
     if (!file_browser_handlers_.get())
       return false;  // Failed to parse file browser actions definition.
   }
 
   // App isolation.
   if (api_permissions.count(ExtensionAPIPermission::kExperimental)) {
     if (is_app() && !LoadAppIsolation(manifest_.get(), error))
       return false;
   }
 
   // Initialize options page url (optional).
   if (manifest->HasKey(keys::kOptionsPage)) {
     std::string options_str;
     if (!manifest->GetString(keys::kOptionsPage, &options_str)) {
-      *error = errors::kInvalidOptionsPage;
+      *error = ASCIIToUTF16(errors::kInvalidOptionsPage);
       return false;
     }
 
     if (is_hosted_app()) {
       // hosted apps require an absolute URL.
       GURL options_url(options_str);
       if (!options_url.is_valid() ||
           !(options_url.SchemeIs("http") || options_url.SchemeIs("https"))) {
-        *error = errors::kInvalidOptionsPageInHostedApp;
+        *error = ASCIIToUTF16(errors::kInvalidOptionsPageInHostedApp);
         return false;
       }
       options_url_ = options_url;
     } else {
       GURL absolute(options_str);
       if (absolute.is_valid()) {
-        *error = errors::kInvalidOptionsPageExpectUrlInPackage;
+        *error = ASCIIToUTF16(errors::kInvalidOptionsPageExpectUrlInPackage);
         return false;
       }
       options_url_ = GetResourceURL(options_str);
       if (!options_url_.is_valid()) {
-        *error = errors::kInvalidOptionsPage;
+        *error = ASCIIToUTF16(errors::kInvalidOptionsPage);
         return false;
       }
     }
   }
 
   // Initialize background url (optional).
   if (manifest->HasKey(keys::kBackground)) {
     std::string background_str;
     if (!manifest->GetString(keys::kBackground, &background_str)) {
-      *error = errors::kInvalidBackground;
+      *error = ASCIIToUTF16(errors::kInvalidBackground);
       return false;
     }
 
     if (is_hosted_app()) {
       // Make sure "background" permission is set.
       if (!api_permissions.count(ExtensionAPIPermission::kBackground)) {
-        *error = errors::kBackgroundPermissionNeeded;
+        *error = ASCIIToUTF16(errors::kBackgroundPermissionNeeded);
         return false;
       }
       // Hosted apps require an absolute URL.
       GURL bg_page(background_str);
       if (!bg_page.is_valid()) {
-        *error = errors::kInvalidBackgroundInHostedApp;
+        *error = ASCIIToUTF16(errors::kInvalidBackgroundInHostedApp);
         return false;
       }
 
       if (!(bg_page.SchemeIs("https") ||
            (CommandLine::ForCurrentProcess()->HasSwitch(
                 switches::kAllowHTTPBackgroundPage) &&
             bg_page.SchemeIs("http")))) {
-        *error = errors::kInvalidBackgroundInHostedApp;
+        *error = ASCIIToUTF16(errors::kInvalidBackgroundInHostedApp);
         return false;
       }
       background_url_ = bg_page;
     } else {
       background_url_ = GetResourceURL(background_str);
     }
   }
 
   if (manifest->HasKey(keys::kDefaultLocale)) {
     if (!manifest->GetString(keys::kDefaultLocale, &default_locale_) ||
         !l10n_util::IsValidLocaleSyntax(default_locale_)) {
-      *error = errors::kInvalidDefaultLocale;
+      *error = ASCIIToUTF16(errors::kInvalidDefaultLocale);
       return false;
     }
   }
 
   // Chrome URL overrides (optional)
   if (manifest->HasKey(keys::kChromeURLOverrides)) {
     DictionaryValue* overrides = NULL;
     if (!manifest->GetDictionary(keys::kChromeURLOverrides, &overrides)) {
-      *error = errors::kInvalidChromeURLOverrides;
+      *error = ASCIIToUTF16(errors::kInvalidChromeURLOverrides);
       return false;
     }
 
     // Validate that the overrides are all strings
     for (DictionaryValue::key_iterator iter = overrides->begin_keys();
          iter != overrides->end_keys(); ++iter) {
       std::string page = *iter;
       std::string val;
       // Restrict override pages to a list of supported URLs.
       if ((page != chrome::kChromeUINewTabHost &&
 #if defined(USE_VIRTUAL_KEYBOARD)
            page != chrome::kChromeUIKeyboardHost &&
 #endif
 #if defined(OS_CHROMEOS)
            page != chrome::kChromeUIActivationMessageHost &&
 #endif
            page != chrome::kChromeUIBookmarksHost &&
            page != chrome::kChromeUIHistoryHost
 #if defined(FILE_MANAGER_EXTENSION)
                &&
            !(location() == COMPONENT &&
              page == chrome::kChromeUIFileManagerHost)
 #endif
           ) ||
           !overrides->GetStringWithoutPathExpansion(*iter, &val)) {
-        *error = errors::kInvalidChromeURLOverrides;
+        *error = ASCIIToUTF16(errors::kInvalidChromeURLOverrides);
         return false;
       }
       // Replace the entry with a fully qualified chrome-extension:// URL.
       chrome_url_overrides_[page] = GetResourceURL(val);
     }
 
     // An extension may override at most one page.
     if (overrides->size() > 1) {
-      *error = errors::kMultipleOverrides;
+      *error = ASCIIToUTF16(errors::kMultipleOverrides);
       return false;
     }
   }
 
   if (api_permissions.count(ExtensionAPIPermission::kExperimental) &&
       manifest->HasKey(keys::kInputComponents)) {
     ListValue* list_value = NULL;
     if (!manifest->GetList(keys::kInputComponents, &list_value)) {
-      *error = errors::kInvalidInputComponents;
+      *error = ASCIIToUTF16(errors::kInvalidInputComponents);
       return false;
     }
 
     for (size_t i = 0; i < list_value->GetSize(); ++i) {
       DictionaryValue* module_value = NULL;
       std::string name_str;
       InputComponentType type;
       std::string id_str;
       std::string description_str;
       std::string language_str;
       std::set<std::string> layouts;
       std::string shortcut_keycode_str;
       bool shortcut_alt = false;
       bool shortcut_ctrl = false;
       bool shortcut_shift = false;
 
       if (!list_value->GetDictionary(i, &module_value)) {
-        *error = errors::kInvalidInputComponents;
+        *error = ASCIIToUTF16(errors::kInvalidInputComponents);
         return false;
       }
 
       // Get input_components[i].name.
       if (!module_value->GetString(keys::kName, &name_str)) {
-        *error = ExtensionErrorUtils::FormatErrorMessage(
+        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidInputComponentName, base::IntToString(i));
         return false;
       }
 
       // Get input_components[i].type.
       std::string type_str;
       if (module_value->GetString(keys::kType, &type_str)) {
         if (type_str == "ime") {
           type = INPUT_COMPONENT_TYPE_IME;
         } else if (type_str == "virtual_keyboard") {
           type = INPUT_COMPONENT_TYPE_VIRTUAL_KEYBOARD;
         } else {
-          *error = ExtensionErrorUtils::FormatErrorMessage(
+          *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
               errors::kInvalidInputComponentType, base::IntToString(i));
           return false;
         }
       } else {
-        *error = ExtensionErrorUtils::FormatErrorMessage(
+        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidInputComponentType, base::IntToString(i));
         return false;
       }
 
       // Get input_components[i].id.
       if (!module_value->GetString(keys::kId, &id_str)) {
         id_str = "";
       }
 
       // Get input_components[i].description.
       if (!module_value->GetString(keys::kDescription, &description_str)) {
-        *error = ExtensionErrorUtils::FormatErrorMessage(
+        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidInputComponentDescription, base::IntToString(i));
         return false;
       }
 
       // Get input_components[i].language.
       if (!module_value->GetString(keys::kLanguage, &language_str)) {
         language_str = "";
       }
 
       // Get input_components[i].layouts.
       ListValue* layouts_value = NULL;
       if (!module_value->GetList(keys::kLayouts, &layouts_value)) {
-        *error = errors::kInvalidInputComponentLayouts;
+        *error = ASCIIToUTF16(errors::kInvalidInputComponentLayouts);
         return false;
       }
 
       for (size_t j = 0; j < layouts_value->GetSize(); ++j) {
         std::string layout_name_str;
         if (!layouts_value->GetString(j, &layout_name_str)) {
-          *error = ExtensionErrorUtils::FormatErrorMessage(
+          *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
               errors::kInvalidInputComponentLayoutName, base::IntToString(i),
               base::IntToString(j));
           return false;
         }
         layouts.insert(layout_name_str);
       }
 
       if (module_value->HasKey(keys::kShortcutKey)) {
         DictionaryValue* shortcut_value = NULL;
         if (!module_value->GetDictionary(keys::kShortcutKey, &shortcut_value)) {
-          *error = ExtensionErrorUtils::FormatErrorMessage(
+          *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
               errors::kInvalidInputComponentShortcutKey, base::IntToString(i));
           return false;
         }
 
         // Get input_components[i].shortcut_keycode.
         if (!shortcut_value->GetString(keys::kKeycode, &shortcut_keycode_str)) {
-          *error = ExtensionErrorUtils::FormatErrorMessage(
+          *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
               errors::kInvalidInputComponentShortcutKeycode,
               base::IntToString(i));
           return false;
         }
 
         // Get input_components[i].shortcut_alt.
         if (!shortcut_value->GetBoolean(keys::kAltKey, &shortcut_alt)) {
           shortcut_alt = false;
         }
 
@@ skipping 18 matching lines @@
       input_components_.back().shortcut_keycode = shortcut_keycode_str;
       input_components_.back().shortcut_alt = shortcut_alt;
       input_components_.back().shortcut_ctrl = shortcut_ctrl;
       input_components_.back().shortcut_shift = shortcut_shift;
     }
   }
 
   if (manifest->HasKey(keys::kOmnibox)) {
     if (!manifest->GetString(keys::kOmniboxKeyword, &omnibox_keyword_) ||
         omnibox_keyword_.empty()) {
-      *error = errors::kInvalidOmniboxKeyword;
+      *error = ASCIIToUTF16(errors::kInvalidOmniboxKeyword);
       return false;
     }
   }
 
   if (manifest->HasKey(keys::kContentSecurityPolicy)) {
     std::string content_security_policy;
     if (!manifest->GetString(keys::kContentSecurityPolicy,
                           &content_security_policy)) {
-      *error = errors::kInvalidContentSecurityPolicy;
+      *error = ASCIIToUTF16(errors::kInvalidContentSecurityPolicy);
       return false;
     }
     if (!ContentSecurityPolicyIsLegal(content_security_policy)) {
-      *error = errors::kInvalidContentSecurityPolicy;
+      *error = ASCIIToUTF16(errors::kInvalidContentSecurityPolicy);
       return false;
     }
     if (manifest_version_ >= 2 &&
         !ContentSecurityPolicyIsSecure(content_security_policy)) {
-      *error = errors::kInvalidContentSecurityPolicy;
+      *error = ASCIIToUTF16(errors::kInvalidContentSecurityPolicy);
       return false;
     }
 
     content_security_policy_ = content_security_policy;
   } else if (manifest_version_ >= 2) {
     // Manifest version 2 introduced a default Content-Security-Policy.
     // TODO(abarth): Should we continue to let extensions override the
     //               default Content-Security-Policy?
     content_security_policy_ = kDefaultContentSecurityPolicy;
     CHECK(ContentSecurityPolicyIsSecure(content_security_policy_));
   }
 
   // Initialize devtools page url (optional).
   if (manifest->HasKey(keys::kDevToolsPage)) {
     std::string devtools_str;
     if (!manifest->GetString(keys::kDevToolsPage, &devtools_str)) {
-      *error = errors::kInvalidDevToolsPage;
+      *error = ASCIIToUTF16(errors::kInvalidDevToolsPage);
       return false;
     }
     if (!api_permissions.count(ExtensionAPIPermission::kExperimental)) {
-      *error = errors::kDevToolsExperimental;
+      *error = ASCIIToUTF16(errors::kDevToolsExperimental);
       return false;
     }
     devtools_url_ = GetResourceURL(devtools_str);
   }
 
   // Initialize sidebar action (optional).
   if (manifest->HasKey(keys::kSidebar)) {
     DictionaryValue* sidebar_value = NULL;
     if (!manifest->GetDictionary(keys::kSidebar, &sidebar_value)) {
-      *error = errors::kInvalidSidebar;
+      *error = ASCIIToUTF16(errors::kInvalidSidebar);
       return false;
     }
     if (!api_permissions.count(ExtensionAPIPermission::kExperimental)) {
-      *error = errors::kSidebarExperimental;
+      *error = ASCIIToUTF16(errors::kSidebarExperimental);
       return false;
     }
     sidebar_defaults_.reset(LoadExtensionSidebarDefaults(sidebar_value, error));
     if (!sidebar_defaults_.get())
       return false;  // Failed to parse sidebar definition.
   }
 
   // Initialize text-to-speech voices (optional).
   if (manifest->HasKey(keys::kTtsEngine)) {
     DictionaryValue* tts_dict = NULL;
     if (!manifest->GetDictionary(keys::kTtsEngine, &tts_dict)) {
-      *error = errors::kInvalidTts;
+      *error = ASCIIToUTF16(errors::kInvalidTts);
       return false;
     }
 
     if (tts_dict->HasKey(keys::kTtsVoices)) {
       ListValue* tts_voices = NULL;
       if (!tts_dict->GetList(keys::kTtsVoices, &tts_voices)) {
-        *error = errors::kInvalidTtsVoices;
+        *error = ASCIIToUTF16(errors::kInvalidTtsVoices);
         return false;
       }
 
       for (size_t i = 0; i < tts_voices->GetSize(); i++) {
         DictionaryValue* one_tts_voice = NULL;
         if (!tts_voices->GetDictionary(i, &one_tts_voice)) {
-          *error = errors::kInvalidTtsVoices;
+          *error = ASCIIToUTF16(errors::kInvalidTtsVoices);
           return false;
         }
 
         TtsVoice voice_data;
         if (one_tts_voice->HasKey(keys::kTtsVoicesVoiceName)) {
           if (!one_tts_voice->GetString(
                   keys::kTtsVoicesVoiceName, &voice_data.voice_name)) {
-            *error = errors::kInvalidTtsVoicesVoiceName;
+            *error = ASCIIToUTF16(errors::kInvalidTtsVoicesVoiceName);
             return false;
           }
         }
         if (one_tts_voice->HasKey(keys::kTtsVoicesLang)) {
           if (!one_tts_voice->GetString(
                   keys::kTtsVoicesLang, &voice_data.lang) ||
               !l10n_util::IsValidLocaleSyntax(voice_data.lang)) {
-            *error = errors::kInvalidTtsVoicesLang;
+            *error = ASCIIToUTF16(errors::kInvalidTtsVoicesLang);
             return false;
           }
         }
         if (one_tts_voice->HasKey(keys::kTtsVoicesGender)) {
           if (!one_tts_voice->GetString(
                   keys::kTtsVoicesGender, &voice_data.gender) ||
               (voice_data.gender != keys::kTtsGenderMale &&
                voice_data.gender != keys::kTtsGenderFemale)) {
-            *error = errors::kInvalidTtsVoicesGender;
+            *error = ASCIIToUTF16(errors::kInvalidTtsVoicesGender);
             return false;
           }
         }
         if (one_tts_voice->HasKey(keys::kTtsVoicesEventTypes)) {
           ListValue* event_types_list;
           if (!one_tts_voice->GetList(
                   keys::kTtsVoicesEventTypes, &event_types_list)) {
-            *error = errors::kInvalidTtsVoicesEventTypes;
+            *error = ASCIIToUTF16(errors::kInvalidTtsVoicesEventTypes);
             return false;
           }
           for (size_t i = 0; i < event_types_list->GetSize(); i++) {
             std::string event_type;
             if (!event_types_list->GetString(i, &event_type)) {
-              *error = errors::kInvalidTtsVoicesEventTypes;
+              *error = ASCIIToUTF16(errors::kInvalidTtsVoicesEventTypes);
               return false;
             }
             if (event_type != keys::kTtsVoicesEventTypeEnd &&
                 event_type != keys::kTtsVoicesEventTypeError &&
                 event_type != keys::kTtsVoicesEventTypeMarker &&
                 event_type != keys::kTtsVoicesEventTypeSentence &&
                 event_type != keys::kTtsVoicesEventTypeStart &&
                 event_type != keys::kTtsVoicesEventTypeWord) {
-              *error = errors::kInvalidTtsVoicesEventTypes;
+              *error = ASCIIToUTF16(errors::kInvalidTtsVoicesEventTypes);
               return false;
             }
             if (voice_data.event_types.find(event_type) !=
                 voice_data.event_types.end()) {
-              *error = errors::kInvalidTtsVoicesEventTypes;
+              *error = ASCIIToUTF16(errors::kInvalidTtsVoicesEventTypes);
               return false;
             }
             voice_data.event_types.insert(event_type);
           }
         }
 
         tts_voices_.push_back(voice_data);
       }
     }
   }
 
   // Initialize web intents (optional).
   if (!LoadWebIntentServices(manifest, error))
     return false;
 
   // Initialize incognito behavior. Apps default to split mode, extensions
   // default to spanning.
   incognito_split_mode_ = is_app();
   if (manifest->HasKey(keys::kIncognito)) {
     std::string value;
     if (!manifest->GetString(keys::kIncognito, &value)) {
-      *error = errors::kInvalidIncognitoBehavior;
+      *error = ASCIIToUTF16(errors::kInvalidIncognitoBehavior);
       return false;
     }
     if (value == values::kIncognitoSpanning) {
       incognito_split_mode_ = false;
     } else if (value == values::kIncognitoSplit) {
       incognito_split_mode_ = true;
     } else {
-      *error = errors::kInvalidIncognitoBehavior;
+      *error = ASCIIToUTF16(errors::kInvalidIncognitoBehavior);
       return false;
     }
   }
 
   // Initialize offline-enabled status. Defaults to false.
   if (manifest->HasKey(keys::kOfflineEnabled)) {
     if (!manifest->GetBoolean(keys::kOfflineEnabled, &offline_enabled_)) {
-      *error = errors::kInvalidOfflineEnabled;
+      *error = ASCIIToUTF16(errors::kInvalidOfflineEnabled);
       return false;
     }
   }
 
   // Initialize requirements (optional). Not actually persisted (they're only
   // used by the store), but still validated.
   if (manifest->HasKey(keys::kRequirements)) {
     DictionaryValue* requirements_value = NULL;
     if (!manifest->GetDictionary(keys::kRequirements, &requirements_value)) {
-      *error = errors::kInvalidRequirements;
+      *error = ASCIIToUTF16(errors::kInvalidRequirements);
       return false;
     }
 
     for (DictionaryValue::key_iterator it = requirements_value->begin_keys();
          it != requirements_value->end_keys(); ++it) {
       DictionaryValue* requirement_value;
       if (!requirements_value->GetDictionaryWithoutPathExpansion(
           *it, &requirement_value)) {
-        *error = ExtensionErrorUtils::FormatErrorMessage(
+        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidRequirement, *it);
         return false;
       }
     }
   }
 
   if (HasMultipleUISurfaces()) {
-    *error = errors::kOneUISurfaceOnly;
+    *error = ASCIIToUTF16(errors::kOneUISurfaceOnly);
     return false;
   }
 
   runtime_data_.SetActivePermissions(new ExtensionPermissionSet(
       this, api_permissions, host_permissions));
   required_permission_set_ = new ExtensionPermissionSet(
       this, api_permissions, host_permissions);
   optional_permission_set_ = new ExtensionPermissionSet(
       optional_api_permissions, optional_host_permissions, URLPatternSet());
 
@@ skipping 148 matching lines @@
   std::string path = icons().Get(size, match_type);
   if (path.empty())
     return GURL();
   else
     return GetResourceURL(path);
 }
 
 bool Extension::ParsePermissions(const extensions::Manifest* source,
                                  const char* key,
                                  int flags,
-                                 std::string* error,
+                                 string16* error,
                                  ExtensionAPIPermissionSet* api_permissions,
                                  URLPatternSet* host_permissions) {
   if (source->HasKey(key)) {
     // When strict error checks are enabled, make URL pattern parsing strict.
     URLPattern::ParseOption parse_option =
         (flags & STRICT_ERROR_CHECKS ? URLPattern::ERROR_ON_PORTS
                                      : URLPattern::IGNORE_PORTS);
     ListValue* permissions = NULL;
     if (!source->GetList(key, &permissions)) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidPermissions, "");
       return false;
     }
 
     for (size_t i = 0; i < permissions->GetSize(); ++i) {
       std::string permission_str;
       if (!permissions->GetString(i, &permission_str)) {
-        *error = ExtensionErrorUtils::FormatErrorMessage(
+        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidPermission, base::IntToString(i));
         return false;
       }
 
       ExtensionAPIPermission* permission =
           ExtensionPermissionsInfo::GetInstance()->GetByName(permission_str);
 
       if (permission != NULL) {
         if (CanSpecifyAPIPermission(permission, error))
           api_permissions->insert(permission->id());
         if (!error->empty())
           return false;
         continue;
       }
 
       // Check if it's a host pattern permission.
       const int kAllowedSchemes = CanExecuteScriptEverywhere() ?
           URLPattern::SCHEME_ALL : kValidHostPermissionSchemes;
 
       URLPattern pattern = URLPattern(parse_option, kAllowedSchemes);
       URLPattern::ParseResult parse_result = pattern.Parse(permission_str);
       if (parse_result == URLPattern::PARSE_SUCCESS) {
         if (!CanSpecifyHostPermission(pattern, *api_permissions)) {
-          *error = ExtensionErrorUtils::FormatErrorMessage(
+          *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
               errors::kInvalidPermissionScheme, base::IntToString(i));
           return false;
         }
 
         // The path component is not used for host permissions, so we force it
         // to match all paths.
         pattern.SetPath("/*");
 
         if (pattern.MatchesScheme(chrome::kFileScheme) &&
             !CanExecuteScriptEverywhere()) {
@@ skipping 183 matching lines @@
 }
 
 bool Extension::ImplicitlyDelaysNetworkStartup() const {
   // Network requests should be deferred until any extensions that might want
   // to observe and modify them are loaded.
   return HasAPIPermission(ExtensionAPIPermission::kWebRequestBlocking);
 }
 
 bool Extension::CanSpecifyAPIPermission(
     const ExtensionAPIPermission* permission,
-    std::string* error) const {
+    string16* error) const {
   if (permission->is_component_only()) {
     if (!CanSpecifyComponentOnlyPermission()) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kPermissionNotAllowed, permission->name());
       return false;
     }
   }
 
   if (permission->id() == ExtensionAPIPermission::kExperimental) {
     if (!CanSpecifyExperimentalPermission()) {
-      *error = errors::kExperimentalFlagRequired;
+      *error = ASCIIToUTF16(errors::kExperimentalFlagRequired);
       return false;
     }
   }
 
   if (location_ == Extension::COMPONENT)
     return true;
 
   bool supports_type = false;
   switch (GetType()) {
     case TYPE_USER_SCRIPT: // Pass through.
@@ skipping 17 matching lines @@
   if (!supports_type) {
     // We special case hosted apps because some old versions of Chrome did not
     // return errors here and we ended up with extensions in the store
     // containing bad data: crbug.com/101993.
     //
     // TODO(aa): Consider just being a lot looser when loading and installing
     // extensions. We can be strict when packing and in development mode. Then
     // we won't have to maintain all these tricky backward compat issues:
     // crbug.com/102328.
     if (!is_hosted_app() || creation_flags_ & STRICT_ERROR_CHECKS) {
-      *error = ExtensionErrorUtils::FormatErrorMessage(
+      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kPermissionNotAllowed, permission->name());
     }
     return false;
   }
 
   return true;
 }
 
 bool Extension::CanSpecifyComponentOnlyPermission() const {
   // Only COMPONENT extensions can use private APIs.
@@ skipping 156 matching lines @@
     already_disabled(false),
     extension(extension) {}
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const ExtensionPermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}