1 // Copyright 2013 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 "apps/ui/native_app_window.h" 6 #include "base/path_service.h" 7 #include "base/strings/stringprintf.h" 8 #include "base/strings/utf_string_conversions.h" 9 #include "chrome/app/chrome_command_ids.h" 10 #include "chrome/browser/apps/app_browsertest_util.h" 11 #include "chrome/browser/chrome_content_browser_client.h" 12 #include "chrome/browser/extensions/extension_test_message_listener.h" 13 #include "chrome/browser/guest_view/guest_view_manager.h" 14 #include "chrome/browser/guest_view/guest_view_manager_factory.h" 15 #include "chrome/browser/prerender/prerender_link_manager.h" 16 #include "chrome/browser/prerender/prerender_link_manager_factory.h" 17 #include "chrome/browser/profiles/profile.h" 18 #include "chrome/browser/renderer_context_menu/render_view_context_menu.h" 19 #include "chrome/browser/renderer_context_menu/render_view_context_menu_test_util.h" 20 #include "chrome/browser/task_manager/task_manager_browsertest_util.h" 21 #include "chrome/browser/ui/browser.h" 22 #include "chrome/browser/ui/browser_dialogs.h" 23 #include "chrome/browser/ui/tabs/tab_strip_model.h" 24 #include "chrome/test/base/ui_test_utils.h" 25 #include "content/public/browser/gpu_data_manager.h" 26 #include "content/public/browser/interstitial_page.h" 27 #include "content/public/browser/interstitial_page_delegate.h" 28 #include "content/public/browser/notification_service.h" 29 #include "content/public/browser/render_process_host.h" 30 #include "content/public/browser/web_contents_delegate.h" 31 #include "content/public/common/content_switches.h" 32 #include "content/public/test/browser_test_utils.h" 33 #include "content/public/test/fake_speech_recognition_manager.h" 34 #include "content/public/test/test_renderer_host.h" 35 #include "extensions/common/extension.h" 36 #include "extensions/common/extensions_client.h" 37 #include "media/base/media_switches.h" 38 #include "net/test/embedded_test_server/embedded_test_server.h" 39 #include "net/test/embedded_test_server/http_request.h" 40 #include "net/test/embedded_test_server/http_response.h" 41 #include "ui/gl/gl_switches.h" 42 43 #if defined(OS_CHROMEOS) 44 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h" 45 #include "chrome/browser/chromeos/accessibility/speech_monitor.h" 46 #endif 47 48 // For fine-grained suppression on flaky tests. 49 #if defined(OS_WIN) 50 #include "base/win/windows_version.h" 51 #endif 52 53 using extensions::MenuItem; 54 using prerender::PrerenderLinkManager; 55 using prerender::PrerenderLinkManagerFactory; 56 using task_manager::browsertest_util::MatchAboutBlankTab; 57 using task_manager::browsertest_util::MatchAnyApp; 58 using task_manager::browsertest_util::MatchAnyBackground; 59 using task_manager::browsertest_util::MatchAnyTab; 60 using task_manager::browsertest_util::MatchAnyWebView; 61 using task_manager::browsertest_util::MatchApp; 62 using task_manager::browsertest_util::MatchBackground; 63 using task_manager::browsertest_util::MatchWebView; 64 using task_manager::browsertest_util::WaitForTaskManagerRows; 65 using ui::MenuModel; 66 67 namespace { 68 const char kEmptyResponsePath[] = "/close-socket"; 69 const char kRedirectResponsePath[] = "/server-redirect"; 70 const char kRedirectResponseFullPath[] = 71 "/extensions/platform_apps/web_view/shim/guest_redirect.html"; 72 73 // Platform-specific filename relative to the chrome executable. 74 #if defined(OS_WIN) 75 const wchar_t library_name[] = L"ppapi_tests.dll"; 76 #elif defined(OS_MACOSX) 77 const char library_name[] = "ppapi_tests.plugin"; 78 #elif defined(OS_POSIX) 79 const char library_name[] = "libppapi_tests.so"; 80 #endif 81 82 class EmptyHttpResponse : public net::test_server::HttpResponse { 83 public: 84 virtual std::string ToResponseString() const OVERRIDE { 85 return std::string(); 86 } 87 }; 88 89 class TestInterstitialPageDelegate : public content::InterstitialPageDelegate { 90 public: 91 TestInterstitialPageDelegate() { 92 } 93 virtual ~TestInterstitialPageDelegate() {} 94 virtual std::string GetHTMLContents() OVERRIDE { return std::string(); } 95 }; 96 97 class TestGuestViewManager : public GuestViewManager { 98 public: 99 explicit TestGuestViewManager(content::BrowserContext* context) : 100 GuestViewManager(context), 101 web_contents_(NULL) {} 102 103 content::WebContents* WaitForGuestCreated() { 104 if (web_contents_) 105 return web_contents_; 106 107 message_loop_runner_ = new content::MessageLoopRunner; 108 message_loop_runner_->Run(); 109 return web_contents_; 110 } 111 112 private: 113 // GuestViewManager override: 114 virtual void AddGuest(int guest_instance_id, 115 content::WebContents* guest_web_contents) OVERRIDE{ 116 GuestViewManager::AddGuest(guest_instance_id, guest_web_contents); 117 web_contents_ = guest_web_contents; 118 119 if (message_loop_runner_) 120 message_loop_runner_->Quit(); 121 } 122 123 content::WebContents* web_contents_; 124 scoped_refptr<content::MessageLoopRunner> message_loop_runner_; 125 }; 126 127 // Test factory for creating test instances of GuestViewManager. 128 class TestGuestViewManagerFactory : public GuestViewManagerFactory { 129 public: 130 TestGuestViewManagerFactory() : 131 test_guest_view_manager_(NULL) {} 132 133 virtual ~TestGuestViewManagerFactory() {} 134 135 virtual GuestViewManager* CreateGuestViewManager( 136 content::BrowserContext* context) OVERRIDE { 137 return GetManager(context); 138 } 139 140 TestGuestViewManager* GetManager(content::BrowserContext* context) { 141 if (!test_guest_view_manager_) { 142 test_guest_view_manager_ = new TestGuestViewManager(context); 143 } 144 return test_guest_view_manager_; 145 } 146 147 private: 148 TestGuestViewManager* test_guest_view_manager_; 149 150 DISALLOW_COPY_AND_ASSIGN(TestGuestViewManagerFactory); 151 }; 152 153 class WebContentsHiddenObserver : public content::WebContentsObserver { 154 public: 155 WebContentsHiddenObserver(content::WebContents* web_contents, 156 const base::Closure& hidden_callback) 157 : WebContentsObserver(web_contents), 158 hidden_callback_(hidden_callback), 159 hidden_observed_(false) { 160 } 161 162 // WebContentsObserver. 163 virtual void WasHidden() OVERRIDE { 164 hidden_observed_ = true; 165 hidden_callback_.Run(); 166 } 167 168 bool hidden_observed() { return hidden_observed_; } 169 170 private: 171 base::Closure hidden_callback_; 172 bool hidden_observed_; 173 174 DISALLOW_COPY_AND_ASSIGN(WebContentsHiddenObserver); 175 }; 176 177 class InterstitialObserver : public content::WebContentsObserver { 178 public: 179 InterstitialObserver(content::WebContents* web_contents, 180 const base::Closure& attach_callback, 181 const base::Closure& detach_callback) 182 : WebContentsObserver(web_contents), 183 attach_callback_(attach_callback), 184 detach_callback_(detach_callback) { 185 } 186 187 virtual void DidAttachInterstitialPage() OVERRIDE { 188 attach_callback_.Run(); 189 } 190 191 virtual void DidDetachInterstitialPage() OVERRIDE { 192 detach_callback_.Run(); 193 } 194 195 private: 196 base::Closure attach_callback_; 197 base::Closure detach_callback_; 198 199 DISALLOW_COPY_AND_ASSIGN(InterstitialObserver); 200 }; 201 202 void ExecuteScriptWaitForTitle(content::WebContents* web_contents, 203 const char* script, 204 const char* title) { 205 base::string16 expected_title(base::ASCIIToUTF16(title)); 206 base::string16 error_title(base::ASCIIToUTF16("error")); 207 208 content::TitleWatcher title_watcher(web_contents, expected_title); 209 title_watcher.AlsoWaitForTitle(error_title); 210 EXPECT_TRUE(content::ExecuteScript(web_contents, script)); 211 EXPECT_EQ(expected_title, title_watcher.WaitAndGetTitle()); 212 } 213 214 } // namespace 215 216 // This class intercepts media access request from the embedder. The request 217 // should be triggered only if the embedder API (from tests) allows the request 218 // in Javascript. 219 // We do not issue the actual media request; the fact that the request reached 220 // embedder's WebContents is good enough for our tests. This is also to make 221 // the test run successfully on trybots. 222 class MockWebContentsDelegate : public content::WebContentsDelegate { 223 public: 224 MockWebContentsDelegate() : requested_(false) {} 225 virtual ~MockWebContentsDelegate() {} 226 227 virtual void RequestMediaAccessPermission( 228 content::WebContents* web_contents, 229 const content::MediaStreamRequest& request, 230 const content::MediaResponseCallback& callback) OVERRIDE { 231 requested_ = true; 232 if (message_loop_runner_.get()) 233 message_loop_runner_->Quit(); 234 } 235 236 void WaitForSetMediaPermission() { 237 if (requested_) 238 return; 239 message_loop_runner_ = new content::MessageLoopRunner; 240 message_loop_runner_->Run(); 241 } 242 243 private: 244 bool requested_; 245 scoped_refptr<content::MessageLoopRunner> message_loop_runner_; 246 247 DISALLOW_COPY_AND_ASSIGN(MockWebContentsDelegate); 248 }; 249 250 // This class intercepts download request from the guest. 251 class MockDownloadWebContentsDelegate : public content::WebContentsDelegate { 252 public: 253 explicit MockDownloadWebContentsDelegate( 254 content::WebContentsDelegate* orig_delegate) 255 : orig_delegate_(orig_delegate), 256 waiting_for_decision_(false), 257 expect_allow_(false), 258 decision_made_(false), 259 last_download_allowed_(false) {} 260 virtual ~MockDownloadWebContentsDelegate() {} 261 262 virtual void CanDownload( 263 content::RenderViewHost* render_view_host, 264 const GURL& url, 265 const std::string& request_method, 266 const base::Callback<void(bool)>& callback) OVERRIDE { 267 orig_delegate_->CanDownload( 268 render_view_host, url, request_method, 269 base::Bind(&MockDownloadWebContentsDelegate::DownloadDecided, 270 base::Unretained(this))); 271 } 272 273 void WaitForCanDownload(bool expect_allow) { 274 EXPECT_FALSE(waiting_for_decision_); 275 waiting_for_decision_ = true; 276 277 if (decision_made_) { 278 EXPECT_EQ(expect_allow, last_download_allowed_); 279 return; 280 } 281 282 expect_allow_ = expect_allow; 283 message_loop_runner_ = new content::MessageLoopRunner; 284 message_loop_runner_->Run(); 285 } 286 287 void DownloadDecided(bool allow) { 288 EXPECT_FALSE(decision_made_); 289 decision_made_ = true; 290 291 if (waiting_for_decision_) { 292 EXPECT_EQ(expect_allow_, allow); 293 if (message_loop_runner_.get()) 294 message_loop_runner_->Quit(); 295 return; 296 } 297 last_download_allowed_ = allow; 298 } 299 300 void Reset() { 301 waiting_for_decision_ = false; 302 decision_made_ = false; 303 } 304 305 private: 306 content::WebContentsDelegate* orig_delegate_; 307 bool waiting_for_decision_; 308 bool expect_allow_; 309 bool decision_made_; 310 bool last_download_allowed_; 311 scoped_refptr<content::MessageLoopRunner> message_loop_runner_; 312 313 DISALLOW_COPY_AND_ASSIGN(MockDownloadWebContentsDelegate); 314 }; 315 316 class WebViewTest : public extensions::PlatformAppBrowserTest { 317 protected: 318 virtual void SetUp() OVERRIDE { 319 if (UsesFakeSpeech()) { 320 // SpeechRecognition test specific SetUp. 321 fake_speech_recognition_manager_.reset( 322 new content::FakeSpeechRecognitionManager()); 323 fake_speech_recognition_manager_->set_should_send_fake_response(true); 324 // Inject the fake manager factory so that the test result is returned to 325 // the web page. 326 content::SpeechRecognitionManager::SetManagerForTesting( 327 fake_speech_recognition_manager_.get()); 328 } 329 extensions::PlatformAppBrowserTest::SetUp(); 330 } 331 332 virtual void TearDown() OVERRIDE { 333 if (UsesFakeSpeech()) { 334 // SpeechRecognition test specific TearDown. 335 content::SpeechRecognitionManager::SetManagerForTesting(NULL); 336 } 337 338 extensions::PlatformAppBrowserTest::TearDown(); 339 } 340 341 virtual void SetUpOnMainThread() OVERRIDE { 342 extensions::PlatformAppBrowserTest::SetUpOnMainThread(); 343 const testing::TestInfo* const test_info = 344 testing::UnitTest::GetInstance()->current_test_info(); 345 // Mock out geolocation for geolocation specific tests. 346 if (!strncmp(test_info->name(), "GeolocationAPI", 347 strlen("GeolocationAPI"))) { 348 ui_test_utils::OverrideGeolocation(10, 20); 349 } 350 } 351 352 virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE { 353 command_line->AppendSwitch(switches::kUseFakeDeviceForMediaStream); 354 command_line->AppendSwitchASCII(switches::kJavaScriptFlags, "--expose-gc"); 355 356 extensions::PlatformAppBrowserTest::SetUpCommandLine(command_line); 357 } 358 359 // This method is responsible for initializing a packaged app, which contains 360 // multiple webview tags. The tags have different partition identifiers and 361 // their WebContent objects are returned as output. The method also verifies 362 // the expected process allocation and storage partition assignment. 363 // The |navigate_to_url| parameter is used to navigate the main browser 364 // window. 365 // 366 // TODO(ajwong): This function is getting to be too large. Either refactor it 367 // so the test can specify a configuration of WebView tags that we will 368 // dynamically inject JS to generate, or move this test wholesale into 369 // something that RunPlatformAppTest() can execute purely in Javascript. This 370 // won't let us do a white-box examination of the StoragePartition equivalence 371 // directly, but we will be able to view the black box effects which is good 372 // enough. http://crbug.com/160361 373 void NavigateAndOpenAppForIsolation( 374 GURL navigate_to_url, 375 content::WebContents** default_tag_contents1, 376 content::WebContents** default_tag_contents2, 377 content::WebContents** named_partition_contents1, 378 content::WebContents** named_partition_contents2, 379 content::WebContents** persistent_partition_contents1, 380 content::WebContents** persistent_partition_contents2, 381 content::WebContents** persistent_partition_contents3) { 382 GURL::Replacements replace_host; 383 std::string host_str("localhost"); // Must stay in scope with replace_host. 384 replace_host.SetHostStr(host_str); 385 386 navigate_to_url = navigate_to_url.ReplaceComponents(replace_host); 387 388 GURL tag_url1 = embedded_test_server()->GetURL( 389 "/extensions/platform_apps/web_view/isolation/cookie.html"); 390 tag_url1 = tag_url1.ReplaceComponents(replace_host); 391 GURL tag_url2 = embedded_test_server()->GetURL( 392 "/extensions/platform_apps/web_view/isolation/cookie2.html"); 393 tag_url2 = tag_url2.ReplaceComponents(replace_host); 394 GURL tag_url3 = embedded_test_server()->GetURL( 395 "/extensions/platform_apps/web_view/isolation/storage1.html"); 396 tag_url3 = tag_url3.ReplaceComponents(replace_host); 397 GURL tag_url4 = embedded_test_server()->GetURL( 398 "/extensions/platform_apps/web_view/isolation/storage2.html"); 399 tag_url4 = tag_url4.ReplaceComponents(replace_host); 400 GURL tag_url5 = embedded_test_server()->GetURL( 401 "/extensions/platform_apps/web_view/isolation/storage1.html#p1"); 402 tag_url5 = tag_url5.ReplaceComponents(replace_host); 403 GURL tag_url6 = embedded_test_server()->GetURL( 404 "/extensions/platform_apps/web_view/isolation/storage1.html#p2"); 405 tag_url6 = tag_url6.ReplaceComponents(replace_host); 406 GURL tag_url7 = embedded_test_server()->GetURL( 407 "/extensions/platform_apps/web_view/isolation/storage1.html#p3"); 408 tag_url7 = tag_url7.ReplaceComponents(replace_host); 409 410 ui_test_utils::NavigateToURLWithDisposition( 411 browser(), navigate_to_url, CURRENT_TAB, 412 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); 413 414 ui_test_utils::UrlLoadObserver observer1( 415 tag_url1, content::NotificationService::AllSources()); 416 ui_test_utils::UrlLoadObserver observer2( 417 tag_url2, content::NotificationService::AllSources()); 418 ui_test_utils::UrlLoadObserver observer3( 419 tag_url3, content::NotificationService::AllSources()); 420 ui_test_utils::UrlLoadObserver observer4( 421 tag_url4, content::NotificationService::AllSources()); 422 ui_test_utils::UrlLoadObserver observer5( 423 tag_url5, content::NotificationService::AllSources()); 424 ui_test_utils::UrlLoadObserver observer6( 425 tag_url6, content::NotificationService::AllSources()); 426 ui_test_utils::UrlLoadObserver observer7( 427 tag_url7, content::NotificationService::AllSources()); 428 LoadAndLaunchPlatformApp("web_view/isolation", "Launched"); 429 observer1.Wait(); 430 observer2.Wait(); 431 observer3.Wait(); 432 observer4.Wait(); 433 observer5.Wait(); 434 observer6.Wait(); 435 observer7.Wait(); 436 437 content::Source<content::NavigationController> source1 = observer1.source(); 438 EXPECT_TRUE(source1->GetWebContents()->GetRenderProcessHost()-> 439 IsIsolatedGuest()); 440 content::Source<content::NavigationController> source2 = observer2.source(); 441 EXPECT_TRUE(source2->GetWebContents()->GetRenderProcessHost()-> 442 IsIsolatedGuest()); 443 content::Source<content::NavigationController> source3 = observer3.source(); 444 EXPECT_TRUE(source3->GetWebContents()->GetRenderProcessHost()-> 445 IsIsolatedGuest()); 446 content::Source<content::NavigationController> source4 = observer4.source(); 447 EXPECT_TRUE(source4->GetWebContents()->GetRenderProcessHost()-> 448 IsIsolatedGuest()); 449 content::Source<content::NavigationController> source5 = observer5.source(); 450 EXPECT_TRUE(source5->GetWebContents()->GetRenderProcessHost()-> 451 IsIsolatedGuest()); 452 content::Source<content::NavigationController> source6 = observer6.source(); 453 EXPECT_TRUE(source6->GetWebContents()->GetRenderProcessHost()-> 454 IsIsolatedGuest()); 455 content::Source<content::NavigationController> source7 = observer7.source(); 456 EXPECT_TRUE(source7->GetWebContents()->GetRenderProcessHost()-> 457 IsIsolatedGuest()); 458 459 // Check that the first two tags use the same process and it is different 460 // than the process used by the other two. 461 EXPECT_EQ(source1->GetWebContents()->GetRenderProcessHost()->GetID(), 462 source2->GetWebContents()->GetRenderProcessHost()->GetID()); 463 EXPECT_EQ(source3->GetWebContents()->GetRenderProcessHost()->GetID(), 464 source4->GetWebContents()->GetRenderProcessHost()->GetID()); 465 EXPECT_NE(source1->GetWebContents()->GetRenderProcessHost()->GetID(), 466 source3->GetWebContents()->GetRenderProcessHost()->GetID()); 467 468 // The two sets of tags should also be isolated from the main browser. 469 EXPECT_NE(source1->GetWebContents()->GetRenderProcessHost()->GetID(), 470 browser()->tab_strip_model()->GetWebContentsAt(0)-> 471 GetRenderProcessHost()->GetID()); 472 EXPECT_NE(source3->GetWebContents()->GetRenderProcessHost()->GetID(), 473 browser()->tab_strip_model()->GetWebContentsAt(0)-> 474 GetRenderProcessHost()->GetID()); 475 476 // Check that the storage partitions of the first two tags match and are 477 // different than the other two. 478 EXPECT_EQ( 479 source1->GetWebContents()->GetRenderProcessHost()-> 480 GetStoragePartition(), 481 source2->GetWebContents()->GetRenderProcessHost()-> 482 GetStoragePartition()); 483 EXPECT_EQ( 484 source3->GetWebContents()->GetRenderProcessHost()-> 485 GetStoragePartition(), 486 source4->GetWebContents()->GetRenderProcessHost()-> 487 GetStoragePartition()); 488 EXPECT_NE( 489 source1->GetWebContents()->GetRenderProcessHost()-> 490 GetStoragePartition(), 491 source3->GetWebContents()->GetRenderProcessHost()-> 492 GetStoragePartition()); 493 494 // Ensure the persistent storage partitions are different. 495 EXPECT_EQ( 496 source5->GetWebContents()->GetRenderProcessHost()-> 497 GetStoragePartition(), 498 source6->GetWebContents()->GetRenderProcessHost()-> 499 GetStoragePartition()); 500 EXPECT_NE( 501 source5->GetWebContents()->GetRenderProcessHost()-> 502 GetStoragePartition(), 503 source7->GetWebContents()->GetRenderProcessHost()-> 504 GetStoragePartition()); 505 EXPECT_NE( 506 source1->GetWebContents()->GetRenderProcessHost()-> 507 GetStoragePartition(), 508 source5->GetWebContents()->GetRenderProcessHost()-> 509 GetStoragePartition()); 510 EXPECT_NE( 511 source1->GetWebContents()->GetRenderProcessHost()-> 512 GetStoragePartition(), 513 source7->GetWebContents()->GetRenderProcessHost()-> 514 GetStoragePartition()); 515 516 *default_tag_contents1 = source1->GetWebContents(); 517 *default_tag_contents2 = source2->GetWebContents(); 518 *named_partition_contents1 = source3->GetWebContents(); 519 *named_partition_contents2 = source4->GetWebContents(); 520 if (persistent_partition_contents1) { 521 *persistent_partition_contents1 = source5->GetWebContents(); 522 } 523 if (persistent_partition_contents2) { 524 *persistent_partition_contents2 = source6->GetWebContents(); 525 } 526 if (persistent_partition_contents3) { 527 *persistent_partition_contents3 = source7->GetWebContents(); 528 } 529 } 530 531 // Handles |request| by serving a redirect response. 532 static scoped_ptr<net::test_server::HttpResponse> RedirectResponseHandler( 533 const std::string& path, 534 const GURL& redirect_target, 535 const net::test_server::HttpRequest& request) { 536 if (!StartsWithASCII(path, request.relative_url, true)) 537 return scoped_ptr<net::test_server::HttpResponse>(); 538 539 scoped_ptr<net::test_server::BasicHttpResponse> http_response( 540 new net::test_server::BasicHttpResponse); 541 http_response->set_code(net::HTTP_MOVED_PERMANENTLY); 542 http_response->AddCustomHeader("Location", redirect_target.spec()); 543 return http_response.PassAs<net::test_server::HttpResponse>(); 544 } 545 546 // Handles |request| by serving an empty response. 547 static scoped_ptr<net::test_server::HttpResponse> EmptyResponseHandler( 548 const std::string& path, 549 const net::test_server::HttpRequest& request) { 550 if (StartsWithASCII(path, request.relative_url, true)) { 551 return scoped_ptr<net::test_server::HttpResponse>( 552 new EmptyHttpResponse); 553 } 554 555 return scoped_ptr<net::test_server::HttpResponse>(); 556 } 557 558 // Shortcut to return the current MenuManager. 559 extensions::MenuManager* menu_manager() { 560 return extensions::MenuManager::Get(browser()->profile()); 561 } 562 563 // This gets all the items that any extension has registered for possible 564 // inclusion in context menus. 565 MenuItem::List GetItems() { 566 MenuItem::List result; 567 std::set<MenuItem::ExtensionKey> extension_ids = 568 menu_manager()->ExtensionIds(); 569 std::set<MenuItem::ExtensionKey>::iterator i; 570 for (i = extension_ids.begin(); i != extension_ids.end(); ++i) { 571 const MenuItem::List* list = menu_manager()->MenuItems(*i); 572 result.insert(result.end(), list->begin(), list->end()); 573 } 574 return result; 575 } 576 577 enum TestServer { 578 NEEDS_TEST_SERVER, 579 NO_TEST_SERVER 580 }; 581 582 void TestHelper(const std::string& test_name, 583 const std::string& app_location, 584 TestServer test_server) { 585 // For serving guest pages. 586 if (test_server == NEEDS_TEST_SERVER) { 587 if (!StartEmbeddedTestServer()) { 588 LOG(ERROR) << "FAILED TO START TEST SERVER."; 589 return; 590 } 591 embedded_test_server()->RegisterRequestHandler( 592 base::Bind(&WebViewTest::RedirectResponseHandler, 593 kRedirectResponsePath, 594 embedded_test_server()->GetURL(kRedirectResponseFullPath))); 595 596 embedded_test_server()->RegisterRequestHandler( 597 base::Bind(&WebViewTest::EmptyResponseHandler, kEmptyResponsePath)); 598 } 599 600 LoadAndLaunchPlatformApp(app_location.c_str(), "Launched"); 601 602 // Flush any pending events to make sure we start with a clean slate. 603 content::RunAllPendingInMessageLoop(); 604 605 content::WebContents* embedder_web_contents = 606 GetFirstAppWindowWebContents(); 607 if (!embedder_web_contents) { 608 LOG(ERROR) << "UNABLE TO FIND EMBEDDER WEB CONTENTS."; 609 return; 610 } 611 612 ExtensionTestMessageListener done_listener("TEST_PASSED", false); 613 done_listener.set_failure_message("TEST_FAILED"); 614 if (!content::ExecuteScript( 615 embedder_web_contents, 616 base::StringPrintf("runTest('%s')", test_name.c_str()))) { 617 LOG(ERROR) << "UNABLE TO START TEST."; 618 return; 619 } 620 ASSERT_TRUE(done_listener.WaitUntilSatisfied()); 621 } 622 623 content::WebContents* LoadGuest(const std::string& guest_path, 624 const std::string& app_path) { 625 GURL::Replacements replace_host; 626 std::string host_str("localhost"); // Must stay in scope with replace_host. 627 replace_host.SetHostStr(host_str); 628 629 GURL guest_url = embedded_test_server()->GetURL(guest_path); 630 guest_url = guest_url.ReplaceComponents(replace_host); 631 632 ui_test_utils::UrlLoadObserver guest_observer( 633 guest_url, content::NotificationService::AllSources()); 634 635 LoadAndLaunchPlatformApp(app_path.c_str(), "guest-loaded"); 636 637 guest_observer.Wait(); 638 content::Source<content::NavigationController> source = 639 guest_observer.source(); 640 EXPECT_TRUE(source->GetWebContents()->GetRenderProcessHost()-> 641 IsIsolatedGuest()); 642 643 content::WebContents* guest_web_contents = source->GetWebContents(); 644 return guest_web_contents; 645 } 646 647 // Runs media_access/allow tests. 648 void MediaAccessAPIAllowTestHelper(const std::string& test_name); 649 650 // Runs media_access/deny tests, each of them are run separately otherwise 651 // they timeout (mostly on Windows). 652 void MediaAccessAPIDenyTestHelper(const std::string& test_name) { 653 ASSERT_TRUE(StartEmbeddedTestServer()); // For serving guest pages. 654 LoadAndLaunchPlatformApp("web_view/media_access/deny", "loaded"); 655 656 content::WebContents* embedder_web_contents = 657 GetFirstAppWindowWebContents(); 658 ASSERT_TRUE(embedder_web_contents); 659 660 ExtensionTestMessageListener test_run_listener("PASSED", false); 661 test_run_listener.set_failure_message("FAILED"); 662 EXPECT_TRUE( 663 content::ExecuteScript( 664 embedder_web_contents, 665 base::StringPrintf("startDenyTest('%s')", test_name.c_str()))); 666 ASSERT_TRUE(test_run_listener.WaitUntilSatisfied()); 667 } 668 669 void WaitForInterstitial(content::WebContents* web_contents) { 670 scoped_refptr<content::MessageLoopRunner> loop_runner( 671 new content::MessageLoopRunner); 672 InterstitialObserver observer(web_contents, 673 loop_runner->QuitClosure(), 674 base::Closure()); 675 if (!content::InterstitialPage::GetInterstitialPage(web_contents)) 676 loop_runner->Run(); 677 } 678 679 void LoadAppWithGuest(const std::string& app_path) { 680 681 ExtensionTestMessageListener launched_listener("WebViewTest.LAUNCHED", 682 false); 683 launched_listener.set_failure_message("WebViewTest.FAILURE"); 684 LoadAndLaunchPlatformApp(app_path.c_str(), &launched_listener); 685 686 guest_web_contents_ = GetGuestViewManager()->WaitForGuestCreated(); 687 } 688 689 void SendMessageToEmbedder(const std::string& message) { 690 EXPECT_TRUE( 691 content::ExecuteScript( 692 GetEmbedderWebContents(), 693 base::StringPrintf("onAppCommand('%s');", message.c_str()))); 694 } 695 696 void SendMessageToGuestAndWait(const std::string& message, 697 const std::string& wait_message) { 698 scoped_ptr<ExtensionTestMessageListener> listener; 699 if (!wait_message.empty()) { 700 listener.reset(new ExtensionTestMessageListener(wait_message, false)); 701 } 702 703 EXPECT_TRUE( 704 content::ExecuteScript( 705 GetGuestWebContents(), 706 base::StringPrintf("onAppCommand('%s');", message.c_str()))); 707 708 if (listener) { 709 ASSERT_TRUE(listener->WaitUntilSatisfied()); 710 } 711 } 712 713 content::WebContents* GetGuestWebContents() { 714 return guest_web_contents_; 715 } 716 717 content::WebContents* GetEmbedderWebContents() { 718 if (!embedder_web_contents_) { 719 embedder_web_contents_ = GetFirstAppWindowWebContents(); 720 } 721 return embedder_web_contents_; 722 } 723 724 TestGuestViewManager* GetGuestViewManager() { 725 return factory_.GetManager(browser()->profile()); 726 } 727 728 WebViewTest() : guest_web_contents_(NULL), 729 embedder_web_contents_(NULL) { 730 GuestViewManager::set_factory_for_testing(&factory_); 731 } 732 733 private: 734 bool UsesFakeSpeech() { 735 const testing::TestInfo* const test_info = 736 testing::UnitTest::GetInstance()->current_test_info(); 737 738 // SpeechRecognition test specific SetUp. 739 return !strcmp(test_info->name(), 740 "SpeechRecognitionAPI_HasPermissionAllow"); 741 } 742 743 scoped_ptr<content::FakeSpeechRecognitionManager> 744 fake_speech_recognition_manager_; 745 746 TestGuestViewManagerFactory factory_; 747 // Note that these are only set if you launch app using LoadAppWithGuest(). 748 content::WebContents* guest_web_contents_; 749 content::WebContents* embedder_web_contents_; 750 }; 751 752 // This test verifies that hiding the guest triggers WebContents::WasHidden(). 753 IN_PROC_BROWSER_TEST_F(WebViewTest, GuestVisibilityChanged) { 754 LoadAppWithGuest("web_view/visibility_changed"); 755 756 scoped_refptr<content::MessageLoopRunner> loop_runner( 757 new content::MessageLoopRunner); 758 WebContentsHiddenObserver observer(GetGuestWebContents(), 759 loop_runner->QuitClosure()); 760 761 // Handled in platform_apps/web_view/visibility_changed/main.js 762 SendMessageToEmbedder("hide-guest"); 763 if (!observer.hidden_observed()) 764 loop_runner->Run(); 765 } 766 767 // This test verifies that hiding the embedder also hides the guest. 768 IN_PROC_BROWSER_TEST_F(WebViewTest, EmbedderVisibilityChanged) { 769 LoadAppWithGuest("web_view/visibility_changed"); 770 771 scoped_refptr<content::MessageLoopRunner> loop_runner( 772 new content::MessageLoopRunner); 773 WebContentsHiddenObserver observer(GetGuestWebContents(), 774 loop_runner->QuitClosure()); 775 776 // Handled in platform_apps/web_view/visibility_changed/main.js 777 SendMessageToEmbedder("hide-embedder"); 778 if (!observer.hidden_observed()) 779 loop_runner->Run(); 780 } 781 782 // This test verifies that reloading the embedder reloads the guest (and doest 783 // not crash). 784 IN_PROC_BROWSER_TEST_F(WebViewTest, ReloadEmbedder) { 785 // Just load a guest from other test, we do not want to add a separate 786 // platform_app for this test. 787 LoadAppWithGuest("web_view/visibility_changed"); 788 789 ExtensionTestMessageListener launched_again_listener("WebViewTest.LAUNCHED", 790 false); 791 GetEmbedderWebContents()->GetController().Reload(false); 792 ASSERT_TRUE(launched_again_listener.WaitUntilSatisfied()); 793 } 794 795 IN_PROC_BROWSER_TEST_F(WebViewTest, AcceptTouchEvents) { 796 LoadAppWithGuest("web_view/accept_touch_events"); 797 798 content::RenderViewHost* embedder_rvh = 799 GetEmbedderWebContents()->GetRenderViewHost(); 800 801 bool embedder_has_touch_handler = 802 content::RenderViewHostTester::HasTouchEventHandler(embedder_rvh); 803 EXPECT_FALSE(embedder_has_touch_handler); 804 805 SendMessageToGuestAndWait("install-touch-handler", "installed-touch-handler"); 806 807 // Note that we need to wait for the installed/registered touch handler to 808 // appear in browser process before querying |embedder_rvh|. 809 // In practice, since we do a roundrtip from browser process to guest and 810 // back, this is sufficient. 811 embedder_has_touch_handler = 812 content::RenderViewHostTester::HasTouchEventHandler(embedder_rvh); 813 EXPECT_TRUE(embedder_has_touch_handler); 814 815 SendMessageToGuestAndWait("uninstall-touch-handler", 816 "uninstalled-touch-handler"); 817 // Same as the note above about waiting. 818 embedder_has_touch_handler = 819 content::RenderViewHostTester::HasTouchEventHandler(embedder_rvh); 820 EXPECT_FALSE(embedder_has_touch_handler); 821 } 822 823 // This test ensures JavaScript errors ("Cannot redefine property") do not 824 // happen when a <webview> is removed from DOM and added back. 825 IN_PROC_BROWSER_TEST_F(WebViewTest, 826 AddRemoveWebView_AddRemoveWebView) { 827 ASSERT_TRUE(StartEmbeddedTestServer()); // For serving guest pages. 828 ASSERT_TRUE(RunPlatformAppTest("platform_apps/web_view/addremove")) 829 << message_; 830 } 831 832 IN_PROC_BROWSER_TEST_F(WebViewTest, AutoSize) { 833 #if defined(OS_WIN) 834 // Flaky on XP bot http://crbug.com/299507 835 if (base::win::GetVersion() <= base::win::VERSION_XP) 836 return; 837 #endif 838 839 ASSERT_TRUE(RunPlatformAppTest("platform_apps/web_view/autosize")) 840 << message_; 841 } 842 843 // http://crbug.com/326332 844 IN_PROC_BROWSER_TEST_F(WebViewTest, DISABLED_Shim_TestAutosizeAfterNavigation) { 845 TestHelper("testAutosizeAfterNavigation", "web_view/shim", NO_TEST_SERVER); 846 } 847 848 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestAutosizeBeforeNavigation) { 849 TestHelper("testAutosizeBeforeNavigation", "web_view/shim", NO_TEST_SERVER); 850 } 851 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestAutosizeRemoveAttributes) { 852 TestHelper("testAutosizeRemoveAttributes", "web_view/shim", NO_TEST_SERVER); 853 } 854 855 // This test is disabled due to being flaky. http://crbug.com/282116 856 #if defined(OS_WIN) 857 #define MAYBE_Shim_TestAutosizeWithPartialAttributes \ 858 DISABLED_Shim_TestAutosizeWithPartialAttributes 859 #else 860 #define MAYBE_Shim_TestAutosizeWithPartialAttributes \ 861 Shim_TestAutosizeWithPartialAttributes 862 #endif 863 IN_PROC_BROWSER_TEST_F(WebViewTest, 864 MAYBE_Shim_TestAutosizeWithPartialAttributes) { 865 TestHelper("testAutosizeWithPartialAttributes", 866 "web_view/shim", 867 NO_TEST_SERVER); 868 } 869 870 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestAPIMethodExistence) { 871 TestHelper("testAPIMethodExistence", "web_view/shim", NO_TEST_SERVER); 872 } 873 874 // Tests the existence of WebRequest API event objects on the request 875 // object, on the webview element, and hanging directly off webview. 876 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestWebRequestAPIExistence) { 877 TestHelper("testWebRequestAPIExistence", "web_view/shim", NO_TEST_SERVER); 878 } 879 880 // http://crbug.com/315920 881 #if defined(GOOGLE_CHROME_BUILD) && (defined(OS_WIN) || defined(OS_LINUX)) 882 #define MAYBE_Shim_TestChromeExtensionURL DISABLED_Shim_TestChromeExtensionURL 883 #else 884 #define MAYBE_Shim_TestChromeExtensionURL Shim_TestChromeExtensionURL 885 #endif 886 IN_PROC_BROWSER_TEST_F(WebViewTest, MAYBE_Shim_TestChromeExtensionURL) { 887 TestHelper("testChromeExtensionURL", "web_view/shim", NO_TEST_SERVER); 888 } 889 890 // http://crbug.com/315920 891 #if defined(GOOGLE_CHROME_BUILD) && (defined(OS_WIN) || defined(OS_LINUX)) 892 #define MAYBE_Shim_TestChromeExtensionRelativePath \ 893 DISABLED_Shim_TestChromeExtensionRelativePath 894 #else 895 #define MAYBE_Shim_TestChromeExtensionRelativePath \ 896 Shim_TestChromeExtensionRelativePath 897 #endif 898 IN_PROC_BROWSER_TEST_F(WebViewTest, 899 MAYBE_Shim_TestChromeExtensionRelativePath) { 900 TestHelper("testChromeExtensionRelativePath", 901 "web_view/shim", 902 NO_TEST_SERVER); 903 } 904 905 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestDisplayNoneWebviewLoad) { 906 TestHelper("testDisplayNoneWebviewLoad", "web_view/shim", NO_TEST_SERVER); 907 } 908 909 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestDisplayNoneWebviewRemoveChild) { 910 TestHelper("testDisplayNoneWebviewRemoveChild", 911 "web_view/shim", NO_TEST_SERVER); 912 } 913 914 IN_PROC_BROWSER_TEST_F(WebViewTest, 915 Shim_TestInlineScriptFromAccessibleResources) { 916 TestHelper("testInlineScriptFromAccessibleResources", 917 "web_view/shim", 918 NO_TEST_SERVER); 919 } 920 921 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestInvalidChromeExtensionURL) { 922 TestHelper("testInvalidChromeExtensionURL", "web_view/shim", NO_TEST_SERVER); 923 } 924 925 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestEventName) { 926 TestHelper("testEventName", "web_view/shim", NO_TEST_SERVER); 927 } 928 929 // WebViewTest.Shim_TestOnEventProperty is flaky, so disable it. 930 // http://crbug.com/359832. 931 IN_PROC_BROWSER_TEST_F(WebViewTest, DISABLED_Shim_TestOnEventProperty) { 932 TestHelper("testOnEventProperties", "web_view/shim", NO_TEST_SERVER); 933 } 934 935 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadProgressEvent) { 936 TestHelper("testLoadProgressEvent", "web_view/shim", NO_TEST_SERVER); 937 } 938 939 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestDestroyOnEventListener) { 940 TestHelper("testDestroyOnEventListener", "web_view/shim", NO_TEST_SERVER); 941 } 942 943 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestCannotMutateEventName) { 944 TestHelper("testCannotMutateEventName", "web_view/shim", NO_TEST_SERVER); 945 } 946 947 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestPartitionRaisesException) { 948 TestHelper("testPartitionRaisesException", "web_view/shim", NO_TEST_SERVER); 949 } 950 951 IN_PROC_BROWSER_TEST_F(WebViewTest, 952 Shim_TestPartitionRemovalAfterNavigationFails) { 953 TestHelper("testPartitionRemovalAfterNavigationFails", 954 "web_view/shim", 955 NO_TEST_SERVER); 956 } 957 958 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestExecuteScriptFail) { 959 #if defined(OS_WIN) 960 // Flaky on XP bot http://crbug.com/266185 961 if (base::win::GetVersion() <= base::win::VERSION_XP) 962 return; 963 #endif 964 965 TestHelper("testExecuteScriptFail", "web_view/shim", NEEDS_TEST_SERVER); 966 } 967 968 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestExecuteScript) { 969 TestHelper("testExecuteScript", "web_view/shim", NO_TEST_SERVER); 970 } 971 972 IN_PROC_BROWSER_TEST_F( 973 WebViewTest, 974 Shim_TestExecuteScriptIsAbortedWhenWebViewSourceIsChanged) { 975 TestHelper("testExecuteScriptIsAbortedWhenWebViewSourceIsChanged", 976 "web_view/shim", 977 NO_TEST_SERVER); 978 } 979 980 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestTerminateAfterExit) { 981 TestHelper("testTerminateAfterExit", "web_view/shim", NO_TEST_SERVER); 982 } 983 984 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestAssignSrcAfterCrash) { 985 TestHelper("testAssignSrcAfterCrash", "web_view/shim", NO_TEST_SERVER); 986 } 987 988 IN_PROC_BROWSER_TEST_F(WebViewTest, 989 Shim_TestNavOnConsecutiveSrcAttributeChanges) { 990 TestHelper("testNavOnConsecutiveSrcAttributeChanges", 991 "web_view/shim", 992 NO_TEST_SERVER); 993 } 994 995 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNavOnSrcAttributeChange) { 996 TestHelper("testNavOnSrcAttributeChange", "web_view/shim", NO_TEST_SERVER); 997 } 998 999 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNavigateAfterResize) { 1000 TestHelper("testNavigateAfterResize", "web_view/shim", NO_TEST_SERVER); 1001 } 1002 1003 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestRemoveSrcAttribute) { 1004 TestHelper("testRemoveSrcAttribute", "web_view/shim", NO_TEST_SERVER); 1005 } 1006 1007 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestReassignSrcAttribute) { 1008 TestHelper("testReassignSrcAttribute", "web_view/shim", NO_TEST_SERVER); 1009 } 1010 1011 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNewWindow) { 1012 TestHelper("testNewWindow", "web_view/shim", NEEDS_TEST_SERVER); 1013 } 1014 1015 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNewWindowTwoListeners) { 1016 TestHelper("testNewWindowTwoListeners", "web_view/shim", NEEDS_TEST_SERVER); 1017 } 1018 1019 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNewWindowNoPreventDefault) { 1020 TestHelper("testNewWindowNoPreventDefault", 1021 "web_view/shim", 1022 NEEDS_TEST_SERVER); 1023 } 1024 1025 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNewWindowNoReferrerLink) { 1026 TestHelper("testNewWindowNoReferrerLink", "web_view/shim", NEEDS_TEST_SERVER); 1027 } 1028 1029 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestContentLoadEvent) { 1030 TestHelper("testContentLoadEvent", "web_view/shim", NO_TEST_SERVER); 1031 } 1032 1033 // http://crbug.com/326330 1034 IN_PROC_BROWSER_TEST_F(WebViewTest, 1035 Shim_TestDeclarativeWebRequestAPI) { 1036 TestHelper("testDeclarativeWebRequestAPI", 1037 "web_view/shim", 1038 NEEDS_TEST_SERVER); 1039 } 1040 1041 IN_PROC_BROWSER_TEST_F(WebViewTest, 1042 Shim_TestDeclarativeWebRequestAPISendMessage) { 1043 TestHelper("testDeclarativeWebRequestAPISendMessage", 1044 "web_view/shim", 1045 NEEDS_TEST_SERVER); 1046 } 1047 1048 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestWebRequestAPI) { 1049 TestHelper("testWebRequestAPI", "web_view/shim", NEEDS_TEST_SERVER); 1050 } 1051 1052 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestWebRequestAPIGoogleProperty) { 1053 TestHelper("testWebRequestAPIGoogleProperty", 1054 "web_view/shim", 1055 NO_TEST_SERVER); 1056 } 1057 1058 // This test is disabled due to being flaky. http://crbug.com/309451 1059 #if defined(OS_WIN) 1060 #define MAYBE_Shim_TestWebRequestListenerSurvivesReparenting \ 1061 DISABLED_Shim_TestWebRequestListenerSurvivesReparenting 1062 #else 1063 #define MAYBE_Shim_TestWebRequestListenerSurvivesReparenting \ 1064 Shim_TestWebRequestListenerSurvivesReparenting 1065 #endif 1066 IN_PROC_BROWSER_TEST_F( 1067 WebViewTest, 1068 MAYBE_Shim_TestWebRequestListenerSurvivesReparenting) { 1069 TestHelper("testWebRequestListenerSurvivesReparenting", 1070 "web_view/shim", 1071 NEEDS_TEST_SERVER); 1072 } 1073 1074 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadStartLoadRedirect) { 1075 TestHelper("testLoadStartLoadRedirect", "web_view/shim", NEEDS_TEST_SERVER); 1076 } 1077 1078 IN_PROC_BROWSER_TEST_F(WebViewTest, 1079 Shim_TestLoadAbortChromeExtensionURLWrongPartition) { 1080 TestHelper("testLoadAbortChromeExtensionURLWrongPartition", 1081 "web_view/shim", 1082 NO_TEST_SERVER); 1083 } 1084 1085 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadAbortEmptyResponse) { 1086 TestHelper("testLoadAbortEmptyResponse", "web_view/shim", NEEDS_TEST_SERVER); 1087 } 1088 1089 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadAbortIllegalChromeURL) { 1090 TestHelper("testLoadAbortIllegalChromeURL", 1091 "web_view/shim", 1092 NO_TEST_SERVER); 1093 } 1094 1095 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadAbortIllegalFileURL) { 1096 TestHelper("testLoadAbortIllegalFileURL", "web_view/shim", NO_TEST_SERVER); 1097 } 1098 1099 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadAbortIllegalJavaScriptURL) { 1100 TestHelper("testLoadAbortIllegalJavaScriptURL", 1101 "web_view/shim", 1102 NO_TEST_SERVER); 1103 } 1104 1105 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadAbortInvalidNavigation) { 1106 TestHelper("testLoadAbortInvalidNavigation", "web_view/shim", NO_TEST_SERVER); 1107 } 1108 1109 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadAbortNonWebSafeScheme) { 1110 TestHelper("testLoadAbortNonWebSafeScheme", "web_view/shim", NO_TEST_SERVER); 1111 } 1112 1113 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestReload) { 1114 TestHelper("testReload", "web_view/shim", NEEDS_TEST_SERVER); 1115 } 1116 1117 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestGetProcessId) { 1118 TestHelper("testGetProcessId", "web_view/shim", NEEDS_TEST_SERVER); 1119 } 1120 1121 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestHiddenBeforeNavigation) { 1122 TestHelper("testHiddenBeforeNavigation", "web_view/shim", NO_TEST_SERVER); 1123 } 1124 1125 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestRemoveWebviewOnExit) { 1126 ASSERT_TRUE(StartEmbeddedTestServer()); // For serving guest pages. 1127 1128 // Launch the app and wait until it's ready to load a test. 1129 LoadAndLaunchPlatformApp("web_view/shim", "Launched"); 1130 1131 content::WebContents* embedder_web_contents = GetFirstAppWindowWebContents(); 1132 ASSERT_TRUE(embedder_web_contents); 1133 1134 GURL::Replacements replace_host; 1135 std::string host_str("localhost"); // Must stay in scope with replace_host. 1136 replace_host.SetHostStr(host_str); 1137 1138 std::string guest_path( 1139 "/extensions/platform_apps/web_view/shim/empty_guest.html"); 1140 GURL guest_url = embedded_test_server()->GetURL(guest_path); 1141 guest_url = guest_url.ReplaceComponents(replace_host); 1142 1143 ui_test_utils::UrlLoadObserver guest_observer( 1144 guest_url, content::NotificationService::AllSources()); 1145 1146 // Run the test and wait until the guest WebContents is available and has 1147 // finished loading. 1148 ExtensionTestMessageListener guest_loaded_listener("guest-loaded", false); 1149 EXPECT_TRUE(content::ExecuteScript( 1150 embedder_web_contents, 1151 "runTest('testRemoveWebviewOnExit')")); 1152 guest_observer.Wait(); 1153 1154 content::Source<content::NavigationController> source = 1155 guest_observer.source(); 1156 EXPECT_TRUE(source->GetWebContents()->GetRenderProcessHost()-> 1157 IsIsolatedGuest()); 1158 1159 ASSERT_TRUE(guest_loaded_listener.WaitUntilSatisfied()); 1160 1161 content::WebContentsDestroyedWatcher destroyed_watcher( 1162 source->GetWebContents()); 1163 1164 // Tell the embedder to kill the guest. 1165 EXPECT_TRUE(content::ExecuteScript( 1166 embedder_web_contents, 1167 "removeWebviewOnExitDoCrash();")); 1168 1169 // Wait until the guest WebContents is destroyed. 1170 destroyed_watcher.Wait(); 1171 } 1172 1173 // Remove <webview> immediately after navigating it. 1174 // This is a regression test for http://crbug.com/276023. 1175 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestRemoveWebviewAfterNavigation) { 1176 TestHelper("testRemoveWebviewAfterNavigation", 1177 "web_view/shim", 1178 NO_TEST_SERVER); 1179 } 1180 1181 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNavigationToExternalProtocol) { 1182 TestHelper("testNavigationToExternalProtocol", 1183 "web_view/shim", 1184 NO_TEST_SERVER); 1185 } 1186 1187 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestResizeWebviewResizesContent) { 1188 TestHelper("testResizeWebviewResizesContent", 1189 "web_view/shim", 1190 NO_TEST_SERVER); 1191 } 1192 1193 // This test makes sure we do not crash if app is closed while interstitial 1194 // page is being shown in guest. 1195 // Disabled under LeakSanitizer due to memory leaks. http://crbug.com/321662 1196 #if defined(LEAK_SANITIZER) 1197 #define MAYBE_InterstitialTeardown DISABLED_InterstitialTeardown 1198 #else 1199 #define MAYBE_InterstitialTeardown InterstitialTeardown 1200 #endif 1201 IN_PROC_BROWSER_TEST_F(WebViewTest, MAYBE_InterstitialTeardown) { 1202 #if defined(OS_WIN) 1203 // Flaky on XP bot http://crbug.com/297014 1204 if (base::win::GetVersion() <= base::win::VERSION_XP) 1205 return; 1206 #endif 1207 1208 // Start a HTTPS server so we can load an interstitial page inside guest. 1209 net::SpawnedTestServer::SSLOptions ssl_options; 1210 ssl_options.server_certificate = 1211 net::SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME; 1212 net::SpawnedTestServer https_server( 1213 net::SpawnedTestServer::TYPE_HTTPS, ssl_options, 1214 base::FilePath(FILE_PATH_LITERAL("chrome/test/data"))); 1215 ASSERT_TRUE(https_server.Start()); 1216 1217 net::HostPortPair host_and_port = https_server.host_port_pair(); 1218 1219 LoadAndLaunchPlatformApp("web_view/interstitial_teardown", "EmbedderLoaded"); 1220 1221 // Now load the guest. 1222 content::WebContents* embedder_web_contents = GetFirstAppWindowWebContents(); 1223 ExtensionTestMessageListener second("GuestAddedToDom", false); 1224 EXPECT_TRUE(content::ExecuteScript( 1225 embedder_web_contents, 1226 base::StringPrintf("loadGuest(%d);\n", host_and_port.port()))); 1227 ASSERT_TRUE(second.WaitUntilSatisfied()); 1228 1229 // Wait for interstitial page to be shown in guest. 1230 content::WebContents* guest_web_contents = 1231 GetGuestViewManager()->WaitForGuestCreated(); 1232 ASSERT_TRUE(guest_web_contents->GetRenderProcessHost()->IsIsolatedGuest()); 1233 WaitForInterstitial(guest_web_contents); 1234 1235 // Now close the app while interstitial page being shown in guest. 1236 apps::AppWindow* window = GetFirstAppWindow(); 1237 window->GetBaseWindow()->Close(); 1238 } 1239 1240 IN_PROC_BROWSER_TEST_F(WebViewTest, ShimSrcAttribute) { 1241 ASSERT_TRUE(RunPlatformAppTest("platform_apps/web_view/src_attribute")) 1242 << message_; 1243 } 1244 1245 // This test verifies that prerendering has been disabled inside <webview>. 1246 // This test is here rather than in PrerenderBrowserTest for testing convenience 1247 // only. If it breaks then this is a bug in the prerenderer. 1248 IN_PROC_BROWSER_TEST_F(WebViewTest, NoPrerenderer) { 1249 ASSERT_TRUE(StartEmbeddedTestServer()); 1250 content::WebContents* guest_web_contents = 1251 LoadGuest( 1252 "/extensions/platform_apps/web_view/noprerenderer/guest.html", 1253 "web_view/noprerenderer"); 1254 ASSERT_TRUE(guest_web_contents != NULL); 1255 1256 PrerenderLinkManager* prerender_link_manager = 1257 PrerenderLinkManagerFactory::GetForProfile( 1258 Profile::FromBrowserContext(guest_web_contents->GetBrowserContext())); 1259 ASSERT_TRUE(prerender_link_manager != NULL); 1260 EXPECT_TRUE(prerender_link_manager->IsEmpty()); 1261 } 1262 1263 // Verify that existing <webview>'s are detected when the task manager starts 1264 // up. 1265 IN_PROC_BROWSER_TEST_F(WebViewTest, TaskManagerExistingWebView) { 1266 ASSERT_TRUE(StartEmbeddedTestServer()); 1267 1268 LoadGuest("/extensions/platform_apps/web_view/task_manager/guest.html", 1269 "web_view/task_manager"); 1270 1271 chrome::ShowTaskManager(browser()); // Show task manager AFTER guest loads. 1272 1273 const char* guest_title = "WebViewed test content"; 1274 const char* app_name = "<webview> task manager test"; 1275 ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchWebView(guest_title))); 1276 ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab())); 1277 ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchApp(app_name))); 1278 ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchBackground(app_name))); 1279 1280 ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyWebView())); 1281 ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab())); 1282 ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyApp())); 1283 ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyBackground())); 1284 } 1285 1286 // Verify that the task manager notices the creation of new <webview>'s. 1287 IN_PROC_BROWSER_TEST_F(WebViewTest, TaskManagerNewWebView) { 1288 ASSERT_TRUE(StartEmbeddedTestServer()); 1289 1290 chrome::ShowTaskManager(browser()); // Show task manager BEFORE guest loads. 1291 1292 LoadGuest("/extensions/platform_apps/web_view/task_manager/guest.html", 1293 "web_view/task_manager"); 1294 1295 const char* guest_title = "WebViewed test content"; 1296 const char* app_name = "<webview> task manager test"; 1297 ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchWebView(guest_title))); 1298 ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAboutBlankTab())); 1299 ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchApp(app_name))); 1300 ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchBackground(app_name))); 1301 1302 ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyWebView())); 1303 ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyTab())); 1304 ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyApp())); 1305 ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, MatchAnyBackground())); 1306 } 1307 1308 // This tests cookie isolation for packaged apps with webview tags. It navigates 1309 // the main browser window to a page that sets a cookie and loads an app with 1310 // multiple webview tags. Each tag sets a cookie and the test checks the proper 1311 // storage isolation is enforced. 1312 IN_PROC_BROWSER_TEST_F(WebViewTest, CookieIsolation) { 1313 ASSERT_TRUE(StartEmbeddedTestServer()); 1314 const std::string kExpire = 1315 "var expire = new Date(Date.now() + 24 * 60 * 60 * 1000);"; 1316 std::string cookie_script1(kExpire); 1317 cookie_script1.append( 1318 "document.cookie = 'guest1=true; path=/; expires=' + expire + ';';"); 1319 std::string cookie_script2(kExpire); 1320 cookie_script2.append( 1321 "document.cookie = 'guest2=true; path=/; expires=' + expire + ';';"); 1322 1323 GURL::Replacements replace_host; 1324 std::string host_str("localhost"); // Must stay in scope with replace_host. 1325 replace_host.SetHostStr(host_str); 1326 1327 GURL set_cookie_url = embedded_test_server()->GetURL( 1328 "/extensions/platform_apps/isolation/set_cookie.html"); 1329 set_cookie_url = set_cookie_url.ReplaceComponents(replace_host); 1330 1331 // The first two partitions will be used to set cookies and ensure they are 1332 // shared. The named partition is used to ensure that cookies are isolated 1333 // between partitions within the same app. 1334 content::WebContents* cookie_contents1; 1335 content::WebContents* cookie_contents2; 1336 content::WebContents* named_partition_contents1; 1337 content::WebContents* named_partition_contents2; 1338 1339 NavigateAndOpenAppForIsolation(set_cookie_url, &cookie_contents1, 1340 &cookie_contents2, &named_partition_contents1, 1341 &named_partition_contents2, NULL, NULL, NULL); 1342 1343 EXPECT_TRUE(content::ExecuteScript(cookie_contents1, cookie_script1)); 1344 EXPECT_TRUE(content::ExecuteScript(cookie_contents2, cookie_script2)); 1345 1346 int cookie_size; 1347 std::string cookie_value; 1348 1349 // Test the regular browser context to ensure we have only one cookie. 1350 ui_test_utils::GetCookies(GURL("http://localhost"), 1351 browser()->tab_strip_model()->GetWebContentsAt(0), 1352 &cookie_size, &cookie_value); 1353 EXPECT_EQ("testCookie=1", cookie_value); 1354 1355 // The default behavior is to combine webview tags with no explicit partition 1356 // declaration into the same in-memory partition. Test the webview tags to 1357 // ensure we have properly set the cookies and we have both cookies in both 1358 // tags. 1359 ui_test_utils::GetCookies(GURL("http://localhost"), 1360 cookie_contents1, 1361 &cookie_size, &cookie_value); 1362 EXPECT_EQ("guest1=true; guest2=true", cookie_value); 1363 1364 ui_test_utils::GetCookies(GURL("http://localhost"), 1365 cookie_contents2, 1366 &cookie_size, &cookie_value); 1367 EXPECT_EQ("guest1=true; guest2=true", cookie_value); 1368 1369 // The third tag should not have any cookies as it is in a separate partition. 1370 ui_test_utils::GetCookies(GURL("http://localhost"), 1371 named_partition_contents1, 1372 &cookie_size, &cookie_value); 1373 EXPECT_EQ("", cookie_value); 1374 } 1375 1376 // This tests that in-memory storage partitions are reset on browser restart, 1377 // but persistent ones maintain state for cookies and HTML5 storage. 1378 IN_PROC_BROWSER_TEST_F(WebViewTest, PRE_StoragePersistence) { 1379 ASSERT_TRUE(StartEmbeddedTestServer()); 1380 const std::string kExpire = 1381 "var expire = new Date(Date.now() + 24 * 60 * 60 * 1000);"; 1382 std::string cookie_script1(kExpire); 1383 cookie_script1.append( 1384 "document.cookie = 'inmemory=true; path=/; expires=' + expire + ';';"); 1385 std::string cookie_script2(kExpire); 1386 cookie_script2.append( 1387 "document.cookie = 'persist1=true; path=/; expires=' + expire + ';';"); 1388 std::string cookie_script3(kExpire); 1389 cookie_script3.append( 1390 "document.cookie = 'persist2=true; path=/; expires=' + expire + ';';"); 1391 1392 // We don't care where the main browser is on this test. 1393 GURL blank_url("about:blank"); 1394 1395 // The first two partitions will be used to set cookies and ensure they are 1396 // shared. The named partition is used to ensure that cookies are isolated 1397 // between partitions within the same app. 1398 content::WebContents* cookie_contents1; 1399 content::WebContents* cookie_contents2; 1400 content::WebContents* named_partition_contents1; 1401 content::WebContents* named_partition_contents2; 1402 content::WebContents* persistent_partition_contents1; 1403 content::WebContents* persistent_partition_contents2; 1404 content::WebContents* persistent_partition_contents3; 1405 NavigateAndOpenAppForIsolation(blank_url, &cookie_contents1, 1406 &cookie_contents2, &named_partition_contents1, 1407 &named_partition_contents2, 1408 &persistent_partition_contents1, 1409 &persistent_partition_contents2, 1410 &persistent_partition_contents3); 1411 1412 // Set the inmemory=true cookie for tags with inmemory partitions. 1413 EXPECT_TRUE(content::ExecuteScript(cookie_contents1, cookie_script1)); 1414 EXPECT_TRUE(content::ExecuteScript(named_partition_contents1, 1415 cookie_script1)); 1416 1417 // For the two different persistent storage partitions, set the 1418 // two different cookies so we can check that they aren't comingled below. 1419 EXPECT_TRUE(content::ExecuteScript(persistent_partition_contents1, 1420 cookie_script2)); 1421 1422 EXPECT_TRUE(content::ExecuteScript(persistent_partition_contents3, 1423 cookie_script3)); 1424 1425 int cookie_size; 1426 std::string cookie_value; 1427 1428 // Check that all in-memory partitions have a cookie set. 1429 ui_test_utils::GetCookies(GURL("http://localhost"), 1430 cookie_contents1, 1431 &cookie_size, &cookie_value); 1432 EXPECT_EQ("inmemory=true", cookie_value); 1433 ui_test_utils::GetCookies(GURL("http://localhost"), 1434 cookie_contents2, 1435 &cookie_size, &cookie_value); 1436 EXPECT_EQ("inmemory=true", cookie_value); 1437 ui_test_utils::GetCookies(GURL("http://localhost"), 1438 named_partition_contents1, 1439 &cookie_size, &cookie_value); 1440 EXPECT_EQ("inmemory=true", cookie_value); 1441 ui_test_utils::GetCookies(GURL("http://localhost"), 1442 named_partition_contents2, 1443 &cookie_size, &cookie_value); 1444 EXPECT_EQ("inmemory=true", cookie_value); 1445 1446 // Check that all persistent partitions kept their state. 1447 ui_test_utils::GetCookies(GURL("http://localhost"), 1448 persistent_partition_contents1, 1449 &cookie_size, &cookie_value); 1450 EXPECT_EQ("persist1=true", cookie_value); 1451 ui_test_utils::GetCookies(GURL("http://localhost"), 1452 persistent_partition_contents2, 1453 &cookie_size, &cookie_value); 1454 EXPECT_EQ("persist1=true", cookie_value); 1455 ui_test_utils::GetCookies(GURL("http://localhost"), 1456 persistent_partition_contents3, 1457 &cookie_size, &cookie_value); 1458 EXPECT_EQ("persist2=true", cookie_value); 1459 } 1460 1461 // This is the post-reset portion of the StoragePersistence test. See 1462 // PRE_StoragePersistence for main comment. 1463 IN_PROC_BROWSER_TEST_F(WebViewTest, StoragePersistence) { 1464 ASSERT_TRUE(StartEmbeddedTestServer()); 1465 1466 // We don't care where the main browser is on this test. 1467 GURL blank_url("about:blank"); 1468 1469 // The first two partitions will be used to set cookies and ensure they are 1470 // shared. The named partition is used to ensure that cookies are isolated 1471 // between partitions within the same app. 1472 content::WebContents* cookie_contents1; 1473 content::WebContents* cookie_contents2; 1474 content::WebContents* named_partition_contents1; 1475 content::WebContents* named_partition_contents2; 1476 content::WebContents* persistent_partition_contents1; 1477 content::WebContents* persistent_partition_contents2; 1478 content::WebContents* persistent_partition_contents3; 1479 NavigateAndOpenAppForIsolation(blank_url, &cookie_contents1, 1480 &cookie_contents2, &named_partition_contents1, 1481 &named_partition_contents2, 1482 &persistent_partition_contents1, 1483 &persistent_partition_contents2, 1484 &persistent_partition_contents3); 1485 1486 int cookie_size; 1487 std::string cookie_value; 1488 1489 // Check that all in-memory partitions lost their state. 1490 ui_test_utils::GetCookies(GURL("http://localhost"), 1491 cookie_contents1, 1492 &cookie_size, &cookie_value); 1493 EXPECT_EQ("", cookie_value); 1494 ui_test_utils::GetCookies(GURL("http://localhost"), 1495 cookie_contents2, 1496 &cookie_size, &cookie_value); 1497 EXPECT_EQ("", cookie_value); 1498 ui_test_utils::GetCookies(GURL("http://localhost"), 1499 named_partition_contents1, 1500 &cookie_size, &cookie_value); 1501 EXPECT_EQ("", cookie_value); 1502 ui_test_utils::GetCookies(GURL("http://localhost"), 1503 named_partition_contents2, 1504 &cookie_size, &cookie_value); 1505 EXPECT_EQ("", cookie_value); 1506 1507 // Check that all persistent partitions kept their state. 1508 ui_test_utils::GetCookies(GURL("http://localhost"), 1509 persistent_partition_contents1, 1510 &cookie_size, &cookie_value); 1511 EXPECT_EQ("persist1=true", cookie_value); 1512 ui_test_utils::GetCookies(GURL("http://localhost"), 1513 persistent_partition_contents2, 1514 &cookie_size, &cookie_value); 1515 EXPECT_EQ("persist1=true", cookie_value); 1516 ui_test_utils::GetCookies(GURL("http://localhost"), 1517 persistent_partition_contents3, 1518 &cookie_size, &cookie_value); 1519 EXPECT_EQ("persist2=true", cookie_value); 1520 } 1521 1522 // This tests DOM storage isolation for packaged apps with webview tags. It 1523 // loads an app with multiple webview tags and each tag sets DOM storage 1524 // entries, which the test checks to ensure proper storage isolation is 1525 // enforced. 1526 IN_PROC_BROWSER_TEST_F(WebViewTest, DOMStorageIsolation) { 1527 ASSERT_TRUE(StartEmbeddedTestServer()); 1528 GURL regular_url = embedded_test_server()->GetURL("/title1.html"); 1529 1530 std::string output; 1531 std::string get_local_storage("window.domAutomationController.send(" 1532 "window.localStorage.getItem('foo') || 'badval')"); 1533 std::string get_session_storage("window.domAutomationController.send(" 1534 "window.sessionStorage.getItem('bar') || 'badval')"); 1535 1536 content::WebContents* default_tag_contents1; 1537 content::WebContents* default_tag_contents2; 1538 content::WebContents* storage_contents1; 1539 content::WebContents* storage_contents2; 1540 1541 NavigateAndOpenAppForIsolation(regular_url, &default_tag_contents1, 1542 &default_tag_contents2, &storage_contents1, 1543 &storage_contents2, NULL, NULL, NULL); 1544 1545 // Initialize the storage for the first of the two tags that share a storage 1546 // partition. 1547 EXPECT_TRUE(content::ExecuteScript(storage_contents1, 1548 "initDomStorage('page1')")); 1549 1550 // Let's test that the expected values are present in the first tag, as they 1551 // will be overwritten once we call the initDomStorage on the second tag. 1552 EXPECT_TRUE(ExecuteScriptAndExtractString(storage_contents1, 1553 get_local_storage.c_str(), 1554 &output)); 1555 EXPECT_STREQ("local-page1", output.c_str()); 1556 EXPECT_TRUE(ExecuteScriptAndExtractString(storage_contents1, 1557 get_session_storage.c_str(), 1558 &output)); 1559 EXPECT_STREQ("session-page1", output.c_str()); 1560 1561 // Now, init the storage in the second tag in the same storage partition, 1562 // which will overwrite the shared localStorage. 1563 EXPECT_TRUE(content::ExecuteScript(storage_contents2, 1564 "initDomStorage('page2')")); 1565 1566 // The localStorage value now should reflect the one written through the 1567 // second tag. 1568 EXPECT_TRUE(ExecuteScriptAndExtractString(storage_contents1, 1569 get_local_storage.c_str(), 1570 &output)); 1571 EXPECT_STREQ("local-page2", output.c_str()); 1572 EXPECT_TRUE(ExecuteScriptAndExtractString(storage_contents2, 1573 get_local_storage.c_str(), 1574 &output)); 1575 EXPECT_STREQ("local-page2", output.c_str()); 1576 1577 // Session storage is not shared though, as each webview tag has separate 1578 // instance, even if they are in the same storage partition. 1579 EXPECT_TRUE(ExecuteScriptAndExtractString(storage_contents1, 1580 get_session_storage.c_str(), 1581 &output)); 1582 EXPECT_STREQ("session-page1", output.c_str()); 1583 EXPECT_TRUE(ExecuteScriptAndExtractString(storage_contents2, 1584 get_session_storage.c_str(), 1585 &output)); 1586 EXPECT_STREQ("session-page2", output.c_str()); 1587 1588 // Also, let's check that the main browser and another tag that doesn't share 1589 // the same partition don't have those values stored. 1590 EXPECT_TRUE(ExecuteScriptAndExtractString( 1591 browser()->tab_strip_model()->GetWebContentsAt(0), 1592 get_local_storage.c_str(), 1593 &output)); 1594 EXPECT_STREQ("badval", output.c_str()); 1595 EXPECT_TRUE(ExecuteScriptAndExtractString( 1596 browser()->tab_strip_model()->GetWebContentsAt(0), 1597 get_session_storage.c_str(), 1598 &output)); 1599 EXPECT_STREQ("badval", output.c_str()); 1600 EXPECT_TRUE(ExecuteScriptAndExtractString(default_tag_contents1, 1601 get_local_storage.c_str(), 1602 &output)); 1603 EXPECT_STREQ("badval", output.c_str()); 1604 EXPECT_TRUE(ExecuteScriptAndExtractString(default_tag_contents1, 1605 get_session_storage.c_str(), 1606 &output)); 1607 EXPECT_STREQ("badval", output.c_str()); 1608 } 1609 1610 // This tests IndexedDB isolation for packaged apps with webview tags. It loads 1611 // an app with multiple webview tags and each tag creates an IndexedDB record, 1612 // which the test checks to ensure proper storage isolation is enforced. 1613 IN_PROC_BROWSER_TEST_F(WebViewTest, IndexedDBIsolation) { 1614 ASSERT_TRUE(StartEmbeddedTestServer()); 1615 GURL regular_url = embedded_test_server()->GetURL("/title1.html"); 1616 1617 content::WebContents* default_tag_contents1; 1618 content::WebContents* default_tag_contents2; 1619 content::WebContents* storage_contents1; 1620 content::WebContents* storage_contents2; 1621 1622 NavigateAndOpenAppForIsolation(regular_url, &default_tag_contents1, 1623 &default_tag_contents2, &storage_contents1, 1624 &storage_contents2, NULL, NULL, NULL); 1625 1626 // Initialize the storage for the first of the two tags that share a storage 1627 // partition. 1628 ExecuteScriptWaitForTitle(storage_contents1, "initIDB()", "idb created"); 1629 ExecuteScriptWaitForTitle(storage_contents1, "addItemIDB(7, 'page1')", 1630 "addItemIDB complete"); 1631 ExecuteScriptWaitForTitle(storage_contents1, "readItemIDB(7)", 1632 "readItemIDB complete"); 1633 1634 std::string output; 1635 std::string get_value( 1636 "window.domAutomationController.send(getValueIDB() || 'badval')"); 1637 1638 EXPECT_TRUE(ExecuteScriptAndExtractString(storage_contents1, 1639 get_value.c_str(), &output)); 1640 EXPECT_STREQ("page1", output.c_str()); 1641 1642 // Initialize the db in the second tag. 1643 ExecuteScriptWaitForTitle(storage_contents2, "initIDB()", "idb open"); 1644 1645 // Since we share a partition, reading the value should return the existing 1646 // one. 1647 ExecuteScriptWaitForTitle(storage_contents2, "readItemIDB(7)", 1648 "readItemIDB complete"); 1649 EXPECT_TRUE(ExecuteScriptAndExtractString(storage_contents2, 1650 get_value.c_str(), &output)); 1651 EXPECT_STREQ("page1", output.c_str()); 1652 1653 // Now write through the second tag and read it back. 1654 ExecuteScriptWaitForTitle(storage_contents2, "addItemIDB(7, 'page2')", 1655 "addItemIDB complete"); 1656 ExecuteScriptWaitForTitle(storage_contents2, "readItemIDB(7)", 1657 "readItemIDB complete"); 1658 EXPECT_TRUE(ExecuteScriptAndExtractString(storage_contents2, 1659 get_value.c_str(), &output)); 1660 EXPECT_STREQ("page2", output.c_str()); 1661 1662 // Reset the document title, otherwise the next call will not see a change and 1663 // will hang waiting for it. 1664 EXPECT_TRUE(content::ExecuteScript(storage_contents1, 1665 "document.title = 'foo'")); 1666 1667 // Read through the first tag to ensure we have the second value. 1668 ExecuteScriptWaitForTitle(storage_contents1, "readItemIDB(7)", 1669 "readItemIDB complete"); 1670 EXPECT_TRUE(ExecuteScriptAndExtractString(storage_contents1, 1671 get_value.c_str(), &output)); 1672 EXPECT_STREQ("page2", output.c_str()); 1673 1674 // Now, let's confirm there is no database in the main browser and another 1675 // tag that doesn't share the same partition. Due to the IndexedDB API design, 1676 // open will succeed, but the version will be 1, since it creates the database 1677 // if it is not found. The two tags use database version 3, so we avoid 1678 // ambiguity. 1679 const char* script = 1680 "indexedDB.open('isolation').onsuccess = function(e) {" 1681 " if (e.target.result.version == 1)" 1682 " document.title = 'db not found';" 1683 " else " 1684 " document.title = 'error';" 1685 "}"; 1686 ExecuteScriptWaitForTitle(browser()->tab_strip_model()->GetWebContentsAt(0), 1687 script, "db not found"); 1688 ExecuteScriptWaitForTitle(default_tag_contents1, script, "db not found"); 1689 } 1690 1691 // This test ensures that closing app window on 'loadcommit' does not crash. 1692 // The test launches an app with guest and closes the window on loadcommit. It 1693 // then launches the app window again. The process is repeated 3 times. 1694 // http://crbug.com/291278 1695 #if defined(OS_WIN) 1696 #define MAYBE_CloseOnLoadcommit DISABLED_CloseOnLoadcommit 1697 #else 1698 #define MAYBE_CloseOnLoadcommit CloseOnLoadcommit 1699 #endif 1700 IN_PROC_BROWSER_TEST_F(WebViewTest, MAYBE_CloseOnLoadcommit) { 1701 LoadAndLaunchPlatformApp("web_view/close_on_loadcommit", 1702 "done-close-on-loadcommit"); 1703 } 1704 1705 IN_PROC_BROWSER_TEST_F(WebViewTest, MediaAccessAPIDeny_TestDeny) { 1706 MediaAccessAPIDenyTestHelper("testDeny"); 1707 } 1708 1709 IN_PROC_BROWSER_TEST_F(WebViewTest, 1710 MediaAccessAPIDeny_TestDenyThenAllowThrows) { 1711 MediaAccessAPIDenyTestHelper("testDenyThenAllowThrows"); 1712 1713 } 1714 1715 IN_PROC_BROWSER_TEST_F(WebViewTest, 1716 MediaAccessAPIDeny_TestDenyWithPreventDefault) { 1717 MediaAccessAPIDenyTestHelper("testDenyWithPreventDefault"); 1718 } 1719 1720 IN_PROC_BROWSER_TEST_F(WebViewTest, 1721 MediaAccessAPIDeny_TestNoListenersImplyDeny) { 1722 MediaAccessAPIDenyTestHelper("testNoListenersImplyDeny"); 1723 } 1724 1725 IN_PROC_BROWSER_TEST_F(WebViewTest, 1726 MediaAccessAPIDeny_TestNoPreventDefaultImpliesDeny) { 1727 MediaAccessAPIDenyTestHelper("testNoPreventDefaultImpliesDeny"); 1728 } 1729 1730 void WebViewTest::MediaAccessAPIAllowTestHelper(const std::string& test_name) { 1731 ASSERT_TRUE(StartEmbeddedTestServer()); // For serving guest pages. 1732 LoadAndLaunchPlatformApp("web_view/media_access/allow", "Launched"); 1733 1734 content::WebContents* embedder_web_contents = GetFirstAppWindowWebContents(); 1735 ASSERT_TRUE(embedder_web_contents); 1736 scoped_ptr<MockWebContentsDelegate> mock(new MockWebContentsDelegate()); 1737 embedder_web_contents->SetDelegate(mock.get()); 1738 1739 ExtensionTestMessageListener done_listener("TEST_PASSED", false); 1740 done_listener.set_failure_message("TEST_FAILED"); 1741 EXPECT_TRUE( 1742 content::ExecuteScript( 1743 embedder_web_contents, 1744 base::StringPrintf("startAllowTest('%s')", 1745 test_name.c_str()))); 1746 ASSERT_TRUE(done_listener.WaitUntilSatisfied()); 1747 1748 mock->WaitForSetMediaPermission(); 1749 } 1750 1751 IN_PROC_BROWSER_TEST_F(WebViewTest, ContextMenusAPI_Basic) { 1752 LoadAppWithGuest("web_view/context_menus/basic"); 1753 1754 content::WebContents* guest_web_contents = GetGuestWebContents(); 1755 content::WebContents* embedder = GetEmbedderWebContents(); 1756 ASSERT_TRUE(embedder); 1757 1758 // 1. Basic property test. 1759 ExecuteScriptWaitForTitle(embedder, "checkProperties()", "ITEM_CHECKED"); 1760 1761 // 2. Create a menu item and wait for created callback to be called. 1762 ExecuteScriptWaitForTitle(embedder, "createMenuItem()", "ITEM_CREATED"); 1763 1764 // 3. Click the created item, wait for the click handlers to fire from JS. 1765 ExtensionTestMessageListener click_listener("ITEM_CLICKED", false); 1766 GURL page_url("http://www.google.com"); 1767 // Create and build our test context menu. 1768 scoped_ptr<TestRenderViewContextMenu> menu(TestRenderViewContextMenu::Create( 1769 guest_web_contents, page_url, GURL(), GURL())); 1770 1771 // Look for the extension item in the menu, and execute it. 1772 int command_id = IDC_EXTENSIONS_CONTEXT_CUSTOM_FIRST; 1773 ASSERT_TRUE(menu->IsCommandIdEnabled(command_id)); 1774 menu->ExecuteCommand(command_id, 0); 1775 1776 // Wait for embedder's script to tell us its onclick fired, it does 1777 // chrome.test.sendMessage('ITEM_CLICKED') 1778 ASSERT_TRUE(click_listener.WaitUntilSatisfied()); 1779 1780 // 4. Update the item's title and verify. 1781 ExecuteScriptWaitForTitle(embedder, "updateMenuItem()", "ITEM_UPDATED"); 1782 MenuItem::List items = GetItems(); 1783 ASSERT_EQ(1u, items.size()); 1784 MenuItem* item = items.at(0); 1785 EXPECT_EQ("new_title", item->title()); 1786 1787 // 5. Remove the item. 1788 ExecuteScriptWaitForTitle(embedder, "removeItem()", "ITEM_REMOVED"); 1789 MenuItem::List items_after_removal = GetItems(); 1790 ASSERT_EQ(0u, items_after_removal.size()); 1791 1792 // 6. Add some more items. 1793 ExecuteScriptWaitForTitle( 1794 embedder, "createThreeMenuItems()", "ITEM_MULTIPLE_CREATED"); 1795 MenuItem::List items_after_insertion = GetItems(); 1796 ASSERT_EQ(3u, items_after_insertion.size()); 1797 1798 // 7. Test removeAll(). 1799 ExecuteScriptWaitForTitle(embedder, "removeAllItems()", "ITEM_ALL_REMOVED"); 1800 MenuItem::List items_after_all_removal = GetItems(); 1801 ASSERT_EQ(0u, items_after_all_removal.size()); 1802 } 1803 1804 IN_PROC_BROWSER_TEST_F(WebViewTest, MediaAccessAPIAllow_TestAllow) { 1805 MediaAccessAPIAllowTestHelper("testAllow"); 1806 } 1807 1808 IN_PROC_BROWSER_TEST_F(WebViewTest, MediaAccessAPIAllow_TestAllowAndThenDeny) { 1809 MediaAccessAPIAllowTestHelper("testAllowAndThenDeny"); 1810 } 1811 1812 IN_PROC_BROWSER_TEST_F(WebViewTest, MediaAccessAPIAllow_TestAllowTwice) { 1813 MediaAccessAPIAllowTestHelper("testAllowTwice"); 1814 } 1815 1816 IN_PROC_BROWSER_TEST_F(WebViewTest, MediaAccessAPIAllow_TestAllowAsync) { 1817 MediaAccessAPIAllowTestHelper("testAllowAsync"); 1818 } 1819 1820 // Checks that window.screenX/screenY/screenLeft/screenTop works correctly for 1821 // guests. 1822 IN_PROC_BROWSER_TEST_F(WebViewTest, ScreenCoordinates) { 1823 ASSERT_TRUE(RunPlatformAppTestWithArg( 1824 "platform_apps/web_view/common", "screen_coordinates")) 1825 << message_; 1826 } 1827 1828 #if defined(OS_CHROMEOS) 1829 IN_PROC_BROWSER_TEST_F(WebViewTest, ChromeVoxInjection) { 1830 EXPECT_FALSE( 1831 chromeos::AccessibilityManager::Get()->IsSpokenFeedbackEnabled()); 1832 1833 ASSERT_TRUE(StartEmbeddedTestServer()); 1834 content::WebContents* guest_web_contents = LoadGuest( 1835 "/extensions/platform_apps/web_view/chromevox_injection/guest.html", 1836 "web_view/chromevox_injection"); 1837 ASSERT_TRUE(guest_web_contents); 1838 1839 chromeos::SpeechMonitor monitor; 1840 chromeos::AccessibilityManager::Get()->EnableSpokenFeedback( 1841 true, ash::A11Y_NOTIFICATION_NONE); 1842 EXPECT_TRUE(monitor.SkipChromeVoxEnabledMessage()); 1843 1844 EXPECT_EQ("chrome vox test title", monitor.GetNextUtterance()); 1845 } 1846 #endif 1847 1848 // Flaky on Windows. http://crbug.com/303966 1849 #if defined(OS_WIN) 1850 #define MAYBE_TearDownTest DISABLED_TearDownTest 1851 #else 1852 #define MAYBE_TearDownTest TearDownTest 1853 #endif 1854 IN_PROC_BROWSER_TEST_F(WebViewTest, MAYBE_TearDownTest) { 1855 const extensions::Extension* extension = 1856 LoadAndLaunchPlatformApp("web_view/teardown", "guest-loaded"); 1857 apps::AppWindow* window = NULL; 1858 if (!GetAppWindowCount()) 1859 window = CreateAppWindow(extension); 1860 else 1861 window = GetFirstAppWindow(); 1862 CloseAppWindow(window); 1863 1864 // Load the app again. 1865 LoadAndLaunchPlatformApp("web_view/teardown", "guest-loaded"); 1866 } 1867 1868 // In following GeolocationAPIEmbedderHasNoAccess* tests, embedder (i.e. the 1869 // platform app) does not have geolocation permission for this test. 1870 // No matter what the API does, geolocation permission would be denied. 1871 // Note that the test name prefix must be "GeolocationAPI". 1872 IN_PROC_BROWSER_TEST_F(WebViewTest, GeolocationAPIEmbedderHasNoAccessAllow) { 1873 TestHelper("testDenyDenies", 1874 "web_view/geolocation/embedder_has_no_permission", 1875 NEEDS_TEST_SERVER); 1876 } 1877 1878 IN_PROC_BROWSER_TEST_F(WebViewTest, GeolocationAPIEmbedderHasNoAccessDeny) { 1879 TestHelper("testDenyDenies", 1880 "web_view/geolocation/embedder_has_no_permission", 1881 NEEDS_TEST_SERVER); 1882 } 1883 1884 // In following GeolocationAPIEmbedderHasAccess* tests, embedder (i.e. the 1885 // platform app) has geolocation permission 1886 // 1887 // Note that these test names must be "GeolocationAPI" prefixed (b/c we mock out 1888 // geolocation in this case). 1889 // 1890 // Also note that these are run separately because OverrideGeolocation() doesn't 1891 // mock out geolocation for multiple navigator.geolocation calls properly and 1892 // the tests become flaky. 1893 // GeolocationAPI* test 1 of 3. 1894 IN_PROC_BROWSER_TEST_F(WebViewTest, GeolocationAPIEmbedderHasAccessAllow) { 1895 TestHelper("testAllow", 1896 "web_view/geolocation/embedder_has_permission", 1897 NEEDS_TEST_SERVER); 1898 } 1899 1900 // GeolocationAPI* test 2 of 3. 1901 IN_PROC_BROWSER_TEST_F(WebViewTest, GeolocationAPIEmbedderHasAccessDeny) { 1902 TestHelper("testDeny", 1903 "web_view/geolocation/embedder_has_permission", 1904 NEEDS_TEST_SERVER); 1905 } 1906 1907 // GeolocationAPI* test 3 of 3. 1908 IN_PROC_BROWSER_TEST_F(WebViewTest, 1909 GeolocationAPIEmbedderHasAccessMultipleBridgeIdAllow) { 1910 TestHelper("testMultipleBridgeIdAllow", 1911 "web_view/geolocation/embedder_has_permission", 1912 NEEDS_TEST_SERVER); 1913 } 1914 1915 // Tests that 1916 // BrowserPluginGeolocationPermissionContext::CancelGeolocationPermissionRequest 1917 // is handled correctly (and does not crash). 1918 IN_PROC_BROWSER_TEST_F(WebViewTest, GeolocationAPICancelGeolocation) { 1919 ASSERT_TRUE(StartEmbeddedTestServer()); // For serving guest pages. 1920 ASSERT_TRUE(RunPlatformAppTest( 1921 "platform_apps/web_view/geolocation/cancel_request")) << message_; 1922 } 1923 1924 IN_PROC_BROWSER_TEST_F(WebViewTest, DISABLED_GeolocationRequestGone) { 1925 ASSERT_TRUE(StartEmbeddedTestServer()); // For serving guest pages. 1926 ASSERT_TRUE(RunPlatformAppTest( 1927 "platform_apps/web_view/geolocation/geolocation_request_gone")) 1928 << message_; 1929 } 1930 1931 // In following FilesystemAPIRequestFromMainThread* tests, guest request 1932 // filesystem access from main thread of the guest. 1933 // FileSystemAPIRequestFromMainThread* test 1 of 3 1934 IN_PROC_BROWSER_TEST_F(WebViewTest, FileSystemAPIRequestFromMainThreadAllow) { 1935 TestHelper("testAllow", "web_view/filesystem/main", NEEDS_TEST_SERVER); 1936 } 1937 1938 // FileSystemAPIRequestFromMainThread* test 2 of 3. 1939 IN_PROC_BROWSER_TEST_F(WebViewTest, FileSystemAPIRequestFromMainThreadDeny) { 1940 TestHelper("testDeny", "web_view/filesystem/main", NEEDS_TEST_SERVER); 1941 } 1942 1943 // FileSystemAPIRequestFromMainThread* test 3 of 3. 1944 IN_PROC_BROWSER_TEST_F(WebViewTest, 1945 FileSystemAPIRequestFromMainThreadDefaultAllow) { 1946 TestHelper("testDefaultAllow", "web_view/filesystem/main", NEEDS_TEST_SERVER); 1947 } 1948 1949 // In following FilesystemAPIRequestFromWorker* tests, guest create a worker 1950 // to request filesystem access from worker thread. 1951 // FileSystemAPIRequestFromWorker* test 1 of 3 1952 IN_PROC_BROWSER_TEST_F(WebViewTest, FileSystemAPIRequestFromWorkerAllow) { 1953 TestHelper("testAllow", "web_view/filesystem/worker", NEEDS_TEST_SERVER); 1954 } 1955 1956 // FileSystemAPIRequestFromWorker* test 2 of 3. 1957 IN_PROC_BROWSER_TEST_F(WebViewTest, FileSystemAPIRequestFromWorkerDeny) { 1958 TestHelper("testDeny", "web_view/filesystem/worker", NEEDS_TEST_SERVER); 1959 } 1960 1961 // FileSystemAPIRequestFromWorker* test 3 of 3. 1962 IN_PROC_BROWSER_TEST_F(WebViewTest, 1963 FileSystemAPIRequestFromWorkerDefaultAllow) { 1964 TestHelper( 1965 "testDefaultAllow", "web_view/filesystem/worker", NEEDS_TEST_SERVER); 1966 } 1967 1968 IN_PROC_BROWSER_TEST_F(WebViewTest, ClearData) { 1969 #if defined(OS_WIN) 1970 // Flaky on XP bot http://crbug.com/282674 1971 if (base::win::GetVersion() <= base::win::VERSION_XP) 1972 return; 1973 #endif 1974 1975 ASSERT_TRUE(StartEmbeddedTestServer()); // For serving guest pages. 1976 ASSERT_TRUE(RunPlatformAppTestWithArg( 1977 "platform_apps/web_view/common", "cleardata")) 1978 << message_; 1979 } 1980 1981 // This test is disabled on Win due to being flaky. http://crbug.com/294592 1982 #if defined(OS_WIN) 1983 #define MAYBE_ConsoleMessage DISABLED_ConsoleMessage 1984 #else 1985 #define MAYBE_ConsoleMessage ConsoleMessage 1986 #endif 1987 IN_PROC_BROWSER_TEST_F(WebViewTest, MAYBE_ConsoleMessage) { 1988 ASSERT_TRUE(RunPlatformAppTestWithArg( 1989 "platform_apps/web_view/common", "console_messages")) 1990 << message_; 1991 } 1992 1993 IN_PROC_BROWSER_TEST_F(WebViewTest, DownloadPermission) { 1994 ASSERT_TRUE(StartEmbeddedTestServer()); // For serving guest pages. 1995 content::WebContents* guest_web_contents = 1996 LoadGuest("/extensions/platform_apps/web_view/download/guest.html", 1997 "web_view/download"); 1998 ASSERT_TRUE(guest_web_contents); 1999 2000 // Replace WebContentsDelegate with mock version so we can intercept download 2001 // requests. 2002 content::WebContentsDelegate* delegate = guest_web_contents->GetDelegate(); 2003 scoped_ptr<MockDownloadWebContentsDelegate> 2004 mock_delegate(new MockDownloadWebContentsDelegate(delegate)); 2005 guest_web_contents->SetDelegate(mock_delegate.get()); 2006 2007 // Start test. 2008 // 1. Guest requests a download that its embedder denies. 2009 EXPECT_TRUE(content::ExecuteScript(guest_web_contents, 2010 "startDownload('download-link-1')")); 2011 mock_delegate->WaitForCanDownload(false); // Expect to not allow. 2012 mock_delegate->Reset(); 2013 2014 // 2. Guest requests a download that its embedder allows. 2015 EXPECT_TRUE(content::ExecuteScript(guest_web_contents, 2016 "startDownload('download-link-2')")); 2017 mock_delegate->WaitForCanDownload(true); // Expect to allow. 2018 mock_delegate->Reset(); 2019 2020 // 3. Guest requests a download that its embedder ignores, this implies deny. 2021 EXPECT_TRUE(content::ExecuteScript(guest_web_contents, 2022 "startDownload('download-link-3')")); 2023 mock_delegate->WaitForCanDownload(false); // Expect to not allow. 2024 } 2025 2026 // This test makes sure loading <webview> does not crash when there is an 2027 // extension which has content script whitelisted/forced. 2028 IN_PROC_BROWSER_TEST_F(WebViewTest, WhitelistedContentScript) { 2029 // Whitelist the extension for running content script we are going to load. 2030 extensions::ExtensionsClient::ScriptingWhitelist whitelist; 2031 const std::string extension_id = "imeongpbjoodlnmlakaldhlcmijmhpbb"; 2032 whitelist.push_back(extension_id); 2033 extensions::ExtensionsClient::Get()->SetScriptingWhitelist(whitelist); 2034 2035 // Load the extension. 2036 const extensions::Extension* content_script_whitelisted_extension = 2037 LoadExtension(test_data_dir_.AppendASCII( 2038 "platform_apps/web_view/extension_api/content_script")); 2039 ASSERT_TRUE(content_script_whitelisted_extension); 2040 ASSERT_EQ(extension_id, content_script_whitelisted_extension->id()); 2041 2042 // Now load an app with <webview>. 2043 LoadAndLaunchPlatformApp("web_view/content_script_whitelisted", 2044 "TEST_PASSED"); 2045 } 2046 2047 IN_PROC_BROWSER_TEST_F(WebViewTest, SetPropertyOnDocumentReady) { 2048 ASSERT_TRUE(RunPlatformAppTest("platform_apps/web_view/document_ready")) 2049 << message_; 2050 } 2051 2052 IN_PROC_BROWSER_TEST_F(WebViewTest, SetPropertyOnDocumentInteractive) { 2053 ASSERT_TRUE(RunPlatformAppTest("platform_apps/web_view/document_interactive")) 2054 << message_; 2055 } 2056 2057 IN_PROC_BROWSER_TEST_F(WebViewTest, SpeechRecognitionAPI_HasPermissionAllow) { 2058 ASSERT_TRUE( 2059 RunPlatformAppTestWithArg("platform_apps/web_view/speech_recognition_api", 2060 "allowTest")) 2061 << message_; 2062 } 2063 2064 IN_PROC_BROWSER_TEST_F(WebViewTest, SpeechRecognitionAPI_HasPermissionDeny) { 2065 ASSERT_TRUE( 2066 RunPlatformAppTestWithArg("platform_apps/web_view/speech_recognition_api", 2067 "denyTest")) 2068 << message_; 2069 } 2070 2071 IN_PROC_BROWSER_TEST_F(WebViewTest, SpeechRecognitionAPI_NoPermission) { 2072 ASSERT_TRUE( 2073 RunPlatformAppTestWithArg("platform_apps/web_view/common", 2074 "speech_recognition_api_no_permission")) 2075 << message_; 2076 } 2077 2078 // Tests overriding user agent. 2079 IN_PROC_BROWSER_TEST_F(WebViewTest, UserAgent) { 2080 ASSERT_TRUE(RunPlatformAppTestWithArg( 2081 "platform_apps/web_view/common", "useragent")) << message_; 2082 } 2083 2084 IN_PROC_BROWSER_TEST_F(WebViewTest, UserAgent_NewWindow) { 2085 ASSERT_TRUE(RunPlatformAppTestWithArg( 2086 "platform_apps/web_view/common", 2087 "useragent_newwindow")) << message_; 2088 } 2089 2090 IN_PROC_BROWSER_TEST_F(WebViewTest, NoPermission) { 2091 ASSERT_TRUE(RunPlatformAppTest("platform_apps/web_view/nopermission")) 2092 << message_; 2093 } 2094 2095 IN_PROC_BROWSER_TEST_F(WebViewTest, Dialog_TestAlertDialog) { 2096 TestHelper("testAlertDialog", "web_view/dialog", NO_TEST_SERVER); 2097 } 2098 2099 IN_PROC_BROWSER_TEST_F(WebViewTest, TestConfirmDialog) { 2100 TestHelper("testConfirmDialog", "web_view/dialog", NO_TEST_SERVER); 2101 } 2102 2103 IN_PROC_BROWSER_TEST_F(WebViewTest, Dialog_TestConfirmDialogCancel) { 2104 TestHelper("testConfirmDialogCancel", "web_view/dialog", NO_TEST_SERVER); 2105 } 2106 2107 IN_PROC_BROWSER_TEST_F(WebViewTest, Dialog_TestConfirmDialogDefaultCancel) { 2108 TestHelper("testConfirmDialogDefaultCancel", 2109 "web_view/dialog", 2110 NO_TEST_SERVER); 2111 } 2112 2113 IN_PROC_BROWSER_TEST_F(WebViewTest, Dialog_TestConfirmDialogDefaultGCCancel) { 2114 TestHelper("testConfirmDialogDefaultGCCancel", 2115 "web_view/dialog", 2116 NO_TEST_SERVER); 2117 } 2118 2119 IN_PROC_BROWSER_TEST_F(WebViewTest, Dialog_TestPromptDialog) { 2120 TestHelper("testPromptDialog", "web_view/dialog", NO_TEST_SERVER); 2121 } 2122 2123 IN_PROC_BROWSER_TEST_F(WebViewTest, NoContentSettingsAPI) { 2124 // Load the extension. 2125 const extensions::Extension* content_settings_extension = 2126 LoadExtension( 2127 test_data_dir_.AppendASCII( 2128 "platform_apps/web_view/extension_api/content_settings")); 2129 ASSERT_TRUE(content_settings_extension); 2130 TestHelper("testPostMessageCommChannel", "web_view/shim", NO_TEST_SERVER); 2131 } 2132 2133 #if defined(ENABLE_PLUGINS) 2134 class WebViewPluginTest : public WebViewTest { 2135 protected: 2136 virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE { 2137 WebViewTest::SetUpCommandLine(command_line); 2138 2139 // Append the switch to register the pepper plugin. 2140 // library name = <out dir>/<test_name>.<library_extension> 2141 // MIME type = application/x-ppapi-<test_name> 2142 base::FilePath plugin_dir; 2143 EXPECT_TRUE(PathService::Get(base::DIR_MODULE, &plugin_dir)); 2144 2145 base::FilePath plugin_lib = plugin_dir.Append(library_name); 2146 EXPECT_TRUE(base::PathExists(plugin_lib)); 2147 base::FilePath::StringType pepper_plugin = plugin_lib.value(); 2148 pepper_plugin.append(FILE_PATH_LITERAL(";application/x-ppapi-tests")); 2149 command_line->AppendSwitchNative(switches::kRegisterPepperPlugins, 2150 pepper_plugin); 2151 } 2152 }; 2153 2154 IN_PROC_BROWSER_TEST_F(WebViewPluginTest, TestLoadPluginEvent) { 2155 TestHelper("testPluginLoadPermission", "web_view/shim", NO_TEST_SERVER); 2156 } 2157 #endif // defined(ENABLE_PLUGINS) 2158 2159 class WebViewCaptureTest : public WebViewTest { 2160 public: 2161 WebViewCaptureTest() {} 2162 virtual ~WebViewCaptureTest() {} 2163 virtual void SetUp() OVERRIDE { 2164 EnablePixelOutput(); 2165 WebViewTest::SetUp(); 2166 } 2167 }; 2168 2169 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestZoomAPI) { 2170 TestHelper("testZoomAPI", "web_view/shim", NO_TEST_SERVER); 2171 } 2172 2173 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestFindAPI) { 2174 TestHelper("testFindAPI", "web_view/shim", NO_TEST_SERVER); 2175 } 2176 2177 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestFindAPI_findupdate) { 2178 TestHelper("testFindAPI_findupdate", "web_view/shim", NO_TEST_SERVER); 2179 } 2180 2181 // <webview> screenshot capture fails with ubercomp. 2182 // See http://crbug.com/327035. 2183 IN_PROC_BROWSER_TEST_F(WebViewCaptureTest, 2184 DISABLED_Shim_ScreenshotCapture) { 2185 TestHelper("testScreenshotCapture", "web_view/shim", NO_TEST_SERVER); 2186 } 2187