Adding more webview browser tests to app_shell_browsertests.

extensions/browser/guest_view/web_view/web_view_apitest.cc

 // Copyright 2014 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 "extensions/browser/guest_view/web_view/web_view_apitest.h"
 
 #include "base/command_line.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/test/browser_test_utils.h"
+#include "content/public/test/test_renderer_host.h"
 #include "content/public/test/test_utils.h"
 #include "extensions/browser/api/test/test_api.h"
 #include "extensions/browser/app_window/app_window.h"
 #include "extensions/browser/app_window/app_window_registry.h"
 #include "extensions/browser/extension_host.h"
 #include "extensions/browser/guest_view/guest_view_manager.h"
 #include "extensions/browser/guest_view/guest_view_manager_factory.h"
 #include "extensions/browser/guest_view/test_guest_view_manager.h"
 #include "extensions/browser/process_manager.h"
 #include "extensions/common/extension.h"
@@ skipping 17 matching lines @@
 const char kTestServerPort[] = "testServer.port";
 const char kTestWebSocketPort[] = "testWebSocketPort";
 
 class EmptyHttpResponse : public net::test_server::HttpResponse {
  public:
   virtual std::string ToResponseString() const override {
     return std::string();
   }
 };
 
+class WebContentsHiddenObserver : public content::WebContentsObserver {
+ public:
+  WebContentsHiddenObserver(content::WebContents* web_contents,
+                            const base::Closure& hidden_callback)
+      : WebContentsObserver(web_contents),
+        hidden_callback_(hidden_callback),
+        hidden_observed_(false) {
+  }
+
+  // WebContentsObserver.
+  virtual void WasHidden() OVERRIDE {
+    hidden_observed_ = true;
+    hidden_callback_.Run();
+  }
+
+  bool hidden_observed() { return hidden_observed_; }
+
+ private:
+  base::Closure hidden_callback_;
+  bool hidden_observed_;
+
+  DISALLOW_COPY_AND_ASSIGN(WebContentsHiddenObserver);
+};
+
 // Handles |request| by serving a redirect response.
 scoped_ptr<net::test_server::HttpResponse> RedirectResponseHandler(
     const std::string& path,
     const GURL& redirect_target,
     const net::test_server::HttpRequest& request) {
   if (!StartsWithASCII(path, request.relative_url, true))
     return scoped_ptr<net::test_server::HttpResponse>();
 
   scoped_ptr<net::test_server::BasicHttpResponse> http_response(
       new net::test_server::BasicHttpResponse);
@@ skipping 30 matching lines @@
                          net::FilePathToFileURL(test_data_dir).spec());
 
   embedded_test_server()->ServeFilesFromDirectory(test_data_dir);
 
   ASSERT_TRUE(extension_system_->LoadApp(test_data_dir));
   extension_system_->LaunchApp();
 
   ExtensionTestMessageListener launch_listener("LAUNCHED", false);
   ASSERT_TRUE(launch_listener.WaitUntilSatisfied());
 
