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