Add support for a "frame" context option to chrome.contextMenus.create/update.

chrome/browser/extensions/extension_context_menu_browsertest.cc

 // Copyright (c) 2011 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 "base/utf_string_conversions.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/extensions/extension_browsertest.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 113 matching lines @@
   }
 
   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) {
+                                        const GURL& link_url,
+                                        const GURL& frame_url) {
     TabContents* tab_contents = browser->GetSelectedTabContents();
     WebContextMenuData data;
     ContextMenuParams params(data);
     params.page_url = page_url;
     params.link_url = link_url;
+    params.frame_url = frame_url;
     TestRenderViewContextMenu* menu =
         new TestRenderViewContextMenu(tab_contents, params);
     menu->Init();
     return menu;
   }
 
   // Shortcut to return the current ExtensionMenuManager.
   ExtensionMenuManager* menu_manager() {
     return browser()->profile()->GetExtensionService()->menu_manager();
   }
@@ skipping 23 matching lines @@
       result.insert(result.end(), list->begin(), list->end());
     }
     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 GURL& frame_url,
                             const std::string& label) {
     scoped_ptr<TestRenderViewContextMenu> menu(
-        CreateMenu(browser(), page_url, link_url));
+        CreateMenu(browser(), page_url, link_url, frame_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(browser(), page_url, GURL()));
+      CreateMenu(browser(), page_url, GURL(), 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());
 }
 
 // Tests that setting "documentUrlPatterns" for an item properly restricts
 // those items to matching pages.
 IN_PROC_BROWSER_TEST_F(ExtensionContextMenuBrowserTest, Patterns) {
   ExtensionTestMessageListener listener("created items", false);
 
   ASSERT_TRUE(LoadContextMenuExtension("patterns"));
 
   // Wait for the js test code to create its two items with patterns.
   ASSERT_TRUE(listener.WaitUntilSatisfied());
 
   // Check that a document url that should match the items' patterns appears.
   GURL google_url("http://www.google.com");
   ASSERT_TRUE(MenuHasItemWithLabel(google_url,
                                    GURL(),
+                                   GURL(),
                                    std::string("test_item1")));
   ASSERT_TRUE(MenuHasItemWithLabel(google_url,
                                    GURL(),
+                                   GURL(),
                                    std::string("test_item2")));
 
   // Now check with a non-matching url.
   GURL test_url("http://www.test.com");
   ASSERT_FALSE(MenuHasItemWithLabel(test_url,
                                     GURL(),
+                                   GURL(),
                                     std::string("test_item1")));
   ASSERT_FALSE(MenuHasItemWithLabel(test_url,
                                     GURL(),
+                                    GURL(),
                                     std::string("test_item2")));
 }
 
 // Tests registering an item with a very long title that should get truncated in
 // the actual menu displayed.
 IN_PROC_BROWSER_TEST_F(ExtensionContextMenuBrowserTest, LongTitle) {
   ExtensionTestMessageListener listener("created", false);
 
   // Load the extension and wait until it's created a menu item.
   ASSERT_TRUE(LoadContextMenuExtension("long_title"));
   ASSERT_TRUE(listener.WaitUntilSatisfied());
 
   // 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(browser(), url, GURL()));
+      CreateMenu(browser(), url, GURL(), 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 44 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(browser(), url, GURL()));
+      CreateMenu(browser(), url, GURL(), 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(browser(), url, GURL()));
+  menu.reset(CreateMenu(browser(), url, GURL(), 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.
 IN_PROC_BROWSER_TEST_F(ExtensionContextMenuBrowserTest, TargetURLs) {
   ExtensionTestMessageListener listener("created items", false);
   ASSERT_TRUE(LoadContextMenuExtension("target_urls"));
   ASSERT_TRUE(listener.WaitUntilSatisfied());
 
   GURL google_url("http://www.google.com");
   GURL non_google_url("http://www.foo.com");
 
   // No target url - the item should not appear.
-  ASSERT_FALSE(MenuHasItemWithLabel(google_url, GURL(), std::string("item1")));
+  ASSERT_FALSE(MenuHasItemWithLabel(
+      google_url, GURL(), GURL(), std::string("item1")));
 
   // A matching target url - the item should appear.
   ASSERT_TRUE(MenuHasItemWithLabel(google_url,
                                    google_url,
+                                   GURL(),
                                    std::string("item1")));
 
   // A non-matching target url - the item should not appear.
   ASSERT_FALSE(MenuHasItemWithLabel(google_url,
                                     non_google_url,
+                                    GURL(),
                                     std::string("item1")));
 }
 
-// Tests adding a simple context menu item.
+// Tests adding of context menus in incognito mode.
 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()));
+      CreateMenu(browser(), page_url, GURL(), GURL()));
   scoped_ptr<TestRenderViewContextMenu> menu_incognito(
-      CreateMenu(browser_incognito, page_url, GURL()));
+      CreateMenu(browser_incognito, page_url, GURL(), 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());
 }
+
+// Tests that items with a context of frames only appear when the menu is
+// invoked in a frame.
+IN_PROC_BROWSER_TEST_F(ExtensionContextMenuBrowserTest, Frames) {
+  ExtensionTestMessageListener listener("created items", false);
+  ASSERT_TRUE(LoadContextMenuExtension("frames"));
+  ASSERT_TRUE(listener.WaitUntilSatisfied());
+
+  GURL page_url("http://www.google.com");
+  GURL no_frame_url;
+  GURL frame_url("http://www.google.com");
+
+  ASSERT_TRUE(MenuHasItemWithLabel(
+      page_url, GURL(), no_frame_url, std::string("Page item")));
+  ASSERT_FALSE(MenuHasItemWithLabel(
+      page_url, GURL(), no_frame_url, std::string("Frame item")));
+
+  ASSERT_TRUE(MenuHasItemWithLabel(
+      page_url, GURL(), frame_url, std::string("Page item")));
+  ASSERT_TRUE(MenuHasItemWithLabel(
+      page_url, GURL(), frame_url, std::string("Frame item")));
+}