// 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/common/content_switches.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/web_view/test_guest_view_manager.h"
+#include "extensions/browser/guest_view/test_guest_view_manager.h"
#include "extensions/browser/process_manager.h"
#include "extensions/common/extension.h"
#include "extensions/common/extension_paths.h"
+#include "extensions/shell/browser/shell_content_browser_client.h"
#include "extensions/shell/browser/shell_extension_system.h"
#include "extensions/shell/test/shell_test.h"
#include "extensions/test/extension_test_message_listener.h"
+#include "net/base/filename_util.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/gfx/switches.h"
-namespace extensions {
+namespace {
+
+const char kEmptyResponsePath[] = "/close-socket";
+const char kRedirectResponsePath[] = "/server-redirect";
+const char kRedirectResponseFullPath[] = "/guest_redirect.html";
+const char kUserAgentRedirectResponsePath[] = "/detect-user-agent";
+const char kTestDataDirectory[] = "testDataDirectory";
+const char kTestServerPort[] = "testServer.port";
+const char kTestWebSocketPort[] = "testWebSocketPort";
+
+class EmptyHttpResponse : public net::test_server::HttpResponse {
+ public:
+ std::string ToResponseString() const override { return std::string(); }
+};
+
+// Handles |request| by serving a redirect response if the |User-Agent| is
+// foobar.
+static scoped_ptr<net::test_server::HttpResponse> UserAgentResponseHandler(
+ 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>();
-// This class intercepts download request from the guest.
-class WebViewAPITest : public AppShellTest {
- protected:
- void RunTest(const std::string& test_name, const std::string& app_location) {
- base::FilePath test_data_dir;
- PathService::Get(DIR_TEST_DATA, &test_data_dir);
- test_data_dir = test_data_dir.AppendASCII(app_location.c_str());
-
- ASSERT_TRUE(extension_system_->LoadApp(test_data_dir));
- extension_system_->LaunchApp();
-
- ExtensionTestMessageListener launch_listener("LAUNCHED", false);
- ASSERT_TRUE(launch_listener.WaitUntilSatisfied());
-
- const AppWindowRegistry::AppWindowList& app_window_list =
- AppWindowRegistry::Get(browser_context_)->app_windows();
- DCHECK(app_window_list.size() == 1);
- content::WebContents* embedder_web_contents =
- (*app_window_list.begin())->web_contents();
-
- ExtensionTestMessageListener done_listener("TEST_PASSED", false);
- done_listener.set_failure_message("TEST_FAILED");
- if (!content::ExecuteScript(
- embedder_web_contents,
- base::StringPrintf("runTest('%s')", test_name.c_str()))) {
- LOG(ERROR) << "Unable to start test.";
- return;
- }
- ASSERT_TRUE(done_listener.WaitUntilSatisfied());
+ std::map<std::string, std::string>::const_iterator it =
+ request.headers.find("User-Agent");
+ EXPECT_TRUE(it != request.headers.end());
+ if (!StartsWithASCII("foobar", it->second, true))
+ return scoped_ptr<net::test_server::HttpResponse>();
+
+ scoped_ptr<net::test_server::BasicHttpResponse> http_response(
+ new net::test_server::BasicHttpResponse);
+ http_response->set_code(net::HTTP_MOVED_PERMANENTLY);
+ http_response->AddCustomHeader("Location", redirect_target.spec());
+ return http_response.Pass();
+}
+
+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.
+ void WasHidden() override {
+ hidden_observed_ = true;
+ hidden_callback_.Run();
}
- WebViewAPITest() { GuestViewManager::set_factory_for_testing(&factory_); }
+ bool hidden_observed() { return hidden_observed_; }
private:
- TestGuestViewManagerFactory factory_;
+ 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);
+ http_response->set_code(net::HTTP_MOVED_PERMANENTLY);
+ http_response->AddCustomHeader("Location", redirect_target.spec());
+ return http_response.Pass();
+}
+
+// Handles |request| by serving an empty response.
+scoped_ptr<net::test_server::HttpResponse> EmptyResponseHandler(
+ 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>();
+}
+
+} // namespace
+
+namespace extensions {
+
+WebViewAPITest::WebViewAPITest() {
+ GuestViewManager::set_factory_for_testing(&factory_);
+}
+
+void WebViewAPITest::LaunchApp(const std::string& app_location) {
+ base::FilePath test_data_dir;
+ PathService::Get(DIR_TEST_DATA, &test_data_dir);
+ test_data_dir = test_data_dir.AppendASCII(app_location.c_str());
+
+ test_config_.SetString(kTestDataDirectory,
+ net::FilePathToFileURL(test_data_dir).spec());
+
+ embedded_test_server()->ServeFilesFromDirectory(test_data_dir);
+
+ const Extension* extension = extension_system_->LoadApp(test_data_dir);
+ ASSERT_TRUE(extension);
+ extension_system_->LaunchApp(extension->id());
+
+ 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);
+ 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");
+ ASSERT_TRUE(content::ExecuteScript(
+ embedder_web_contents_,
+ base::StringPrintf("runTest('%s')", test_name.c_str())))
+ << "Unable to start test.";
+ ASSERT_TRUE(done_listener.WaitUntilSatisfied());
+}
+
+void WebViewAPITest::RunTestOnMainThreadLoop() {
+ AppShellTest::RunTestOnMainThreadLoop();
+ GetGuestViewManager()->WaitForAllGuestsDeleted();
+}
+
+void WebViewAPITest::SetUpCommandLine(base::CommandLine* command_line) {
+ AppShellTest::SetUpCommandLine(command_line);
+ command_line->AppendSwitchASCII(switches::kJavaScriptFlags, "--expose-gc");
+}
+
+void WebViewAPITest::SetUpOnMainThread() {
+ AppShellTest::SetUpOnMainThread();
+
+ TestGetConfigFunction::set_test_config_state(&test_config_);
+ base::FilePath test_data_dir;
+ test_config_.SetInteger(kTestWebSocketPort, 0);
+}
+
+void WebViewAPITest::StartTestServer() {
+ // For serving guest pages.
+ if (!embedded_test_server()->InitializeAndWaitUntilReady()) {
+ LOG(ERROR) << "Failed to start test server.";
+ return;
+ }
+
+ test_config_.SetInteger(kTestServerPort, embedded_test_server()->port());
+
+ embedded_test_server()->RegisterRequestHandler(
+ base::Bind(&RedirectResponseHandler,
+ kRedirectResponsePath,
+ embedded_test_server()->GetURL(kRedirectResponseFullPath)));
+
+ embedded_test_server()->RegisterRequestHandler(
+ base::Bind(&EmptyResponseHandler, kEmptyResponsePath));
+
+ embedded_test_server()->RegisterRequestHandler(
+ base::Bind(
+ &UserAgentResponseHandler,
+ kUserAgentRedirectResponsePath,
+ embedded_test_server()->GetURL(kRedirectResponseFullPath)));
+}
+
+void WebViewAPITest::StopTestServer() {
+ if (!embedded_test_server()->ShutdownAndWaitUntilComplete()) {
+ 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_)
+ 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();
+}
+
+// Occasionally hits NOTIMPLEMENTED on Linux. https://crbug.com/422998
+#if defined(OS_LINUX)
+#define MAYBE_AcceptTouchEvents DISABLED_AcceptTouchEvents
+#else
+#define MAYBE_AcceptTouchEvents AcceptTouchEvents
+#endif
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, MAYBE_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();
+}
+
+// Test for http://crbug.com/419611.
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, DisplayNoneSetSrc) {
+ LaunchApp("web_view/display_none_set_src");
+ // Navigate the guest while it's in "display: none" state.
+ SendMessageToEmbedder("navigate-guest");
+ GetGuestViewManager()->WaitForSingleGuestCreated();
+
+ // Now attempt to navigate the guest again.
+ SendMessageToEmbedder("navigate-guest");
+
+ ExtensionTestMessageListener test_passed_listener("WebViewTest.PASSED",
+ false);
+ // Making the guest visible would trigger loadstop.
+ SendMessageToEmbedder("show-guest");
+ EXPECT_TRUE(test_passed_listener.WaitUntilSatisfied());
+}
+
+// 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 ensures that closing app window on 'loadcommit' does not crash.
+// The test launches an app with guest and closes the window on loadcommit. It
+// then launches the app window again. The process is repeated 3 times.
+// http://crbug.com/291278
+#if defined(OS_WIN)
+#define MAYBE_CloseOnLoadcommit DISABLED_CloseOnLoadcommit
+#else
+#define MAYBE_CloseOnLoadcommit CloseOnLoadcommit
+#endif
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, MAYBE_CloseOnLoadcommit) {
+ LaunchApp("web_view/close_on_loadcommit");
+ ExtensionTestMessageListener test_done_listener("done-close-on-loadcommit",
+ false);
+ ASSERT_TRUE(test_done_listener.WaitUntilSatisfied());
+}
+
+// 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");
}
RunTest("testAPIMethodExistence", "web_view/apitest");
}
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestAssignSrcAfterCrash) {
+ RunTest("testAssignSrcAfterCrash", "web_view/apitest");
+}
+
IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestAutosizeAfterNavigation) {
RunTest("testAutosizeAfterNavigation", "web_view/apitest");
}
RunTest("testAutosizeBeforeNavigation", "web_view/apitest");
}
+IN_PROC_BROWSER_TEST_F(WebViewDPIAPITest, TestAutosizeBeforeNavigation) {
+ RunTest("testAutosizeBeforeNavigation", "web_view/apitest");
+}
+
IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestAutosizeHeight) {
RunTest("testAutosizeHeight", "web_view/apitest");
}
+IN_PROC_BROWSER_TEST_F(WebViewDPIAPITest, TestAutosizeHeight) {
+ RunTest("testAutosizeHeight", "web_view/apitest");
+}
+
IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestAutosizeRemoveAttributes) {
RunTest("testAutosizeRemoveAttributes", "web_view/apitest");
}
+IN_PROC_BROWSER_TEST_F(WebViewDPIAPITest, TestAutosizeRemoveAttributes) {
+ RunTest("testAutosizeRemoveAttributes", "web_view/apitest");
+}
+
IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestAutosizeWithPartialAttributes) {
RunTest("testAutosizeWithPartialAttributes", "web_view/apitest");
}
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestCannotMutateEventName) {
+ RunTest("testCannotMutateEventName", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestChromeExtensionRelativePath) {
+ RunTest("testChromeExtensionRelativePath", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestChromeExtensionURL) {
+ RunTest("testChromeExtensionURL", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestContentLoadEvent) {
+ RunTest("testContentLoadEvent", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDeclarativeWebRequestAPI) {
+ StartTestServer();
+ RunTest("testDeclarativeWebRequestAPI", "web_view/apitest");
+ StopTestServer();
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest,
+ TestDeclarativeWebRequestAPISendMessage) {
+ StartTestServer();
+ RunTest("testDeclarativeWebRequestAPISendMessage", "web_view/apitest");
+ StopTestServer();
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDestroyOnEventListener) {
+ RunTest("testDestroyOnEventListener", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDialogAlert) {
+ RunTest("testDialogAlert", "web_view/dialog");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDialogConfirm) {
+ RunTest("testDialogConfirm", "web_view/dialog");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDialogConfirmCancel) {
+ RunTest("testDialogConfirmCancel", "web_view/dialog");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDialogConfirmDefaultCancel) {
+ RunTest("testDialogConfirmDefaultCancel", "web_view/dialog");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDialogConfirmDefaultGCCancel) {
+ RunTest("testDialogConfirmDefaultGCCancel", "web_view/dialog");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDialogPrompt) {
+ RunTest("testDialogPrompt", "web_view/dialog");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDisplayNoneWebviewLoad) {
+ RunTest("testDisplayNoneWebviewLoad", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDisplayNoneWebviewRemoveChild) {
+ RunTest("testDisplayNoneWebviewRemoveChild", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestEventName) {
+ RunTest("testEventName", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestExecuteScript) {
+ RunTest("testExecuteScript", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestExecuteScriptFail) {
+ RunTest("testExecuteScriptFail", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest,
+ TestExecuteScriptIsAbortedWhenWebViewSourceIsChanged) {
+ RunTest("testExecuteScriptIsAbortedWhenWebViewSourceIsChanged",
+ "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestFindAPI) {
+ RunTest("testFindAPI", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestFindAPI_findupdate) {
+ RunTest("testFindAPI_findupdate", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestGetProcessId) {
+ RunTest("testGetProcessId", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestHiddenBeforeNavigation) {
+ RunTest("testHiddenBeforeNavigation", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest,
+ TestInlineScriptFromAccessibleResources) {
+ RunTest("testInlineScriptFromAccessibleResources", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestInvalidChromeExtensionURL) {
+ RunTest("testInvalidChromeExtensionURL", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest,
+ TestLoadAbortChromeExtensionURLWrongPartition) {
+ RunTest("testLoadAbortChromeExtensionURLWrongPartition", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestLoadAbortEmptyResponse) {
+ StartTestServer();
+ RunTest("testLoadAbortEmptyResponse", "web_view/apitest");
+ StopTestServer();
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestLoadAbortIllegalChromeURL) {
+ RunTest("testLoadAbortIllegalChromeURL", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestLoadAbortIllegalFileURL) {
+ RunTest("testLoadAbortIllegalFileURL", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestLoadAbortIllegalJavaScriptURL) {
+ RunTest("testLoadAbortIllegalJavaScriptURL", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestLoadAbortInvalidNavigation) {
+ RunTest("testLoadAbortInvalidNavigation", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestLoadAbortNonWebSafeScheme) {
+ RunTest("testLoadAbortNonWebSafeScheme", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestLoadProgressEvent) {
+ RunTest("testLoadProgressEvent", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestLoadStartLoadRedirect) {
+ StartTestServer();
+ RunTest("testLoadStartLoadRedirect", "web_view/apitest");
+ StopTestServer();
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestNavigateAfterResize) {
+ RunTest("testNavigateAfterResize", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestNavigationToExternalProtocol) {
+ RunTest("testNavigationToExternalProtocol", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest,
+ TestNavOnConsecutiveSrcAttributeChanges) {
+ RunTest("testNavOnConsecutiveSrcAttributeChanges", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestNavOnSrcAttributeChange) {
+ RunTest("testNavOnSrcAttributeChange", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestNewWindow) {
+ StartTestServer();
+ RunTest("testNewWindow", "web_view/apitest");
+ StopTestServer();
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestNewWindowNoPreventDefault) {
+ StartTestServer();
+ RunTest("testNewWindowNoPreventDefault", "web_view/apitest");
+ StopTestServer();
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestNewWindowNoReferrerLink) {
+ StartTestServer();
+ RunTest("testNewWindowNoReferrerLink", "web_view/apitest");
+ StopTestServer();
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestNewWindowTwoListeners) {
+ StartTestServer();
+ RunTest("testNewWindowTwoListeners", "web_view/apitest");
+ StopTestServer();
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestOnEventProperty) {
+ RunTest("testOnEventProperties", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestPartitionChangeAfterNavigation) {
+ RunTest("testPartitionChangeAfterNavigation", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest,
+ TestPartitionRemovalAfterNavigationFails) {
+ RunTest("testPartitionRemovalAfterNavigationFails", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestReassignSrcAttribute) {
+ RunTest("testReassignSrcAttribute", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestRemoveWebviewOnExit) {
+ StartTestServer();
+
+ // Launch the app and wait until it's ready to load a test.
+ LaunchApp("web_view/apitest");
+
+ 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 = 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.
+ destroyed_watcher.Wait();
+ StopTestServer();
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestReload) {
+ RunTest("testReload", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestReloadAfterTerminate) {
+ RunTest("testReloadAfterTerminate", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestRemoveSrcAttribute) {
+ RunTest("testRemoveSrcAttribute", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestRemoveWebviewAfterNavigation) {
+ RunTest("testRemoveWebviewAfterNavigation", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestResizeWebviewResizesContent) {
+ RunTest("testResizeWebviewResizesContent", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestTerminateAfterExit) {
+ RunTest("testTerminateAfterExit", "web_view/apitest");
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestWebRequestAPI) {
+ StartTestServer();
+ RunTest("testWebRequestAPI", "web_view/apitest");
+ StopTestServer();
+}
+
+IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestWebRequestAPIWithHeaders) {
+ StartTestServer();
+ RunTest("testWebRequestAPIWithHeaders", "web_view/apitest");
+ StopTestServer();
+}
+
+// Tests the existence of WebRequest API event objects on the request
+// 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
projects / platform / framework / web / crosswalk.git / blobdiff