chrome/browser/prerender/prerender_browsertest.cc

   1 // Copyright (c) 2012 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 <deque>
   6 #include <vector>
   7
   8 #include "base/bind.h"
   9 #include "base/command_line.h"
  10 #include "base/files/file_path.h"
  11 #include "base/memory/ref_counted_memory.h"
  12 #include "base/memory/scoped_vector.h"
  13 #include "base/memory/weak_ptr.h"
  14 #include "base/path_service.h"
  15 #include "base/prefs/pref_service.h"
  16 #include "base/run_loop.h"
  17 #include "base/strings/string_util.h"
  18 #include "base/strings/stringprintf.h"
  19 #include "base/strings/utf_string_conversions.h"
  20 #include "base/test/histogram_tester.h"
  21 #include "base/test/test_timeouts.h"
  22 #include "base/values.h"
  23 #include "chrome/browser/browsing_data/browsing_data_helper.h"
  24 #include "chrome/browser/browsing_data/browsing_data_remover.h"
  25 #include "chrome/browser/browsing_data/browsing_data_remover_test_util.h"
  26 #include "chrome/browser/chrome_content_browser_client.h"
  27 #include "chrome/browser/chrome_notification_types.h"
  28 #include "chrome/browser/content_settings/host_content_settings_map.h"
  29 #include "chrome/browser/extensions/api/web_navigation/web_navigation_api.h"
  30 #include "chrome/browser/extensions/extension_apitest.h"
  31 #include "chrome/browser/external_protocol/external_protocol_handler.h"
  32 #include "chrome/browser/favicon/favicon_tab_helper.h"
  33 #include "chrome/browser/net/prediction_options.h"
  34 #include "chrome/browser/predictors/autocomplete_action_predictor.h"
  35 #include "chrome/browser/predictors/autocomplete_action_predictor_factory.h"
  36 #include "chrome/browser/prerender/prerender_contents.h"
  37 #include "chrome/browser/prerender/prerender_field_trial.h"
  38 #include "chrome/browser/prerender/prerender_handle.h"
  39 #include "chrome/browser/prerender/prerender_link_manager.h"
  40 #include "chrome/browser/prerender/prerender_link_manager_factory.h"
  41 #include "chrome/browser/prerender/prerender_manager.h"
  42 #include "chrome/browser/prerender/prerender_manager_factory.h"
  43 #include "chrome/browser/profiles/profile.h"
  44 #include "chrome/browser/profiles/profile_io_data.h"
  45 #include "chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.h"
  46 #include "chrome/browser/safe_browsing/database_manager.h"
  47 #include "chrome/browser/safe_browsing/safe_browsing_service.h"
  48 #include "chrome/browser/safe_browsing/safe_browsing_util.h"
  49 #include "chrome/browser/task_manager/task_manager.h"
  50 #include "chrome/browser/task_manager/task_manager_browsertest_util.h"
  51 #include "chrome/browser/ui/browser.h"
  52 #include "chrome/browser/ui/browser_commands.h"
  53 #include "chrome/browser/ui/browser_finder.h"
  54 #include "chrome/browser/ui/browser_navigator.h"
  55 #include "chrome/browser/ui/browser_window.h"
  56 #include "chrome/browser/ui/location_bar/location_bar.h"
  57 #include "chrome/browser/ui/omnibox/omnibox_edit_model.h"
  58 #include "chrome/browser/ui/omnibox/omnibox_popup_model.h"
  59 #include "chrome/browser/ui/omnibox/omnibox_view.h"
  60 #include "chrome/browser/ui/tabs/tab_strip_model.h"
  61 #include "chrome/browser/ui/tabs/tab_strip_model_observer.h"
  62 #include "chrome/common/chrome_paths.h"
  63 #include "chrome/common/chrome_switches.h"
  64 #include "chrome/common/extensions/extension_constants.h"
  65 #include "chrome/common/extensions/manifest_handlers/mime_types_handler.h"
  66 #include "chrome/common/pref_names.h"
  67 #include "chrome/grit/generated_resources.h"
  68 #include "chrome/test/base/in_process_browser_test.h"
  69 #include "chrome/test/base/test_switches.h"
  70 #include "chrome/test/base/ui_test_utils.h"
  71 #include "components/variations/entropy_provider.h"
  72 #include "components/variations/variations_associated_data.h"
  73 #include "content/public/browser/browser_message_filter.h"
  74 #include "content/public/browser/devtools_agent_host.h"
  75 #include "content/public/browser/navigation_controller.h"
  76 #include "content/public/browser/navigation_entry.h"
  77 #include "content/public/browser/notification_service.h"
  78 #include "content/public/browser/render_frame_host.h"
  79 #include "content/public/browser/render_process_host.h"
  80 #include "content/public/browser/render_view_host.h"
  81 #include "content/public/browser/site_instance.h"
  82 #include "content/public/browser/web_contents.h"
  83 #include "content/public/browser/web_contents_observer.h"
  84 #include "content/public/common/url_constants.h"
  85 #include "content/public/test/browser_test_utils.h"
  86 #include "content/public/test/test_navigation_observer.h"
  87 #include "content/public/test/test_utils.h"
  88 #include "extensions/common/extension_urls.h"
  89 #include "extensions/common/switches.h"
  90 #include "extensions/test/result_catcher.h"
  91 #include "net/base/escape.h"
  92 #include "net/cert/x509_certificate.h"
  93 #include "net/dns/mock_host_resolver.h"
  94 #include "net/ssl/client_cert_store.h"
  95 #include "net/ssl/ssl_cert_request_info.h"
  96 #include "net/test/url_request/url_request_mock_http_job.h"
  97 #include "net/url_request/url_request_context.h"
  98 #include "net/url_request/url_request_context_getter.h"
  99 #include "net/url_request/url_request_filter.h"
 100 #include "net/url_request/url_request_interceptor.h"
 101 #include "net/url_request/url_request_job.h"
 102 #include "ui/base/l10n/l10n_util.h"
 103 #include "url/gurl.h"
 104
 105 using chrome_browser_net::NetworkPredictionOptions;
 106 using content::BrowserThread;
 107 using content::DevToolsAgentHost;
 108 using content::NavigationController;
 109 using content::OpenURLParams;
 110 using content::Referrer;
 111 using content::RenderFrameHost;
 112 using content::RenderViewHost;
 113 using content::RenderWidgetHost;
 114 using content::TestNavigationObserver;
 115 using content::WebContents;
 116 using content::WebContentsObserver;
 117 using net::NetworkChangeNotifier;
 118 using task_manager::browsertest_util::WaitForTaskManagerRows;
 119
 120 // Prerender tests work as follows:
 121 //
 122 // A page with a prefetch link to the test page is loaded.  Once prerendered,
 123 // its Javascript function DidPrerenderPass() is called, which returns true if
 124 // the page behaves as expected when prerendered.
 125 //
 126 // The prerendered page is then displayed on a tab.  The Javascript function
 127 // DidDisplayPass() is called, and returns true if the page behaved as it
 128 // should while being displayed.
 129
 130 namespace prerender {
 131
 132 namespace {
 133
 134 class MockNetworkChangeNotifierWIFI : public NetworkChangeNotifier {
 135  public:
 136   virtual ConnectionType GetCurrentConnectionType() const override {
 137     return NetworkChangeNotifier::CONNECTION_WIFI;
 138   }
 139 };
 140
 141 class MockNetworkChangeNotifier4G : public NetworkChangeNotifier {
 142  public:
 143   virtual ConnectionType GetCurrentConnectionType() const override {
 144     return NetworkChangeNotifier::CONNECTION_4G;
 145   }
 146 };
 147
 148 // Constants used in the test HTML files.
 149 const char* kReadyTitle = "READY";
 150 const char* kPassTitle = "PASS";
 151
 152 std::string CreateClientRedirect(const std::string& dest_url) {
 153   const char* const kClientRedirectBase = "client-redirect?";
 154   return kClientRedirectBase + net::EscapeQueryParamValue(dest_url, false);
 155 }
 156
 157 std::string CreateServerRedirect(const std::string& dest_url) {
 158   const char* const kServerRedirectBase = "server-redirect?";
 159   return kServerRedirectBase + net::EscapeQueryParamValue(dest_url, false);
 160 }
 161
 162 // Clears the specified data using BrowsingDataRemover.
 163 void ClearBrowsingData(Browser* browser, int remove_mask) {
 164   BrowsingDataRemover* remover =
 165       BrowsingDataRemover::CreateForUnboundedRange(browser->profile());
 166   BrowsingDataRemoverCompletionObserver observer(remover);
 167   remover->Remove(remove_mask, BrowsingDataHelper::UNPROTECTED_WEB);
 168   observer.BlockUntilCompletion();
 169   // BrowsingDataRemover deletes itself.
 170 }
 171
 172 // Returns true if the prerender is expected to abort on its own, before
 173 // attempting to swap it.
 174 bool ShouldAbortPrerenderBeforeSwap(FinalStatus status) {
 175   switch (status) {
 176     case FINAL_STATUS_USED:
 177     case FINAL_STATUS_WINDOW_OPENER:
 178     case FINAL_STATUS_APP_TERMINATING:
 179     case FINAL_STATUS_PROFILE_DESTROYED:
 180     case FINAL_STATUS_CACHE_OR_HISTORY_CLEARED:
 181     // We'll crash the renderer after it's loaded.
 182     case FINAL_STATUS_RENDERER_CRASHED:
 183     case FINAL_STATUS_CANCELLED:
 184     case FINAL_STATUS_DEVTOOLS_ATTACHED:
 185     case FINAL_STATUS_PAGE_BEING_CAPTURED:
 186     case FINAL_STATUS_NAVIGATION_UNCOMMITTED:
 187     case FINAL_STATUS_WOULD_HAVE_BEEN_USED:
 188     case FINAL_STATUS_NON_EMPTY_BROWSING_INSTANCE:
 189       return false;
 190     default:
 191       return true;
 192   }
 193 }
 194
 195 // Convenience function to wait for a title. Handles the case when the
 196 // WebContents already has the expected title.
 197 void WaitForASCIITitle(WebContents* web_contents,
 198                        const char* expected_title_ascii) {
 199   base::string16 expected_title = base::ASCIIToUTF16(expected_title_ascii);
 200   if (web_contents->GetTitle() == expected_title)
 201     return;
 202   content::TitleWatcher title_watcher(web_contents, expected_title);
 203   EXPECT_EQ(expected_title, title_watcher.WaitAndGetTitle());
 204 }
 205
 206 // Waits for the destruction of a RenderProcessHost's IPC channel.
 207 // Used to make sure the PrerenderLinkManager's OnChannelClosed function has
 208 // been called, before checking its state.
 209 class ChannelDestructionWatcher {
 210  public:
 211   ChannelDestructionWatcher() : channel_destroyed_(false) {
 212   }
 213
 214   ~ChannelDestructionWatcher() {
 215   }
 216
 217   void WatchChannel(content::RenderProcessHost* host) {
 218     host->AddFilter(new DestructionMessageFilter(this));
 219   }
 220
 221   void WaitForChannelClose() {
 222     run_loop_.Run();
 223     EXPECT_TRUE(channel_destroyed_);
 224   }
 225
 226  private:
 227   // When destroyed, calls ChannelDestructionWatcher::OnChannelDestroyed.
 228   // Ignores all messages.
 229   class DestructionMessageFilter : public content::BrowserMessageFilter {
 230    public:
 231      explicit DestructionMessageFilter(ChannelDestructionWatcher* watcher)
 232          : BrowserMessageFilter(0),
 233            watcher_(watcher) {
 234     }
 235
 236    private:
 237     virtual ~DestructionMessageFilter() {
 238       content::BrowserThread::PostTask(
 239           content::BrowserThread::UI, FROM_HERE,
 240           base::Bind(&ChannelDestructionWatcher::OnChannelDestroyed,
 241                      base::Unretained(watcher_)));
 242     }
 243
 244     virtual bool OnMessageReceived(const IPC::Message& message) override {
 245       return false;
 246     }
 247
 248     ChannelDestructionWatcher* watcher_;
 249
 250     DISALLOW_COPY_AND_ASSIGN(DestructionMessageFilter);
 251   };
 252
 253   void OnChannelDestroyed() {
 254     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 255
 256     EXPECT_FALSE(channel_destroyed_);
 257     channel_destroyed_ = true;
 258     run_loop_.Quit();
 259   }
 260
 261   bool channel_destroyed_;
 262   base::RunLoop run_loop_;
 263
 264   DISALLOW_COPY_AND_ASSIGN(ChannelDestructionWatcher);
 265 };
 266
 267 // A navigation observer to wait on either a new load or a swap of a
 268 // WebContents. On swap, if the new WebContents is still loading, wait for that
 269 // load to complete as well. Note that the load must begin after the observer is
 270 // attached.
 271 class NavigationOrSwapObserver : public WebContentsObserver,
 272                                  public TabStripModelObserver {
 273  public:
 274   // Waits for either a new load or a swap of |tab_strip_model|'s active
 275   // WebContents.
 276   NavigationOrSwapObserver(TabStripModel* tab_strip_model,
 277                            WebContents* web_contents)
 278       : WebContentsObserver(web_contents),
 279         tab_strip_model_(tab_strip_model),
 280         did_start_loading_(false),
 281         number_of_loads_(1) {
 282     CHECK_NE(TabStripModel::kNoTab,
 283              tab_strip_model->GetIndexOfWebContents(web_contents));
 284     tab_strip_model_->AddObserver(this);
 285   }
 286
 287   // Waits for either |number_of_loads| loads or a swap of |tab_strip_model|'s
 288   // active WebContents.
 289   NavigationOrSwapObserver(TabStripModel* tab_strip_model,
 290                            WebContents* web_contents,
 291                            int number_of_loads)
 292       : WebContentsObserver(web_contents),
 293         tab_strip_model_(tab_strip_model),
 294         did_start_loading_(false),
 295         number_of_loads_(number_of_loads) {
 296     CHECK_NE(TabStripModel::kNoTab,
 297              tab_strip_model->GetIndexOfWebContents(web_contents));
 298     tab_strip_model_->AddObserver(this);
 299   }
 300
 301   virtual ~NavigationOrSwapObserver() {
 302     tab_strip_model_->RemoveObserver(this);
 303   }
 304
 305   void set_did_start_loading() {
 306     did_start_loading_ = true;
 307   }
 308
 309   void Wait() {
 310     loop_.Run();
 311   }
 312
 313   // WebContentsObserver implementation:
 314   virtual void DidStartLoading(RenderViewHost* render_view_host) override {
 315     did_start_loading_ = true;
 316   }
 317   virtual void DidStopLoading(RenderViewHost* render_view_host) override {
 318     if (!did_start_loading_)
 319       return;
 320     number_of_loads_--;
 321     if (number_of_loads_ == 0)
 322       loop_.Quit();
 323   }
 324
 325   // TabStripModelObserver implementation:
 326   virtual void TabReplacedAt(TabStripModel* tab_strip_model,
 327                              WebContents* old_contents,
 328                              WebContents* new_contents,
 329                              int index) override {
 330     if (old_contents != web_contents())
 331       return;
 332     // Switch to observing the new WebContents.
 333     Observe(new_contents);
 334     if (new_contents->IsLoading()) {
 335       // If the new WebContents is still loading, wait for it to complete. Only
 336       // one load post-swap is supported.
 337       did_start_loading_ = true;
 338       number_of_loads_ = 1;
 339     } else {
 340       loop_.Quit();
 341     }
 342   }
 343
 344  private:
 345   TabStripModel* tab_strip_model_;
 346   bool did_start_loading_;
 347   int number_of_loads_;
 348   base::RunLoop loop_;
 349 };
 350
 351 // Waits for a new tab to open and a navigation or swap in it.
 352 class NewTabNavigationOrSwapObserver {
 353  public:
 354   NewTabNavigationOrSwapObserver()
 355       : new_tab_observer_(
 356             chrome::NOTIFICATION_TAB_ADDED,
 357             base::Bind(&NewTabNavigationOrSwapObserver::OnTabAdded,
 358                        base::Unretained(this))) {
 359     // Watch for NOTIFICATION_TAB_ADDED. Add a callback so that the
 360     // NavigationOrSwapObserver can be attached synchronously and no events are
 361     // missed.
 362   }
 363
 364   void Wait() {
 365     new_tab_observer_.Wait();
 366     swap_observer_->Wait();
 367   }
 368
 369   bool OnTabAdded(const content::NotificationSource& source,
 370                   const content::NotificationDetails& details) {
 371     if (swap_observer_)
 372       return true;
 373     WebContents* new_tab = content::Details<WebContents>(details).ptr();
 374     // Get the TabStripModel. Assume this is attached to a Browser.
 375     TabStripModel* tab_strip_model =
 376         static_cast<Browser*>(new_tab->GetDelegate())->tab_strip_model();
 377     swap_observer_.reset(new NavigationOrSwapObserver(tab_strip_model,
 378                                                       new_tab));
 379     swap_observer_->set_did_start_loading();
 380     return true;
 381   }
 382
 383  private:
 384   content::WindowedNotificationObserver new_tab_observer_;
 385   scoped_ptr<NavigationOrSwapObserver> swap_observer_;
 386 };
 387
 388 // PrerenderContents that stops the UI message loop on DidStopLoading().
 389 class TestPrerenderContents : public PrerenderContents {
 390  public:
 391   TestPrerenderContents(
 392       PrerenderManager* prerender_manager,
 393       Profile* profile,
 394       const GURL& url,
 395       const content::Referrer& referrer,
 396       Origin origin,
 397       FinalStatus expected_final_status)
 398       : PrerenderContents(prerender_manager, profile, url,
 399                           referrer, origin, PrerenderManager::kNoExperiment),
 400         expected_final_status_(expected_final_status),
 401         new_render_view_host_(NULL),
 402         was_hidden_(false),
 403         was_shown_(false),
 404         should_be_shown_(expected_final_status == FINAL_STATUS_USED),
 405         skip_final_checks_(false) {
 406   }
 407
 408   virtual ~TestPrerenderContents() {
 409     if (skip_final_checks_)
 410       return;
 411
 412     if (expected_final_status_ == FINAL_STATUS_MAX) {
 413       EXPECT_EQ(MATCH_COMPLETE_REPLACEMENT, match_complete_status());
 414     } else {
 415       EXPECT_EQ(expected_final_status_, final_status()) <<
 416           " when testing URL " << prerender_url().path() <<
 417           " (Expected: " << NameFromFinalStatus(expected_final_status_) <<
 418           ", Actual: " << NameFromFinalStatus(final_status()) << ")";
 419     }
 420     // Prerendering RenderViewHosts should be hidden before the first
 421     // navigation, so this should be happen for every PrerenderContents for
 422     // which a RenderViewHost is created, regardless of whether or not it's
 423     // used.
 424     if (new_render_view_host_)
 425       EXPECT_TRUE(was_hidden_);
 426
 427     // A used PrerenderContents will only be destroyed when we swap out
 428     // WebContents, at the end of a navigation caused by a call to
 429     // NavigateToURLImpl().
 430     if (final_status() == FINAL_STATUS_USED)
 431       EXPECT_TRUE(new_render_view_host_);
 432
 433     EXPECT_EQ(should_be_shown_, was_shown_);
 434   }
 435
 436   virtual void RenderProcessGone(base::TerminationStatus status) override {
 437     // On quit, it's possible to end up here when render processes are closed
 438     // before the PrerenderManager is destroyed.  As a result, it's possible to
 439     // get either FINAL_STATUS_APP_TERMINATING or FINAL_STATUS_RENDERER_CRASHED
 440     // on quit.
 441     //
 442     // It's also possible for this to be called after we've been notified of
 443     // app termination, but before we've been deleted, which is why the second
 444     // check is needed.
 445     if (expected_final_status_ == FINAL_STATUS_APP_TERMINATING &&
 446         final_status() != expected_final_status_) {
 447       expected_final_status_ = FINAL_STATUS_RENDERER_CRASHED;
 448     }
 449
 450     PrerenderContents::RenderProcessGone(status);
 451   }
 452
 453   virtual bool CheckURL(const GURL& url) override {
 454     // Prevent FINAL_STATUS_UNSUPPORTED_SCHEME when navigating to about:crash in
 455     // the PrerenderRendererCrash test.
 456     if (url.spec() != content::kChromeUICrashURL)
 457       return PrerenderContents::CheckURL(url);
 458     return true;
 459   }
 460
 461   // For tests that open the prerender in a new background tab, the RenderView
 462   // will not have been made visible when the PrerenderContents is destroyed
 463   // even though it is used.
 464   void set_should_be_shown(bool value) { should_be_shown_ = value; }
 465
 466   // For tests which do not know whether the prerender will be used.
 467   void set_skip_final_checks(bool value) { skip_final_checks_ = value; }
 468
 469   FinalStatus expected_final_status() const { return expected_final_status_; }
 470
 471  private:
 472   virtual void OnRenderViewHostCreated(
 473       RenderViewHost* new_render_view_host) override {
 474     // Used to make sure the RenderViewHost is hidden and, if used,
 475     // subsequently shown.
 476     notification_registrar().Add(
 477         this,
 478         content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
 479         content::Source<RenderWidgetHost>(new_render_view_host));
 480
 481     new_render_view_host_ = new_render_view_host;
 482
 483     PrerenderContents::OnRenderViewHostCreated(new_render_view_host);
 484   }
 485
 486   virtual void Observe(int type,
 487                        const content::NotificationSource& source,
 488                        const content::NotificationDetails& details) override {
 489     if (type ==
 490         content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED) {
 491       EXPECT_EQ(new_render_view_host_,
 492                 content::Source<RenderWidgetHost>(source).ptr());
 493       bool is_visible = *content::Details<bool>(details).ptr();
 494
 495       if (!is_visible) {
 496         was_hidden_ = true;
 497       } else if (is_visible && was_hidden_) {
 498         // Once hidden, a prerendered RenderViewHost should only be shown after
 499         // being removed from the PrerenderContents for display.
 500         EXPECT_FALSE(GetRenderViewHost());
 501         was_shown_ = true;
 502       }
 503       return;
 504     }
 505     PrerenderContents::Observe(type, source, details);
 506   }
 507
 508   FinalStatus expected_final_status_;
 509
 510   // The RenderViewHost created for the prerender, if any.
 511   RenderViewHost* new_render_view_host_;
 512   // Set to true when the prerendering RenderWidget is hidden.
 513   bool was_hidden_;
 514   // Set to true when the prerendering RenderWidget is shown, after having been
 515   // hidden.
 516   bool was_shown_;
 517   // Expected final value of was_shown_.  Defaults to true for
 518   // FINAL_STATUS_USED, and false otherwise.
 519   bool should_be_shown_;
 520   // If true, |expected_final_status_| and other shutdown checks are skipped.
 521   bool skip_final_checks_;
 522 };
 523
 524 // A handle to a TestPrerenderContents whose lifetime is under the caller's
 525 // control. A PrerenderContents may be destroyed at any point. This allows
 526 // tracking the final status, etc.
 527 class TestPrerender : public PrerenderContents::Observer,
 528                       public base::SupportsWeakPtr<TestPrerender> {
 529  public:
 530   TestPrerender()
 531       : contents_(NULL),
 532         number_of_loads_(0),
 533         expected_number_of_loads_(0) {
 534   }
 535   virtual ~TestPrerender() {
 536     if (contents_)
 537       contents_->RemoveObserver(this);
 538   }
 539
 540   TestPrerenderContents* contents() const { return contents_; }
 541   int number_of_loads() const { return number_of_loads_; }
 542
 543   void WaitForCreate() { create_loop_.Run(); }
 544   void WaitForStart() { start_loop_.Run(); }
 545   void WaitForStop() { stop_loop_.Run(); }
 546
 547   // Waits for |number_of_loads()| to be at least |expected_number_of_loads| OR
 548   // for the prerender to stop running (just to avoid a timeout if the prerender
 549   // dies). Note: this does not assert equality on the number of loads; the
 550   // caller must do it instead.
 551   void WaitForLoads(int expected_number_of_loads) {
 552     DCHECK(!load_waiter_);
 553     DCHECK(!expected_number_of_loads_);
 554     if (number_of_loads_ < expected_number_of_loads) {
 555       load_waiter_.reset(new base::RunLoop);
 556       expected_number_of_loads_ = expected_number_of_loads;
 557       load_waiter_->Run();
 558       load_waiter_.reset();
 559       expected_number_of_loads_ = 0;
 560     }
 561     EXPECT_LE(expected_number_of_loads, number_of_loads_);
 562   }
 563
 564   void OnPrerenderCreated(TestPrerenderContents* contents) {
 565     DCHECK(!contents_);
 566     contents_ = contents;
 567     contents_->AddObserver(this);
 568     create_loop_.Quit();
 569   }
 570
 571   // PrerenderContents::Observer implementation:
 572   virtual void OnPrerenderStart(PrerenderContents* contents) override {
 573     start_loop_.Quit();
 574   }
 575
 576   virtual void OnPrerenderStopLoading(PrerenderContents* contents) override {
 577     number_of_loads_++;
 578     if (load_waiter_ && number_of_loads_ >= expected_number_of_loads_)
 579       load_waiter_->Quit();
 580   }
 581
 582   virtual void OnPrerenderStop(PrerenderContents* contents) override {
 583     DCHECK(contents_);
 584     contents_ = NULL;
 585     stop_loop_.Quit();
 586     // If there is a WaitForLoads call and it has yet to see the expected number
 587     // of loads, stop the loop so the test fails instead of timing out.
 588     if (load_waiter_)
 589       load_waiter_->Quit();
 590   }
 591
 592   virtual void OnPrerenderCreatedMatchCompleteReplacement(
 593       PrerenderContents* contents, PrerenderContents* replacement) override {
 594   }
 595
 596  private:
 597   TestPrerenderContents* contents_;
 598   int number_of_loads_;
 599
 600   int expected_number_of_loads_;
 601   scoped_ptr<base::RunLoop> load_waiter_;
 602
 603   base::RunLoop create_loop_;
 604   base::RunLoop start_loop_;
 605   base::RunLoop stop_loop_;
 606
 607   DISALLOW_COPY_AND_ASSIGN(TestPrerender);
 608 };
 609
 610 // PrerenderManager that uses TestPrerenderContents.
 611 class TestPrerenderContentsFactory : public PrerenderContents::Factory {
 612  public:
 613   TestPrerenderContentsFactory() {}
 614
 615   virtual ~TestPrerenderContentsFactory() {
 616     EXPECT_TRUE(expected_contents_queue_.empty());
 617   }
 618
 619   scoped_ptr<TestPrerender> ExpectPrerenderContents(FinalStatus final_status) {
 620     scoped_ptr<TestPrerender> handle(new TestPrerender());
 621     expected_contents_queue_.push_back(
 622         ExpectedContents(final_status, handle->AsWeakPtr()));
 623     return handle.Pass();
 624   }
 625
 626   virtual PrerenderContents* CreatePrerenderContents(
 627       PrerenderManager* prerender_manager,
 628       Profile* profile,
 629       const GURL& url,
 630       const content::Referrer& referrer,
 631       Origin origin,
 632       uint8 experiment_id) override {
 633     ExpectedContents expected;
 634     if (!expected_contents_queue_.empty()) {
 635       expected = expected_contents_queue_.front();
 636       expected_contents_queue_.pop_front();
 637     }
 638     VLOG(1) << "Creating prerender contents for " << url.path() <<
 639                " with expected final status " << expected.final_status;
 640     VLOG(1) << expected_contents_queue_.size() << " left in the queue.";
 641     TestPrerenderContents* contents =
 642         new TestPrerenderContents(prerender_manager,
 643                                   profile, url, referrer, origin,
 644                                   expected.final_status);
 645     if (expected.handle)
 646       expected.handle->OnPrerenderCreated(contents);
 647     return contents;
 648   }
 649
 650  private:
 651   struct ExpectedContents {
 652     ExpectedContents() : final_status(FINAL_STATUS_MAX) { }
 653     ExpectedContents(FinalStatus final_status,
 654                      const base::WeakPtr<TestPrerender>& handle)
 655         : final_status(final_status),
 656           handle(handle) {
 657     }
 658
 659     FinalStatus final_status;
 660     base::WeakPtr<TestPrerender> handle;
 661   };
 662
 663   std::deque<ExpectedContents> expected_contents_queue_;
 664 };
 665
 666 #if defined(FULL_SAFE_BROWSING)
 667 // A SafeBrowsingDatabaseManager implementation that returns a fixed result for
 668 // a given URL.
 669 class FakeSafeBrowsingDatabaseManager :  public SafeBrowsingDatabaseManager {
 670  public:
 671   explicit FakeSafeBrowsingDatabaseManager(SafeBrowsingService* service)
 672       : SafeBrowsingDatabaseManager(service),
 673         threat_type_(SB_THREAT_TYPE_SAFE) { }
 674
 675   // Called on the IO thread to check if the given url is safe or not.  If we
 676   // can synchronously determine that the url is safe, CheckUrl returns true.
 677   // Otherwise it returns false, and "client" is called asynchronously with the
 678   // result when it is ready.
 679   // Returns true, indicating a SAFE result, unless the URL is the fixed URL
 680   // specified by the user, and the user-specified result is not SAFE
 681   // (in which that result will be communicated back via a call into the
 682   // client, and false will be returned).
 683   // Overrides SafeBrowsingService::CheckBrowseUrl.
 684   virtual bool CheckBrowseUrl(const GURL& gurl, Client* client) override {
 685     if (gurl != url_ || threat_type_ == SB_THREAT_TYPE_SAFE)
 686       return true;
 687
 688     BrowserThread::PostTask(
 689         BrowserThread::IO, FROM_HERE,
 690         base::Bind(&FakeSafeBrowsingDatabaseManager::OnCheckBrowseURLDone,
 691                    this, gurl, client));
 692     return false;
 693   }
 694
 695   void SetThreatTypeForUrl(const GURL& url, SBThreatType threat_type) {
 696     url_ = url;
 697     threat_type_ = threat_type;
 698   }
 699
 700  private:
 701   virtual ~FakeSafeBrowsingDatabaseManager() {}
 702
 703   void OnCheckBrowseURLDone(const GURL& gurl, Client* client) {
 704     std::vector<SBThreatType> expected_threats;
 705     expected_threats.push_back(SB_THREAT_TYPE_URL_MALWARE);
 706     expected_threats.push_back(SB_THREAT_TYPE_URL_PHISHING);
 707     SafeBrowsingDatabaseManager::SafeBrowsingCheck sb_check(
 708         std::vector<GURL>(1, gurl),
 709         std::vector<SBFullHash>(),
 710         client,
 711         safe_browsing_util::MALWARE,
 712         expected_threats);
 713     sb_check.url_results[0] = threat_type_;
 714     client->OnSafeBrowsingResult(sb_check);
 715   }
 716
 717   GURL url_;
 718   SBThreatType threat_type_;
 719   DISALLOW_COPY_AND_ASSIGN(FakeSafeBrowsingDatabaseManager);
 720 };
 721
 722 class FakeSafeBrowsingService : public SafeBrowsingService {
 723  public:
 724   FakeSafeBrowsingService() { }
 725
 726   // Returned pointer has the same lifespan as the database_manager_ refcounted
 727   // object.
 728   FakeSafeBrowsingDatabaseManager* fake_database_manager() {
 729     return fake_database_manager_;
 730   }
 731
 732  protected:
 733   virtual ~FakeSafeBrowsingService() { }
 734
 735   virtual SafeBrowsingDatabaseManager* CreateDatabaseManager() override {
 736     fake_database_manager_ = new FakeSafeBrowsingDatabaseManager(this);
 737     return fake_database_manager_;
 738   }
 739
 740  private:
 741   FakeSafeBrowsingDatabaseManager* fake_database_manager_;
 742
 743   DISALLOW_COPY_AND_ASSIGN(FakeSafeBrowsingService);
 744 };
 745
 746 // Factory that creates FakeSafeBrowsingService instances.
 747 class TestSafeBrowsingServiceFactory : public SafeBrowsingServiceFactory {
 748  public:
 749   TestSafeBrowsingServiceFactory() :
 750       most_recent_service_(NULL) { }
 751   virtual ~TestSafeBrowsingServiceFactory() { }
 752
 753   virtual SafeBrowsingService* CreateSafeBrowsingService() override {
 754     most_recent_service_ =  new FakeSafeBrowsingService();
 755     return most_recent_service_;
 756   }
 757
 758   FakeSafeBrowsingService* most_recent_service() const {
 759     return most_recent_service_;
 760   }
 761
 762  private:
 763   FakeSafeBrowsingService* most_recent_service_;
 764 };
 765 #endif
 766
 767 class FakeDevToolsClient : public content::DevToolsAgentHostClient {
 768  public:
 769   FakeDevToolsClient() {}
 770   virtual ~FakeDevToolsClient() {}
 771   virtual void DispatchProtocolMessage(
 772       DevToolsAgentHost* agent_host, const std::string& message) override {}
 773   virtual void AgentHostClosed(
 774       DevToolsAgentHost* agent_host, bool replaced) override {}
 775 };
 776
 777 class RestorePrerenderMode {
 778  public:
 779   RestorePrerenderMode() : prev_mode_(PrerenderManager::GetMode()) {
 780   }
 781
 782   ~RestorePrerenderMode() { PrerenderManager::SetMode(prev_mode_); }
 783  private:
 784   PrerenderManager::PrerenderManagerMode prev_mode_;
 785 };
 786
 787 // URLRequestJob (and associated handler) which hangs.
 788 class HangingURLRequestJob : public net::URLRequestJob {
 789  public:
 790   HangingURLRequestJob(net::URLRequest* request,
 791                           net::NetworkDelegate* network_delegate)
 792       : net::URLRequestJob(request, network_delegate) {
 793   }
 794
 795   virtual void Start() override {}
 796
 797  private:
 798   virtual ~HangingURLRequestJob() {}
 799 };
 800
 801 class HangingFirstRequestInterceptor : public net::URLRequestInterceptor {
 802  public:
 803   HangingFirstRequestInterceptor(const base::FilePath& file,
 804                                  base::Closure callback)
 805       : file_(file),
 806         callback_(callback),
 807         first_run_(true) {
 808   }
 809   virtual ~HangingFirstRequestInterceptor() {}
 810
 811   virtual net::URLRequestJob* MaybeInterceptRequest(
 812       net::URLRequest* request,
 813       net::NetworkDelegate* network_delegate) const override {
 814     if (first_run_) {
 815       first_run_ = false;
 816       if (!callback_.is_null()) {
 817         BrowserThread::PostTask(
 818             BrowserThread::UI, FROM_HERE, callback_);
 819       }
 820       return new HangingURLRequestJob(request, network_delegate);
 821     }
 822     return new net::URLRequestMockHTTPJob(
 823         request,
 824         network_delegate,
 825         file_,
 826         BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
 827             base::SequencedWorkerPool::SKIP_ON_SHUTDOWN));
 828   }
 829
 830  private:
 831   base::FilePath file_;
 832   base::Closure callback_;
 833   mutable bool first_run_;
 834 };
 835
 836 // Makes |url| never respond on the first load, and then with the contents of
 837 // |file| afterwards. When the first load has been scheduled, runs |callback| on
 838 // the UI thread.
 839 void CreateHangingFirstRequestInterceptorOnIO(
 840     const GURL& url, const base::FilePath& file, base::Closure callback) {
 841   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 842   scoped_ptr<net::URLRequestInterceptor> never_respond_handler(
 843       new HangingFirstRequestInterceptor(file, callback));
 844   net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
 845       url, never_respond_handler.Pass());
 846 }
 847
 848 // Wrapper over URLRequestMockHTTPJob that exposes extra callbacks.
 849 class MockHTTPJob : public net::URLRequestMockHTTPJob {
 850  public:
 851   MockHTTPJob(net::URLRequest* request,
 852               net::NetworkDelegate* delegate,
 853               const base::FilePath& file)
 854       : net::URLRequestMockHTTPJob(
 855             request,
 856             delegate,
 857             file,
 858             BrowserThread::GetBlockingPool()->GetTaskRunnerWithShutdownBehavior(
 859                 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN)) {}
 860
 861   void set_start_callback(const base::Closure& start_callback) {
 862     start_callback_ = start_callback;
 863   }
 864
 865   virtual void Start() override {
 866     if (!start_callback_.is_null())
 867       start_callback_.Run();
 868     net::URLRequestMockHTTPJob::Start();
 869   }
 870
 871  private:
 872   virtual ~MockHTTPJob() {}
 873
 874   base::Closure start_callback_;
 875 };
 876
 877 // Dummy counter class to live on the UI thread for counting requests.
 878 class RequestCounter : public base::SupportsWeakPtr<RequestCounter> {
 879  public:
 880   RequestCounter() : count_(0), expected_count_(-1) {}
 881   int count() const { return count_; }
 882
 883   void RequestStarted() {
 884     count_++;
 885     if (loop_ && count_ == expected_count_)
 886       loop_->Quit();
 887   }
 888
 889   void WaitForCount(int expected_count) {
 890     ASSERT_TRUE(!loop_);
 891     ASSERT_EQ(-1, expected_count_);
 892     if (count_ < expected_count) {
 893       expected_count_ = expected_count;
 894       loop_.reset(new base::RunLoop);
 895       loop_->Run();
 896       expected_count_ = -1;
 897       loop_.reset();
 898     }
 899
 900     EXPECT_EQ(expected_count, count_);
 901   }
 902  private:
 903   int count_;
 904   int expected_count_;
 905   scoped_ptr<base::RunLoop> loop_;
 906 };
 907
 908 // Protocol handler which counts the number of requests that start.
 909 class CountingInterceptor : public net::URLRequestInterceptor {
 910  public:
 911   CountingInterceptor(const base::FilePath& file,
 912                       const base::WeakPtr<RequestCounter>& counter)
 913       : file_(file),
 914         counter_(counter),
 915         weak_factory_(this) {
 916   }
 917   virtual ~CountingInterceptor() {}
 918
 919   virtual net::URLRequestJob* MaybeInterceptRequest(
 920       net::URLRequest* request,
 921       net::NetworkDelegate* network_delegate) const override {
 922     MockHTTPJob* job = new MockHTTPJob(request, network_delegate, file_);
 923     job->set_start_callback(base::Bind(&CountingInterceptor::RequestStarted,
 924                                        weak_factory_.GetWeakPtr()));
 925     return job;
 926   }
 927
 928   void RequestStarted() {
 929     BrowserThread::PostTask(
 930         BrowserThread::UI, FROM_HERE,
 931         base::Bind(&RequestCounter::RequestStarted, counter_));
 932   }
 933
 934  private:
 935   base::FilePath file_;
 936   base::WeakPtr<RequestCounter> counter_;
 937   mutable base::WeakPtrFactory<CountingInterceptor> weak_factory_;
 938 };
 939
 940 // Makes |url| respond to requests with the contents of |file|, counting the
 941 // number that start in |counter|.
 942 void CreateCountingInterceptorOnIO(
 943     const GURL& url,
 944     const base::FilePath& file,
 945     const base::WeakPtr<RequestCounter>& counter) {
 946   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 947   scoped_ptr<net::URLRequestInterceptor> request_interceptor(
 948       new CountingInterceptor(file, counter));
 949   net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
 950       url, request_interceptor.Pass());
 951 }
 952
 953 // Makes |url| respond to requests with the contents of |file|.
 954 void CreateMockInterceptorOnIO(const GURL& url, const base::FilePath& file) {
 955   CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 956   net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
 957       url,
 958       net::URLRequestMockHTTPJob::CreateInterceptorForSingleFile(
 959           file, BrowserThread::GetBlockingPool()));
 960 }
 961
 962 // A ContentBrowserClient that cancels all prerenderers on OpenURL.
 963 class TestContentBrowserClient : public chrome::ChromeContentBrowserClient {
 964  public:
 965   TestContentBrowserClient() {}
 966   virtual ~TestContentBrowserClient() {}
 967
 968   // chrome::ChromeContentBrowserClient implementation.
 969   virtual bool ShouldAllowOpenURL(content::SiteInstance* site_instance,
 970                                   const GURL& url) override {
 971     PrerenderManagerFactory::GetForProfile(
 972         Profile::FromBrowserContext(site_instance->GetBrowserContext()))
 973         ->CancelAllPrerenders();
 974     return chrome::ChromeContentBrowserClient::ShouldAllowOpenURL(site_instance,
 975                                                                   url);
 976   }
 977
 978  private:
 979   DISALLOW_COPY_AND_ASSIGN(TestContentBrowserClient);
 980 };
 981
 982 // A ContentBrowserClient that forces cross-process navigations.
 983 class SwapProcessesContentBrowserClient
 984     : public chrome::ChromeContentBrowserClient {
 985  public:
 986   SwapProcessesContentBrowserClient() {}
 987   virtual ~SwapProcessesContentBrowserClient() {}
 988
 989   // chrome::ChromeContentBrowserClient implementation.
 990   virtual bool ShouldSwapProcessesForRedirect(
 991       content::ResourceContext* resource_context,
 992       const GURL& current_url,
 993       const GURL& new_url) override {
 994     return true;
 995   }
 996
 997  private:
 998   DISALLOW_COPY_AND_ASSIGN(SwapProcessesContentBrowserClient);
 999 };
