Fix bug with context menus in incognito mode.

chrome/browser/extensions/extension_context_menu_browsertest.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 "app/menus/menu_model.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/browser/browser.h"
+#include "chrome/browser/browser_list.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/render_view_context_menu.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/test/ui_test_utils.h"
 #include "net/base/mock_host_resolver.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebContextMenuData.h"
@@ skipping 97 matching lines @@
 class ExtensionContextMenuBrowserTest : public ExtensionBrowserTest {
  public:
   // Helper to load an extension from context_menus/|subdirectory| in the
   // extensions test data dir.
   bool LoadContextMenuExtension(std::string subdirectory) {
     FilePath extension_dir =
         test_data_dir_.AppendASCII("context_menus").AppendASCII(subdirectory);
     return LoadExtension(extension_dir);
   }
 
-  TestRenderViewContextMenu* CreateMenu(const GURL& page_url,
+  bool LoadContextMenuExtensionIncognito(std::string subdirectory) {
+    FilePath extension_dir =
+        test_data_dir_.AppendASCII("context_menus").AppendASCII(subdirectory);
+    return LoadExtensionIncognito(extension_dir);
+  }
+
+  TestRenderViewContextMenu* CreateMenu(Browser* browser,
+                                        const GURL& page_url,
                                         const GURL& link_url) {
-    TabContents* tab_contents = browser()->GetSelectedTabContents();
+    TabContents* tab_contents = browser->GetSelectedTabContents();
     WebContextMenuData data;
     ContextMenuParams params(data);
     params.page_url = page_url;
     params.link_url = link_url;
     TestRenderViewContextMenu* menu =
         new TestRenderViewContextMenu(tab_contents, params);
     menu->Init();
     return menu;
   }
 
@@ skipping 28 matching lines @@
     }
     return result;
   }
 
   // This creates a test menu for a page with |page_url| and |link_url|, looks
   // for an extension item with the given |label|, and returns true if the item
   // was found.
   bool MenuHasItemWithLabel(const GURL& page_url,
                             const GURL& link_url,
                             const std::string& label) {
-    scoped_ptr<TestRenderViewContextMenu> menu(CreateMenu(page_url, link_url));
+    scoped_ptr<TestRenderViewContextMenu> menu(
+        CreateMenu(browser(), page_url, link_url));
     return menu->HasExtensionItemWithLabel(label);
   }
 };
 
 // Tests adding a simple context menu item.
 IN_PROC_BROWSER_TEST_F(ExtensionContextMenuBrowserTest, Simple) {
   ExtensionTestMessageListener listener1("created item", false);
   ExtensionTestMessageListener listener2("onclick fired", false);
   ASSERT_TRUE(LoadContextMenuExtension("simple"));
 
   // Wait for the extension to tell us it's created an item.
   ASSERT_TRUE(listener1.WaitUntilSatisfied());
 
   GURL page_url("http://www.google.com");
 
   // Create and build our test context menu.
-  scoped_ptr<TestRenderViewContextMenu> menu(CreateMenu(page_url, GURL()));
+  scoped_ptr<TestRenderViewContextMenu> menu(
+      CreateMenu(browser(), page_url, GURL()));
 
   // Look for the extension item in the menu, and execute it.
   int command_id = IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST;
   ASSERT_TRUE(menu->IsCommandIdEnabled(command_id));
   menu->ExecuteCommand(command_id);
 
   // Wait for the extension's script to tell us its onclick fired.
   ASSERT_TRUE(listener2.WaitUntilSatisfied());
 }
 
@@ skipping 38 matching lines @@
   // Make sure we have an item registered with a long title.
   size_t limit = RenderViewContextMenu::kMaxExtensionItemTitleLength;
   ExtensionMenuItem::List items = GetItems();
   ASSERT_EQ(1u, items.size());
   ExtensionMenuItem* item = items.at(0);
   ASSERT_GT(item->title().size(), limit);
 
   // Create a context menu, then find the item's label. It should be properly
   // truncated.
   GURL url("http://foo.com/");
