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