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