-  scoped_ptr<TestRenderViewContextMenu> menu(CreateMenu(url, GURL()));
+  scoped_ptr<TestRenderViewContextMenu> menu(
+      CreateMenu(browser(), url, GURL()));
 
   string16 label;
   ASSERT_TRUE(menu->GetItemLabel(item->id(), &label));
   ASSERT_TRUE(label.size() <= limit);
 }
 
 // Checks that in |menu|, the item at |index| has type |expected_type| and a
 // label of |expected_label|.
 static void ExpectLabelAndType(const char* expected_label,
                                MenuModel::ItemType expected_type,
@@ skipping 43 matching lines @@
 
   // Navigate to test1.html inside the extension, which should create a bunch
   // of items at the top-level (but they'll get pushed into an auto-generated
   // parent).
   ExtensionTestMessageListener listener1("test1 create finished", false);
   ui_test_utils::NavigateToURL(browser(),
                                GURL(extension->GetResourceURL("test1.html")));
   listener1.WaitUntilSatisfied();
 
   GURL url("http://www.google.com/");
-  scoped_ptr<TestRenderViewContextMenu> menu(CreateMenu(url, GURL()));
+  scoped_ptr<TestRenderViewContextMenu> menu(
+      CreateMenu(browser(), url, GURL()));
 
   // The top-level item should be an "automagic parent" with the extension's
   // name.
   MenuModel* model = NULL;
   int index = 0;
   string16 label;
   ASSERT_TRUE(menu->GetMenuModelAndItemIndex(
       IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST, &model, &index));
   EXPECT_EQ(UTF8ToUTF16(extension->name()), model->GetLabelAt(index));
   ASSERT_EQ(MenuModel::TYPE_SUBMENU, model->GetTypeAt(index));
 
   // Get the submenu and verify the items there.
   MenuModel* submenu = model->GetSubmenuModelAt(index);
   ASSERT_TRUE(submenu != NULL);
   VerifyMenuForSeparatorsTest(*submenu);
 
   // Now run our second test - navigate to test2.html which creates an explicit
   // parent node and populates that with the same items as in test1.
   ExtensionTestMessageListener listener2("test2 create finished", false);
   ui_test_utils::NavigateToURL(browser(),
                                GURL(extension->GetResourceURL("test2.html")));
   listener2.WaitUntilSatisfied();
-  menu.reset(CreateMenu(url, GURL()));
+  menu.reset(CreateMenu(browser(), url, GURL()));
   ASSERT_TRUE(menu->GetMenuModelAndItemIndex(
       IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST, &model, &index));
   EXPECT_EQ(UTF8ToUTF16("parent"), model->GetLabelAt(index));
   submenu = model->GetSubmenuModelAt(index);
   ASSERT_TRUE(submenu != NULL);
   VerifyMenuForSeparatorsTest(*submenu);
 }
 
 // Tests that targetUrlPattern keeps items from appearing when there is no
 // target url.
@@ skipping 11 matching lines @@
   // A matching target url - the item should appear.
   ASSERT_TRUE(MenuHasItemWithLabel(google_url,
                                    google_url,
                                    std::string("item1")));
 
   // A non-matching target url - the item should not appear.
   ASSERT_FALSE(MenuHasItemWithLabel(google_url,
                                     non_google_url,
                                     std::string("item1")));
 }
+
+// Tests adding a simple context menu item.
+IN_PROC_BROWSER_TEST_F(ExtensionContextMenuBrowserTest, IncognitoSplit) {
+  ExtensionTestMessageListener created("created item regular", false);
+  ExtensionTestMessageListener created_incognito("created item incognito",
+                                                 false);
+
+  ExtensionTestMessageListener onclick("onclick fired regular", false);
+  ExtensionTestMessageListener onclick_incognito("onclick fired incognito",
+                                                 false);
+
+  // Open an incognito window.
+  ui_test_utils::OpenURLOffTheRecord(browser()->profile(), GURL("about:blank"));
+
+  ASSERT_TRUE(LoadContextMenuExtensionIncognito("incognito"));
+
+  // Wait for the extension's processes to tell us they've created an item.
+  ASSERT_TRUE(created.WaitUntilSatisfied());
+  ASSERT_TRUE(created_incognito.WaitUntilSatisfied());
+
+  GURL page_url("http://www.google.com");
+
+  // Create and build our test context menu.
+  Browser* browser_incognito = BrowserList::FindBrowserWithType(
+      browser()->profile()->GetOffTheRecordProfile(),
+      Browser::TYPE_NORMAL, false);
+  ASSERT_TRUE(browser_incognito);
+  scoped_ptr<TestRenderViewContextMenu> menu(
+      CreateMenu(browser(), page_url, GURL()));
+  scoped_ptr<TestRenderViewContextMenu> menu_incognito(
+      CreateMenu(browser_incognito, page_url, GURL()));
+
+  // Look for the extension item in the menu, and execute it.
+  int command_id = IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST;
+  ASSERT_TRUE(menu->IsCommandIdEnabled(command_id));
+  menu->ExecuteCommand(command_id);
+
+  // Wait for the extension's script to tell us its onclick fired. Ensure
+  // that the incognito version doesn't fire until we explicitly click the
+  // incognito menu item.
+  ASSERT_TRUE(onclick.WaitUntilSatisfied());
+  EXPECT_FALSE(onclick_incognito.was_satisfied());
+
+  ASSERT_TRUE(menu_incognito->IsCommandIdEnabled(command_id));
+  menu_incognito->ExecuteCommand(command_id);
+  ASSERT_TRUE(onclick_incognito.WaitUntilSatisfied());
+}