<webview>: Context menu API implementation CL.

chrome/browser/apps/web_view_browsertest.cc

 // Copyright 2013 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 "apps/ui/native_app_window.h"
 #include "base/path_service.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/apps/app_browsertest_util.h"
 #include "chrome/browser/automation/automation_util.h"
 #include "chrome/browser/chrome_content_browser_client.h"
 #include "chrome/browser/extensions/extension_test_message_listener.h"
 #include "chrome/browser/prerender/prerender_link_manager.h"
 #include "chrome/browser/prerender/prerender_link_manager_factory.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/renderer_context_menu/render_view_context_menu.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/browser/gpu_data_manager.h"
 #include "content/public/browser/interstitial_page.h"
 #include "content/public/browser/interstitial_page_delegate.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents_delegate.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/fake_speech_recognition_manager.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extensions_client.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "ui/gl/gl_switches.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
 #include "chrome/browser/chromeos/accessibility/speech_monitor.h"
 #endif
 
 // For fine-grained suppression on flaky tests.
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
+using extensions::MenuItem;
 using prerender::PrerenderLinkManager;
 using prerender::PrerenderLinkManagerFactory;
+using ui::MenuModel;
 
 namespace {
 const char kEmptyResponsePath[] = "/close-socket";
 const char kRedirectResponsePath[] = "/server-redirect";
 const char kRedirectResponseFullPath[] =
     "/extensions/platform_apps/web_view/shim/guest_redirect.html";
 
 // Platform-specific filename relative to the chrome executable.
 #if defined(OS_WIN)
 const wchar_t library_name[] = L"ppapi_tests.dll";
@@ skipping 68 matching lines @@
     detach_callback_.Run();
   }
 
  private:
   base::Closure attach_callback_;
   base::Closure detach_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(InterstitialObserver);
 };
 
+// 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 {

[Yoyo Zhou, 2014/03/07 02:40:30]

This looks duplicated from ExtensionContextMenuBrowserTest. There is also a
class by this name in render_view_context_menu_test_util.h. Can we combine this
with at least the first one?

[lazyboy, 2014/03/07 06:38:03]

I've made WebViewTest (this) and ExtensionContextMenuBrowserTest use the one
from render_view_context_menu_test_util.h (after some modification).

