<webview>: Context menu API implementation CL.

chrome/browser/extensions/extension_context_menu_browsertest.cc

 // Copyright (c) 2012 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/strings/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/extensions/lazy_background_page_test_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/renderer_context_menu/render_view_context_menu.h"
+#include "chrome/browser/renderer_context_menu/render_view_context_menu_test_util.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "content/public/common/context_menu_params.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/test_management_policy.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/switches.h"
 #include "net/dns/mock_host_resolver.h"
 #include "ui/base/models/menu_model.h"
 
 using content::WebContents;
 using extensions::MenuItem;
 using ui::MenuModel;
 
-namespace {
-// This test class helps us sidestep platform-specific issues with popping up a
-// real context menu, while still running through the actual code in
-// RenderViewContextMenu where extension items get added and executed.
-class TestRenderViewContextMenu : public RenderViewContextMenu {
- public:
-  TestRenderViewContextMenu(content::RenderFrameHost* render_frame_host,
-                            const content::ContextMenuParams& params)
-      : RenderViewContextMenu(render_frame_host, params) {}
-
-  virtual ~TestRenderViewContextMenu() {}
-
-  // Searches for an menu item with |command_id|. If it's found, the return
-  // value is true and the model and index where it appears in that model are
-  // returned in |found_model| and |found_index|. Otherwise returns false.
-  bool GetMenuModelAndItemIndex(int command_id,
-                                MenuModel** found_model,
-                                int *found_index) {
-    std::vector<MenuModel*> models_to_search;
-    models_to_search.push_back(&menu_model_);
-
-    while (!models_to_search.empty()) {
-      MenuModel* model = models_to_search.back();
-      models_to_search.pop_back();
-      for (int i = 0; i < model->GetItemCount(); i++) {
-        if (model->GetCommandIdAt(i) == command_id) {
-          *found_model = model;
-          *found_index = i;
-          return true;
-        } else if (model->GetTypeAt(i) == MenuModel::TYPE_SUBMENU) {
-          models_to_search.push_back(model->GetSubmenuModelAt(i));
-        }
-      }
-    }
-
-    return false;
-  }
-
-  extensions::ContextMenuMatcher& extension_items() {
-    return extension_items_;
-  }
-
- protected:
-  // These two functions implement pure virtual methods of
-  // RenderViewContextMenu.
-  virtual bool GetAcceleratorForCommandId(
-      int command_id,
-      ui::Accelerator* accelerator) OVERRIDE {
-    // None of our commands have accelerators, so always return false.
-    return false;
-  }
-  virtual void PlatformInit() OVERRIDE {}
-  virtual void PlatformCancel() OVERRIDE {}
-};
-
-}  // namespace
-
 class ExtensionContextMenuBrowserTest : public ExtensionBrowserTest {
  public:
   // Helper to load an extension from context_menus/|subdirectory| in the
   // extensions test data dir.
   const extensions::Extension* LoadContextMenuExtension(
       std::string subdirectory) {
     base::FilePath extension_dir =
         test_data_dir_.AppendASCII("context_menus").AppendASCII(subdirectory);
     return LoadExtension(extension_dir);
   }
 
   // Helper to load an extension from context_menus/top_level/|subdirectory| in
   // the extensions test data dir.
   const extensions::Extension* LoadTopLevelContextMenuExtension(
       std::string subdirectory) {
     base::FilePath extension_dir =
         test_data_dir_.AppendASCII("context_menus").AppendASCII("top_level");
     extension_dir = extension_dir.AppendASCII(subdirectory);
     return LoadExtension(extension_dir);
   }
 
   const extensions::Extension* LoadContextMenuExtensionIncognito(
       std::string subdirectory) {
     base::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& frame_url) {
-    WebContents* web_contents =
-        browser->tab_strip_model()->GetActiveWebContents();
-    content::ContextMenuParams params;
-    params.page_url = page_url;
-    params.link_url = link_url;
-    params.frame_url = frame_url;
-    TestRenderViewContextMenu* menu =
-        new TestRenderViewContextMenu(web_contents->GetMainFrame(), params);
-    menu->Init();
-    return menu;
+  // Returns the active WebContents.
+  WebContents* GetWebContents() {
+    return browser()->tab_strip_model()->GetActiveWebContents();
   }
 
   // Shortcut to return the current MenuManager.
   extensions::MenuManager* menu_manager() {
     return extensions::MenuManager::Get(browser()->profile());
   }
 
   // Returns a pointer to the currently loaded extension with |name|, or null
   // if not found.
   const extensions::Extension* GetExtensionNamed(std::string name) {
     const extensions::ExtensionSet* extensions =
         browser()->profile()->GetExtensionService()->extensions();
     for (extensions::ExtensionSet::const_iterator i = extensions->begin();
          i != extensions->end(); ++i) {
       if ((*i)->name() == name) {
         return i->get();
       }
     }
     return NULL;
   }
 
   // This gets all the items that any extension has registered for possible
   // inclusion in context menus.
   MenuItem::List GetItems() {
     MenuItem::List result;
-    std::set<std::string> extension_ids = menu_manager()->ExtensionIds();
-    std::set<std::string>::iterator i;
+    std::set<MenuItem::ExtensionKey> extension_ids =
+        menu_manager()->ExtensionIds();
+    std::set<MenuItem::ExtensionKey>::iterator i;
     for (i = extension_ids.begin(); i != extension_ids.end(); ++i) {
       const MenuItem::List* list = menu_manager()->MenuItems(*i);
       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, frame_url));
+        TestRenderViewContextMenu::Create(
+            GetWebContents(), page_url, link_url, frame_url));
     return MenuHasExtensionItemWithLabel(menu.get(), label);
   }
 
   // This creates an extension that starts |enabled| and then switches to
   // |!enabled|.
   void TestEnabledContextMenu(bool enabled) {
     ExtensionTestMessageListener begin("begin", true);
     ExtensionTestMessageListener create("create", true);
     ExtensionTestMessageListener update("update", false);
     ASSERT_TRUE(LoadContextMenuExtension("enabled"));
 
     ASSERT_TRUE(begin.WaitUntilSatisfied());
 
     if (enabled)
       begin.Reply("start enabled");
     else
       begin.Reply("start disabled");
 
     // Wait for the extension to tell us it's created an item.
     ASSERT_TRUE(create.WaitUntilSatisfied());
     create.Reply("go");
 
     GURL page_url("http://www.google.com");
 
     // Create and build our test context menu.
     scoped_ptr<TestRenderViewContextMenu> menu(
-        CreateMenu(browser(), page_url, GURL(), GURL()));
+        TestRenderViewContextMenu::Create(
+            GetWebContents(), page_url, GURL(), GURL()));
 
     // Look for the extension item in the menu, and make sure it's |enabled|.
     int command_id = IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST;
     ASSERT_EQ(enabled, menu->IsCommandIdEnabled(command_id));
 
     // Update the item and make sure it is now |!enabled|.
     ASSERT_TRUE(update.WaitUntilSatisfied());
     ASSERT_EQ(!enabled, menu->IsCommandIdEnabled(command_id));
   }
 
