web_view_browsertest.cc revision 116680a4aac90f2aa7413d9095a592090648e557 
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
53using extensions::MenuItem;
54using prerender::PrerenderLinkManager;
55using prerender::PrerenderLinkManagerFactory;
56using task_manager::browsertest_util::MatchAboutBlankTab;
57using task_manager::browsertest_util::MatchAnyApp;
58using task_manager::browsertest_util::MatchAnyBackground;
59using task_manager::browsertest_util::MatchAnyTab;
60using task_manager::browsertest_util::MatchAnyWebView;
61using task_manager::browsertest_util::MatchApp;
62using task_manager::browsertest_util::MatchBackground;
63using task_manager::browsertest_util::MatchWebView;
64using task_manager::browsertest_util::WaitForTaskManagerRows;
65using ui::MenuModel;
66
67namespace {
68const char kEmptyResponsePath[] = "/close-socket";
69const char kRedirectResponsePath[] = "/server-redirect";
70const 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)
75const wchar_t library_name[] = L"ppapi_tests.dll";
76#elif defined(OS_MACOSX)
77const char library_name[] = "ppapi_tests.plugin";
78#elif defined(OS_POSIX)
79const char library_name[] = "libppapi_tests.so";
80#endif
81
82class EmptyHttpResponse : public net::test_server::HttpResponse {
83 public:
84  virtual std::string ToResponseString() const OVERRIDE {
85    return std::string();
86  }
87};
88
89class TestInterstitialPageDelegate : public content::InterstitialPageDelegate {
90 public:
91  TestInterstitialPageDelegate() {
92  }
93  virtual ~TestInterstitialPageDelegate() {}
94  virtual std::string GetHTMLContents() OVERRIDE { return std::string(); }
95};
96
97class TestGuestViewManager : public GuestViewManager {
98 public:
99  explicit TestGuestViewManager(content::BrowserContext* context) :
100      GuestViewManager(context),
101      web_contents_(NULL) {}
102
103  content::WebContents* WaitForGuestCreated() {
104    if (web_contents_)
105      return web_contents_;
106
107    message_loop_runner_ = new content::MessageLoopRunner;
108    message_loop_runner_->Run();
109    return web_contents_;
110  }
111
112 private:
113  // GuestViewManager override:
114  virtual void AddGuest(int guest_instance_id,
115                        content::WebContents* guest_web_contents) OVERRIDE{
116    GuestViewManager::AddGuest(guest_instance_id, guest_web_contents);
117    web_contents_ = guest_web_contents;
118
119    if (message_loop_runner_)
120      message_loop_runner_->Quit();
121  }
122
123  content::WebContents* web_contents_;
124  scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
125};
126
127// Test factory for creating test instances of GuestViewManager.
128class TestGuestViewManagerFactory : public GuestViewManagerFactory {
129 public:
130  TestGuestViewManagerFactory() :
131      test_guest_view_manager_(NULL) {}
132
133  virtual ~TestGuestViewManagerFactory() {}
134
135  virtual GuestViewManager* CreateGuestViewManager(
136      content::BrowserContext* context) OVERRIDE {
137    return GetManager(context);
138  }
139
140  TestGuestViewManager* GetManager(content::BrowserContext* context) {
141    if (!test_guest_view_manager_) {
142      test_guest_view_manager_ = new TestGuestViewManager(context);
143    }
144    return test_guest_view_manager_;
145  }
146
147 private:
148  TestGuestViewManager* test_guest_view_manager_;
149
150  DISALLOW_COPY_AND_ASSIGN(TestGuestViewManagerFactory);
151};
152
153class WebContentsHiddenObserver : public content::WebContentsObserver {
154 public:
155  WebContentsHiddenObserver(content::WebContents* web_contents,
156                            const base::Closure& hidden_callback)
157      : WebContentsObserver(web_contents),
158        hidden_callback_(hidden_callback),
159        hidden_observed_(false) {
160  }
161
162  // WebContentsObserver.
163  virtual void WasHidden() OVERRIDE {
164    hidden_observed_ = true;
165    hidden_callback_.Run();
166  }
167
168  bool hidden_observed() { return hidden_observed_; }
169
170 private:
171  base::Closure hidden_callback_;
172  bool hidden_observed_;
173
174  DISALLOW_COPY_AND_ASSIGN(WebContentsHiddenObserver);
175};
176
177class InterstitialObserver : public content::WebContentsObserver {
178 public:
179  InterstitialObserver(content::WebContents* web_contents,
180                       const base::Closure& attach_callback,
181                       const base::Closure& detach_callback)
182      : WebContentsObserver(web_contents),
183        attach_callback_(attach_callback),
184        detach_callback_(detach_callback) {
185  }
186
187  virtual void DidAttachInterstitialPage() OVERRIDE {
188    attach_callback_.Run();
189  }
190
191  virtual void DidDetachInterstitialPage() OVERRIDE {
192    detach_callback_.Run();
193  }
194
195 private:
196  base::Closure attach_callback_;
197  base::Closure detach_callback_;
198
199  DISALLOW_COPY_AND_ASSIGN(InterstitialObserver);
200};
201
202void 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.
222class MockWebContentsDelegate : public content::WebContentsDelegate {
223 public:
224  MockWebContentsDelegate() : requested_(false) {}
225  virtual ~MockWebContentsDelegate() {}
226
227  virtual void RequestMediaAccessPermission(
228      content::WebContents* web_contents,
229      const content::MediaStreamRequest& request,
230      const content::MediaResponseCallback& callback) OVERRIDE {
231    requested_ = true;
232    if (message_loop_runner_.get())
233      message_loop_runner_->Quit();
234  }
235
236  void WaitForSetMediaPermission() {
237    if (requested_)
238      return;
239    message_loop_runner_ = new content::MessageLoopRunner;
240    message_loop_runner_->Run();
241  }
242
243 private:
244  bool requested_;
245  scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
246
247  DISALLOW_COPY_AND_ASSIGN(MockWebContentsDelegate);
248};
249
250// This class intercepts download request from the guest.
251class MockDownloadWebContentsDelegate : public content::WebContentsDelegate {
252 public:
253  explicit MockDownloadWebContentsDelegate(
254      content::WebContentsDelegate* orig_delegate)
255      : orig_delegate_(orig_delegate),
256        waiting_for_decision_(false),
257        expect_allow_(false),
258        decision_made_(false),
259        last_download_allowed_(false) {}
260  virtual ~MockDownloadWebContentsDelegate() {}
261
262  virtual void CanDownload(
263      content::RenderViewHost* render_view_host,
264      const GURL& url,
265      const std::string& request_method,
266      const base::Callback<void(bool)>& callback) OVERRIDE {
267    orig_delegate_->CanDownload(
268        render_view_host, url, request_method,
269        base::Bind(&MockDownloadWebContentsDelegate::DownloadDecided,
270                   base::Unretained(this)));
271  }
272
273  void WaitForCanDownload(bool expect_allow) {
274    EXPECT_FALSE(waiting_for_decision_);
275    waiting_for_decision_ = true;
276
277    if (decision_made_) {
278      EXPECT_EQ(expect_allow, last_download_allowed_);
279      return;
280    }
281
282    expect_allow_ = expect_allow;
283    message_loop_runner_ = new content::MessageLoopRunner;
284    message_loop_runner_->Run();
285  }
286
287  void DownloadDecided(bool allow) {
288    EXPECT_FALSE(decision_made_);
289    decision_made_ = true;
290
291    if (waiting_for_decision_) {
292      EXPECT_EQ(expect_allow_, allow);
293      if (message_loop_runner_.get())
294        message_loop_runner_->Quit();
295      return;
296    }
297    last_download_allowed_ = allow;
298  }
299
300  void Reset() {
301    waiting_for_decision_ = false;
302    decision_made_ = false;
303  }
304
305 private:
306  content::WebContentsDelegate* orig_delegate_;
307  bool waiting_for_decision_;
308  bool expect_allow_;
309  bool decision_made_;
310  bool last_download_allowed_;
311  scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
312
313  DISALLOW_COPY_AND_ASSIGN(MockDownloadWebContentsDelegate);
314};
315
316class WebViewTest : public extensions::PlatformAppBrowserTest {
317 protected:
318  virtual void SetUp() OVERRIDE {
319    if (UsesFakeSpeech()) {
320      // SpeechRecognition test specific SetUp.
321      fake_speech_recognition_manager_.reset(
322          new content::FakeSpeechRecognitionManager());
323      fake_speech_recognition_manager_->set_should_send_fake_response(true);
324      // Inject the fake manager factory so that the test result is returned to
325      // the web page.
326      content::SpeechRecognitionManager::SetManagerForTesting(
327          fake_speech_recognition_manager_.get());
328    }
329    extensions::PlatformAppBrowserTest::SetUp();
330  }
331
332  virtual void TearDown() OVERRIDE {
333    if (UsesFakeSpeech()) {
334      // SpeechRecognition test specific TearDown.
335      content::SpeechRecognitionManager::SetManagerForTesting(NULL);
336    }
337
338    extensions::PlatformAppBrowserTest::TearDown();
339  }
340
341  virtual void SetUpOnMainThread() OVERRIDE {
342    extensions::PlatformAppBrowserTest::SetUpOnMainThread();
343    const testing::TestInfo* const test_info =
344        testing::UnitTest::GetInstance()->current_test_info();
345    // Mock out geolocation for geolocation specific tests.
346    if (!strncmp(test_info->name(), "GeolocationAPI",
347            strlen("GeolocationAPI"))) {
348      ui_test_utils::OverrideGeolocation(10, 20);
349    }
350  }
351
352  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
353    command_line->AppendSwitch(switches::kUseFakeDeviceForMediaStream);
354    command_line->AppendSwitchASCII(switches::kJavaScriptFlags, "--expose-gc");
355
356    extensions::PlatformAppBrowserTest::SetUpCommandLine(command_line);
357  }
358
359  // This method is responsible for initializing a packaged app, which contains
360  // multiple webview tags. The tags have different partition identifiers and
361  // their WebContent objects are returned as output. The method also verifies
362  // the expected process allocation and storage partition assignment.
363  // The |navigate_to_url| parameter is used to navigate the main browser
364  // window.
365  //
366  // TODO(ajwong): This function is getting to be too large. Either refactor it
367  // so the test can specify a configuration of WebView tags that we will
368  // dynamically inject JS to generate, or move this test wholesale into
369  // something that RunPlatformAppTest() can execute purely in Javascript. This
370  // won't let us do a white-box examination of the StoragePartition equivalence
371  // directly, but we will be able to view the black box effects which is good
372  // enough.  http://crbug.com/160361
373  void NavigateAndOpenAppForIsolation(
374      GURL navigate_to_url,
375      content::WebContents** default_tag_contents1,
376      content::WebContents** default_tag_contents2,
377      content::WebContents** named_partition_contents1,
378      content::WebContents** named_partition_contents2,
379      content::WebContents** persistent_partition_contents1,
380      content::WebContents** persistent_partition_contents2,
381      content::WebContents** persistent_partition_contents3) {
382    GURL::Replacements replace_host;
383    std::string host_str("localhost");  // Must stay in scope with replace_host.
384    replace_host.SetHostStr(host_str);
385
386    navigate_to_url = navigate_to_url.ReplaceComponents(replace_host);
387
388    GURL tag_url1 = embedded_test_server()->GetURL(
389        "/extensions/platform_apps/web_view/isolation/cookie.html");
390    tag_url1 = tag_url1.ReplaceComponents(replace_host);
391    GURL tag_url2 = embedded_test_server()->GetURL(
392        "/extensions/platform_apps/web_view/isolation/cookie2.html");
393    tag_url2 = tag_url2.ReplaceComponents(replace_host);
394    GURL tag_url3 = embedded_test_server()->GetURL(
395        "/extensions/platform_apps/web_view/isolation/storage1.html");
396    tag_url3 = tag_url3.ReplaceComponents(replace_host);
397    GURL tag_url4 = embedded_test_server()->GetURL(
398        "/extensions/platform_apps/web_view/isolation/storage2.html");
399    tag_url4 = tag_url4.ReplaceComponents(replace_host);
400    GURL tag_url5 = embedded_test_server()->GetURL(
401        "/extensions/platform_apps/web_view/isolation/storage1.html#p1");
402    tag_url5 = tag_url5.ReplaceComponents(replace_host);
403    GURL tag_url6 = embedded_test_server()->GetURL(
404        "/extensions/platform_apps/web_view/isolation/storage1.html#p2");
405    tag_url6 = tag_url6.ReplaceComponents(replace_host);
406    GURL tag_url7 = embedded_test_server()->GetURL(
407        "/extensions/platform_apps/web_view/isolation/storage1.html#p3");
408    tag_url7 = tag_url7.ReplaceComponents(replace_host);
409
410    ui_test_utils::NavigateToURLWithDisposition(
411        browser(), navigate_to_url, CURRENT_TAB,
412        ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
413
414    ui_test_utils::UrlLoadObserver observer1(
415        tag_url1, content::NotificationService::AllSources());
416    ui_test_utils::UrlLoadObserver observer2(
417        tag_url2, content::NotificationService::AllSources());
418    ui_test_utils::UrlLoadObserver observer3(
419        tag_url3, content::NotificationService::AllSources());
420    ui_test_utils::UrlLoadObserver observer4(
421        tag_url4, content::NotificationService::AllSources());
422    ui_test_utils::UrlLoadObserver observer5(
423        tag_url5, content::NotificationService::AllSources());
424    ui_test_utils::UrlLoadObserver observer6(
425        tag_url6, content::NotificationService::AllSources());
426    ui_test_utils::UrlLoadObserver observer7(
427        tag_url7, content::NotificationService::AllSources());
428    LoadAndLaunchPlatformApp("web_view/isolation", "Launched");
429    observer1.Wait();
430    observer2.Wait();
431    observer3.Wait();
432    observer4.Wait();
433    observer5.Wait();
434    observer6.Wait();
435    observer7.Wait();
436
437    content::Source<content::NavigationController> source1 = observer1.source();
438    EXPECT_TRUE(source1->GetWebContents()->GetRenderProcessHost()->
439        IsIsolatedGuest());
440    content::Source<content::NavigationController> source2 = observer2.source();
441    EXPECT_TRUE(source2->GetWebContents()->GetRenderProcessHost()->
442        IsIsolatedGuest());
443    content::Source<content::NavigationController> source3 = observer3.source();
444    EXPECT_TRUE(source3->GetWebContents()->GetRenderProcessHost()->
445        IsIsolatedGuest());
446    content::Source<content::NavigationController> source4 = observer4.source();
447    EXPECT_TRUE(source4->GetWebContents()->GetRenderProcessHost()->
448        IsIsolatedGuest());
449    content::Source<content::NavigationController> source5 = observer5.source();
450    EXPECT_TRUE(source5->GetWebContents()->GetRenderProcessHost()->
451        IsIsolatedGuest());
452    content::Source<content::NavigationController> source6 = observer6.source();
453    EXPECT_TRUE(source6->GetWebContents()->GetRenderProcessHost()->
454        IsIsolatedGuest());
455    content::Source<content::NavigationController> source7 = observer7.source();
456    EXPECT_TRUE(source7->GetWebContents()->GetRenderProcessHost()->
457        IsIsolatedGuest());
458
459    // Check that the first two tags use the same process and it is different
460    // than the process used by the other two.
461    EXPECT_EQ(source1->GetWebContents()->GetRenderProcessHost()->GetID(),
462              source2->GetWebContents()->GetRenderProcessHost()->GetID());
463    EXPECT_EQ(source3->GetWebContents()->GetRenderProcessHost()->GetID(),
464              source4->GetWebContents()->GetRenderProcessHost()->GetID());
465    EXPECT_NE(source1->GetWebContents()->GetRenderProcessHost()->GetID(),
466              source3->GetWebContents()->GetRenderProcessHost()->GetID());
467
468    // The two sets of tags should also be isolated from the main browser.
469    EXPECT_NE(source1->GetWebContents()->GetRenderProcessHost()->GetID(),
470              browser()->tab_strip_model()->GetWebContentsAt(0)->
471                  GetRenderProcessHost()->GetID());
472    EXPECT_NE(source3->GetWebContents()->GetRenderProcessHost()->GetID(),
473              browser()->tab_strip_model()->GetWebContentsAt(0)->
474                  GetRenderProcessHost()->GetID());
475
476    // Check that the storage partitions of the first two tags match and are
477    // different than the other two.
478    EXPECT_EQ(
479        source1->GetWebContents()->GetRenderProcessHost()->
480            GetStoragePartition(),
481        source2->GetWebContents()->GetRenderProcessHost()->
482            GetStoragePartition());
483    EXPECT_EQ(
484        source3->GetWebContents()->GetRenderProcessHost()->
485            GetStoragePartition(),
486        source4->GetWebContents()->GetRenderProcessHost()->
487            GetStoragePartition());
488    EXPECT_NE(
489        source1->GetWebContents()->GetRenderProcessHost()->
490            GetStoragePartition(),
491        source3->GetWebContents()->GetRenderProcessHost()->
492            GetStoragePartition());
493
494    // Ensure the persistent storage partitions are different.
495    EXPECT_EQ(
496        source5->GetWebContents()->GetRenderProcessHost()->
497            GetStoragePartition(),
498        source6->GetWebContents()->GetRenderProcessHost()->
499            GetStoragePartition());
500    EXPECT_NE(
501        source5->GetWebContents()->GetRenderProcessHost()->
502            GetStoragePartition(),
503        source7->GetWebContents()->GetRenderProcessHost()->
504            GetStoragePartition());
505    EXPECT_NE(
506        source1->GetWebContents()->GetRenderProcessHost()->
507            GetStoragePartition(),
508        source5->GetWebContents()->GetRenderProcessHost()->
509            GetStoragePartition());
510    EXPECT_NE(
511        source1->GetWebContents()->GetRenderProcessHost()->
512            GetStoragePartition(),
513        source7->GetWebContents()->GetRenderProcessHost()->
514            GetStoragePartition());
515
516    *default_tag_contents1 = source1->GetWebContents();
517    *default_tag_contents2 = source2->GetWebContents();
518    *named_partition_contents1 = source3->GetWebContents();
519    *named_partition_contents2 = source4->GetWebContents();
520    if (persistent_partition_contents1) {
521      *persistent_partition_contents1 = source5->GetWebContents();
522    }
523    if (persistent_partition_contents2) {
524      *persistent_partition_contents2 = source6->GetWebContents();
525    }
526    if (persistent_partition_contents3) {
527      *persistent_partition_contents3 = source7->GetWebContents();
528    }
529  }
530
531  // Handles |request| by serving a redirect response.
532  static scoped_ptr<net::test_server::HttpResponse> RedirectResponseHandler(
533      const std::string& path,
534      const GURL& redirect_target,
535      const net::test_server::HttpRequest& request) {
536    if (!StartsWithASCII(path, request.relative_url, true))
537      return scoped_ptr<net::test_server::HttpResponse>();
538
539    scoped_ptr<net::test_server::BasicHttpResponse> http_response(
540        new net::test_server::BasicHttpResponse);
541    http_response->set_code(net::HTTP_MOVED_PERMANENTLY);
542    http_response->AddCustomHeader("Location", redirect_target.spec());
543    return http_response.PassAs<net::test_server::HttpResponse>();
544  }
545
546  // Handles |request| by serving an empty response.
547  static scoped_ptr<net::test_server::HttpResponse> EmptyResponseHandler(
548      const std::string& path,
549      const net::test_server::HttpRequest& request) {
550    if (StartsWithASCII(path, request.relative_url, true)) {
551      return scoped_ptr<net::test_server::HttpResponse>(
552          new EmptyHttpResponse);
553    }
554
555    return scoped_ptr<net::test_server::HttpResponse>();
556  }
557
558  // Shortcut to return the current MenuManager.
559  extensions::MenuManager* menu_manager() {
560    return extensions::MenuManager::Get(browser()->profile());
561  }
562
563  // This gets all the items that any extension has registered for possible
564  // inclusion in context menus.
565  MenuItem::List GetItems() {
566    MenuItem::List result;
567    std::set<MenuItem::ExtensionKey> extension_ids =
568        menu_manager()->ExtensionIds();
569    std::set<MenuItem::ExtensionKey>::iterator i;
570    for (i = extension_ids.begin(); i != extension_ids.end(); ++i) {
571      const MenuItem::List* list = menu_manager()->MenuItems(*i);
572      result.insert(result.end(), list->begin(), list->end());
573    }
574    return result;
575  }
576
577  enum TestServer {
578    NEEDS_TEST_SERVER,
579    NO_TEST_SERVER
580  };
581
582  void TestHelper(const std::string& test_name,
583                  const std::string& app_location,
584                  TestServer test_server) {
585    // For serving guest pages.
586    if (test_server == NEEDS_TEST_SERVER) {
587      if (!StartEmbeddedTestServer()) {
588        LOG(ERROR) << "FAILED TO START TEST SERVER.";
589        return;
590      }
591      embedded_test_server()->RegisterRequestHandler(
592          base::Bind(&WebViewTest::RedirectResponseHandler,
593                    kRedirectResponsePath,
594                    embedded_test_server()->GetURL(kRedirectResponseFullPath)));
595
596      embedded_test_server()->RegisterRequestHandler(
597          base::Bind(&WebViewTest::EmptyResponseHandler, kEmptyResponsePath));
598    }
599
600    LoadAndLaunchPlatformApp(app_location.c_str(), "Launched");
601
602    // Flush any pending events to make sure we start with a clean slate.
603    content::RunAllPendingInMessageLoop();
604
605    content::WebContents* embedder_web_contents =
606        GetFirstAppWindowWebContents();
607    if (!embedder_web_contents) {
608      LOG(ERROR) << "UNABLE TO FIND EMBEDDER WEB CONTENTS.";
609      return;
610    }
611
612    ExtensionTestMessageListener done_listener("TEST_PASSED", false);
613    done_listener.set_failure_message("TEST_FAILED");
614    if (!content::ExecuteScript(
615            embedder_web_contents,
616            base::StringPrintf("runTest('%s')", test_name.c_str()))) {
617      LOG(ERROR) << "UNABLE TO START TEST.";
618      return;
619    }
620    ASSERT_TRUE(done_listener.WaitUntilSatisfied());
621  }
622
623  content::WebContents* LoadGuest(const std::string& guest_path,
624                                  const std::string& app_path) {
625    GURL::Replacements replace_host;
626    std::string host_str("localhost");  // Must stay in scope with replace_host.
627    replace_host.SetHostStr(host_str);
628
629    GURL guest_url = embedded_test_server()->GetURL(guest_path);
630    guest_url = guest_url.ReplaceComponents(replace_host);
631
632    ui_test_utils::UrlLoadObserver guest_observer(
633        guest_url, content::NotificationService::AllSources());
634
635    LoadAndLaunchPlatformApp(app_path.c_str(), "guest-loaded");
636
637    guest_observer.Wait();
638    content::Source<content::NavigationController> source =
639        guest_observer.source();
640    EXPECT_TRUE(source->GetWebContents()->GetRenderProcessHost()->
641        IsIsolatedGuest());
642
643    content::WebContents* guest_web_contents = source->GetWebContents();
644    return guest_web_contents;
645  }
646
647  // Runs media_access/allow tests.
648  void MediaAccessAPIAllowTestHelper(const std::string& test_name);
649
650  // Runs media_access/deny tests, each of them are run separately otherwise
651  // they timeout (mostly on Windows).
652  void MediaAccessAPIDenyTestHelper(const std::string& test_name) {
653    ASSERT_TRUE(StartEmbeddedTestServer());  // For serving guest pages.
654    LoadAndLaunchPlatformApp("web_view/media_access/deny", "loaded");
655
656    content::WebContents* embedder_web_contents =
657        GetFirstAppWindowWebContents();
658    ASSERT_TRUE(embedder_web_contents);
659
660    ExtensionTestMessageListener test_run_listener("PASSED", false);
661    test_run_listener.set_failure_message("FAILED");
662    EXPECT_TRUE(
663        content::ExecuteScript(
664            embedder_web_contents,
665            base::StringPrintf("startDenyTest('%s')", test_name.c_str())));
666    ASSERT_TRUE(test_run_listener.WaitUntilSatisfied());
667  }
668
669  void WaitForInterstitial(content::WebContents* web_contents) {
670    scoped_refptr<content::MessageLoopRunner> loop_runner(
671        new content::MessageLoopRunner);
672    InterstitialObserver observer(web_contents,
673                                  loop_runner->QuitClosure(),
674                                  base::Closure());
675    if (!content::InterstitialPage::GetInterstitialPage(web_contents))
676      loop_runner->Run();
677  }
678
679  void LoadAppWithGuest(const std::string& app_path) {
680
681    ExtensionTestMessageListener launched_listener("WebViewTest.LAUNCHED",
682                                                   false);
683    launched_listener.set_failure_message("WebViewTest.FAILURE");
684    LoadAndLaunchPlatformApp(app_path.c_str(), &launched_listener);
685
686    guest_web_contents_ = GetGuestViewManager()->WaitForGuestCreated();
687  }
688
689  void SendMessageToEmbedder(const std::string& message) {
690    EXPECT_TRUE(
691        content::ExecuteScript(
692            GetEmbedderWebContents(),
693            base::StringPrintf("onAppCommand('%s');", message.c_str())));
694  }
695
696  void SendMessageToGuestAndWait(const std::string& message,
697                                 const std::string& wait_message) {
698    scoped_ptr<ExtensionTestMessageListener> listener;
699    if (!wait_message.empty()) {
700      listener.reset(new ExtensionTestMessageListener(wait_message, false));
701    }
702
703    EXPECT_TRUE(
704        content::ExecuteScript(
705            GetGuestWebContents(),
706            base::StringPrintf("onAppCommand('%s');", message.c_str())));
707
708    if (listener) {
709      ASSERT_TRUE(listener->WaitUntilSatisfied());
710    }
711  }
712
713  content::WebContents* GetGuestWebContents() {
714    return guest_web_contents_;
715  }
716
717  content::WebContents* GetEmbedderWebContents() {
718    if (!embedder_web_contents_) {
719      embedder_web_contents_ = GetFirstAppWindowWebContents();
720    }
721    return embedder_web_contents_;
722  }
723
724  TestGuestViewManager* GetGuestViewManager() {
725    return factory_.GetManager(browser()->profile());
726  }
727
728  WebViewTest() : guest_web_contents_(NULL),
729                  embedder_web_contents_(NULL) {
730    GuestViewManager::set_factory_for_testing(&factory_);
731  }
732
733 private:
734  bool UsesFakeSpeech() {
735    const testing::TestInfo* const test_info =
736        testing::UnitTest::GetInstance()->current_test_info();
737
738    // SpeechRecognition test specific SetUp.
739    return !strcmp(test_info->name(),
740                   "SpeechRecognitionAPI_HasPermissionAllow");
741  }
742
743  scoped_ptr<content::FakeSpeechRecognitionManager>
744      fake_speech_recognition_manager_;
745
746  TestGuestViewManagerFactory factory_;
747  // Note that these are only set if you launch app using LoadAppWithGuest().
748  content::WebContents* guest_web_contents_;
749  content::WebContents* embedder_web_contents_;
750};
751
752// This test verifies that hiding the guest triggers WebContents::WasHidden().
753IN_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.
768IN_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).
784IN_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
795IN_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.
825IN_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
832IN_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
844IN_PROC_BROWSER_TEST_F(WebViewTest, DISABLED_Shim_TestAutosizeAfterNavigation) {
845  TestHelper("testAutosizeAfterNavigation", "web_view/shim", NO_TEST_SERVER);
846}
847
848IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestAutosizeBeforeNavigation) {
849  TestHelper("testAutosizeBeforeNavigation", "web_view/shim", NO_TEST_SERVER);
850}
851IN_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
863IN_PROC_BROWSER_TEST_F(WebViewTest,
864                       MAYBE_Shim_TestAutosizeWithPartialAttributes) {
865  TestHelper("testAutosizeWithPartialAttributes",
866             "web_view/shim",
867             NO_TEST_SERVER);
868}
869
870IN_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.
876IN_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
886IN_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
898IN_PROC_BROWSER_TEST_F(WebViewTest,
899                       MAYBE_Shim_TestChromeExtensionRelativePath) {
900  TestHelper("testChromeExtensionRelativePath",
901             "web_view/shim",
902             NO_TEST_SERVER);
903}
904
905IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestDisplayNoneWebviewLoad) {
906  TestHelper("testDisplayNoneWebviewLoad", "web_view/shim", NO_TEST_SERVER);
907}
908
909IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestDisplayNoneWebviewRemoveChild) {
910  TestHelper("testDisplayNoneWebviewRemoveChild",
911             "web_view/shim", NO_TEST_SERVER);
912}
913
914IN_PROC_BROWSER_TEST_F(WebViewTest,
915                       Shim_TestInlineScriptFromAccessibleResources) {
916  TestHelper("testInlineScriptFromAccessibleResources",
917             "web_view/shim",
918             NO_TEST_SERVER);
919}
920
921IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestInvalidChromeExtensionURL) {
922  TestHelper("testInvalidChromeExtensionURL", "web_view/shim", NO_TEST_SERVER);
923}
924
925IN_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.
931IN_PROC_BROWSER_TEST_F(WebViewTest, DISABLED_Shim_TestOnEventProperty) {
932  TestHelper("testOnEventProperties", "web_view/shim", NO_TEST_SERVER);
933}
934
935IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadProgressEvent) {
936  TestHelper("testLoadProgressEvent", "web_view/shim", NO_TEST_SERVER);
937}
938
939IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestDestroyOnEventListener) {
940  TestHelper("testDestroyOnEventListener", "web_view/shim", NO_TEST_SERVER);
941}
942
943IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestCannotMutateEventName) {
944  TestHelper("testCannotMutateEventName", "web_view/shim", NO_TEST_SERVER);
945}
946
947IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestPartitionRaisesException) {
948  TestHelper("testPartitionRaisesException", "web_view/shim", NO_TEST_SERVER);
949}
950
951IN_PROC_BROWSER_TEST_F(WebViewTest,
952                       Shim_TestPartitionRemovalAfterNavigationFails) {
953  TestHelper("testPartitionRemovalAfterNavigationFails",
954             "web_view/shim",
955             NO_TEST_SERVER);
956}
957
958IN_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
968IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestExecuteScript) {
969  TestHelper("testExecuteScript", "web_view/shim", NO_TEST_SERVER);
970}
971
972IN_PROC_BROWSER_TEST_F(
973    WebViewTest,
974    Shim_TestExecuteScriptIsAbortedWhenWebViewSourceIsChanged) {
975  TestHelper("testExecuteScriptIsAbortedWhenWebViewSourceIsChanged",
976             "web_view/shim",
977             NO_TEST_SERVER);
978}
979
980IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestTerminateAfterExit) {
981  TestHelper("testTerminateAfterExit", "web_view/shim", NO_TEST_SERVER);
982}
983
984IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestAssignSrcAfterCrash) {
985  TestHelper("testAssignSrcAfterCrash", "web_view/shim", NO_TEST_SERVER);
986}
987
988IN_PROC_BROWSER_TEST_F(WebViewTest,
989                       Shim_TestNavOnConsecutiveSrcAttributeChanges) {
990  TestHelper("testNavOnConsecutiveSrcAttributeChanges",
991             "web_view/shim",
992             NO_TEST_SERVER);
993}
994
995IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNavOnSrcAttributeChange) {
996  TestHelper("testNavOnSrcAttributeChange", "web_view/shim", NO_TEST_SERVER);
997}
998
999IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNavigateAfterResize) {
1000  TestHelper("testNavigateAfterResize", "web_view/shim", NO_TEST_SERVER);
1001}
1002
1003IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestRemoveSrcAttribute) {
1004  TestHelper("testRemoveSrcAttribute", "web_view/shim", NO_TEST_SERVER);
1005}
1006
1007IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestReassignSrcAttribute) {
1008  TestHelper("testReassignSrcAttribute", "web_view/shim", NO_TEST_SERVER);
1009}
1010
1011IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNewWindow) {
1012  TestHelper("testNewWindow", "web_view/shim", NEEDS_TEST_SERVER);
1013}
1014
1015IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNewWindowTwoListeners) {
1016  TestHelper("testNewWindowTwoListeners", "web_view/shim", NEEDS_TEST_SERVER);
1017}
1018
1019IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNewWindowNoPreventDefault) {
1020  TestHelper("testNewWindowNoPreventDefault",
1021             "web_view/shim",
1022             NEEDS_TEST_SERVER);
1023}
1024
1025IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNewWindowNoReferrerLink) {
1026  TestHelper("testNewWindowNoReferrerLink", "web_view/shim", NEEDS_TEST_SERVER);
1027}
1028
1029IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestContentLoadEvent) {
1030  TestHelper("testContentLoadEvent", "web_view/shim", NO_TEST_SERVER);
1031}
1032
1033// http://crbug.com/326330
1034IN_PROC_BROWSER_TEST_F(WebViewTest,
1035                       Shim_TestDeclarativeWebRequestAPI) {
1036  TestHelper("testDeclarativeWebRequestAPI",
1037             "web_view/shim",
1038             NEEDS_TEST_SERVER);
1039}
1040
1041IN_PROC_BROWSER_TEST_F(WebViewTest,
1042                       Shim_TestDeclarativeWebRequestAPISendMessage) {
1043  TestHelper("testDeclarativeWebRequestAPISendMessage",
1044             "web_view/shim",
1045             NEEDS_TEST_SERVER);
1046}
1047
1048IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestWebRequestAPI) {
1049  TestHelper("testWebRequestAPI", "web_view/shim", NEEDS_TEST_SERVER);
1050}
1051
1052IN_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
1066IN_PROC_BROWSER_TEST_F(
1067    WebViewTest,
1068    MAYBE_Shim_TestWebRequestListenerSurvivesReparenting) {
1069  TestHelper("testWebRequestListenerSurvivesReparenting",
1070             "web_view/shim",
1071             NEEDS_TEST_SERVER);
1072}
1073
1074IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadStartLoadRedirect) {
1075  TestHelper("testLoadStartLoadRedirect", "web_view/shim", NEEDS_TEST_SERVER);
1076}
1077
1078IN_PROC_BROWSER_TEST_F(WebViewTest,
1079                       Shim_TestLoadAbortChromeExtensionURLWrongPartition) {
1080  TestHelper("testLoadAbortChromeExtensionURLWrongPartition",
1081             "web_view/shim",
1082             NO_TEST_SERVER);
1083}
1084
1085IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadAbortEmptyResponse) {
1086  TestHelper("testLoadAbortEmptyResponse", "web_view/shim", NEEDS_TEST_SERVER);
1087}
1088
1089IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadAbortIllegalChromeURL) {
1090  TestHelper("testLoadAbortIllegalChromeURL",
1091             "web_view/shim",
1092             NO_TEST_SERVER);
1093}
1094
1095IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadAbortIllegalFileURL) {
1096  TestHelper("testLoadAbortIllegalFileURL", "web_view/shim", NO_TEST_SERVER);
1097}
1098
1099IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadAbortIllegalJavaScriptURL) {
1100  TestHelper("testLoadAbortIllegalJavaScriptURL",
1101             "web_view/shim",
1102             NO_TEST_SERVER);
1103}
1104
1105IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadAbortInvalidNavigation) {
1106  TestHelper("testLoadAbortInvalidNavigation", "web_view/shim", NO_TEST_SERVER);
1107}
1108
1109IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestLoadAbortNonWebSafeScheme) {
1110  TestHelper("testLoadAbortNonWebSafeScheme", "web_view/shim", NO_TEST_SERVER);
1111}
1112
1113IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestReload) {
1114  TestHelper("testReload", "web_view/shim", NEEDS_TEST_SERVER);
1115}
1116
1117IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestGetProcessId) {
1118  TestHelper("testGetProcessId", "web_view/shim", NEEDS_TEST_SERVER);
1119}
1120
1121IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestHiddenBeforeNavigation) {
1122  TestHelper("testHiddenBeforeNavigation", "web_view/shim", NO_TEST_SERVER);
1123}
1124
1125IN_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.
1175IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestRemoveWebviewAfterNavigation) {
1176  TestHelper("testRemoveWebviewAfterNavigation",
1177             "web_view/shim",
1178             NO_TEST_SERVER);
1179}
1180
1181IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestNavigationToExternalProtocol) {
1182  TestHelper("testNavigationToExternalProtocol",
1183             "web_view/shim",
1184             NO_TEST_SERVER);
1185}
1186
1187IN_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
1201IN_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
1240IN_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.
1248IN_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.
1265IN_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.
1287IN_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.
1312IN_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.
1378IN_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.
1463IN_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.
1526IN_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.
1613IN_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
1700IN_PROC_BROWSER_TEST_F(WebViewTest, MAYBE_CloseOnLoadcommit) {
1701  LoadAndLaunchPlatformApp("web_view/close_on_loadcommit",
1702                           "done-close-on-loadcommit");
1703}
1704
1705IN_PROC_BROWSER_TEST_F(WebViewTest, MediaAccessAPIDeny_TestDeny) {
1706  MediaAccessAPIDenyTestHelper("testDeny");
1707}
1708
1709IN_PROC_BROWSER_TEST_F(WebViewTest,
1710                       MediaAccessAPIDeny_TestDenyThenAllowThrows) {
1711  MediaAccessAPIDenyTestHelper("testDenyThenAllowThrows");
1712
1713}
1714
1715IN_PROC_BROWSER_TEST_F(WebViewTest,
1716                       MediaAccessAPIDeny_TestDenyWithPreventDefault) {
1717  MediaAccessAPIDenyTestHelper("testDenyWithPreventDefault");
1718}
1719
1720IN_PROC_BROWSER_TEST_F(WebViewTest,
1721                       MediaAccessAPIDeny_TestNoListenersImplyDeny) {
1722  MediaAccessAPIDenyTestHelper("testNoListenersImplyDeny");
1723}
1724
1725IN_PROC_BROWSER_TEST_F(WebViewTest,
1726                       MediaAccessAPIDeny_TestNoPreventDefaultImpliesDeny) {
1727  MediaAccessAPIDenyTestHelper("testNoPreventDefaultImpliesDeny");
1728}
1729
1730void 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
1751IN_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
1804IN_PROC_BROWSER_TEST_F(WebViewTest, MediaAccessAPIAllow_TestAllow) {
1805  MediaAccessAPIAllowTestHelper("testAllow");
1806}
1807
1808IN_PROC_BROWSER_TEST_F(WebViewTest, MediaAccessAPIAllow_TestAllowAndThenDeny) {
1809  MediaAccessAPIAllowTestHelper("testAllowAndThenDeny");
1810}
1811
1812IN_PROC_BROWSER_TEST_F(WebViewTest, MediaAccessAPIAllow_TestAllowTwice) {
1813  MediaAccessAPIAllowTestHelper("testAllowTwice");
1814}
1815
1816IN_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.
1822IN_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)
1829IN_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
1854IN_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".
1872IN_PROC_BROWSER_TEST_F(WebViewTest, GeolocationAPIEmbedderHasNoAccessAllow) {
1873  TestHelper("testDenyDenies",
1874             "web_view/geolocation/embedder_has_no_permission",
1875             NEEDS_TEST_SERVER);
1876}
1877
1878IN_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.
1894IN_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.
1901IN_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.
1908IN_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).
1918IN_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
1924IN_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
1934IN_PROC_BROWSER_TEST_F(WebViewTest, FileSystemAPIRequestFromMainThreadAllow) {
1935  TestHelper("testAllow", "web_view/filesystem/main", NEEDS_TEST_SERVER);
1936}
1937
1938// FileSystemAPIRequestFromMainThread* test 2 of 3.
1939IN_PROC_BROWSER_TEST_F(WebViewTest, FileSystemAPIRequestFromMainThreadDeny) {
1940  TestHelper("testDeny", "web_view/filesystem/main", NEEDS_TEST_SERVER);
1941}
1942
1943// FileSystemAPIRequestFromMainThread* test 3 of 3.
1944IN_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
1952IN_PROC_BROWSER_TEST_F(WebViewTest, FileSystemAPIRequestFromWorkerAllow) {
1953  TestHelper("testAllow", "web_view/filesystem/worker", NEEDS_TEST_SERVER);
1954}
1955
1956// FileSystemAPIRequestFromWorker* test 2 of 3.
1957IN_PROC_BROWSER_TEST_F(WebViewTest, FileSystemAPIRequestFromWorkerDeny) {
1958  TestHelper("testDeny", "web_view/filesystem/worker", NEEDS_TEST_SERVER);
1959}
1960
1961// FileSystemAPIRequestFromWorker* test 3 of 3.
1962IN_PROC_BROWSER_TEST_F(WebViewTest,
1963                       FileSystemAPIRequestFromWorkerDefaultAllow) {
1964  TestHelper(
1965      "testDefaultAllow", "web_view/filesystem/worker", NEEDS_TEST_SERVER);
1966}
1967
1968// In following FilesystemAPIRequestFromSharedWorkerOfSingleWebViewGuest* tests,
1969// embedder contains a single webview guest. The guest creates a shared worker
1970// to request filesystem access from worker thread.
1971// FileSystemAPIRequestFromSharedWorkerOfSingleWebViewGuest* test 1 of 3
1972IN_PROC_BROWSER_TEST_F(
1973    WebViewTest,
1974    FileSystemAPIRequestFromSharedWorkerOfSingleWebViewGuestAllow) {
1975  TestHelper("testAllow",
1976             "web_view/filesystem/shared_worker/single",
1977             NEEDS_TEST_SERVER);
1978}
1979
1980// FileSystemAPIRequestFromSharedWorkerOfSingleWebViewGuest* test 2 of 3.
1981IN_PROC_BROWSER_TEST_F(
1982    WebViewTest,
1983    FileSystemAPIRequestFromSharedWorkerOfSingleWebViewGuestDeny) {
1984  TestHelper("testDeny",
1985             "web_view/filesystem/shared_worker/single",
1986             NEEDS_TEST_SERVER);
1987}
1988
1989// FileSystemAPIRequestFromSharedWorkerOfSingleWebViewGuest* test 3 of 3.
1990IN_PROC_BROWSER_TEST_F(
1991    WebViewTest,
1992    FileSystemAPIRequestFromSharedWorkerOfSingleWebViewGuestDefaultAllow) {
1993  TestHelper(
1994      "testDefaultAllow",
1995      "web_view/filesystem/shared_worker/single",
1996      NEEDS_TEST_SERVER);
1997}
1998
1999// In following FilesystemAPIRequestFromSharedWorkerOfMultiWebViewGuests* tests,
2000// embedder contains mutiple webview guests. Each guest creates a shared worker
2001// to request filesystem access from worker thread.
2002// FileSystemAPIRequestFromSharedWorkerOfMultiWebViewGuests* test 1 of 3
2003IN_PROC_BROWSER_TEST_F(
2004    WebViewTest,
2005    FileSystemAPIRequestFromSharedWorkerOfMultiWebViewGuestsAllow) {
2006  TestHelper("testAllow",
2007             "web_view/filesystem/shared_worker/multiple",
2008             NEEDS_TEST_SERVER);
2009}
2010
2011// FileSystemAPIRequestFromSharedWorkerOfMultiWebViewGuests* test 2 of 3.
2012IN_PROC_BROWSER_TEST_F(
2013    WebViewTest,
2014    FileSystemAPIRequestFromSharedWorkerOfMultiWebViewGuestsDeny) {
2015  TestHelper("testDeny",
2016             "web_view/filesystem/shared_worker/multiple",
2017             NEEDS_TEST_SERVER);
2018}
2019
2020// FileSystemAPIRequestFromSharedWorkerOfMultiWebViewGuests* test 3 of 3.
2021IN_PROC_BROWSER_TEST_F(
2022    WebViewTest,
2023    FileSystemAPIRequestFromSharedWorkerOfMultiWebViewGuestsDefaultAllow) {
2024  TestHelper(
2025      "testDefaultAllow",
2026      "web_view/filesystem/shared_worker/multiple",
2027      NEEDS_TEST_SERVER);
2028}
2029
2030IN_PROC_BROWSER_TEST_F(WebViewTest, ClearData) {
2031#if defined(OS_WIN)
2032  // Flaky on XP bot http://crbug.com/282674
2033  if (base::win::GetVersion() <= base::win::VERSION_XP)
2034    return;
2035#endif
2036
2037  ASSERT_TRUE(StartEmbeddedTestServer());  // For serving guest pages.
2038  ASSERT_TRUE(RunPlatformAppTestWithArg(
2039      "platform_apps/web_view/common", "cleardata"))
2040          << message_;
2041}
2042
2043// This test is disabled on Win due to being flaky. http://crbug.com/294592
2044#if defined(OS_WIN)
2045#define MAYBE_ConsoleMessage DISABLED_ConsoleMessage
2046#else
2047#define MAYBE_ConsoleMessage ConsoleMessage
2048#endif
2049IN_PROC_BROWSER_TEST_F(WebViewTest, MAYBE_ConsoleMessage) {
2050  ASSERT_TRUE(RunPlatformAppTestWithArg(
2051      "platform_apps/web_view/common", "console_messages"))
2052          << message_;
2053}
2054
2055IN_PROC_BROWSER_TEST_F(WebViewTest, DownloadPermission) {
2056  ASSERT_TRUE(StartEmbeddedTestServer());  // For serving guest pages.
2057  content::WebContents* guest_web_contents =
2058      LoadGuest("/extensions/platform_apps/web_view/download/guest.html",
2059                "web_view/download");
2060  ASSERT_TRUE(guest_web_contents);
2061
2062  // Replace WebContentsDelegate with mock version so we can intercept download
2063  // requests.
2064  content::WebContentsDelegate* delegate = guest_web_contents->GetDelegate();
2065  scoped_ptr<MockDownloadWebContentsDelegate>
2066      mock_delegate(new MockDownloadWebContentsDelegate(delegate));
2067  guest_web_contents->SetDelegate(mock_delegate.get());
2068
2069  // Start test.
2070  // 1. Guest requests a download that its embedder denies.
2071  EXPECT_TRUE(content::ExecuteScript(guest_web_contents,
2072                                     "startDownload('download-link-1')"));
2073  mock_delegate->WaitForCanDownload(false); // Expect to not allow.
2074  mock_delegate->Reset();
2075
2076  // 2. Guest requests a download that its embedder allows.
2077  EXPECT_TRUE(content::ExecuteScript(guest_web_contents,
2078                                     "startDownload('download-link-2')"));
2079  mock_delegate->WaitForCanDownload(true); // Expect to allow.
2080  mock_delegate->Reset();
2081
2082  // 3. Guest requests a download that its embedder ignores, this implies deny.
2083  EXPECT_TRUE(content::ExecuteScript(guest_web_contents,
2084                                     "startDownload('download-link-3')"));
2085  mock_delegate->WaitForCanDownload(false); // Expect to not allow.
2086}
2087
2088// This test makes sure loading <webview> does not crash when there is an
2089// extension which has content script whitelisted/forced.
2090IN_PROC_BROWSER_TEST_F(WebViewTest, WhitelistedContentScript) {
2091  // Whitelist the extension for running content script we are going to load.
2092  extensions::ExtensionsClient::ScriptingWhitelist whitelist;
2093  const std::string extension_id = "imeongpbjoodlnmlakaldhlcmijmhpbb";
2094  whitelist.push_back(extension_id);
2095  extensions::ExtensionsClient::Get()->SetScriptingWhitelist(whitelist);
2096
2097  // Load the extension.
2098  const extensions::Extension* content_script_whitelisted_extension =
2099      LoadExtension(test_data_dir_.AppendASCII(
2100                        "platform_apps/web_view/extension_api/content_script"));
2101  ASSERT_TRUE(content_script_whitelisted_extension);
2102  ASSERT_EQ(extension_id, content_script_whitelisted_extension->id());
2103
2104  // Now load an app with <webview>.
2105  LoadAndLaunchPlatformApp("web_view/content_script_whitelisted",
2106                           "TEST_PASSED");
2107}
2108
2109IN_PROC_BROWSER_TEST_F(WebViewTest, SetPropertyOnDocumentReady) {
2110  ASSERT_TRUE(RunPlatformAppTest("platform_apps/web_view/document_ready"))
2111                  << message_;
2112}
2113
2114IN_PROC_BROWSER_TEST_F(WebViewTest, SetPropertyOnDocumentInteractive) {
2115  ASSERT_TRUE(RunPlatformAppTest("platform_apps/web_view/document_interactive"))
2116                  << message_;
2117}
2118
2119IN_PROC_BROWSER_TEST_F(WebViewTest, SpeechRecognitionAPI_HasPermissionAllow) {
2120  ASSERT_TRUE(
2121      RunPlatformAppTestWithArg("platform_apps/web_view/speech_recognition_api",
2122                                "allowTest"))
2123          << message_;
2124}
2125
2126IN_PROC_BROWSER_TEST_F(WebViewTest, SpeechRecognitionAPI_HasPermissionDeny) {
2127  ASSERT_TRUE(
2128      RunPlatformAppTestWithArg("platform_apps/web_view/speech_recognition_api",
2129                                "denyTest"))
2130          << message_;
2131}
2132
2133IN_PROC_BROWSER_TEST_F(WebViewTest, SpeechRecognitionAPI_NoPermission) {
2134  ASSERT_TRUE(
2135      RunPlatformAppTestWithArg("platform_apps/web_view/common",
2136                                "speech_recognition_api_no_permission"))
2137          << message_;
2138}
2139
2140// Tests overriding user agent.
2141IN_PROC_BROWSER_TEST_F(WebViewTest, UserAgent) {
2142  ASSERT_TRUE(RunPlatformAppTestWithArg(
2143              "platform_apps/web_view/common", "useragent")) << message_;
2144}
2145
2146IN_PROC_BROWSER_TEST_F(WebViewTest, UserAgent_NewWindow) {
2147  ASSERT_TRUE(RunPlatformAppTestWithArg(
2148              "platform_apps/web_view/common",
2149              "useragent_newwindow")) << message_;
2150}
2151
2152IN_PROC_BROWSER_TEST_F(WebViewTest, NoPermission) {
2153  ASSERT_TRUE(RunPlatformAppTest("platform_apps/web_view/nopermission"))
2154                  << message_;
2155}
2156
2157IN_PROC_BROWSER_TEST_F(WebViewTest, Dialog_TestAlertDialog) {
2158  TestHelper("testAlertDialog", "web_view/dialog", NO_TEST_SERVER);
2159}
2160
2161IN_PROC_BROWSER_TEST_F(WebViewTest, TestConfirmDialog) {
2162  TestHelper("testConfirmDialog", "web_view/dialog", NO_TEST_SERVER);
2163}
2164
2165IN_PROC_BROWSER_TEST_F(WebViewTest, Dialog_TestConfirmDialogCancel) {
2166  TestHelper("testConfirmDialogCancel", "web_view/dialog", NO_TEST_SERVER);
2167}
2168
2169IN_PROC_BROWSER_TEST_F(WebViewTest, Dialog_TestConfirmDialogDefaultCancel) {
2170  TestHelper("testConfirmDialogDefaultCancel",
2171             "web_view/dialog",
2172             NO_TEST_SERVER);
2173}
2174
2175IN_PROC_BROWSER_TEST_F(WebViewTest, Dialog_TestConfirmDialogDefaultGCCancel) {
2176  TestHelper("testConfirmDialogDefaultGCCancel",
2177             "web_view/dialog",
2178             NO_TEST_SERVER);
2179}
2180
2181IN_PROC_BROWSER_TEST_F(WebViewTest, Dialog_TestPromptDialog) {
2182  TestHelper("testPromptDialog", "web_view/dialog", NO_TEST_SERVER);
2183}
2184
2185IN_PROC_BROWSER_TEST_F(WebViewTest, NoContentSettingsAPI) {
2186  // Load the extension.
2187  const extensions::Extension* content_settings_extension =
2188      LoadExtension(
2189          test_data_dir_.AppendASCII(
2190              "platform_apps/web_view/extension_api/content_settings"));
2191  ASSERT_TRUE(content_settings_extension);
2192  TestHelper("testPostMessageCommChannel", "web_view/shim", NO_TEST_SERVER);
2193}
2194
2195#if defined(ENABLE_PLUGINS)
2196class WebViewPluginTest : public WebViewTest {
2197 protected:
2198  virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
2199    WebViewTest::SetUpCommandLine(command_line);
2200
2201    // Append the switch to register the pepper plugin.
2202    // library name = <out dir>/<test_name>.<library_extension>
2203    // MIME type = application/x-ppapi-<test_name>
2204    base::FilePath plugin_dir;
2205    EXPECT_TRUE(PathService::Get(base::DIR_MODULE, &plugin_dir));
2206
2207    base::FilePath plugin_lib = plugin_dir.Append(library_name);
2208    EXPECT_TRUE(base::PathExists(plugin_lib));
2209    base::FilePath::StringType pepper_plugin = plugin_lib.value();
2210    pepper_plugin.append(FILE_PATH_LITERAL(";application/x-ppapi-tests"));
2211    command_line->AppendSwitchNative(switches::kRegisterPepperPlugins,
2212                                     pepper_plugin);
2213  }
2214};
2215
2216IN_PROC_BROWSER_TEST_F(WebViewPluginTest, TestLoadPluginEvent) {
2217  TestHelper("testPluginLoadPermission", "web_view/shim", NO_TEST_SERVER);
2218}
2219#endif  // defined(ENABLE_PLUGINS)
2220
2221class WebViewCaptureTest : public WebViewTest {
2222 public:
2223  WebViewCaptureTest() {}
2224  virtual ~WebViewCaptureTest() {}
2225  virtual void SetUp() OVERRIDE {
2226    EnablePixelOutput();
2227    WebViewTest::SetUp();
2228  }
2229};
2230
2231IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestZoomAPI) {
2232  TestHelper("testZoomAPI", "web_view/shim", NO_TEST_SERVER);
2233}
2234
2235IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestFindAPI) {
2236  TestHelper("testFindAPI", "web_view/shim", NO_TEST_SERVER);
2237}
2238
2239IN_PROC_BROWSER_TEST_F(WebViewTest, Shim_TestFindAPI_findupdate) {
2240  TestHelper("testFindAPI_findupdate", "web_view/shim", NO_TEST_SERVER);
2241}
2242
2243// <webview> screenshot capture fails with ubercomp.
2244// See http://crbug.com/327035.
2245IN_PROC_BROWSER_TEST_F(WebViewCaptureTest,
2246                       DISABLED_Shim_ScreenshotCapture) {
2247  TestHelper("testScreenshotCapture", "web_view/shim", NO_TEST_SERVER);
2248}
2249