+  embedder_web_contents_ = GetFirstAppWindowWebContents();
+}
+
+content::WebContents* WebViewAPITest::GetFirstAppWindowWebContents() {
   const AppWindowRegistry::AppWindowList& app_window_list =
       AppWindowRegistry::Get(browser_context_)->app_windows();
   DCHECK(app_window_list.size() == 1);
-  embedder_web_contents_ = (*app_window_list.begin())->web_contents();
+  return (*app_window_list.begin())->web_contents();
 }
 
 void WebViewAPITest::RunTest(const std::string& test_name,
                              const std::string& app_location) {
   LaunchApp(app_location);
 
   ExtensionTestMessageListener done_listener("TEST_PASSED", false);
   done_listener.set_failure_message("TEST_FAILED");
   if (!content::ExecuteScript(
           embedder_web_contents_,
@@ skipping 40 matching lines @@
     LOG(ERROR) << "Failed to shutdown test server.";
   }
 }
 
 void WebViewAPITest::TearDownOnMainThread() {
   TestGetConfigFunction::set_test_config_state(nullptr);
 
   AppShellTest::TearDownOnMainThread();
 }
 
+void WebViewAPITest::SendMessageToEmbedder(const std::string& message) {
+  EXPECT_TRUE(
+      content::ExecuteScript(
+          GetEmbedderWebContents(),
+          base::StringPrintf("onAppCommand('%s');", message.c_str())));
+}
+
+content::WebContents* WebViewAPITest::GetEmbedderWebContents() {
+  if (!embedder_web_contents_) {

[lazyboy, 2014/10/10 02:24:56]

nit: here and in other places below: single statement if()s, remove curly braces
{}

+    embedder_web_contents_ = GetFirstAppWindowWebContents();
+  }
+  return embedder_web_contents_;
+}
+
 TestGuestViewManager* WebViewAPITest::GetGuestViewManager() {
   return static_cast<TestGuestViewManager*>(
       TestGuestViewManager::FromBrowserContext(
           ShellContentBrowserClient::Get()->GetBrowserContext()));
 }
 
+void WebViewAPITest::SendMessageToGuestAndWait(
+    const std::string& message,
+    const std::string& wait_message) {
+  scoped_ptr<ExtensionTestMessageListener> listener;
+  if (!wait_message.empty()) {
+    listener.reset(new ExtensionTestMessageListener(wait_message, false));
+  }
+
+  EXPECT_TRUE(
+      content::ExecuteScript(
+          GetGuestWebContents(),
+          base::StringPrintf("onAppCommand('%s');", message.c_str())));
+
+  if (listener) {
+    ASSERT_TRUE(listener->WaitUntilSatisfied());
+  }
+}
+
 void WebViewDPIAPITest::SetUp() {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   command_line->AppendSwitchASCII(switches::kForceDeviceScaleFactor,
                                   base::StringPrintf("%f", scale()));
   WebViewAPITest::SetUp();
 }
 
+content::WebContents* WebViewAPITest::GetGuestWebContents() {
+  return GetGuestViewManager()->WaitForSingleGuestCreated();
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, AcceptTouchEvents) {
+  LaunchApp("web_view/accept_touch_events");
+
+  content::RenderViewHost* embedder_rvh =
+      GetEmbedderWebContents()->GetRenderViewHost();
+
+  bool embedder_has_touch_handler =
+      content::RenderViewHostTester::HasTouchEventHandler(embedder_rvh);
+  EXPECT_FALSE(embedder_has_touch_handler);
+
+  SendMessageToGuestAndWait("install-touch-handler", "installed-touch-handler");
+
+  // Note that we need to wait for the installed/registered touch handler to
+  // appear in browser process before querying |embedder_rvh|.
+  // In practice, since we do a roundrtip from browser process to guest and
+  // back, this is sufficient.
+  embedder_has_touch_handler =
+      content::RenderViewHostTester::HasTouchEventHandler(embedder_rvh);
+  EXPECT_TRUE(embedder_has_touch_handler);
+
+  SendMessageToGuestAndWait("uninstall-touch-handler",
+                            "uninstalled-touch-handler");
+  // Same as the note above about waiting.
+  embedder_has_touch_handler =
+      content::RenderViewHostTester::HasTouchEventHandler(embedder_rvh);
+  EXPECT_FALSE(embedder_has_touch_handler);
+}
+
+// This test verifies that hiding the embedder also hides the guest.
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, EmbedderVisibilityChanged) {
+  LaunchApp("web_view/visibility_changed");
+
+  scoped_refptr<content::MessageLoopRunner> loop_runner(
+      new content::MessageLoopRunner);
+  WebContentsHiddenObserver observer(GetGuestWebContents(),
+                                     loop_runner->QuitClosure());
+
+  // Handled in web_view/visibility_changed/main.js
+  SendMessageToEmbedder("hide-embedder");
+  if (!observer.hidden_observed())
+    loop_runner->Run();
+}
+
+// This test verifies that hiding the guest triggers WebContents::WasHidden().
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, GuestVisibilityChanged) {
+  LaunchApp("web_view/visibility_changed");
+
+  scoped_refptr<content::MessageLoopRunner> loop_runner(
+      new content::MessageLoopRunner);
+  WebContentsHiddenObserver observer(GetGuestWebContents(),
+                                     loop_runner->QuitClosure());
+
+  // Handled in web_view/visibility_changed/main.js
+  SendMessageToEmbedder("hide-guest");
+  if (!observer.hidden_observed())
+    loop_runner->Run();
+}
+
+// This test verifies that reloading the embedder reloads the guest (and doest
+// not crash).
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, ReloadEmbedder) {
+  // Just load a guest from other test, we do not want to add a separate
+  // app for this test.
+  LaunchApp("web_view/visibility_changed");
+
+  ExtensionTestMessageListener launched_again_listener("LAUNCHED", false);
+  embedder_web_contents_->GetController().Reload(false);
+  ASSERT_TRUE(launched_again_listener.WaitUntilSatisfied());
+}
+
 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestAllowTransparencyAttribute) {
   RunTest("testAllowTransparencyAttribute", "web_view/apitest");
 }
 
 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestAPIMethodExistence) {
   RunTest("testAPIMethodExistence", "web_view/apitest");
 }
 
 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestAssignSrcAfterCrash) {
   RunTest("testAssignSrcAfterCrash", "web_view/apitest");
@@ skipping 226 matching lines @@
   GURL::Replacements replace_host;
   std::string host_str("localhost");  // Must stay in scope with replace_host.
   replace_host.SetHostStr(host_str);
 
   // Run the test and wait until the guest WebContents is available and has
   // finished loading.
   ExtensionTestMessageListener guest_loaded_listener("guest-loaded", false);
   EXPECT_TRUE(content::ExecuteScript(embedder_web_contents_,
                                      "runTest('testRemoveWebviewOnExit')"));
 
-  content::WebContents* guest_web_contents =
-      GetGuestViewManager()->WaitForSingleGuestCreated();
+  content::WebContents* guest_web_contents = GetGuestWebContents();
   EXPECT_TRUE(guest_web_contents->GetRenderProcessHost()->IsIsolatedGuest());
   ASSERT_TRUE(guest_loaded_listener.WaitUntilSatisfied());
 
   content::WebContentsDestroyedWatcher destroyed_watcher(guest_web_contents);
 
   // Tell the embedder to kill the guest.
   EXPECT_TRUE(content::ExecuteScript(embedder_web_contents_,
                                      "removeWebviewOnExitDoCrash()"));
 
   // Wait until the guest WebContents is destroyed.
@@ skipping 38 matching lines @@
 // object, on the webview element, and hanging directly off webview.
 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestWebRequestAPIExistence) {
   RunTest("testWebRequestAPIExistence", "web_view/apitest");
 }
 
 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestWebRequestAPIGoogleProperty) {
   RunTest("testWebRequestAPIGoogleProperty", "web_view/apitest");
 }
 
 }  // namespace extensions