Move extension_error_utils.* and url_pattern_set.* into

chrome/common/extensions/extension.cc

 // Copyright (c) 2012 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 <ostream>
 
 #include "base/base64.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/version.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/csp_validator.h"
-#include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_resource.h"
 #include "chrome/common/extensions/feature_switch.h"
 #include "chrome/common/extensions/features/feature.h"
 #include "chrome/common/extensions/features/simple_feature_provider.h"
 #include "chrome/common/extensions/file_browser_handler.h"
 #include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/permissions/permission_set.h"
 #include "chrome/common/extensions/permissions/permissions_info.h"
-#include "chrome/common/extensions/url_pattern_set.h"
 #include "chrome/common/extensions/user_script.h"
 #include "chrome/common/url_constants.h"
 #include "crypto/sha2.h"
 #include "extensions/common/constants.h"
+#include "extensions/common/error_utils.h"
+#include "extensions/common/url_pattern_set.h"
 #include "googleurl/src/url_util.h"
 #include "grit/chromium_strings.h"
 #include "grit/theme_resources.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "webkit/glue/image_decoder.h"
 #include "webkit/glue/web_intent_service_data.h"
 
 #if defined(OS_WIN)
@@ skipping 95 matching lines @@
                              const int* icon_sizes,
                              size_t num_icon_sizes,
                              ExtensionIconSet* icons,
                              string16* error) {
   DCHECK(icons);
   for (size_t i = 0; i < num_icon_sizes; ++i) {
     std::string key = base::IntToString(icon_sizes[i]);
     if (icons_value->HasKey(key)) {
       std::string icon_path;
       if (!icons_value->GetString(key, &icon_path)) {
-        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidIconPath, key);
         return false;
       }
 
       if (!NormalizeAndValidatePath(&icon_path)) {
-        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidIconPath, key);
         return false;
       }
 
       icons->Add(icon_sizes[i], icon_path);
     }
   }
   return true;
 }
 
@@ skipping 81 matching lines @@
 }
 
 bool ReadLaunchDimension(const extensions::Manifest* manifest,
                          const char* key,
                          int* target,
                          bool is_valid_container,
                          string16* error) {
   Value* temp = NULL;
   if (manifest->Get(key, &temp)) {
     if (!is_valid_container) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidLaunchValueContainer,
           key);
       return false;
     }
     if (!temp->GetAsInteger(target) || *target < 0) {
       *target = 0;
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidLaunchValue,
           key);
       return false;
     }
   }
   return true;
 }
 
 }  // namespace
 
