Fix bug with context menus in incognito mode.

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/l10n_util.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/autocomplete/autocomplete_classifier.h"
 #include "chrome/browser/autocomplete/autocomplete_edit.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/child_process_security_policy.h"
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/debugger/devtools_window.h"
 #include "chrome/browser/download/download_manager.h"
+#include "chrome/browser/extensions/extension_event_router.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/fonts_languages_window.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/net/browser_url_util.h"
 #include "chrome/browser/page_info_window.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/prefs/pref_member.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_view_host.h"
@@ skipping 107 matching lines @@
   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|.
+// of |params| and the profile.
 static ExtensionMenuItem::List GetRelevantExtensionItems(
     const ExtensionMenuItem::List& items,
-    const ContextMenuParams& params) {
+    const ContextMenuParams& params,
+    Profile* profile,
+    bool can_cross_incognito) {
   ExtensionMenuItem::List result;
   for (ExtensionMenuItem::List::const_iterator i = items.begin();
        i != items.end(); ++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 (!ExtensionPatternMatch(item->target_url_patterns(), target_url))
       continue;
 
-    result.push_back(*i);
+    if (item->id().profile == profile || can_cross_incognito)
+      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();
   const Extension* extension = service->GetExtensionById(extension_id, false);
+  bool can_cross_incognito =
+      ExtensionEventRouter::CanCrossIncognito(profile_, extension);
   DCHECK_GE(*index, 0);
   int max_index =
       IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST - IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST;
   if (!extension || *index >= max_index)
     return;
 
   // Find matching items.
   const ExtensionMenuItem::List* all_items = manager->MenuItems(extension_id);
   if (!all_items || all_items->empty())
     return;
   ExtensionMenuItem::List items =
-      GetRelevantExtensionItems(*all_items, params_);
+      GetRelevantExtensionItems(*all_items, params_, profile_,
+                                can_cross_incognito);
   if (items.empty())
     return;
 
   // If this is the first extension-provided menu item, add a separator.
   if (*index == 0)
     menu_model_.AddSeparator();
 
   int menu_id = IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST + (*index)++;
 
   // Extensions are only allowed one top-level slot (and it can't be a radio or
   // checkbox item because we are going to put the extension icon next to it).
   // If they have more than that, we automatically push them into a submenu.
   string16 title;
   ExtensionMenuItem::List submenu_items;
   if (items.size() > 1 || items[0]->type() != ExtensionMenuItem::NORMAL) {
     title = UTF8ToUTF16(extension->name());
     submenu_items = items;
   } else {
     ExtensionMenuItem* item = items[0];
     extension_item_map_[menu_id] = item->id();
     title = item->TitleWithReplacement(PrintableSelectionText(),
                                        kMaxExtensionItemTitleLength);
-    submenu_items = GetRelevantExtensionItems(item->children(), params_);
+    submenu_items = GetRelevantExtensionItems(item->children(), params_,
+                                              profile_, can_cross_incognito);
   }
 
   // Now add our item(s) to the menu_model_.
   if (submenu_items.empty()) {
     menu_model_.AddItem(menu_id, title);
   } else {
     menus::SimpleMenuModel* submenu = new menus::SimpleMenuModel(this);
     extension_menu_models_.push_back(submenu);
     menu_model_.AddSubMenu(menu_id, title, submenu);
-    RecursivelyAppendExtensionItems(submenu_items, submenu, index);
+    RecursivelyAppendExtensionItems(submenu_items, can_cross_incognito, submenu,
+                                    index);
   }
   SetExtensionIcon(extension_id);
 }
 
 void RenderViewContextMenu::RecursivelyAppendExtensionItems(
     const ExtensionMenuItem::List& items,
+    bool can_cross_incognito,
     menus::SimpleMenuModel* menu_model,
     int *index) {
   string16 selection_text = PrintableSelectionText();
   ExtensionMenuItem::Type last_type = ExtensionMenuItem::NORMAL;
   int radio_group_id = 1;
 
   for (ExtensionMenuItem::List::const_iterator i = items.begin();
        i != items.end(); ++i) {
     ExtensionMenuItem* item = *i;
 
     // If last item was of type radio but the current one isn't, auto-insert
     // a separator.  The converse case is handled below.
     if (last_type == ExtensionMenuItem::RADIO &&
         item->type() != ExtensionMenuItem::RADIO) {
       menu_model->AddSeparator();
       last_type = ExtensionMenuItem::SEPARATOR;
     }
 
     int menu_id = IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST + (*index)++;
     if (menu_id >= IDC_EXTENSIONS_CONTEXT_CUSTOM_LAST)
       return;
     extension_item_map_[menu_id] = item->id();
     string16 title = item->TitleWithReplacement(selection_text,
                                                 kMaxExtensionItemTitleLength);
     if (item->type() == ExtensionMenuItem::NORMAL) {
       ExtensionMenuItem::List children =
-          GetRelevantExtensionItems(item->children(), params_);
+          GetRelevantExtensionItems(item->children(), params_,
+                                    profile_, can_cross_incognito);
       if (children.size() == 0) {
         menu_model->AddItem(menu_id, title);
       } else {
         menus::SimpleMenuModel* submenu = new menus::SimpleMenuModel(this);
         extension_menu_models_.push_back(submenu);
         menu_model->AddSubMenu(menu_id, title, submenu);
-        RecursivelyAppendExtensionItems(children, submenu, index);
+        RecursivelyAppendExtensionItems(children, can_cross_incognito,
+                                        submenu, index);
       }
     } else if (item->type() == ExtensionMenuItem::CHECKBOX) {
       menu_model->AddCheckItem(menu_id, title);
     } else if (item->type() == ExtensionMenuItem::RADIO) {
       if (i != items.begin() &&
           last_type != ExtensionMenuItem::RADIO) {
         radio_group_id++;
 
         // Auto-append a separator if needed.
         if (last_type != ExtensionMenuItem::SEPARATOR)
@@ skipping 1196 matching lines @@
       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);
 }