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
105using chrome_browser_net::NetworkPredictionOptions;
106using content::BrowserThread;
107using content::DevToolsAgentHost;
108using content::NavigationController;
109using content::OpenURLParams;
110using content::Referrer;
111using content::RenderFrameHost;
112using content::RenderViewHost;
113using content::RenderWidgetHost;
114using content::TestNavigationObserver;
115using content::WebContents;
116using content::WebContentsObserver;
117using net::NetworkChangeNotifier;
118using 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
130namespace prerender {
131
132namespace {
133
134class MockNetworkChangeNotifierWIFI : public NetworkChangeNotifier {
135 public:
136  virtual ConnectionType GetCurrentConnectionType() const OVERRIDE {
137    return NetworkChangeNotifier::CONNECTION_WIFI;
138  }
139};
140
141class 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.
149const char* kReadyTitle = "READY";
150const char* kPassTitle = "PASS";
151
152std::string CreateClientRedirect(const std::string& dest_url) {
153  const char* const kClientRedirectBase = "client-redirect?";
154  return kClientRedirectBase + net::EscapeQueryParamValue(dest_url, false);
155}
156
157std::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.
163void 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.
174bool 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.
197void 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.
209class 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.
271class 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.
352class 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().
389class 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.
527class 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.
611class 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.
669class 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
722class 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.
747class 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
767class 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
777class 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.
788class 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
801class 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.
839void 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.
849class 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.
878class 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.
909class 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|.
942void 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|.
954void 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.
963class 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.
983class 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.
1003class 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
1035base::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
1044class 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.
1772IN_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.
1798IN_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.
1817IN_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.
1851IN_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
1870IN_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
1890IN_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
1919IN_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
1951IN_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.
1985IN_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.
1994IN_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.
2016IN_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.
2038IN_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.
2046IN_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
2070IN_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.
2079IN_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.
2093IN_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
2127IN_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.
2138IN_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.
2147IN_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.
2158IN_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.
2168IN_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.
2178IN_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.
2188IN_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.
2257IN_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.
2268IN_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.
2282IN_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.
2303IN_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.
2314IN_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.
2325IN_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.
2337IN_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.
2356IN_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
2365IN_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.
2373IN_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.
2380IN_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.
2389IN_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.
2399IN_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.
2416IN_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.
2423IN_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.
2430IN_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.
2444IN_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.
2453IN_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.
2485IN_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.
2531IN_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
2555IN_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
2590IN_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
2624IN_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.
2645IN_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.
2655IN_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.
2665IN_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.
2674IN_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.
2684IN_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.
2693IN_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.
2706IN_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.
2717IN_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
2736IN_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
2751IN_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.
2769IN_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.
2781IN_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.
2793IN_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.
2805IN_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.
2818IN_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.
2831IN_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.
2840IN_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.
2847IN_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.
2855IN_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.
2860IN_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.
2868IN_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.
2876IN_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.
2884IN_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.
2892IN_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.
2900IN_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.
2907IN_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.
2914IN_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.
2931IN_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.
2955IN_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.
2978IN_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.
2988IN_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.
2999IN_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.
3009IN_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
3017class 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
3033scoped_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.
3039IN_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.
3057IN_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.
3085IN_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.
3114IN_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.
3123IN_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.
3134IN_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.
3145IN_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.
3163IN_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.
3184IN_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.
3192IN_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.
3200IN_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.
3221IN_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.
3240IN_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.
3259IN_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.
3274IN_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
3288IN_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
3300IN_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.
3315IN_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
3334IN_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
3343IN_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
3352IN_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
3361IN_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
3370IN_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
3379IN_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
3388IN_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
3400IN_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.
3417IN_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.
3428IN_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.)
3441IN_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.
3455IN_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.
3482IN_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
3533class 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.
3545IN_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.
3570IN_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.
3579IN_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.
3590IN_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.
3615class 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
3648IN_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
3669IN_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
3692IN_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.
3721IN_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.
3736IN_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.
3753IN_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.
3769IN_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.
3786IN_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.
3803IN_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.
3811IN_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.
3821IN_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.
3828IN_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.
3839IN_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
3857IN_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.
3876IN_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.
3896IN_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.
3918IN_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.
3963IN_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.
3993IN_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.
4003IN_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.
4014IN_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.
4024IN_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.
4036IN_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.
4052IN_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.
4060IN_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.
4107IN_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.
4157IN_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|.
4176IN_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.
4195IN_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.
4251IN_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.
4287IN_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
4304IN_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
4313IN_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
4341IN_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
4387IN_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.
4411IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderWindowClose) {
4412  DisableLoadEventCheck();
4413  PrerenderTestURL("files/prerender/prerender_window_close.html",
4414                   FINAL_STATUS_CLOSED, 0);
4415}
4416
4417class 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.
4428IN_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.
4434IN_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
4443class 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
4487IN_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
4509IN_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.
4553IN_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.
4566IN_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.
4582IN_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.
4599IN_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
4614