@@ skipping 317 matching lines @@
 // 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,
                                      string16* error,
                                      UserScript* result) {
   // run_at
   if (content_script->HasKey(keys::kRunAt)) {
     std::string run_location;
     if (!content_script->GetString(keys::kRunAt, &run_location)) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::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::FormatErrorMessageUTF16(
+      *error = ErrorUtils::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::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidAllFrames, base::IntToString(definition_index));
       return false;
     }
     result->set_match_all_frames(all_frames);
   }
 
   // matches (required)
   const ListValue* matches = NULL;
   if (!content_script->GetList(keys::kMatches, &matches)) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+    *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidMatches,
         base::IntToString(definition_index));
     return false;
   }
 
   if (matches->GetSize() == 0) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+    *error = ErrorUtils::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::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidMatch,
           base::IntToString(definition_index),
           base::IntToString(j),
           errors::kExpectString);
       return false;
     }
 
     URLPattern pattern(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::FormatErrorMessageUTF16(
+      *error = ErrorUtils::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 (!(creation_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
     const ListValue* exclude_matches = NULL;
     if (!content_script->GetList(keys::kExcludeMatches, &exclude_matches)) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::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::FormatErrorMessageUTF16(
+        *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidExcludeMatch,
             base::IntToString(definition_index),
             base::IntToString(j),
             errors::kExpectString);
         return false;
       }
 
       URLPattern pattern(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::FormatErrorMessageUTF16(
+        *error = ErrorUtils::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
   const ListValue* js = NULL;
   if (content_script->HasKey(keys::kJs) &&
       !content_script->GetList(keys::kJs, &js)) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+    *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidJsList,
         base::IntToString(definition_index));
     return false;
   }
 
   const ListValue* css = NULL;
   if (content_script->HasKey(keys::kCss) &&
       !content_script->GetList(keys::kCss, &css)) {
-    *error = ExtensionErrorUtils::
+    *error = ErrorUtils::
         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::FormatErrorMessageUTF16(
+    *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kMissingFile,
         base::IntToString(definition_index));
     return false;
   }
 
   if (js) {
     for (size_t script_index = 0; script_index < js->GetSize();
          ++script_index) {
       const Value* value;
       std::string relative;
       if (!js->Get(script_index, &value) || !value->GetAsString(&relative)) {
-        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        *error = ErrorUtils::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) {
       const Value* value;
       std::string relative;
       if (!css->Get(script_index, &value) || !value->GetAsString(&relative)) {
-        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        *error = ErrorUtils::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,
     string16* error,
     void(UserScript::*add_method)(const std::string& glob),
     UserScript* instance) {
   if (!content_script->HasKey(globs_property_name))
     return true;  // they are optional
 
   const ListValue* list = NULL;
   if (!content_script->GetList(globs_property_name, &list)) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+    *error = ErrorUtils::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::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidGlob,
           base::IntToString(content_script_index),
           globs_property_name,
           base::IntToString(i));
       return false;
     }
 
     (instance->*add_method)(glob);
   }
 
@@ skipping 77 matching lines @@
   }
 
   // Read the action's |popup| (optional).
   const char* popup_key = NULL;
   if (extension_action->HasKey(keys::kPageActionDefaultPopup))
     popup_key = keys::kPageActionDefaultPopup;
 
   if (manifest_version_ == 1 &&
       extension_action->HasKey(keys::kPageActionPopup)) {
     if (popup_key) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidPageActionOldAndNewKeys,
           keys::kPageActionDefaultPopup,
           keys::kPageActionPopup);
       return scoped_ptr<ActionInfo>();
     }
     popup_key = keys::kPageActionPopup;
   }
 
   if (popup_key) {
     const 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 (manifest_version_ == 1 &&
                extension_action->GetDictionary(popup_key, &popup)) {
       if (!popup->GetString(keys::kPageActionPopupPath, &url_str)) {
-        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidPageActionPopupPath, "<missing>");
         return scoped_ptr<ActionInfo>();
       }
     } else {
       *error = ASCIIToUTF16(errors::kInvalidPageActionPopup);
       return scoped_ptr<ActionInfo>();
     }
 
     if (!url_str.empty()) {
       // An empty string is treated as having no popup.
       result->default_popup_url = GetResourceURL(url_str);
       if (!result->default_popup_url.is_valid()) {
-        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidPageActionPopupPath, url_str);
         return scoped_ptr<ActionInfo>();
       }
     } else {
       DCHECK(result->default_popup_url.is_empty())
           << "Shouldn't be possible for the popup to be set.";
     }
   }
 
   return result.Pass();
@@ skipping 133 matching lines @@
 
   if (temp_pattern_value->GetType() != Value::TYPE_LIST) {
     *error = ASCIIToUTF16(list_error);
     return false;
   }
 
   ListValue* pattern_list = static_cast<ListValue*>(temp_pattern_value);
   for (size_t i = 0; i < pattern_list->GetSize(); ++i) {
     std::string pattern_string;
     if (!pattern_list->GetString(i, &pattern_string)) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(value_error,
+      *error = ErrorUtils::FormatErrorMessageUTF16(value_error,
                                                        base::UintToString(i),
                                                        errors::kExpectString);
       return false;
     }
 
     URLPattern pattern(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::FormatErrorMessageUTF16(
+      *error = ErrorUtils::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::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           value_error,
           base::UintToString(i),
           errors::kCannotClaimAllURLsInExtent);
       return false;
     }
 
     // Do not allow authors to claim "*" for host.
     if (pattern.host().empty()) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::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::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           value_error,
           base::UintToString(i),
           errors::kNoWildCardsInPaths);
       return false;
     }
     pattern.SetPath(pattern.path() + '*');
 
     extent->AddPattern(pattern);
   }
 