@@ skipping 53 matching lines @@
   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(), GURL()));
+  scoped_ptr<TestRenderViewContextMenu> menu(TestRenderViewContextMenu::Create(
+      GetWebContents(), 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, 0);
 
   // Wait for the extension's script to tell us its onclick fired.
   ASSERT_TRUE(listener2.WaitUntilSatisfied());
 }
 
@@ skipping 43 matching lines @@
   size_t limit = extensions::ContextMenuMatcher::kMaxExtensionItemTitleLength;
   MenuItem::List items = GetItems();
   ASSERT_EQ(1u, items.size());
   MenuItem* 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(), GURL()));
+      TestRenderViewContextMenu::Create(GetWebContents(), url, GURL(), GURL()));
 
   base::string16 label;
   ASSERT_TRUE(GetItemLabel(menu.get(), item->id(), &label));
   ASSERT_TRUE(label.size() <= limit);
 }
 
 // Flaky on Windows debug bots. http://crbug.com/251590
 #if defined(OS_WIN)
 #define MAYBE_TopLevel DISABLED_TopLevel
 #else
@@ skipping 31 matching lines @@
   ExtensionTestMessageListener listener4("created items", false);
   ASSERT_TRUE(LoadTopLevelContextMenuExtension("multi4"));
   ASSERT_TRUE(listener4.WaitUntilSatisfied());
 
   ExtensionTestMessageListener listener5("created items", false);
   ASSERT_TRUE(LoadTopLevelContextMenuExtension("multi5"));
   ASSERT_TRUE(listener5.WaitUntilSatisfied());
 
   GURL url("http://foo.com/");
   scoped_ptr<TestRenderViewContextMenu> menu(
-      CreateMenu(browser(), url, GURL(), GURL()));
+      TestRenderViewContextMenu::Create(GetWebContents(), url, GURL(), GURL()));
 
   int index = 0;
   MenuModel* model = NULL;
 
   ASSERT_TRUE(menu->GetMenuModelAndItemIndex(
       IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST, &model, &index));
   EXPECT_EQ(base::UTF8ToUTF16("An Extension with multiple Context Menus"),
                               model->GetLabelAt(index++));
   EXPECT_EQ(base::UTF8ToUTF16("Context Menu #1 - Extension #2"),
                               model->GetLabelAt(index++));
