Move extension_error_utils.* and url_pattern_set.* into

chrome/common/extensions/command.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/command.h"
 
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/common/extensions/extension.h"
-#include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
+#include "extensions/common/error_utils.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace errors = extension_manifest_errors;
 namespace keys = extension_manifest_keys;
 namespace values = extension_manifest_values;
 
+using extensions::ErrorUtils;
+
 namespace {
 
 static const char kMissing[] = "Missing";
 
 static const char kCommandKeyNotSupported[] =
     "Command key is not supported. Note: Ctrl means Command on Mac";
 
 
 ui::Accelerator ParseImpl(const std::string& accelerator,
                           const std::string& platform_key,
                           int index,
                           string16* error) {
   if (platform_key != values::kKeybindingPlatformWin &&
       platform_key != values::kKeybindingPlatformMac &&
       platform_key != values::kKeybindingPlatformChromeOs &&
       platform_key != values::kKeybindingPlatformLinux &&
       platform_key != values::kKeybindingPlatformDefault) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+    *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidKeyBindingUnknownPlatform,
         base::IntToString(index),
         platform_key);
     return ui::Accelerator();
   }
 
   std::vector<std::string> tokens;
   base::SplitString(accelerator, '+', &tokens);
   if (tokens.size() < 2 || tokens.size() > 3) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+    *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidKeyBinding,
         base::IntToString(index),
         platform_key,
         accelerator);
     return ui::Accelerator();
   }
 
   // Now, parse it into an accelerator.
   int modifiers = ui::EF_NONE;
   ui::KeyboardCode key = ui::VKEY_UNKNOWN;
@@ skipping 32 matching lines @@
       }
       if (tokens[i][0] >= 'A' && tokens[i][0] <= 'Z') {
         key = static_cast<ui::KeyboardCode>(ui::VKEY_A + (tokens[i][0] - 'A'));
       } else if (tokens[i][0] >= '0' && tokens[i][0] <= '9') {
         key = static_cast<ui::KeyboardCode>(ui::VKEY_0 + (tokens[i][0] - '0'));
       } else {
         key = ui::VKEY_UNKNOWN;
         break;
       }
     } else {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidKeyBinding,
           base::IntToString(index),
           platform_key,
           accelerator);
       return ui::Accelerator();
     }
   }
   bool command = (modifiers & ui::EF_COMMAND_DOWN) != 0;
   bool ctrl = (modifiers & ui::EF_CONTROL_DOWN) != 0;
   bool alt = (modifiers & ui::EF_ALT_DOWN) != 0;
   bool shift = (modifiers & ui::EF_SHIFT_DOWN) != 0;
 
   // We support Ctrl+foo, Alt+foo, Ctrl+Shift+foo, Alt+Shift+foo, but not
   // Ctrl+Alt+foo and not Shift+foo either. For a more detailed reason why we
   // don't support Ctrl+Alt+foo see this article:
   // http://blogs.msdn.com/b/oldnewthing/archive/2004/03/29/101121.aspx.
   // On Mac Command can also be used in combination with Shift or on its own,
   // as a modifier.
   if (key == ui::VKEY_UNKNOWN || (ctrl && alt) || (command && alt) ||
       (shift && !ctrl && !alt && !command)) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+    *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidKeyBinding,
         base::IntToString(index),
         platform_key,
         accelerator);
     return ui::Accelerator();
   }
 
   return ui::Accelerator(key, modifiers);
 }
 