1000
1001 // An ExternalProtocolHandler that blocks everything and asserts it never is
1002 // called.
1003 class NeverRunsExternalProtocolHandlerDelegate
1004     : public ExternalProtocolHandler::Delegate {
1005  public:
1006   // ExternalProtocolHandler::Delegate implementation.
1007   virtual ShellIntegration::DefaultProtocolClientWorker* CreateShellWorker(
1008       ShellIntegration::DefaultWebClientObserver* observer,
1009       const std::string& protocol) override {
1010     NOTREACHED();
1011     // This will crash, but it shouldn't get this far with BlockState::BLOCK
1012     // anyway.
1013     return NULL;
1014   }
1015   virtual ExternalProtocolHandler::BlockState GetBlockState(
1016       const std::string& scheme) override {
1017     // Block everything and fail the test.
1018     ADD_FAILURE();
1019     return ExternalProtocolHandler::BLOCK;
1020   }
1021   virtual void BlockRequest() override { }
1022   virtual void RunExternalProtocolDialog(const GURL& url,
1023                                          int render_process_host_id,
1024                                          int routing_id) override {
1025     NOTREACHED();
1026   }
1027   virtual void LaunchUrlWithoutSecurityCheck(const GURL& url) override {
1028     NOTREACHED();
1029   }
1030   virtual void FinishedProcessingCheck() override {
1031     NOTREACHED();
1032   }
1033 };
1034
1035 base::FilePath GetTestPath(const std::string& file_name) {
1036   return ui_test_utils::GetTestFilePath(
1037       base::FilePath(FILE_PATH_LITERAL("prerender")),
1038       base::FilePath().AppendASCII(file_name));
1039 }
1040
1041 }  // namespace
1042
1043 // Many of these tests are flaky. See http://crbug.com/249179
1044 class PrerenderBrowserTest : virtual public InProcessBrowserTest {
1045  public:
1046   PrerenderBrowserTest()
1047       : autostart_test_server_(true),
1048         prerender_contents_factory_(NULL),
1049 #if defined(FULL_SAFE_BROWSING)
1050         safe_browsing_factory_(new TestSafeBrowsingServiceFactory()),
1051 #endif
1052         call_javascript_(true),
1053         check_load_events_(true),
1054         loader_path_("files/prerender/prerender_loader.html"),
1055         explicitly_set_browser_(NULL) {}
1056
1057   virtual ~PrerenderBrowserTest() {}
1058
1059   content::SessionStorageNamespace* GetSessionStorageNamespace() const {
1060     WebContents* web_contents = GetActiveWebContents();
1061     if (!web_contents)
1062       return NULL;
1063     return web_contents->GetController().GetDefaultSessionStorageNamespace();
1064   }
1065
1066   virtual void SetUpInProcessBrowserTestFixture() override {
1067 #if defined(FULL_SAFE_BROWSING)
1068     SafeBrowsingService::RegisterFactory(safe_browsing_factory_.get());
1069 #endif
1070   }
1071
1072   virtual void TearDownInProcessBrowserTestFixture() override {
1073 #if defined(FULL_SAFE_BROWSING)
1074     SafeBrowsingService::RegisterFactory(NULL);
1075 #endif
1076   }
1077
1078   virtual void SetUpCommandLine(CommandLine* command_line) override {
1079     command_line->AppendSwitchASCII(switches::kPrerenderMode,
1080                                     switches::kPrerenderModeSwitchValueEnabled);
1081 #if defined(OS_MACOSX)
1082     // The plugins directory isn't read by default on the Mac, so it needs to be
1083     // explicitly registered.
1084     base::FilePath app_dir;
1085     PathService::Get(chrome::DIR_APP, &app_dir);
1086     command_line->AppendSwitchPath(
1087         switches::kExtraPluginDir,
1088         app_dir.Append(FILE_PATH_LITERAL("plugins")));
1089 #endif
1090     command_line->AppendSwitch(switches::kAlwaysAuthorizePlugins);
1091   }
1092
1093   void SetPreference(NetworkPredictionOptions value) {
1094     browser()->profile()->GetPrefs()->SetInteger(
1095         prefs::kNetworkPredictionOptions, value);
1096   }
1097
1098   void CreateTestFieldTrial(const std::string& name,
1099                             const std::string& group_name) {
1100     base::FieldTrial* trial = base::FieldTrialList::CreateFieldTrial(
1101         name, group_name);
1102     trial->group();
1103   }
1104
1105   // Verifies, for the current field trial, whether
1106   // ShouldDisableLocalPredictorDueToPreferencesAndNetwork produces the desired
1107   // output.
1108   void TestShouldDisableLocalPredictorPreferenceNetworkMatrix(
1109       bool preference_wifi_network_wifi,
1110       bool preference_wifi_network_4g,
1111       bool preference_always_network_wifi,
1112       bool preference_always_network_4g,
1113       bool preference_never_network_wifi,
1114       bool preference_never_network_4g) {
1115     Profile* profile = browser()->profile();
1116
1117     // Set real NetworkChangeNotifier singleton aside.
1118     scoped_ptr<NetworkChangeNotifier::DisableForTest> disable_for_test(
1119         new NetworkChangeNotifier::DisableForTest);
1120
1121     // Set preference to WIFI_ONLY: prefetch when not on cellular.
1122     SetPreference(NetworkPredictionOptions::NETWORK_PREDICTION_WIFI_ONLY);
1123     {
1124       scoped_ptr<NetworkChangeNotifier> mock(new MockNetworkChangeNotifierWIFI);
1125       EXPECT_EQ(
1126           ShouldDisableLocalPredictorDueToPreferencesAndNetwork(profile),
1127           preference_wifi_network_wifi);
1128     }
1129     {
1130       scoped_ptr<NetworkChangeNotifier> mock(new MockNetworkChangeNotifier4G);
1131       EXPECT_EQ(
1132           ShouldDisableLocalPredictorDueToPreferencesAndNetwork(profile),
1133           preference_wifi_network_4g);
1134     }
1135
1136     // Set preference to ALWAYS: always prefetch.
1137     SetPreference(NetworkPredictionOptions::NETWORK_PREDICTION_ALWAYS);
1138     {
1139       scoped_ptr<NetworkChangeNotifier> mock(new MockNetworkChangeNotifierWIFI);
1140       EXPECT_EQ(
1141           ShouldDisableLocalPredictorDueToPreferencesAndNetwork(profile),
1142           preference_always_network_wifi);
1143     }
1144     {
1145       scoped_ptr<NetworkChangeNotifier> mock(new MockNetworkChangeNotifier4G);
1146       EXPECT_EQ(
1147           ShouldDisableLocalPredictorDueToPreferencesAndNetwork(profile),
1148           preference_always_network_4g);
1149     }
1150
1151     // Set preference to NEVER: never prefetch.
1152     SetPreference(NetworkPredictionOptions::NETWORK_PREDICTION_NEVER);
1153     {
1154       scoped_ptr<NetworkChangeNotifier> mock(new MockNetworkChangeNotifierWIFI);
1155       EXPECT_EQ(
1156           ShouldDisableLocalPredictorDueToPreferencesAndNetwork(profile),
1157           preference_never_network_wifi);
1158     }
1159     {
1160       scoped_ptr<NetworkChangeNotifier> mock(new MockNetworkChangeNotifier4G);
1161       EXPECT_EQ(
1162           ShouldDisableLocalPredictorDueToPreferencesAndNetwork(profile),
1163           preference_never_network_4g);
1164     }
1165   }
1166
1167   virtual void SetUpOnMainThread() override {
1168     current_browser()->profile()->GetPrefs()->SetBoolean(
1169         prefs::kPromptForDownload, false);
1170     IncreasePrerenderMemory();
1171     if (autostart_test_server_)
1172       ASSERT_TRUE(test_server()->Start());
1173     ChromeResourceDispatcherHostDelegate::
1174         SetExternalProtocolHandlerDelegateForTesting(
1175             &external_protocol_handler_delegate_);
1176
1177     PrerenderManager* prerender_manager = GetPrerenderManager();
1178     ASSERT_TRUE(prerender_manager);
1179     prerender_manager->mutable_config().rate_limit_enabled = false;
1180     ASSERT_TRUE(prerender_contents_factory_ == NULL);
1181     prerender_contents_factory_ = new TestPrerenderContentsFactory;
1182     prerender_manager->SetPrerenderContentsFactory(prerender_contents_factory_);
1183   }
1184
1185   // Convenience function to get the currently active WebContents in
1186   // current_browser().
1187   WebContents* GetActiveWebContents() const {
1188     return current_browser()->tab_strip_model()->GetActiveWebContents();
1189   }
1190
1191   // Overload for a single expected final status
1192   scoped_ptr<TestPrerender> PrerenderTestURL(
1193       const std::string& html_file,
1194       FinalStatus expected_final_status,
1195       int expected_number_of_loads) {
1196     GURL url = test_server()->GetURL(html_file);
1197     return PrerenderTestURL(url,
1198                             expected_final_status,
1199                             expected_number_of_loads);
1200   }
1201
1202   ScopedVector<TestPrerender> PrerenderTestURL(
1203       const std::string& html_file,
1204       const std::vector<FinalStatus>& expected_final_status_queue,
1205       int expected_number_of_loads) {
1206     GURL url = test_server()->GetURL(html_file);
1207     return PrerenderTestURLImpl(url,
1208                                 expected_final_status_queue,
1209                                 expected_number_of_loads);
1210   }
1211
1212   scoped_ptr<TestPrerender> PrerenderTestURL(
1213       const GURL& url,
1214       FinalStatus expected_final_status,
1215       int expected_number_of_loads) {
1216     std::vector<FinalStatus> expected_final_status_queue(
1217         1, expected_final_status);
1218     std::vector<TestPrerender*> prerenders;
1219     PrerenderTestURLImpl(url,
1220                          expected_final_status_queue,
1221                          expected_number_of_loads).release(&prerenders);
1222     CHECK_EQ(1u, prerenders.size());
1223     return scoped_ptr<TestPrerender>(prerenders[0]);
1224   }
1225
1226   // Navigates to a URL, unrelated to prerendering
1227   void NavigateStraightToURL(const std::string dest_html_file) {
1228     ui_test_utils::NavigateToURL(current_browser(),
1229                                  test_server()->GetURL(dest_html_file));
1230   }
1231
1232   void NavigateToDestURL() const {
1233     NavigateToDestURLWithDisposition(CURRENT_TAB, true);
1234   }
1235
1236   // Opens the url in a new tab, with no opener.
1237   void NavigateToDestURLWithDisposition(
1238       WindowOpenDisposition disposition,
1239       bool expect_swap_to_succeed) const {
1240     NavigateToURLWithParams(
1241         content::OpenURLParams(dest_url_, Referrer(), disposition,
1242                                ui::PAGE_TRANSITION_TYPED, false),
1243         expect_swap_to_succeed);
1244   }
1245
1246   void NavigateToURL(const std::string& dest_html_file) const {
1247     NavigateToURLWithDisposition(dest_html_file, CURRENT_TAB, true);
1248   }
1249
1250   void NavigateToURLWithDisposition(const std::string& dest_html_file,
1251                                     WindowOpenDisposition disposition,
1252                                     bool expect_swap_to_succeed) const {
1253     GURL dest_url = test_server()->GetURL(dest_html_file);
1254     NavigateToURLWithDisposition(dest_url, disposition, expect_swap_to_succeed);
1255   }
1256
1257   void NavigateToURLWithDisposition(const GURL& dest_url,
1258                                     WindowOpenDisposition disposition,
1259                                     bool expect_swap_to_succeed) const {
1260     NavigateToURLWithParams(
1261         content::OpenURLParams(dest_url, Referrer(), disposition,
1262                                ui::PAGE_TRANSITION_TYPED, false),
1263         expect_swap_to_succeed);
1264   }
1265
1266   void NavigateToURLWithParams(const content::OpenURLParams& params,
1267                                bool expect_swap_to_succeed) const {
1268     NavigateToURLImpl(params, expect_swap_to_succeed);
1269   }
1270
1271   void OpenDestURLViaClick() const {
1272     OpenURLViaClick(dest_url_);
1273   }
1274
1275   void OpenURLViaClick(const GURL& url) const {
1276     OpenURLWithJSImpl("Click", url, GURL(), false);
1277   }
1278
1279   void OpenDestURLViaClickTarget() const {
1280     OpenURLWithJSImpl("ClickTarget", dest_url_, GURL(), true);
1281   }
1282
1283   void OpenDestURLViaClickPing(const GURL& ping_url) const {
1284     OpenURLWithJSImpl("ClickPing", dest_url_, ping_url, false);
1285   }
1286
1287   void OpenDestURLViaClickNewWindow() const {
1288     OpenURLWithJSImpl("ShiftClick", dest_url_, GURL(), true);
1289   }
1290
1291   void OpenDestURLViaClickNewForegroundTab() const {
1292 #if defined(OS_MACOSX)
1293     OpenURLWithJSImpl("MetaShiftClick", dest_url_, GURL(), true);
1294 #else
1295     OpenURLWithJSImpl("CtrlShiftClick", dest_url_, GURL(), true);
1296 #endif
1297   }
1298
1299   void OpenDestURLViaClickNewBackgroundTab() const {
1300 #if defined(OS_MACOSX)
1301     OpenURLWithJSImpl("MetaClick", dest_url_, GURL(), true);
1302 #else
1303     OpenURLWithJSImpl("CtrlClick", dest_url_, GURL(), true);
1304 #endif
1305   }
1306
1307   void OpenDestURLViaWindowOpen() const {
1308     OpenURLViaWindowOpen(dest_url_);
1309   }
1310
1311   void OpenURLViaWindowOpen(const GURL& url) const {
1312     OpenURLWithJSImpl("WindowOpen", url, GURL(), true);
1313   }
1314
1315   void RemoveLinkElement(int i) const {
1316     GetActiveWebContents()->GetMainFrame()->ExecuteJavaScript(
1317         base::ASCIIToUTF16(base::StringPrintf("RemoveLinkElement(%d)", i)));
1318   }
1319
1320   void ClickToNextPageAfterPrerender() {
1321     TestNavigationObserver nav_observer(GetActiveWebContents());
1322     RenderFrameHost* render_frame_host = GetActiveWebContents()->GetMainFrame();
1323     render_frame_host->ExecuteJavaScript(base::ASCIIToUTF16("ClickOpenLink()"));
1324     nav_observer.Wait();
1325   }
1326
1327   void NavigateToNextPageAfterPrerender() const {
1328     ui_test_utils::NavigateToURL(
1329         current_browser(),
1330         test_server()->GetURL("files/prerender/prerender_page.html"));
1331   }
1332
1333   // Called after the prerendered page has been navigated to and then away from.
1334   // Navigates back through the history to the prerendered page.
1335   void GoBackToPrerender() {
1336     TestNavigationObserver back_nav_observer(GetActiveWebContents());
1337     chrome::GoBack(current_browser(), CURRENT_TAB);
1338     back_nav_observer.Wait();
1339     bool original_prerender_page = false;
1340     ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
1341         GetActiveWebContents(),
1342         "window.domAutomationController.send(IsOriginalPrerenderPage())",
1343         &original_prerender_page));
1344     EXPECT_TRUE(original_prerender_page);
1345   }
1346
1347   // Goes back to the page that was active before the prerender was swapped
1348   // in. This must be called when the prerendered page is the current page
1349   // in the active tab.
1350   void GoBackToPageBeforePrerender() {
1351     WebContents* tab = GetActiveWebContents();
1352     ASSERT_TRUE(tab);
1353     EXPECT_FALSE(tab->IsLoading());
1354     TestNavigationObserver back_nav_observer(tab);
1355     chrome::GoBack(current_browser(), CURRENT_TAB);
1356     back_nav_observer.Wait();
1357     bool js_result;
1358     ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
1359         tab,
1360         "window.domAutomationController.send(DidBackToOriginalPagePass())",
1361         &js_result));
1362     EXPECT_TRUE(js_result);
1363   }
1364
1365   bool UrlIsInPrerenderManager(const std::string& html_file) const {
1366     return UrlIsInPrerenderManager(test_server()->GetURL(html_file));
1367   }
1368
1369   bool UrlIsInPrerenderManager(const GURL& url) const {
1370     return GetPrerenderManager()->FindPrerenderData(
1371         url, GetSessionStorageNamespace()) != NULL;
1372   }
1373
1374   void UseHttpsSrcServer() {
1375     if (https_src_server_)
1376       return;
1377     https_src_server_.reset(
1378         new net::SpawnedTestServer(
1379             net::SpawnedTestServer::TYPE_HTTPS,
1380             net::SpawnedTestServer::kLocalhost,
1381             base::FilePath(FILE_PATH_LITERAL("chrome/test/data"))));
1382     CHECK(https_src_server_->Start());
1383   }
1384
1385   void DisableJavascriptCalls() {
1386     call_javascript_ = false;
1387   }
1388
1389   void DisableLoadEventCheck() {
1390     check_load_events_ = false;
1391   }
1392
1393   TaskManagerModel* GetModel() const {
1394     return TaskManager::GetInstance()->model();
1395   }
1396
1397   PrerenderManager* GetPrerenderManager() const {
1398     PrerenderManager* prerender_manager =
1399         PrerenderManagerFactory::GetForProfile(current_browser()->profile());
1400     return prerender_manager;
1401   }
1402
1403   const PrerenderLinkManager* GetPrerenderLinkManager() const {
1404     PrerenderLinkManager* prerender_link_manager =
1405         PrerenderLinkManagerFactory::GetForProfile(
1406             current_browser()->profile());
1407     return prerender_link_manager;
1408   }
1409
1410   int GetPrerenderEventCount(int index, const std::string& type) const {
1411     int event_count;
1412     std::string expression = base::StringPrintf(
1413         "window.domAutomationController.send("
1414         "    GetPrerenderEventCount(%d, '%s'))", index, type.c_str());
1415
1416     CHECK(content::ExecuteScriptAndExtractInt(
1417         GetActiveWebContents(), expression, &event_count));
1418     return event_count;
1419   }
1420
1421   bool DidReceivePrerenderStartEventForLinkNumber(int index) const {
1422     return GetPrerenderEventCount(index, "webkitprerenderstart") > 0;
1423   }
1424
1425   int GetPrerenderLoadEventCountForLinkNumber(int index) const {
1426     return GetPrerenderEventCount(index, "webkitprerenderload");
1427   }
1428
1429   int GetPrerenderDomContentLoadedEventCountForLinkNumber(int index) const {
1430     return GetPrerenderEventCount(index, "webkitprerenderdomcontentloaded");
1431   }
1432
1433   bool DidReceivePrerenderStopEventForLinkNumber(int index) const {
1434     return GetPrerenderEventCount(index, "webkitprerenderstop") > 0;
1435   }
1436
1437   void WaitForPrerenderEventCount(int index,
1438                                   const std::string& type,
1439                                   int count) const {
1440     int dummy;
1441     std::string expression = base::StringPrintf(
1442         "WaitForPrerenderEventCount(%d, '%s', %d,"
1443         "    window.domAutomationController.send.bind("
1444         "        window.domAutomationController, 0))",
1445         index, type.c_str(), count);
1446
1447     CHECK(content::ExecuteScriptAndExtractInt(
1448         GetActiveWebContents(), expression, &dummy));
1449     CHECK_EQ(0, dummy);
1450   }
1451
1452   bool HadPrerenderEventErrors() const {
1453     bool had_prerender_event_errors;
1454     CHECK(content::ExecuteScriptAndExtractBool(
1455         GetActiveWebContents(),
1456         "window.domAutomationController.send(Boolean("
1457         "    hadPrerenderEventErrors))",
1458         &had_prerender_event_errors));
1459     return had_prerender_event_errors;
1460   }
1461
1462   // Asserting on this can result in flaky tests.  PrerenderHandles are
1463   // removed from the PrerenderLinkManager when the prerender is canceled from
1464   // the browser, when the prerenders are cancelled from the renderer process,
1465   // or the channel for the renderer process is closed on the IO thread.  In the
1466   // last case, the code must be careful to wait for the channel to close, as it
1467   // is done asynchronously after swapping out the old process.  See
1468   // ChannelDestructionWatcher.
1469   bool IsEmptyPrerenderLinkManager() const {
1470     return GetPrerenderLinkManager()->IsEmpty();
1471   }
1472
1473   size_t GetLinkPrerenderCount() const {
1474     return GetPrerenderLinkManager()->prerenders_.size();
1475   }
1476
1477   size_t GetRunningLinkPrerenderCount() const {
1478     return GetPrerenderLinkManager()->CountRunningPrerenders();
1479   }
1480
1481   // Returns length of |prerender_manager_|'s history, or -1 on failure.
1482   int GetHistoryLength() const {
1483     scoped_ptr<base::DictionaryValue> prerender_dict(
1484         static_cast<base::DictionaryValue*>(
1485             GetPrerenderManager()->GetAsValue()));
1486     if (!prerender_dict.get())
1487       return -1;
1488     base::ListValue* history_list;
1489     if (!prerender_dict->GetList("history", &history_list))
1490       return -1;
1491     return static_cast<int>(history_list->GetSize());
1492   }
1493
1494 #if defined(FULL_SAFE_BROWSING)
1495   FakeSafeBrowsingDatabaseManager* GetFakeSafeBrowsingDatabaseManager() {
1496     return safe_browsing_factory_->most_recent_service()->
1497         fake_database_manager();
1498   }
1499 #endif
1500
1501   TestPrerenderContents* GetPrerenderContentsFor(const GURL& url) const {
1502     PrerenderManager::PrerenderData* prerender_data =
1503         GetPrerenderManager()->FindPrerenderData(url, NULL);
1504     return static_cast<TestPrerenderContents*>(
1505         prerender_data ? prerender_data->contents() : NULL);
1506   }
1507
1508   void SetLoaderHostOverride(const std::string& host) {
1509     loader_host_override_ = host;
1510     host_resolver()->AddRule(host, "127.0.0.1");
1511   }
1512
1513   void set_loader_path(const std::string& path) {
1514     loader_path_ = path;
1515   }
1516
1517   void set_loader_query(const std::string& query) {
1518     loader_query_ = query;
1519   }
1520
1521   GURL GetCrossDomainTestUrl(const std::string& path) {
1522     static const std::string secondary_domain = "www.foo.com";
1523     host_resolver()->AddRule(secondary_domain, "127.0.0.1");
1524     std::string url_str(base::StringPrintf(
1525         "http://%s:%d/%s",
1526         secondary_domain.c_str(),
1527         test_server()->host_port_pair().port(),
1528         path.c_str()));
1529     return GURL(url_str);
1530   }
1531
1532   void set_browser(Browser* browser) {
1533     explicitly_set_browser_ = browser;
1534   }
1535
1536   Browser* current_browser() const {
1537     return explicitly_set_browser_ ? explicitly_set_browser_ : browser();
1538   }
1539
1540   const GURL& dest_url() const {
1541     return dest_url_;
1542   }
1543
1544   void IncreasePrerenderMemory() {
1545     // Increase the memory allowed in a prerendered page above normal settings.
1546     // Debug build bots occasionally run against the default limit, and tests
1547     // were failing because the prerender was canceled due to memory exhaustion.
1548     // http://crbug.com/93076
1549     GetPrerenderManager()->mutable_config().max_bytes = 1000 * 1024 * 1024;
1550   }
1551
1552   bool DidPrerenderPass(WebContents* web_contents) const {
1553     bool prerender_test_result = false;
1554     if (!content::ExecuteScriptAndExtractBool(
1555             web_contents,
1556             "window.domAutomationController.send(DidPrerenderPass())",
1557             &prerender_test_result))
1558       return false;
1559     return prerender_test_result;
1560   }
1561
1562   bool DidDisplayPass(WebContents* web_contents) const {
1563     bool display_test_result = false;
1564     if (!content::ExecuteScriptAndExtractBool(
1565             web_contents,
1566             "window.domAutomationController.send(DidDisplayPass())",
1567             &display_test_result))
1568       return false;
1569     return display_test_result;
1570   }
1571
1572   scoped_ptr<TestPrerender> ExpectPrerender(FinalStatus expected_final_status) {
1573     return prerender_contents_factory_->ExpectPrerenderContents(
1574         expected_final_status);
1575   }
1576
1577   void AddPrerender(const GURL& url, int index) {
1578     std::string javascript = base::StringPrintf(
1579         "AddPrerender('%s', %d)", url.spec().c_str(), index);
1580     RenderFrameHost* render_frame_host = GetActiveWebContents()->GetMainFrame();
1581     render_frame_host->ExecuteJavaScript(base::ASCIIToUTF16(javascript));
1582   }
1583
1584   // Returns a string for pattern-matching TaskManager tab entries.
1585   base::string16 MatchTaskManagerTab(const char* page_title) {
1586     return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_TAB_PREFIX,
1587                                       base::ASCIIToUTF16(page_title));
1588   }
1589
1590   // Returns a string for pattern-matching TaskManager prerender entries.
1591   base::string16 MatchTaskManagerPrerender(const char* page_title) {
1592     return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_PRERENDER_PREFIX,
1593                                       base::ASCIIToUTF16(page_title));
1594   }
1595
1596   void RunJSReturningString(const char* js, std::string* result) {
1597     ASSERT_TRUE(
1598         content::ExecuteScriptAndExtractString(
1599             GetActiveWebContents(),
1600             base::StringPrintf("window.domAutomationController.send(%s)",
1601                                js).c_str(),
1602             result));
1603   }
1604
1605   void RunJS(const char* js) {
1606     ASSERT_TRUE(content::ExecuteScript(
1607         GetActiveWebContents(),
1608         base::StringPrintf("window.domAutomationController.send(%s)",
1609                            js).c_str()));
1610   }
1611
1612   const base::HistogramTester& histogram_tester() { return histogram_tester_; }
1613
1614  protected:
1615   bool autostart_test_server_;
1616
1617  private:
1618   // TODO(davidben): Remove this altogether so the tests don't globally assume
1619   // only one prerender.
1620   TestPrerenderContents* GetPrerenderContents() const {
1621     return GetPrerenderContentsFor(dest_url_);
1622   }
1623
1624   ScopedVector<TestPrerender> PrerenderTestURLImpl(
1625       const GURL& prerender_url,
1626       const std::vector<FinalStatus>& expected_final_status_queue,
1627       int expected_number_of_loads) {
1628     dest_url_ = prerender_url;
1629
1630     std::vector<net::SpawnedTestServer::StringPair> replacement_text;
1631     replacement_text.push_back(
1632         make_pair("REPLACE_WITH_PRERENDER_URL", prerender_url.spec()));
1633     std::string replacement_path;
1634     CHECK(net::SpawnedTestServer::GetFilePathWithReplacements(
1635         loader_path_,
1636         replacement_text,
1637         &replacement_path));
1638
1639     const net::SpawnedTestServer* src_server = test_server();
1640     if (https_src_server_)
1641       src_server = https_src_server_.get();
1642     GURL loader_url = src_server->GetURL(
1643         replacement_path + "&" + loader_query_);
1644
1645     GURL::Replacements loader_replacements;
1646     if (!loader_host_override_.empty())
1647       loader_replacements.SetHostStr(loader_host_override_);
1648     loader_url = loader_url.ReplaceComponents(loader_replacements);
1649
1650     VLOG(1) << "Running test with queue length " <<
1651                expected_final_status_queue.size();
1652     CHECK(!expected_final_status_queue.empty());
1653     ScopedVector<TestPrerender> prerenders;
1654     for (size_t i = 0; i < expected_final_status_queue.size(); i++) {
1655       prerenders.push_back(
1656           prerender_contents_factory_->ExpectPrerenderContents(
1657               expected_final_status_queue[i]).release());
1658     }
1659
1660     FinalStatus expected_final_status = expected_final_status_queue.front();
1661
1662     // Navigate to the loader URL and then wait for the first prerender to be
1663     // created.
1664     ui_test_utils::NavigateToURL(current_browser(), loader_url);
1665     prerenders[0]->WaitForCreate();
1666     prerenders[0]->WaitForLoads(expected_number_of_loads);
1667
1668     if (ShouldAbortPrerenderBeforeSwap(expected_final_status)) {
1669       // The prerender will abort on its own. Assert it does so correctly.
1670       prerenders[0]->WaitForStop();
1671       EXPECT_FALSE(prerenders[0]->contents());
1672       EXPECT_TRUE(DidReceivePrerenderStopEventForLinkNumber(0));
1673     } else {
1674       // Otherwise, check that it prerendered correctly.
1675       TestPrerenderContents* prerender_contents = prerenders[0]->contents();
1676
1677       CHECK_NE(static_cast<PrerenderContents*>(NULL), prerender_contents);
1678       EXPECT_EQ(FINAL_STATUS_MAX, prerender_contents->final_status());
1679       EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
1680
1681       if (call_javascript_) {
1682         // Check if page behaves as expected while in prerendered state.
1683         EXPECT_TRUE(DidPrerenderPass(prerender_contents->prerender_contents()));
1684       }
1685     }
1686
1687     // Test that the referring page received the right start and load events.
1688     EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
1689     if (check_load_events_) {
1690       EXPECT_EQ(expected_number_of_loads, prerenders[0]->number_of_loads());
1691       EXPECT_EQ(expected_number_of_loads,
1692                 GetPrerenderLoadEventCountForLinkNumber(0));
1693     }
1694     EXPECT_FALSE(HadPrerenderEventErrors());
1695
1696     return prerenders.Pass();
1697   }
1698
1699   void NavigateToURLImpl(const content::OpenURLParams& params,
1700                          bool expect_swap_to_succeed) const {
1701     ASSERT_NE(static_cast<PrerenderManager*>(NULL), GetPrerenderManager());
1702     // Make sure in navigating we have a URL to use in the PrerenderManager.
1703     ASSERT_NE(static_cast<PrerenderContents*>(NULL), GetPrerenderContents());
1704
1705     WebContents* web_contents = GetPrerenderContents()->prerender_contents();
1706
1707     // Navigate and wait for either the load to finish normally or for a swap to
1708     // occur.
1709     // TODO(davidben): The only handles CURRENT_TAB navigations, which is the
1710     // only case tested or prerendered right now.
1711     CHECK_EQ(CURRENT_TAB, params.disposition);
1712     NavigationOrSwapObserver swap_observer(current_browser()->tab_strip_model(),
1713                                            GetActiveWebContents());
1714     WebContents* target_web_contents = current_browser()->OpenURL(params);
1715     swap_observer.Wait();
1716
1717     if (web_contents && expect_swap_to_succeed) {
1718       EXPECT_EQ(web_contents, target_web_contents);
1719       if (call_javascript_)
1720         EXPECT_TRUE(DidDisplayPass(web_contents));
1721     }
1722   }
1723
1724   // Opens the prerendered page using javascript functions in the loader
1725   // page. |javascript_function_name| should be a 0 argument function which is
1726   // invoked. |new_web_contents| is true if the navigation is expected to
1727   // happen in a new WebContents via OpenURL.
1728   void OpenURLWithJSImpl(const std::string& javascript_function_name,
1729                          const GURL& url,
1730                          const GURL& ping_url,
1731                          bool new_web_contents) const {
1732     WebContents* web_contents = GetActiveWebContents();
1733     RenderFrameHost* render_frame_host = web_contents->GetMainFrame();
1734     // Extra arguments in JS are ignored.
1735     std::string javascript = base::StringPrintf(
1736         "%s('%s', '%s')", javascript_function_name.c_str(),
1737         url.spec().c_str(), ping_url.spec().c_str());
1738
1739     if (new_web_contents) {
1740       NewTabNavigationOrSwapObserver observer;
1741       render_frame_host->
1742           ExecuteJavaScriptForTests(base::ASCIIToUTF16(javascript));
1743       observer.Wait();
1744     } else {
1745       NavigationOrSwapObserver observer(current_browser()->tab_strip_model(),
1746                                         web_contents);
1747       render_frame_host->ExecuteJavaScript(base::ASCIIToUTF16(javascript));
1748       observer.Wait();
1749     }
1750   }
1751
1752   TestPrerenderContentsFactory* prerender_contents_factory_;
1753 #if defined(FULL_SAFE_BROWSING)
1754   scoped_ptr<TestSafeBrowsingServiceFactory> safe_browsing_factory_;
1755 #endif
1756   NeverRunsExternalProtocolHandlerDelegate external_protocol_handler_delegate_;
1757   GURL dest_url_;
1758   scoped_ptr<net::SpawnedTestServer> https_src_server_;
1759   bool call_javascript_;
1760   bool check_load_events_;
1761   std::string loader_host_override_;
1762   std::string loader_path_;
1763   std::string loader_query_;
1764   Browser* explicitly_set_browser_;
1765   base::HistogramTester histogram_tester_;
1766   scoped_ptr<base::FieldTrialList> field_trial_list_;
1767 };
1768
1769 // Checks that a page is correctly prerendered in the case of a
1770 // <link rel=prerender> tag and then loaded into a tab in response to a
1771 // navigation.
1772 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPage) {
1773   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
1774   EXPECT_EQ(1, GetPrerenderDomContentLoadedEventCountForLinkNumber(0));
1775   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
1776   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
1777   histogram_tester().ExpectTotalCount(
1778       "Prerender.none_PerceivedPLTMatchedComplete", 0);
1779   histogram_tester().ExpectTotalCount(
1780       "Prerender.websame_PrerenderNotSwappedInPLT", 1);
1781
1782   ChannelDestructionWatcher channel_close_watcher;
1783   channel_close_watcher.WatchChannel(
1784       GetActiveWebContents()->GetRenderProcessHost());
1785   NavigateToDestURL();
1786   channel_close_watcher.WaitForChannelClose();
1787
1788   histogram_tester().ExpectTotalCount("Prerender.websame_PerceivedPLT", 1);
1789   histogram_tester().ExpectTotalCount("Prerender.websame_PerceivedPLTMatched",
1790                                       1);
1791   histogram_tester().ExpectTotalCount(
1792       "Prerender.websame_PerceivedPLTMatchedComplete", 1);
1793
1794   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
1795 }
1796
1797 // Checks that cross-domain prerenders emit the correct histograms.
1798 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageCrossDomain) {
1799   PrerenderTestURL(GetCrossDomainTestUrl("files/prerender/prerender_page.html"),
1800                    FINAL_STATUS_USED, 1);
1801   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
1802   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
1803   histogram_tester().ExpectTotalCount(
1804       "Prerender.none_PerceivedPLTMatchedComplete", 0);
1805   histogram_tester().ExpectTotalCount(
1806       "Prerender.webcross_PrerenderNotSwappedInPLT", 1);
1807
1808   NavigateToDestURL();
1809   histogram_tester().ExpectTotalCount("Prerender.webcross_PerceivedPLT", 1);
1810   histogram_tester().ExpectTotalCount("Prerender.webcross_PerceivedPLTMatched",
1811                                       1);
1812   histogram_tester().ExpectTotalCount(
1813       "Prerender.webcross_PerceivedPLTMatchedComplete", 1);
1814 }
1815
1816 // Checks that pending prerenders launch and receive proper event treatment.
1817 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPagePending) {
1818   scoped_ptr<TestPrerender> prerender =
1819       PrerenderTestURL("files/prerender/prerender_page_pending.html",
1820                        FINAL_STATUS_USED, 1);
1821
1822   // Navigate to the prerender.
1823   scoped_ptr<TestPrerender> prerender2 = ExpectPrerender(FINAL_STATUS_USED);
1824   NavigateToDestURL();
1825   // Abort early if the original prerender didn't swap, so as not to hang.
1826   ASSERT_FALSE(prerender->contents());
1827
1828   // Wait for the new prerender to be ready.
1829   prerender2->WaitForStart();
1830   prerender2->WaitForLoads(1);
1831
1832   const GURL prerender_page_url =
1833       test_server()->GetURL("files/prerender/prerender_page.html");
1834   EXPECT_FALSE(IsEmptyPrerenderLinkManager());
1835   EXPECT_NE(static_cast<TestPrerenderContents*>(NULL),
1836             GetPrerenderContentsFor(prerender_page_url));
1837
1838   // Now navigate to our target page.
1839   NavigationOrSwapObserver swap_observer(current_browser()->tab_strip_model(),
1840                                          GetActiveWebContents());
1841   ui_test_utils::NavigateToURLWithDisposition(
1842       current_browser(), prerender_page_url, CURRENT_TAB,
1843       ui_test_utils::BROWSER_TEST_NONE);
1844   swap_observer.Wait();
1845
1846   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
1847 }
1848
1849 // Checks that pending prerenders which are canceled before they are launched
1850 // never get started.
1851 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageRemovesPending) {
1852   PrerenderTestURL("files/prerender/prerender_page_removes_pending.html",
1853                    FINAL_STATUS_USED, 1);
1854
1855   ChannelDestructionWatcher channel_close_watcher;
1856   channel_close_watcher.WatchChannel(
1857       GetActiveWebContents()->GetRenderProcessHost());
1858   NavigateToDestURL();
1859   channel_close_watcher.WaitForChannelClose();
1860
1861   EXPECT_FALSE(DidReceivePrerenderStartEventForLinkNumber(1));
1862   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
1863   EXPECT_FALSE(HadPrerenderEventErrors());
1864   // IsEmptyPrerenderLinkManager() is not racy because the earlier DidReceive*
1865   // calls did a thread/process hop to the renderer which insured pending
1866   // renderer events have arrived.
1867   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
1868 }
1869
1870 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageRemovingLink) {
1871   scoped_ptr<TestPrerender> prerender =
1872       PrerenderTestURL("files/prerender/prerender_page.html",
1873                        FINAL_STATUS_CANCELLED, 1);
1874
1875   // No ChannelDestructionWatcher is needed here, since prerenders in the
1876   // PrerenderLinkManager should be deleted by removing the links, rather than
1877   // shutting down the renderer process.
1878   RemoveLinkElement(0);
1879   prerender->WaitForStop();
1880
1881   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
1882   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
1883   EXPECT_FALSE(HadPrerenderEventErrors());
1884   // IsEmptyPrerenderLinkManager() is not racy because the earlier DidReceive*
1885   // calls did a thread/process hop to the renderer which insured pending
1886   // renderer events have arrived.
1887   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
1888 }
1889
1890 IN_PROC_BROWSER_TEST_F(
1891     PrerenderBrowserTest, PrerenderPageRemovingLinkWithTwoLinks) {
1892   GetPrerenderManager()->mutable_config().max_link_concurrency = 2;
1893   GetPrerenderManager()->mutable_config().max_link_concurrency_per_launcher = 2;
1894
1895   set_loader_query("links_to_insert=2");
1896   scoped_ptr<TestPrerender> prerender =
1897       PrerenderTestURL("files/prerender/prerender_page.html",
1898                        FINAL_STATUS_CANCELLED, 1);
1899   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
1900   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
1901   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(1));
1902   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
1903
1904   RemoveLinkElement(0);
1905   RemoveLinkElement(1);
1906   prerender->WaitForStop();
1907
1908   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
1909   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
1910   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(1));
1911   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
1912   EXPECT_FALSE(HadPrerenderEventErrors());
1913   // IsEmptyPrerenderLinkManager() is not racy because the earlier DidReceive*
1914   // calls did a thread/process hop to the renderer which insured pending
1915   // renderer events have arrived.
1916   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
1917 }
1918
1919 IN_PROC_BROWSER_TEST_F(
1920     PrerenderBrowserTest, PrerenderPageRemovingLinkWithTwoLinksOneLate) {
1921   GetPrerenderManager()->mutable_config().max_link_concurrency = 2;
1922   GetPrerenderManager()->mutable_config().max_link_concurrency_per_launcher = 2;
1923
1924   GURL url = test_server()->GetURL("files/prerender/prerender_page.html");
1925   scoped_ptr<TestPrerender> prerender =
1926       PrerenderTestURL(url, FINAL_STATUS_CANCELLED, 1);
1927
1928   // Add a second prerender for the same link. It reuses the prerender, so only
1929   // the start event fires here.
1930   AddPrerender(url, 1);
1931   WaitForPrerenderEventCount(1, "webkitprerenderstart", 1);
1932   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(1));
1933   EXPECT_EQ(0, GetPrerenderLoadEventCountForLinkNumber(1));
1934   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
1935
1936   RemoveLinkElement(0);
1937   RemoveLinkElement(1);
1938   prerender->WaitForStop();
1939
1940   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
1941   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
1942   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(1));
1943   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
1944   EXPECT_FALSE(HadPrerenderEventErrors());
1945   // IsEmptyPrerenderLinkManager() is not racy because the earlier DidReceive*
1946   // calls did a thread/process hop to the renderer which insured pending
1947   // renderer events have arrived.
1948   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
1949 }
1950
1951 IN_PROC_BROWSER_TEST_F(
1952     PrerenderBrowserTest,
1953     PrerenderPageRemovingLinkWithTwoLinksRemovingOne) {
1954   GetPrerenderManager()->mutable_config().max_link_concurrency = 2;
1955   GetPrerenderManager()->mutable_config().max_link_concurrency_per_launcher = 2;
1956   set_loader_query("links_to_insert=2");
1957   PrerenderTestURL("files/prerender/prerender_page.html",
1958                    FINAL_STATUS_USED, 1);
1959   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
1960   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
1961   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(1));
1962   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
1963
1964   RemoveLinkElement(0);
1965   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
1966   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
1967   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(1));
1968   EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
1969   EXPECT_FALSE(HadPrerenderEventErrors());
1970   // IsEmptyPrerenderLinkManager() is not racy because the earlier DidReceive*
1971   // calls did a thread/process hop to the renderer which insured pending
1972   // renderer events have arrived.
1973   EXPECT_FALSE(IsEmptyPrerenderLinkManager());
1974
1975   ChannelDestructionWatcher channel_close_watcher;
1976   channel_close_watcher.WatchChannel(
1977       GetActiveWebContents()->GetRenderProcessHost());
1978   NavigateToDestURL();
1979   channel_close_watcher.WaitForChannelClose();
1980
1981   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
1982 }
1983
1984 // Checks that the visibility API works.
1985 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderVisibility) {
1986   PrerenderTestURL("files/prerender/prerender_visibility.html",
1987                    FINAL_STATUS_USED,
1988                    1);
1989   NavigateToDestURL();
1990 }
1991
1992 // Checks that the prerendering of a page is canceled correctly if we try to
1993 // swap it in before it commits.
1994 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNoCommitNoSwap) {
1995   // Navigate to a page that triggers a prerender for a URL that never commits.
1996   const GURL kNoCommitUrl("http://never-respond.example.com");
1997   base::FilePath file(GetTestPath("prerender_page.html"));
1998
1999   base::RunLoop prerender_start_loop;
2000   BrowserThread::PostTask(
2001       BrowserThread::IO, FROM_HERE,
2002       base::Bind(&CreateHangingFirstRequestInterceptorOnIO, kNoCommitUrl, file,
2003                  prerender_start_loop.QuitClosure()));
2004   DisableJavascriptCalls();
2005   PrerenderTestURL(kNoCommitUrl,
2006                    FINAL_STATUS_NAVIGATION_UNCOMMITTED,
2007                    0);
2008   // Wait for the hanging request to be scheduled.
2009   prerender_start_loop.Run();
2010
2011   // Navigate to the URL, but assume the contents won't be swapped in.
2012   NavigateToDestURLWithDisposition(CURRENT_TAB, false);
2013 }
2014
2015 // Checks that client redirects don't add alias URLs until after they commit.
2016 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNoCommitNoSwap2) {
2017   // Navigate to a page that then navigates to a URL that never commits.
2018   const GURL kNoCommitUrl("http://never-respond.example.com");
2019   base::FilePath file(GetTestPath("prerender_page.html"));
2020
2021   base::RunLoop prerender_start_loop;
2022   BrowserThread::PostTask(
2023       BrowserThread::IO, FROM_HERE,
2024       base::Bind(&CreateHangingFirstRequestInterceptorOnIO, kNoCommitUrl, file,
2025                  prerender_start_loop.QuitClosure()));
2026   DisableJavascriptCalls();
2027   PrerenderTestURL(CreateClientRedirect(kNoCommitUrl.spec()),
2028                    FINAL_STATUS_APP_TERMINATING, 1);
2029   // Wait for the hanging request to be scheduled.
2030   prerender_start_loop.Run();
2031
2032   // Navigating to the second URL should not swap.
2033   NavigateToURLWithDisposition(kNoCommitUrl, CURRENT_TAB, false);
2034 }
2035
2036 // Checks that the prerendering of a page is canceled correctly when a
2037 // Javascript alert is called.
2038 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderAlertBeforeOnload) {
2039   PrerenderTestURL("files/prerender/prerender_alert_before_onload.html",
2040                    FINAL_STATUS_JAVASCRIPT_ALERT,
2041                    0);
2042 }
2043
2044 // Checks that the prerendering of a page is canceled correctly when a
2045 // Javascript alert is called.
2046 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderAlertAfterOnload) {
2047   PrerenderTestURL("files/prerender/prerender_alert_after_onload.html",
2048                    FINAL_STATUS_JAVASCRIPT_ALERT,
2049                    1);
2050 }
2051
2052 // Checks that plugins are not loaded while a page is being preloaded, but
2053 // are loaded when the page is displayed.
2054 #if defined(USE_AURA) && !defined(OS_WIN)
2055 // http://crbug.com/103496
2056 #define MAYBE_PrerenderDelayLoadPlugin DISABLED_PrerenderDelayLoadPlugin
2057 #elif defined(OS_MACOSX)
2058 // http://crbug.com/100514
2059 #define MAYBE_PrerenderDelayLoadPlugin DISABLED_PrerenderDelayLoadPlugin
2060 #elif defined(OS_WIN) && defined(ARCH_CPU_X86_64)
2061 // TODO(jschuh): Failing plugin tests. crbug.com/244653
2062 #define MAYBE_PrerenderDelayLoadPlugin DISABLED_PrerenderDelayLoadPlugin
2063 #elif defined(OS_LINUX)
2064 // http://crbug.com/306715
2065 #define MAYBE_PrerenderDelayLoadPlugin DISABLED_PrerenderDelayLoadPlugin
2066 #else
2067 #define MAYBE_PrerenderDelayLoadPlugin PrerenderDelayLoadPlugin
2068 #endif
2069 // http://crbug.com/306715
2070 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, MAYBE_PrerenderDelayLoadPlugin) {
2071   PrerenderTestURL("files/prerender/plugin_delay_load.html",
2072                    FINAL_STATUS_USED,
2073                    1);
2074   NavigateToDestURL();
2075 }
2076
2077 // Checks that plugins are not loaded on prerendering pages when click-to-play
2078 // is enabled.
2079 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickToPlay) {
2080   // Enable click-to-play.
2081   HostContentSettingsMap* content_settings_map =
2082       current_browser()->profile()->GetHostContentSettingsMap();
2083   content_settings_map->SetDefaultContentSetting(
2084       CONTENT_SETTINGS_TYPE_PLUGINS, CONTENT_SETTING_ASK);
2085
2086   PrerenderTestURL("files/prerender/prerender_plugin_click_to_play.html",
2087                    FINAL_STATUS_USED,
2088                    1);
2089   NavigateToDestURL();
2090 }
2091
2092 // Checks that we don't load a NaCl plugin when NaCl is disabled.
2093 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNaClPluginDisabled) {
2094   PrerenderTestURL("files/prerender/prerender_plugin_nacl_disabled.html",
2095                    FINAL_STATUS_USED,
2096                    1);
2097   NavigateToDestURL();
2098
2099
2100   // Run this check again.  When we try to load aa ppapi plugin, the
2101   // "loadstart" event is asynchronously posted to a message loop.
2102   // It's possible that earlier call could have been run before the
2103   // the "loadstart" event was posted.
2104   // TODO(mmenke):  While this should reliably fail on regressions, the
2105   //                reliability depends on the specifics of ppapi plugin
2106   //                loading.  It would be great if we could avoid that.
2107   EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
2108 }
2109
2110 // Checks that plugins in an iframe are not loaded while a page is
2111 // being preloaded, but are loaded when the page is displayed.
2112 #if defined(USE_AURA) && !defined(OS_WIN)
2113 // http://crbug.com/103496
2114 #define MAYBE_PrerenderIframeDelayLoadPlugin \
2115         DISABLED_PrerenderIframeDelayLoadPlugin
2116 #elif defined(OS_MACOSX)
2117 // http://crbug.com/100514
2118 #define MAYBE_PrerenderIframeDelayLoadPlugin \
2119         DISABLED_PrerenderIframeDelayLoadPlugin
2120 #elif defined(OS_WIN) && defined(ARCH_CPU_X86_64)
2121 // TODO(jschuh): Failing plugin tests. crbug.com/244653
2122 #define MAYBE_PrerenderIframeDelayLoadPlugin \
2123         DISABLED_PrerenderIframeDelayLoadPlugin
2124 #else
2125 #define MAYBE_PrerenderIframeDelayLoadPlugin PrerenderIframeDelayLoadPlugin
2126 #endif
2127 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2128                        MAYBE_PrerenderIframeDelayLoadPlugin) {
2129   PrerenderTestURL("files/prerender/prerender_iframe_plugin_delay_load.html",
2130                    FINAL_STATUS_USED,
2131                    1);
2132   NavigateToDestURL();
2133 }
2134
2135 // Renders a page that contains a prerender link to a page that contains an
2136 // iframe with a source that requires http authentication. This should not
2137 // prerender successfully.
2138 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHttpAuthentication) {
2139   PrerenderTestURL("files/prerender/prerender_http_auth_container.html",
2140                    FINAL_STATUS_AUTH_NEEDED,
2141                    0);
2142 }
2143
2144 // Checks that client-issued redirects work with prerendering.
2145 // This version navigates to the page which issues the redirection, rather
2146 // than the final destination page.
2147 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2148                        PrerenderClientRedirectNavigateToFirst) {
2149   PrerenderTestURL(CreateClientRedirect("files/prerender/prerender_page.html"),
2150                    FINAL_STATUS_USED,
2151                    2);
2152   NavigateToDestURL();
2153 }
2154
2155 // Checks that client-issued redirects work with prerendering.
2156 // This version navigates to the final destination page, rather than the
2157 // page which does the redirection.
2158 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2159                        PrerenderClientRedirectNavigateToSecond) {
2160   PrerenderTestURL(CreateClientRedirect("files/prerender/prerender_page.html"),
2161                    FINAL_STATUS_USED,
2162                    2);
2163   NavigateToURL("files/prerender/prerender_page.html");
2164 }
2165
2166 // Checks that redirects with location.replace do not cancel a prerender and
2167 // and swap when navigating to the first page.
2168 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2169                        PrerenderLocationReplaceNavigateToFirst) {
2170   PrerenderTestURL("files/prerender/prerender_location_replace.html",
2171                    FINAL_STATUS_USED,
2172                    2);
2173   NavigateToDestURL();
2174 }
2175
2176 // Checks that redirects with location.replace do not cancel a prerender and
2177 // and swap when navigating to the second.
2178 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2179                        PrerenderLocationReplaceNavigateToSecond) {
2180   PrerenderTestURL("files/prerender/prerender_location_replace.html",
2181                    FINAL_STATUS_USED,
2182                    2);
2183   NavigateToURL("files/prerender/prerender_page.html");
2184 }
2185
2186 // Checks that we get the right PPLT histograms for client redirect prerenders
2187 // and navigations when the referring page is Google.
2188 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2189                        PrerenderLocationReplaceGWSHistograms) {
2190   DisableJavascriptCalls();
2191
2192   // The loader page should look like Google.
2193   const std::string kGoogleDotCom("www.google.com");
2194   SetLoaderHostOverride(kGoogleDotCom);
2195   set_loader_path("files/prerender/prerender_loader_with_replace_state.html");
2196
2197   GURL dest_url = GetCrossDomainTestUrl(
2198       "files/prerender/prerender_deferred_image.html");
2199
2200   GURL prerender_url = test_server()->GetURL(
2201       "files/prerender/prerender_location_replace.html?" +
2202       net::EscapeQueryParamValue(dest_url.spec(), false) +
2203       "#prerender");
2204   GURL::Replacements replacements;
2205   replacements.SetHostStr(kGoogleDotCom);
2206   prerender_url = prerender_url.ReplaceComponents(replacements);
2207
2208   // The prerender will not completely load until after the swap, so wait for a
2209   // title change before calling DidPrerenderPass.
2210   scoped_ptr<TestPrerender> prerender =
2211       PrerenderTestURL(prerender_url, FINAL_STATUS_USED, 1);
2212   WaitForASCIITitle(prerender->contents()->prerender_contents(), kReadyTitle);
2213   EXPECT_TRUE(DidPrerenderPass(prerender->contents()->prerender_contents()));
2214   EXPECT_EQ(1, prerender->number_of_loads());
2215
2216   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
2217   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
2218   histogram_tester().ExpectTotalCount(
2219       "Prerender.none_PerceivedPLTMatchedComplete", 0);
2220   // Although there is a client redirect, it is dropped from histograms because
2221   // it is a Google URL. The target page itself does not load until after the
2222   // swap.
2223   histogram_tester().ExpectTotalCount("Prerender.gws_PrerenderNotSwappedInPLT",
2224                                       0);
2225
2226   GURL navigate_url = test_server()->GetURL(
2227       "files/prerender/prerender_location_replace.html?" +
2228       net::EscapeQueryParamValue(dest_url.spec(), false) +
2229       "#navigate");
2230   navigate_url = navigate_url.ReplaceComponents(replacements);
2231
2232   NavigationOrSwapObserver swap_observer(
2233       current_browser()->tab_strip_model(),
2234       GetActiveWebContents(), 2);
2235   current_browser()->OpenURL(OpenURLParams(
2236       navigate_url, Referrer(), CURRENT_TAB,
2237       ui::PAGE_TRANSITION_TYPED, false));
2238   swap_observer.Wait();
2239
2240   EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
2241
2242   histogram_tester().ExpectTotalCount("Prerender.gws_PrerenderNotSwappedInPLT",
2243                                       0);
2244   histogram_tester().ExpectTotalCount("Prerender.gws_PerceivedPLT", 1);
2245   histogram_tester().ExpectTotalCount("Prerender.gws_PerceivedPLTMatched", 1);
2246   histogram_tester().ExpectTotalCount(
2247       "Prerender.gws_PerceivedPLTMatchedComplete", 1);
2248
2249   // The client redirect does /not/ count as a miss because it's a Google URL.
2250   histogram_tester().ExpectTotalCount("Prerender.PerceivedPLTFirstAfterMiss",
2251                                       0);
2252 }
2253
2254 // Checks that client-issued redirects work with prerendering.
2255 // This version navigates to the final destination page, rather than the
2256 // page which does the redirection via a mouse click.
2257 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2258                        PrerenderClientRedirectNavigateToSecondViaClick) {
2259   GURL prerender_url = test_server()->GetURL(
2260       CreateClientRedirect("files/prerender/prerender_page.html"));
2261   GURL destination_url = test_server()->GetURL(
2262       "files/prerender/prerender_page.html");
2263   PrerenderTestURL(prerender_url, FINAL_STATUS_USED, 2);
2264   OpenURLViaClick(destination_url);
2265 }
2266
2267 // Checks that a page served over HTTPS is correctly prerendered.
2268 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHttps) {
2269   net::SpawnedTestServer https_server(
2270       net::SpawnedTestServer::TYPE_HTTPS, net::SpawnedTestServer::kLocalhost,
2271       base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
2272   ASSERT_TRUE(https_server.Start());
2273   GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
2274   PrerenderTestURL(https_url,
2275                    FINAL_STATUS_USED,
2276                    1);
2277   NavigateToDestURL();
2278 }
2279
2280 // Checks that client-issued redirects within an iframe in a prerendered
2281 // page will not count as an "alias" for the prerendered page.
2282 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2283                        PrerenderClientRedirectInIframe) {
2284   std::string redirect_path = CreateClientRedirect(
2285       "/files/prerender/prerender_embedded_content.html");
2286   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
2287   replacement_text.push_back(
2288       std::make_pair("REPLACE_WITH_URL", "/" + redirect_path));
2289   std::string replacement_path;
2290   ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
2291       "files/prerender/prerender_with_iframe.html",
2292       replacement_text,
2293       &replacement_path));
2294   PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 2);
2295   EXPECT_FALSE(UrlIsInPrerenderManager(
2296       "files/prerender/prerender_embedded_content.html"));
2297   NavigateToDestURL();
2298 }
2299
2300 // Checks that server-issued redirects work with prerendering.
2301 // This version navigates to the page which issues the redirection, rather
2302 // than the final destination page.
2303 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2304                        PrerenderServerRedirectNavigateToFirst) {
2305   PrerenderTestURL(CreateServerRedirect("files/prerender/prerender_page.html"),
2306                    FINAL_STATUS_USED,
2307                    1);
2308   NavigateToDestURL();
2309 }
2310
2311 // Checks that server-issued redirects work with prerendering.
2312 // This version navigates to the final destination page, rather than the
2313 // page which does the redirection.
2314 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2315                        PrerenderServerRedirectNavigateToSecond) {
2316   PrerenderTestURL(CreateServerRedirect("files/prerender/prerender_page.html"),
2317                    FINAL_STATUS_USED,
2318                    1);
2319   NavigateToURL("files/prerender/prerender_page.html");
2320 }
2321
2322 // Checks that server-issued redirects work with prerendering.
2323 // This version navigates to the final destination page, rather than the
2324 // page which does the redirection via a mouse click.
2325 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2326                        PrerenderServerRedirectNavigateToSecondViaClick) {
2327   GURL prerender_url = test_server()->GetURL(
2328       CreateServerRedirect("files/prerender/prerender_page.html"));
2329   GURL destination_url = test_server()->GetURL(
2330       "files/prerender/prerender_page.html");
2331   PrerenderTestURL(prerender_url, FINAL_STATUS_USED, 1);
2332   OpenURLViaClick(destination_url);
2333 }
2334
2335 // Checks that server-issued redirects within an iframe in a prerendered
2336 // page will not count as an "alias" for the prerendered page.
2337 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderServerRedirectInIframe) {
2338   std::string redirect_path = CreateServerRedirect(
2339       "/files/prerender/prerender_embedded_content.html");
2340   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
2341   replacement_text.push_back(
2342       std::make_pair("REPLACE_WITH_URL", "/" + redirect_path));
2343   std::string replacement_path;
2344   ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
2345       "files/prerender/prerender_with_iframe.html",
2346       replacement_text,
2347       &replacement_path));
2348   PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
2349   EXPECT_FALSE(UrlIsInPrerenderManager(
2350       "files/prerender/prerender_embedded_content.html"));
2351   NavigateToDestURL();
2352 }
2353
2354 // Prerenders a page that contains an automatic download triggered through an
2355 // iframe. This should not prerender successfully.
2356 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDownloadIframe) {
2357   PrerenderTestURL("files/prerender/prerender_download_iframe.html",
2358                    FINAL_STATUS_DOWNLOAD,
2359                    0);
2360 }
2361
2362 // Prerenders a page that contains an automatic download triggered through
2363 // Javascript changing the window.location. This should not prerender
2364 // successfully
2365 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDownloadLocation) {
2366   PrerenderTestURL(CreateClientRedirect("files/download-test1.lib"),
2367                    FINAL_STATUS_DOWNLOAD,
2368                    1);
2369 }
2370
2371 // Prerenders a page that contains an automatic download triggered through a
2372 // client-issued redirect. This should not prerender successfully.
2373 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDownloadClientRedirect) {
2374   PrerenderTestURL("files/prerender/prerender_download_refresh.html",
2375                    FINAL_STATUS_DOWNLOAD,
2376                    1);
2377 }
2378
2379 // Checks that the referrer is set when prerendering.
2380 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderReferrer) {
2381   PrerenderTestURL("files/prerender/prerender_referrer.html",
2382                    FINAL_STATUS_USED,
2383                    1);
2384   NavigateToDestURL();
2385 }
2386
2387 // Checks that the referrer is not set when prerendering and the source page is
2388 // HTTPS.
2389 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2390                        PrerenderNoSSLReferrer) {
2391   UseHttpsSrcServer();
2392   PrerenderTestURL("files/prerender/prerender_no_referrer.html",
2393                    FINAL_STATUS_USED,
2394                    1);
2395   NavigateToDestURL();
2396 }
2397
2398 // Checks that the referrer is set when prerendering is cancelled.
2399 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCancelReferrer) {
2400   scoped_ptr<TestContentBrowserClient> test_content_browser_client(
2401       new TestContentBrowserClient);
2402   content::ContentBrowserClient* original_browser_client =
2403       content::SetBrowserClientForTesting(test_content_browser_client.get());
2404
2405   PrerenderTestURL("files/prerender/prerender_referrer.html",
2406                    FINAL_STATUS_CANCELLED,
2407                    1);
2408   OpenDestURLViaClick();
2409
2410   EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
2411
2412   content::SetBrowserClientForTesting(original_browser_client);
2413 }
2414
2415 // Checks that popups on a prerendered page cause cancellation.
2416 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPopup) {
2417   PrerenderTestURL("files/prerender/prerender_popup.html",
2418                    FINAL_STATUS_CREATE_NEW_WINDOW,
2419                    0);
2420 }
2421
2422 // Checks that registering a protocol handler causes cancellation.
2423 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderRegisterProtocolHandler) {
2424   PrerenderTestURL("files/prerender/prerender_register_protocol_handler.html",
2425                    FINAL_STATUS_REGISTER_PROTOCOL_HANDLER,
2426                    0);
2427 }
2428
2429 // Checks that renderers using excessive memory will be terminated.
2430 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderExcessiveMemory) {
2431   ASSERT_TRUE(GetPrerenderManager());
2432   GetPrerenderManager()->mutable_config().max_bytes = 30 * 1024 * 1024;
2433   // The excessive memory kill may happen before or after the load event as it
2434   // happens asynchronously with IPC calls. Even if the test does not start
2435   // allocating until after load, the browser process might notice before the
2436   // message gets through. This happens on XP debug bots because they're so
2437   // slow. Instead, don't bother checking the load event count.
2438   DisableLoadEventCheck();
2439   PrerenderTestURL("files/prerender/prerender_excessive_memory.html",
2440                    FINAL_STATUS_MEMORY_LIMIT_EXCEEDED, 0);
2441 }
2442
2443 // Checks shutdown code while a prerender is active.
2444 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderQuickQuit) {
2445   DisableJavascriptCalls();
2446   DisableLoadEventCheck();
2447   PrerenderTestURL("files/prerender/prerender_page.html",
2448                    FINAL_STATUS_APP_TERMINATING,
2449                    0);
2450 }
2451
2452 // Checks that we don't prerender in an infinite loop.
2453 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderInfiniteLoop) {
2454   const char* const kHtmlFileA = "files/prerender/prerender_infinite_a.html";
2455   const char* const kHtmlFileB = "files/prerender/prerender_infinite_b.html";
2456
2457   std::vector<FinalStatus> expected_final_status_queue;
2458   expected_final_status_queue.push_back(FINAL_STATUS_USED);
2459   expected_final_status_queue.push_back(FINAL_STATUS_APP_TERMINATING);
2460
2461   ScopedVector<TestPrerender> prerenders =
2462       PrerenderTestURL(kHtmlFileA, expected_final_status_queue, 1);
2463   ASSERT_TRUE(prerenders[0]->contents());
2464   // Assert that the pending prerender is in there already. This relies on the
2465   // fact that the renderer sends out the AddLinkRelPrerender IPC before sending
2466   // the page load one.
2467   EXPECT_EQ(2U, GetLinkPrerenderCount());
2468   EXPECT_EQ(1U, GetRunningLinkPrerenderCount());
2469
2470   // Next url should be in pending list but not an active entry.
2471   EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileB));
2472
2473   NavigateToDestURL();
2474
2475   // Make sure the PrerenderContents for the next url is now in the manager and
2476   // not pending. This relies on pending prerenders being resolved in the same
2477   // event loop iteration as OnPrerenderStop.
2478   EXPECT_TRUE(UrlIsInPrerenderManager(kHtmlFileB));
2479   EXPECT_EQ(1U, GetLinkPrerenderCount());
2480   EXPECT_EQ(1U, GetRunningLinkPrerenderCount());
2481 }
2482
2483 // Checks that we don't prerender in an infinite loop and multiple links are
2484 // handled correctly.
2485 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2486                        PrerenderInfiniteLoopMultiple) {
2487   const char* const kHtmlFileA =
2488       "files/prerender/prerender_infinite_a_multiple.html";
2489   const char* const kHtmlFileB =
2490       "files/prerender/prerender_infinite_b_multiple.html";
2491   const char* const kHtmlFileC =
2492       "files/prerender/prerender_infinite_c_multiple.html";
2493
2494   // This test is conceptually simplest if concurrency is at two, since we
2495   // don't have to worry about which of kHtmlFileB or kHtmlFileC gets evicted.
2496   GetPrerenderManager()->mutable_config().max_link_concurrency = 2;
2497   GetPrerenderManager()->mutable_config().max_link_concurrency_per_launcher = 2;
2498
2499   std::vector<FinalStatus> expected_final_status_queue;
2500   expected_final_status_queue.push_back(FINAL_STATUS_USED);
2501   expected_final_status_queue.push_back(FINAL_STATUS_APP_TERMINATING);
2502   expected_final_status_queue.push_back(FINAL_STATUS_APP_TERMINATING);
2503
2504   ScopedVector<TestPrerender> prerenders =
2505       PrerenderTestURL(kHtmlFileA, expected_final_status_queue, 1);
2506   ASSERT_TRUE(prerenders[0]->contents());
2507
2508   // Next url should be in pending list but not an active entry. This relies on
2509   // the fact that the renderer sends out the AddLinkRelPrerender IPC before
2510   // sending the page load one.
2511   EXPECT_EQ(3U, GetLinkPrerenderCount());
2512   EXPECT_EQ(1U, GetRunningLinkPrerenderCount());
2513   EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileB));
2514   EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileC));
2515
2516   NavigateToDestURL();
2517
2518   // Make sure the PrerenderContents for the next urls are now in the manager
2519   // and not pending. One and only one of the URLs (the last seen) should be the
2520   // active entry. This relies on pending prerenders being resolved in the same
2521   // event loop iteration as OnPrerenderStop.
2522   bool url_b_is_active_prerender = UrlIsInPrerenderManager(kHtmlFileB);
2523   bool url_c_is_active_prerender = UrlIsInPrerenderManager(kHtmlFileC);
2524   EXPECT_TRUE(url_b_is_active_prerender && url_c_is_active_prerender);
2525   EXPECT_EQ(2U, GetLinkPrerenderCount());
2526   EXPECT_EQ(2U, GetRunningLinkPrerenderCount());
2527 }
2528
2529 // Checks that pending prerenders are aborted (and never launched) when launched
2530 // by a prerender that itself gets aborted.
2531 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderAbortPendingOnCancel) {
2532   const char* const kHtmlFileA = "files/prerender/prerender_infinite_a.html";
2533   const char* const kHtmlFileB = "files/prerender/prerender_infinite_b.html";
2534
2535   scoped_ptr<TestPrerender> prerender =
2536       PrerenderTestURL(kHtmlFileA, FINAL_STATUS_CANCELLED, 1);
2537   ASSERT_TRUE(prerender->contents());
2538   // Assert that the pending prerender is in there already. This relies on the
2539   // fact that the renderer sends out the AddLinkRelPrerender IPC before sending
2540   // the page load one.
2541   EXPECT_EQ(2U, GetLinkPrerenderCount());
2542   EXPECT_EQ(1U, GetRunningLinkPrerenderCount());
2543
2544   // Next url should be in pending list but not an active entry.
2545   EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileB));
2546
2547   // Cancel the prerender.
2548   GetPrerenderManager()->CancelAllPrerenders();
2549   prerender->WaitForStop();
2550
2551   // All prerenders are now gone.
2552   EXPECT_TRUE(IsEmptyPrerenderLinkManager());
2553 }
2554
2555 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, OpenTaskManagerBeforePrerender) {
2556   const base::string16 any_prerender = MatchTaskManagerPrerender("*");
2557   const base::string16 any_tab = MatchTaskManagerTab("*");
2558   const base::string16 original = MatchTaskManagerTab("Preloader");
2559   const base::string16 prerender = MatchTaskManagerPrerender("Prerender Page");
2560   const base::string16 final = MatchTaskManagerTab("Prerender Page");
2561
2562   // Show the task manager. This populates the model.
2563   chrome::OpenTaskManager(current_browser());
2564   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_tab));
2565   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, any_prerender));
2566
2567   // Prerender a page in addition to the original tab.
2568   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
2569
2570   // A TaskManager entry should appear like "Prerender: Prerender Page"
2571   // alongside the original tab entry. There should be just these two entries.
2572   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, prerender));
2573   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, original));
2574   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, final));
2575   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_prerender));
2576   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_tab));
2577
2578   // Swap in the prerendered content.
2579   NavigateToDestURL();
2580
2581   // The "Prerender: " TaskManager entry should disappear, being replaced by a
2582   // "Tab: Prerender Page" entry, and nothing else.
2583   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, prerender));
2584   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, original));
2585   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, final));
2586   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_tab));
2587   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, any_prerender));
2588 }
2589
2590 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, OpenTaskManagerAfterPrerender) {
2591   const base::string16 any_prerender = MatchTaskManagerPrerender("*");
2592   const base::string16 any_tab = MatchTaskManagerTab("*");
2593   const base::string16 original = MatchTaskManagerTab("Preloader");
2594   const base::string16 prerender = MatchTaskManagerPrerender("Prerender Page");
2595   const base::string16 final = MatchTaskManagerTab("Prerender Page");
2596
2597   // Start with two resources.
2598   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
2599
2600   // Show the task manager. This populates the model. Importantly, we're doing
2601   // this after the prerender WebContents already exists - the task manager
2602   // needs to find it, it can't just listen for creation.
2603   chrome::OpenTaskManager(current_browser());
2604
2605   // A TaskManager entry should appear like "Prerender: Prerender Page"
2606   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, prerender));
2607   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, original));
2608   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, final));
2609   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_prerender));
2610   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_tab));
2611
2612   // Swap in the tab.
2613   NavigateToDestURL();
2614
2615   // The "Prerender: Prerender Page" TaskManager row should disappear, being
2616   // replaced by "Tab: Prerender Page"
2617   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, prerender));
2618   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, original));
2619   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, final));
2620   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_tab));
2621   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, any_prerender));
2622 }
2623
2624 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, OpenTaskManagerAfterSwapIn) {
2625   const base::string16 any_prerender = MatchTaskManagerPrerender("*");
2626   const base::string16 any_tab = MatchTaskManagerTab("*");
2627   const base::string16 final = MatchTaskManagerTab("Prerender Page");
2628
2629   // Prerender, and swap it in.
2630   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
2631   NavigateToDestURL();
2632
2633   // Show the task manager. This populates the model. Importantly, we're doing
2634   // this after the prerender has been swapped in.
2635   chrome::OpenTaskManager(current_browser());
2636
2637   // We should not see a prerender resource in the task manager, just a normal
2638   // page.
2639   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, final));
2640   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_tab));
2641   ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, any_prerender));
2642 }
2643
2644 // Checks that audio loads are deferred on prerendering.
2645 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5Audio) {
2646   PrerenderTestURL("files/prerender/prerender_html5_audio.html",
2647                    FINAL_STATUS_USED,
2648                    1);
2649   NavigateToDestURL();
2650   WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
2651 }
2652
2653 // Checks that audio loads are deferred on prerendering and played back when
2654 // the prerender is swapped in if autoplay is set.
2655 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5AudioAutoplay) {
2656   PrerenderTestURL("files/prerender/prerender_html5_audio_autoplay.html",
2657                    FINAL_STATUS_USED,
2658                    1);
2659   NavigateToDestURL();
2660   WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
2661 }
2662
2663 // Checks that audio loads are deferred on prerendering and played back when
2664 // the prerender is swapped in if js starts playing.
2665 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5AudioJsplay) {
2666   PrerenderTestURL("files/prerender/prerender_html5_audio_jsplay.html",
2667                    FINAL_STATUS_USED,
2668                    1);
2669   NavigateToDestURL();
2670   WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
2671 }
2672
2673 // Checks that video loads are deferred on prerendering.
2674 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5Video) {
2675   PrerenderTestURL("files/prerender/prerender_html5_video.html",
2676                    FINAL_STATUS_USED,
2677                    1);
2678   NavigateToDestURL();
2679   WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
2680 }
2681
2682 // Checks that video tags inserted by javascript are deferred and played
2683 // correctly on swap in.
2684 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5VideoJs) {
2685   PrerenderTestURL("files/prerender/prerender_html5_video_script.html",
2686                    FINAL_STATUS_USED,
2687                    1);
2688   NavigateToDestURL();
2689   WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
2690 }
2691
2692 // Checks for correct network events by using a busy sleep the javascript.
2693 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5VideoNetwork) {
2694   DisableJavascriptCalls();
2695   scoped_ptr<TestPrerender> prerender =
2696       PrerenderTestURL("files/prerender/prerender_html5_video_network.html",
2697                        FINAL_STATUS_USED,
2698                        1);
2699   WaitForASCIITitle(prerender->contents()->prerender_contents(), kReadyTitle);
2700   EXPECT_TRUE(DidPrerenderPass(prerender->contents()->prerender_contents()));
2701   NavigateToDestURL();
2702   WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
2703 }
2704
2705 // Checks that scripts can retrieve the correct window size while prerendering.
2706 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderWindowSize) {
2707   PrerenderTestURL("files/prerender/prerender_size.html",
2708                    FINAL_STATUS_USED,
2709                    1);
2710   NavigateToDestURL();
2711 }
2712
2713 // TODO(jam): http://crbug.com/350550
2714 #if !(defined(OS_CHROMEOS) && defined(ADDRESS_SANITIZER))
2715
2716 // Checks that prerenderers will terminate when the RenderView crashes.
2717 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderRendererCrash) {
2718   scoped_ptr<TestPrerender> prerender =
2719       PrerenderTestURL("files/prerender/prerender_page.html",
2720                        FINAL_STATUS_RENDERER_CRASHED,
2721                        1);
2722
2723   // Navigate to about:crash and then wait for the renderer to crash.
2724   ASSERT_TRUE(prerender->contents());
2725   ASSERT_TRUE(prerender->contents()->prerender_contents());
2726   prerender->contents()->prerender_contents()->GetController().
2727       LoadURL(
2728           GURL(content::kChromeUICrashURL),
2729           content::Referrer(),
2730           ui::PAGE_TRANSITION_TYPED,
2731           std::string());
2732   prerender->WaitForStop();
2733 }
2734 #endif
2735
2736 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2737                        PrerenderPageWithFragment) {
2738   PrerenderTestURL("files/prerender/prerender_page.html#fragment",
2739                    FINAL_STATUS_USED,
2740                    1);
2741
2742   ChannelDestructionWatcher channel_close_watcher;
2743   channel_close_watcher.WatchChannel(browser()->tab_strip_model()->
2744       GetActiveWebContents()->GetRenderProcessHost());
2745   NavigateToDestURL();
2746   channel_close_watcher.WaitForChannelClose();
2747
2748   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
2749 }
2750
2751 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2752                        PrerenderPageWithRedirectedFragment) {
2753   PrerenderTestURL(
2754       CreateClientRedirect("files/prerender/prerender_page.html#fragment"),
2755       FINAL_STATUS_USED,
2756       2);
2757
2758   ChannelDestructionWatcher channel_close_watcher;
2759   channel_close_watcher.WatchChannel(browser()->tab_strip_model()->
2760       GetActiveWebContents()->GetRenderProcessHost());
2761   NavigateToDestURL();
2762   channel_close_watcher.WaitForChannelClose();
2763
2764   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
2765 }
2766
2767 // Checks that we do not use a prerendered page when navigating from
2768 // the main page to a fragment.
2769 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2770                        PrerenderPageNavigateFragment) {
2771   PrerenderTestURL("files/prerender/no_prerender_page.html",
2772                    FINAL_STATUS_APP_TERMINATING,
2773                    1);
2774   NavigateToURLWithDisposition(
2775       "files/prerender/no_prerender_page.html#fragment",
2776       CURRENT_TAB, false);
2777 }
2778
2779 // Checks that we do not use a prerendered page when we prerender a fragment
2780 // but navigate to the main page.
2781 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2782                        PrerenderFragmentNavigatePage) {
2783   PrerenderTestURL("files/prerender/no_prerender_page.html#fragment",
2784                    FINAL_STATUS_APP_TERMINATING,
2785                    1);
2786   NavigateToURLWithDisposition(
2787       "files/prerender/no_prerender_page.html",
2788       CURRENT_TAB, false);
2789 }
2790
2791 // Checks that we do not use a prerendered page when we prerender a fragment
2792 // but navigate to a different fragment on the same page.
2793 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2794                        PrerenderFragmentNavigateFragment) {
2795   PrerenderTestURL("files/prerender/no_prerender_page.html#other_fragment",
2796                    FINAL_STATUS_APP_TERMINATING,
2797                    1);
2798   NavigateToURLWithDisposition(
2799       "files/prerender/no_prerender_page.html#fragment",
2800       CURRENT_TAB, false);
2801 }
2802
2803 // Checks that we do not use a prerendered page when the page uses a client
2804 // redirect to refresh from a fragment on the same page.
2805 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2806                        PrerenderClientRedirectFromFragment) {
2807   PrerenderTestURL(
2808       CreateClientRedirect("files/prerender/no_prerender_page.html#fragment"),
2809       FINAL_STATUS_APP_TERMINATING,
2810       2);
2811   NavigateToURLWithDisposition(
2812       "files/prerender/no_prerender_page.html",
2813       CURRENT_TAB, false);
2814 }
2815
2816 // Checks that we do not use a prerendered page when the page uses a client
2817 // redirect to refresh to a fragment on the same page.
2818 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2819                        PrerenderClientRedirectToFragment) {
2820   PrerenderTestURL(
2821       CreateClientRedirect("files/prerender/no_prerender_page.html"),
2822       FINAL_STATUS_APP_TERMINATING,
2823       2);
2824   NavigateToURLWithDisposition(
2825       "files/prerender/no_prerender_page.html#fragment",
2826       CURRENT_TAB, false);
2827 }
2828
2829 // Checks that we correctly use a prerendered page when the page uses JS to set
2830 // the window.location.hash to a fragment on the same page.
2831 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2832                        PrerenderPageChangeFragmentLocationHash) {
2833   PrerenderTestURL("files/prerender/prerender_fragment_location_hash.html",
2834                    FINAL_STATUS_USED,
2835                    1);
2836   NavigateToURL("files/prerender/prerender_fragment_location_hash.html");
2837 }
2838
2839 // Checks that prerendering a PNG works correctly.
2840 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderImagePng) {
2841   DisableJavascriptCalls();
2842   PrerenderTestURL("files/prerender/image.png", FINAL_STATUS_USED, 1);
2843   NavigateToDestURL();
2844 }
2845
2846 // Checks that prerendering a JPG works correctly.
2847 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderImageJpeg) {
2848   DisableJavascriptCalls();
2849   PrerenderTestURL("files/prerender/image.jpeg", FINAL_STATUS_USED, 1);
2850   NavigateToDestURL();
2851 }
2852
2853 // Checks that a prerender of a CRX will result in a cancellation due to
2854 // download.
2855 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCrx) {
2856   PrerenderTestURL("files/prerender/extension.crx", FINAL_STATUS_DOWNLOAD, 0);
2857 }
2858
2859 // Checks that xhr GET requests allow prerenders.
2860 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrGet) {
2861   PrerenderTestURL("files/prerender/prerender_xhr_get.html",
2862                    FINAL_STATUS_USED,
2863                    1);
2864   NavigateToDestURL();
2865 }
2866
2867 // Checks that xhr HEAD requests allow prerenders.
2868 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrHead) {
2869   PrerenderTestURL("files/prerender/prerender_xhr_head.html",
2870                    FINAL_STATUS_USED,
2871                    1);
2872   NavigateToDestURL();
2873 }
2874
2875 // Checks that xhr OPTIONS requests allow prerenders.
2876 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrOptions) {
2877   PrerenderTestURL("files/prerender/prerender_xhr_options.html",
2878                    FINAL_STATUS_USED,
2879                    1);
2880   NavigateToDestURL();
2881 }
2882
2883 // Checks that xhr TRACE requests allow prerenders.
2884 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrTrace) {
2885   PrerenderTestURL("files/prerender/prerender_xhr_trace.html",
2886                    FINAL_STATUS_USED,
2887                    1);
2888   NavigateToDestURL();
2889 }
2890
2891 // Checks that xhr POST requests allow prerenders.
2892 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrPost) {
2893   PrerenderTestURL("files/prerender/prerender_xhr_post.html",
2894                    FINAL_STATUS_USED,
2895                    1);
2896   NavigateToDestURL();
2897 }
2898
2899 // Checks that xhr PUT cancels prerenders.
2900 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrPut) {
2901   PrerenderTestURL("files/prerender/prerender_xhr_put.html",
2902                    FINAL_STATUS_INVALID_HTTP_METHOD,
2903                    1);
2904 }
2905
2906 // Checks that xhr DELETE cancels prerenders.
2907 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrDelete) {
2908   PrerenderTestURL("files/prerender/prerender_xhr_delete.html",
2909                    FINAL_STATUS_INVALID_HTTP_METHOD,
2910                    1);
2911 }
2912
2913 // Checks that a top-level page which would trigger an SSL error is canceled.
2914 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLErrorTopLevel) {
2915   net::SpawnedTestServer::SSLOptions ssl_options;
2916   ssl_options.server_certificate =
2917       net::SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME;
2918   net::SpawnedTestServer https_server(
2919       net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
2920       base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
2921   ASSERT_TRUE(https_server.Start());
2922   GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
2923   PrerenderTestURL(https_url,
2924                    FINAL_STATUS_SSL_ERROR,
2925                    0);
2926 }
2927
2928 // Checks that an SSL error that comes from a subresource does not cancel
2929 // the page. Non-main-frame requests are simply cancelled if they run into
2930 // an SSL problem.
2931 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLErrorSubresource) {
2932   net::SpawnedTestServer::SSLOptions ssl_options;
2933   ssl_options.server_certificate =
2934       net::SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME;
2935   net::SpawnedTestServer https_server(
2936       net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
2937       base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
2938   ASSERT_TRUE(https_server.Start());
2939   GURL https_url = https_server.GetURL("files/prerender/image.jpeg");
2940   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
2941   replacement_text.push_back(
2942       std::make_pair("REPLACE_WITH_IMAGE_URL", https_url.spec()));
2943   std::string replacement_path;
2944   ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
2945       "files/prerender/prerender_with_image.html",
2946       replacement_text,
2947       &replacement_path));
2948   PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
2949   NavigateToDestURL();
2950 }
2951
2952 // Checks that an SSL error that comes from an iframe does not cancel
2953 // the page. Non-main-frame requests are simply cancelled if they run into
2954 // an SSL problem.
2955 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLErrorIframe) {
2956   net::SpawnedTestServer::SSLOptions ssl_options;
2957   ssl_options.server_certificate =
2958       net::SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME;
2959   net::SpawnedTestServer https_server(
2960       net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
2961       base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
2962   ASSERT_TRUE(https_server.Start());
2963   GURL https_url = https_server.GetURL(
2964       "files/prerender/prerender_embedded_content.html");
2965   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
2966   replacement_text.push_back(
2967       std::make_pair("REPLACE_WITH_URL", https_url.spec()));
2968   std::string replacement_path;
2969   ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
2970       "files/prerender/prerender_with_iframe.html",
2971       replacement_text,
2972       &replacement_path));
2973   PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
2974   NavigateToDestURL();
2975 }
2976
2977 // Checks that we cancel correctly when window.print() is called.
2978 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPrint) {
2979   DisableLoadEventCheck();
2980   PrerenderTestURL("files/prerender/prerender_print.html",
2981                    FINAL_STATUS_WINDOW_PRINT,
2982                    0);
2983 }
2984
2985 // Checks that if a page is opened in a new window by javascript and both the
2986 // pages are in the same domain, the prerendered page is not used, due to
2987 // there being other tabs in the same browsing instance.
2988 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
2989                        PrerenderSameDomainWindowOpenerWindowOpen) {
2990   PrerenderTestURL("files/prerender/prerender_page.html",
2991                    FINAL_STATUS_NON_EMPTY_BROWSING_INSTANCE,
2992                    1);
2993   OpenDestURLViaWindowOpen();
2994 }
2995
2996 // Checks that if a page is opened due to click on a href with target="_blank"
2997 // and both pages are in the same domain the prerendered page is not used, due
2998 // there being other tabs in the same browsing instance.
2999 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
3000                        PrerenderSameDomainWindowOpenerClickTarget) {
3001   PrerenderTestURL("files/prerender/prerender_page.html",
3002                    FINAL_STATUS_NON_EMPTY_BROWSING_INSTANCE,
3003                    1);
3004   OpenDestURLViaClickTarget();
3005 }
3006
3007 // Checks that prerenders do not get swapped into target pages that have opened
3008 // a popup, even if the target page itself does not have an opener.
3009 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderTargetHasPopup) {
3010   PrerenderTestURL("files/prerender/prerender_page.html",
3011                    FINAL_STATUS_NON_EMPTY_BROWSING_INSTANCE,
3012                    1);
3013   OpenURLViaWindowOpen(GURL(url::kAboutBlankURL));
3014   NavigateToDestURLWithDisposition(CURRENT_TAB, false);
3015 }
3016
3017 class TestClientCertStore : public net::ClientCertStore {
3018  public:
3019   TestClientCertStore() {}
3020   virtual ~TestClientCertStore() {}
3021
3022   // net::ClientCertStore:
3023   virtual void GetClientCerts(const net::SSLCertRequestInfo& cert_request_info,
3024                               net::CertificateList* selected_certs,
3025                               const base::Closure& callback) override {
3026     *selected_certs = net::CertificateList(
3027         1, scoped_refptr<net::X509Certificate>(
3028         new net::X509Certificate("test", "test", base::Time(), base::Time())));
3029     callback.Run();
3030   }
3031 };
3032
3033 scoped_ptr<net::ClientCertStore> CreateCertStore() {
3034   return scoped_ptr<net::ClientCertStore>(new TestClientCertStore);
3035 }
3036
3037 // Checks that a top-level page which would normally request an SSL client
3038 // certificate will never be seen since it's an https top-level resource.
3039 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
3040                        PrerenderSSLClientCertTopLevel) {
3041   ProfileIOData::FromResourceContext(
3042       current_browser()->profile()->GetResourceContext())->
3043           set_client_cert_store_factory_for_testing(
3044               base::Bind(&CreateCertStore));
3045   net::SpawnedTestServer::SSLOptions ssl_options;
3046   ssl_options.request_client_certificate = true;
3047   net::SpawnedTestServer https_server(
3048       net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
3049       base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
3050   ASSERT_TRUE(https_server.Start());
3051   GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
3052   PrerenderTestURL(https_url, FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED, 0);
3053 }
3054
3055 // Checks that an SSL Client Certificate request that originates from a
3056 // subresource will cancel the prerendered page.
3057 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
3058                        PrerenderSSLClientCertSubresource) {
3059   ProfileIOData::FromResourceContext(
3060       current_browser()->profile()->GetResourceContext())->
3061           set_client_cert_store_factory_for_testing(
3062               base::Bind(&CreateCertStore));
3063   net::SpawnedTestServer::SSLOptions ssl_options;
3064   ssl_options.request_client_certificate = true;
3065   net::SpawnedTestServer https_server(
3066       net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
3067       base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
3068   ASSERT_TRUE(https_server.Start());
3069   GURL https_url = https_server.GetURL("files/prerender/image.jpeg");
3070   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
3071   replacement_text.push_back(
3072       std::make_pair("REPLACE_WITH_IMAGE_URL", https_url.spec()));
3073   std::string replacement_path;
3074   ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
3075       "files/prerender/prerender_with_image.html",
3076       replacement_text,
3077       &replacement_path));
3078   PrerenderTestURL(replacement_path,
3079                    FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED,
3080                    0);
3081 }
3082
3083 // Checks that an SSL Client Certificate request that originates from an
3084 // iframe will cancel the prerendered page.
3085 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLClientCertIframe) {
3086   ProfileIOData::FromResourceContext(
3087       current_browser()->profile()->GetResourceContext())->
3088           set_client_cert_store_factory_for_testing(
3089               base::Bind(&CreateCertStore));
3090   net::SpawnedTestServer::SSLOptions ssl_options;
3091   ssl_options.request_client_certificate = true;
3092   net::SpawnedTestServer https_server(
3093       net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
3094       base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
3095   ASSERT_TRUE(https_server.Start());
3096   GURL https_url = https_server.GetURL(
3097       "files/prerender/prerender_embedded_content.html");
3098   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
3099   replacement_text.push_back(
3100       std::make_pair("REPLACE_WITH_URL", https_url.spec()));
3101   std::string replacement_path;
3102   ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
3103       "files/prerender/prerender_with_iframe.html",
3104       replacement_text,
3105       &replacement_path));
3106   PrerenderTestURL(replacement_path,
3107                    FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED,
3108                    0);
3109 }
3110
3111 #if defined(FULL_SAFE_BROWSING)
3112 // Ensures that we do not prerender pages with a safe browsing
3113 // interstitial.
3114 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSafeBrowsingTopLevel) {
3115   GURL url = test_server()->GetURL("files/prerender/prerender_page.html");
3116   GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
3117       url, SB_THREAT_TYPE_URL_MALWARE);
3118   PrerenderTestURL("files/prerender/prerender_page.html",
3119                    FINAL_STATUS_SAFE_BROWSING, 0);
3120 }
3121
3122 // Ensures that server redirects to a malware page will cancel prerenders.
3123 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
3124                        PrerenderSafeBrowsingServerRedirect) {
3125   GURL url = test_server()->GetURL("files/prerender/prerender_page.html");
3126   GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
3127       url, SB_THREAT_TYPE_URL_MALWARE);
3128   PrerenderTestURL(CreateServerRedirect("files/prerender/prerender_page.html"),
3129                    FINAL_STATUS_SAFE_BROWSING,
3130                    0);
3131 }
3132
3133 // Ensures that client redirects to a malware page will cancel prerenders.
3134 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
3135                        PrerenderSafeBrowsingClientRedirect) {
3136   GURL url = test_server()->GetURL("files/prerender/prerender_page.html");
3137   GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
3138       url, SB_THREAT_TYPE_URL_MALWARE);
3139   PrerenderTestURL(CreateClientRedirect("files/prerender/prerender_page.html"),
3140                    FINAL_STATUS_SAFE_BROWSING,
3141                    1);
3142 }
3143
3144 // Ensures that we do not prerender pages which have a malware subresource.
3145 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSafeBrowsingSubresource) {
3146   GURL image_url = test_server()->GetURL("files/prerender/image.jpeg");
3147   GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
3148       image_url, SB_THREAT_TYPE_URL_MALWARE);
3149   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
3150   replacement_text.push_back(
3151       std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
3152   std::string replacement_path;
3153   ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
3154       "files/prerender/prerender_with_image.html",
3155       replacement_text,
3156       &replacement_path));
3157   PrerenderTestURL(replacement_path,
3158                    FINAL_STATUS_SAFE_BROWSING,
3159                    0);
3160 }
3161
3162 // Ensures that we do not prerender pages which have a malware iframe.
3163 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSafeBrowsingIframe) {
3164   GURL iframe_url = test_server()->GetURL(
3165       "files/prerender/prerender_embedded_content.html");
3166   GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
3167       iframe_url, SB_THREAT_TYPE_URL_MALWARE);
3168   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
3169   replacement_text.push_back(
3170       std::make_pair("REPLACE_WITH_URL", iframe_url.spec()));
3171   std::string replacement_path;
3172   ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
3173       "files/prerender/prerender_with_iframe.html",
3174       replacement_text,
3175       &replacement_path));
3176   PrerenderTestURL(replacement_path,
3177                    FINAL_STATUS_SAFE_BROWSING,
3178                    0);
3179 }
3180
3181 #endif
3182
3183 // Checks that a local storage read will not cause prerender to fail.
3184 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderLocalStorageRead) {
3185   PrerenderTestURL("files/prerender/prerender_localstorage_read.html",
3186                    FINAL_STATUS_USED,
3187                    1);
3188   NavigateToDestURL();
3189 }
3190
3191 // Checks that a local storage write will not cause prerender to fail.
3192 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderLocalStorageWrite) {
3193   PrerenderTestURL("files/prerender/prerender_localstorage_write.html",
3194                    FINAL_STATUS_USED,
3195                    1);
3196   NavigateToDestURL();
3197 }
3198
3199 // Checks that the favicon is properly loaded on prerender.
3200 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderFavicon) {
3201   scoped_ptr<TestPrerender> prerender =
3202       PrerenderTestURL("files/prerender/prerender_favicon.html",
3203                        FINAL_STATUS_USED,
3204                        1);
3205   NavigateToDestURL();
3206
3207   if (!FaviconTabHelper::FromWebContents(
3208           GetActiveWebContents())->FaviconIsValid()) {
3209     // If the favicon has not been set yet, wait for it to be.
3210     content::WindowedNotificationObserver favicon_update_watcher(
3211         chrome::NOTIFICATION_FAVICON_UPDATED,
3212         content::Source<WebContents>(GetActiveWebContents()));
3213     favicon_update_watcher.Wait();
3214   }
3215   EXPECT_TRUE(FaviconTabHelper::FromWebContents(
3216       GetActiveWebContents())->FaviconIsValid());
3217 }
3218
3219 // Checks that when a prerendered page is swapped in to a referring page, the
3220 // unload handlers on the referring page are executed.
3221 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderUnload) {
3222   // Matches URL in prerender_loader_with_unload.html.
3223   const GURL unload_url("http://unload-url.test");
3224   base::FilePath empty_file = ui_test_utils::GetTestFilePath(
3225       base::FilePath(), base::FilePath(FILE_PATH_LITERAL("empty.html")));
3226   RequestCounter unload_counter;
3227   BrowserThread::PostTask(
3228       BrowserThread::IO, FROM_HERE,
3229       base::Bind(&CreateCountingInterceptorOnIO,
3230                  unload_url, empty_file, unload_counter.AsWeakPtr()));
3231
3232   set_loader_path("files/prerender/prerender_loader_with_unload.html");
3233   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
3234   NavigateToDestURL();
3235   unload_counter.WaitForCount(1);
3236 }
3237
3238 // Checks that a hanging unload on the referring page of a prerender swap does
3239 // not crash the browser on exit.
3240 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHangingUnload) {
3241   // Matches URL in prerender_loader_with_unload.html.
3242   const GURL hang_url("http://unload-url.test");
3243   base::FilePath empty_file = ui_test_utils::GetTestFilePath(
3244       base::FilePath(), base::FilePath(FILE_PATH_LITERAL("empty.html")));
3245   BrowserThread::PostTask(
3246       BrowserThread::IO, FROM_HERE,
3247       base::Bind(&CreateHangingFirstRequestInterceptorOnIO,
3248                  hang_url, empty_file,
3249                  base::Closure()));
3250
3251   set_loader_path("files/prerender/prerender_loader_with_unload.html");
3252   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
3253   NavigateToDestURL();
3254 }
3255
3256
3257 // Checks that when the history is cleared, prerendering is cancelled and
3258 // prerendering history is cleared.
3259 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClearHistory) {
3260   scoped_ptr<TestPrerender> prerender =
3261       PrerenderTestURL("files/prerender/prerender_page.html",
3262                        FINAL_STATUS_CACHE_OR_HISTORY_CLEARED,
3263                        1);
3264
3265   ClearBrowsingData(current_browser(), BrowsingDataRemover::REMOVE_HISTORY);
3266   prerender->WaitForStop();
3267
3268   // Make sure prerender history was cleared.
3269   EXPECT_EQ(0, GetHistoryLength());
3270 }
3271
3272 // Checks that when the cache is cleared, prerenders are cancelled but
3273 // prerendering history is not cleared.
3274 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClearCache) {
3275   scoped_ptr<TestPrerender> prerender =
3276       PrerenderTestURL("files/prerender/prerender_page.html",
3277                        FINAL_STATUS_CACHE_OR_HISTORY_CLEARED,
3278                        1);
3279
3280   ClearBrowsingData(current_browser(), BrowsingDataRemover::REMOVE_CACHE);
3281   prerender->WaitForStop();
3282
3283   // Make sure prerender history was not cleared.  Not a vital behavior, but
3284   // used to compare with PrerenderClearHistory test.
3285   EXPECT_EQ(1, GetHistoryLength());
3286 }
3287
3288 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCancelAll) {
3289   scoped_ptr<TestPrerender> prerender =
3290       PrerenderTestURL("files/prerender/prerender_page.html",
3291                        FINAL_STATUS_CANCELLED,
3292                        1);
3293
3294   GetPrerenderManager()->CancelAllPrerenders();
3295   prerender->WaitForStop();
3296
3297   EXPECT_FALSE(prerender->contents());
3298 }
3299
3300 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderEvents) {
3301   scoped_ptr<TestPrerender> prerender =
3302       PrerenderTestURL("files/prerender/prerender_page.html",
3303                        FINAL_STATUS_CANCELLED, 1);
3304
3305   GetPrerenderManager()->CancelAllPrerenders();
3306   prerender->WaitForStop();
3307
3308   EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
3309   EXPECT_TRUE(DidReceivePrerenderStopEventForLinkNumber(0));
3310   EXPECT_FALSE(HadPrerenderEventErrors());
3311 }
3312
3313 // Cancels the prerender of a page with its own prerender.  The second prerender
3314 // should never be started.
3315 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
3316                        PrerenderCancelPrerenderWithPrerender) {
3317   scoped_ptr<TestPrerender> prerender =
3318       PrerenderTestURL("files/prerender/prerender_infinite_a.html",
3319                        FINAL_STATUS_CANCELLED,
3320                        1);
3321
3322   GetPrerenderManager()->CancelAllPrerenders();
3323   prerender->WaitForStop();
3324
3325   EXPECT_FALSE(prerender->contents());
3326 }
3327
3328 // Prerendering and history tests.
3329 // The prerendered page is navigated to in several ways [navigate via
3330 // omnibox, click on link, key-modified click to open in background tab, etc],
3331 // followed by a navigation to another page from the prerendered page, followed
3332 // by a back navigation.
3333
3334 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNavigateClickGoBack) {
3335   PrerenderTestURL("files/prerender/prerender_page_with_link.html",
3336                    FINAL_STATUS_USED,
3337                    1);
3338   NavigateToDestURL();
3339   ClickToNextPageAfterPrerender();
3340   GoBackToPrerender();
3341 }
3342
3343 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNavigateNavigateGoBack) {
3344   PrerenderTestURL("files/prerender/prerender_page_with_link.html",
3345                    FINAL_STATUS_USED,
3346                    1);
3347   NavigateToDestURL();
3348   NavigateToNextPageAfterPrerender();
3349   GoBackToPrerender();
3350 }
3351
3352 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickClickGoBack) {
3353   PrerenderTestURL("files/prerender/prerender_page_with_link.html",
3354                    FINAL_STATUS_USED,
3355                    1);
3356   OpenDestURLViaClick();
3357   ClickToNextPageAfterPrerender();
3358   GoBackToPrerender();
3359 }
3360
3361 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickNavigateGoBack) {
3362   PrerenderTestURL("files/prerender/prerender_page_with_link.html",
3363                    FINAL_STATUS_USED,
3364                    1);
3365   OpenDestURLViaClick();
3366   NavigateToNextPageAfterPrerender();
3367   GoBackToPrerender();
3368 }
3369
3370 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickNewWindow) {
3371   // Prerender currently doesn't interpose on this navigation.
3372   // http://crbug.com/345474.
3373   PrerenderTestURL("files/prerender/prerender_page_with_link.html",
3374                    FINAL_STATUS_USED,
3375                    1);
3376   OpenDestURLViaClickNewWindow();
3377 }
3378
3379 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickNewForegroundTab) {
3380   // Prerender currently doesn't interpose on this navigation.
3381   // http://crbug.com/345474.
3382   PrerenderTestURL("files/prerender/prerender_page_with_link.html",
3383                    FINAL_STATUS_USED,
3384                    1);
3385   OpenDestURLViaClickNewForegroundTab();
3386 }
3387
3388 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickNewBackgroundTab) {
3389   // Prerender currently doesn't interpose on this navigation.
3390   // http://crbug.com/345474.
3391   scoped_ptr<TestPrerender> prerender =
3392       PrerenderTestURL("files/prerender/prerender_page_with_link.html",
3393                        FINAL_STATUS_USED,
3394                        1);
3395   ASSERT_TRUE(prerender->contents());
3396   prerender->contents()->set_should_be_shown(false);
3397   OpenDestURLViaClickNewBackgroundTab();
3398 }
3399
3400 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
3401                        NavigateToPrerenderedPageWhenDevToolsAttached) {
3402   DisableJavascriptCalls();
3403   WebContents* web_contents =
3404       current_browser()->tab_strip_model()->GetActiveWebContents();
3405   scoped_refptr<DevToolsAgentHost> agent(
3406       DevToolsAgentHost::GetOrCreateFor(web_contents));
3407   FakeDevToolsClient client;
3408   agent->AttachClient(&client);
3409   const char* url = "files/prerender/prerender_page.html";
3410   PrerenderTestURL(url, FINAL_STATUS_DEVTOOLS_ATTACHED, 1);
3411   NavigateToURLWithDisposition(url, CURRENT_TAB, false);
3412   agent->DetachClient();
3413 }
3414
3415 // Validate that the sessionStorage namespace remains the same when swapping
3416 // in a prerendered page.
3417 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSessionStorage) {
3418   set_loader_path("files/prerender/prerender_loader_with_session_storage.html");
3419   PrerenderTestURL(GetCrossDomainTestUrl("files/prerender/prerender_page.html"),
3420                    FINAL_STATUS_USED,
3421                    1);
3422   NavigateToDestURL();
3423   GoBackToPageBeforePrerender();
3424 }
3425
3426 // Checks that the control group works.  An XHR PUT cannot be detected in the
3427 // control group.
3428 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, ControlGroup) {
3429   RestorePrerenderMode restore_prerender_mode;
3430   PrerenderManager::SetMode(
3431       PrerenderManager::PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP);
3432   DisableJavascriptCalls();
3433   PrerenderTestURL("files/prerender/prerender_xhr_put.html",
3434                    FINAL_STATUS_WOULD_HAVE_BEEN_USED, 0);
3435   NavigateToDestURL();
3436 }
3437
3438 // Checks that the control group correctly hits WOULD_HAVE_BEEN_USED
3439 // renderer-initiated navigations. (This verifies that the ShouldFork logic
3440 // behaves correctly.)
3441 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, ControlGroupRendererInitiated) {
3442   RestorePrerenderMode restore_prerender_mode;
3443   PrerenderManager::SetMode(
3444       PrerenderManager::PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP);
3445   DisableJavascriptCalls();
3446   PrerenderTestURL("files/prerender/prerender_xhr_put.html",
3447                    FINAL_STATUS_WOULD_HAVE_BEEN_USED, 0);
3448   OpenDestURLViaClick();
3449 }
3450
3451 // Make sure that the MatchComplete dummy works in the normal case.  Once
3452 // a prerender is cancelled because of a script, a dummy must be created to
3453 // account for the MatchComplete case, and it must have a final status of
3454 // FINAL_STATUS_WOULD_HAVE_BEEN_USED.
3455 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, MatchCompleteDummy) {
3456   RestorePrerenderMode restore_prerender_mode;
3457   PrerenderManager::SetMode(
3458       PrerenderManager::PRERENDER_MODE_EXPERIMENT_MATCH_COMPLETE_GROUP);
3459
3460   std::vector<FinalStatus> expected_final_status_queue;
3461   expected_final_status_queue.push_back(FINAL_STATUS_INVALID_HTTP_METHOD);
3462   expected_final_status_queue.push_back(FINAL_STATUS_WOULD_HAVE_BEEN_USED);
3463   PrerenderTestURL("files/prerender/prerender_xhr_put.html",
3464                    expected_final_status_queue, 1);
3465   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
3466   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
3467   histogram_tester().ExpectTotalCount(
3468       "Prerender.none_PerceivedPLTMatchedComplete", 0);
3469   histogram_tester().ExpectTotalCount(
3470       "Prerender.websame_PrerenderNotSwappedInPLT", 1);
3471
3472   NavigateToDestURL();
3473   histogram_tester().ExpectTotalCount("Prerender.websame_PerceivedPLT", 1);
3474   histogram_tester().ExpectTotalCount("Prerender.websame_PerceivedPLTMatched",
3475                                       0);
3476   histogram_tester().ExpectTotalCount(
3477       "Prerender.websame_PerceivedPLTMatchedComplete", 1);
3478 }
3479
3480 // Verify that a navigation that hits a MatchComplete dummy while another is in
3481 // progress does not also classify the previous navigation as a MatchComplete.
3482 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
3483                        MatchCompleteDummyCancelNavigation) {
3484   RestorePrerenderMode restore_prerender_mode;
3485   PrerenderManager::SetMode(
3486       PrerenderManager::PRERENDER_MODE_EXPERIMENT_MATCH_COMPLETE_GROUP);
3487
3488   // Arrange for a URL to hang.
3489   const GURL kNoCommitUrl("http://never-respond.example.com");
3490   base::FilePath file(FILE_PATH_LITERAL(
3491       "chrome/test/data/prerender/prerender_page.html"));
3492   base::RunLoop hang_loop;
3493   BrowserThread::PostTask(
3494       BrowserThread::IO, FROM_HERE,
3495       base::Bind(&CreateHangingFirstRequestInterceptorOnIO, kNoCommitUrl,
3496                  file, hang_loop.QuitClosure()));
3497
3498   // First, fire a prerender that aborts after it completes its load.
3499   std::vector<FinalStatus> expected_final_status_queue;
3500   expected_final_status_queue.push_back(FINAL_STATUS_INVALID_HTTP_METHOD);
3501   expected_final_status_queue.push_back(FINAL_STATUS_WOULD_HAVE_BEEN_USED);
3502   PrerenderTestURL("files/prerender/prerender_xhr_put.html",
3503                    expected_final_status_queue, 1);
3504   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
3505   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
3506   histogram_tester().ExpectTotalCount(
3507       "Prerender.none_PerceivedPLTMatchedComplete", 0);
3508   histogram_tester().ExpectTotalCount(
3509       "Prerender.websame_PrerenderNotSwappedInPLT", 1);
3510
3511   // Open the hanging URL in a new tab. Wait for both the new tab to open and
3512   // the hanging request to be scheduled.
3513   ui_test_utils::NavigateToURLWithDisposition(
3514       current_browser(), kNoCommitUrl, NEW_FOREGROUND_TAB,
3515       ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
3516   hang_loop.Run();
3517
3518   // Now interrupt that navigation and navigate to the destination URL. This
3519   // should forcibly complete the previous navigation and also complete a
3520   // WOULD_HAVE_BEEN_PRERENDERED navigation.
3521   NavigateToDestURL();
3522   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLT", 2);
3523   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
3524   histogram_tester().ExpectTotalCount(
3525       "Prerender.none_PerceivedPLTMatchedComplete", 0);
3526   histogram_tester().ExpectTotalCount("Prerender.websame_PerceivedPLT", 1);
3527   histogram_tester().ExpectTotalCount("Prerender.websame_PerceivedPLTMatched",
3528                                       0);
3529   histogram_tester().ExpectTotalCount(
3530       "Prerender.websame_PerceivedPLTMatchedComplete", 1);
3531 }
3532
3533 class PrerenderBrowserTestWithNaCl : public PrerenderBrowserTest {
3534  public:
3535   PrerenderBrowserTestWithNaCl() {}
3536   virtual ~PrerenderBrowserTestWithNaCl() {}
3537
3538   virtual void SetUpCommandLine(CommandLine* command_line) override {
3539     PrerenderBrowserTest::SetUpCommandLine(command_line);
3540     command_line->AppendSwitch(switches::kEnableNaCl);
3541   }
3542 };
3543
3544 // Check that NaCl plugins work when enabled, with prerendering.
3545 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTestWithNaCl,
3546                        PrerenderNaClPluginEnabled) {
3547 #if defined(OS_WIN) && defined(USE_ASH)
3548   // Disable this test in Metro+Ash for now (http://crbug.com/262796).
3549   if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
3550     return;
3551 #endif
3552
3553   PrerenderTestURL("files/prerender/prerender_plugin_nacl_enabled.html",
3554                    FINAL_STATUS_USED,
3555                    1);
3556   NavigateToDestURL();
3557
3558   // To avoid any chance of a race, we have to let the script send its response
3559   // asynchronously.
3560   WebContents* web_contents =
3561       browser()->tab_strip_model()->GetActiveWebContents();
3562   bool display_test_result = false;
3563   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(web_contents,
3564                                                    "DidDisplayReallyPass()",
3565                                                    &display_test_result));
3566   ASSERT_TRUE(display_test_result);
3567 }
3568
3569 // Checks that the referrer policy is used when prerendering.
3570 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderReferrerPolicy) {
3571   set_loader_path("files/prerender/prerender_loader_with_referrer_policy.html");
3572   PrerenderTestURL("files/prerender/prerender_referrer_policy.html",
3573                    FINAL_STATUS_USED,
3574                    1);
3575   NavigateToDestURL();
3576 }
3577
3578 // Checks that the referrer policy is used when prerendering on HTTPS.
3579 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
3580                        PrerenderSSLReferrerPolicy) {
3581   UseHttpsSrcServer();
3582   set_loader_path("files/prerender/prerender_loader_with_referrer_policy.html");
3583   PrerenderTestURL("files/prerender/prerender_referrer_policy.html",
3584                    FINAL_STATUS_USED,
3585                    1);
3586   NavigateToDestURL();
3587 }
3588
3589 // Checks that the referrer policy is used when prerendering is cancelled.
3590 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCancelReferrerPolicy) {
3591   scoped_ptr<TestContentBrowserClient> test_content_browser_client(
3592       new TestContentBrowserClient);
3593   content::ContentBrowserClient* original_browser_client =
3594       content::SetBrowserClientForTesting(test_content_browser_client.get());
3595
3596   set_loader_path("files/prerender/prerender_loader_with_referrer_policy.html");
3597   PrerenderTestURL("files/prerender/prerender_referrer_policy.html",
3598                    FINAL_STATUS_CANCELLED,
3599                    1);
3600   OpenDestURLViaClick();
3601
3602   bool display_test_result = false;
3603   WebContents* web_contents =
3604       browser()->tab_strip_model()->GetActiveWebContents();
3605   ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
3606       web_contents,
3607       "window.domAutomationController.send(DidDisplayPass())",
3608       &display_test_result));
3609   EXPECT_TRUE(display_test_result);
3610
3611   content::SetBrowserClientForTesting(original_browser_client);
3612 }
3613
3614 // Test interaction of the webNavigation and tabs API with prerender.
3615 class PrerenderBrowserTestWithExtensions : public PrerenderBrowserTest,
3616                                            public ExtensionApiTest {
3617  public:
3618   PrerenderBrowserTestWithExtensions() {
3619     // The individual tests start the test server through ExtensionApiTest, so
3620     // the port number can be passed through to the extension.
3621     autostart_test_server_ = false;
3622   }
3623
3624   virtual void SetUp() override {
3625     PrerenderBrowserTest::SetUp();
3626   }
3627
3628   virtual void SetUpCommandLine(CommandLine* command_line) override {
3629     PrerenderBrowserTest::SetUpCommandLine(command_line);
3630     ExtensionApiTest::SetUpCommandLine(command_line);
3631   }
3632
3633   virtual void SetUpInProcessBrowserTestFixture() override {
3634     PrerenderBrowserTest::SetUpInProcessBrowserTestFixture();
3635     ExtensionApiTest::SetUpInProcessBrowserTestFixture();
3636   }
3637
3638   virtual void TearDownInProcessBrowserTestFixture() override {
3639     PrerenderBrowserTest::TearDownInProcessBrowserTestFixture();
3640     ExtensionApiTest::TearDownInProcessBrowserTestFixture();
3641   }
3642
3643   virtual void SetUpOnMainThread() override {
3644     PrerenderBrowserTest::SetUpOnMainThread();
3645   }
3646 };
3647
3648 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTestWithExtensions, WebNavigation) {
3649   ASSERT_TRUE(StartSpawnedTestServer());
3650   extensions::FrameNavigationState::set_allow_extension_scheme(true);
3651
3652   // Wait for the extension to set itself up and return control to us.
3653   ASSERT_TRUE(RunExtensionTest("webnavigation/prerender")) << message_;
3654
3655   extensions::ResultCatcher catcher;
3656
3657   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
3658
3659   ChannelDestructionWatcher channel_close_watcher;
3660   channel_close_watcher.WatchChannel(browser()->tab_strip_model()->
3661       GetActiveWebContents()->GetRenderProcessHost());
3662   NavigateToDestURL();
3663   channel_close_watcher.WaitForChannelClose();
3664
3665   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
3666   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
3667 }
3668
3669 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTestWithExtensions, TabsApi) {
3670   ASSERT_TRUE(StartSpawnedTestServer());
3671   extensions::FrameNavigationState::set_allow_extension_scheme(true);
3672
3673   // Wait for the extension to set itself up and return control to us.
3674   ASSERT_TRUE(RunExtensionTest("tabs/on_replaced")) << message_;
3675
3676   extensions::ResultCatcher catcher;
3677
3678   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
3679
3680   ChannelDestructionWatcher channel_close_watcher;
3681   channel_close_watcher.WatchChannel(browser()->tab_strip_model()->
3682       GetActiveWebContents()->GetRenderProcessHost());
3683   NavigateToDestURL();
3684   channel_close_watcher.WaitForChannelClose();
3685
3686   ASSERT_TRUE(IsEmptyPrerenderLinkManager());
3687   ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
3688 }
3689
3690 // Test that prerenders abort when navigating to a stream.
3691 // See chrome/browser/extensions/api/streams_private/streams_private_apitest.cc
3692 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTestWithExtensions, StreamsTest) {
3693   RestorePrerenderMode restore_prerender_mode;
3694   PrerenderManager::SetMode(
3695       PrerenderManager::PRERENDER_MODE_EXPERIMENT_MATCH_COMPLETE_GROUP);
3696
3697   ASSERT_TRUE(StartSpawnedTestServer());
3698
3699   const extensions::Extension* extension = LoadExtension(
3700       test_data_dir_.AppendASCII("streams_private/handle_mime_type"));
3701   ASSERT_TRUE(extension);
3702   EXPECT_EQ(std::string(extension_misc::kStreamsPrivateTestExtensionId),
3703             extension->id());
3704   MimeTypesHandler* handler = MimeTypesHandler::GetHandler(extension);
3705   ASSERT_TRUE(handler);
3706   EXPECT_TRUE(handler->CanHandleMIMEType("application/msword"));
3707
3708   PrerenderTestURL("files/prerender/document.doc", FINAL_STATUS_DOWNLOAD, 0);
3709
3710   // Sanity-check that the extension would have picked up the stream in a normal
3711   // navigation had prerender not intercepted it.
3712   // streams_private/handle_mime_type reports success if it has handled the
3713   // application/msword type.
3714   extensions::ResultCatcher catcher;
3715   NavigateToDestURL();
3716   EXPECT_TRUE(catcher.GetNextResult());
3717 }
3718
3719 // Checks that non-http/https/chrome-extension subresource cancels the
3720 // prerender.
3721 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
3722                        PrerenderCancelSubresourceUnsupportedScheme) {
3723   GURL image_url = GURL("invalidscheme://www.google.com/test.jpg");
3724   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
3725   replacement_text.push_back(
3726       std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
3727   std::string replacement_path;
3728   ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
3729       "files/prerender/prerender_with_image.html",
3730       replacement_text,
3731       &replacement_path));
3732   PrerenderTestURL(replacement_path, FINAL_STATUS_UNSUPPORTED_SCHEME, 0);
3733 }
3734
3735 // Ensure that about:blank is permitted for any subresource.
3736 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
3737                        PrerenderAllowAboutBlankSubresource) {
3738   GURL image_url = GURL("about:blank");
3739   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
3740   replacement_text.push_back(
3741       std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
3742   std::string replacement_path;
3743   ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
3744       "files/prerender/prerender_with_image.html",
3745       replacement_text,
3746       &replacement_path));
3747   PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
3748   NavigateToDestURL();
3749 }
3750
3751 // Checks that non-http/https/chrome-extension subresource cancels the prerender
3752 // on redirect.
3753 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
3754                        PrerenderCancelSubresourceRedirectUnsupportedScheme) {
3755   GURL image_url = test_server()->GetURL(
3756       CreateServerRedirect("invalidscheme://www.google.com/test.jpg"));
3757   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
3758   replacement_text.push_back(
3759       std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
3760   std::string replacement_path;
3761   ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
3762       "files/prerender/prerender_with_image.html",
3763       replacement_text,
3764       &replacement_path));
3765   PrerenderTestURL(replacement_path, FINAL_STATUS_UNSUPPORTED_SCHEME, 0);
3766 }
3767
3768 // Checks that chrome-extension subresource does not cancel the prerender.
3769 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
3770                        PrerenderKeepSubresourceExtensionScheme) {
3771   GURL image_url = GURL("chrome-extension://abcdefg/test.jpg");
3772   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
3773   replacement_text.push_back(
3774       std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
3775   std::string replacement_path;
3776   ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
3777       "files/prerender/prerender_with_image.html",
3778       replacement_text,
3779       &replacement_path));
3780   PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
3781   NavigateToDestURL();
3782 }
3783
3784 // Checks that redirect to chrome-extension subresource does not cancel the
3785 // prerender.
3786 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
3787                        PrerenderKeepSubresourceRedirectExtensionScheme) {
3788   GURL image_url = test_server()->GetURL(
3789       CreateServerRedirect("chrome-extension://abcdefg/test.jpg"));
3790   std::vector<net::SpawnedTestServer::StringPair> replacement_text;
3791   replacement_text.push_back(
3792       std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
3793   std::string replacement_path;
3794   ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
3795       "files/prerender/prerender_with_image.html",
3796       replacement_text,
3797       &replacement_path));
3798   PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
3799   NavigateToDestURL();
3800 }
3801
3802 // Checks that non-http/https main page redirects cancel the prerender.
3803 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
3804                        PrerenderCancelMainFrameRedirectUnsupportedScheme) {
3805   GURL url = test_server()->GetURL(
3806       CreateServerRedirect("invalidscheme://www.google.com/test.html"));
3807   PrerenderTestURL(url, FINAL_STATUS_UNSUPPORTED_SCHEME, 0);
3808 }
3809
3810 // Checks that media source video loads are deferred on prerendering.
3811 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5MediaSourceVideo) {
3812   PrerenderTestURL("files/prerender/prerender_html5_video_media_source.html",
3813                    FINAL_STATUS_USED,
3814                    1);
3815   NavigateToDestURL();
3816   WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
3817 }
3818
3819 // Checks that a prerender that creates an audio stream (via a WebAudioDevice)
3820 // is cancelled.
3821 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderWebAudioDevice) {
3822   DisableLoadEventCheck();
3823   PrerenderTestURL("files/prerender/prerender_web_audio_device.html",
3824                    FINAL_STATUS_CREATING_AUDIO_STREAM, 0);
3825 }
3826
3827 // Checks that prerenders do not swap in to WebContents being captured.
3828 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCapturedWebContents) {
3829   PrerenderTestURL("files/prerender/prerender_page.html",
3830                    FINAL_STATUS_PAGE_BEING_CAPTURED, 1);
3831   WebContents* web_contents = GetActiveWebContents();
3832   web_contents->IncrementCapturerCount(gfx::Size());
3833   NavigateToDestURLWithDisposition(CURRENT_TAB, false);
3834   web_contents->DecrementCapturerCount();
3835 }
3836
3837 // Checks that prerenders are aborted on cross-process navigation from
3838 // a server redirect.
3839 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
3840                        PrerenderCrossProcessServerRedirect) {
3841   // Force everything to be a process swap.
3842   SwapProcessesContentBrowserClient test_browser_client;
3843   content::ContentBrowserClient* original_browser_client =
3844       content::SetBrowserClientForTesting(&test_browser_client);
3845
3846   PrerenderTestURL(
3847       CreateServerRedirect("files/prerender/prerender_page.html"),
3848       FINAL_STATUS_OPEN_URL, 0);
3849
3850   content::SetBrowserClientForTesting(original_browser_client);
3851 }
3852
3853 // Checks that URLRequests for prerenders being aborted on cross-process
3854 // navigation from a server redirect are cleaned up, so they don't keep cache
3855 // entries locked.
3856 // See http://crbug.com/341134
3857 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
3858                        PrerenderCrossProcessServerRedirectNoHang) {
3859   const char kDestPath[] = "files/prerender/prerender_page.html";
3860   // Force everything to be a process swap.
3861   SwapProcessesContentBrowserClient test_browser_client;
3862   content::ContentBrowserClient* original_browser_client =
3863       content::SetBrowserClientForTesting(&test_browser_client);
3864
3865   PrerenderTestURL(CreateServerRedirect(kDestPath), FINAL_STATUS_OPEN_URL, 0);
3866
3867   ui_test_utils::NavigateToURL(
3868       browser(),
3869       test_server()->GetURL(kDestPath));
3870
3871   content::SetBrowserClientForTesting(original_browser_client);
3872 }
3873
3874 // Checks that prerenders are aborted on cross-process navigation from
3875 // a client redirect.
3876 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
3877                        PrerenderCrossProcessClientRedirect) {
3878   // Cross-process navigation logic for renderer-initiated navigations
3879   // is partially controlled by the renderer, namely
3880   // ChromeContentRendererClient. This test instead relies on the Web
3881   // Store triggering such navigations.
3882   std::string webstore_url = extension_urls::GetWebstoreLaunchURL();
3883
3884   // Mock out requests to the Web Store.
3885   base::FilePath file(GetTestPath("prerender_page.html"));
3886   BrowserThread::PostTask(
3887       BrowserThread::IO, FROM_HERE,
3888       base::Bind(&CreateMockInterceptorOnIO, GURL(webstore_url), file));
3889
3890   PrerenderTestURL(CreateClientRedirect(webstore_url),
3891                    FINAL_STATUS_OPEN_URL, 1);
3892 }
3893
3894 // Checks that canceling a MatchComplete dummy doesn't result in two
3895 // stop events.
3896 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, CancelMatchCompleteDummy) {
3897   RestorePrerenderMode restore_prerender_mode;
3898   PrerenderManager::SetMode(
3899       PrerenderManager::PRERENDER_MODE_EXPERIMENT_MATCH_COMPLETE_GROUP);
3900
3901   std::vector<FinalStatus> expected_final_status_queue;
3902   expected_final_status_queue.push_back(FINAL_STATUS_JAVASCRIPT_ALERT);
3903   expected_final_status_queue.push_back(FINAL_STATUS_CANCELLED);
3904   ScopedVector<TestPrerender> prerenders =
3905       PrerenderTestURL("files/prerender/prerender_alert_before_onload.html",
3906                        expected_final_status_queue, 0);
3907
3908   // Cancel the MatchComplete dummy.
3909   GetPrerenderManager()->CancelAllPrerenders();
3910   prerenders[1]->WaitForStop();
3911
3912   // Check the referring page only got one copy of the event.
3913   EXPECT_FALSE(HadPrerenderEventErrors());
3914 }
3915
3916 // Checks that a deferred redirect to an image is not loaded until the page is
3917 // visible. Also test the right histogram events are emitted in this case.
3918 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDeferredImage) {
3919   DisableJavascriptCalls();
3920
3921   // The prerender will not completely load until after the swap, so wait for a
3922   // title change before calling DidPrerenderPass.
3923   scoped_ptr<TestPrerender> prerender =
3924       PrerenderTestURL(
3925           "files/prerender/prerender_deferred_image.html",
3926           FINAL_STATUS_USED, 0);
3927   WaitForASCIITitle(prerender->contents()->prerender_contents(), kReadyTitle);
3928   EXPECT_EQ(1, GetPrerenderDomContentLoadedEventCountForLinkNumber(0));
3929   EXPECT_TRUE(DidPrerenderPass(prerender->contents()->prerender_contents()));
3930   EXPECT_EQ(0, prerender->number_of_loads());
3931   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
3932   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
3933   histogram_tester().ExpectTotalCount(
3934       "Prerender.none_PerceivedPLTMatchedComplete", 0);
3935   histogram_tester().ExpectTotalCount(
3936       "Prerender.websame_PrerenderNotSwappedInPLT", 0);
3937
3938   // Swap.
3939   NavigationOrSwapObserver swap_observer(current_browser()->tab_strip_model(),
3940                                          GetActiveWebContents());
3941   ui_test_utils::NavigateToURLWithDisposition(
3942       current_browser(), dest_url(), CURRENT_TAB,
3943       ui_test_utils::BROWSER_TEST_NONE);
3944   swap_observer.Wait();
3945
3946   // The prerender never observes the final load.
3947   EXPECT_EQ(0, prerender->number_of_loads());
3948
3949   // Now check DidDisplayPass.
3950   EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
3951
3952   histogram_tester().ExpectTotalCount(
3953       "Prerender.websame_PrerenderNotSwappedInPLT", 0);
3954   histogram_tester().ExpectTotalCount("Prerender.websame_PerceivedPLT", 1);
3955   histogram_tester().ExpectTotalCount("Prerender.websame_PerceivedPLTMatched",
3956                                       1);
3957   histogram_tester().ExpectTotalCount(
3958       "Prerender.websame_PerceivedPLTMatchedComplete", 1);
3959 }
3960
3961 // Checks that a deferred redirect to an image is not loaded until the
3962 // page is visible, even after another redirect.
3963 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
3964                        PrerenderDeferredImageAfterRedirect) {
3965   DisableJavascriptCalls();
3966
3967   // The prerender will not completely load until after the swap, so wait for a
3968   // title change before calling DidPrerenderPass.
3969   scoped_ptr<TestPrerender> prerender =
3970       PrerenderTestURL(
3971           "files/prerender/prerender_deferred_image.html",
3972           FINAL_STATUS_USED, 0);
3973   WaitForASCIITitle(prerender->contents()->prerender_contents(), kReadyTitle);
3974   EXPECT_TRUE(DidPrerenderPass(prerender->contents()->prerender_contents()));
3975   EXPECT_EQ(0, prerender->number_of_loads());
3976
3977   // Swap.
3978   NavigationOrSwapObserver swap_observer(current_browser()->tab_strip_model(),
3979                                          GetActiveWebContents());
3980   ui_test_utils::NavigateToURLWithDisposition(
3981       current_browser(), dest_url(), CURRENT_TAB,
3982       ui_test_utils::BROWSER_TEST_NONE);
3983   swap_observer.Wait();
3984
3985   // The prerender never observes the final load.
3986   EXPECT_EQ(0, prerender->number_of_loads());
3987
3988   // Now check DidDisplayPass.
3989   EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
3990 }
3991
3992 // Checks that deferred redirects in the main frame are followed.
3993 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDeferredMainFrame) {
3994   DisableJavascriptCalls();
3995   PrerenderTestURL(
3996       "files/prerender/image-deferred.png",
3997       FINAL_STATUS_USED, 1);
3998   NavigateToDestURL();
3999 }
4000
4001 // Checks that deferred redirects in the main frame are followed, even
4002 // with a double-redirect.
4003 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
4004                        PrerenderDeferredMainFrameAfterRedirect) {
4005   DisableJavascriptCalls();
4006   PrerenderTestURL(
4007       CreateServerRedirect("files/prerender/image-deferred.png"),
4008       FINAL_STATUS_USED, 1);
4009   NavigateToDestURL();
4010 }
4011
4012 // Checks that deferred redirects in a synchronous XHR abort the
4013 // prerender.
4014 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDeferredSynchronousXHR) {
4015   RestorePrerenderMode restore_prerender_mode;
4016   PrerenderManager::SetMode(
4017       PrerenderManager::PRERENDER_MODE_EXPERIMENT_MATCH_COMPLETE_GROUP);
4018   PrerenderTestURL("files/prerender/prerender_deferred_sync_xhr.html",
4019                    FINAL_STATUS_BAD_DEFERRED_REDIRECT, 0);
4020   NavigateToDestURL();
4021 }
4022
4023 // Checks that prerenders are not swapped for navigations with extra headers.
4024 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderExtraHeadersNoSwap) {
4025   PrerenderTestURL("files/prerender/prerender_page.html",
4026                    FINAL_STATUS_APP_TERMINATING, 1);
4027
4028   content::OpenURLParams params(dest_url(), Referrer(), CURRENT_TAB,
4029                                 ui::PAGE_TRANSITION_TYPED, false);
4030   params.extra_headers = "X-Custom-Header: 42\r\n";
4031   NavigateToURLWithParams(params, false);
4032 }
4033
4034 // Checks that prerenders are not swapped for navigations with browser-initiated
4035 // POST data.
4036 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
4037                        PrerenderBrowserInitiatedPostNoSwap) {
4038   PrerenderTestURL("files/prerender/prerender_page.html",
4039                    FINAL_STATUS_APP_TERMINATING, 1);
4040
4041   std::string post_data = "DATA";
4042   content::OpenURLParams params(dest_url(), Referrer(), CURRENT_TAB,
4043                                 ui::PAGE_TRANSITION_TYPED, false);
4044   params.uses_post = true;
4045   params.browser_initiated_post_data =
4046       base::RefCountedString::TakeString(&post_data);
4047   NavigateToURLWithParams(params, false);
4048 }
4049
4050 // Checks that the prerendering of a page is canceled correctly when the
4051 // prerendered page tries to make a second navigation entry.
4052 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNewNavigationEntry) {
4053   PrerenderTestURL("files/prerender/prerender_new_entry.html",
4054                    FINAL_STATUS_NEW_NAVIGATION_ENTRY,
4055                    1);
4056 }
4057
4058 // Attempt a swap-in in a new tab, verifying that session storage namespace
4059 // merging works.
4060 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageNewTab) {
4061   // Mock out some URLs and count the number of requests to one of them. Both
4062   // prerender_session_storage.html and init_session_storage.html need to be
4063   // mocked so they are same-origin.
4064   const GURL kInitURL("http://prerender.test/init_session_storage.html");
4065   base::FilePath init_file = GetTestPath("init_session_storage.html");
4066   BrowserThread::PostTask(
4067       BrowserThread::IO, FROM_HERE,
4068       base::Bind(&CreateMockInterceptorOnIO, kInitURL, init_file));
4069
4070   const GURL kTestURL("http://prerender.test/prerender_session_storage.html");
4071   base::FilePath test_file = GetTestPath("prerender_session_storage.html");
4072   RequestCounter counter;
4073   BrowserThread::PostTask(
4074       BrowserThread::IO, FROM_HERE,
4075       base::Bind(&CreateCountingInterceptorOnIO,
4076                  kTestURL, test_file, counter.AsWeakPtr()));
4077
4078   PrerenderTestURL(kTestURL, FINAL_STATUS_USED, 1);
4079
4080   // Open a new tab to navigate in.
4081   ui_test_utils::NavigateToURLWithDisposition(
4082       current_browser(), kInitURL, NEW_FOREGROUND_TAB,
4083       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
4084
4085   // Now navigate in the new tab. Set expect_swap_to_succeed to false because
4086   // the swap does not occur synchronously.
4087   //
4088   // TODO(davidben): When all swaps become asynchronous, remove the OpenURL
4089   // return value assertion and let this go through the usual successful-swap
4090   // codepath.
4091   NavigateToDestURLWithDisposition(CURRENT_TAB, false);
4092
4093   // Verify DidDisplayPass manually since the previous call skipped it.
4094   EXPECT_TRUE(DidDisplayPass(
4095       current_browser()->tab_strip_model()->GetActiveWebContents()));
4096
4097   // Only one request to the test URL started.
4098   //
4099   // TODO(davidben): Re-enable this check when the races in attaching the
4100   // throttle are resolved. http://crbug.com/335835
4101   // EXPECT_EQ(1, counter.count());
4102 }
4103
4104 // Attempt a swap-in in a new tab, verifying that session storage namespace
4105 // merging works. Unlike the above test, the swap is for a navigation that would
4106 // normally be cross-process.
4107 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageNewTabCrossProcess) {
4108   base::FilePath test_data_dir;
4109   ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir));
4110
4111   // Mock out some URLs and count the number of requests to one of them. Both
4112   // prerender_session_storage.html and init_session_storage.html need to be
4113   // mocked so they are same-origin.
4114   const GURL kInitURL("http://prerender.test/init_session_storage.html");
4115   base::FilePath init_file = GetTestPath("init_session_storage.html");
4116   BrowserThread::PostTask(
4117       BrowserThread::IO, FROM_HERE,
4118       base::Bind(&CreateMockInterceptorOnIO, kInitURL, init_file));
4119
4120   const GURL kTestURL("http://prerender.test/prerender_session_storage.html");
4121   base::FilePath test_file = GetTestPath("prerender_session_storage.html");
4122   RequestCounter counter;
4123   BrowserThread::PostTask(
4124       BrowserThread::IO, FROM_HERE,
4125       base::Bind(&CreateCountingInterceptorOnIO,
4126                  kTestURL, test_file, counter.AsWeakPtr()));
4127
4128   PrerenderTestURL(kTestURL, FINAL_STATUS_USED, 1);
4129
4130   // Open a new tab to navigate in.
4131   ui_test_utils::NavigateToURLWithDisposition(
4132       current_browser(), kInitURL, NEW_FOREGROUND_TAB,
4133       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
4134
4135   // Navigate to about:blank so the next navigation is cross-process.
4136   ui_test_utils::NavigateToURL(current_browser(), GURL(url::kAboutBlankURL));
4137
4138   // Now navigate in the new tab. Set expect_swap_to_succeed to false because
4139   // the swap does not occur synchronously.
4140   //
4141   // TODO(davidben): When all swaps become asynchronous, remove the OpenURL
4142   // return value assertion and let this go through the usual successful-swap
4143   // codepath.
4144   NavigateToDestURLWithDisposition(CURRENT_TAB, false);
4145
4146   // Verify DidDisplayPass manually since the previous call skipped it.
4147   EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
4148
4149   // Only one request to the test URL started.
4150   //
4151   // TODO(davidben): Re-enable this check when the races in attaching the
4152   // throttle are resolved. http://crbug.com/335835
4153   // EXPECT_EQ(1, counter.count());
4154 }
4155
4156 // Verify that session storage conflicts don't merge.
4157 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSessionStorageConflict) {
4158   PrerenderTestURL("files/prerender/prerender_session_storage_conflict.html",
4159                    FINAL_STATUS_APP_TERMINATING, 1);
4160
4161   // Open a new tab to navigate in.
4162   ui_test_utils::NavigateToURLWithDisposition(
4163       current_browser(),
4164       test_server()->GetURL("files/prerender/init_session_storage.html"),
4165       NEW_FOREGROUND_TAB,
4166       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
4167
4168   // Now navigate in the new tab.
4169   NavigateToDestURLWithDisposition(CURRENT_TAB, false);
4170
4171   // Verify DidDisplayPass in the new tab.
4172   EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
4173 }
4174
4175 // Checks that prerenders honor |should_replace_current_entry|.
4176 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderReplaceCurrentEntry) {
4177   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
4178
4179   content::OpenURLParams params(dest_url(), Referrer(), CURRENT_TAB,
4180                                 ui::PAGE_TRANSITION_TYPED, false);
4181   params.should_replace_current_entry = true;
4182   NavigateToURLWithParams(params, false);
4183
4184   const NavigationController& controller =
4185       GetActiveWebContents()->GetController();
4186   // First entry is about:blank, second is prerender_page.html.
4187   EXPECT_TRUE(controller.GetPendingEntry() == NULL);
4188   EXPECT_EQ(2, controller.GetEntryCount());
4189   EXPECT_EQ(GURL(url::kAboutBlankURL), controller.GetEntryAtIndex(0)->GetURL());
4190   EXPECT_EQ(dest_url(), controller.GetEntryAtIndex(1)->GetURL());
4191 }
4192
4193 // Checks prerender does not hit DCHECKs and behaves properly if two pending
4194 // swaps occur in a row.
4195 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDoublePendingSwap) {
4196   GetPrerenderManager()->mutable_config().max_link_concurrency = 2;
4197   GetPrerenderManager()->mutable_config().max_link_concurrency_per_launcher = 2;
4198
4199   GURL url1 = test_server()->GetURL("files/prerender/prerender_page.html?1");
4200   scoped_ptr<TestPrerender> prerender1 =
4201       PrerenderTestURL(url1, FINAL_STATUS_APP_TERMINATING, 1);
4202
4203   GURL url2 = test_server()->GetURL("files/prerender/prerender_page.html?2");
4204   scoped_ptr<TestPrerender> prerender2 = ExpectPrerender(FINAL_STATUS_USED);
4205   AddPrerender(url2, 1);
4206   prerender2->WaitForStart();
4207   prerender2->WaitForLoads(1);
4208
4209   // There's no reason the second prerender can't be used, but the swap races
4210   // with didStartProvisionalLoad and didFailProvisionalLoad from the previous
4211   // navigation. The current logic will conservatively fail to swap under such
4212   // races. However, if the renderer is slow enough, it's possible for the
4213   // prerender to still be used, so don't program in either expectation.
4214   ASSERT_TRUE(prerender2->contents());
4215   prerender2->contents()->set_skip_final_checks(true);
4216
4217   // Open a new tab to navigate in.
4218   ui_test_utils::NavigateToURLWithDisposition(
4219       current_browser(),
4220       GURL(url::kAboutBlankURL),
4221       NEW_FOREGROUND_TAB,
4222       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
4223
4224   // Fire off two navigations, without running the event loop between them.
4225   NavigationOrSwapObserver swap_observer(
4226       current_browser()->tab_strip_model(),
4227       GetActiveWebContents(), 2);
4228   current_browser()->OpenURL(OpenURLParams(
4229       url1, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_TYPED, false));
4230   current_browser()->OpenURL(OpenURLParams(
4231       url2, Referrer(), CURRENT_TAB, ui::PAGE_TRANSITION_TYPED, false));
4232   swap_observer.Wait();
4233
4234   // The WebContents should be on url2. There may be 2 or 3 entries, depending
4235   // on whether the first one managed to complete.
4236   //
4237   // TODO(davidben): When http://crbug.com/335835 is fixed, the 3 entry case
4238   // shouldn't be possible because it's throttled by the pending swap that
4239   // cannot complete.
4240   const NavigationController& controller =
4241       GetActiveWebContents()->GetController();
4242   EXPECT_TRUE(controller.GetPendingEntry() == NULL);
4243   EXPECT_LE(2, controller.GetEntryCount());
4244   EXPECT_GE(3, controller.GetEntryCount());
4245   EXPECT_EQ(GURL(url::kAboutBlankURL), controller.GetEntryAtIndex(0)->GetURL());
4246   EXPECT_EQ(url2, controller.GetEntryAtIndex(
4247       controller.GetEntryCount() - 1)->GetURL());
4248 }
4249
4250 // Verify that pending swaps get aborted on new navigations.
4251 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
4252                        PrerenderPendingSwapNewNavigation) {
4253   PrerenderManager::HangSessionStorageMergesForTesting();
4254
4255   PrerenderTestURL("files/prerender/prerender_page.html",
4256                    FINAL_STATUS_APP_TERMINATING, 1);
4257
4258   // Open a new tab to navigate in.
4259   ui_test_utils::NavigateToURLWithDisposition(
4260       current_browser(),
4261       GURL(url::kAboutBlankURL),
4262       NEW_FOREGROUND_TAB,
4263       ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
4264
4265   // Navigate to the URL. Wait for DidStartLoading, just so it's definitely
4266   // progressed somewhere.
4267   content::WindowedNotificationObserver page_load_observer(
4268       content::NOTIFICATION_LOAD_START,
4269       content::Source<NavigationController>(
4270           &GetActiveWebContents()->GetController()));
4271   current_browser()->OpenURL(OpenURLParams(
4272       dest_url(), Referrer(), CURRENT_TAB,
4273       ui::PAGE_TRANSITION_TYPED, false));
4274   page_load_observer.Wait();
4275
4276   // Navigate somewhere else. This should succeed and abort the pending swap.
4277   TestNavigationObserver nav_observer(GetActiveWebContents());
4278   current_browser()->OpenURL(OpenURLParams(GURL(url::kAboutBlankURL),
4279                                            Referrer(),
4280                                            CURRENT_TAB,
4281                                            ui::PAGE_TRANSITION_TYPED,
4282                                            false));
4283   nav_observer.Wait();
4284 }
4285
4286 // Checks that <a ping> requests are not dropped in prerender.
4287 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPing) {
4288   // Count hits to a certain URL.
4289   const GURL kPingURL("http://prerender.test/ping");
4290   base::FilePath empty_file = ui_test_utils::GetTestFilePath(
4291       base::FilePath(), base::FilePath(FILE_PATH_LITERAL("empty.html")));
4292   RequestCounter ping_counter;
4293   BrowserThread::PostTask(
4294       BrowserThread::IO, FROM_HERE,
4295       base::Bind(&CreateCountingInterceptorOnIO,
4296                  kPingURL, empty_file, ping_counter.AsWeakPtr()));
4297
4298   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
4299   OpenDestURLViaClickPing(kPingURL);
4300
4301   ping_counter.WaitForCount(1);
4302 }
4303
4304 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPPLTNormalNavigation) {
4305   GURL url = test_server()->GetURL("files/prerender/prerender_page.html");
4306   ui_test_utils::NavigateToURL(current_browser(), url);
4307   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
4308   histogram_tester().ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
4309   histogram_tester().ExpectTotalCount(
4310       "Prerender.none_PerceivedPLTMatchedComplete", 0);
4311 }
4312
4313 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
4314                        PrerenderCookieChangeConflictTest) {
4315   NavigateStraightToURL(
4316       "files/prerender/prerender_cookie.html?set=1&key=c&value=1");
4317
4318   GURL url = test_server()->GetURL(
4319       "files/prerender/prerender_cookie.html?set=1&key=c&value=2");
4320
4321   scoped_ptr<TestPrerender> prerender =
4322       ExpectPrerender(FINAL_STATUS_COOKIE_CONFLICT);
4323   AddPrerender(url, 1);
4324   prerender->WaitForStart();
4325   prerender->WaitForLoads(1);
4326   // Ensure that in the prerendered page, querying the cookie again
4327   // via javascript yields the same value that was set during load.
4328   EXPECT_TRUE(DidPrerenderPass(prerender->contents()->prerender_contents()));
4329
4330   // The prerender has loaded. Ensure that the change is not visible
4331   // to visible tabs.
4332   std::string value;
4333   RunJSReturningString("GetCookie('c')", &value);
4334   ASSERT_EQ(value, "1");
4335
4336   // Make a conflicting cookie change, which should cancel the prerender.
4337   RunJS("SetCookie('c', '3')");
4338   prerender->WaitForStop();
4339 }
4340
4341 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCookieChangeUseTest) {
4342   // Permit 2 concurrent prerenders.
4343   GetPrerenderManager()->mutable_config().max_link_concurrency = 2;
4344   GetPrerenderManager()->mutable_config().max_link_concurrency_per_launcher = 2;
4345
4346   // Go to a first URL setting the cookie to value "1".
4347   NavigateStraightToURL(
4348       "files/prerender/prerender_cookie.html?set=1&key=c&value=1");
4349
4350   // Prerender a URL setting the cookie to value "2".
4351   GURL url = test_server()->GetURL(
4352       "files/prerender/prerender_cookie.html?set=1&key=c&value=2");
4353
4354   scoped_ptr<TestPrerender> prerender1 = ExpectPrerender(FINAL_STATUS_USED);
4355   AddPrerender(url, 1);
4356   prerender1->WaitForStart();
4357   prerender1->WaitForLoads(1);
4358
4359   // Launch a second prerender, setting the cookie to value "3".
4360   scoped_ptr<TestPrerender> prerender2 =
4361       ExpectPrerender(FINAL_STATUS_COOKIE_CONFLICT);
4362   AddPrerender(test_server()->GetURL(
4363       "files/prerender/prerender_cookie.html?set=1&key=c&value=3"), 1);
4364   prerender2->WaitForStart();
4365   prerender2->WaitForLoads(1);
4366
4367   // Both prerenders have loaded. Ensure that the visible tab is still
4368   // unchanged and cannot see their changes.
4369   // to visible tabs.
4370   std::string value;
4371   RunJSReturningString("GetCookie('c')", &value);
4372   ASSERT_EQ(value, "1");
4373
4374   // Navigate to the prerendered URL. The first prerender should be swapped in,
4375   // and the changes should now be visible. The second prerender should
4376   // be cancelled due to the conflict.
4377   ui_test_utils::NavigateToURLWithDisposition(
4378       current_browser(),
4379       url,
4380       CURRENT_TAB,
4381       ui_test_utils::BROWSER_TEST_NONE);
4382   RunJSReturningString("GetCookie('c')", &value);
4383   ASSERT_EQ(value, "2");
4384   prerender2->WaitForStop();
4385 }
4386
4387 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
4388                        PrerenderCookieChangeConflictHTTPHeaderTest) {
4389   NavigateStraightToURL(
4390       "files/prerender/prerender_cookie.html?set=1&key=c&value=1");
4391
4392   GURL url = test_server()->GetURL("set-cookie?c=2");
4393   scoped_ptr<TestPrerender> prerender =
4394       ExpectPrerender(FINAL_STATUS_COOKIE_CONFLICT);
4395   AddPrerender(url, 1);
4396   prerender->WaitForStart();
4397   prerender->WaitForLoads(1);
4398
4399   // The prerender has loaded. Ensure that the change is not visible
4400   // to visible tabs.
4401   std::string value;
4402   RunJSReturningString("GetCookie('c')", &value);
4403   ASSERT_EQ(value, "1");
4404
4405   // Make a conflicting cookie change, which should cancel the prerender.
4406   RunJS("SetCookie('c', '3')");
4407   prerender->WaitForStop();
4408 }
4409
4410 // Checks that a prerender which calls window.close() on itself is aborted.
4411 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderWindowClose) {
4412   DisableLoadEventCheck();
4413   PrerenderTestURL("files/prerender/prerender_window_close.html",
4414                    FINAL_STATUS_CLOSED, 0);
4415 }
4416
4417 class PrerenderIncognitoBrowserTest : public PrerenderBrowserTest {
4418  public:
4419   virtual void SetUpOnMainThread() override {
4420     Profile* normal_profile = current_browser()->profile();
4421     set_browser(ui_test_utils::OpenURLOffTheRecord(
4422         normal_profile, GURL("about:blank")));
4423     PrerenderBrowserTest::SetUpOnMainThread();
4424   }
4425 };
4426
4427 // Checks that prerendering works in incognito mode.
4428 IN_PROC_BROWSER_TEST_F(PrerenderIncognitoBrowserTest, PrerenderIncognito) {
4429   PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
4430   NavigateToDestURL();
4431 }
4432
4433 // Checks that prerenders are aborted when an incognito profile is closed.
4434 IN_PROC_BROWSER_TEST_F(PrerenderIncognitoBrowserTest,
4435                        PrerenderIncognitoClosed) {
4436   scoped_ptr<TestPrerender> prerender =
4437       PrerenderTestURL("files/prerender/prerender_page.html",
4438                        FINAL_STATUS_PROFILE_DESTROYED, 1);
4439   current_browser()->window()->Close();
4440   prerender->WaitForStop();
4441 }
4442
4443 class PrerenderOmniboxBrowserTest : public PrerenderBrowserTest {
4444  public:
4445   LocationBar* GetLocationBar() {
4446     return current_browser()->window()->GetLocationBar();
4447   }
4448
4449   OmniboxView* GetOmniboxView() {
4450     return GetLocationBar()->GetOmniboxView();
4451   }
4452
4453   void WaitForAutocompleteDone(OmniboxView* omnibox_view) {
4454     AutocompleteController* controller =
4455         omnibox_view->model()->popup_model()->autocomplete_controller();
4456     while (!controller->done()) {
4457       content::WindowedNotificationObserver ready_observer(
4458           chrome::NOTIFICATION_AUTOCOMPLETE_CONTROLLER_RESULT_READY,
4459           content::Source<AutocompleteController>(controller));
4460       ready_observer.Wait();
4461     }
4462   }
4463
4464   predictors::AutocompleteActionPredictor* GetAutocompleteActionPredictor() {
4465     Profile* profile = current_browser()->profile();
4466     return predictors::AutocompleteActionPredictorFactory::GetForProfile(
4467         profile);
4468   }
4469
4470   scoped_ptr<TestPrerender> StartOmniboxPrerender(
4471       const GURL& url,
4472       FinalStatus expected_final_status) {
4473     scoped_ptr<TestPrerender> prerender =
4474         ExpectPrerender(expected_final_status);
4475     WebContents* web_contents = GetActiveWebContents();
4476     GetAutocompleteActionPredictor()->StartPrerendering(
4477         url,
4478         web_contents->GetController().GetSessionStorageNamespaceMap(),
4479         gfx::Size(50, 50));
4480     prerender->WaitForStart();
4481     return prerender.Pass();
4482   }
4483 };
4484
4485 // Checks that closing the omnibox popup cancels an omnibox prerender.
4486 // http://crbug.com/395152
4487 IN_PROC_BROWSER_TEST_F(PrerenderOmniboxBrowserTest,
4488                        DISABLED_PrerenderOmniboxCancel) {
4489   // Ensure the cookie store has been loaded.
4490   if (!GetPrerenderManager()->cookie_store_loaded()) {
4491     base::RunLoop loop;
4492     GetPrerenderManager()->set_on_cookie_store_loaded_cb_for_testing(
4493         loop.QuitClosure());
4494     loop.Run();
4495   }
4496
4497   // Fake an omnibox prerender.
4498   scoped_ptr<TestPrerender> prerender = StartOmniboxPrerender(
4499       test_server()->GetURL("files/empty.html"),
4500       FINAL_STATUS_CANCELLED);
4501
4502   // Revert the location bar. This should cancel the prerender.
4503   GetLocationBar()->Revert();
4504   prerender->WaitForStop();
4505 }
4506
4507 // Checks that accepting omnibox input abandons an omnibox prerender.
4508 // http://crbug.com/394592
4509 IN_PROC_BROWSER_TEST_F(PrerenderOmniboxBrowserTest,
4510                        DISABLED_PrerenderOmniboxAbandon) {
4511   // Set the abandon timeout to something high so it does not introduce
4512   // flakiness if the prerender times out before the test completes.
4513   GetPrerenderManager()->mutable_config().abandon_time_to_live =
4514       base::TimeDelta::FromDays(999);
4515
4516   // Ensure the cookie store has been loaded.
4517   if (!GetPrerenderManager()->cookie_store_loaded()) {
4518     base::RunLoop loop;
4519     GetPrerenderManager()->set_on_cookie_store_loaded_cb_for_testing(
4520         loop.QuitClosure());
4521     loop.Run();
4522   }
4523
4524   // Enter a URL into the Omnibox.
4525   OmniboxView* omnibox_view = GetOmniboxView();
4526   omnibox_view->OnBeforePossibleChange();
4527   omnibox_view->SetUserText(
4528       base::UTF8ToUTF16(test_server()->GetURL("files/empty.html?1").spec()));
4529   omnibox_view->OnAfterPossibleChange();
4530   WaitForAutocompleteDone(omnibox_view);
4531
4532   // Fake an omnibox prerender for a different URL.
4533   scoped_ptr<TestPrerender> prerender = StartOmniboxPrerender(
4534       test_server()->GetURL("files/empty.html?2"),
4535       FINAL_STATUS_APP_TERMINATING);
4536
4537   // The final status may be either FINAL_STATUS_APP_TERMINATING or
4538   // FINAL_STATUS_CANCELLED. Although closing the omnibox will not cancel an
4539   // abandoned prerender, the AutocompleteActionPredictor will cancel the
4540   // predictor on destruction.
4541   prerender->contents()->set_skip_final_checks(true);
4542
4543   // Navigate to the URL entered.
4544   omnibox_view->model()->AcceptInput(CURRENT_TAB, false);
4545
4546   // Prerender should be running, but abandoned.
4547   EXPECT_TRUE(
4548       GetAutocompleteActionPredictor()->IsPrerenderAbandonedForTesting());
4549 }
4550
4551 // Prefetch should be allowed depending on preference and network type.
4552 // This test is for the bsae case: no Finch overrides should never disable.
4553 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
4554                        LocalPredictorDisableWorksBaseCase) {
4555   TestShouldDisableLocalPredictorPreferenceNetworkMatrix(
4556       false /*preference_wifi_network_wifi*/,
4557       false /*preference_wifi_network_4g*/,
4558       false /*preference_always_network_wifi*/,
4559       false /*preference_always_network_4g*/,
4560       false /*preference_never_network_wifi*/,
4561       false /*preference_never_network_4g*/);
4562 }
4563
4564 // Prefetch should be allowed depending on preference and network type.
4565 // LocalPredictorOnCellularOnly should disable all wifi cases.
4566 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
4567                        LocalPredictorDisableWorksCellularOnly) {
4568   CreateTestFieldTrial("PrerenderLocalPredictorSpec",
4569                        "LocalPredictorOnCellularOnly=Enabled");
4570   TestShouldDisableLocalPredictorPreferenceNetworkMatrix(
4571       true /*preference_wifi_network_wifi*/,
4572       false /*preference_wifi_network_4g*/,
4573       true /*preference_always_network_wifi*/,
4574       false /*preference_always_network_4g*/,
4575       true /*preference_never_network_wifi*/,
4576       false /*preference_never_network_4g*/);
4577 }
4578
4579 // Prefetch should be allowed depending on preference and network type.
4580 // LocalPredictorNetworkPredictionEnabledOnly should disable whenever
4581 // network predictions will not be exercised.
4582 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
4583                        LocalPredictorDisableWorksNetworkPredictionEnableOnly) {
4584   CreateTestFieldTrial("PrerenderLocalPredictorSpec",
4585                        "LocalPredictorNetworkPredictionEnabledOnly=Enabled");
4586   TestShouldDisableLocalPredictorPreferenceNetworkMatrix(
4587       false /*preference_wifi_network_wifi*/,
4588       true /*preference_wifi_network_4g*/,
4589       false /*preference_always_network_wifi*/,
4590       false /*preference_always_network_4g*/,
4591       true /*preference_never_network_wifi*/,
4592       true /*preference_never_network_4g*/);
4593 }
4594
4595 // Prefetch should be allowed depending on preference and network type.
4596 // If LocalPredictorNetworkPredictionEnabledOnly and
4597 // LocalPredictorOnCellularOnly are both selected, we must disable whenever
4598 // network predictions are not exercised, or when we are on wifi.
4599 IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
4600                        LocalPredictorDisableWorksBothOptions) {
4601   CreateTestFieldTrial("PrerenderLocalPredictorSpec",
4602                        "LocalPredictorOnCellularOnly=Enabled:"
4603                        "LocalPredictorNetworkPredictionEnabledOnly=Enabled");
4604   TestShouldDisableLocalPredictorPreferenceNetworkMatrix(
4605       true /*preference_wifi_network_wifi*/,
4606       true /*preference_wifi_network_4g*/,
4607       true /*preference_always_network_wifi*/,
4608       false /*preference_always_network_4g*/,
4609       true /*preference_never_network_wifi*/,
4610       true /*preference_never_network_4g*/);
4611 }
4612
4613 }  // namespace prerender