Remove the limit of number of commands per extension, but keep the limit of 4 shortcuts per extensi…

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_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
@@ skipping 190 matching lines @@
       ParseImpl(accelerator, Command::CommandPlatform(), 0, &error);
   return parsed;
 }
 
 bool Command::Parse(const DictionaryValue* command,
                     const std::string& command_name,
                     int index,
                     string16* error) {
   DCHECK(!command_name.empty());
 
+  string16 description;
+  if (command_name !=
+          extension_manifest_values::kPageActionCommandEvent &&

[Yoyo Zhou, 2013/03/27 00:44:46]

If you use values instead of extension_manifest_values this would look less
ugly.

[Finnur, 2013/03/27 13:00:39]

Good point.

+      command_name !=
+          extension_manifest_values::kBrowserActionCommandEvent &&
+      command_name !=
+          extension_manifest_values::kScriptBadgeCommandEvent) {
+    if (!command->GetString(keys::kDescription, &description) ||
+        description.empty()) {
+      *error = ErrorUtils::FormatErrorMessageUTF16(
+          errors::kInvalidKeyBindingDescription,
+          base::IntToString(index));
+      return false;
+    }
+  }
+
   // We'll build up a map of platform-to-shortcut suggestions.
   typedef std::map<const std::string, std::string> SuggestionMap;
   SuggestionMap suggestions;
 
   // First try to parse the |suggested_key| as a dictionary.
   const DictionaryValue* suggested_key_dict;
   if (command->GetDictionary(keys::kSuggestedKey, &suggested_key_dict)) {
     for (DictionaryValue::Iterator iter(*suggested_key_dict); !iter.IsAtEnd();
          iter.Advance()) {
       // For each item in the dictionary, extract the platforms specified.
@@ skipping 14 matching lines @@
   } 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 = ErrorUtils::FormatErrorMessageUTF16(
-          errors::kInvalidKeyBinding,
-          base::IntToString(index),
-          keys::kSuggestedKey,
-          kMissing);
-       return false;
+      suggestions["default"] = "";
     }
   }
 
   // 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.
@@ skipping 22 matching lines @@
         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 = ErrorUtils::FormatErrorMessageUTF16(
-          errors::kInvalidKeyBinding,
-          base::IntToString(index),
-          iter->first,
-          iter->second);
-      return false;
+    ui::Accelerator accelerator;
+    if (!iter->second.empty()) {
+      // Note that we pass iter->first to pretend we are on a platform we're not
+      // on.
+      accelerator = ParseImpl(iter->second, iter->first, index, error);
+      if (accelerator.key_code() == ui::VKEY_UNKNOWN) {
+        *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 = ErrorUtils::FormatErrorMessageUTF16(
-              errors::kInvalidKeyBindingDescription,
-              base::IntToString(index));
-          return false;
-        }
-      }
+      description_ = description;
     }
   }
   return true;
 }
 
 DictionaryValue* Command::ToValue(const Extension* extension,
                                   bool active) const {
   DictionaryValue* extension_data = new DictionaryValue();
 
   string16 command_description;
   if (command_name() == values::kBrowserActionCommandEvent ||
       command_name() == values::kPageActionCommandEvent ||
       command_name() == values::kScriptBadgeCommandEvent) {
     command_description =
         l10n_util::GetStringUTF16(IDS_EXTENSION_COMMANDS_GENERIC_ACTIVATE);
   } else {
     command_description = description();
   }
   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