@@ skipping 11 matching lines @@
       return false;
     }
 
     if (manifest_->Get(keys::kWebURLs, NULL)) {
       *error = ASCIIToUTF16(errors::kLaunchPathAndExtentAreExclusive);
       return false;
     }
 
     std::string launch_path;
     if (!temp->GetAsString(&launch_path)) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidLaunchValue,
           keys::kLaunchLocalPath);
       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 = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidLaunchValue,
           keys::kLaunchLocalPath);
       return false;
     }
 
     launch_local_path_ = launch_path;
   } else if (manifest_->Get(keys::kLaunchWebURL, &temp)) {
     std::string launch_url;
     if (!temp->GetAsString(&launch_url)) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidLaunchValue,
           keys::kLaunchWebURL);
       return false;
     }
 
     // Ensure the launch URL is a valid absolute URL and web extent scheme.
     GURL url(launch_url);
     URLPattern pattern(kValidWebExtentSchemes);
     if (!url.is_valid() || !pattern.SetScheme(url.scheme())) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidLaunchValue,
           keys::kLaunchWebURL);
       return false;
     }
 
     launch_web_url_ = launch_url;
   } else if (is_legacy_packaged_app() || is_hosted_app()) {
     *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(kValidWebExtentSchemes);
     if (!pattern.SetScheme("*")) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidLaunchValue,
           keys::kLaunchWebURL);
       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
@@ skipping 131 matching lines @@
       *error = ASCIIToUTF16(errors::kInvalidManifestVersion);
       return false;
     }
   }
 
   manifest_version_ = manifest_->GetManifestVersion();
   if (creation_flags_ & REQUIRE_MODERN_MANIFEST_VERSION &&
       manifest_version_ < kModernManifestVersion &&
       !CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kAllowLegacyExtensionManifests)) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+    *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidManifestVersionOld,
         base::IntToString(kModernManifestVersion));
     return false;
   }
 
   return true;
 }
 
 bool Extension::LoadHomepageURL(string16* error) {
   if (!manifest_->HasKey(keys::kHomepageURL))
     return true;
   std::string tmp_homepage_url;
   if (!manifest_->GetString(keys::kHomepageURL, &tmp_homepage_url)) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+    *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidHomepageURL, "");
     return false;
   }
   homepage_url_ = GURL(tmp_homepage_url);
   if (!homepage_url_.is_valid() ||
       (!homepage_url_.SchemeIs("http") &&
        !homepage_url_.SchemeIs("https"))) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+    *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidHomepageURL, tmp_homepage_url);
     return false;
   }
   return true;
 }
 
 bool Extension::LoadUpdateURL(string16* error) {
   if (!manifest_->HasKey(keys::kUpdateURL))
     return true;
   std::string tmp_update_url;
   if (!manifest_->GetString(keys::kUpdateURL, &tmp_update_url)) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+    *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidUpdateURL, "");
     return false;
   }
   update_url_ = GURL(tmp_update_url);
   if (!update_url_.is_valid() ||
       update_url_.has_ref()) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+    *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidUpdateURL, tmp_update_url);
     return false;
   }
   return true;
 }
 
 bool Extension::LoadIcons(string16* error) {
   if (!manifest_->HasKey(keys::kIcons))
     return true;
   DictionaryValue* icons_value = NULL;
@@ skipping 11 matching lines @@
 
 bool Extension::LoadCommands(string16* error) {
   if (manifest_->HasKey(keys::kCommands)) {
     DictionaryValue* commands = NULL;
     if (!manifest_->GetDictionary(keys::kCommands, &commands)) {
       *error = ASCIIToUTF16(errors::kInvalidCommandsKey);
       return false;
     }
 
     if (commands->size() > kMaxCommandsPerExtension) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidKeyBindingTooMany,
           base::IntToString(kMaxCommandsPerExtension));
       return false;
     }
 
     int command_index = 0;
     for (DictionaryValue::key_iterator iter = commands->begin_keys();
          iter != commands->end_keys(); ++iter) {
       ++command_index;
 
       DictionaryValue* command = NULL;
       if (!commands->GetDictionary(*iter, &command)) {
-        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidKeyBindingDictionary,
             base::IntToString(command_index));
         return false;
       }
 
       scoped_ptr<extensions::Command> binding(new extensions::Command());
       if (!binding->Parse(command, *iter, command_index, error))
         return false;  // |error| already set.
 
       std::string command_name = binding->command_name();
@@ skipping 35 matching lines @@
 
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
     DictionaryValue* plugin_value = NULL;
     if (!list_value->GetDictionary(i, &plugin_value)) {
       *error = ASCIIToUTF16(errors::kInvalidPlugins);
       return false;
     }
     // Get plugins[i].path.
     std::string path_str;
     if (!plugin_value->GetString(keys::kPluginsPath, &path_str)) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidPluginsPath, base::IntToString(i));
       return false;
     }
 
     // Get plugins[i].content (optional).
     bool is_public = false;
     if (plugin_value->HasKey(keys::kPluginsPublic)) {
       if (!plugin_value->GetBoolean(keys::kPluginsPublic, &is_public)) {
-        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidPluginsPublic, base::IntToString(i));
         return false;
       }
     }
 
     // We don't allow extensions to load NPAPI plugins on Chrome OS, or under
     // Windows 8 Metro mode, but still parse the entries to display consistent
     // error messages. If the extension actually requires the plugins then
     // LoadRequirements will prevent it loading.
 #if defined(OS_CHROMEOS)