@@ skipping 81 matching lines @@
   if (command->GetDictionary(keys::kSuggestedKey, &suggested_key_dict)) {
     DictionaryValue::key_iterator iter = suggested_key_dict->begin_keys();
     for ( ; iter != suggested_key_dict->end_keys(); ++iter) {
       // For each item in the dictionary, extract the platforms specified.
       std::string suggested_key_string;
       if (suggested_key_dict->GetString(*iter, &suggested_key_string) &&
           !suggested_key_string.empty()) {
         // Found a platform, add it to the suggestions list.
         suggestions[*iter] = suggested_key_string;
       } else {
-        *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+        *error = ErrorUtils::FormatErrorMessageUTF16(
             errors::kInvalidKeyBinding,
             base::IntToString(index),
             keys::kSuggestedKey,
             kMissing);
         return false;
       }
     }
   } else {
     // No dictionary was found, fall back to using just a string, so developers
     // don't have to specify a dictionary if they just want to use one default
     // for all platforms.
     std::string suggested_key_string;
     if (command->GetString(keys::kSuggestedKey, &suggested_key_string) &&
         !suggested_key_string.empty()) {
       // If only a single string is provided, it must be default for all.
       suggestions["default"] = suggested_key_string;
     } else {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidKeyBinding,
           base::IntToString(index),
           keys::kSuggestedKey,
           kMissing);
        return false;
     }
   }
 
   // Normalize the suggestions.
   for (SuggestionMap::iterator iter = suggestions.begin();
        iter != suggestions.end(); ++iter) {
     // Before we normalize Ctrl to Command we must detect when the developer
     // specified Command in the Default section, which will work on Mac after
     // normalization but only fail on other platforms when they try it out on
     // other platforms, which is not what we want.
     if (iter->first == "default" &&
         iter->second.find("Command+") != std::string::npos) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidKeyBinding,
           base::IntToString(index),
           keys::kSuggestedKey,
           kCommandKeyNotSupported);
       return false;
     }
 
     suggestions[iter->first] = NormalizeShortcutSuggestion(iter->second,
                                                            iter->first);
   }
 
   std::string platform = CommandPlatform();
   std::string key = platform;
   if (suggestions.find(key) == suggestions.end())
     key = values::kKeybindingPlatformDefault;
   if (suggestions.find(key) == suggestions.end()) {
-    *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+    *error = ErrorUtils::FormatErrorMessageUTF16(
         errors::kInvalidKeyBindingMissingPlatform,
         base::IntToString(index),
         keys::kSuggestedKey,
         platform);
     return false;  // No platform specified and no fallback. Bail.
   }
 
   // For developer convenience, we parse all the suggestions (and complain about
   // errors for platforms other than the current one) but use only what we need.
   std::map<const std::string, std::string>::const_iterator iter =
       suggestions.begin();
   for ( ; iter != suggestions.end(); ++iter) {
     // Note that we pass iter->first to pretend we are on a platform we're not
     // on.
     ui::Accelerator accelerator =
         ParseImpl(iter->second, iter->first, index, error);
     if (accelerator.key_code() == ui::VKEY_UNKNOWN) {
-      *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+      *error = ErrorUtils::FormatErrorMessageUTF16(
           errors::kInvalidKeyBinding,
           base::IntToString(index),
           iter->first,
           iter->second);
       return false;
     }
 
     if (iter->first == key) {
       // This platform is our platform, so grab this key.
       accelerator_ = accelerator;
       command_name_ = command_name;
 
       if (command_name !=
               extension_manifest_values::kPageActionCommandEvent &&
           command_name !=
               extension_manifest_values::kBrowserActionCommandEvent &&
           command_name !=
               extension_manifest_values::kScriptBadgeCommandEvent) {
         if (!command->GetString(keys::kDescription, &description_) ||
             description_.empty()) {
-          *error = ExtensionErrorUtils::FormatErrorMessageUTF16(
+          *error = ErrorUtils::FormatErrorMessageUTF16(
               errors::kInvalidKeyBindingDescription,
               base::IntToString(index));
           return false;
         }
       }
     }
   }
   return true;
 }
 
@@ skipping 13 matching lines @@
   extension_data->SetString("description", command_description);
   extension_data->SetBoolean("active", active);
   extension_data->SetString("keybinding", accelerator().GetShortcutText());
   extension_data->SetString("command_name", command_name());
   extension_data->SetString("extension_id", extension->id());
 
   return extension_data;
 }
 
 }  // namespace extensions