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

chrome/browser/tab_contents/render_view_context_menu.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 <algorithm>
 #include <set>
 
 #include "chrome/browser/tab_contents/render_view_context_menu.h"
 
 #include "app/clipboard/clipboard.h"
@@ skipping 71 matching lines @@
 RenderViewContextMenu::~RenderViewContextMenu() {
 }
 
 // Menu construction functions -------------------------------------------------
 
 void RenderViewContextMenu::Init() {
   InitMenu();
   PlatformInit();
 }
 
-static bool ExtensionContextMatch(ContextMenuParams params,
+static bool ExtensionContextMatch(const ContextMenuParams& params,
                                   ExtensionMenuItem::ContextList contexts) {
   bool has_link = !params.link_url.is_empty();
   bool has_selection = !params.selection_text.empty();
 
   if (contexts.Contains(ExtensionMenuItem::ALL) ||
       (has_selection && contexts.Contains(ExtensionMenuItem::SELECTION)) ||
       (has_link && contexts.Contains(ExtensionMenuItem::LINK)) ||
       (params.is_editable && contexts.Contains(ExtensionMenuItem::EDITABLE))) {
     return true;
   }
@@ skipping 15 matching lines @@
   // PAGE is the least specific context, so we only examine that if none of the
   // other contexts apply.
   if (!has_link && !has_selection && !params.is_editable &&
       params.media_type == WebContextMenuData::MediaTypeNone &&
       contexts.Contains(ExtensionMenuItem::PAGE))
     return true;
 
   return false;
 }
 
+static bool ExtensionPatternMatch(const ExtensionExtent& patterns,
+                                  const GURL& url) {
+  // No patterns means no restriction, so that implicitly matches.
+  if (patterns.is_empty())
+    return true;
+  return patterns.ContainsURL(url);
+}
+
+static const GURL& GetDocumentURL(const ContextMenuParams& params) {
+  return params.frame_url.is_empty() ? params.page_url : params.frame_url;
+}
+
 // Given a list of items, returns the ones that match given the contents
 // of |params|.
 static ExtensionMenuItem::List GetRelevantExtensionItems(
     const ExtensionMenuItem::List& items,
-    ContextMenuParams params) {
+    const ContextMenuParams& params) {
   ExtensionMenuItem::List result;
   for (ExtensionMenuItem::List::const_iterator i = items.begin();
        i != items.end(); ++i) {
-    if (ExtensionContextMatch(params, (*i)->contexts()))
-      result.push_back(*i);
+    const ExtensionMenuItem* item = *i;
+
+    if (!ExtensionContextMatch(params, item->contexts()))
+      continue;
+
+    const GURL& document_url = GetDocumentURL(params);
+    if (!ExtensionPatternMatch(item->document_url_patterns(), document_url))
+      continue;
+
+    const GURL& target_url =
+        params.src_url.is_empty() ? params.link_url : params.src_url;
+    if (!target_url.is_empty() &&
+        !ExtensionPatternMatch(item->target_url_patterns(), target_url))
+      continue;
+
+    result.push_back(*i);
   }
   return result;
 }
 
 void RenderViewContextMenu::AppendExtensionItems(
     const std::string& extension_id, int* index) {
   ExtensionsService* service = profile_->GetExtensionsService();
   ExtensionMenuManager* manager = service->menu_manager();
   Extension* extension = service->GetExtensionById(extension_id, false);
   DCHECK_GE(*index, 0);
@@ skipping 113 matching lines @@
 
   menu_model_.SetIcon(index, icon);
 }
 
 void RenderViewContextMenu::AppendAllExtensionItems() {
   extension_item_map_.clear();
   ExtensionsService* service = profile_->GetExtensionsService();
   if (!service)
     return;  // In unit-tests, we may not have an ExtensionService.
   ExtensionMenuManager* menu_manager = service->menu_manager();
+  const GURL& document_url = GetDocumentURL(params_);
+  if (!menu_manager->HasAllowedScheme(document_url))
+    return;
 
   // Get a list of extension id's that have context menu items, and sort it by
   // the extension's name.
   std::set<std::string> ids = menu_manager->ExtensionIds();
   std::vector<std::pair<std::string, std::string> > sorted_ids;
   for (std::set<std::string>::iterator i = ids.begin(); i != ids.end(); ++i) {
     Extension* extension = service->GetExtensionById(*i, false);
     if (extension)
       sorted_ids.push_back(
           std::pair<std::string, std::string>(extension->name(), *i));
@@ skipping 1074 matching lines @@
       UTF8ToWide(profile_->GetPrefs()->GetString(prefs::kAcceptLanguages)),
       g_browser_process->clipboard());
 }
 
 void RenderViewContextMenu::MediaPlayerActionAt(
     const gfx::Point& location,
     const WebMediaPlayerAction& action) {
   source_tab_contents_->render_view_host()->MediaPlayerActionAt(
       location, action);
 }