@@ skipping 22 matching lines @@
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
     DictionaryValue* module_value = NULL;
     if (!list_value->GetDictionary(i, &module_value)) {
       *error = ASCIIToUTF16(errors::kInvalidNaClModules);
       return false;
     }
 
     // Get nacl_modules[i].path.
     std::string path_str;
     if (!module_value->GetString(keys::kNaClModulesPath, &path_str)) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidNaClModulesPath, base::IntToString(i));
       return false;
     }
 
     // Get nacl_modules[i].mime_type.
     std::string mime_type;
     if (!module_value->GetString(keys::kNaClModulesMIMEType, &mime_type)) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::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;
   }
 
   return true;
 }
 
 bool Extension::LoadWebAccessibleResources(string16* error) {
   if (!manifest_->HasKey(keys::kWebAccessibleResources))
     return true;
   ListValue* list_value = NULL;
   if (!manifest_->GetList(keys::kWebAccessibleResources, &list_value)) {
     *error = ASCIIToUTF16(errors::kInvalidWebAccessibleResourcesList);
     return false;
   }
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
     std::string relative_path;
     if (!list_value->GetString(i, &relative_path)) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidWebAccessibleResource, base::IntToString(i));
       return false;
     }
     URLPattern pattern(URLPattern::SCHEME_EXTENSION);
     if (pattern.Parse(extension_url_.spec()) != URLPattern::PARSE_SUCCESS) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidURLPatternError, extension_url_.spec());
       return false;
     }
     while (relative_path[0] == '/')
       relative_path = relative_path.substr(1, relative_path.length() - 1);
     pattern.SetPath(pattern.path() + relative_path);
     web_accessible_resources_.AddPattern(pattern);
   }
 
   return true;
 }
 
 bool Extension::LoadSandboxedPages(string16* error) {
   if (!manifest_->HasPath(keys::kSandboxedPages))
     return true;
 
   ListValue* list_value = NULL;
   if (!manifest_->GetList(keys::kSandboxedPages, &list_value)) {
     *error = ASCIIToUTF16(errors::kInvalidSandboxedPagesList);
     return false;
   }
   for (size_t i = 0; i < list_value->GetSize(); ++i) {
     std::string relative_path;
     if (!list_value->GetString(i, &relative_path)) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidSandboxedPage, base::IntToString(i));
       return false;
     }
     URLPattern pattern(URLPattern::SCHEME_EXTENSION);
     if (pattern.Parse(extension_url_.spec()) != URLPattern::PARSE_SUCCESS) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidURLPatternError, extension_url_.spec());
       return false;
     }
     while (relative_path[0] == '/')
       relative_path = relative_path.substr(1, relative_path.length() - 1);
     pattern.SetPath(pattern.path() + relative_path);
     sandboxed_pages_.AddPattern(pattern);
   }
 
   if (manifest_->HasPath(keys::kSandboxedPagesCSP)) {
@@ skipping 34 matching lines @@
   if (!manifest_->GetDictionary(keys::kRequirements, &requirements_value)) {
     *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::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidRequirement, *it);
       return false;
     }
 
     if (*it == "plugins") {
       for (DictionaryValue::key_iterator plugin_it =
               requirement_value->begin_keys();
            plugin_it != requirement_value->end_keys(); ++plugin_it) {
         bool plugin_required = false;
         if (!requirement_value->GetBoolean(*plugin_it, &plugin_required)) {
-          *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+          *error = ErrorUtils::FormatErrorMessageUTF16(
               errors::kInvalidRequirement, *it);
           return false;
         }
         if (*plugin_it == "npapi") {
           requirements_.npapi = plugin_required;
         } else {
-          *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+          *error = ErrorUtils::FormatErrorMessageUTF16(
               errors::kInvalidRequirement, *it);
           return false;
         }
       }
     } else if (*it == "3D") {
       ListValue* features = NULL;
       if (!requirement_value->GetListWithoutPathExpansion("features",
                                                           &features) ||
           !features) {
-        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidRequirement, *it);
         return false;
       }
 
       for (base::ListValue::iterator feature_it = features->begin();
            feature_it != features->end();
            ++feature_it) {
         std::string feature;
         if ((*feature_it)->GetAsString(&feature)) {
           if (feature == "webgl") {
             requirements_.webgl = true;
           } else if (feature == "css3d") {
             requirements_.css3d = true;
           } else {
-            *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+            *error = ErrorUtils::FormatErrorMessageUTF16(
                 errors::kInvalidRequirement, *it);
             return false;
           }
         }
       }
     } else {
       *error = ASCIIToUTF16(errors::kInvalidRequirements);
       return false;
     }
   }
