chrome/browser/apps/web_view_browsertest.cc

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