@@ skipping 62 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(), GURL()));
+      TestRenderViewContextMenu::Create(GetWebContents(), url, GURL(), GURL()));
 
   // The top-level item should be an "automagic parent" with the extension's
   // name.
   MenuModel* model = NULL;
   int index = 0;
   base::string16 label;
   ASSERT_TRUE(menu->GetMenuModelAndItemIndex(
       IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST, &model, &index));
   EXPECT_EQ(base::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(), GURL()));
+  menu.reset(
+      TestRenderViewContextMenu::Create(GetWebContents(), url, GURL(), GURL()));
   ASSERT_TRUE(menu->GetMenuModelAndItemIndex(
       IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST, &model, &index));
   EXPECT_EQ(base::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 44 matching lines @@
 
   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.
-  scoped_ptr<TestRenderViewContextMenu> menu(
-      CreateMenu(browser(), page_url, GURL(), GURL()));
+  scoped_ptr<TestRenderViewContextMenu> menu(TestRenderViewContextMenu::Create(
+      GetWebContents(), page_url, GURL(), GURL()));
+  WebContents* incognito_web_contents =
+      browser_incognito->tab_strip_model()->GetActiveWebContents();
   scoped_ptr<TestRenderViewContextMenu> menu_incognito(
-      CreateMenu(browser_incognito, page_url, GURL(), GURL()));
+      TestRenderViewContextMenu::Create(
+          incognito_web_contents, 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, 0);
 
   // 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());
@@ skipping 53 matching lines @@
   page_complete.Wait();
 
   // Test that menu items appear while the page is unloaded.
   ASSERT_TRUE(MenuHasItemWithLabel(
       about_blank, GURL(), GURL(), std::string("Item 1")));
   ASSERT_TRUE(MenuHasItemWithLabel(
       about_blank, GURL(), GURL(), std::string("Checkbox 1")));
 
   // Test that checked menu items retain their checkedness.
   LazyBackgroundObserver checkbox_checked;
-  scoped_ptr<TestRenderViewContextMenu> menu(
-      CreateMenu(browser(), about_blank, GURL(), GURL()));
-  MenuItem::Id id(false, extension->id());
+  scoped_ptr<TestRenderViewContextMenu> menu(TestRenderViewContextMenu::Create(
+      GetWebContents(), about_blank, GURL(), GURL()));
+
+  MenuItem::Id id(false, MenuItem::ExtensionKey(extension->id()));
   id.string_uid = "checkbox1";
   int command_id = -1;
   ASSERT_TRUE(FindCommandId(menu.get(), id, &command_id));
   EXPECT_FALSE(menu->IsCommandIdChecked(command_id));
 
   // Executing the checkbox also fires the onClicked event.
   ExtensionTestMessageListener listener("onClicked fired for checkbox1", false);
   menu->ExecuteCommand(command_id, 0);
   checkbox_checked.WaitUntilClosed();
 
@@ skipping 12 matching lines @@
   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());
   ASSERT_EQ(2u, GetItems().size());
 
   browser()->profile()->DestroyOffTheRecordProfile();
   ASSERT_EQ(1u, GetItems().size());
 }