src/extensions/browser/guest_view/web_view/web_view_apitest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "extensions/browser/guest_view/web_view/web_view_apitest.h"
   6
   7 #include "base/command_line.h"
   8 #include "base/path_service.h"
   9 #include "base/strings/string_util.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "content/public/browser/render_process_host.h"
  12 #include "content/public/common/content_switches.h"
  13 #include "content/public/test/browser_test_utils.h"
  14 #include "content/public/test/test_renderer_host.h"
  15 #include "content/public/test/test_utils.h"
  16 #include "extensions/browser/api/test/test_api.h"
  17 #include "extensions/browser/app_window/app_window.h"
  18 #include "extensions/browser/app_window/app_window_registry.h"
  19 #include "extensions/browser/extension_host.h"
  20 #include "extensions/browser/guest_view/guest_view_manager.h"
  21 #include "extensions/browser/guest_view/guest_view_manager_factory.h"
  22 #include "extensions/browser/guest_view/test_guest_view_manager.h"
  23 #include "extensions/browser/process_manager.h"
  24 #include "extensions/common/extension.h"
  25 #include "extensions/common/extension_paths.h"
  26 #include "extensions/shell/browser/shell_content_browser_client.h"
  27 #include "extensions/shell/browser/shell_extension_system.h"
  28 #include "extensions/shell/test/shell_test.h"
  29 #include "extensions/test/extension_test_message_listener.h"
  30 #include "net/base/filename_util.h"
  31 #include "net/test/embedded_test_server/embedded_test_server.h"
  32 #include "net/test/embedded_test_server/http_request.h"
  33 #include "net/test/embedded_test_server/http_response.h"
  34 #include "ui/gfx/switches.h"
  35
  36 namespace {
  37
  38 const char kEmptyResponsePath[] = "/close-socket";
  39 const char kRedirectResponsePath[] = "/server-redirect";
  40 const char kRedirectResponseFullPath[] = "/guest_redirect.html";
  41 const char kUserAgentRedirectResponsePath[] = "/detect-user-agent";
  42 const char kTestDataDirectory[] = "testDataDirectory";
  43 const char kTestServerPort[] = "testServer.port";
  44 const char kTestWebSocketPort[] = "testWebSocketPort";
  45
  46 class EmptyHttpResponse : public net::test_server::HttpResponse {
  47  public:
  48   std::string ToResponseString() const override { return std::string(); }
  49 };
  50
  51 // Handles |request| by serving a redirect response if the |User-Agent| is
  52 // foobar.
  53 static scoped_ptr<net::test_server::HttpResponse> UserAgentResponseHandler(
  54     const std::string& path,
  55     const GURL& redirect_target,
  56     const net::test_server::HttpRequest& request) {
  57   if (!StartsWithASCII(path, request.relative_url, true))
  58     return scoped_ptr<net::test_server::HttpResponse>();
  59
  60   std::map<std::string, std::string>::const_iterator it =
  61         request.headers.find("User-Agent");
  62   EXPECT_TRUE(it != request.headers.end());
  63   if (!StartsWithASCII("foobar", it->second, true))
  64     return scoped_ptr<net::test_server::HttpResponse>();
  65
  66   scoped_ptr<net::test_server::BasicHttpResponse> http_response(
  67       new net::test_server::BasicHttpResponse);
  68   http_response->set_code(net::HTTP_MOVED_PERMANENTLY);
  69   http_response->AddCustomHeader("Location", redirect_target.spec());
  70   return http_response.Pass();
  71 }
  72
  73 class WebContentsHiddenObserver : public content::WebContentsObserver {
  74  public:
  75   WebContentsHiddenObserver(content::WebContents* web_contents,
  76                             const base::Closure& hidden_callback)
  77       : WebContentsObserver(web_contents),
  78         hidden_callback_(hidden_callback),
  79         hidden_observed_(false) {
  80   }
  81
  82   // WebContentsObserver.
  83   void WasHidden() override {
  84     hidden_observed_ = true;
  85     hidden_callback_.Run();
  86   }
  87
  88   bool hidden_observed() { return hidden_observed_; }
  89
  90  private:
  91   base::Closure hidden_callback_;
  92   bool hidden_observed_;
  93
  94   DISALLOW_COPY_AND_ASSIGN(WebContentsHiddenObserver);
  95 };
  96
  97 // Handles |request| by serving a redirect response.
  98 scoped_ptr<net::test_server::HttpResponse> RedirectResponseHandler(
  99     const std::string& path,
 100     const GURL& redirect_target,
 101     const net::test_server::HttpRequest& request) {
 102   if (!StartsWithASCII(path, request.relative_url, true))
 103     return scoped_ptr<net::test_server::HttpResponse>();
 104
 105   scoped_ptr<net::test_server::BasicHttpResponse> http_response(
 106       new net::test_server::BasicHttpResponse);
 107   http_response->set_code(net::HTTP_MOVED_PERMANENTLY);
 108   http_response->AddCustomHeader("Location", redirect_target.spec());
 109   return http_response.Pass();
 110 }
 111
 112 // Handles |request| by serving an empty response.
 113 scoped_ptr<net::test_server::HttpResponse> EmptyResponseHandler(
 114     const std::string& path,
 115     const net::test_server::HttpRequest& request) {
 116   if (StartsWithASCII(path, request.relative_url, true)) {
 117     return scoped_ptr<net::test_server::HttpResponse>(new EmptyHttpResponse);
 118   }
 119
 120   return scoped_ptr<net::test_server::HttpResponse>();
 121 }
 122
 123 }  // namespace
 124
 125 namespace extensions {
 126
 127 WebViewAPITest::WebViewAPITest() {
 128   GuestViewManager::set_factory_for_testing(&factory_);
 129 }
 130
 131 void WebViewAPITest::LaunchApp(const std::string& app_location) {
 132   base::FilePath test_data_dir;
 133   PathService::Get(DIR_TEST_DATA, &test_data_dir);
 134   test_data_dir = test_data_dir.AppendASCII(app_location.c_str());
 135
 136   test_config_.SetString(kTestDataDirectory,
 137                          net::FilePathToFileURL(test_data_dir).spec());
 138
 139   embedded_test_server()->ServeFilesFromDirectory(test_data_dir);
 140
 141   const Extension* extension = extension_system_->LoadApp(test_data_dir);
 142   ASSERT_TRUE(extension);
 143   extension_system_->LaunchApp(extension->id());
 144
 145   ExtensionTestMessageListener launch_listener("LAUNCHED", false);
 146   ASSERT_TRUE(launch_listener.WaitUntilSatisfied());
 147
 148   embedder_web_contents_ = GetFirstAppWindowWebContents();
 149 }
 150
 151 content::WebContents* WebViewAPITest::GetFirstAppWindowWebContents() {
 152   const AppWindowRegistry::AppWindowList& app_window_list =
 153       AppWindowRegistry::Get(browser_context_)->app_windows();
 154   DCHECK(app_window_list.size() == 1);
 155   return (*app_window_list.begin())->web_contents();
 156 }
 157
 158 void WebViewAPITest::RunTest(const std::string& test_name,
 159                              const std::string& app_location) {
 160   LaunchApp(app_location);
 161
 162   ExtensionTestMessageListener done_listener("TEST_PASSED", false);
 163   done_listener.set_failure_message("TEST_FAILED");
 164   ASSERT_TRUE(content::ExecuteScript(
 165       embedder_web_contents_,
 166       base::StringPrintf("runTest('%s')", test_name.c_str())))
 167       << "Unable to start test.";
 168   ASSERT_TRUE(done_listener.WaitUntilSatisfied());
 169 }
 170
 171 void WebViewAPITest::RunTestOnMainThreadLoop() {
 172   AppShellTest::RunTestOnMainThreadLoop();
 173   GetGuestViewManager()->WaitForAllGuestsDeleted();
 174 }
 175
 176 void WebViewAPITest::SetUpCommandLine(base::CommandLine* command_line) {
 177   AppShellTest::SetUpCommandLine(command_line);
 178   command_line->AppendSwitchASCII(switches::kJavaScriptFlags, "--expose-gc");
 179 }
 180
 181 void WebViewAPITest::SetUpOnMainThread() {
 182   AppShellTest::SetUpOnMainThread();
 183
 184   TestGetConfigFunction::set_test_config_state(&test_config_);
 185   base::FilePath test_data_dir;
 186   test_config_.SetInteger(kTestWebSocketPort, 0);
 187 }
 188
 189 void WebViewAPITest::StartTestServer() {
 190   // For serving guest pages.
 191   if (!embedded_test_server()->InitializeAndWaitUntilReady()) {
 192     LOG(ERROR) << "Failed to start test server.";
 193     return;
 194   }
 195
 196   test_config_.SetInteger(kTestServerPort, embedded_test_server()->port());
 197
 198   embedded_test_server()->RegisterRequestHandler(
 199       base::Bind(&RedirectResponseHandler,
 200                  kRedirectResponsePath,
 201                  embedded_test_server()->GetURL(kRedirectResponseFullPath)));
 202
 203   embedded_test_server()->RegisterRequestHandler(
 204       base::Bind(&EmptyResponseHandler, kEmptyResponsePath));
 205
 206   embedded_test_server()->RegisterRequestHandler(
 207       base::Bind(
 208           &UserAgentResponseHandler,
 209           kUserAgentRedirectResponsePath,
 210           embedded_test_server()->GetURL(kRedirectResponseFullPath)));
 211 }
 212
 213 void WebViewAPITest::StopTestServer() {
 214   if (!embedded_test_server()->ShutdownAndWaitUntilComplete()) {
 215     LOG(ERROR) << "Failed to shutdown test server.";
 216   }
 217 }
 218
 219 void WebViewAPITest::TearDownOnMainThread() {
 220   TestGetConfigFunction::set_test_config_state(nullptr);
 221
 222   AppShellTest::TearDownOnMainThread();
 223 }
 224
 225 void WebViewAPITest::SendMessageToEmbedder(const std::string& message) {
 226   EXPECT_TRUE(
 227       content::ExecuteScript(
 228           GetEmbedderWebContents(),
 229           base::StringPrintf("onAppCommand('%s');", message.c_str())));
 230 }
 231
 232 content::WebContents* WebViewAPITest::GetEmbedderWebContents() {
 233   if (!embedder_web_contents_)
 234     embedder_web_contents_ = GetFirstAppWindowWebContents();
 235   return embedder_web_contents_;
 236 }
 237
 238 TestGuestViewManager* WebViewAPITest::GetGuestViewManager() {
 239   return static_cast<TestGuestViewManager*>(
 240       TestGuestViewManager::FromBrowserContext(
 241           ShellContentBrowserClient::Get()->GetBrowserContext()));
 242 }
 243
 244 void WebViewAPITest::SendMessageToGuestAndWait(
 245     const std::string& message,
 246     const std::string& wait_message) {
 247   scoped_ptr<ExtensionTestMessageListener> listener;
 248   if (!wait_message.empty())
 249     listener.reset(new ExtensionTestMessageListener(wait_message, false));
 250
 251   EXPECT_TRUE(
 252       content::ExecuteScript(
 253           GetGuestWebContents(),
 254           base::StringPrintf("onAppCommand('%s');", message.c_str())));
 255
 256   if (listener)
 257     ASSERT_TRUE(listener->WaitUntilSatisfied());
 258 }
 259
 260 void WebViewDPIAPITest::SetUp() {
 261   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
 262   command_line->AppendSwitchASCII(switches::kForceDeviceScaleFactor,
 263                                   base::StringPrintf("%f", scale()));
 264   WebViewAPITest::SetUp();
 265 }
 266
 267 content::WebContents* WebViewAPITest::GetGuestWebContents() {
 268   return GetGuestViewManager()->WaitForSingleGuestCreated();
 269 }
 270
 271 // Occasionally hits NOTIMPLEMENTED on Linux.  https://crbug.com/422998
 272 #if defined(OS_LINUX)
 273 #define MAYBE_AcceptTouchEvents DISABLED_AcceptTouchEvents
 274 #else
 275 #define MAYBE_AcceptTouchEvents AcceptTouchEvents
 276 #endif
 277 IN_PROC_BROWSER_TEST_F(WebViewAPITest, MAYBE_AcceptTouchEvents) {
 278   LaunchApp("web_view/accept_touch_events");
 279
 280   content::RenderViewHost* embedder_rvh =
 281       GetEmbedderWebContents()->GetRenderViewHost();
 282
 283   bool embedder_has_touch_handler =
 284       content::RenderViewHostTester::HasTouchEventHandler(embedder_rvh);
 285   EXPECT_FALSE(embedder_has_touch_handler);
 286
 287   SendMessageToGuestAndWait("install-touch-handler", "installed-touch-handler");
 288
 289   // Note that we need to wait for the installed/registered touch handler to
 290   // appear in browser process before querying |embedder_rvh|.
 291   // In practice, since we do a roundrtip from browser process to guest and
 292   // back, this is sufficient.
 293   embedder_has_touch_handler =
 294       content::RenderViewHostTester::HasTouchEventHandler(embedder_rvh);
 295   EXPECT_TRUE(embedder_has_touch_handler);
 296
 297   SendMessageToGuestAndWait("uninstall-touch-handler",
 298                             "uninstalled-touch-handler");
 299   // Same as the note above about waiting.
 300   embedder_has_touch_handler =
 301       content::RenderViewHostTester::HasTouchEventHandler(embedder_rvh);
 302   EXPECT_FALSE(embedder_has_touch_handler);
 303 }
 304
 305 // This test verifies that hiding the embedder also hides the guest.
 306 IN_PROC_BROWSER_TEST_F(WebViewAPITest, EmbedderVisibilityChanged) {
 307   LaunchApp("web_view/visibility_changed");
 308
 309   scoped_refptr<content::MessageLoopRunner> loop_runner(
 310       new content::MessageLoopRunner);
 311   WebContentsHiddenObserver observer(GetGuestWebContents(),
 312                                      loop_runner->QuitClosure());
 313
 314   // Handled in web_view/visibility_changed/main.js
 315   SendMessageToEmbedder("hide-embedder");
 316   if (!observer.hidden_observed())
 317     loop_runner->Run();
 318 }
 319
 320 // Test for http://crbug.com/419611.
 321 IN_PROC_BROWSER_TEST_F(WebViewAPITest, DisplayNoneSetSrc) {
 322   LaunchApp("web_view/display_none_set_src");
 323   // Navigate the guest while it's in "display: none" state.
 324   SendMessageToEmbedder("navigate-guest");
 325   GetGuestViewManager()->WaitForSingleGuestCreated();
 326
 327   // Now attempt to navigate the guest again.
 328   SendMessageToEmbedder("navigate-guest");
 329
 330   ExtensionTestMessageListener test_passed_listener("WebViewTest.PASSED",
 331                                                     false);
 332   // Making the guest visible would trigger loadstop.
 333   SendMessageToEmbedder("show-guest");
 334   EXPECT_TRUE(test_passed_listener.WaitUntilSatisfied());
 335 }
 336
 337 // This test verifies that hiding the guest triggers WebContents::WasHidden().
 338 IN_PROC_BROWSER_TEST_F(WebViewAPITest, GuestVisibilityChanged) {
 339   LaunchApp("web_view/visibility_changed");
 340
 341   scoped_refptr<content::MessageLoopRunner> loop_runner(
 342       new content::MessageLoopRunner);
 343   WebContentsHiddenObserver observer(GetGuestWebContents(),
 344                                      loop_runner->QuitClosure());
 345
 346   // Handled in web_view/visibility_changed/main.js
 347   SendMessageToEmbedder("hide-guest");
 348   if (!observer.hidden_observed())
 349     loop_runner->Run();
 350 }
 351
 352 // This test ensures that closing app window on 'loadcommit' does not crash.
 353 // The test launches an app with guest and closes the window on loadcommit. It
 354 // then launches the app window again. The process is repeated 3 times.
 355 // http://crbug.com/291278
 356 #if defined(OS_WIN)
 357 #define MAYBE_CloseOnLoadcommit DISABLED_CloseOnLoadcommit
 358 #else
 359 #define MAYBE_CloseOnLoadcommit CloseOnLoadcommit
 360 #endif
 361 IN_PROC_BROWSER_TEST_F(WebViewAPITest, MAYBE_CloseOnLoadcommit) {
 362   LaunchApp("web_view/close_on_loadcommit");
 363   ExtensionTestMessageListener test_done_listener("done-close-on-loadcommit",
 364                                                   false);
 365   ASSERT_TRUE(test_done_listener.WaitUntilSatisfied());
 366 }
 367
 368 // This test verifies that reloading the embedder reloads the guest (and doest
 369 // not crash).
 370 IN_PROC_BROWSER_TEST_F(WebViewAPITest, ReloadEmbedder) {
 371   // Just load a guest from other test, we do not want to add a separate
 372   // app for this test.
 373   LaunchApp("web_view/visibility_changed");
 374
 375   ExtensionTestMessageListener launched_again_listener("LAUNCHED", false);
 376   embedder_web_contents_->GetController().Reload(false);
 377   ASSERT_TRUE(launched_again_listener.WaitUntilSatisfied());
 378 }
 379
 380 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestAllowTransparencyAttribute) {
 381   RunTest("testAllowTransparencyAttribute", "web_view/apitest");
 382 }
 383
 384 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestAPIMethodExistence) {
 385   RunTest("testAPIMethodExistence", "web_view/apitest");
 386 }
 387
 388 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestAssignSrcAfterCrash) {
 389   RunTest("testAssignSrcAfterCrash", "web_view/apitest");
 390 }
 391
 392 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestAutosizeAfterNavigation) {
 393   RunTest("testAutosizeAfterNavigation", "web_view/apitest");
 394 }
 395
 396 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestAutosizeBeforeNavigation) {
 397   RunTest("testAutosizeBeforeNavigation", "web_view/apitest");
 398 }
 399
 400 IN_PROC_BROWSER_TEST_F(WebViewDPIAPITest, TestAutosizeBeforeNavigation) {
 401   RunTest("testAutosizeBeforeNavigation", "web_view/apitest");
 402 }
 403
 404 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestAutosizeHeight) {
 405   RunTest("testAutosizeHeight", "web_view/apitest");
 406 }
 407
 408 IN_PROC_BROWSER_TEST_F(WebViewDPIAPITest, TestAutosizeHeight) {
 409   RunTest("testAutosizeHeight", "web_view/apitest");
 410 }
 411
 412 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestAutosizeRemoveAttributes) {
 413   RunTest("testAutosizeRemoveAttributes", "web_view/apitest");
 414 }
 415
 416 IN_PROC_BROWSER_TEST_F(WebViewDPIAPITest, TestAutosizeRemoveAttributes) {
 417   RunTest("testAutosizeRemoveAttributes", "web_view/apitest");
 418 }
 419
 420 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestAutosizeWithPartialAttributes) {
 421   RunTest("testAutosizeWithPartialAttributes", "web_view/apitest");
 422 }
 423
 424 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestCannotMutateEventName) {
 425   RunTest("testCannotMutateEventName", "web_view/apitest");
 426 }
 427
 428 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestChromeExtensionRelativePath) {
 429   RunTest("testChromeExtensionRelativePath", "web_view/apitest");
 430 }
 431
 432 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestChromeExtensionURL) {
 433   RunTest("testChromeExtensionURL", "web_view/apitest");
 434 }
 435
 436 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestContentLoadEvent) {
 437   RunTest("testContentLoadEvent", "web_view/apitest");
 438 }
 439
 440 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDeclarativeWebRequestAPI) {
 441   StartTestServer();
 442   RunTest("testDeclarativeWebRequestAPI", "web_view/apitest");
 443   StopTestServer();
 444 }
 445
 446 IN_PROC_BROWSER_TEST_F(WebViewAPITest,
 447                        TestDeclarativeWebRequestAPISendMessage) {
 448   StartTestServer();
 449   RunTest("testDeclarativeWebRequestAPISendMessage", "web_view/apitest");
 450   StopTestServer();
 451 }
 452
 453 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDestroyOnEventListener) {
 454   RunTest("testDestroyOnEventListener", "web_view/apitest");
 455 }
 456
 457 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDialogAlert) {
 458   RunTest("testDialogAlert", "web_view/dialog");
 459 }
 460
 461 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDialogConfirm) {
 462   RunTest("testDialogConfirm", "web_view/dialog");
 463 }
 464
 465 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDialogConfirmCancel) {
 466   RunTest("testDialogConfirmCancel", "web_view/dialog");
 467 }
 468
 469 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDialogConfirmDefaultCancel) {
 470   RunTest("testDialogConfirmDefaultCancel", "web_view/dialog");
 471 }
 472
 473 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDialogConfirmDefaultGCCancel) {
 474   RunTest("testDialogConfirmDefaultGCCancel", "web_view/dialog");
 475 }
 476
 477 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDialogPrompt) {
 478   RunTest("testDialogPrompt", "web_view/dialog");
 479 }
 480
 481 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDisplayNoneWebviewLoad) {
 482   RunTest("testDisplayNoneWebviewLoad", "web_view/apitest");
 483 }
 484
 485 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestDisplayNoneWebviewRemoveChild) {
 486   RunTest("testDisplayNoneWebviewRemoveChild", "web_view/apitest");
 487 }
 488
 489 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestEventName) {
 490   RunTest("testEventName", "web_view/apitest");
 491 }
 492
 493 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestExecuteScript) {
 494   RunTest("testExecuteScript", "web_view/apitest");
 495 }
 496
 497 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestExecuteScriptFail) {
 498   RunTest("testExecuteScriptFail", "web_view/apitest");
 499 }
 500
 501 IN_PROC_BROWSER_TEST_F(WebViewAPITest,
 502                        TestExecuteScriptIsAbortedWhenWebViewSourceIsChanged) {
 503   RunTest("testExecuteScriptIsAbortedWhenWebViewSourceIsChanged",
 504           "web_view/apitest");
 505 }
 506
 507 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestFindAPI) {
 508   RunTest("testFindAPI", "web_view/apitest");
 509 }
 510
 511 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestFindAPI_findupdate) {
 512   RunTest("testFindAPI_findupdate", "web_view/apitest");
 513 }
 514
 515 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestGetProcessId) {
 516   RunTest("testGetProcessId", "web_view/apitest");
 517 }
 518
 519 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestHiddenBeforeNavigation) {
 520   RunTest("testHiddenBeforeNavigation", "web_view/apitest");
 521 }
 522
 523 IN_PROC_BROWSER_TEST_F(WebViewAPITest,
 524                        TestInlineScriptFromAccessibleResources) {
 525   RunTest("testInlineScriptFromAccessibleResources", "web_view/apitest");
 526 }
 527
 528 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestInvalidChromeExtensionURL) {
 529   RunTest("testInvalidChromeExtensionURL", "web_view/apitest");
 530 }
 531
 532 IN_PROC_BROWSER_TEST_F(WebViewAPITest,
 533                        TestLoadAbortChromeExtensionURLWrongPartition) {
 534   RunTest("testLoadAbortChromeExtensionURLWrongPartition", "web_view/apitest");
 535 }
 536
 537 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestLoadAbortEmptyResponse) {
 538   StartTestServer();
 539   RunTest("testLoadAbortEmptyResponse", "web_view/apitest");
 540   StopTestServer();
 541 }
 542
 543 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestLoadAbortIllegalChromeURL) {
 544   RunTest("testLoadAbortIllegalChromeURL", "web_view/apitest");
 545 }
 546
 547 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestLoadAbortIllegalFileURL) {
 548   RunTest("testLoadAbortIllegalFileURL", "web_view/apitest");
 549 }
 550
 551 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestLoadAbortIllegalJavaScriptURL) {
 552   RunTest("testLoadAbortIllegalJavaScriptURL", "web_view/apitest");
 553 }
 554
 555 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestLoadAbortInvalidNavigation) {
 556   RunTest("testLoadAbortInvalidNavigation", "web_view/apitest");
 557 }
 558
 559 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestLoadAbortNonWebSafeScheme) {
 560   RunTest("testLoadAbortNonWebSafeScheme", "web_view/apitest");
 561 }
 562
 563 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestLoadProgressEvent) {
 564   RunTest("testLoadProgressEvent", "web_view/apitest");
 565 }
 566
 567 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestLoadStartLoadRedirect) {
 568   StartTestServer();
 569   RunTest("testLoadStartLoadRedirect", "web_view/apitest");
 570   StopTestServer();
 571 }
 572
 573 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestNavigateAfterResize) {
 574   RunTest("testNavigateAfterResize", "web_view/apitest");
 575 }
 576
 577 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestNavigationToExternalProtocol) {
 578   RunTest("testNavigationToExternalProtocol", "web_view/apitest");
 579 }
 580
 581 IN_PROC_BROWSER_TEST_F(WebViewAPITest,
 582                        TestNavOnConsecutiveSrcAttributeChanges) {
 583   RunTest("testNavOnConsecutiveSrcAttributeChanges", "web_view/apitest");
 584 }
 585
 586 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestNavOnSrcAttributeChange) {
 587   RunTest("testNavOnSrcAttributeChange", "web_view/apitest");
 588 }
 589
 590 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestNewWindow) {
 591   StartTestServer();
 592   RunTest("testNewWindow", "web_view/apitest");
 593   StopTestServer();
 594 }
 595
 596 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestNewWindowNoPreventDefault) {
 597   StartTestServer();
 598   RunTest("testNewWindowNoPreventDefault", "web_view/apitest");
 599   StopTestServer();
 600 }
 601
 602 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestNewWindowNoReferrerLink) {
 603   StartTestServer();
 604   RunTest("testNewWindowNoReferrerLink", "web_view/apitest");
 605   StopTestServer();
 606 }
 607
 608 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestNewWindowTwoListeners) {
 609   StartTestServer();
 610   RunTest("testNewWindowTwoListeners", "web_view/apitest");
 611   StopTestServer();
 612 }
 613
 614 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestOnEventProperty) {
 615   RunTest("testOnEventProperties", "web_view/apitest");
 616 }
 617
 618 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestPartitionChangeAfterNavigation) {
 619   RunTest("testPartitionChangeAfterNavigation", "web_view/apitest");
 620 }
 621
 622 IN_PROC_BROWSER_TEST_F(WebViewAPITest,
 623                        TestPartitionRemovalAfterNavigationFails) {
 624   RunTest("testPartitionRemovalAfterNavigationFails", "web_view/apitest");
 625 }
 626
 627 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestReassignSrcAttribute) {
 628   RunTest("testReassignSrcAttribute", "web_view/apitest");
 629 }
 630
 631 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestRemoveWebviewOnExit) {
 632   StartTestServer();
 633
 634   // Launch the app and wait until it's ready to load a test.
 635   LaunchApp("web_view/apitest");
 636
 637   GURL::Replacements replace_host;
 638   std::string host_str("localhost");  // Must stay in scope with replace_host.
 639   replace_host.SetHostStr(host_str);
 640
 641   // Run the test and wait until the guest WebContents is available and has
 642   // finished loading.
 643   ExtensionTestMessageListener guest_loaded_listener("guest-loaded", false);
 644   EXPECT_TRUE(content::ExecuteScript(embedder_web_contents_,
 645                                      "runTest('testRemoveWebviewOnExit')"));
 646
 647   content::WebContents* guest_web_contents = GetGuestWebContents();
 648   EXPECT_TRUE(guest_web_contents->GetRenderProcessHost()->IsIsolatedGuest());
 649   ASSERT_TRUE(guest_loaded_listener.WaitUntilSatisfied());
 650
 651   content::WebContentsDestroyedWatcher destroyed_watcher(guest_web_contents);
 652
 653   // Tell the embedder to kill the guest.
 654   EXPECT_TRUE(content::ExecuteScript(embedder_web_contents_,
 655                                      "removeWebviewOnExitDoCrash()"));
 656
 657   // Wait until the guest WebContents is destroyed.
 658   destroyed_watcher.Wait();
 659   StopTestServer();
 660 }
 661
 662 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestReload) {
 663   RunTest("testReload", "web_view/apitest");
 664 }
 665
 666 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestReloadAfterTerminate) {
 667   RunTest("testReloadAfterTerminate", "web_view/apitest");
 668 }
 669
 670 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestRemoveSrcAttribute) {
 671   RunTest("testRemoveSrcAttribute", "web_view/apitest");
 672 }
 673
 674 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestRemoveWebviewAfterNavigation) {
 675   RunTest("testRemoveWebviewAfterNavigation", "web_view/apitest");
 676 }
 677
 678 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestResizeWebviewResizesContent) {
 679   RunTest("testResizeWebviewResizesContent", "web_view/apitest");
 680 }
 681
 682 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestTerminateAfterExit) {
 683   RunTest("testTerminateAfterExit", "web_view/apitest");
 684 }
 685
 686 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestWebRequestAPI) {
 687   StartTestServer();
 688   RunTest("testWebRequestAPI", "web_view/apitest");
 689   StopTestServer();
 690 }
 691
 692 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestWebRequestAPIWithHeaders) {
 693   StartTestServer();
 694   RunTest("testWebRequestAPIWithHeaders", "web_view/apitest");
 695   StopTestServer();
 696 }
 697
 698 // Tests the existence of WebRequest API event objects on the request
 699 // object, on the webview element, and hanging directly off webview.
 700 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestWebRequestAPIExistence) {
 701   RunTest("testWebRequestAPIExistence", "web_view/apitest");
 702 }
 703
 704 IN_PROC_BROWSER_TEST_F(WebViewAPITest, TestWebRequestAPIGoogleProperty) {
 705   RunTest("testWebRequestAPIGoogleProperty", "web_view/apitest");
 706 }
 707
 708 }  // namespace extensions