Altho, codesearch shows there are 5+ other TestRenderViewContextMenu-s :(
I've filed http://crbug.com/350302 to track.

+ 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
 
 // This class intercepts media access request from the embedder. The request
 // should be triggered only if the embedder API (from tests) allows the request
 // in Javascript.
 // We do not issue the actual media request; the fact that the request reached
 // embedder's WebContents is good enough for our tests. This is also to make
 // the test run successfully on trybots.
 class MockWebContentsDelegate : public content::WebContentsDelegate {
  public:
@@ skipping 334 matching lines @@
       const std::string& path,
       const net::test_server::HttpRequest& request) {
     if (StartsWithASCII(path, request.relative_url, true)) {
       return scoped_ptr<net::test_server::HttpResponse>(
           new EmptyHttpResponse);
     }
 
     return scoped_ptr<net::test_server::HttpResponse>();
   }
 
+  TestRenderViewContextMenu* CreateMenu(Browser* browser,
+                                        const GURL& page_url,
+                                        content::WebContents* web_contents) {
+    content::ContextMenuParams params;
+    params.page_url = page_url;
+    params.link_url = GURL();
+    params.frame_url = GURL();
+    TestRenderViewContextMenu* menu =
+        new TestRenderViewContextMenu(web_contents->GetMainFrame(), params);
+    printf("menu->Init()\n");
+    menu->Init();
+    return menu;
+  }
+
+  // Shortcut to return the current MenuManager.
+  extensions::MenuManager* menu_manager() {
+    return extensions::MenuManager::Get(browser()->profile());
+  }
+
+  // This gets all the items that any extension has registered for possible
+  // inclusion in context menus.
+  MenuItem::List GetItems() {
+    MenuItem::List result;
+    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;
+  }
+
   enum TestServer {
     NEEDS_TEST_SERVER,
     NO_TEST_SERVER
   };
 
   void TestHelper(const std::string& test_name,
                   const std::string& app_location,
                   TestServer test_server) {
     // For serving guest pages.
     if (test_server == NEEDS_TEST_SERVER) {
@@ skipping 1004 matching lines @@
   EXPECT_TRUE(
       content::ExecuteScript(
           embedder_web_contents,
           base::StringPrintf("startAllowTest('%s')",
                              test_name.c_str())));
   ASSERT_TRUE(done_listener.WaitUntilSatisfied());
 
   mock->WaitForSetMediaPermission();
 }
 
+IN_PROC_BROWSER_TEST_F(WebViewTest, ContextMenusAPI_Basic) {
+  GuestContentBrowserClient new_client;
+  content::ContentBrowserClient* old_client =
+      SetBrowserClientForTesting(&new_client);
+
+  ExtensionTestMessageListener launched_listener("Launched", false);
+  launched_listener.AlsoListenForFailureMessage("TEST_FAILED");
+  LoadAndLaunchPlatformApp("web_view/context_menus/basic");
+  ASSERT_TRUE(launched_listener.WaitUntilSatisfied());
+
+  content::WebContents* guest_web_contents = new_client.WaitForGuestCreated();
+  ASSERT_TRUE(guest_web_contents);
+  SetBrowserClientForTesting(old_client);
+
+  content::WebContents* embedder = GetFirstAppWindowWebContents();
+  ASSERT_TRUE(embedder);
+
+  // 1. Basic property test.
+  ExecuteScriptWaitForTitle(embedder, "checkProperties()", "ITEM_CHECKED");
+
+  // 2. Create a menu item and wait for created callback to be called.
+  ExecuteScriptWaitForTitle(embedder, "createMenuItem()", "ITEM_CREATED");
+
+  // 3. Click the created item, wait for the click handlers to fire from JS.
+  ExtensionTestMessageListener click_listener("ITEM_CLICKED", false);
+  GURL page_url("http://www.google.com");
+  // Create and build our test context menu.
+  scoped_ptr<TestRenderViewContextMenu> menu(
+      CreateMenu(browser(), page_url, guest_web_contents));
+  // 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 embedder's script to tell us its onclick fired, it does
+  // chrome.test.sendMessage('ITEM_CLICKED')
+  ASSERT_TRUE(click_listener.WaitUntilSatisfied());
+
+  // 4. Update the item's title and verify.
+  ExecuteScriptWaitForTitle(embedder, "updateMenuItem()", "ITEM_UPDATED");
+  MenuItem::List items = GetItems();
+  ASSERT_EQ(1u, items.size());
+  MenuItem* item = items.at(0);
+  EXPECT_EQ("new_title", item->title());
+
+  // 5. Remove the item.
+  ExecuteScriptWaitForTitle(embedder, "removeItem()", "ITEM_REMOVED");
+  MenuItem::List items_after_removal = GetItems();
+  ASSERT_EQ(0u, items_after_removal.size());
+
+  // 6. Add some more items.
+  ExecuteScriptWaitForTitle(embedder, "createThreeMenuItems()",
+                            "ITEM_MULTIPLE_CREATED");
+  MenuItem::List items_after_insertion = GetItems();
+  ASSERT_EQ(3u, items_after_insertion.size());
+
+  // 7. Test removeAll().
+  ExecuteScriptWaitForTitle(embedder, "removeAllItems()", "ITEM_ALL_REMOVED");
+  MenuItem::List items_after_all_removal = GetItems();
+  ASSERT_EQ(0u, items_after_all_removal.size());
+}
+
 IN_PROC_BROWSER_TEST_F(WebViewTest, MediaAccessAPIAllow_TestAllow) {
   MediaAccessAPIAllowTestHelper("testAllow");
 }
 
 IN_PROC_BROWSER_TEST_F(WebViewTest, MediaAccessAPIAllow_TestAllowAndThenDeny) {
   MediaAccessAPIAllowTestHelper("testAllowAndThenDeny");
 }
 
 IN_PROC_BROWSER_TEST_F(WebViewTest, MediaAccessAPIAllow_TestAllowTwice) {
   MediaAccessAPIAllowTestHelper("testAllowTwice");
@@ skipping 362 matching lines @@
 }
 
 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestFindAPI) {
   TestHelper("testFindAPI", "web_view/shim", NO_TEST_SERVER);
 }
 
 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestFindAPI_findupdate) {
   TestHelper("testFindAPI_findupdate", "web_view/shim", NO_TEST_SERVER);
 }
 
+IN_PROC_BROWSER_TEST_F(WebViewTest, ContextMenusClick) {
+  ASSERT_TRUE(RunPlatformAppTestWithArg(
+      "platform_apps/web_view/common", "context_menus_click")) << message_;
+}
+
 // <webview> screenshot capture fails with ubercomp.
 // See http://crbug.com/327035.
 IN_PROC_BROWSER_TEST_P(WebViewCaptureTest,
                        DISABLED_Shim_ScreenshotCapture) {
   TestHelper("testScreenshotCapture", "web_view/shim", NO_TEST_SERVER);
 }
 
+

[Yoyo Zhou, 2014/03/07 02:40:30]

nit: stray newline

[lazyboy, 2014/03/07 06:38:03]

Done.

 // Threaded compositing is always enabled on Aura and Mac.
 #if !defined(USE_AURA) && !defined(OS_MACOSX)
 INSTANTIATE_TEST_CASE_P(WithoutThreadedCompositor,
     WebViewCaptureTest,
     ::testing::Values(std::string(switches::kDisableThreadedCompositing)));
 #endif
 
 #if defined(USE_AURA) || defined(OS_MACOSX)
 INSTANTIATE_TEST_CASE_P(WithThreadedCompositor,
     WebViewCaptureTest,
     ::testing::Values(std::string(switches::kEnableThreadedCompositing)));
 #endif