Add ability to limit when context menu items appear with url patterns....

chrome/browser/extensions/extension_context_menu_api.cc

 // Copyright (c) 2010 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/browser/extensions/extension_context_menu_api.h"
 
 #include <string>
 
 #include "base/values.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/common/extensions/extension_error_utils.h"
 
 const wchar_t kCheckedKey[] = L"checked";
 const wchar_t kContextsKey[] = L"contexts";
+const wchar_t kDocumentUrlPatternsKey[] = L"documentUrlPatterns";
 const wchar_t kGeneratedIdKey[] = L"generatedId";
 const wchar_t kParentIdKey[] = L"parentId";
+const wchar_t kTargetUrlPatternsKey[] = L"targetUrlPatterns";
 const wchar_t kTitleKey[] = L"title";
 const wchar_t kTypeKey[] = L"type";
 
 const char kCannotFindItemError[] = "Cannot find menu item with id *";
 const char kCheckedError[] =
     "Only items with type \"radio\" or \"checkbox\" can be checked";
+const char kInvalidURLPatternError[] = "Invalid url pattern '*'";
 const char kInvalidValueError[] = "Invalid value for *";
 const char kInvalidTypeStringError[] = "Invalid type string '*'";
 const char kParentsMustBeNormalError[] =
     "Parent items must have type \"normal\"";
 const char kTitleNeededError[] =
     "All menu items except for separators must have a title";
 
 
 bool ExtensionContextMenuFunction::ParseContexts(
     const DictionaryValue& properties,
@@ skipping 78 matching lines @@
   if (!properties.GetBoolean(kCheckedKey, checked))
     return false;
   if (checked && type != ExtensionMenuItem::CHECKBOX &&
       type != ExtensionMenuItem::RADIO) {
     error_ = kCheckedError;
     return false;
   }
   return true;
 }
 
+bool ExtensionContextMenuFunction::ParseURLPatterns(
+    const DictionaryValue& properties,
+    const wchar_t* key,
+    ExtensionExtent* result) {
+  if (!properties.HasKey(key))
+    return true;
+  ListValue* list = NULL;
+  if (!properties.GetList(key, &list))
+    return false;
+  for (ListValue::iterator i = list->begin(); i != list->end(); ++i) {
+    std::string tmp;
+    if (!(*i)->GetAsString(&tmp))
+      return false;
+
+    URLPattern pattern(ExtensionMenuManager::kAllowedSchemes);
+    if (!pattern.Parse(tmp)) {
+      error_ = ExtensionErrorUtils::FormatErrorMessage(kInvalidURLPatternError,
+                                                       tmp);
+      return false;
+    }
+    result->AddPattern(pattern);
+  }
+  return true;
+}
+
+bool ExtensionContextMenuFunction::SetURLPatterns(
+    const DictionaryValue& properties,
+    ExtensionMenuItem* item) {
+  // Process the documentUrlPattern value.
+  ExtensionExtent document_url_patterns;
+  if (!ParseURLPatterns(properties, kDocumentUrlPatternsKey,
+                        &document_url_patterns))
+    return false;
+
+  if (!document_url_patterns.is_empty()) {
+    item->set_document_url_patterns(document_url_patterns);
+  }
+
+  // Process the targetUrlPattern value.
+  ExtensionExtent target_url_patterns;
+  if (!ParseURLPatterns(properties, kTargetUrlPatternsKey,
+                        &target_url_patterns))
+    return false;
+
+  if (!target_url_patterns.is_empty()) {
+    item->set_target_url_patterns(target_url_patterns);
+  }
+
+  return true;
+}
+
+
 bool ExtensionContextMenuFunction::GetParent(
     const DictionaryValue& properties,
     const ExtensionMenuManager& manager,
     ExtensionMenuItem** result) {
   if (!properties.HasKey(kParentIdKey))
     return true;
   ExtensionMenuItem::Id parent_id(extension_id(), 0);
   if (properties.HasKey(kParentIdKey) &&
       !properties.GetInteger(kParentIdKey, &parent_id.second))
     return false;
@@ skipping 40 matching lines @@
     return false;
   }
 
   bool checked;
   if (!ParseChecked(type, *properties, false, &checked))
     return false;
 
   scoped_ptr<ExtensionMenuItem> item(
       new ExtensionMenuItem(id, title, checked, type, contexts));
 
+  if (!SetURLPatterns(*properties, item.get()))
+    return false;
+
   bool success = true;
   if (properties->HasKey(kParentIdKey)) {
     ExtensionMenuItem::Id parent_id(extension_id(), 0);
     EXTENSION_FUNCTION_VALIDATE(properties->GetInteger(kParentIdKey,
                                                        &parent_id.second));
     ExtensionMenuItem* parent = menu_manager->GetItemById(parent_id);
     if (!parent) {
       error_ = ExtensionErrorUtils::FormatErrorMessage(
           kCannotFindItemError, IntToString(parent_id.second));
       return false;
@@ skipping 34 matching lines @@
       profile()->GetExtensionsService()->menu_manager();
 
   // Type.
   ExtensionMenuItem::Type type;
   if (!ParseType(*properties, item->type(), &type))
     return false;
   if (type != item->type())
     item->set_type(type);
 
   // Title.
-  std::string title;
-  if (properties->HasKey(kTitleKey) &&
-      !properties->GetString(kTitleKey, &title))
-    return false;
-  if (title.empty() && type != ExtensionMenuItem::SEPARATOR) {
-    error_ = kTitleNeededError;
-    return false;
+  if (properties->HasKey(kTitleKey)) {
+    std::string title;
+    EXTENSION_FUNCTION_VALIDATE(properties->GetString(kTitleKey, &title));
+    if (title.empty() && type != ExtensionMenuItem::SEPARATOR) {
+      error_ = kTitleNeededError;
+      return false;
+    }
+    item->set_title(title);
   }
-  item->set_title(title);
 
   // Checked state.
   bool checked;
   if (!ParseChecked(item->type(), *properties, item->checked(), &checked))
     return false;
   if (checked != item->checked()) {
     if (!item->SetChecked(checked))
       return false;
   }
 
   // Contexts.
   ExtensionMenuItem::ContextList contexts(item->contexts());
   if (!ParseContexts(*properties, kContextsKey, &contexts))
     return false;
   if (contexts != item->contexts())
     item->set_contexts(contexts);
 
   // Parent id.
   ExtensionMenuItem* parent = NULL;
   if (!GetParent(*properties, *menu_manager, &parent))
     return false;
   if (parent && !menu_manager->ChangeParent(item->id(), &parent->id()))
     return false;
 
+  if (!SetURLPatterns(*properties, item))
+    return false;
+
   return true;
 }
 
 bool RemoveContextMenuFunction::RunImpl() {
   ExtensionMenuItem::Id id(extension_id(), 0);
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &id.second));
   ExtensionsService* service = profile()->GetExtensionsService();
   ExtensionMenuManager* manager = service->menu_manager();
 
   ExtensionMenuItem* item = manager->GetItemById(id);
   // Ensure one extension can't remove another's menu items.
   if (!item || item->extension_id() != extension_id()) {
     error_ = ExtensionErrorUtils::FormatErrorMessage(
         kCannotFindItemError, IntToString(id.second));
     return false;
   }
 
   return manager->RemoveContextMenuItem(id);
 }
 
 bool RemoveAllContextMenusFunction::RunImpl() {
   ExtensionsService* service = profile()->GetExtensionsService();
   ExtensionMenuManager* manager = service->menu_manager();
   manager->RemoveAllContextItems(extension_id());
   return true;
 }