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.
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"
43 #if defined(OS_CHROMEOS)
44 #include "chrome/browser/chromeos/accessibility/accessibility_manager.h"
45 #include "chrome/browser/chromeos/accessibility/speech_monitor.h"
48 // For fine-grained suppression on flaky tests.
50 #include "base/win/windows_version.h"
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;
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";
73 // Platform-specific filename relative to the chrome executable.
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";
82 class EmptyHttpResponse : public net::test_server::HttpResponse {
84 virtual std::string ToResponseString() const OVERRIDE {
89 class TestInterstitialPageDelegate : public content::InterstitialPageDelegate {
91 TestInterstitialPageDelegate() {
93 virtual ~TestInterstitialPageDelegate() {}
94 virtual std::string GetHTMLContents() OVERRIDE { return std::string(); }
97 class TestGuestViewManager : public GuestViewManager {
99 explicit TestGuestViewManager(content::BrowserContext* context) :
100 GuestViewManager(context),
101 web_contents_(NULL) {}
103 content::WebContents* WaitForGuestCreated() {
105 return web_contents_;
107 message_loop_runner_ = new content::MessageLoopRunner;
108 message_loop_runner_->Run();
109 return web_contents_;
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;
119 if (message_loop_runner_)
120 message_loop_runner_->Quit();
123 content::WebContents* web_contents_;
124 scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
127 // Test factory for creating test instances of GuestViewManager.
128 class TestGuestViewManagerFactory : public GuestViewManagerFactory {
130 TestGuestViewManagerFactory() :
131 test_guest_view_manager_(NULL) {}
133 virtual ~TestGuestViewManagerFactory() {}
135 virtual GuestViewManager* CreateGuestViewManager(
136 content::BrowserContext* context) OVERRIDE {
137 return GetManager(context);
140 TestGuestViewManager* GetManager(content::BrowserContext* context) {
141 if (!test_guest_view_manager_) {
142 test_guest_view_manager_ = new TestGuestViewManager(context);
144 return test_guest_view_manager_;
148 TestGuestViewManager* test_guest_view_manager_;
150 DISALLOW_COPY_AND_ASSIGN(TestGuestViewManagerFactory);
153 class WebContentsHiddenObserver : public content::WebContentsObserver {
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) {
162 // WebContentsObserver.
163 virtual void WasHidden() OVERRIDE {
164 hidden_observed_ = true;
165 hidden_callback_.Run();
168 bool hidden_observed() { return hidden_observed_; }
171 base::Closure hidden_callback_;
172 bool hidden_observed_;
174 DISALLOW_COPY_AND_ASSIGN(WebContentsHiddenObserver);
177 class InterstitialObserver : public content::WebContentsObserver {
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) {
187 virtual void DidAttachInterstitialPage() OVERRIDE {
188 attach_callback_.Run();
191 virtual void DidDetachInterstitialPage() OVERRIDE {
192 detach_callback_.Run();
196 base::Closure attach_callback_;
197 base::Closure detach_callback_;
199 DISALLOW_COPY_AND_ASSIGN(InterstitialObserver);
202 void ExecuteScriptWaitForTitle(content::WebContents* web_contents,
205 base::string16 expected_title(base::ASCIIToUTF16(title));
206 base::string16 error_title(base::ASCIIToUTF16("error"));
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());
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
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 {
224 MockWebContentsDelegate() : requested_(false) {}
225 virtual ~MockWebContentsDelegate() {}
227 virtual void RequestMediaAccessPermission(
228 content::WebContents* web_contents,
229 const content::MediaStreamRequest& request,
230 const content::MediaResponseCallback& callback) OVERRIDE {
232 if (message_loop_runner_.get())
233 message_loop_runner_->Quit();
236 void WaitForSetMediaPermission() {
239 message_loop_runner_ = new content::MessageLoopRunner;
240 message_loop_runner_->Run();
245 scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
247 DISALLOW_COPY_AND_ASSIGN(MockWebContentsDelegate);
250 // This class intercepts download request from the guest.
251 class MockDownloadWebContentsDelegate : public content::WebContentsDelegate {
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() {}
262 virtual void CanDownload(
263 content::RenderViewHost* render_view_host,
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)));
273 void WaitForCanDownload(bool expect_allow) {
274 EXPECT_FALSE(waiting_for_decision_);
275 waiting_for_decision_ = true;
277 if (decision_made_) {
278 EXPECT_EQ(expect_allow, last_download_allowed_);
282 expect_allow_ = expect_allow;
283 message_loop_runner_ = new content::MessageLoopRunner;
284 message_loop_runner_->Run();
287 void DownloadDecided(bool allow) {
288 EXPECT_FALSE(decision_made_);
289 decision_made_ = true;
291 if (waiting_for_decision_) {
292 EXPECT_EQ(expect_allow_, allow);
293 if (message_loop_runner_.get())
294 message_loop_runner_->Quit();
297 last_download_allowed_ = allow;
301 waiting_for_decision_ = false;
302 decision_made_ = false;
306 content::WebContentsDelegate* orig_delegate_;
307 bool waiting_for_decision_;
310 bool last_download_allowed_;
311 scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
313 DISALLOW_COPY_AND_ASSIGN(MockDownloadWebContentsDelegate);
316 class WebViewTest : public extensions::PlatformAppBrowserTest {
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
326 content::SpeechRecognitionManager::SetManagerForTesting(
327 fake_speech_recognition_manager_.get());
329 extensions::PlatformAppBrowserTest::SetUp();
332 virtual void TearDown() OVERRIDE {
333 if (UsesFakeSpeech()) {
334 // SpeechRecognition test specific TearDown.
335 content::SpeechRecognitionManager::SetManagerForTesting(NULL);
338 extensions::PlatformAppBrowserTest::TearDown();
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);
352 virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
353 command_line->AppendSwitch(switches::kUseFakeDeviceForMediaStream);
354 command_line->AppendSwitchASCII(switches::kJavaScriptFlags, "--expose-gc");
356 extensions::PlatformAppBrowserTest::SetUpCommandLine(command_line);
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
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);
386 navigate_to_url = navigate_to_url.ReplaceComponents(replace_host);
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);
410 ui_test_utils::NavigateToURLWithDisposition(
411 browser(), navigate_to_url, CURRENT_TAB,
412 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
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");
437 content::Source<content::NavigationController> source1 = observer1.source();
438 EXPECT_TRUE(source1->GetWebContents()->GetRenderProcessHost()->
440 content::Source<content::NavigationController> source2 = observer2.source();
441 EXPECT_TRUE(source2->GetWebContents()->GetRenderProcessHost()->
443 content::Source<content::NavigationController> source3 = observer3.source();
444 EXPECT_TRUE(source3->GetWebContents()->GetRenderProcessHost()->
446 content::Source<content::NavigationController> source4 = observer4.source();
447 EXPECT_TRUE(source4->GetWebContents()->GetRenderProcessHost()->
449 content::Source<content::NavigationController> source5 = observer5.source();
450 EXPECT_TRUE(source5->GetWebContents()->GetRenderProcessHost()->
452 content::Source<content::NavigationController> source6 = observer6.source();
453 EXPECT_TRUE(source6->GetWebContents()->GetRenderProcessHost()->
455 content::Source<content::NavigationController> source7 = observer7.source();
456 EXPECT_TRUE(source7->GetWebContents()->GetRenderProcessHost()->
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());
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());
476 // Check that the storage partitions of the first two tags match and are
477 // different than the other two.
479 source1->GetWebContents()->GetRenderProcessHost()->
480 GetStoragePartition(),
481 source2->GetWebContents()->GetRenderProcessHost()->
482 GetStoragePartition());
484 source3->GetWebContents()->GetRenderProcessHost()->
485 GetStoragePartition(),
486 source4->GetWebContents()->GetRenderProcessHost()->
487 GetStoragePartition());
489 source1->GetWebContents()->GetRenderProcessHost()->
490 GetStoragePartition(),
491 source3->GetWebContents()->GetRenderProcessHost()->
492 GetStoragePartition());
494 // Ensure the persistent storage partitions are different.
496 source5->GetWebContents()->GetRenderProcessHost()->
497 GetStoragePartition(),
498 source6->GetWebContents()->GetRenderProcessHost()->
499 GetStoragePartition());
501 source5->GetWebContents()->GetRenderProcessHost()->
502 GetStoragePartition(),
503 source7->GetWebContents()->GetRenderProcessHost()->
504 GetStoragePartition());
506 source1->GetWebContents()->GetRenderProcessHost()->
507 GetStoragePartition(),
508 source5->GetWebContents()->GetRenderProcessHost()->
509 GetStoragePartition());
511 source1->GetWebContents()->GetRenderProcessHost()->
512 GetStoragePartition(),
513 source7->GetWebContents()->GetRenderProcessHost()->
514 GetStoragePartition());
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();
523 if (persistent_partition_contents2) {
524 *persistent_partition_contents2 = source6->GetWebContents();
526 if (persistent_partition_contents3) {
527 *persistent_partition_contents3 = source7->GetWebContents();
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>();
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>();
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);
555 return scoped_ptr<net::test_server::HttpResponse>();
558 // Shortcut to return the current MenuManager.
559 extensions::MenuManager* menu_manager() {
560 return extensions::MenuManager::Get(browser()->profile());
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());
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.";
591 embedded_test_server()->RegisterRequestHandler(
592 base::Bind(&WebViewTest::RedirectResponseHandler,
593 kRedirectResponsePath,
594 embedded_test_server()->GetURL(kRedirectResponseFullPath)));
596 embedded_test_server()->RegisterRequestHandler(
597 base::Bind(&WebViewTest::EmptyResponseHandler, kEmptyResponsePath));
600 LoadAndLaunchPlatformApp(app_location.c_str(), "Launched");
602 // Flush any pending events to make sure we start with a clean slate.
603 content::RunAllPendingInMessageLoop();
605 content::WebContents* embedder_web_contents =
606 GetFirstAppWindowWebContents();
607 if (!embedder_web_contents) {
608 LOG(ERROR) << "UNABLE TO FIND EMBEDDER WEB CONTENTS.";
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.";
620 ASSERT_TRUE(done_listener.WaitUntilSatisfied());
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);
629 GURL guest_url = embedded_test_server()->GetURL(guest_path);
630 guest_url = guest_url.ReplaceComponents(replace_host);
632 ui_test_utils::UrlLoadObserver guest_observer(
633 guest_url, content::NotificationService::AllSources());
635 LoadAndLaunchPlatformApp(app_path.c_str(), "guest-loaded");
637 guest_observer.Wait();
638 content::Source<content::NavigationController> source =
639 guest_observer.source();
640 EXPECT_TRUE(source->GetWebContents()->GetRenderProcessHost()->
643 content::WebContents* guest_web_contents = source->GetWebContents();
644 return guest_web_contents;
647 // Runs media_access/allow tests.
648 void MediaAccessAPIAllowTestHelper(const std::string& test_name);
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");
656 content::WebContents* embedder_web_contents =
657 GetFirstAppWindowWebContents();
658 ASSERT_TRUE(embedder_web_contents);
660 ExtensionTestMessageListener test_run_listener("PASSED", false);
661 test_run_listener.set_failure_message("FAILED");
663 content::ExecuteScript(
664 embedder_web_contents,
665 base::StringPrintf("startDenyTest('%s')", test_name.c_str())));
666 ASSERT_TRUE(test_run_listener.WaitUntilSatisfied());
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(),
675 if (!content::InterstitialPage::GetInterstitialPage(web_contents))
679 void LoadAppWithGuest(const std::string& app_path) {
681 ExtensionTestMessageListener launched_listener("WebViewTest.LAUNCHED",
683 launched_listener.set_failure_message("WebViewTest.FAILURE");
684 LoadAndLaunchPlatformApp(app_path.c_str(), &launched_listener);
686 guest_web_contents_ = GetGuestViewManager()->WaitForGuestCreated();
689 void SendMessageToEmbedder(const std::string& message) {
691 content::ExecuteScript(
692 GetEmbedderWebContents(),
693 base::StringPrintf("onAppCommand('%s');", message.c_str())));
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));
704 content::ExecuteScript(
705 GetGuestWebContents(),
706 base::StringPrintf("onAppCommand('%s');", message.c_str())));
709 ASSERT_TRUE(listener->WaitUntilSatisfied());
713 content::WebContents* GetGuestWebContents() {
714 return guest_web_contents_;
717 content::WebContents* GetEmbedderWebContents() {
718 if (!embedder_web_contents_) {
719 embedder_web_contents_ = GetFirstAppWindowWebContents();
721 return embedder_web_contents_;
724 TestGuestViewManager* GetGuestViewManager() {
725 return factory_.GetManager(browser()->profile());
728 WebViewTest() : guest_web_contents_(NULL),
729 embedder_web_contents_(NULL) {
730 GuestViewManager::set_factory_for_testing(&factory_);
734 bool UsesFakeSpeech() {
735 const testing::TestInfo* const test_info =
736 testing::UnitTest::GetInstance()->current_test_info();
738 // SpeechRecognition test specific SetUp.
739 return !strcmp(test_info->name(),
740 "SpeechRecognitionAPI_HasPermissionAllow");
743 scoped_ptr<content::FakeSpeechRecognitionManager>
744 fake_speech_recognition_manager_;
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_;
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");
756 scoped_refptr<content::MessageLoopRunner> loop_runner(
757 new content::MessageLoopRunner);
758 WebContentsHiddenObserver observer(GetGuestWebContents(),
759 loop_runner->QuitClosure());
761 // Handled in platform_apps/web_view/visibility_changed/main.js
762 SendMessageToEmbedder("hide-guest");
763 if (!observer.hidden_observed())
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");
771 scoped_refptr<content::MessageLoopRunner> loop_runner(
772 new content::MessageLoopRunner);
773 WebContentsHiddenObserver observer(GetGuestWebContents(),
774 loop_runner->QuitClosure());
776 // Handled in platform_apps/web_view/visibility_changed/main.js
777 SendMessageToEmbedder("hide-embedder");
778 if (!observer.hidden_observed())
782 // This test verifies that reloading the embedder reloads the guest (and doest
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");
789 ExtensionTestMessageListener launched_again_listener("WebViewTest.LAUNCHED",
791 GetEmbedderWebContents()->GetController().Reload(false);
792 ASSERT_TRUE(launched_again_listener.WaitUntilSatisfied());
795 IN_PROC_BROWSER_TEST_F(WebViewTest, AcceptTouchEvents) {
796 LoadAppWithGuest("web_view/accept_touch_events");
798 content::RenderViewHost* embedder_rvh =
799 GetEmbedderWebContents()->GetRenderViewHost();
801 bool embedder_has_touch_handler =
802 content::RenderViewHostTester::HasTouchEventHandler(embedder_rvh);
803 EXPECT_FALSE(embedder_has_touch_handler);
805 SendMessageToGuestAndWait("install-touch-handler", "installed-touch-handler");
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);
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);
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"))
832 IN_PROC_BROWSER_TEST_F(WebViewTest, AutoSize) {
834 // Flaky on XP bot http://crbug.com/299507
835 if (base::win::GetVersion() <= base::win::VERSION_XP)
839 ASSERT_TRUE(RunPlatformAppTest("platform_apps/web_view/autosize"))
843 // http://crbug.com/326332
844 IN_PROC_BROWSER_TEST_F(WebViewTest, DISABLED_Shim_TestAutosizeAfterNavigation) {
845 TestHelper("testAutosizeAfterNavigation", "web_view/shim", NO_TEST_SERVER);
848 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestAutosizeBeforeNavigation) {
849 TestHelper("testAutosizeBeforeNavigation", "web_view/shim", NO_TEST_SERVER);
851 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestAutosizeRemoveAttributes) {
852 TestHelper("testAutosizeRemoveAttributes", "web_view/shim", NO_TEST_SERVER);
855 // This test is disabled due to being flaky. http://crbug.com/282116
857 #define MAYBE_Shim_TestAutosizeWithPartialAttributes \
858 DISABLED_Shim_TestAutosizeWithPartialAttributes
860 #define MAYBE_Shim_TestAutosizeWithPartialAttributes \
861 Shim_TestAutosizeWithPartialAttributes
863 IN_PROC_BROWSER_TEST_F(WebViewTest,
864 MAYBE_Shim_TestAutosizeWithPartialAttributes) {
865 TestHelper("testAutosizeWithPartialAttributes",
870 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestAPIMethodExistence) {
871 TestHelper("testAPIMethodExistence", "web_view/shim", NO_TEST_SERVER);
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);
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
884 #define MAYBE_Shim_TestChromeExtensionURL Shim_TestChromeExtensionURL
886 IN_PROC_BROWSER_TEST_F(WebViewTest, MAYBE_Shim_TestChromeExtensionURL) {
887 TestHelper("testChromeExtensionURL", "web_view/shim", NO_TEST_SERVER);
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
895 #define MAYBE_Shim_TestChromeExtensionRelativePath \
896 Shim_TestChromeExtensionRelativePath
898 IN_PROC_BROWSER_TEST_F(WebViewTest,
899 MAYBE_Shim_TestChromeExtensionRelativePath) {
900 TestHelper("testChromeExtensionRelativePath",
905 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestDisplayNoneWebviewLoad) {
906 TestHelper("testDisplayNoneWebviewLoad", "web_view/shim", NO_TEST_SERVER);
909 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestDisplayNoneWebviewRemoveChild) {
910 TestHelper("testDisplayNoneWebviewRemoveChild",
911 "web_view/shim", NO_TEST_SERVER);
914 IN_PROC_BROWSER_TEST_F(WebViewTest,
915 Shim_TestInlineScriptFromAccessibleResources) {
916 TestHelper("testInlineScriptFromAccessibleResources",
921 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestInvalidChromeExtensionURL) {
922 TestHelper("testInvalidChromeExtensionURL", "web_view/shim", NO_TEST_SERVER);
925 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestEventName) {
926 TestHelper("testEventName", "web_view/shim", NO_TEST_SERVER);
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);
935 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadProgressEvent) {
936 TestHelper("testLoadProgressEvent", "web_view/shim", NO_TEST_SERVER);
939 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestDestroyOnEventListener) {
940 TestHelper("testDestroyOnEventListener", "web_view/shim", NO_TEST_SERVER);
943 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestCannotMutateEventName) {
944 TestHelper("testCannotMutateEventName", "web_view/shim", NO_TEST_SERVER);
947 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestPartitionRaisesException) {
948 TestHelper("testPartitionRaisesException", "web_view/shim", NO_TEST_SERVER);
951 IN_PROC_BROWSER_TEST_F(WebViewTest,
952 Shim_TestPartitionRemovalAfterNavigationFails) {
953 TestHelper("testPartitionRemovalAfterNavigationFails",
958 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestExecuteScriptFail) {
960 // Flaky on XP bot http://crbug.com/266185
961 if (base::win::GetVersion() <= base::win::VERSION_XP)
965 TestHelper("testExecuteScriptFail", "web_view/shim", NEEDS_TEST_SERVER);
968 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestExecuteScript) {
969 TestHelper("testExecuteScript", "web_view/shim", NO_TEST_SERVER);
972 IN_PROC_BROWSER_TEST_F(
974 Shim_TestExecuteScriptIsAbortedWhenWebViewSourceIsChanged) {
975 TestHelper("testExecuteScriptIsAbortedWhenWebViewSourceIsChanged",
980 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestTerminateAfterExit) {
981 TestHelper("testTerminateAfterExit", "web_view/shim", NO_TEST_SERVER);
984 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestAssignSrcAfterCrash) {
985 TestHelper("testAssignSrcAfterCrash", "web_view/shim", NO_TEST_SERVER);
988 IN_PROC_BROWSER_TEST_F(WebViewTest,
989 Shim_TestNavOnConsecutiveSrcAttributeChanges) {
990 TestHelper("testNavOnConsecutiveSrcAttributeChanges",
995 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNavOnSrcAttributeChange) {
996 TestHelper("testNavOnSrcAttributeChange", "web_view/shim", NO_TEST_SERVER);
999 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNavigateAfterResize) {
1000 TestHelper("testNavigateAfterResize", "web_view/shim", NO_TEST_SERVER);
1003 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestRemoveSrcAttribute) {
1004 TestHelper("testRemoveSrcAttribute", "web_view/shim", NO_TEST_SERVER);
1007 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestReassignSrcAttribute) {
1008 TestHelper("testReassignSrcAttribute", "web_view/shim", NO_TEST_SERVER);
1011 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNewWindow) {
1012 TestHelper("testNewWindow", "web_view/shim", NEEDS_TEST_SERVER);
1015 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNewWindowTwoListeners) {
1016 TestHelper("testNewWindowTwoListeners", "web_view/shim", NEEDS_TEST_SERVER);
1019 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNewWindowNoPreventDefault) {
1020 TestHelper("testNewWindowNoPreventDefault",
1025 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNewWindowNoReferrerLink) {
1026 TestHelper("testNewWindowNoReferrerLink", "web_view/shim", NEEDS_TEST_SERVER);
1029 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestContentLoadEvent) {
1030 TestHelper("testContentLoadEvent", "web_view/shim", NO_TEST_SERVER);
1033 // http://crbug.com/326330
1034 IN_PROC_BROWSER_TEST_F(WebViewTest,
1035 Shim_TestDeclarativeWebRequestAPI) {
1036 TestHelper("testDeclarativeWebRequestAPI",
1041 IN_PROC_BROWSER_TEST_F(WebViewTest,
1042 Shim_TestDeclarativeWebRequestAPISendMessage) {
1043 TestHelper("testDeclarativeWebRequestAPISendMessage",
1048 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestWebRequestAPI) {
1049 TestHelper("testWebRequestAPI", "web_view/shim", NEEDS_TEST_SERVER);
1052 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestWebRequestAPIGoogleProperty) {
1053 TestHelper("testWebRequestAPIGoogleProperty",
1058 // This test is disabled due to being flaky. http://crbug.com/309451
1060 #define MAYBE_Shim_TestWebRequestListenerSurvivesReparenting \
1061 DISABLED_Shim_TestWebRequestListenerSurvivesReparenting
1063 #define MAYBE_Shim_TestWebRequestListenerSurvivesReparenting \
1064 Shim_TestWebRequestListenerSurvivesReparenting
1066 IN_PROC_BROWSER_TEST_F(
1068 MAYBE_Shim_TestWebRequestListenerSurvivesReparenting) {
1069 TestHelper("testWebRequestListenerSurvivesReparenting",
1074 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadStartLoadRedirect) {
1075 TestHelper("testLoadStartLoadRedirect", "web_view/shim", NEEDS_TEST_SERVER);
1078 IN_PROC_BROWSER_TEST_F(WebViewTest,
1079 Shim_TestLoadAbortChromeExtensionURLWrongPartition) {
1080 TestHelper("testLoadAbortChromeExtensionURLWrongPartition",
1085 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadAbortEmptyResponse) {
1086 TestHelper("testLoadAbortEmptyResponse", "web_view/shim", NEEDS_TEST_SERVER);
1089 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadAbortIllegalChromeURL) {
1090 TestHelper("testLoadAbortIllegalChromeURL",
1095 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadAbortIllegalFileURL) {
1096 TestHelper("testLoadAbortIllegalFileURL", "web_view/shim", NO_TEST_SERVER);
1099 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadAbortIllegalJavaScriptURL) {
1100 TestHelper("testLoadAbortIllegalJavaScriptURL",
1105 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadAbortInvalidNavigation) {
1106 TestHelper("testLoadAbortInvalidNavigation", "web_view/shim", NO_TEST_SERVER);
1109 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadAbortNonWebSafeScheme) {
1110 TestHelper("testLoadAbortNonWebSafeScheme", "web_view/shim", NO_TEST_SERVER);
1113 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestReload) {
1114 TestHelper("testReload", "web_view/shim", NEEDS_TEST_SERVER);
1117 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestGetProcessId) {
1118 TestHelper("testGetProcessId", "web_view/shim", NEEDS_TEST_SERVER);
1121 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestHiddenBeforeNavigation) {
1122 TestHelper("testHiddenBeforeNavigation", "web_view/shim", NO_TEST_SERVER);
1125 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestRemoveWebviewOnExit) {
1126 ASSERT_TRUE(StartEmbeddedTestServer()); // For serving guest pages.
1128 // Launch the app and wait until it's ready to load a test.
1129 LoadAndLaunchPlatformApp("web_view/shim", "Launched");
1131 content::WebContents* embedder_web_contents = GetFirstAppWindowWebContents();
1132 ASSERT_TRUE(embedder_web_contents);
1134 GURL::Replacements replace_host;
1135 std::string host_str("localhost"); // Must stay in scope with replace_host.
1136 replace_host.SetHostStr(host_str);
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);
1143 ui_test_utils::UrlLoadObserver guest_observer(
1144 guest_url, content::NotificationService::AllSources());
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();
1154 content::Source<content::NavigationController> source =
1155 guest_observer.source();
1156 EXPECT_TRUE(source->GetWebContents()->GetRenderProcessHost()->
1159 ASSERT_TRUE(guest_loaded_listener.WaitUntilSatisfied());
1161 content::WebContentsDestroyedWatcher destroyed_watcher(
1162 source->GetWebContents());
1164 // Tell the embedder to kill the guest.
1165 EXPECT_TRUE(content::ExecuteScript(
1166 embedder_web_contents,
1167 "removeWebviewOnExitDoCrash();"));
1169 // Wait until the guest WebContents is destroyed.
1170 destroyed_watcher.Wait();
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",
1181 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNavigationToExternalProtocol) {
1182 TestHelper("testNavigationToExternalProtocol",
1187 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestResizeWebviewResizesContent) {
1188 TestHelper("testResizeWebviewResizesContent",
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
1199 #define MAYBE_InterstitialTeardown InterstitialTeardown
1201 IN_PROC_BROWSER_TEST_F(WebViewTest, MAYBE_InterstitialTeardown) {
1203 // Flaky on XP bot http://crbug.com/297014
1204 if (base::win::GetVersion() <= base::win::VERSION_XP)
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());
1217 net::HostPortPair host_and_port = https_server.host_port_pair();
1219 LoadAndLaunchPlatformApp("web_view/interstitial_teardown", "EmbedderLoaded");
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());
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);
1235 // Now close the app while interstitial page being shown in guest.
1236 apps::AppWindow* window = GetFirstAppWindow();
1237 window->GetBaseWindow()->Close();
1240 IN_PROC_BROWSER_TEST_F(WebViewTest, ShimSrcAttribute) {
1241 ASSERT_TRUE(RunPlatformAppTest("platform_apps/web_view/src_attribute"))
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 =
1252 "/extensions/platform_apps/web_view/noprerenderer/guest.html",
1253 "web_view/noprerenderer");
1254 ASSERT_TRUE(guest_web_contents != NULL);
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());
1263 // Verify that existing <webview>'s are detected when the task manager starts
1265 IN_PROC_BROWSER_TEST_F(WebViewTest, TaskManagerExistingWebView) {
1266 ASSERT_TRUE(StartEmbeddedTestServer());
1268 LoadGuest("/extensions/platform_apps/web_view/task_manager/guest.html",
1269 "web_view/task_manager");
1271 chrome::ShowTaskManager(browser()); // Show task manager AFTER guest loads.
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)));
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()));
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());
1290 chrome::ShowTaskManager(browser()); // Show task manager BEFORE guest loads.
1292 LoadGuest("/extensions/platform_apps/web_view/task_manager/guest.html",
1293 "web_view/task_manager");
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)));
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()));
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 + ';';");
1323 GURL::Replacements replace_host;
1324 std::string host_str("localhost"); // Must stay in scope with replace_host.
1325 replace_host.SetHostStr(host_str);
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);
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;
1339 NavigateAndOpenAppForIsolation(set_cookie_url, &cookie_contents1,
1340 &cookie_contents2, &named_partition_contents1,
1341 &named_partition_contents2, NULL, NULL, NULL);
1343 EXPECT_TRUE(content::ExecuteScript(cookie_contents1, cookie_script1));
1344 EXPECT_TRUE(content::ExecuteScript(cookie_contents2, cookie_script2));
1347 std::string cookie_value;
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);
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
1359 ui_test_utils::GetCookies(GURL("http://localhost"),
1361 &cookie_size, &cookie_value);
1362 EXPECT_EQ("guest1=true; guest2=true", cookie_value);
1364 ui_test_utils::GetCookies(GURL("http://localhost"),
1366 &cookie_size, &cookie_value);
1367 EXPECT_EQ("guest1=true; guest2=true", cookie_value);
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);
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 + ';';");
1392 // We don't care where the main browser is on this test.
1393 GURL blank_url("about:blank");
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);
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,
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,
1422 EXPECT_TRUE(content::ExecuteScript(persistent_partition_contents3,
1426 std::string cookie_value;
1428 // Check that all in-memory partitions have a cookie set.
1429 ui_test_utils::GetCookies(GURL("http://localhost"),
1431 &cookie_size, &cookie_value);
1432 EXPECT_EQ("inmemory=true", cookie_value);
1433 ui_test_utils::GetCookies(GURL("http://localhost"),
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);
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);
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());
1466 // We don't care where the main browser is on this test.
1467 GURL blank_url("about:blank");
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);
1487 std::string cookie_value;
1489 // Check that all in-memory partitions lost their state.
1490 ui_test_utils::GetCookies(GURL("http://localhost"),
1492 &cookie_size, &cookie_value);
1493 EXPECT_EQ("", cookie_value);
1494 ui_test_utils::GetCookies(GURL("http://localhost"),
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);
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);
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
1526 IN_PROC_BROWSER_TEST_F(WebViewTest, DOMStorageIsolation) {
1527 ASSERT_TRUE(StartEmbeddedTestServer());
1528 GURL regular_url = embedded_test_server()->GetURL("/title1.html");
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')");
1536 content::WebContents* default_tag_contents1;
1537 content::WebContents* default_tag_contents2;
1538 content::WebContents* storage_contents1;
1539 content::WebContents* storage_contents2;
1541 NavigateAndOpenAppForIsolation(regular_url, &default_tag_contents1,
1542 &default_tag_contents2, &storage_contents1,
1543 &storage_contents2, NULL, NULL, NULL);
1545 // Initialize the storage for the first of the two tags that share a storage
1547 EXPECT_TRUE(content::ExecuteScript(storage_contents1,
1548 "initDomStorage('page1')"));
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(),
1555 EXPECT_STREQ("local-page1", output.c_str());
1556 EXPECT_TRUE(ExecuteScriptAndExtractString(storage_contents1,
1557 get_session_storage.c_str(),
1559 EXPECT_STREQ("session-page1", output.c_str());
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')"));
1566 // The localStorage value now should reflect the one written through the
1568 EXPECT_TRUE(ExecuteScriptAndExtractString(storage_contents1,
1569 get_local_storage.c_str(),
1571 EXPECT_STREQ("local-page2", output.c_str());
1572 EXPECT_TRUE(ExecuteScriptAndExtractString(storage_contents2,
1573 get_local_storage.c_str(),
1575 EXPECT_STREQ("local-page2", output.c_str());
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(),
1582 EXPECT_STREQ("session-page1", output.c_str());
1583 EXPECT_TRUE(ExecuteScriptAndExtractString(storage_contents2,
1584 get_session_storage.c_str(),
1586 EXPECT_STREQ("session-page2", output.c_str());
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(),
1594 EXPECT_STREQ("badval", output.c_str());
1595 EXPECT_TRUE(ExecuteScriptAndExtractString(
1596 browser()->tab_strip_model()->GetWebContentsAt(0),
1597 get_session_storage.c_str(),
1599 EXPECT_STREQ("badval", output.c_str());
1600 EXPECT_TRUE(ExecuteScriptAndExtractString(default_tag_contents1,
1601 get_local_storage.c_str(),
1603 EXPECT_STREQ("badval", output.c_str());
1604 EXPECT_TRUE(ExecuteScriptAndExtractString(default_tag_contents1,
1605 get_session_storage.c_str(),
1607 EXPECT_STREQ("badval", output.c_str());
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");
1617 content::WebContents* default_tag_contents1;
1618 content::WebContents* default_tag_contents2;
1619 content::WebContents* storage_contents1;
1620 content::WebContents* storage_contents2;
1622 NavigateAndOpenAppForIsolation(regular_url, &default_tag_contents1,
1623 &default_tag_contents2, &storage_contents1,
1624 &storage_contents2, NULL, NULL, NULL);
1626 // Initialize the storage for the first of the two tags that share a storage
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");
1635 std::string get_value(
1636 "window.domAutomationController.send(getValueIDB() || 'badval')");
1638 EXPECT_TRUE(ExecuteScriptAndExtractString(storage_contents1,
1639 get_value.c_str(), &output));
1640 EXPECT_STREQ("page1", output.c_str());
1642 // Initialize the db in the second tag.
1643 ExecuteScriptWaitForTitle(storage_contents2, "initIDB()", "idb open");
1645 // Since we share a partition, reading the value should return the existing
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());
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());
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'"));
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());
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
1679 const char* script =
1680 "indexedDB.open('isolation').onsuccess = function(e) {"
1681 " if (e.target.result.version == 1)"
1682 " document.title = 'db not found';"
1684 " document.title = 'error';"
1686 ExecuteScriptWaitForTitle(browser()->tab_strip_model()->GetWebContentsAt(0),
1687 script, "db not found");
1688 ExecuteScriptWaitForTitle(default_tag_contents1, script, "db not found");
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
1696 #define MAYBE_CloseOnLoadcommit DISABLED_CloseOnLoadcommit
1698 #define MAYBE_CloseOnLoadcommit CloseOnLoadcommit
1700 IN_PROC_BROWSER_TEST_F(WebViewTest, MAYBE_CloseOnLoadcommit) {
1701 LoadAndLaunchPlatformApp("web_view/close_on_loadcommit",
1702 "done-close-on-loadcommit");
1705 IN_PROC_BROWSER_TEST_F(WebViewTest, MediaAccessAPIDeny_TestDeny) {
1706 MediaAccessAPIDenyTestHelper("testDeny");
1709 IN_PROC_BROWSER_TEST_F(WebViewTest,
1710 MediaAccessAPIDeny_TestDenyThenAllowThrows) {
1711 MediaAccessAPIDenyTestHelper("testDenyThenAllowThrows");
1715 IN_PROC_BROWSER_TEST_F(WebViewTest,
1716 MediaAccessAPIDeny_TestDenyWithPreventDefault) {
1717 MediaAccessAPIDenyTestHelper("testDenyWithPreventDefault");
1720 IN_PROC_BROWSER_TEST_F(WebViewTest,
1721 MediaAccessAPIDeny_TestNoListenersImplyDeny) {
1722 MediaAccessAPIDenyTestHelper("testNoListenersImplyDeny");
1725 IN_PROC_BROWSER_TEST_F(WebViewTest,
1726 MediaAccessAPIDeny_TestNoPreventDefaultImpliesDeny) {
1727 MediaAccessAPIDenyTestHelper("testNoPreventDefaultImpliesDeny");
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");
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());
1739 ExtensionTestMessageListener done_listener("TEST_PASSED", false);
1740 done_listener.set_failure_message("TEST_FAILED");
1742 content::ExecuteScript(
1743 embedder_web_contents,
1744 base::StringPrintf("startAllowTest('%s')",
1745 test_name.c_str())));
1746 ASSERT_TRUE(done_listener.WaitUntilSatisfied());
1748 mock->WaitForSetMediaPermission();
1751 IN_PROC_BROWSER_TEST_F(WebViewTest, ContextMenusAPI_Basic) {
1752 LoadAppWithGuest("web_view/context_menus/basic");
1754 content::WebContents* guest_web_contents = GetGuestWebContents();
1755 content::WebContents* embedder = GetEmbedderWebContents();
1756 ASSERT_TRUE(embedder);
1758 // 1. Basic property test.
1759 ExecuteScriptWaitForTitle(embedder, "checkProperties()", "ITEM_CHECKED");
1761 // 2. Create a menu item and wait for created callback to be called.
1762 ExecuteScriptWaitForTitle(embedder, "createMenuItem()", "ITEM_CREATED");
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()));
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);
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());
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());
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());
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());
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());
1804 IN_PROC_BROWSER_TEST_F(WebViewTest, MediaAccessAPIAllow_TestAllow) {
1805 MediaAccessAPIAllowTestHelper("testAllow");
1808 IN_PROC_BROWSER_TEST_F(WebViewTest, MediaAccessAPIAllow_TestAllowAndThenDeny) {
1809 MediaAccessAPIAllowTestHelper("testAllowAndThenDeny");
1812 IN_PROC_BROWSER_TEST_F(WebViewTest, MediaAccessAPIAllow_TestAllowTwice) {
1813 MediaAccessAPIAllowTestHelper("testAllowTwice");
1816 IN_PROC_BROWSER_TEST_F(WebViewTest, MediaAccessAPIAllow_TestAllowAsync) {
1817 MediaAccessAPIAllowTestHelper("testAllowAsync");
1820 // Checks that window.screenX/screenY/screenLeft/screenTop works correctly for
1822 IN_PROC_BROWSER_TEST_F(WebViewTest, ScreenCoordinates) {
1823 ASSERT_TRUE(RunPlatformAppTestWithArg(
1824 "platform_apps/web_view/common", "screen_coordinates"))
1828 #if defined(OS_CHROMEOS)
1829 IN_PROC_BROWSER_TEST_F(WebViewTest, ChromeVoxInjection) {
1831 chromeos::AccessibilityManager::Get()->IsSpokenFeedbackEnabled());
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);
1839 chromeos::SpeechMonitor monitor;
1840 chromeos::AccessibilityManager::Get()->EnableSpokenFeedback(
1841 true, ash::A11Y_NOTIFICATION_NONE);
1842 EXPECT_TRUE(monitor.SkipChromeVoxEnabledMessage());
1844 EXPECT_EQ("chrome vox test title", monitor.GetNextUtterance());
1848 // Flaky on Windows. http://crbug.com/303966
1850 #define MAYBE_TearDownTest DISABLED_TearDownTest
1852 #define MAYBE_TearDownTest TearDownTest
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);
1861 window = GetFirstAppWindow();
1862 CloseAppWindow(window);
1864 // Load the app again.
1865 LoadAndLaunchPlatformApp("web_view/teardown", "guest-loaded");
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",
1878 IN_PROC_BROWSER_TEST_F(WebViewTest, GeolocationAPIEmbedderHasNoAccessDeny) {
1879 TestHelper("testDenyDenies",
1880 "web_view/geolocation/embedder_has_no_permission",
1884 // In following GeolocationAPIEmbedderHasAccess* tests, embedder (i.e. the
1885 // platform app) has geolocation permission
1887 // Note that these test names must be "GeolocationAPI" prefixed (b/c we mock out
1888 // geolocation in this case).
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",
1900 // GeolocationAPI* test 2 of 3.
1901 IN_PROC_BROWSER_TEST_F(WebViewTest, GeolocationAPIEmbedderHasAccessDeny) {
1902 TestHelper("testDeny",
1903 "web_view/geolocation/embedder_has_permission",
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",
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_;
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"))
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);
1938 // FileSystemAPIRequestFromMainThread* test 2 of 3.
1939 IN_PROC_BROWSER_TEST_F(WebViewTest, FileSystemAPIRequestFromMainThreadDeny) {
1940 TestHelper("testDeny", "web_view/filesystem/main", NEEDS_TEST_SERVER);
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);
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);
1956 // FileSystemAPIRequestFromWorker* test 2 of 3.
1957 IN_PROC_BROWSER_TEST_F(WebViewTest, FileSystemAPIRequestFromWorkerDeny) {
1958 TestHelper("testDeny", "web_view/filesystem/worker", NEEDS_TEST_SERVER);
1961 // FileSystemAPIRequestFromWorker* test 3 of 3.
1962 IN_PROC_BROWSER_TEST_F(WebViewTest,
1963 FileSystemAPIRequestFromWorkerDefaultAllow) {
1965 "testDefaultAllow", "web_view/filesystem/worker", NEEDS_TEST_SERVER);
1968 IN_PROC_BROWSER_TEST_F(WebViewTest, ClearData) {
1970 // Flaky on XP bot http://crbug.com/282674
1971 if (base::win::GetVersion() <= base::win::VERSION_XP)
1975 ASSERT_TRUE(StartEmbeddedTestServer()); // For serving guest pages.
1976 ASSERT_TRUE(RunPlatformAppTestWithArg(
1977 "platform_apps/web_view/common", "cleardata"))
1981 // This test is disabled on Win due to being flaky. http://crbug.com/294592
1983 #define MAYBE_ConsoleMessage DISABLED_ConsoleMessage
1985 #define MAYBE_ConsoleMessage ConsoleMessage
1987 IN_PROC_BROWSER_TEST_F(WebViewTest, MAYBE_ConsoleMessage) {
1988 ASSERT_TRUE(RunPlatformAppTestWithArg(
1989 "platform_apps/web_view/common", "console_messages"))
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);
2000 // Replace WebContentsDelegate with mock version so we can intercept download
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());
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();
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();
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.
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);
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());
2042 // Now load an app with <webview>.
2043 LoadAndLaunchPlatformApp("web_view/content_script_whitelisted",
2047 IN_PROC_BROWSER_TEST_F(WebViewTest, SetPropertyOnDocumentReady) {
2048 ASSERT_TRUE(RunPlatformAppTest("platform_apps/web_view/document_ready"))
2052 IN_PROC_BROWSER_TEST_F(WebViewTest, SetPropertyOnDocumentInteractive) {
2053 ASSERT_TRUE(RunPlatformAppTest("platform_apps/web_view/document_interactive"))
2057 IN_PROC_BROWSER_TEST_F(WebViewTest, SpeechRecognitionAPI_HasPermissionAllow) {
2059 RunPlatformAppTestWithArg("platform_apps/web_view/speech_recognition_api",
2064 IN_PROC_BROWSER_TEST_F(WebViewTest, SpeechRecognitionAPI_HasPermissionDeny) {
2066 RunPlatformAppTestWithArg("platform_apps/web_view/speech_recognition_api",
2071 IN_PROC_BROWSER_TEST_F(WebViewTest, SpeechRecognitionAPI_NoPermission) {
2073 RunPlatformAppTestWithArg("platform_apps/web_view/common",
2074 "speech_recognition_api_no_permission"))
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_;
2084 IN_PROC_BROWSER_TEST_F(WebViewTest, UserAgent_NewWindow) {
2085 ASSERT_TRUE(RunPlatformAppTestWithArg(
2086 "platform_apps/web_view/common",
2087 "useragent_newwindow")) << message_;
2090 IN_PROC_BROWSER_TEST_F(WebViewTest, NoPermission) {
2091 ASSERT_TRUE(RunPlatformAppTest("platform_apps/web_view/nopermission"))
2095 IN_PROC_BROWSER_TEST_F(WebViewTest, Dialog_TestAlertDialog) {
2096 TestHelper("testAlertDialog", "web_view/dialog", NO_TEST_SERVER);
2099 IN_PROC_BROWSER_TEST_F(WebViewTest, TestConfirmDialog) {
2100 TestHelper("testConfirmDialog", "web_view/dialog", NO_TEST_SERVER);
2103 IN_PROC_BROWSER_TEST_F(WebViewTest, Dialog_TestConfirmDialogCancel) {
2104 TestHelper("testConfirmDialogCancel", "web_view/dialog", NO_TEST_SERVER);
2107 IN_PROC_BROWSER_TEST_F(WebViewTest, Dialog_TestConfirmDialogDefaultCancel) {
2108 TestHelper("testConfirmDialogDefaultCancel",
2113 IN_PROC_BROWSER_TEST_F(WebViewTest, Dialog_TestConfirmDialogDefaultGCCancel) {
2114 TestHelper("testConfirmDialogDefaultGCCancel",
2119 IN_PROC_BROWSER_TEST_F(WebViewTest, Dialog_TestPromptDialog) {
2120 TestHelper("testPromptDialog", "web_view/dialog", NO_TEST_SERVER);
2123 IN_PROC_BROWSER_TEST_F(WebViewTest, NoContentSettingsAPI) {
2124 // Load the extension.
2125 const extensions::Extension* content_settings_extension =
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);
2133 #if defined(ENABLE_PLUGINS)
2134 class WebViewPluginTest : public WebViewTest {
2136 virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
2137 WebViewTest::SetUpCommandLine(command_line);
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));
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,
2154 IN_PROC_BROWSER_TEST_F(WebViewPluginTest, TestLoadPluginEvent) {
2155 TestHelper("testPluginLoadPermission", "web_view/shim", NO_TEST_SERVER);
2157 #endif // defined(ENABLE_PLUGINS)
2159 class WebViewCaptureTest : public WebViewTest {
2161 WebViewCaptureTest() {}
2162 virtual ~WebViewCaptureTest() {}
2163 virtual void SetUp() OVERRIDE {
2164 EnablePixelOutput();
2165 WebViewTest::SetUp();
2169 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestZoomAPI) {
2170 TestHelper("testZoomAPI", "web_view/shim", NO_TEST_SERVER);
2173 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestFindAPI) {
2174 TestHelper("testFindAPI", "web_view/shim", NO_TEST_SERVER);
2177 IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestFindAPI_findupdate) {
2178 TestHelper("testFindAPI_findupdate", "web_view/shim", NO_TEST_SERVER);
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);