@@ skipping 73 matching lines @@
   if (background_scripts_value->GetType() != Value::TYPE_LIST) {
     *error = ASCIIToUTF16(errors::kInvalidBackgroundScripts);
     return false;
   }
 
   ListValue* background_scripts =
       static_cast<ListValue*>(background_scripts_value);
   for (size_t i = 0; i < background_scripts->GetSize(); ++i) {
     std::string script;
     if (!background_scripts->GetString(i, &script)) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidBackgroundScript, base::IntToString(i));
       return false;
     }
     background_scripts_.push_back(script);
   }
 
   return true;
 }
 
 bool Extension::LoadBackgroundPage(
@@ skipping 108 matching lines @@
   DCHECK(error);
   webkit_glue::WebIntentServiceData service;
   std::string value;
 
   service.action = UTF8ToUTF16(action_name);
 
   const ListValue* mime_types = NULL;
   if (!intent_service.HasKey(keys::kIntentType) ||
       !intent_service.GetList(keys::kIntentType, &mime_types) ||
       mime_types->GetSize() == 0) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+    *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidIntentType, action_name);
     return false;
   }
 
   std::string href;
   if (intent_service.HasKey(keys::kIntentPath)) {
     if (!intent_service.GetString(keys::kIntentPath, &href)) {
       *error = ASCIIToUTF16(errors::kInvalidIntentHref);
       return false;
     }
   }
 
   if (intent_service.HasKey(keys::kIntentHref)) {
     if (!href.empty()) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidIntentHrefOldAndNewKey, action_name,
           keys::kIntentPath, keys::kIntentHref);
        return false;
     }
     if (!intent_service.GetString(keys::kIntentHref, &href)) {
       *error = ASCIIToUTF16(errors::kInvalidIntentHref);
       return false;
     }
   }
 
   // For packaged/hosted apps, empty href implies the respective launch URLs.
   if (href.empty()) {
     if (is_hosted_app()) {
       href = launch_web_url();
     } else if (is_legacy_packaged_app()) {
       href = launch_local_path();
     }
   }
 
   // If there still is not an  href, the manifest is malformed, unless this is a
   // platform app in which case the href should not be present.
   if (href.empty() && !is_platform_app()) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+    *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidIntentHrefEmpty, action_name);
     return false;
   } else if (!href.empty() && is_platform_app()) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+    *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidIntentHrefInPlatformApp, action_name);
     return false;
   }
 
   GURL service_url(href);
   if (is_hosted_app()) {
     // Hosted apps require an absolute URL for intents.
     if (!service_url.is_valid() ||
         !(web_extent().MatchesURL(service_url))) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidIntentPageInHostedApp, action_name);
       return false;
     }
     service.service_url = service_url;
   } else if (is_platform_app()) {
     service.service_url = GetBackgroundURL();
   } else {
     // We do not allow absolute intent URLs in non-hosted apps.
     if (service_url.is_valid()) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kCannotAccessPage, href);
       return false;
     }
     service.service_url = GetResourceURL(href);
   }
 
   if (intent_service.HasKey(keys::kIntentTitle) &&
       !intent_service.GetString(keys::kIntentTitle, &service.title)) {
     *error = ASCIIToUTF16(errors::kInvalidIntentTitle);
     return false;
   }
 
   if (intent_service.HasKey(keys::kIntentDisposition)) {
     if (is_platform_app()) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidIntentDispositionInPlatformApp, action_name);
       return false;
     }
     if (!intent_service.GetString(keys::kIntentDisposition, &value) ||
         (value != values::kIntentDispositionWindow &&
          value != values::kIntentDispositionInline)) {
       *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;
     }
   }
 
   for (size_t i = 0; i < mime_types->GetSize(); ++i) {
     if (!mime_types->GetString(i, &service.type)) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidIntentTypeElement, action_name,
           std::string(base::IntToString(i)));
       return false;
     }
     intents_services_.push_back(service);
   }
   return true;
 }
 
 bool Extension::LoadWebIntentServices(string16* error) {
@@ skipping 45 matching lines @@
   webkit_glue::WebIntentServiceData service;
 
   // TODO(jeremya): use a file-handler-specific data structure instead of web
   // intents.
   service.action = ASCIIToUTF16("http://webintents.org/view");
 
   const ListValue* mime_types = NULL;
   if (!handler_info.HasKey(keys::kFileHandlerTypes) ||
       !handler_info.GetList(keys::kFileHandlerTypes, &mime_types) ||
       mime_types->GetSize() == 0) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+    *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidFileHandlerType, handler_id);
     return false;
   }
 
   service.service_url = GetBackgroundURL();
 
   if (handler_info.HasKey(keys::kFileHandlerTitle) &&
       !handler_info.GetString(keys::kFileHandlerTitle, &service.title)) {
     *error = ASCIIToUTF16(errors::kInvalidFileHandlerTitle);
     return false;
   }
 
   for (size_t i = 0; i < mime_types->GetSize(); ++i) {
     if (!mime_types->GetString(i, &service.type)) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidFileHandlerTypeElement, handler_id,
           std::string(base::IntToString(i)));
       return false;
     }
     intents_services_.push_back(service);
   }
   return true;
 }
 
 bool Extension::LoadFileHandlers(string16* error) {
@@ skipping 82 matching lines @@
     bool shortcut_ctrl = false;
     bool shortcut_shift = false;
 
     if (!list_value->GetDictionary(i, &module_value)) {
       *error = ASCIIToUTF16(errors::kInvalidInputComponents);
       return false;
     }
 
     // Get input_components[i].name.
     if (!module_value->GetString(keys::kName, &name_str)) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::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 {
-        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidInputComponentType, base::IntToString(i));
         return false;
       }
     } else {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::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::FormatErrorMessageUTF16(
+      *error = ErrorUtils::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 = 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::FormatErrorMessageUTF16(
+        *error = ErrorUtils::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::FormatErrorMessageUTF16(
+        *error = ErrorUtils::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::FormatErrorMessageUTF16(
+        *error = ErrorUtils::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 29 matching lines @@
     return true;
   ListValue* list_value;
   if (!manifest_->GetList(keys::kContentScripts, &list_value)) {
     *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::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidContentScript, base::IntToString(i));
       return false;
     }
 
     UserScript script;
     if (!LoadUserScriptHelper(content_script, i, 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);
@@ skipping 184 matching lines @@
     if (!file_browser_handler->GetList(keys::kFileAccessList,
                                        &access_list_value) ||
         access_list_value->empty()) {
       *error = ASCIIToUTF16(errors::kInvalidFileAccessList);
       return NULL;
     }
     for (size_t i = 0; i < access_list_value->GetSize(); ++i) {
       std::string access;
       if (!access_list_value->GetString(i, &access) ||
           result->AddFileAccessPermission(access)) {
-        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidFileAccessValue, base::IntToString(i));
         return NULL;
       }
     }
   }
   if (!result->ValidateFileAccessPermissions()) {
     *error = ASCIIToUTF16(errors::kInvalidFileAccessList);
     return NULL;
   }
 
   // Initialize file filters (mandatory, unless "create" access is specified,
   // in which case is ignored).
   if (!result->HasCreateAccessPermission()) {
     const ListValue* list_value = NULL;
     if (!file_browser_handler->HasKey(keys::kFileFilters) ||
         !file_browser_handler->GetList(keys::kFileFilters, &list_value) ||
         list_value->empty()) {
       *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::FormatErrorMessageUTF16(
+        *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidFileFilterValue, base::IntToString(i));
         return NULL;
       }
       StringToLowerASCII(&filter);
       if (!StartsWithASCII(filter,
                            std::string(chrome::kFileSystemScheme) + ':',
                            true)) {
-        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidURLPatternError, filter);
         return NULL;
       }
       // The user inputs filesystem:*; we don't actually implement scheme
       // wildcards in URLPattern, so transform to what will match correctly.
       filter.replace(0, 11, "chrome-extension://*/");
       URLPattern pattern(URLPattern::SCHEME_EXTENSION);
       if (pattern.Parse(filter) != URLPattern::PARSE_SUCCESS) {
-        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidURLPatternError, filter);
         return NULL;
       }
       std::string path = pattern.path();
       bool allowed = path == "/*" || path == "/*.*" ||
           (path.compare(0, 3, "/*.") == 0 &&
            path.find_first_of('*', 3) == std::string::npos);
       if (!allowed) {
-        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        *error = ErrorUtils::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)) {
@@ skipping 44 matching lines @@
     }
     // Replace the entry with a fully qualified chrome-extension:// URL.
     chrome_url_overrides_[page] = GetResourceURL(val);
 
     // For component extensions, add override URL to extent patterns.
     if (is_legacy_packaged_app() && location() == COMPONENT) {
       URLPattern pattern(URLPattern::SCHEME_CHROMEUI);
       std::string url = base::StringPrintf(kOverrideExtentUrlPatternFormat,
                                            page.c_str());
       if (pattern.Parse(url) != URLPattern::PARSE_SUCCESS) {
-        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidURLPatternError, url);
         return false;
       }
       extent_.AddPattern(pattern);
     }
   }
 
   // An extension may override at most one page.
   if (overrides->size() > 1) {
     *error = ASCIIToUTF16(errors::kMultipleOverrides);
@@ skipping 172 matching lines @@
 
   if (tmp_isolation->GetType() != Value::TYPE_LIST) {
     *error = ASCIIToUTF16(errors::kInvalidIsolation);
     return false;
   }
 
   ListValue* isolation_list = static_cast<ListValue*>(tmp_isolation);
   for (size_t i = 0; i < isolation_list->GetSize(); ++i) {
     std::string isolation_string;
     if (!isolation_list->GetString(i, &isolation_string)) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::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;
@@ skipping 533 matching lines @@
   return path.empty() ? GURL() : GetResourceURL(path);
 }
 
 bool Extension::ParsePermissions(const char* key,
                                  string16* error,
                                  APIPermissionSet* api_permissions,
                                  URLPatternSet* host_permissions) {
   if (manifest_->HasKey(key)) {
     ListValue* permissions = NULL;
     if (!manifest_->GetList(key, &permissions)) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidPermissions, "");
       return false;
     }
 
     // NOTE: We need to get the APIPermission before we check if features
     // associated with them are available because the feature system does not
     // know about aliases.
 
     std::vector<std::string> host_data;
     if (!APIPermissionSet::ParseFromJSON(permissions, api_permissions,
@@ skipping 50 matching lines @@
 
     for (std::vector<std::string>::const_iterator it = host_data.begin();
          it != host_data.end(); ++it) {
       const std::string& permission_str = *it;
 
       // Check if it's a host pattern permission.
       URLPattern pattern = URLPattern(kAllowedSchemes);
       URLPattern::ParseResult parse_result = pattern.Parse(permission_str);
       if (parse_result == URLPattern::PARSE_SUCCESS) {
         if (!CanSpecifyHostPermission(pattern, *api_permissions)) {
-          *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+          *error = ErrorUtils::FormatErrorMessageUTF16(
               errors::kInvalidPermissionScheme, permission_str);
           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 203 matching lines @@
     return script->MatchesURL(document_url);
 
   // Otherwise, see if this extension has permission to execute script
   // programmatically on pages.
   if (runtime_data_.GetActivePermissions()->HasExplicitAccessToOrigin(
           document_url)) {
     return true;
   }
 
   if (error) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(errors::kCannotAccessPage,
+    *error = ErrorUtils::FormatErrorMessage(errors::kCannotAccessPage,
                                                      document_url.spec());
   }
 
   return false;
 }
 
 bool Extension::ShowConfigureContextMenus() const {
   // Don't show context menu for component extensions. We might want to show
   // options for component extension button but now there is no component
   // extension with options. All other menu items like uninstall have
@@ skipping 44 matching lines @@
     if (tab_permissions.get() &&
         tab_permissions->explicit_hosts().MatchesSecurityOrigin(page_url)) {
       return true;
     }
   }
 
   if (HasHostPermission(page_url) || page_url.GetOrigin() == url())
     return true;
 
   if (error) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(errors::kCannotAccessPage,
+    *error = ErrorUtils::FormatErrorMessage(errors::kCannotAccessPage,
                                                      page_url.spec());
   }
   return false;
 }
 
 bool Extension::UpdatesFromGallery() const {
   return extension_urls::IsWebstoreUpdateUrl(update_url());
 }
 
 bool Extension::OverlapsWithOrigin(const GURL& origin) const {
@@ skipping 192 matching lines @@
     return false;
   }
 
   Version current_version(current_version_info.Version());
   if (!current_version.IsValid()) {
     DCHECK(false);
     return false;
   }
 
   if (current_version.CompareTo(minimum_version) < 0) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+    *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kChromeVersionTooLow,
         l10n_util::GetStringUTF8(IDS_PRODUCT_NAME),
         minimum_version_string);
     return false;
   }
   return true;
 }
 
 bool Extension::CheckPlatformAppFeatures(std::string* utf8_error) const {
   if (!is_platform_app())
@@ skipping 73 matching lines @@
 
 UpdatedExtensionPermissionsInfo::UpdatedExtensionPermissionsInfo(
     const Extension* extension,
     const PermissionSet* permissions,
     Reason reason)
     : reason(reason),
       extension(extension),
       permissions(permissions) {}
 
 }   // namespace extensions