// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <deque>
#include <vector>
#include "base/bind.h"
#include "base/command_line.h"
#include "base/files/file_path.h"
#include "base/memory/ref_counted_memory.h"
#include "base/memory/scoped_vector.h"
#include "base/memory/weak_ptr.h"
#include "base/path_service.h"
#include "base/prefs/pref_service.h"
#include "base/run_loop.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/test/test_timeouts.h"
#include "base/values.h"
#include "chrome/browser/browsing_data/browsing_data_helper.h"
#include "chrome/browser/browsing_data/browsing_data_remover.h"
#include "chrome/browser/browsing_data/browsing_data_remover_test_util.h"
#include "chrome/browser/chrome_content_browser_client.h"
#include "chrome/browser/chrome_notification_types.h"
#include "chrome/browser/content_settings/host_content_settings_map.h"
#include "chrome/browser/extensions/api/web_navigation/web_navigation_api.h"
#include "chrome/browser/extensions/extension_apitest.h"
#include "chrome/browser/external_protocol/external_protocol_handler.h"
#include "chrome/browser/favicon/favicon_tab_helper.h"
#include "chrome/browser/predictors/autocomplete_action_predictor.h"
#include "chrome/browser/predictors/autocomplete_action_predictor_factory.h"
#include "chrome/browser/prerender/prerender_contents.h"
#include "chrome/browser/prerender/prerender_handle.h"
#include "chrome/browser/prerender/prerender_link_manager.h"
#include "chrome/browser/prerender/prerender_link_manager_factory.h"
#include "chrome/browser/prerender/prerender_manager.h"
#include "chrome/browser/prerender/prerender_manager_factory.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/profiles/profile_io_data.h"
#include "chrome/browser/renderer_host/chrome_resource_dispatcher_host_delegate.h"
#include "chrome/browser/safe_browsing/database_manager.h"
#include "chrome/browser/safe_browsing/safe_browsing_service.h"
#include "chrome/browser/safe_browsing/safe_browsing_util.h"
#include "chrome/browser/task_manager/task_manager.h"
#include "chrome/browser/task_manager/task_manager_browsertest_util.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/browser_commands.h"
#include "chrome/browser/ui/browser_finder.h"
#include "chrome/browser/ui/browser_navigator.h"
#include "chrome/browser/ui/browser_window.h"
#include "chrome/browser/ui/omnibox/location_bar.h"
#include "chrome/browser/ui/omnibox/omnibox_edit_model.h"
#include "chrome/browser/ui/omnibox/omnibox_popup_model.h"
#include "chrome/browser/ui/omnibox/omnibox_view.h"
#include "chrome/browser/ui/tabs/tab_strip_model.h"
#include "chrome/browser/ui/tabs/tab_strip_model_observer.h"
#include "chrome/common/chrome_paths.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/extensions/extension_constants.h"
#include "chrome/common/extensions/manifest_handlers/mime_types_handler.h"
#include "chrome/common/pref_names.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "chrome/test/base/test_switches.h"
#include "chrome/test/base/ui_test_utils.h"
#include "chrome/test/base/uma_histogram_helper.h"
#include "content/public/browser/browser_message_filter.h"
#include "content/public/browser/devtools_agent_host.h"
#include "content/public/browser/devtools_client_host.h"
#include "content/public/browser/devtools_manager.h"
#include "content/public/browser/navigation_controller.h"
#include "content/public/browser/navigation_entry.h"
#include "content/public/browser/notification_service.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_process_host.h"
#include "content/public/browser/render_view_host.h"
#include "content/public/browser/site_instance.h"
#include "content/public/browser/web_contents.h"
#include "content/public/browser/web_contents_observer.h"
#include "content/public/common/url_constants.h"
#include "content/public/test/browser_test_utils.h"
#include "content/public/test/test_navigation_observer.h"
#include "content/public/test/test_utils.h"
#include "content/test/net/url_request_mock_http_job.h"
#include "extensions/common/switches.h"
#include "grit/generated_resources.h"
#include "net/base/escape.h"
#include "net/cert/x509_certificate.h"
#include "net/dns/mock_host_resolver.h"
#include "net/ssl/client_cert_store.h"
#include "net/ssl/ssl_cert_request_info.h"
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_context_getter.h"
#include "net/url_request/url_request_filter.h"
#include "net/url_request/url_request_interceptor.h"
#include "net/url_request/url_request_job.h"
#include "ui/base/l10n/l10n_util.h"
#include "url/gurl.h"
using content::BrowserThread;
using content::DevToolsAgentHost;
using content::DevToolsClientHost;
using content::DevToolsManager;
using content::NavigationController;
using content::OpenURLParams;
using content::Referrer;
using content::RenderFrameHost;
using content::RenderViewHost;
using content::RenderWidgetHost;
using content::TestNavigationObserver;
using content::WebContents;
using content::WebContentsObserver;
using task_manager::browsertest_util::WaitForTaskManagerRows;
// Prerender tests work as follows:
//
// A page with a prefetch link to the test page is loaded. Once prerendered,
// its Javascript function DidPrerenderPass() is called, which returns true if
// the page behaves as expected when prerendered.
//
// The prerendered page is then displayed on a tab. The Javascript function
// DidDisplayPass() is called, and returns true if the page behaved as it
// should while being displayed.
namespace prerender {
namespace {
// Constants used in the test HTML files.
const char* kReadyTitle = "READY";
const char* kPassTitle = "PASS";
std::string CreateClientRedirect(const std::string& dest_url) {
const char* const kClientRedirectBase = "client-redirect?";
return kClientRedirectBase + net::EscapeQueryParamValue(dest_url, false);
}
std::string CreateServerRedirect(const std::string& dest_url) {
const char* const kServerRedirectBase = "server-redirect?";
return kServerRedirectBase + net::EscapeQueryParamValue(dest_url, false);
}
// Clears the specified data using BrowsingDataRemover.
void ClearBrowsingData(Browser* browser, int remove_mask) {
BrowsingDataRemover* remover =
BrowsingDataRemover::CreateForUnboundedRange(browser->profile());
BrowsingDataRemoverCompletionObserver observer(remover);
remover->Remove(remove_mask, BrowsingDataHelper::UNPROTECTED_WEB);
observer.BlockUntilCompletion();
// BrowsingDataRemover deletes itself.
}
// Returns true if the prerender is expected to abort on its own, before
// attempting to swap it.
bool ShouldAbortPrerenderBeforeSwap(FinalStatus status) {
switch (status) {
case FINAL_STATUS_USED:
case FINAL_STATUS_WINDOW_OPENER:
case FINAL_STATUS_APP_TERMINATING:
case FINAL_STATUS_PROFILE_DESTROYED:
case FINAL_STATUS_CACHE_OR_HISTORY_CLEARED:
// We'll crash the renderer after it's loaded.
case FINAL_STATUS_RENDERER_CRASHED:
case FINAL_STATUS_CANCELLED:
case FINAL_STATUS_DEVTOOLS_ATTACHED:
case FINAL_STATUS_PAGE_BEING_CAPTURED:
case FINAL_STATUS_NAVIGATION_UNCOMMITTED:
case FINAL_STATUS_WOULD_HAVE_BEEN_USED:
case FINAL_STATUS_NON_EMPTY_BROWSING_INSTANCE:
return false;
default:
return true;
}
}
// Convenience function to wait for a title. Handles the case when the
// WebContents already has the expected title.
void WaitForASCIITitle(WebContents* web_contents,
const char* expected_title_ascii) {
base::string16 expected_title = base::ASCIIToUTF16(expected_title_ascii);
if (web_contents->GetTitle() == expected_title)
return;
content::TitleWatcher title_watcher(web_contents, expected_title);
EXPECT_EQ(expected_title, title_watcher.WaitAndGetTitle());
}
// Waits for the destruction of a RenderProcessHost's IPC channel.
// Used to make sure the PrerenderLinkManager's OnChannelClosed function has
// been called, before checking its state.
class ChannelDestructionWatcher {
public:
ChannelDestructionWatcher() : channel_destroyed_(false) {
}
~ChannelDestructionWatcher() {
}
void WatchChannel(content::RenderProcessHost* host) {
host->AddFilter(new DestructionMessageFilter(this));
}
void WaitForChannelClose() {
run_loop_.Run();
EXPECT_TRUE(channel_destroyed_);
}
private:
// When destroyed, calls ChannelDestructionWatcher::OnChannelDestroyed.
// Ignores all messages.
class DestructionMessageFilter : public content::BrowserMessageFilter {
public:
explicit DestructionMessageFilter(ChannelDestructionWatcher* watcher)
: BrowserMessageFilter(0),
watcher_(watcher) {
}
private:
virtual ~DestructionMessageFilter() {
content::BrowserThread::PostTask(
content::BrowserThread::UI, FROM_HERE,
base::Bind(&ChannelDestructionWatcher::OnChannelDestroyed,
base::Unretained(watcher_)));
}
virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
return false;
}
ChannelDestructionWatcher* watcher_;
DISALLOW_COPY_AND_ASSIGN(DestructionMessageFilter);
};
void OnChannelDestroyed() {
DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
EXPECT_FALSE(channel_destroyed_);
channel_destroyed_ = true;
run_loop_.Quit();
}
bool channel_destroyed_;
base::RunLoop run_loop_;
DISALLOW_COPY_AND_ASSIGN(ChannelDestructionWatcher);
};
// A navigation observer to wait on either a new load or a swap of a
// WebContents. On swap, if the new WebContents is still loading, wait for that
// load to complete as well. Note that the load must begin after the observer is
// attached.
class NavigationOrSwapObserver : public WebContentsObserver,
public TabStripModelObserver {
public:
// Waits for either a new load or a swap of |tab_strip_model|'s active
// WebContents.
NavigationOrSwapObserver(TabStripModel* tab_strip_model,
WebContents* web_contents)
: WebContentsObserver(web_contents),
tab_strip_model_(tab_strip_model),
did_start_loading_(false),
number_of_loads_(1) {
CHECK_NE(TabStripModel::kNoTab,
tab_strip_model->GetIndexOfWebContents(web_contents));
tab_strip_model_->AddObserver(this);
}
// Waits for either |number_of_loads| loads or a swap of |tab_strip_model|'s
// active WebContents.
NavigationOrSwapObserver(TabStripModel* tab_strip_model,
WebContents* web_contents,
int number_of_loads)
: WebContentsObserver(web_contents),
tab_strip_model_(tab_strip_model),
did_start_loading_(false),
number_of_loads_(number_of_loads) {
CHECK_NE(TabStripModel::kNoTab,
tab_strip_model->GetIndexOfWebContents(web_contents));
tab_strip_model_->AddObserver(this);
}
virtual ~NavigationOrSwapObserver() {
tab_strip_model_->RemoveObserver(this);
}
void set_did_start_loading() {
did_start_loading_ = true;
}
void Wait() {
loop_.Run();
}
// WebContentsObserver implementation:
virtual void DidStartLoading(RenderViewHost* render_view_host) OVERRIDE {
did_start_loading_ = true;
}
virtual void DidStopLoading(RenderViewHost* render_view_host) OVERRIDE {
if (!did_start_loading_)
return;
number_of_loads_--;
if (number_of_loads_ == 0)
loop_.Quit();
}
// TabStripModelObserver implementation:
virtual void TabReplacedAt(TabStripModel* tab_strip_model,
WebContents* old_contents,
WebContents* new_contents,
int index) OVERRIDE {
if (old_contents != web_contents())
return;
// Switch to observing the new WebContents.
Observe(new_contents);
if (new_contents->IsLoading()) {
// If the new WebContents is still loading, wait for it to complete. Only
// one load post-swap is supported.
did_start_loading_ = true;
number_of_loads_ = 1;
} else {
loop_.Quit();
}
}
private:
TabStripModel* tab_strip_model_;
bool did_start_loading_;
int number_of_loads_;
base::RunLoop loop_;
};
// Waits for a new tab to open and a navigation or swap in it.
class NewTabNavigationOrSwapObserver {
public:
NewTabNavigationOrSwapObserver()
: new_tab_observer_(
chrome::NOTIFICATION_TAB_ADDED,
base::Bind(&NewTabNavigationOrSwapObserver::OnTabAdded,
base::Unretained(this))) {
// Watch for NOTIFICATION_TAB_ADDED. Add a callback so that the
// NavigationOrSwapObserver can be attached synchronously and no events are
// missed.
}
void Wait() {
new_tab_observer_.Wait();
swap_observer_->Wait();
}
bool OnTabAdded(const content::NotificationSource& source,
const content::NotificationDetails& details) {
if (swap_observer_)
return true;
WebContents* new_tab = content::Details<WebContents>(details).ptr();
// Get the TabStripModel. Assume this is attached to a Browser.
TabStripModel* tab_strip_model =
static_cast<Browser*>(new_tab->GetDelegate())->tab_strip_model();
swap_observer_.reset(new NavigationOrSwapObserver(tab_strip_model,
new_tab));
swap_observer_->set_did_start_loading();
return true;
}
private:
content::WindowedNotificationObserver new_tab_observer_;
scoped_ptr<NavigationOrSwapObserver> swap_observer_;
};
// PrerenderContents that stops the UI message loop on DidStopLoading().
class TestPrerenderContents : public PrerenderContents {
public:
TestPrerenderContents(
PrerenderManager* prerender_manager,
Profile* profile,
const GURL& url,
const content::Referrer& referrer,
Origin origin,
FinalStatus expected_final_status)
: PrerenderContents(prerender_manager, profile, url,
referrer, origin, PrerenderManager::kNoExperiment),
expected_final_status_(expected_final_status),
new_render_view_host_(NULL),
was_hidden_(false),
was_shown_(false),
should_be_shown_(expected_final_status == FINAL_STATUS_USED),
skip_final_checks_(false) {
}
virtual ~TestPrerenderContents() {
if (skip_final_checks_)
return;
if (expected_final_status_ == FINAL_STATUS_MAX) {
EXPECT_EQ(MATCH_COMPLETE_REPLACEMENT, match_complete_status());
} else {
EXPECT_EQ(expected_final_status_, final_status()) <<
" when testing URL " << prerender_url().path() <<
" (Expected: " << NameFromFinalStatus(expected_final_status_) <<
", Actual: " << NameFromFinalStatus(final_status()) << ")";
}
// Prerendering RenderViewHosts should be hidden before the first
// navigation, so this should be happen for every PrerenderContents for
// which a RenderViewHost is created, regardless of whether or not it's
// used.
if (new_render_view_host_)
EXPECT_TRUE(was_hidden_);
// A used PrerenderContents will only be destroyed when we swap out
// WebContents, at the end of a navigation caused by a call to
// NavigateToURLImpl().
if (final_status() == FINAL_STATUS_USED)
EXPECT_TRUE(new_render_view_host_);
EXPECT_EQ(should_be_shown_, was_shown_);
}
virtual void RenderProcessGone(base::TerminationStatus status) OVERRIDE {
// On quit, it's possible to end up here when render processes are closed
// before the PrerenderManager is destroyed. As a result, it's possible to
// get either FINAL_STATUS_APP_TERMINATING or FINAL_STATUS_RENDERER_CRASHED
// on quit.
//
// It's also possible for this to be called after we've been notified of
// app termination, but before we've been deleted, which is why the second
// check is needed.
if (expected_final_status_ == FINAL_STATUS_APP_TERMINATING &&
final_status() != expected_final_status_) {
expected_final_status_ = FINAL_STATUS_RENDERER_CRASHED;
}
PrerenderContents::RenderProcessGone(status);
}
virtual bool CheckURL(const GURL& url) OVERRIDE {
// Prevent FINAL_STATUS_UNSUPPORTED_SCHEME when navigating to about:crash in
// the PrerenderRendererCrash test.
if (url.spec() != content::kChromeUICrashURL)
return PrerenderContents::CheckURL(url);
return true;
}
// For tests that open the prerender in a new background tab, the RenderView
// will not have been made visible when the PrerenderContents is destroyed
// even though it is used.
void set_should_be_shown(bool value) { should_be_shown_ = value; }
// For tests which do not know whether the prerender will be used.
void set_skip_final_checks(bool value) { skip_final_checks_ = value; }
FinalStatus expected_final_status() const { return expected_final_status_; }
private:
virtual void OnRenderViewHostCreated(
RenderViewHost* new_render_view_host) OVERRIDE {
// Used to make sure the RenderViewHost is hidden and, if used,
// subsequently shown.
notification_registrar().Add(
this,
content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
content::Source<RenderWidgetHost>(new_render_view_host));
new_render_view_host_ = new_render_view_host;
PrerenderContents::OnRenderViewHostCreated(new_render_view_host);
}
virtual void Observe(int type,
const content::NotificationSource& source,
const content::NotificationDetails& details) OVERRIDE {
if (type ==
content::NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED) {
EXPECT_EQ(new_render_view_host_,
content::Source<RenderWidgetHost>(source).ptr());
bool is_visible = *content::Details<bool>(details).ptr();
if (!is_visible) {
was_hidden_ = true;
} else if (is_visible && was_hidden_) {
// Once hidden, a prerendered RenderViewHost should only be shown after
// being removed from the PrerenderContents for display.
EXPECT_FALSE(GetRenderViewHost());
was_shown_ = true;
}
return;
}
PrerenderContents::Observe(type, source, details);
}
FinalStatus expected_final_status_;
// The RenderViewHost created for the prerender, if any.
RenderViewHost* new_render_view_host_;
// Set to true when the prerendering RenderWidget is hidden.
bool was_hidden_;
// Set to true when the prerendering RenderWidget is shown, after having been
// hidden.
bool was_shown_;
// Expected final value of was_shown_. Defaults to true for
// FINAL_STATUS_USED, and false otherwise.
bool should_be_shown_;
// If true, |expected_final_status_| and other shutdown checks are skipped.
bool skip_final_checks_;
};
// A handle to a TestPrerenderContents whose lifetime is under the caller's
// control. A PrerenderContents may be destroyed at any point. This allows
// tracking the final status, etc.
class TestPrerender : public PrerenderContents::Observer,
public base::SupportsWeakPtr<TestPrerender> {
public:
TestPrerender()
: contents_(NULL),
number_of_loads_(0),
expected_number_of_loads_(0) {
}
virtual ~TestPrerender() {
if (contents_)
contents_->RemoveObserver(this);
}
TestPrerenderContents* contents() const { return contents_; }
int number_of_loads() const { return number_of_loads_; }
void WaitForCreate() { create_loop_.Run(); }
void WaitForStart() { start_loop_.Run(); }
void WaitForStop() { stop_loop_.Run(); }
// Waits for |number_of_loads()| to be at least |expected_number_of_loads| OR
// for the prerender to stop running (just to avoid a timeout if the prerender
// dies). Note: this does not assert equality on the number of loads; the
// caller must do it instead.
void WaitForLoads(int expected_number_of_loads) {
DCHECK(!load_waiter_);
DCHECK(!expected_number_of_loads_);
if (number_of_loads_ < expected_number_of_loads) {
load_waiter_.reset(new base::RunLoop);
expected_number_of_loads_ = expected_number_of_loads;
load_waiter_->Run();
load_waiter_.reset();
expected_number_of_loads_ = 0;
}
EXPECT_LE(expected_number_of_loads, number_of_loads_);
}
void OnPrerenderCreated(TestPrerenderContents* contents) {
DCHECK(!contents_);
contents_ = contents;
contents_->AddObserver(this);
create_loop_.Quit();
}
// PrerenderContents::Observer implementation:
virtual void OnPrerenderStart(PrerenderContents* contents) OVERRIDE {
start_loop_.Quit();
}
virtual void OnPrerenderStopLoading(PrerenderContents* contents) OVERRIDE {
number_of_loads_++;
if (load_waiter_ && number_of_loads_ >= expected_number_of_loads_)
load_waiter_->Quit();
}
virtual void OnPrerenderStop(PrerenderContents* contents) OVERRIDE {
DCHECK(contents_);
contents_ = NULL;
stop_loop_.Quit();
// If there is a WaitForLoads call and it has yet to see the expected number
// of loads, stop the loop so the test fails instead of timing out.
if (load_waiter_)
load_waiter_->Quit();
}
virtual void OnPrerenderCreatedMatchCompleteReplacement(
PrerenderContents* contents, PrerenderContents* replacement) OVERRIDE {
}
private:
TestPrerenderContents* contents_;
int number_of_loads_;
int expected_number_of_loads_;
scoped_ptr<base::RunLoop> load_waiter_;
base::RunLoop create_loop_;
base::RunLoop start_loop_;
base::RunLoop stop_loop_;
DISALLOW_COPY_AND_ASSIGN(TestPrerender);
};
// PrerenderManager that uses TestPrerenderContents.
class TestPrerenderContentsFactory : public PrerenderContents::Factory {
public:
TestPrerenderContentsFactory() {}
virtual ~TestPrerenderContentsFactory() {
EXPECT_TRUE(expected_contents_queue_.empty());
}
scoped_ptr<TestPrerender> ExpectPrerenderContents(FinalStatus final_status) {
scoped_ptr<TestPrerender> handle(new TestPrerender());
expected_contents_queue_.push_back(
ExpectedContents(final_status, handle->AsWeakPtr()));
return handle.Pass();
}
virtual PrerenderContents* CreatePrerenderContents(
PrerenderManager* prerender_manager,
Profile* profile,
const GURL& url,
const content::Referrer& referrer,
Origin origin,
uint8 experiment_id) OVERRIDE {
ExpectedContents expected;
if (!expected_contents_queue_.empty()) {
expected = expected_contents_queue_.front();
expected_contents_queue_.pop_front();
}
VLOG(1) << "Creating prerender contents for " << url.path() <<
" with expected final status " << expected.final_status;
VLOG(1) << expected_contents_queue_.size() << " left in the queue.";
TestPrerenderContents* contents =
new TestPrerenderContents(prerender_manager,
profile, url, referrer, origin,
expected.final_status);
if (expected.handle)
expected.handle->OnPrerenderCreated(contents);
return contents;
}
private:
struct ExpectedContents {
ExpectedContents() : final_status(FINAL_STATUS_MAX) { }
ExpectedContents(FinalStatus final_status,
const base::WeakPtr<TestPrerender>& handle)
: final_status(final_status),
handle(handle) {
}
FinalStatus final_status;
base::WeakPtr<TestPrerender> handle;
};
std::deque<ExpectedContents> expected_contents_queue_;
};
#if defined(FULL_SAFE_BROWSING)
// A SafeBrowsingDatabaseManager implementation that returns a fixed result for
// a given URL.
class FakeSafeBrowsingDatabaseManager : public SafeBrowsingDatabaseManager {
public:
explicit FakeSafeBrowsingDatabaseManager(SafeBrowsingService* service)
: SafeBrowsingDatabaseManager(service),
threat_type_(SB_THREAT_TYPE_SAFE) { }
// Called on the IO thread to check if the given url is safe or not. If we
// can synchronously determine that the url is safe, CheckUrl returns true.
// Otherwise it returns false, and "client" is called asynchronously with the
// result when it is ready.
// Returns true, indicating a SAFE result, unless the URL is the fixed URL
// specified by the user, and the user-specified result is not SAFE
// (in which that result will be communicated back via a call into the
// client, and false will be returned).
// Overrides SafeBrowsingService::CheckBrowseUrl.
virtual bool CheckBrowseUrl(const GURL& gurl, Client* client) OVERRIDE {
if (gurl != url_ || threat_type_ == SB_THREAT_TYPE_SAFE)
return true;
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&FakeSafeBrowsingDatabaseManager::OnCheckBrowseURLDone,
this, gurl, client));
return false;
}
void SetThreatTypeForUrl(const GURL& url, SBThreatType threat_type) {
url_ = url;
threat_type_ = threat_type;
}
private:
virtual ~FakeSafeBrowsingDatabaseManager() {}
void OnCheckBrowseURLDone(const GURL& gurl, Client* client) {
std::vector<SBThreatType> expected_threats;
expected_threats.push_back(SB_THREAT_TYPE_URL_MALWARE);
expected_threats.push_back(SB_THREAT_TYPE_URL_PHISHING);
SafeBrowsingDatabaseManager::SafeBrowsingCheck sb_check(
std::vector<GURL>(1, gurl),
std::vector<SBFullHash>(),
client,
safe_browsing_util::MALWARE,
expected_threats);
sb_check.url_results[0] = threat_type_;
client->OnSafeBrowsingResult(sb_check);
}
GURL url_;
SBThreatType threat_type_;
DISALLOW_COPY_AND_ASSIGN(FakeSafeBrowsingDatabaseManager);
};
class FakeSafeBrowsingService : public SafeBrowsingService {
public:
FakeSafeBrowsingService() { }
// Returned pointer has the same lifespan as the database_manager_ refcounted
// object.
FakeSafeBrowsingDatabaseManager* fake_database_manager() {
return fake_database_manager_;
}
protected:
virtual ~FakeSafeBrowsingService() { }
virtual SafeBrowsingDatabaseManager* CreateDatabaseManager() OVERRIDE {
fake_database_manager_ = new FakeSafeBrowsingDatabaseManager(this);
return fake_database_manager_;
}
private:
FakeSafeBrowsingDatabaseManager* fake_database_manager_;
DISALLOW_COPY_AND_ASSIGN(FakeSafeBrowsingService);
};
// Factory that creates FakeSafeBrowsingService instances.
class TestSafeBrowsingServiceFactory : public SafeBrowsingServiceFactory {
public:
TestSafeBrowsingServiceFactory() :
most_recent_service_(NULL) { }
virtual ~TestSafeBrowsingServiceFactory() { }
virtual SafeBrowsingService* CreateSafeBrowsingService() OVERRIDE {
most_recent_service_ = new FakeSafeBrowsingService();
return most_recent_service_;
}
FakeSafeBrowsingService* most_recent_service() const {
return most_recent_service_;
}
private:
FakeSafeBrowsingService* most_recent_service_;
};
#endif
class FakeDevToolsClientHost : public DevToolsClientHost {
public:
FakeDevToolsClientHost() {}
virtual ~FakeDevToolsClientHost() {}
virtual void InspectedContentsClosing() OVERRIDE {}
virtual void DispatchOnInspectorFrontend(const std::string& msg) OVERRIDE {}
virtual void ReplacedWithAnotherClient() OVERRIDE {}
};
class RestorePrerenderMode {
public:
RestorePrerenderMode() : prev_mode_(PrerenderManager::GetMode()) {
}
~RestorePrerenderMode() { PrerenderManager::SetMode(prev_mode_); }
private:
PrerenderManager::PrerenderManagerMode prev_mode_;
};
// URLRequestJob (and associated handler) which hangs.
class HangingURLRequestJob : public net::URLRequestJob {
public:
HangingURLRequestJob(net::URLRequest* request,
net::NetworkDelegate* network_delegate)
: net::URLRequestJob(request, network_delegate) {
}
virtual void Start() OVERRIDE {}
private:
virtual ~HangingURLRequestJob() {}
};
class HangingFirstRequestInterceptor : public net::URLRequestInterceptor {
public:
HangingFirstRequestInterceptor(const base::FilePath& file,
base::Closure callback)
: file_(file),
callback_(callback),
first_run_(true) {
}
virtual ~HangingFirstRequestInterceptor() {}
virtual net::URLRequestJob* MaybeInterceptRequest(
net::URLRequest* request,
net::NetworkDelegate* network_delegate) const OVERRIDE {
if (first_run_) {
first_run_ = false;
if (!callback_.is_null()) {
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE, callback_);
}
return new HangingURLRequestJob(request, network_delegate);
}
return new content::URLRequestMockHTTPJob(request, network_delegate, file_);
}
private:
base::FilePath file_;
base::Closure callback_;
mutable bool first_run_;
};
// Makes |url| never respond on the first load, and then with the contents of
// |file| afterwards. When the first load has been scheduled, runs |callback| on
// the UI thread.
void CreateHangingFirstRequestInterceptorOnIO(
const GURL& url, const base::FilePath& file, base::Closure callback) {
CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
scoped_ptr<net::URLRequestInterceptor> never_respond_handler(
new HangingFirstRequestInterceptor(file, callback));
net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
url, never_respond_handler.Pass());
}
// Wrapper over URLRequestMockHTTPJob that exposes extra callbacks.
class MockHTTPJob : public content::URLRequestMockHTTPJob {
public:
MockHTTPJob(net::URLRequest* request,
net::NetworkDelegate* delegate,
const base::FilePath& file)
: content::URLRequestMockHTTPJob(request, delegate, file) {
}
void set_start_callback(const base::Closure& start_callback) {
start_callback_ = start_callback;
}
virtual void Start() OVERRIDE {
if (!start_callback_.is_null())
start_callback_.Run();
content::URLRequestMockHTTPJob::Start();
}
private:
virtual ~MockHTTPJob() {}
base::Closure start_callback_;
};
// Dummy counter class to live on the UI thread for counting requests.
class RequestCounter : public base::SupportsWeakPtr<RequestCounter> {
public:
RequestCounter() : count_(0), expected_count_(-1) {}
int count() const { return count_; }
void RequestStarted() {
count_++;
if (loop_ && count_ == expected_count_)
loop_->Quit();
}
void WaitForCount(int expected_count) {
ASSERT_TRUE(!loop_);
ASSERT_EQ(-1, expected_count_);
if (count_ < expected_count) {
expected_count_ = expected_count;
loop_.reset(new base::RunLoop);
loop_->Run();
expected_count_ = -1;
loop_.reset();
}
EXPECT_EQ(expected_count, count_);
}
private:
int count_;
int expected_count_;
scoped_ptr<base::RunLoop> loop_;
};
// Protocol handler which counts the number of requests that start.
class CountingInterceptor : public net::URLRequestInterceptor {
public:
CountingInterceptor(const base::FilePath& file,
const base::WeakPtr<RequestCounter>& counter)
: file_(file),
counter_(counter),
weak_factory_(this) {
}
virtual ~CountingInterceptor() {}
virtual net::URLRequestJob* MaybeInterceptRequest(
net::URLRequest* request,
net::NetworkDelegate* network_delegate) const OVERRIDE {
MockHTTPJob* job = new MockHTTPJob(request, network_delegate, file_);
job->set_start_callback(base::Bind(&CountingInterceptor::RequestStarted,
weak_factory_.GetWeakPtr()));
return job;
}
void RequestStarted() {
BrowserThread::PostTask(
BrowserThread::UI, FROM_HERE,
base::Bind(&RequestCounter::RequestStarted, counter_));
}
private:
base::FilePath file_;
base::WeakPtr<RequestCounter> counter_;
mutable base::WeakPtrFactory<CountingInterceptor> weak_factory_;
};
// Makes |url| respond to requests with the contents of |file|, counting the
// number that start in |counter|.
void CreateCountingInterceptorOnIO(
const GURL& url,
const base::FilePath& file,
const base::WeakPtr<RequestCounter>& counter) {
CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
scoped_ptr<net::URLRequestInterceptor> request_interceptor(
new CountingInterceptor(file, counter));
net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
url, request_interceptor.Pass());
}
// Makes |url| respond to requests with the contents of |file|.
void CreateMockInterceptorOnIO(const GURL& url, const base::FilePath& file) {
CHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
net::URLRequestFilter::GetInstance()->AddUrlInterceptor(
url,
content::URLRequestMockHTTPJob::CreateInterceptorForSingleFile(file));
}
// A ContentBrowserClient that cancels all prerenderers on OpenURL.
class TestContentBrowserClient : public chrome::ChromeContentBrowserClient {
public:
TestContentBrowserClient() {}
virtual ~TestContentBrowserClient() {}
// chrome::ChromeContentBrowserClient implementation.
virtual bool ShouldAllowOpenURL(content::SiteInstance* site_instance,
const GURL& url) OVERRIDE {
PrerenderManagerFactory::GetForProfile(
Profile::FromBrowserContext(site_instance->GetBrowserContext()))
->CancelAllPrerenders();
return chrome::ChromeContentBrowserClient::ShouldAllowOpenURL(site_instance,
url);
}
private:
DISALLOW_COPY_AND_ASSIGN(TestContentBrowserClient);
};
// A ContentBrowserClient that forces cross-process navigations.
class SwapProcessesContentBrowserClient
: public chrome::ChromeContentBrowserClient {
public:
SwapProcessesContentBrowserClient() {}
virtual ~SwapProcessesContentBrowserClient() {}
// chrome::ChromeContentBrowserClient implementation.
virtual bool ShouldSwapProcessesForRedirect(
content::ResourceContext* resource_context,
const GURL& current_url,
const GURL& new_url) OVERRIDE {
return true;
}
private:
DISALLOW_COPY_AND_ASSIGN(SwapProcessesContentBrowserClient);
};
// An ExternalProtocolHandler that blocks everything and asserts it never is
// called.
class NeverRunsExternalProtocolHandlerDelegate
: public ExternalProtocolHandler::Delegate {
public:
// ExternalProtocolHandler::Delegate implementation.
virtual ShellIntegration::DefaultProtocolClientWorker* CreateShellWorker(
ShellIntegration::DefaultWebClientObserver* observer,
const std::string& protocol) OVERRIDE {
NOTREACHED();
// This will crash, but it shouldn't get this far with BlockState::BLOCK
// anyway.
return NULL;
}
virtual ExternalProtocolHandler::BlockState GetBlockState(
const std::string& scheme) OVERRIDE {
// Block everything and fail the test.
ADD_FAILURE();
return ExternalProtocolHandler::BLOCK;
}
virtual void BlockRequest() OVERRIDE { }
virtual void RunExternalProtocolDialog(const GURL& url,
int render_process_host_id,
int routing_id) OVERRIDE {
NOTREACHED();
}
virtual void LaunchUrlWithoutSecurityCheck(const GURL& url) OVERRIDE {
NOTREACHED();
}
virtual void FinishedProcessingCheck() OVERRIDE {
NOTREACHED();
}
};
base::FilePath GetTestPath(const std::string& file_name) {
return ui_test_utils::GetTestFilePath(
base::FilePath(FILE_PATH_LITERAL("prerender")),
base::FilePath().AppendASCII(file_name));
}
} // namespace
// Many of these tests are flaky. See http://crbug.com/249179
class PrerenderBrowserTest : virtual public InProcessBrowserTest {
public:
PrerenderBrowserTest()
: autostart_test_server_(true),
prerender_contents_factory_(NULL),
#if defined(FULL_SAFE_BROWSING)
safe_browsing_factory_(new TestSafeBrowsingServiceFactory()),
#endif
call_javascript_(true),
check_load_events_(true),
loader_path_("files/prerender/prerender_loader.html"),
explicitly_set_browser_(NULL) {}
virtual ~PrerenderBrowserTest() {}
content::SessionStorageNamespace* GetSessionStorageNamespace() const {
WebContents* web_contents = GetActiveWebContents();
if (!web_contents)
return NULL;
return web_contents->GetController().GetDefaultSessionStorageNamespace();
}
virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
#if defined(FULL_SAFE_BROWSING)
SafeBrowsingService::RegisterFactory(safe_browsing_factory_.get());
#endif
}
virtual void TearDownInProcessBrowserTestFixture() OVERRIDE {
#if defined(FULL_SAFE_BROWSING)
SafeBrowsingService::RegisterFactory(NULL);
#endif
}
virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
command_line->AppendSwitchASCII(switches::kPrerenderMode,
switches::kPrerenderModeSwitchValueEnabled);
#if defined(OS_MACOSX)
// The plugins directory isn't read by default on the Mac, so it needs to be
// explicitly registered.
base::FilePath app_dir;
PathService::Get(chrome::DIR_APP, &app_dir);
command_line->AppendSwitchPath(
switches::kExtraPluginDir,
app_dir.Append(FILE_PATH_LITERAL("plugins")));
#endif
command_line->AppendSwitch(switches::kAlwaysAuthorizePlugins);
}
virtual void SetUpOnMainThread() OVERRIDE {
current_browser()->profile()->GetPrefs()->SetBoolean(
prefs::kPromptForDownload, false);
IncreasePrerenderMemory();
if (autostart_test_server_)
ASSERT_TRUE(test_server()->Start());
ChromeResourceDispatcherHostDelegate::
SetExternalProtocolHandlerDelegateForTesting(
&external_protocol_handler_delegate_);
PrerenderManager* prerender_manager = GetPrerenderManager();
ASSERT_TRUE(prerender_manager);
prerender_manager->mutable_config().rate_limit_enabled = false;
ASSERT_TRUE(prerender_contents_factory_ == NULL);
prerender_contents_factory_ = new TestPrerenderContentsFactory;
prerender_manager->SetPrerenderContentsFactory(prerender_contents_factory_);
}
// Convenience function to get the currently active WebContents in
// current_browser().
WebContents* GetActiveWebContents() const {
return current_browser()->tab_strip_model()->GetActiveWebContents();
}
// Overload for a single expected final status
scoped_ptr<TestPrerender> PrerenderTestURL(
const std::string& html_file,
FinalStatus expected_final_status,
int expected_number_of_loads) {
GURL url = test_server()->GetURL(html_file);
return PrerenderTestURL(url,
expected_final_status,
expected_number_of_loads);
}
ScopedVector<TestPrerender> PrerenderTestURL(
const std::string& html_file,
const std::vector<FinalStatus>& expected_final_status_queue,
int expected_number_of_loads) {
GURL url = test_server()->GetURL(html_file);
return PrerenderTestURLImpl(url,
expected_final_status_queue,
expected_number_of_loads);
}
scoped_ptr<TestPrerender> PrerenderTestURL(
const GURL& url,
FinalStatus expected_final_status,
int expected_number_of_loads) {
std::vector<FinalStatus> expected_final_status_queue(
1, expected_final_status);
std::vector<TestPrerender*> prerenders;
PrerenderTestURLImpl(url,
expected_final_status_queue,
expected_number_of_loads).release(&prerenders);
CHECK_EQ(1u, prerenders.size());
return scoped_ptr<TestPrerender>(prerenders[0]);
}
// Navigates to a URL, unrelated to prerendering
void NavigateStraightToURL(const std::string dest_html_file) {
ui_test_utils::NavigateToURL(current_browser(),
test_server()->GetURL(dest_html_file));
}
void NavigateToDestURL() const {
NavigateToDestURLWithDisposition(CURRENT_TAB, true);
}
// Opens the url in a new tab, with no opener.
void NavigateToDestURLWithDisposition(
WindowOpenDisposition disposition,
bool expect_swap_to_succeed) const {
NavigateToURLWithParams(
content::OpenURLParams(dest_url_, Referrer(), disposition,
content::PAGE_TRANSITION_TYPED, false),
expect_swap_to_succeed);
}
void NavigateToURL(const std::string& dest_html_file) const {
NavigateToURLWithDisposition(dest_html_file, CURRENT_TAB, true);
}
void NavigateToURLWithDisposition(const std::string& dest_html_file,
WindowOpenDisposition disposition,
bool expect_swap_to_succeed) const {
GURL dest_url = test_server()->GetURL(dest_html_file);
NavigateToURLWithDisposition(dest_url, disposition, expect_swap_to_succeed);
}
void NavigateToURLWithDisposition(const GURL& dest_url,
WindowOpenDisposition disposition,
bool expect_swap_to_succeed) const {
NavigateToURLWithParams(
content::OpenURLParams(dest_url, Referrer(), disposition,
content::PAGE_TRANSITION_TYPED, false),
expect_swap_to_succeed);
}
void NavigateToURLWithParams(const content::OpenURLParams& params,
bool expect_swap_to_succeed) const {
NavigateToURLImpl(params, expect_swap_to_succeed);
}
void OpenDestURLViaClick() const {
OpenURLViaClick(dest_url_);
}
void OpenURLViaClick(const GURL& url) const {
OpenURLWithJSImpl("Click", url, GURL(), false);
}
void OpenDestURLViaClickTarget() const {
OpenURLWithJSImpl("ClickTarget", dest_url_, GURL(), true);
}
void OpenDestURLViaClickPing(const GURL& ping_url) const {
OpenURLWithJSImpl("ClickPing", dest_url_, ping_url, false);
}
void OpenDestURLViaClickNewWindow() const {
OpenURLWithJSImpl("ShiftClick", dest_url_, GURL(), true);
}
void OpenDestURLViaClickNewForegroundTab() const {
#if defined(OS_MACOSX)
OpenURLWithJSImpl("MetaShiftClick", dest_url_, GURL(), true);
#else
OpenURLWithJSImpl("CtrlShiftClick", dest_url_, GURL(), true);
#endif
}
void OpenDestURLViaClickNewBackgroundTab() const {
#if defined(OS_MACOSX)
OpenURLWithJSImpl("MetaClick", dest_url_, GURL(), true);
#else
OpenURLWithJSImpl("CtrlClick", dest_url_, GURL(), true);
#endif
}
void OpenDestURLViaWindowOpen() const {
OpenURLViaWindowOpen(dest_url_);
}
void OpenURLViaWindowOpen(const GURL& url) const {
OpenURLWithJSImpl("WindowOpen", url, GURL(), true);
}
void RemoveLinkElement(int i) const {
GetActiveWebContents()->GetMainFrame()->ExecuteJavaScript(
base::ASCIIToUTF16(base::StringPrintf("RemoveLinkElement(%d)", i)));
}
void ClickToNextPageAfterPrerender() {
TestNavigationObserver nav_observer(GetActiveWebContents());
RenderFrameHost* render_frame_host = GetActiveWebContents()->GetMainFrame();
render_frame_host->ExecuteJavaScript(base::ASCIIToUTF16("ClickOpenLink()"));
nav_observer.Wait();
}
void NavigateToNextPageAfterPrerender() const {
ui_test_utils::NavigateToURL(
current_browser(),
test_server()->GetURL("files/prerender/prerender_page.html"));
}
// Called after the prerendered page has been navigated to and then away from.
// Navigates back through the history to the prerendered page.
void GoBackToPrerender() {
TestNavigationObserver back_nav_observer(GetActiveWebContents());
chrome::GoBack(current_browser(), CURRENT_TAB);
back_nav_observer.Wait();
bool original_prerender_page = false;
ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
GetActiveWebContents(),
"window.domAutomationController.send(IsOriginalPrerenderPage())",
&original_prerender_page));
EXPECT_TRUE(original_prerender_page);
}
// Goes back to the page that was active before the prerender was swapped
// in. This must be called when the prerendered page is the current page
// in the active tab.
void GoBackToPageBeforePrerender() {
WebContents* tab = GetActiveWebContents();
ASSERT_TRUE(tab);
EXPECT_FALSE(tab->IsLoading());
TestNavigationObserver back_nav_observer(tab);
chrome::GoBack(current_browser(), CURRENT_TAB);
back_nav_observer.Wait();
bool js_result;
ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
tab,
"window.domAutomationController.send(DidBackToOriginalPagePass())",
&js_result));
EXPECT_TRUE(js_result);
}
bool UrlIsInPrerenderManager(const std::string& html_file) const {
return UrlIsInPrerenderManager(test_server()->GetURL(html_file));
}
bool UrlIsInPrerenderManager(const GURL& url) const {
return GetPrerenderManager()->FindPrerenderData(
url, GetSessionStorageNamespace()) != NULL;
}
void UseHttpsSrcServer() {
if (https_src_server_)
return;
https_src_server_.reset(
new net::SpawnedTestServer(
net::SpawnedTestServer::TYPE_HTTPS,
net::SpawnedTestServer::kLocalhost,
base::FilePath(FILE_PATH_LITERAL("chrome/test/data"))));
CHECK(https_src_server_->Start());
}
void DisableJavascriptCalls() {
call_javascript_ = false;
}
void DisableLoadEventCheck() {
check_load_events_ = false;
}
TaskManagerModel* GetModel() const {
return TaskManager::GetInstance()->model();
}
PrerenderManager* GetPrerenderManager() const {
PrerenderManager* prerender_manager =
PrerenderManagerFactory::GetForProfile(current_browser()->profile());
return prerender_manager;
}
const PrerenderLinkManager* GetPrerenderLinkManager() const {
PrerenderLinkManager* prerender_link_manager =
PrerenderLinkManagerFactory::GetForProfile(
current_browser()->profile());
return prerender_link_manager;
}
int GetPrerenderEventCount(int index, const std::string& type) const {
int event_count;
std::string expression = base::StringPrintf(
"window.domAutomationController.send("
" GetPrerenderEventCount(%d, '%s'))", index, type.c_str());
CHECK(content::ExecuteScriptAndExtractInt(
GetActiveWebContents(), expression, &event_count));
return event_count;
}
bool DidReceivePrerenderStartEventForLinkNumber(int index) const {
return GetPrerenderEventCount(index, "webkitprerenderstart") > 0;
}
int GetPrerenderLoadEventCountForLinkNumber(int index) const {
return GetPrerenderEventCount(index, "webkitprerenderload");
}
int GetPrerenderDomContentLoadedEventCountForLinkNumber(int index) const {
return GetPrerenderEventCount(index, "webkitprerenderdomcontentloaded");
}
bool DidReceivePrerenderStopEventForLinkNumber(int index) const {
return GetPrerenderEventCount(index, "webkitprerenderstop") > 0;
}
void WaitForPrerenderEventCount(int index,
const std::string& type,
int count) const {
int dummy;
std::string expression = base::StringPrintf(
"WaitForPrerenderEventCount(%d, '%s', %d,"
" window.domAutomationController.send.bind("
" window.domAutomationController, 0))",
index, type.c_str(), count);
CHECK(content::ExecuteScriptAndExtractInt(
GetActiveWebContents(), expression, &dummy));
CHECK_EQ(0, dummy);
}
bool HadPrerenderEventErrors() const {
bool had_prerender_event_errors;
CHECK(content::ExecuteScriptAndExtractBool(
GetActiveWebContents(),
"window.domAutomationController.send(Boolean("
" hadPrerenderEventErrors))",
&had_prerender_event_errors));
return had_prerender_event_errors;
}
// Asserting on this can result in flaky tests. PrerenderHandles are
// removed from the PrerenderLinkManager when the prerender is canceled from
// the browser, when the prerenders are cancelled from the renderer process,
// or the channel for the renderer process is closed on the IO thread. In the
// last case, the code must be careful to wait for the channel to close, as it
// is done asynchronously after swapping out the old process. See
// ChannelDestructionWatcher.
bool IsEmptyPrerenderLinkManager() const {
return GetPrerenderLinkManager()->IsEmpty();
}
size_t GetLinkPrerenderCount() const {
return GetPrerenderLinkManager()->prerenders_.size();
}
size_t GetRunningLinkPrerenderCount() const {
return GetPrerenderLinkManager()->CountRunningPrerenders();
}
// Returns length of |prerender_manager_|'s history, or -1 on failure.
int GetHistoryLength() const {
scoped_ptr<base::DictionaryValue> prerender_dict(
static_cast<base::DictionaryValue*>(
GetPrerenderManager()->GetAsValue()));
if (!prerender_dict.get())
return -1;
base::ListValue* history_list;
if (!prerender_dict->GetList("history", &history_list))
return -1;
return static_cast<int>(history_list->GetSize());
}
#if defined(FULL_SAFE_BROWSING)
FakeSafeBrowsingDatabaseManager* GetFakeSafeBrowsingDatabaseManager() {
return safe_browsing_factory_->most_recent_service()->
fake_database_manager();
}
#endif
TestPrerenderContents* GetPrerenderContentsFor(const GURL& url) const {
PrerenderManager::PrerenderData* prerender_data =
GetPrerenderManager()->FindPrerenderData(url, NULL);
return static_cast<TestPrerenderContents*>(
prerender_data ? prerender_data->contents() : NULL);
}
void SetLoaderHostOverride(const std::string& host) {
loader_host_override_ = host;
host_resolver()->AddRule(host, "127.0.0.1");
}
void set_loader_path(const std::string& path) {
loader_path_ = path;
}
void set_loader_query(const std::string& query) {
loader_query_ = query;
}
GURL GetCrossDomainTestUrl(const std::string& path) {
static const std::string secondary_domain = "www.foo.com";
host_resolver()->AddRule(secondary_domain, "127.0.0.1");
std::string url_str(base::StringPrintf(
"http://%s:%d/%s",
secondary_domain.c_str(),
test_server()->host_port_pair().port(),
path.c_str()));
return GURL(url_str);
}
void set_browser(Browser* browser) {
explicitly_set_browser_ = browser;
}
Browser* current_browser() const {
return explicitly_set_browser_ ? explicitly_set_browser_ : browser();
}
const GURL& dest_url() const {
return dest_url_;
}
void IncreasePrerenderMemory() {
// Increase the memory allowed in a prerendered page above normal settings.
// Debug build bots occasionally run against the default limit, and tests
// were failing because the prerender was canceled due to memory exhaustion.
// http://crbug.com/93076
GetPrerenderManager()->mutable_config().max_bytes = 1000 * 1024 * 1024;
}
bool DidPrerenderPass(WebContents* web_contents) const {
bool prerender_test_result = false;
if (!content::ExecuteScriptAndExtractBool(
web_contents,
"window.domAutomationController.send(DidPrerenderPass())",
&prerender_test_result))
return false;
return prerender_test_result;
}
bool DidDisplayPass(WebContents* web_contents) const {
bool display_test_result = false;
if (!content::ExecuteScriptAndExtractBool(
web_contents,
"window.domAutomationController.send(DidDisplayPass())",
&display_test_result))
return false;
return display_test_result;
}
scoped_ptr<TestPrerender> ExpectPrerender(FinalStatus expected_final_status) {
return prerender_contents_factory_->ExpectPrerenderContents(
expected_final_status);
}
void AddPrerender(const GURL& url, int index) {
std::string javascript = base::StringPrintf(
"AddPrerender('%s', %d)", url.spec().c_str(), index);
RenderFrameHost* render_frame_host = GetActiveWebContents()->GetMainFrame();
render_frame_host->ExecuteJavaScript(base::ASCIIToUTF16(javascript));
}
// Returns a string for pattern-matching TaskManager tab entries.
base::string16 MatchTaskManagerTab(const char* page_title) {
return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_TAB_PREFIX,
base::ASCIIToUTF16(page_title));
}
// Returns a string for pattern-matching TaskManager prerender entries.
base::string16 MatchTaskManagerPrerender(const char* page_title) {
return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_PRERENDER_PREFIX,
base::ASCIIToUTF16(page_title));
}
void RunJSReturningString(const char* js, std::string* result) {
ASSERT_TRUE(
content::ExecuteScriptAndExtractString(
GetActiveWebContents(),
base::StringPrintf("window.domAutomationController.send(%s)",
js).c_str(),
result));
}
void RunJS(const char* js) {
ASSERT_TRUE(content::ExecuteScript(
GetActiveWebContents(),
base::StringPrintf("window.domAutomationController.send(%s)",
js).c_str()));
}
protected:
bool autostart_test_server_;
private:
// TODO(davidben): Remove this altogether so the tests don't globally assume
// only one prerender.
TestPrerenderContents* GetPrerenderContents() const {
return GetPrerenderContentsFor(dest_url_);
}
ScopedVector<TestPrerender> PrerenderTestURLImpl(
const GURL& prerender_url,
const std::vector<FinalStatus>& expected_final_status_queue,
int expected_number_of_loads) {
dest_url_ = prerender_url;
std::vector<net::SpawnedTestServer::StringPair> replacement_text;
replacement_text.push_back(
make_pair("REPLACE_WITH_PRERENDER_URL", prerender_url.spec()));
std::string replacement_path;
CHECK(net::SpawnedTestServer::GetFilePathWithReplacements(
loader_path_,
replacement_text,
&replacement_path));
const net::SpawnedTestServer* src_server = test_server();
if (https_src_server_)
src_server = https_src_server_.get();
GURL loader_url = src_server->GetURL(
replacement_path + "&" + loader_query_);
GURL::Replacements loader_replacements;
if (!loader_host_override_.empty())
loader_replacements.SetHostStr(loader_host_override_);
loader_url = loader_url.ReplaceComponents(loader_replacements);
VLOG(1) << "Running test with queue length " <<
expected_final_status_queue.size();
CHECK(!expected_final_status_queue.empty());
ScopedVector<TestPrerender> prerenders;
for (size_t i = 0; i < expected_final_status_queue.size(); i++) {
prerenders.push_back(
prerender_contents_factory_->ExpectPrerenderContents(
expected_final_status_queue[i]).release());
}
FinalStatus expected_final_status = expected_final_status_queue.front();
// Navigate to the loader URL and then wait for the first prerender to be
// created.
ui_test_utils::NavigateToURL(current_browser(), loader_url);
prerenders[0]->WaitForCreate();
prerenders[0]->WaitForLoads(expected_number_of_loads);
if (ShouldAbortPrerenderBeforeSwap(expected_final_status)) {
// The prerender will abort on its own. Assert it does so correctly.
prerenders[0]->WaitForStop();
EXPECT_FALSE(prerenders[0]->contents());
EXPECT_TRUE(DidReceivePrerenderStopEventForLinkNumber(0));
} else {
// Otherwise, check that it prerendered correctly.
TestPrerenderContents* prerender_contents = prerenders[0]->contents();
CHECK_NE(static_cast<PrerenderContents*>(NULL), prerender_contents);
EXPECT_EQ(FINAL_STATUS_MAX, prerender_contents->final_status());
EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
if (call_javascript_) {
// Check if page behaves as expected while in prerendered state.
EXPECT_TRUE(DidPrerenderPass(prerender_contents->prerender_contents()));
}
}
// Test that the referring page received the right start and load events.
EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
if (check_load_events_) {
EXPECT_EQ(expected_number_of_loads, prerenders[0]->number_of_loads());
EXPECT_EQ(expected_number_of_loads,
GetPrerenderLoadEventCountForLinkNumber(0));
}
EXPECT_FALSE(HadPrerenderEventErrors());
return prerenders.Pass();
}
void NavigateToURLImpl(const content::OpenURLParams& params,
bool expect_swap_to_succeed) const {
ASSERT_NE(static_cast<PrerenderManager*>(NULL), GetPrerenderManager());
// Make sure in navigating we have a URL to use in the PrerenderManager.
ASSERT_NE(static_cast<PrerenderContents*>(NULL), GetPrerenderContents());
WebContents* web_contents = GetPrerenderContents()->prerender_contents();
// Navigate and wait for either the load to finish normally or for a swap to
// occur.
// TODO(davidben): The only handles CURRENT_TAB navigations, which is the
// only case tested or prerendered right now.
CHECK_EQ(CURRENT_TAB, params.disposition);
NavigationOrSwapObserver swap_observer(current_browser()->tab_strip_model(),
GetActiveWebContents());
WebContents* target_web_contents = current_browser()->OpenURL(params);
swap_observer.Wait();
if (web_contents && expect_swap_to_succeed) {
EXPECT_EQ(web_contents, target_web_contents);
if (call_javascript_)
EXPECT_TRUE(DidDisplayPass(web_contents));
}
}
// Opens the prerendered page using javascript functions in the loader
// page. |javascript_function_name| should be a 0 argument function which is
// invoked. |new_web_contents| is true if the navigation is expected to
// happen in a new WebContents via OpenURL.
void OpenURLWithJSImpl(const std::string& javascript_function_name,
const GURL& url,
const GURL& ping_url,
bool new_web_contents) const {
WebContents* web_contents = GetActiveWebContents();
RenderFrameHost* render_frame_host = web_contents->GetMainFrame();
// Extra arguments in JS are ignored.
std::string javascript = base::StringPrintf(
"%s('%s', '%s')", javascript_function_name.c_str(),
url.spec().c_str(), ping_url.spec().c_str());
if (new_web_contents) {
NewTabNavigationOrSwapObserver observer;
render_frame_host->ExecuteJavaScript(base::ASCIIToUTF16(javascript));
observer.Wait();
} else {
NavigationOrSwapObserver observer(current_browser()->tab_strip_model(),
web_contents);
render_frame_host->ExecuteJavaScript(base::ASCIIToUTF16(javascript));
observer.Wait();
}
}
TestPrerenderContentsFactory* prerender_contents_factory_;
#if defined(FULL_SAFE_BROWSING)
scoped_ptr<TestSafeBrowsingServiceFactory> safe_browsing_factory_;
#endif
NeverRunsExternalProtocolHandlerDelegate external_protocol_handler_delegate_;
GURL dest_url_;
scoped_ptr<net::SpawnedTestServer> https_src_server_;
bool call_javascript_;
bool check_load_events_;
std::string loader_host_override_;
std::string loader_path_;
std::string loader_query_;
Browser* explicitly_set_browser_;
};
// Checks that a page is correctly prerendered in the case of a
// <link rel=prerender> tag and then loaded into a tab in response to a
// navigation.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPage) {
UMAHistogramHelper histograms;
PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
EXPECT_EQ(1, GetPrerenderDomContentLoadedEventCountForLinkNumber(0));
histograms.Fetch();
histograms.ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatchedComplete", 0);
histograms.ExpectTotalCount("Prerender.websame_PrerenderNotSwappedInPLT", 1);
ChannelDestructionWatcher channel_close_watcher;
channel_close_watcher.WatchChannel(
GetActiveWebContents()->GetRenderProcessHost());
NavigateToDestURL();
channel_close_watcher.WaitForChannelClose();
histograms.Fetch();
histograms.ExpectTotalCount("Prerender.websame_PerceivedPLT", 1);
histograms.ExpectTotalCount("Prerender.websame_PerceivedPLTMatched", 1);
histograms.ExpectTotalCount(
"Prerender.websame_PerceivedPLTMatchedComplete", 1);
ASSERT_TRUE(IsEmptyPrerenderLinkManager());
}
// Checks that cross-domain prerenders emit the correct histograms.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageCrossDomain) {
UMAHistogramHelper histograms;
PrerenderTestURL(GetCrossDomainTestUrl("files/prerender/prerender_page.html"),
FINAL_STATUS_USED, 1);
histograms.Fetch();
histograms.ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatchedComplete", 0);
histograms.ExpectTotalCount("Prerender.webcross_PrerenderNotSwappedInPLT", 1);
NavigateToDestURL();
histograms.Fetch();
histograms.ExpectTotalCount("Prerender.webcross_PerceivedPLT", 1);
histograms.ExpectTotalCount("Prerender.webcross_PerceivedPLTMatched", 1);
histograms.ExpectTotalCount(
"Prerender.webcross_PerceivedPLTMatchedComplete", 1);
}
// Checks that pending prerenders launch and receive proper event treatment.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPagePending) {
scoped_ptr<TestPrerender> prerender =
PrerenderTestURL("files/prerender/prerender_page_pending.html",
FINAL_STATUS_USED, 1);
// Navigate to the prerender.
scoped_ptr<TestPrerender> prerender2 = ExpectPrerender(FINAL_STATUS_USED);
NavigateToDestURL();
// Abort early if the original prerender didn't swap, so as not to hang.
ASSERT_FALSE(prerender->contents());
// Wait for the new prerender to be ready.
prerender2->WaitForStart();
prerender2->WaitForLoads(1);
const GURL prerender_page_url =
test_server()->GetURL("files/prerender/prerender_page.html");
EXPECT_FALSE(IsEmptyPrerenderLinkManager());
EXPECT_NE(static_cast<TestPrerenderContents*>(NULL),
GetPrerenderContentsFor(prerender_page_url));
// Now navigate to our target page.
NavigationOrSwapObserver swap_observer(current_browser()->tab_strip_model(),
GetActiveWebContents());
ui_test_utils::NavigateToURLWithDisposition(
current_browser(), prerender_page_url, CURRENT_TAB,
ui_test_utils::BROWSER_TEST_NONE);
swap_observer.Wait();
EXPECT_TRUE(IsEmptyPrerenderLinkManager());
}
// Checks that pending prerenders which are canceled before they are launched
// never get started.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageRemovesPending) {
PrerenderTestURL("files/prerender/prerender_page_removes_pending.html",
FINAL_STATUS_USED, 1);
ChannelDestructionWatcher channel_close_watcher;
channel_close_watcher.WatchChannel(
GetActiveWebContents()->GetRenderProcessHost());
NavigateToDestURL();
channel_close_watcher.WaitForChannelClose();
EXPECT_FALSE(DidReceivePrerenderStartEventForLinkNumber(1));
EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
EXPECT_FALSE(HadPrerenderEventErrors());
// IsEmptyPrerenderLinkManager() is not racy because the earlier DidReceive*
// calls did a thread/process hop to the renderer which insured pending
// renderer events have arrived.
ASSERT_TRUE(IsEmptyPrerenderLinkManager());
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageRemovingLink) {
scoped_ptr<TestPrerender> prerender =
PrerenderTestURL("files/prerender/prerender_page.html",
FINAL_STATUS_CANCELLED, 1);
// No ChannelDestructionWatcher is needed here, since prerenders in the
// PrerenderLinkManager should be deleted by removing the links, rather than
// shutting down the renderer process.
RemoveLinkElement(0);
prerender->WaitForStop();
EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
EXPECT_FALSE(HadPrerenderEventErrors());
// IsEmptyPrerenderLinkManager() is not racy because the earlier DidReceive*
// calls did a thread/process hop to the renderer which insured pending
// renderer events have arrived.
EXPECT_TRUE(IsEmptyPrerenderLinkManager());
}
IN_PROC_BROWSER_TEST_F(
PrerenderBrowserTest, PrerenderPageRemovingLinkWithTwoLinks) {
GetPrerenderManager()->mutable_config().max_link_concurrency = 2;
GetPrerenderManager()->mutable_config().max_link_concurrency_per_launcher = 2;
set_loader_query("links_to_insert=2");
scoped_ptr<TestPrerender> prerender =
PrerenderTestURL("files/prerender/prerender_page.html",
FINAL_STATUS_CANCELLED, 1);
EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(1));
EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
RemoveLinkElement(0);
RemoveLinkElement(1);
prerender->WaitForStop();
EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(1));
EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
EXPECT_FALSE(HadPrerenderEventErrors());
// IsEmptyPrerenderLinkManager() is not racy because the earlier DidReceive*
// calls did a thread/process hop to the renderer which insured pending
// renderer events have arrived.
EXPECT_TRUE(IsEmptyPrerenderLinkManager());
}
IN_PROC_BROWSER_TEST_F(
PrerenderBrowserTest, PrerenderPageRemovingLinkWithTwoLinksOneLate) {
GetPrerenderManager()->mutable_config().max_link_concurrency = 2;
GetPrerenderManager()->mutable_config().max_link_concurrency_per_launcher = 2;
GURL url = test_server()->GetURL("files/prerender/prerender_page.html");
scoped_ptr<TestPrerender> prerender =
PrerenderTestURL(url, FINAL_STATUS_CANCELLED, 1);
// Add a second prerender for the same link. It reuses the prerender, so only
// the start event fires here.
AddPrerender(url, 1);
WaitForPrerenderEventCount(1, "webkitprerenderstart", 1);
EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(1));
EXPECT_EQ(0, GetPrerenderLoadEventCountForLinkNumber(1));
EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
RemoveLinkElement(0);
RemoveLinkElement(1);
prerender->WaitForStop();
EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(1));
EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
EXPECT_FALSE(HadPrerenderEventErrors());
// IsEmptyPrerenderLinkManager() is not racy because the earlier DidReceive*
// calls did a thread/process hop to the renderer which insured pending
// renderer events have arrived.
EXPECT_TRUE(IsEmptyPrerenderLinkManager());
}
IN_PROC_BROWSER_TEST_F(
PrerenderBrowserTest,
PrerenderPageRemovingLinkWithTwoLinksRemovingOne) {
GetPrerenderManager()->mutable_config().max_link_concurrency = 2;
GetPrerenderManager()->mutable_config().max_link_concurrency_per_launcher = 2;
set_loader_query("links_to_insert=2");
PrerenderTestURL("files/prerender/prerender_page.html",
FINAL_STATUS_USED, 1);
EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(1));
EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
RemoveLinkElement(0);
EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(0));
EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(1));
EXPECT_FALSE(DidReceivePrerenderStopEventForLinkNumber(1));
EXPECT_FALSE(HadPrerenderEventErrors());
// IsEmptyPrerenderLinkManager() is not racy because the earlier DidReceive*
// calls did a thread/process hop to the renderer which insured pending
// renderer events have arrived.
EXPECT_FALSE(IsEmptyPrerenderLinkManager());
ChannelDestructionWatcher channel_close_watcher;
channel_close_watcher.WatchChannel(
GetActiveWebContents()->GetRenderProcessHost());
NavigateToDestURL();
channel_close_watcher.WaitForChannelClose();
EXPECT_TRUE(IsEmptyPrerenderLinkManager());
}
// Checks that the visibility API works.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderVisibility) {
PrerenderTestURL("files/prerender/prerender_visibility.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// Checks that the prerendering of a page is canceled correctly if we try to
// swap it in before it commits.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNoCommitNoSwap) {
// Navigate to a page that triggers a prerender for a URL that never commits.
const GURL kNoCommitUrl("http://never-respond.example.com");
base::FilePath file(GetTestPath("prerender_page.html"));
base::RunLoop prerender_start_loop;
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&CreateHangingFirstRequestInterceptorOnIO, kNoCommitUrl, file,
prerender_start_loop.QuitClosure()));
DisableJavascriptCalls();
PrerenderTestURL(kNoCommitUrl,
FINAL_STATUS_NAVIGATION_UNCOMMITTED,
0);
// Wait for the hanging request to be scheduled.
prerender_start_loop.Run();
// Navigate to the URL, but assume the contents won't be swapped in.
NavigateToDestURLWithDisposition(CURRENT_TAB, false);
}
// Checks that client redirects don't add alias URLs until after they commit.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNoCommitNoSwap2) {
// Navigate to a page that then navigates to a URL that never commits.
const GURL kNoCommitUrl("http://never-respond.example.com");
base::FilePath file(GetTestPath("prerender_page.html"));
base::RunLoop prerender_start_loop;
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&CreateHangingFirstRequestInterceptorOnIO, kNoCommitUrl, file,
prerender_start_loop.QuitClosure()));
DisableJavascriptCalls();
PrerenderTestURL(CreateClientRedirect(kNoCommitUrl.spec()),
FINAL_STATUS_APP_TERMINATING, 1);
// Wait for the hanging request to be scheduled.
prerender_start_loop.Run();
// Navigating to the second URL should not swap.
NavigateToURLWithDisposition(kNoCommitUrl, CURRENT_TAB, false);
}
// Checks that the prerendering of a page is canceled correctly when a
// Javascript alert is called.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderAlertBeforeOnload) {
PrerenderTestURL("files/prerender/prerender_alert_before_onload.html",
FINAL_STATUS_JAVASCRIPT_ALERT,
0);
}
// Checks that the prerendering of a page is canceled correctly when a
// Javascript alert is called.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderAlertAfterOnload) {
PrerenderTestURL("files/prerender/prerender_alert_after_onload.html",
FINAL_STATUS_JAVASCRIPT_ALERT,
1);
}
// Checks that plugins are not loaded while a page is being preloaded, but
// are loaded when the page is displayed.
#if defined(USE_AURA) && !defined(OS_WIN)
// http://crbug.com/103496
#define MAYBE_PrerenderDelayLoadPlugin DISABLED_PrerenderDelayLoadPlugin
#elif defined(OS_MACOSX)
// http://crbug.com/100514
#define MAYBE_PrerenderDelayLoadPlugin DISABLED_PrerenderDelayLoadPlugin
#elif defined(OS_WIN) && defined(ARCH_CPU_X86_64)
// TODO(jschuh): Failing plugin tests. crbug.com/244653
#define MAYBE_PrerenderDelayLoadPlugin DISABLED_PrerenderDelayLoadPlugin
#elif defined(OS_LINUX)
// http://crbug.com/306715
#define MAYBE_PrerenderDelayLoadPlugin DISABLED_PrerenderDelayLoadPlugin
#else
#define MAYBE_PrerenderDelayLoadPlugin PrerenderDelayLoadPlugin
#endif
// http://crbug.com/306715
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, MAYBE_PrerenderDelayLoadPlugin) {
PrerenderTestURL("files/prerender/plugin_delay_load.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// Checks that plugins are not loaded on prerendering pages when click-to-play
// is enabled.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickToPlay) {
// Enable click-to-play.
HostContentSettingsMap* content_settings_map =
current_browser()->profile()->GetHostContentSettingsMap();
content_settings_map->SetDefaultContentSetting(
CONTENT_SETTINGS_TYPE_PLUGINS, CONTENT_SETTING_ASK);
PrerenderTestURL("files/prerender/prerender_plugin_click_to_play.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// Checks that we don't load a NaCl plugin when NaCl is disabled.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNaClPluginDisabled) {
PrerenderTestURL("files/prerender/prerender_plugin_nacl_disabled.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
// Run this check again. When we try to load aa ppapi plugin, the
// "loadstart" event is asynchronously posted to a message loop.
// It's possible that earlier call could have been run before the
// the "loadstart" event was posted.
// TODO(mmenke): While this should reliably fail on regressions, the
// reliability depends on the specifics of ppapi plugin
// loading. It would be great if we could avoid that.
EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
}
// Checks that plugins in an iframe are not loaded while a page is
// being preloaded, but are loaded when the page is displayed.
#if defined(USE_AURA) && !defined(OS_WIN)
// http://crbug.com/103496
#define MAYBE_PrerenderIframeDelayLoadPlugin \
DISABLED_PrerenderIframeDelayLoadPlugin
#elif defined(OS_MACOSX)
// http://crbug.com/100514
#define MAYBE_PrerenderIframeDelayLoadPlugin \
DISABLED_PrerenderIframeDelayLoadPlugin
#elif defined(OS_WIN) && defined(ARCH_CPU_X86_64)
// TODO(jschuh): Failing plugin tests. crbug.com/244653
#define MAYBE_PrerenderIframeDelayLoadPlugin \
DISABLED_PrerenderIframeDelayLoadPlugin
#else
#define MAYBE_PrerenderIframeDelayLoadPlugin PrerenderIframeDelayLoadPlugin
#endif
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
MAYBE_PrerenderIframeDelayLoadPlugin) {
PrerenderTestURL("files/prerender/prerender_iframe_plugin_delay_load.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// Renders a page that contains a prerender link to a page that contains an
// iframe with a source that requires http authentication. This should not
// prerender successfully.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHttpAuthentication) {
PrerenderTestURL("files/prerender/prerender_http_auth_container.html",
FINAL_STATUS_AUTH_NEEDED,
0);
}
// Checks that client-issued redirects work with prerendering.
// This version navigates to the page which issues the redirection, rather
// than the final destination page.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderClientRedirectNavigateToFirst) {
PrerenderTestURL(CreateClientRedirect("files/prerender/prerender_page.html"),
FINAL_STATUS_USED,
2);
NavigateToDestURL();
}
// Checks that client-issued redirects work with prerendering.
// This version navigates to the final destination page, rather than the
// page which does the redirection.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderClientRedirectNavigateToSecond) {
PrerenderTestURL(CreateClientRedirect("files/prerender/prerender_page.html"),
FINAL_STATUS_USED,
2);
NavigateToURL("files/prerender/prerender_page.html");
}
// Checks that redirects with location.replace do not cancel a prerender and
// and swap when navigating to the first page.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderLocationReplaceNavigateToFirst) {
PrerenderTestURL("files/prerender/prerender_location_replace.html",
FINAL_STATUS_USED,
2);
NavigateToDestURL();
}
// Checks that redirects with location.replace do not cancel a prerender and
// and swap when navigating to the second.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderLocationReplaceNavigateToSecond) {
PrerenderTestURL("files/prerender/prerender_location_replace.html",
FINAL_STATUS_USED,
2);
NavigateToURL("files/prerender/prerender_page.html");
}
// Checks that we get the right PPLT histograms for client redirect prerenders
// and navigations when the referring page is Google.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderLocationReplaceGWSHistograms) {
DisableJavascriptCalls();
UMAHistogramHelper histograms;
// The loader page should look like Google.
const std::string kGoogleDotCom("www.google.com");
SetLoaderHostOverride(kGoogleDotCom);
set_loader_path("files/prerender/prerender_loader_with_replace_state.html");
GURL dest_url = GetCrossDomainTestUrl(
"files/prerender/prerender_deferred_image.html");
GURL prerender_url = test_server()->GetURL(
"files/prerender/prerender_location_replace.html?" +
net::EscapeQueryParamValue(dest_url.spec(), false) +
"#prerender");
GURL::Replacements replacements;
replacements.SetHostStr(kGoogleDotCom);
prerender_url = prerender_url.ReplaceComponents(replacements);
// The prerender will not completely load until after the swap, so wait for a
// title change before calling DidPrerenderPass.
scoped_ptr<TestPrerender> prerender =
PrerenderTestURL(prerender_url, FINAL_STATUS_USED, 1);
WaitForASCIITitle(prerender->contents()->prerender_contents(), kReadyTitle);
EXPECT_TRUE(DidPrerenderPass(prerender->contents()->prerender_contents()));
EXPECT_EQ(1, prerender->number_of_loads());
histograms.Fetch();
histograms.ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatchedComplete", 0);
// Although there is a client redirect, it is dropped from histograms because
// it is a Google URL. The target page itself does not load until after the
// swap.
histograms.ExpectTotalCount("Prerender.gws_PrerenderNotSwappedInPLT", 0);
GURL navigate_url = test_server()->GetURL(
"files/prerender/prerender_location_replace.html?" +
net::EscapeQueryParamValue(dest_url.spec(), false) +
"#navigate");
navigate_url = navigate_url.ReplaceComponents(replacements);
NavigationOrSwapObserver swap_observer(
current_browser()->tab_strip_model(),
GetActiveWebContents(), 2);
current_browser()->OpenURL(OpenURLParams(
navigate_url, Referrer(), CURRENT_TAB,
content::PAGE_TRANSITION_TYPED, false));
swap_observer.Wait();
EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
histograms.Fetch();
histograms.ExpectTotalCount("Prerender.gws_PrerenderNotSwappedInPLT", 0);
histograms.ExpectTotalCount("Prerender.gws_PerceivedPLT", 1);
histograms.ExpectTotalCount("Prerender.gws_PerceivedPLTMatched", 1);
histograms.ExpectTotalCount(
"Prerender.gws_PerceivedPLTMatchedComplete", 1);
// The client redirect does /not/ count as a miss because it's a Google URL.
histograms.ExpectTotalCount("Prerender.PerceivedPLTFirstAfterMiss", 0);
}
// Checks that client-issued redirects work with prerendering.
// This version navigates to the final destination page, rather than the
// page which does the redirection via a mouse click.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderClientRedirectNavigateToSecondViaClick) {
GURL prerender_url = test_server()->GetURL(
CreateClientRedirect("files/prerender/prerender_page.html"));
GURL destination_url = test_server()->GetURL(
"files/prerender/prerender_page.html");
PrerenderTestURL(prerender_url, FINAL_STATUS_USED, 2);
OpenURLViaClick(destination_url);
}
// Checks that a page served over HTTPS is correctly prerendered.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHttps) {
net::SpawnedTestServer https_server(
net::SpawnedTestServer::TYPE_HTTPS, net::SpawnedTestServer::kLocalhost,
base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
ASSERT_TRUE(https_server.Start());
GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
PrerenderTestURL(https_url,
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// Checks that client-issued redirects within an iframe in a prerendered
// page will not count as an "alias" for the prerendered page.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderClientRedirectInIframe) {
std::string redirect_path = CreateClientRedirect(
"/files/prerender/prerender_embedded_content.html");
std::vector<net::SpawnedTestServer::StringPair> replacement_text;
replacement_text.push_back(
std::make_pair("REPLACE_WITH_URL", "/" + redirect_path));
std::string replacement_path;
ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
"files/prerender/prerender_with_iframe.html",
replacement_text,
&replacement_path));
PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 2);
EXPECT_FALSE(UrlIsInPrerenderManager(
"files/prerender/prerender_embedded_content.html"));
NavigateToDestURL();
}
// Checks that server-issued redirects work with prerendering.
// This version navigates to the page which issues the redirection, rather
// than the final destination page.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderServerRedirectNavigateToFirst) {
PrerenderTestURL(CreateServerRedirect("files/prerender/prerender_page.html"),
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// Checks that server-issued redirects work with prerendering.
// This version navigates to the final destination page, rather than the
// page which does the redirection.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderServerRedirectNavigateToSecond) {
PrerenderTestURL(CreateServerRedirect("files/prerender/prerender_page.html"),
FINAL_STATUS_USED,
1);
NavigateToURL("files/prerender/prerender_page.html");
}
// Checks that server-issued redirects work with prerendering.
// This version navigates to the final destination page, rather than the
// page which does the redirection via a mouse click.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderServerRedirectNavigateToSecondViaClick) {
GURL prerender_url = test_server()->GetURL(
CreateServerRedirect("files/prerender/prerender_page.html"));
GURL destination_url = test_server()->GetURL(
"files/prerender/prerender_page.html");
PrerenderTestURL(prerender_url, FINAL_STATUS_USED, 1);
OpenURLViaClick(destination_url);
}
// Checks that server-issued redirects within an iframe in a prerendered
// page will not count as an "alias" for the prerendered page.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderServerRedirectInIframe) {
std::string redirect_path = CreateServerRedirect(
"/files/prerender/prerender_embedded_content.html");
std::vector<net::SpawnedTestServer::StringPair> replacement_text;
replacement_text.push_back(
std::make_pair("REPLACE_WITH_URL", "/" + redirect_path));
std::string replacement_path;
ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
"files/prerender/prerender_with_iframe.html",
replacement_text,
&replacement_path));
PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
EXPECT_FALSE(UrlIsInPrerenderManager(
"files/prerender/prerender_embedded_content.html"));
NavigateToDestURL();
}
// Prerenders a page that contains an automatic download triggered through an
// iframe. This should not prerender successfully.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDownloadIframe) {
PrerenderTestURL("files/prerender/prerender_download_iframe.html",
FINAL_STATUS_DOWNLOAD,
0);
}
// Prerenders a page that contains an automatic download triggered through
// Javascript changing the window.location. This should not prerender
// successfully
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDownloadLocation) {
PrerenderTestURL(CreateClientRedirect("files/download-test1.lib"),
FINAL_STATUS_DOWNLOAD,
1);
}
// Prerenders a page that contains an automatic download triggered through a
// client-issued redirect. This should not prerender successfully.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDownloadClientRedirect) {
PrerenderTestURL("files/prerender/prerender_download_refresh.html",
FINAL_STATUS_DOWNLOAD,
1);
}
// Checks that the referrer is set when prerendering.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderReferrer) {
PrerenderTestURL("files/prerender/prerender_referrer.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// Checks that the referrer is not set when prerendering and the source page is
// HTTPS.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderNoSSLReferrer) {
UseHttpsSrcServer();
PrerenderTestURL("files/prerender/prerender_no_referrer.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// Checks that the referrer is set when prerendering is cancelled.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCancelReferrer) {
scoped_ptr<TestContentBrowserClient> test_content_browser_client(
new TestContentBrowserClient);
content::ContentBrowserClient* original_browser_client =
content::SetBrowserClientForTesting(test_content_browser_client.get());
PrerenderTestURL("files/prerender/prerender_referrer.html",
FINAL_STATUS_CANCELLED,
1);
OpenDestURLViaClick();
EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
content::SetBrowserClientForTesting(original_browser_client);
}
// Checks that popups on a prerendered page cause cancellation.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPopup) {
PrerenderTestURL("files/prerender/prerender_popup.html",
FINAL_STATUS_CREATE_NEW_WINDOW,
0);
}
// Checks that registering a protocol handler causes cancellation.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderRegisterProtocolHandler) {
PrerenderTestURL("files/prerender/prerender_register_protocol_handler.html",
FINAL_STATUS_REGISTER_PROTOCOL_HANDLER,
0);
}
// Checks that renderers using excessive memory will be terminated.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderExcessiveMemory) {
ASSERT_TRUE(GetPrerenderManager());
GetPrerenderManager()->mutable_config().max_bytes = 30 * 1024 * 1024;
// The excessive memory kill may happen before or after the load event as it
// happens asynchronously with IPC calls. Even if the test does not start
// allocating until after load, the browser process might notice before the
// message gets through. This happens on XP debug bots because they're so
// slow. Instead, don't bother checking the load event count.
DisableLoadEventCheck();
PrerenderTestURL("files/prerender/prerender_excessive_memory.html",
FINAL_STATUS_MEMORY_LIMIT_EXCEEDED, 0);
}
// Checks shutdown code while a prerender is active.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderQuickQuit) {
DisableJavascriptCalls();
DisableLoadEventCheck();
PrerenderTestURL("files/prerender/prerender_page.html",
FINAL_STATUS_APP_TERMINATING,
0);
}
// Checks that we don't prerender in an infinite loop.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderInfiniteLoop) {
const char* const kHtmlFileA = "files/prerender/prerender_infinite_a.html";
const char* const kHtmlFileB = "files/prerender/prerender_infinite_b.html";
std::vector<FinalStatus> expected_final_status_queue;
expected_final_status_queue.push_back(FINAL_STATUS_USED);
expected_final_status_queue.push_back(FINAL_STATUS_APP_TERMINATING);
ScopedVector<TestPrerender> prerenders =
PrerenderTestURL(kHtmlFileA, expected_final_status_queue, 1);
ASSERT_TRUE(prerenders[0]->contents());
// Assert that the pending prerender is in there already. This relies on the
// fact that the renderer sends out the AddLinkRelPrerender IPC before sending
// the page load one.
EXPECT_EQ(2U, GetLinkPrerenderCount());
EXPECT_EQ(1U, GetRunningLinkPrerenderCount());
// Next url should be in pending list but not an active entry.
EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileB));
NavigateToDestURL();
// Make sure the PrerenderContents for the next url is now in the manager and
// not pending. This relies on pending prerenders being resolved in the same
// event loop iteration as OnPrerenderStop.
EXPECT_TRUE(UrlIsInPrerenderManager(kHtmlFileB));
EXPECT_EQ(1U, GetLinkPrerenderCount());
EXPECT_EQ(1U, GetRunningLinkPrerenderCount());
}
// Checks that we don't prerender in an infinite loop and multiple links are
// handled correctly.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderInfiniteLoopMultiple) {
const char* const kHtmlFileA =
"files/prerender/prerender_infinite_a_multiple.html";
const char* const kHtmlFileB =
"files/prerender/prerender_infinite_b_multiple.html";
const char* const kHtmlFileC =
"files/prerender/prerender_infinite_c_multiple.html";
// This test is conceptually simplest if concurrency is at two, since we
// don't have to worry about which of kHtmlFileB or kHtmlFileC gets evicted.
GetPrerenderManager()->mutable_config().max_link_concurrency = 2;
GetPrerenderManager()->mutable_config().max_link_concurrency_per_launcher = 2;
std::vector<FinalStatus> expected_final_status_queue;
expected_final_status_queue.push_back(FINAL_STATUS_USED);
expected_final_status_queue.push_back(FINAL_STATUS_APP_TERMINATING);
expected_final_status_queue.push_back(FINAL_STATUS_APP_TERMINATING);
ScopedVector<TestPrerender> prerenders =
PrerenderTestURL(kHtmlFileA, expected_final_status_queue, 1);
ASSERT_TRUE(prerenders[0]->contents());
// Next url should be in pending list but not an active entry. This relies on
// the fact that the renderer sends out the AddLinkRelPrerender IPC before
// sending the page load one.
EXPECT_EQ(3U, GetLinkPrerenderCount());
EXPECT_EQ(1U, GetRunningLinkPrerenderCount());
EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileB));
EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileC));
NavigateToDestURL();
// Make sure the PrerenderContents for the next urls are now in the manager
// and not pending. One and only one of the URLs (the last seen) should be the
// active entry. This relies on pending prerenders being resolved in the same
// event loop iteration as OnPrerenderStop.
bool url_b_is_active_prerender = UrlIsInPrerenderManager(kHtmlFileB);
bool url_c_is_active_prerender = UrlIsInPrerenderManager(kHtmlFileC);
EXPECT_TRUE(url_b_is_active_prerender && url_c_is_active_prerender);
EXPECT_EQ(2U, GetLinkPrerenderCount());
EXPECT_EQ(2U, GetRunningLinkPrerenderCount());
}
// Checks that pending prerenders are aborted (and never launched) when launched
// by a prerender that itself gets aborted.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderAbortPendingOnCancel) {
const char* const kHtmlFileA = "files/prerender/prerender_infinite_a.html";
const char* const kHtmlFileB = "files/prerender/prerender_infinite_b.html";
scoped_ptr<TestPrerender> prerender =
PrerenderTestURL(kHtmlFileA, FINAL_STATUS_CANCELLED, 1);
ASSERT_TRUE(prerender->contents());
// Assert that the pending prerender is in there already. This relies on the
// fact that the renderer sends out the AddLinkRelPrerender IPC before sending
// the page load one.
EXPECT_EQ(2U, GetLinkPrerenderCount());
EXPECT_EQ(1U, GetRunningLinkPrerenderCount());
// Next url should be in pending list but not an active entry.
EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileB));
// Cancel the prerender.
GetPrerenderManager()->CancelAllPrerenders();
prerender->WaitForStop();
// All prerenders are now gone.
EXPECT_TRUE(IsEmptyPrerenderLinkManager());
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, OpenTaskManagerBeforePrerender) {
const base::string16 any_prerender = MatchTaskManagerPrerender("*");
const base::string16 any_tab = MatchTaskManagerTab("*");
const base::string16 original = MatchTaskManagerTab("Preloader");
const base::string16 prerender = MatchTaskManagerPrerender("Prerender Page");
const base::string16 final = MatchTaskManagerTab("Prerender Page");
// Show the task manager. This populates the model.
chrome::OpenTaskManager(current_browser());
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_tab));
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, any_prerender));
// Prerender a page in addition to the original tab.
PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
// A TaskManager entry should appear like "Prerender: Prerender Page"
// alongside the original tab entry. There should be just these two entries.
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, prerender));
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, original));
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, final));
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_prerender));
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_tab));
// Swap in the prerendered content.
NavigateToDestURL();
// The "Prerender: " TaskManager entry should disappear, being replaced by a
// "Tab: Prerender Page" entry, and nothing else.
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, prerender));
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, original));
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, final));
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_tab));
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, any_prerender));
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, OpenTaskManagerAfterPrerender) {
const base::string16 any_prerender = MatchTaskManagerPrerender("*");
const base::string16 any_tab = MatchTaskManagerTab("*");
const base::string16 original = MatchTaskManagerTab("Preloader");
const base::string16 prerender = MatchTaskManagerPrerender("Prerender Page");
const base::string16 final = MatchTaskManagerTab("Prerender Page");
// Start with two resources.
PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
// Show the task manager. This populates the model. Importantly, we're doing
// this after the prerender WebContents already exists - the task manager
// needs to find it, it can't just listen for creation.
chrome::OpenTaskManager(current_browser());
// A TaskManager entry should appear like "Prerender: Prerender Page"
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, prerender));
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, original));
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, final));
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_prerender));
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_tab));
// Swap in the tab.
NavigateToDestURL();
// The "Prerender: Prerender Page" TaskManager row should disappear, being
// replaced by "Tab: Prerender Page"
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, prerender));
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, original));
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, final));
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_tab));
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, any_prerender));
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, OpenTaskManagerAfterSwapIn) {
const base::string16 any_prerender = MatchTaskManagerPrerender("*");
const base::string16 any_tab = MatchTaskManagerTab("*");
const base::string16 final = MatchTaskManagerTab("Prerender Page");
// Prerender, and swap it in.
PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
NavigateToDestURL();
// Show the task manager. This populates the model. Importantly, we're doing
// this after the prerender has been swapped in.
chrome::OpenTaskManager(current_browser());
// We should not see a prerender resource in the task manager, just a normal
// page.
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, final));
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(1, any_tab));
ASSERT_NO_FATAL_FAILURE(WaitForTaskManagerRows(0, any_prerender));
}
// Checks that audio loads are deferred on prerendering.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5Audio) {
PrerenderTestURL("files/prerender/prerender_html5_audio.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
}
// Checks that audio loads are deferred on prerendering and played back when
// the prerender is swapped in if autoplay is set.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5AudioAutoplay) {
PrerenderTestURL("files/prerender/prerender_html5_audio_autoplay.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
}
// Checks that audio loads are deferred on prerendering and played back when
// the prerender is swapped in if js starts playing.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5AudioJsplay) {
PrerenderTestURL("files/prerender/prerender_html5_audio_jsplay.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
}
// Checks that video loads are deferred on prerendering.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5Video) {
PrerenderTestURL("files/prerender/prerender_html5_video.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
}
// Checks that video tags inserted by javascript are deferred and played
// correctly on swap in.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5VideoJs) {
PrerenderTestURL("files/prerender/prerender_html5_video_script.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
}
// Checks for correct network events by using a busy sleep the javascript.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5VideoNetwork) {
DisableJavascriptCalls();
scoped_ptr<TestPrerender> prerender =
PrerenderTestURL("files/prerender/prerender_html5_video_network.html",
FINAL_STATUS_USED,
1);
WaitForASCIITitle(prerender->contents()->prerender_contents(), kReadyTitle);
EXPECT_TRUE(DidPrerenderPass(prerender->contents()->prerender_contents()));
NavigateToDestURL();
WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
}
// Checks that scripts can retrieve the correct window size while prerendering.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderWindowSize) {
PrerenderTestURL("files/prerender/prerender_size.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// TODO(jam): http://crbug.com/350550
#if !(defined(OS_CHROMEOS) && defined(ADDRESS_SANITIZER))
// Checks that prerenderers will terminate when the RenderView crashes.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderRendererCrash) {
scoped_ptr<TestPrerender> prerender =
PrerenderTestURL("files/prerender/prerender_page.html",
FINAL_STATUS_RENDERER_CRASHED,
1);
// Navigate to about:crash and then wait for the renderer to crash.
ASSERT_TRUE(prerender->contents());
ASSERT_TRUE(prerender->contents()->prerender_contents());
prerender->contents()->prerender_contents()->GetController().
LoadURL(
GURL(content::kChromeUICrashURL),
content::Referrer(),
content::PAGE_TRANSITION_TYPED,
std::string());
prerender->WaitForStop();
}
#endif
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderPageWithFragment) {
PrerenderTestURL("files/prerender/prerender_page.html#fragment",
FINAL_STATUS_USED,
1);
ChannelDestructionWatcher channel_close_watcher;
channel_close_watcher.WatchChannel(browser()->tab_strip_model()->
GetActiveWebContents()->GetRenderProcessHost());
NavigateToDestURL();
channel_close_watcher.WaitForChannelClose();
ASSERT_TRUE(IsEmptyPrerenderLinkManager());
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderPageWithRedirectedFragment) {
PrerenderTestURL(
CreateClientRedirect("files/prerender/prerender_page.html#fragment"),
FINAL_STATUS_USED,
2);
ChannelDestructionWatcher channel_close_watcher;
channel_close_watcher.WatchChannel(browser()->tab_strip_model()->
GetActiveWebContents()->GetRenderProcessHost());
NavigateToDestURL();
channel_close_watcher.WaitForChannelClose();
ASSERT_TRUE(IsEmptyPrerenderLinkManager());
}
// Checks that we do not use a prerendered page when navigating from
// the main page to a fragment.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderPageNavigateFragment) {
PrerenderTestURL("files/prerender/no_prerender_page.html",
FINAL_STATUS_APP_TERMINATING,
1);
NavigateToURLWithDisposition(
"files/prerender/no_prerender_page.html#fragment",
CURRENT_TAB, false);
}
// Checks that we do not use a prerendered page when we prerender a fragment
// but navigate to the main page.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderFragmentNavigatePage) {
PrerenderTestURL("files/prerender/no_prerender_page.html#fragment",
FINAL_STATUS_APP_TERMINATING,
1);
NavigateToURLWithDisposition(
"files/prerender/no_prerender_page.html",
CURRENT_TAB, false);
}
// Checks that we do not use a prerendered page when we prerender a fragment
// but navigate to a different fragment on the same page.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderFragmentNavigateFragment) {
PrerenderTestURL("files/prerender/no_prerender_page.html#other_fragment",
FINAL_STATUS_APP_TERMINATING,
1);
NavigateToURLWithDisposition(
"files/prerender/no_prerender_page.html#fragment",
CURRENT_TAB, false);
}
// Checks that we do not use a prerendered page when the page uses a client
// redirect to refresh from a fragment on the same page.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderClientRedirectFromFragment) {
PrerenderTestURL(
CreateClientRedirect("files/prerender/no_prerender_page.html#fragment"),
FINAL_STATUS_APP_TERMINATING,
2);
NavigateToURLWithDisposition(
"files/prerender/no_prerender_page.html",
CURRENT_TAB, false);
}
// Checks that we do not use a prerendered page when the page uses a client
// redirect to refresh to a fragment on the same page.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderClientRedirectToFragment) {
PrerenderTestURL(
CreateClientRedirect("files/prerender/no_prerender_page.html"),
FINAL_STATUS_APP_TERMINATING,
2);
NavigateToURLWithDisposition(
"files/prerender/no_prerender_page.html#fragment",
CURRENT_TAB, false);
}
// Checks that we correctly use a prerendered page when the page uses JS to set
// the window.location.hash to a fragment on the same page.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderPageChangeFragmentLocationHash) {
PrerenderTestURL("files/prerender/prerender_fragment_location_hash.html",
FINAL_STATUS_USED,
1);
NavigateToURL("files/prerender/prerender_fragment_location_hash.html");
}
// Checks that prerendering a PNG works correctly.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderImagePng) {
DisableJavascriptCalls();
PrerenderTestURL("files/prerender/image.png", FINAL_STATUS_USED, 1);
NavigateToDestURL();
}
// Checks that prerendering a JPG works correctly.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderImageJpeg) {
DisableJavascriptCalls();
PrerenderTestURL("files/prerender/image.jpeg", FINAL_STATUS_USED, 1);
NavigateToDestURL();
}
// Checks that a prerender of a CRX will result in a cancellation due to
// download.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCrx) {
PrerenderTestURL("files/prerender/extension.crx", FINAL_STATUS_DOWNLOAD, 0);
}
// Checks that xhr GET requests allow prerenders.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrGet) {
PrerenderTestURL("files/prerender/prerender_xhr_get.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// Checks that xhr HEAD requests allow prerenders.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrHead) {
PrerenderTestURL("files/prerender/prerender_xhr_head.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// Checks that xhr OPTIONS requests allow prerenders.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrOptions) {
PrerenderTestURL("files/prerender/prerender_xhr_options.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// Checks that xhr TRACE requests allow prerenders.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrTrace) {
PrerenderTestURL("files/prerender/prerender_xhr_trace.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// Checks that xhr POST requests allow prerenders.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrPost) {
PrerenderTestURL("files/prerender/prerender_xhr_post.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// Checks that xhr PUT cancels prerenders.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrPut) {
PrerenderTestURL("files/prerender/prerender_xhr_put.html",
FINAL_STATUS_INVALID_HTTP_METHOD,
1);
}
// Checks that xhr DELETE cancels prerenders.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderXhrDelete) {
PrerenderTestURL("files/prerender/prerender_xhr_delete.html",
FINAL_STATUS_INVALID_HTTP_METHOD,
1);
}
// Checks that a top-level page which would trigger an SSL error is canceled.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLErrorTopLevel) {
net::SpawnedTestServer::SSLOptions ssl_options;
ssl_options.server_certificate =
net::SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME;
net::SpawnedTestServer https_server(
net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
ASSERT_TRUE(https_server.Start());
GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
PrerenderTestURL(https_url,
FINAL_STATUS_SSL_ERROR,
0);
}
// Checks that an SSL error that comes from a subresource does not cancel
// the page. Non-main-frame requests are simply cancelled if they run into
// an SSL problem.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLErrorSubresource) {
net::SpawnedTestServer::SSLOptions ssl_options;
ssl_options.server_certificate =
net::SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME;
net::SpawnedTestServer https_server(
net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
ASSERT_TRUE(https_server.Start());
GURL https_url = https_server.GetURL("files/prerender/image.jpeg");
std::vector<net::SpawnedTestServer::StringPair> replacement_text;
replacement_text.push_back(
std::make_pair("REPLACE_WITH_IMAGE_URL", https_url.spec()));
std::string replacement_path;
ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
"files/prerender/prerender_with_image.html",
replacement_text,
&replacement_path));
PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
NavigateToDestURL();
}
// Checks that an SSL error that comes from an iframe does not cancel
// the page. Non-main-frame requests are simply cancelled if they run into
// an SSL problem.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLErrorIframe) {
net::SpawnedTestServer::SSLOptions ssl_options;
ssl_options.server_certificate =
net::SpawnedTestServer::SSLOptions::CERT_MISMATCHED_NAME;
net::SpawnedTestServer https_server(
net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
ASSERT_TRUE(https_server.Start());
GURL https_url = https_server.GetURL(
"files/prerender/prerender_embedded_content.html");
std::vector<net::SpawnedTestServer::StringPair> replacement_text;
replacement_text.push_back(
std::make_pair("REPLACE_WITH_URL", https_url.spec()));
std::string replacement_path;
ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
"files/prerender/prerender_with_iframe.html",
replacement_text,
&replacement_path));
PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
NavigateToDestURL();
}
// Checks that we cancel correctly when window.print() is called.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPrint) {
DisableLoadEventCheck();
PrerenderTestURL("files/prerender/prerender_print.html",
FINAL_STATUS_WINDOW_PRINT,
0);
}
// Checks that if a page is opened in a new window by javascript and both the
// pages are in the same domain, the prerendered page is not used, due to
// there being other tabs in the same browsing instance.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderSameDomainWindowOpenerWindowOpen) {
PrerenderTestURL("files/prerender/prerender_page.html",
FINAL_STATUS_NON_EMPTY_BROWSING_INSTANCE,
1);
OpenDestURLViaWindowOpen();
}
// Checks that if a page is opened due to click on a href with target="_blank"
// and both pages are in the same domain the prerendered page is not used, due
// there being other tabs in the same browsing instance.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderSameDomainWindowOpenerClickTarget) {
PrerenderTestURL("files/prerender/prerender_page.html",
FINAL_STATUS_NON_EMPTY_BROWSING_INSTANCE,
1);
OpenDestURLViaClickTarget();
}
// Checks that prerenders do not get swapped into target pages that have opened
// a popup, even if the target page itself does not have an opener.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderTargetHasPopup) {
PrerenderTestURL("files/prerender/prerender_page.html",
FINAL_STATUS_NON_EMPTY_BROWSING_INSTANCE,
1);
OpenURLViaWindowOpen(GURL(url::kAboutBlankURL));
NavigateToDestURLWithDisposition(CURRENT_TAB, false);
}
class TestClientCertStore : public net::ClientCertStore {
public:
TestClientCertStore() {}
virtual ~TestClientCertStore() {}
// net::ClientCertStore:
virtual void GetClientCerts(const net::SSLCertRequestInfo& cert_request_info,
net::CertificateList* selected_certs,
const base::Closure& callback) OVERRIDE {
*selected_certs = net::CertificateList(
1, scoped_refptr<net::X509Certificate>(
new net::X509Certificate("test", "test", base::Time(), base::Time())));
callback.Run();
}
};
scoped_ptr<net::ClientCertStore> CreateCertStore() {
return scoped_ptr<net::ClientCertStore>(new TestClientCertStore);
}
// Checks that a top-level page which would normally request an SSL client
// certificate will never be seen since it's an https top-level resource.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderSSLClientCertTopLevel) {
ProfileIOData::FromResourceContext(
current_browser()->profile()->GetResourceContext())->
set_client_cert_store_factory_for_testing(
base::Bind(&CreateCertStore));
net::SpawnedTestServer::SSLOptions ssl_options;
ssl_options.request_client_certificate = true;
net::SpawnedTestServer https_server(
net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
ASSERT_TRUE(https_server.Start());
GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
PrerenderTestURL(https_url, FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED, 0);
}
// Checks that an SSL Client Certificate request that originates from a
// subresource will cancel the prerendered page.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderSSLClientCertSubresource) {
ProfileIOData::FromResourceContext(
current_browser()->profile()->GetResourceContext())->
set_client_cert_store_factory_for_testing(
base::Bind(&CreateCertStore));
net::SpawnedTestServer::SSLOptions ssl_options;
ssl_options.request_client_certificate = true;
net::SpawnedTestServer https_server(
net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
ASSERT_TRUE(https_server.Start());
GURL https_url = https_server.GetURL("files/prerender/image.jpeg");
std::vector<net::SpawnedTestServer::StringPair> replacement_text;
replacement_text.push_back(
std::make_pair("REPLACE_WITH_IMAGE_URL", https_url.spec()));
std::string replacement_path;
ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
"files/prerender/prerender_with_image.html",
replacement_text,
&replacement_path));
PrerenderTestURL(replacement_path,
FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED,
0);
}
// Checks that an SSL Client Certificate request that originates from an
// iframe will cancel the prerendered page.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSSLClientCertIframe) {
ProfileIOData::FromResourceContext(
current_browser()->profile()->GetResourceContext())->
set_client_cert_store_factory_for_testing(
base::Bind(&CreateCertStore));
net::SpawnedTestServer::SSLOptions ssl_options;
ssl_options.request_client_certificate = true;
net::SpawnedTestServer https_server(
net::SpawnedTestServer::TYPE_HTTPS, ssl_options,
base::FilePath(FILE_PATH_LITERAL("chrome/test/data")));
ASSERT_TRUE(https_server.Start());
GURL https_url = https_server.GetURL(
"files/prerender/prerender_embedded_content.html");
std::vector<net::SpawnedTestServer::StringPair> replacement_text;
replacement_text.push_back(
std::make_pair("REPLACE_WITH_URL", https_url.spec()));
std::string replacement_path;
ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
"files/prerender/prerender_with_iframe.html",
replacement_text,
&replacement_path));
PrerenderTestURL(replacement_path,
FINAL_STATUS_SSL_CLIENT_CERTIFICATE_REQUESTED,
0);
}
#if defined(FULL_SAFE_BROWSING)
// Ensures that we do not prerender pages with a safe browsing
// interstitial.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSafeBrowsingTopLevel) {
GURL url = test_server()->GetURL("files/prerender/prerender_page.html");
GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
url, SB_THREAT_TYPE_URL_MALWARE);
PrerenderTestURL("files/prerender/prerender_page.html",
FINAL_STATUS_SAFE_BROWSING, 0);
}
// Ensures that server redirects to a malware page will cancel prerenders.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderSafeBrowsingServerRedirect) {
GURL url = test_server()->GetURL("files/prerender/prerender_page.html");
GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
url, SB_THREAT_TYPE_URL_MALWARE);
PrerenderTestURL(CreateServerRedirect("files/prerender/prerender_page.html"),
FINAL_STATUS_SAFE_BROWSING,
0);
}
// Ensures that client redirects to a malware page will cancel prerenders.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderSafeBrowsingClientRedirect) {
GURL url = test_server()->GetURL("files/prerender/prerender_page.html");
GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
url, SB_THREAT_TYPE_URL_MALWARE);
PrerenderTestURL(CreateClientRedirect("files/prerender/prerender_page.html"),
FINAL_STATUS_SAFE_BROWSING,
1);
}
// Ensures that we do not prerender pages which have a malware subresource.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSafeBrowsingSubresource) {
GURL image_url = test_server()->GetURL("files/prerender/image.jpeg");
GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
image_url, SB_THREAT_TYPE_URL_MALWARE);
std::vector<net::SpawnedTestServer::StringPair> replacement_text;
replacement_text.push_back(
std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
std::string replacement_path;
ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
"files/prerender/prerender_with_image.html",
replacement_text,
&replacement_path));
PrerenderTestURL(replacement_path,
FINAL_STATUS_SAFE_BROWSING,
0);
}
// Ensures that we do not prerender pages which have a malware iframe.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSafeBrowsingIframe) {
GURL iframe_url = test_server()->GetURL(
"files/prerender/prerender_embedded_content.html");
GetFakeSafeBrowsingDatabaseManager()->SetThreatTypeForUrl(
iframe_url, SB_THREAT_TYPE_URL_MALWARE);
std::vector<net::SpawnedTestServer::StringPair> replacement_text;
replacement_text.push_back(
std::make_pair("REPLACE_WITH_URL", iframe_url.spec()));
std::string replacement_path;
ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
"files/prerender/prerender_with_iframe.html",
replacement_text,
&replacement_path));
PrerenderTestURL(replacement_path,
FINAL_STATUS_SAFE_BROWSING,
0);
}
#endif
// Checks that a local storage read will not cause prerender to fail.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderLocalStorageRead) {
PrerenderTestURL("files/prerender/prerender_localstorage_read.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// Checks that a local storage write will not cause prerender to fail.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderLocalStorageWrite) {
PrerenderTestURL("files/prerender/prerender_localstorage_write.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// Checks that the favicon is properly loaded on prerender.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderFavicon) {
scoped_ptr<TestPrerender> prerender =
PrerenderTestURL("files/prerender/prerender_favicon.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
if (!FaviconTabHelper::FromWebContents(
GetActiveWebContents())->FaviconIsValid()) {
// If the favicon has not been set yet, wait for it to be.
content::WindowedNotificationObserver favicon_update_watcher(
chrome::NOTIFICATION_FAVICON_UPDATED,
content::Source<WebContents>(GetActiveWebContents()));
favicon_update_watcher.Wait();
}
EXPECT_TRUE(FaviconTabHelper::FromWebContents(
GetActiveWebContents())->FaviconIsValid());
}
// Checks that when a prerendered page is swapped in to a referring page, the
// unload handlers on the referring page are executed.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderUnload) {
// Matches URL in prerender_loader_with_unload.html.
const GURL unload_url("http://unload-url.test");
base::FilePath empty_file = ui_test_utils::GetTestFilePath(
base::FilePath(), base::FilePath(FILE_PATH_LITERAL("empty.html")));
RequestCounter unload_counter;
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&CreateCountingInterceptorOnIO,
unload_url, empty_file, unload_counter.AsWeakPtr()));
set_loader_path("files/prerender/prerender_loader_with_unload.html");
PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
NavigateToDestURL();
unload_counter.WaitForCount(1);
}
// Checks that a hanging unload on the referring page of a prerender swap does
// not crash the browser on exit.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHangingUnload) {
// Matches URL in prerender_loader_with_unload.html.
const GURL hang_url("http://unload-url.test");
base::FilePath empty_file = ui_test_utils::GetTestFilePath(
base::FilePath(), base::FilePath(FILE_PATH_LITERAL("empty.html")));
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&CreateHangingFirstRequestInterceptorOnIO,
hang_url, empty_file,
base::Closure()));
set_loader_path("files/prerender/prerender_loader_with_unload.html");
PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
NavigateToDestURL();
}
// Checks that when the history is cleared, prerendering is cancelled and
// prerendering history is cleared.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClearHistory) {
scoped_ptr<TestPrerender> prerender =
PrerenderTestURL("files/prerender/prerender_page.html",
FINAL_STATUS_CACHE_OR_HISTORY_CLEARED,
1);
ClearBrowsingData(current_browser(), BrowsingDataRemover::REMOVE_HISTORY);
prerender->WaitForStop();
// Make sure prerender history was cleared.
EXPECT_EQ(0, GetHistoryLength());
}
// Checks that when the cache is cleared, prerenders are cancelled but
// prerendering history is not cleared.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClearCache) {
scoped_ptr<TestPrerender> prerender =
PrerenderTestURL("files/prerender/prerender_page.html",
FINAL_STATUS_CACHE_OR_HISTORY_CLEARED,
1);
ClearBrowsingData(current_browser(), BrowsingDataRemover::REMOVE_CACHE);
prerender->WaitForStop();
// Make sure prerender history was not cleared. Not a vital behavior, but
// used to compare with PrerenderClearHistory test.
EXPECT_EQ(1, GetHistoryLength());
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCancelAll) {
scoped_ptr<TestPrerender> prerender =
PrerenderTestURL("files/prerender/prerender_page.html",
FINAL_STATUS_CANCELLED,
1);
GetPrerenderManager()->CancelAllPrerenders();
prerender->WaitForStop();
EXPECT_FALSE(prerender->contents());
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderEvents) {
scoped_ptr<TestPrerender> prerender =
PrerenderTestURL("files/prerender/prerender_page.html",
FINAL_STATUS_CANCELLED, 1);
GetPrerenderManager()->CancelAllPrerenders();
prerender->WaitForStop();
EXPECT_TRUE(DidReceivePrerenderStartEventForLinkNumber(0));
EXPECT_TRUE(DidReceivePrerenderStopEventForLinkNumber(0));
EXPECT_FALSE(HadPrerenderEventErrors());
}
// Cancels the prerender of a page with its own prerender. The second prerender
// should never be started.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderCancelPrerenderWithPrerender) {
scoped_ptr<TestPrerender> prerender =
PrerenderTestURL("files/prerender/prerender_infinite_a.html",
FINAL_STATUS_CANCELLED,
1);
GetPrerenderManager()->CancelAllPrerenders();
prerender->WaitForStop();
EXPECT_FALSE(prerender->contents());
}
// Prerendering and history tests.
// The prerendered page is navigated to in several ways [navigate via
// omnibox, click on link, key-modified click to open in background tab, etc],
// followed by a navigation to another page from the prerendered page, followed
// by a back navigation.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNavigateClickGoBack) {
PrerenderTestURL("files/prerender/prerender_page_with_link.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
ClickToNextPageAfterPrerender();
GoBackToPrerender();
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNavigateNavigateGoBack) {
PrerenderTestURL("files/prerender/prerender_page_with_link.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
NavigateToNextPageAfterPrerender();
GoBackToPrerender();
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickClickGoBack) {
PrerenderTestURL("files/prerender/prerender_page_with_link.html",
FINAL_STATUS_USED,
1);
OpenDestURLViaClick();
ClickToNextPageAfterPrerender();
GoBackToPrerender();
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickNavigateGoBack) {
PrerenderTestURL("files/prerender/prerender_page_with_link.html",
FINAL_STATUS_USED,
1);
OpenDestURLViaClick();
NavigateToNextPageAfterPrerender();
GoBackToPrerender();
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickNewWindow) {
// Prerender currently doesn't interpose on this navigation.
// http://crbug.com/345474.
PrerenderTestURL("files/prerender/prerender_page_with_link.html",
FINAL_STATUS_USED,
1);
OpenDestURLViaClickNewWindow();
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickNewForegroundTab) {
// Prerender currently doesn't interpose on this navigation.
// http://crbug.com/345474.
PrerenderTestURL("files/prerender/prerender_page_with_link.html",
FINAL_STATUS_USED,
1);
OpenDestURLViaClickNewForegroundTab();
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClickNewBackgroundTab) {
// Prerender currently doesn't interpose on this navigation.
// http://crbug.com/345474.
scoped_ptr<TestPrerender> prerender =
PrerenderTestURL("files/prerender/prerender_page_with_link.html",
FINAL_STATUS_USED,
1);
ASSERT_TRUE(prerender->contents());
prerender->contents()->set_should_be_shown(false);
OpenDestURLViaClickNewBackgroundTab();
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
NavigateToPrerenderedPageWhenDevToolsAttached) {
DisableJavascriptCalls();
WebContents* web_contents =
current_browser()->tab_strip_model()->GetActiveWebContents();
scoped_refptr<DevToolsAgentHost> agent(DevToolsAgentHost::GetOrCreateFor(
web_contents->GetRenderViewHost()));
DevToolsManager* manager = DevToolsManager::GetInstance();
FakeDevToolsClientHost client_host;
manager->RegisterDevToolsClientHostFor(agent.get(), &client_host);
const char* url = "files/prerender/prerender_page.html";
PrerenderTestURL(url, FINAL_STATUS_DEVTOOLS_ATTACHED, 1);
NavigateToURLWithDisposition(url, CURRENT_TAB, false);
manager->ClientHostClosing(&client_host);
}
// Validate that the sessionStorage namespace remains the same when swapping
// in a prerendered page.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSessionStorage) {
set_loader_path("files/prerender/prerender_loader_with_session_storage.html");
PrerenderTestURL(GetCrossDomainTestUrl("files/prerender/prerender_page.html"),
FINAL_STATUS_USED,
1);
NavigateToDestURL();
GoBackToPageBeforePrerender();
}
// Checks that the control group works. An XHR PUT cannot be detected in the
// control group.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, ControlGroup) {
RestorePrerenderMode restore_prerender_mode;
PrerenderManager::SetMode(
PrerenderManager::PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP);
DisableJavascriptCalls();
PrerenderTestURL("files/prerender/prerender_xhr_put.html",
FINAL_STATUS_WOULD_HAVE_BEEN_USED, 0);
NavigateToDestURL();
}
// Checks that the control group correctly hits WOULD_HAVE_BEEN_USED
// renderer-initiated navigations. (This verifies that the ShouldFork logic
// behaves correctly.)
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, ControlGroupRendererInitiated) {
RestorePrerenderMode restore_prerender_mode;
PrerenderManager::SetMode(
PrerenderManager::PRERENDER_MODE_EXPERIMENT_CONTROL_GROUP);
DisableJavascriptCalls();
PrerenderTestURL("files/prerender/prerender_xhr_put.html",
FINAL_STATUS_WOULD_HAVE_BEEN_USED, 0);
OpenDestURLViaClick();
}
// Make sure that the MatchComplete dummy works in the normal case. Once
// a prerender is cancelled because of a script, a dummy must be created to
// account for the MatchComplete case, and it must have a final status of
// FINAL_STATUS_WOULD_HAVE_BEEN_USED.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, MatchCompleteDummy) {
UMAHistogramHelper histograms;
std::vector<FinalStatus> expected_final_status_queue;
expected_final_status_queue.push_back(FINAL_STATUS_INVALID_HTTP_METHOD);
expected_final_status_queue.push_back(FINAL_STATUS_WOULD_HAVE_BEEN_USED);
PrerenderTestURL("files/prerender/prerender_xhr_put.html",
expected_final_status_queue, 1);
histograms.Fetch();
histograms.ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatchedComplete", 0);
histograms.ExpectTotalCount("Prerender.websame_PrerenderNotSwappedInPLT", 1);
NavigateToDestURL();
histograms.Fetch();
histograms.ExpectTotalCount("Prerender.websame_PerceivedPLT", 1);
histograms.ExpectTotalCount("Prerender.websame_PerceivedPLTMatched", 0);
histograms.ExpectTotalCount(
"Prerender.websame_PerceivedPLTMatchedComplete", 1);
}
// Verify that a navigation that hits a MatchComplete dummy while another is in
// progress does not also classify the previous navigation as a MatchComplete.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
MatchCompleteDummyCancelNavigation) {
UMAHistogramHelper histograms;
// Arrange for a URL to hang.
const GURL kNoCommitUrl("http://never-respond.example.com");
base::FilePath file(FILE_PATH_LITERAL(
"chrome/test/data/prerender/prerender_page.html"));
base::RunLoop hang_loop;
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&CreateHangingFirstRequestInterceptorOnIO, kNoCommitUrl,
file, hang_loop.QuitClosure()));
// First, fire a prerender that aborts after it completes its load.
std::vector<FinalStatus> expected_final_status_queue;
expected_final_status_queue.push_back(FINAL_STATUS_INVALID_HTTP_METHOD);
expected_final_status_queue.push_back(FINAL_STATUS_WOULD_HAVE_BEEN_USED);
PrerenderTestURL("files/prerender/prerender_xhr_put.html",
expected_final_status_queue, 1);
histograms.Fetch();
histograms.ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatchedComplete", 0);
histograms.ExpectTotalCount("Prerender.websame_PrerenderNotSwappedInPLT", 1);
// Open the hanging URL in a new tab. Wait for both the new tab to open and
// the hanging request to be scheduled.
ui_test_utils::NavigateToURLWithDisposition(
current_browser(), kNoCommitUrl, NEW_FOREGROUND_TAB,
ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB);
hang_loop.Run();
// Now interrupt that navigation and navigate to the destination URL. This
// should forcibly complete the previous navigation and also complete a
// WOULD_HAVE_BEEN_PRERENDERED navigation.
NavigateToDestURL();
histograms.Fetch();
histograms.ExpectTotalCount("Prerender.none_PerceivedPLT", 2);
histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatchedComplete", 0);
histograms.ExpectTotalCount("Prerender.websame_PerceivedPLT", 1);
histograms.ExpectTotalCount("Prerender.websame_PerceivedPLTMatched", 0);
histograms.ExpectTotalCount(
"Prerender.websame_PerceivedPLTMatchedComplete", 1);
}
class PrerenderBrowserTestWithNaCl : public PrerenderBrowserTest {
public:
PrerenderBrowserTestWithNaCl() {}
virtual ~PrerenderBrowserTestWithNaCl() {}
virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
PrerenderBrowserTest::SetUpCommandLine(command_line);
command_line->AppendSwitch(switches::kEnableNaCl);
}
};
// Check that NaCl plugins work when enabled, with prerendering.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTestWithNaCl,
PrerenderNaClPluginEnabled) {
#if defined(OS_WIN) && defined(USE_ASH)
// Disable this test in Metro+Ash for now (http://crbug.com/262796).
if (CommandLine::ForCurrentProcess()->HasSwitch(switches::kAshBrowserTests))
return;
#endif
PrerenderTestURL("files/prerender/prerender_plugin_nacl_enabled.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
// To avoid any chance of a race, we have to let the script send its response
// asynchronously.
WebContents* web_contents =
browser()->tab_strip_model()->GetActiveWebContents();
bool display_test_result = false;
ASSERT_TRUE(content::ExecuteScriptAndExtractBool(web_contents,
"DidDisplayReallyPass()",
&display_test_result));
ASSERT_TRUE(display_test_result);
}
// Checks that the referrer policy is used when prerendering.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderReferrerPolicy) {
set_loader_path("files/prerender/prerender_loader_with_referrer_policy.html");
PrerenderTestURL("files/prerender/prerender_referrer_policy.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// Checks that the referrer policy is used when prerendering on HTTPS.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderSSLReferrerPolicy) {
UseHttpsSrcServer();
set_loader_path("files/prerender/prerender_loader_with_referrer_policy.html");
PrerenderTestURL("files/prerender/prerender_referrer_policy.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// Checks that the referrer policy is used when prerendering is cancelled.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCancelReferrerPolicy) {
scoped_ptr<TestContentBrowserClient> test_content_browser_client(
new TestContentBrowserClient);
content::ContentBrowserClient* original_browser_client =
content::SetBrowserClientForTesting(test_content_browser_client.get());
set_loader_path("files/prerender/prerender_loader_with_referrer_policy.html");
PrerenderTestURL("files/prerender/prerender_referrer_policy.html",
FINAL_STATUS_CANCELLED,
1);
OpenDestURLViaClick();
bool display_test_result = false;
WebContents* web_contents =
browser()->tab_strip_model()->GetActiveWebContents();
ASSERT_TRUE(content::ExecuteScriptAndExtractBool(
web_contents,
"window.domAutomationController.send(DidDisplayPass())",
&display_test_result));
EXPECT_TRUE(display_test_result);
content::SetBrowserClientForTesting(original_browser_client);
}
// Test interaction of the webNavigation and tabs API with prerender.
class PrerenderBrowserTestWithExtensions : public PrerenderBrowserTest,
public ExtensionApiTest {
public:
PrerenderBrowserTestWithExtensions() {
// The individual tests start the test server through ExtensionApiTest, so
// the port number can be passed through to the extension.
autostart_test_server_ = false;
}
virtual void SetUp() OVERRIDE {
PrerenderBrowserTest::SetUp();
}
virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE {
PrerenderBrowserTest::SetUpCommandLine(command_line);
ExtensionApiTest::SetUpCommandLine(command_line);
}
virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
PrerenderBrowserTest::SetUpInProcessBrowserTestFixture();
ExtensionApiTest::SetUpInProcessBrowserTestFixture();
}
virtual void TearDownInProcessBrowserTestFixture() OVERRIDE {
PrerenderBrowserTest::TearDownInProcessBrowserTestFixture();
ExtensionApiTest::TearDownInProcessBrowserTestFixture();
}
virtual void SetUpOnMainThread() OVERRIDE {
PrerenderBrowserTest::SetUpOnMainThread();
}
};
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTestWithExtensions, WebNavigation) {
ASSERT_TRUE(StartSpawnedTestServer());
extensions::FrameNavigationState::set_allow_extension_scheme(true);
// Wait for the extension to set itself up and return control to us.
ASSERT_TRUE(RunExtensionTest("webnavigation/prerender")) << message_;
ResultCatcher catcher;
PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
ChannelDestructionWatcher channel_close_watcher;
channel_close_watcher.WatchChannel(browser()->tab_strip_model()->
GetActiveWebContents()->GetRenderProcessHost());
NavigateToDestURL();
channel_close_watcher.WaitForChannelClose();
ASSERT_TRUE(IsEmptyPrerenderLinkManager());
ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTestWithExtensions, TabsApi) {
ASSERT_TRUE(StartSpawnedTestServer());
extensions::FrameNavigationState::set_allow_extension_scheme(true);
// Wait for the extension to set itself up and return control to us.
ASSERT_TRUE(RunExtensionTest("tabs/on_replaced")) << message_;
ResultCatcher catcher;
PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
ChannelDestructionWatcher channel_close_watcher;
channel_close_watcher.WatchChannel(browser()->tab_strip_model()->
GetActiveWebContents()->GetRenderProcessHost());
NavigateToDestURL();
channel_close_watcher.WaitForChannelClose();
ASSERT_TRUE(IsEmptyPrerenderLinkManager());
ASSERT_TRUE(catcher.GetNextResult()) << catcher.message();
}
// Test that prerenders abort when navigating to a stream.
// See chrome/browser/extensions/api/streams_private/streams_private_apitest.cc
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTestWithExtensions, StreamsTest) {
ASSERT_TRUE(StartSpawnedTestServer());
const extensions::Extension* extension = LoadExtension(
test_data_dir_.AppendASCII("streams_private/handle_mime_type"));
ASSERT_TRUE(extension);
EXPECT_EQ(std::string(extension_misc::kStreamsPrivateTestExtensionId),
extension->id());
MimeTypesHandler* handler = MimeTypesHandler::GetHandler(extension);
ASSERT_TRUE(handler);
EXPECT_TRUE(handler->CanHandleMIMEType("application/msword"));
PrerenderTestURL("files/prerender/document.doc", FINAL_STATUS_DOWNLOAD, 0);
// Sanity-check that the extension would have picked up the stream in a normal
// navigation had prerender not intercepted it.
// streams_private/handle_mime_type reports success if it has handled the
// application/msword type.
ResultCatcher catcher;
NavigateToDestURL();
EXPECT_TRUE(catcher.GetNextResult());
}
// Checks that non-http/https/chrome-extension subresource cancels the
// prerender.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderCancelSubresourceUnsupportedScheme) {
GURL image_url = GURL("invalidscheme://www.google.com/test.jpg");
std::vector<net::SpawnedTestServer::StringPair> replacement_text;
replacement_text.push_back(
std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
std::string replacement_path;
ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
"files/prerender/prerender_with_image.html",
replacement_text,
&replacement_path));
PrerenderTestURL(replacement_path, FINAL_STATUS_UNSUPPORTED_SCHEME, 0);
}
// Ensure that about:blank is permitted for any subresource.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderAllowAboutBlankSubresource) {
GURL image_url = GURL("about:blank");
std::vector<net::SpawnedTestServer::StringPair> replacement_text;
replacement_text.push_back(
std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
std::string replacement_path;
ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
"files/prerender/prerender_with_image.html",
replacement_text,
&replacement_path));
PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
NavigateToDestURL();
}
// Checks that non-http/https/chrome-extension subresource cancels the prerender
// on redirect.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderCancelSubresourceRedirectUnsupportedScheme) {
GURL image_url = test_server()->GetURL(
CreateServerRedirect("invalidscheme://www.google.com/test.jpg"));
std::vector<net::SpawnedTestServer::StringPair> replacement_text;
replacement_text.push_back(
std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
std::string replacement_path;
ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
"files/prerender/prerender_with_image.html",
replacement_text,
&replacement_path));
PrerenderTestURL(replacement_path, FINAL_STATUS_UNSUPPORTED_SCHEME, 0);
}
// Checks that chrome-extension subresource does not cancel the prerender.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderKeepSubresourceExtensionScheme) {
GURL image_url = GURL("chrome-extension://abcdefg/test.jpg");
std::vector<net::SpawnedTestServer::StringPair> replacement_text;
replacement_text.push_back(
std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
std::string replacement_path;
ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
"files/prerender/prerender_with_image.html",
replacement_text,
&replacement_path));
PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
NavigateToDestURL();
}
// Checks that redirect to chrome-extension subresource does not cancel the
// prerender.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderKeepSubresourceRedirectExtensionScheme) {
GURL image_url = test_server()->GetURL(
CreateServerRedirect("chrome-extension://abcdefg/test.jpg"));
std::vector<net::SpawnedTestServer::StringPair> replacement_text;
replacement_text.push_back(
std::make_pair("REPLACE_WITH_IMAGE_URL", image_url.spec()));
std::string replacement_path;
ASSERT_TRUE(net::SpawnedTestServer::GetFilePathWithReplacements(
"files/prerender/prerender_with_image.html",
replacement_text,
&replacement_path));
PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
NavigateToDestURL();
}
// Checks that non-http/https main page redirects cancel the prerender.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderCancelMainFrameRedirectUnsupportedScheme) {
GURL url = test_server()->GetURL(
CreateServerRedirect("invalidscheme://www.google.com/test.html"));
PrerenderTestURL(url, FINAL_STATUS_UNSUPPORTED_SCHEME, 0);
}
// Checks that media source video loads are deferred on prerendering.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5MediaSourceVideo) {
PrerenderTestURL("files/prerender/prerender_html5_video_media_source.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
WaitForASCIITitle(GetActiveWebContents(), kPassTitle);
}
// Checks that a prerender that creates an audio stream (via a WebAudioDevice)
// is cancelled.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderWebAudioDevice) {
DisableLoadEventCheck();
PrerenderTestURL("files/prerender/prerender_web_audio_device.html",
FINAL_STATUS_CREATING_AUDIO_STREAM, 0);
}
// Checks that prerenders do not swap in to WebContents being captured.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCapturedWebContents) {
PrerenderTestURL("files/prerender/prerender_page.html",
FINAL_STATUS_PAGE_BEING_CAPTURED, 1);
WebContents* web_contents = GetActiveWebContents();
web_contents->IncrementCapturerCount(gfx::Size());
NavigateToDestURLWithDisposition(CURRENT_TAB, false);
web_contents->DecrementCapturerCount();
}
// Checks that prerenders are aborted on cross-process navigation from
// a server redirect.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderCrossProcessServerRedirect) {
// Force everything to be a process swap.
SwapProcessesContentBrowserClient test_browser_client;
content::ContentBrowserClient* original_browser_client =
content::SetBrowserClientForTesting(&test_browser_client);
PrerenderTestURL(
CreateServerRedirect("files/prerender/prerender_page.html"),
FINAL_STATUS_OPEN_URL, 0);
content::SetBrowserClientForTesting(original_browser_client);
}
// Checks that URLRequests for prerenders being aborted on cross-process
// navigation from a server redirect are cleaned up, so they don't keep cache
// entries locked.
// See http://crbug.com/341134
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderCrossProcessServerRedirectNoHang) {
const char kDestPath[] = "files/prerender/prerender_page.html";
// Force everything to be a process swap.
SwapProcessesContentBrowserClient test_browser_client;
content::ContentBrowserClient* original_browser_client =
content::SetBrowserClientForTesting(&test_browser_client);
PrerenderTestURL(CreateServerRedirect(kDestPath), FINAL_STATUS_OPEN_URL, 0);
ui_test_utils::NavigateToURL(
browser(),
test_server()->GetURL(kDestPath));
content::SetBrowserClientForTesting(original_browser_client);
}
// Checks that prerenders are aborted on cross-process navigation from
// a client redirect.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderCrossProcessClientRedirect) {
// Cross-process navigation logic for renderer-initiated navigations
// is partially controlled by the renderer, namely
// ChromeContentRendererClient. This test instead relies on the Web
// Store triggering such navigations.
std::string webstore_url = extension_urls::GetWebstoreLaunchURL();
// Mock out requests to the Web Store.
base::FilePath file(GetTestPath("prerender_page.html"));
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&CreateMockInterceptorOnIO, GURL(webstore_url), file));
PrerenderTestURL(CreateClientRedirect(webstore_url),
FINAL_STATUS_OPEN_URL, 1);
}
// Checks that canceling a MatchComplete dummy doesn't result in two
// stop events.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, CancelMatchCompleteDummy) {
std::vector<FinalStatus> expected_final_status_queue;
expected_final_status_queue.push_back(FINAL_STATUS_JAVASCRIPT_ALERT);
expected_final_status_queue.push_back(FINAL_STATUS_CANCELLED);
ScopedVector<TestPrerender> prerenders =
PrerenderTestURL("files/prerender/prerender_alert_before_onload.html",
expected_final_status_queue, 0);
// Cancel the MatchComplete dummy.
GetPrerenderManager()->CancelAllPrerenders();
prerenders[1]->WaitForStop();
// Check the referring page only got one copy of the event.
EXPECT_FALSE(HadPrerenderEventErrors());
}
// Checks that a deferred redirect to an image is not loaded until the page is
// visible. Also test the right histogram events are emitted in this case.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDeferredImage) {
DisableJavascriptCalls();
UMAHistogramHelper histograms;
// The prerender will not completely load until after the swap, so wait for a
// title change before calling DidPrerenderPass.
scoped_ptr<TestPrerender> prerender =
PrerenderTestURL(
"files/prerender/prerender_deferred_image.html",
FINAL_STATUS_USED, 0);
WaitForASCIITitle(prerender->contents()->prerender_contents(), kReadyTitle);
EXPECT_EQ(1, GetPrerenderDomContentLoadedEventCountForLinkNumber(0));
EXPECT_TRUE(DidPrerenderPass(prerender->contents()->prerender_contents()));
EXPECT_EQ(0, prerender->number_of_loads());
histograms.Fetch();
histograms.ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatchedComplete", 0);
histograms.ExpectTotalCount("Prerender.websame_PrerenderNotSwappedInPLT", 0);
// Swap.
NavigationOrSwapObserver swap_observer(current_browser()->tab_strip_model(),
GetActiveWebContents());
ui_test_utils::NavigateToURLWithDisposition(
current_browser(), dest_url(), CURRENT_TAB,
ui_test_utils::BROWSER_TEST_NONE);
swap_observer.Wait();
// The prerender never observes the final load.
EXPECT_EQ(0, prerender->number_of_loads());
// Now check DidDisplayPass.
EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
histograms.Fetch();
histograms.ExpectTotalCount("Prerender.websame_PrerenderNotSwappedInPLT", 0);
histograms.ExpectTotalCount("Prerender.websame_PerceivedPLT", 1);
histograms.ExpectTotalCount("Prerender.websame_PerceivedPLTMatched", 1);
histograms.ExpectTotalCount(
"Prerender.websame_PerceivedPLTMatchedComplete", 1);
}
// Checks that a deferred redirect to an image is not loaded until the
// page is visible, even after another redirect.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderDeferredImageAfterRedirect) {
DisableJavascriptCalls();
// The prerender will not completely load until after the swap, so wait for a
// title change before calling DidPrerenderPass.
scoped_ptr<TestPrerender> prerender =
PrerenderTestURL(
"files/prerender/prerender_deferred_image.html",
FINAL_STATUS_USED, 0);
WaitForASCIITitle(prerender->contents()->prerender_contents(), kReadyTitle);
EXPECT_TRUE(DidPrerenderPass(prerender->contents()->prerender_contents()));
EXPECT_EQ(0, prerender->number_of_loads());
// Swap.
NavigationOrSwapObserver swap_observer(current_browser()->tab_strip_model(),
GetActiveWebContents());
ui_test_utils::NavigateToURLWithDisposition(
current_browser(), dest_url(), CURRENT_TAB,
ui_test_utils::BROWSER_TEST_NONE);
swap_observer.Wait();
// The prerender never observes the final load.
EXPECT_EQ(0, prerender->number_of_loads());
// Now check DidDisplayPass.
EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
}
// Checks that deferred redirects in the main frame are followed.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDeferredMainFrame) {
DisableJavascriptCalls();
PrerenderTestURL(
"files/prerender/image-deferred.png",
FINAL_STATUS_USED, 1);
NavigateToDestURL();
}
// Checks that deferred redirects in the main frame are followed, even
// with a double-redirect.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderDeferredMainFrameAfterRedirect) {
DisableJavascriptCalls();
PrerenderTestURL(
CreateServerRedirect("files/prerender/image-deferred.png"),
FINAL_STATUS_USED, 1);
NavigateToDestURL();
}
// Checks that deferred redirects in a synchronous XHR abort the
// prerender.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDeferredSynchronousXHR) {
PrerenderTestURL("files/prerender/prerender_deferred_sync_xhr.html",
FINAL_STATUS_BAD_DEFERRED_REDIRECT, 0);
NavigateToDestURL();
}
// Checks that prerenders are not swapped for navigations with extra headers.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderExtraHeadersNoSwap) {
PrerenderTestURL("files/prerender/prerender_page.html",
FINAL_STATUS_APP_TERMINATING, 1);
content::OpenURLParams params(dest_url(), Referrer(), CURRENT_TAB,
content::PAGE_TRANSITION_TYPED, false);
params.extra_headers = "X-Custom-Header: 42\r\n";
NavigateToURLWithParams(params, false);
}
// Checks that prerenders are not swapped for navigations with browser-initiated
// POST data.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderBrowserInitiatedPostNoSwap) {
PrerenderTestURL("files/prerender/prerender_page.html",
FINAL_STATUS_APP_TERMINATING, 1);
std::string post_data = "DATA";
content::OpenURLParams params(dest_url(), Referrer(), CURRENT_TAB,
content::PAGE_TRANSITION_TYPED, false);
params.uses_post = true;
params.browser_initiated_post_data =
base::RefCountedString::TakeString(&post_data);
NavigateToURLWithParams(params, false);
}
// Checks that the prerendering of a page is canceled correctly when the
// prerendered page tries to make a second navigation entry.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderNewNavigationEntry) {
PrerenderTestURL("files/prerender/prerender_new_entry.html",
FINAL_STATUS_NEW_NAVIGATION_ENTRY,
1);
}
// Attempt a swap-in in a new tab, verifying that session storage namespace
// merging works.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageNewTab) {
// Mock out some URLs and count the number of requests to one of them. Both
// prerender_session_storage.html and init_session_storage.html need to be
// mocked so they are same-origin.
const GURL kInitURL("http://prerender.test/init_session_storage.html");
base::FilePath init_file = GetTestPath("init_session_storage.html");
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&CreateMockInterceptorOnIO, kInitURL, init_file));
const GURL kTestURL("http://prerender.test/prerender_session_storage.html");
base::FilePath test_file = GetTestPath("prerender_session_storage.html");
RequestCounter counter;
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&CreateCountingInterceptorOnIO,
kTestURL, test_file, counter.AsWeakPtr()));
PrerenderTestURL(kTestURL, FINAL_STATUS_USED, 1);
// Open a new tab to navigate in.
ui_test_utils::NavigateToURLWithDisposition(
current_browser(), kInitURL, NEW_FOREGROUND_TAB,
ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
// Now navigate in the new tab. Set expect_swap_to_succeed to false because
// the swap does not occur synchronously.
//
// TODO(davidben): When all swaps become asynchronous, remove the OpenURL
// return value assertion and let this go through the usual successful-swap
// codepath.
NavigateToDestURLWithDisposition(CURRENT_TAB, false);
// Verify DidDisplayPass manually since the previous call skipped it.
EXPECT_TRUE(DidDisplayPass(
current_browser()->tab_strip_model()->GetActiveWebContents()));
// Only one request to the test URL started.
//
// TODO(davidben): Re-enable this check when the races in attaching the
// throttle are resolved. http://crbug.com/335835
// EXPECT_EQ(1, counter.count());
}
// Attempt a swap-in in a new tab, verifying that session storage namespace
// merging works. Unlike the above test, the swap is for a navigation that would
// normally be cross-process.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPageNewTabCrossProcess) {
base::FilePath test_data_dir;
ASSERT_TRUE(PathService::Get(chrome::DIR_TEST_DATA, &test_data_dir));
// Mock out some URLs and count the number of requests to one of them. Both
// prerender_session_storage.html and init_session_storage.html need to be
// mocked so they are same-origin.
const GURL kInitURL("http://prerender.test/init_session_storage.html");
base::FilePath init_file = GetTestPath("init_session_storage.html");
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&CreateMockInterceptorOnIO, kInitURL, init_file));
const GURL kTestURL("http://prerender.test/prerender_session_storage.html");
base::FilePath test_file = GetTestPath("prerender_session_storage.html");
RequestCounter counter;
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&CreateCountingInterceptorOnIO,
kTestURL, test_file, counter.AsWeakPtr()));
PrerenderTestURL(kTestURL, FINAL_STATUS_USED, 1);
// Open a new tab to navigate in.
ui_test_utils::NavigateToURLWithDisposition(
current_browser(), kInitURL, NEW_FOREGROUND_TAB,
ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
// Navigate to about:blank so the next navigation is cross-process.
ui_test_utils::NavigateToURL(current_browser(), GURL(url::kAboutBlankURL));
// Now navigate in the new tab. Set expect_swap_to_succeed to false because
// the swap does not occur synchronously.
//
// TODO(davidben): When all swaps become asynchronous, remove the OpenURL
// return value assertion and let this go through the usual successful-swap
// codepath.
NavigateToDestURLWithDisposition(CURRENT_TAB, false);
// Verify DidDisplayPass manually since the previous call skipped it.
EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
// Only one request to the test URL started.
//
// TODO(davidben): Re-enable this check when the races in attaching the
// throttle are resolved. http://crbug.com/335835
// EXPECT_EQ(1, counter.count());
}
// Verify that session storage conflicts don't merge.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderSessionStorageConflict) {
PrerenderTestURL("files/prerender/prerender_session_storage_conflict.html",
FINAL_STATUS_APP_TERMINATING, 1);
// Open a new tab to navigate in.
ui_test_utils::NavigateToURLWithDisposition(
current_browser(),
test_server()->GetURL("files/prerender/init_session_storage.html"),
NEW_FOREGROUND_TAB,
ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
// Now navigate in the new tab.
NavigateToDestURLWithDisposition(CURRENT_TAB, false);
// Verify DidDisplayPass in the new tab.
EXPECT_TRUE(DidDisplayPass(GetActiveWebContents()));
}
// Checks that prerenders honor |should_replace_current_entry|.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderReplaceCurrentEntry) {
PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
content::OpenURLParams params(dest_url(), Referrer(), CURRENT_TAB,
content::PAGE_TRANSITION_TYPED, false);
params.should_replace_current_entry = true;
NavigateToURLWithParams(params, false);
const NavigationController& controller =
GetActiveWebContents()->GetController();
// First entry is about:blank, second is prerender_page.html.
EXPECT_TRUE(controller.GetPendingEntry() == NULL);
EXPECT_EQ(2, controller.GetEntryCount());
EXPECT_EQ(GURL(url::kAboutBlankURL), controller.GetEntryAtIndex(0)->GetURL());
EXPECT_EQ(dest_url(), controller.GetEntryAtIndex(1)->GetURL());
}
// Checks prerender does not hit DCHECKs and behaves properly if two pending
// swaps occur in a row.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDoublePendingSwap) {
GetPrerenderManager()->mutable_config().max_link_concurrency = 2;
GetPrerenderManager()->mutable_config().max_link_concurrency_per_launcher = 2;
GURL url1 = test_server()->GetURL("files/prerender/prerender_page.html?1");
scoped_ptr<TestPrerender> prerender1 =
PrerenderTestURL(url1, FINAL_STATUS_APP_TERMINATING, 1);
GURL url2 = test_server()->GetURL("files/prerender/prerender_page.html?2");
scoped_ptr<TestPrerender> prerender2 = ExpectPrerender(FINAL_STATUS_USED);
AddPrerender(url2, 1);
prerender2->WaitForStart();
prerender2->WaitForLoads(1);
// There's no reason the second prerender can't be used, but the swap races
// with didStartProvisionalLoad and didFailProvisionalLoad from the previous
// navigation. The current logic will conservatively fail to swap under such
// races. However, if the renderer is slow enough, it's possible for the
// prerender to still be used, so don't program in either expectation.
ASSERT_TRUE(prerender2->contents());
prerender2->contents()->set_skip_final_checks(true);
// Open a new tab to navigate in.
ui_test_utils::NavigateToURLWithDisposition(
current_browser(),
GURL(url::kAboutBlankURL),
NEW_FOREGROUND_TAB,
ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
// Fire off two navigations, without running the event loop between them.
NavigationOrSwapObserver swap_observer(
current_browser()->tab_strip_model(),
GetActiveWebContents(), 2);
current_browser()->OpenURL(OpenURLParams(
url1, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
current_browser()->OpenURL(OpenURLParams(
url2, Referrer(), CURRENT_TAB, content::PAGE_TRANSITION_TYPED, false));
swap_observer.Wait();
// The WebContents should be on url2. There may be 2 or 3 entries, depending
// on whether the first one managed to complete.
//
// TODO(davidben): When http://crbug.com/335835 is fixed, the 3 entry case
// shouldn't be possible because it's throttled by the pending swap that
// cannot complete.
const NavigationController& controller =
GetActiveWebContents()->GetController();
EXPECT_TRUE(controller.GetPendingEntry() == NULL);
EXPECT_LE(2, controller.GetEntryCount());
EXPECT_GE(3, controller.GetEntryCount());
EXPECT_EQ(GURL(url::kAboutBlankURL), controller.GetEntryAtIndex(0)->GetURL());
EXPECT_EQ(url2, controller.GetEntryAtIndex(
controller.GetEntryCount() - 1)->GetURL());
}
// Verify that pending swaps get aborted on new navigations.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderPendingSwapNewNavigation) {
PrerenderManager::HangSessionStorageMergesForTesting();
PrerenderTestURL("files/prerender/prerender_page.html",
FINAL_STATUS_APP_TERMINATING, 1);
// Open a new tab to navigate in.
ui_test_utils::NavigateToURLWithDisposition(
current_browser(),
GURL(url::kAboutBlankURL),
NEW_FOREGROUND_TAB,
ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);
// Navigate to the URL. Wait for DidStartLoading, just so it's definitely
// progressed somewhere.
content::WindowedNotificationObserver page_load_observer(
content::NOTIFICATION_LOAD_START,
content::Source<NavigationController>(
&GetActiveWebContents()->GetController()));
current_browser()->OpenURL(OpenURLParams(
dest_url(), Referrer(), CURRENT_TAB,
content::PAGE_TRANSITION_TYPED, false));
page_load_observer.Wait();
// Navigate somewhere else. This should succeed and abort the pending swap.
TestNavigationObserver nav_observer(GetActiveWebContents());
current_browser()->OpenURL(OpenURLParams(GURL(url::kAboutBlankURL),
Referrer(),
CURRENT_TAB,
content::PAGE_TRANSITION_TYPED,
false));
nav_observer.Wait();
}
// Checks that <a ping> requests are not dropped in prerender.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPing) {
// Count hits to a certain URL.
const GURL kPingURL("http://prerender.test/ping");
base::FilePath empty_file = ui_test_utils::GetTestFilePath(
base::FilePath(), base::FilePath(FILE_PATH_LITERAL("empty.html")));
RequestCounter ping_counter;
BrowserThread::PostTask(
BrowserThread::IO, FROM_HERE,
base::Bind(&CreateCountingInterceptorOnIO,
kPingURL, empty_file, ping_counter.AsWeakPtr()));
PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
OpenDestURLViaClickPing(kPingURL);
ping_counter.WaitForCount(1);
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPPLTNormalNavigation) {
UMAHistogramHelper histograms;
GURL url = test_server()->GetURL("files/prerender/prerender_page.html");
ui_test_utils::NavigateToURL(current_browser(), url);
histograms.Fetch();
histograms.ExpectTotalCount("Prerender.none_PerceivedPLT", 1);
histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatched", 0);
histograms.ExpectTotalCount("Prerender.none_PerceivedPLTMatchedComplete", 0);
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderCookieChangeConflictTest) {
NavigateStraightToURL(
"files/prerender/prerender_cookie.html?set=1&key=c&value=1");
GURL url = test_server()->GetURL(
"files/prerender/prerender_cookie.html?set=1&key=c&value=2");
scoped_ptr<TestPrerender> prerender =
ExpectPrerender(FINAL_STATUS_COOKIE_CONFLICT);
AddPrerender(url, 1);
prerender->WaitForStart();
prerender->WaitForLoads(1);
// Ensure that in the prerendered page, querying the cookie again
// via javascript yields the same value that was set during load.
EXPECT_TRUE(DidPrerenderPass(prerender->contents()->prerender_contents()));
// The prerender has loaded. Ensure that the change is not visible
// to visible tabs.
std::string value;
RunJSReturningString("GetCookie('c')", &value);
ASSERT_EQ(value, "1");
// Make a conflicting cookie change, which should cancel the prerender.
RunJS("SetCookie('c', '3')");
prerender->WaitForStop();
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderCookieChangeUseTest) {
// Permit 2 concurrent prerenders.
GetPrerenderManager()->mutable_config().max_link_concurrency = 2;
GetPrerenderManager()->mutable_config().max_link_concurrency_per_launcher = 2;
// Go to a first URL setting the cookie to value "1".
NavigateStraightToURL(
"files/prerender/prerender_cookie.html?set=1&key=c&value=1");
// Prerender a URL setting the cookie to value "2".
GURL url = test_server()->GetURL(
"files/prerender/prerender_cookie.html?set=1&key=c&value=2");
scoped_ptr<TestPrerender> prerender1 = ExpectPrerender(FINAL_STATUS_USED);
AddPrerender(url, 1);
prerender1->WaitForStart();
prerender1->WaitForLoads(1);
// Launch a second prerender, setting the cookie to value "3".
scoped_ptr<TestPrerender> prerender2 =
ExpectPrerender(FINAL_STATUS_COOKIE_CONFLICT);
AddPrerender(test_server()->GetURL(
"files/prerender/prerender_cookie.html?set=1&key=c&value=3"), 1);
prerender2->WaitForStart();
prerender2->WaitForLoads(1);
// Both prerenders have loaded. Ensure that the visible tab is still
// unchanged and cannot see their changes.
// to visible tabs.
std::string value;
RunJSReturningString("GetCookie('c')", &value);
ASSERT_EQ(value, "1");
// Navigate to the prerendered URL. The first prerender should be swapped in,
// and the changes should now be visible. The second prerender should
// be cancelled due to the conflict.
ui_test_utils::NavigateToURLWithDisposition(
current_browser(),
url,
CURRENT_TAB,
ui_test_utils::BROWSER_TEST_NONE);
RunJSReturningString("GetCookie('c')", &value);
ASSERT_EQ(value, "2");
prerender2->WaitForStop();
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderCookieChangeConflictHTTPHeaderTest) {
NavigateStraightToURL(
"files/prerender/prerender_cookie.html?set=1&key=c&value=1");
GURL url = test_server()->GetURL("set-cookie?c=2");
scoped_ptr<TestPrerender> prerender =
ExpectPrerender(FINAL_STATUS_COOKIE_CONFLICT);
AddPrerender(url, 1);
prerender->WaitForStart();
prerender->WaitForLoads(1);
// The prerender has loaded. Ensure that the change is not visible
// to visible tabs.
std::string value;
RunJSReturningString("GetCookie('c')", &value);
ASSERT_EQ(value, "1");
// Make a conflicting cookie change, which should cancel the prerender.
RunJS("SetCookie('c', '3')");
prerender->WaitForStop();
}
// Checks that a prerender which calls window.close() on itself is aborted.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderWindowClose) {
DisableLoadEventCheck();
PrerenderTestURL("files/prerender/prerender_window_close.html",
FINAL_STATUS_CLOSED, 0);
}
class PrerenderIncognitoBrowserTest : public PrerenderBrowserTest {
public:
virtual void SetUpOnMainThread() OVERRIDE {
Profile* normal_profile = current_browser()->profile();
set_browser(ui_test_utils::OpenURLOffTheRecord(
normal_profile, GURL("about:blank")));
PrerenderBrowserTest::SetUpOnMainThread();
}
};
// Checks that prerendering works in incognito mode.
IN_PROC_BROWSER_TEST_F(PrerenderIncognitoBrowserTest, PrerenderIncognito) {
PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
NavigateToDestURL();
}
// Checks that prerenders are aborted when an incognito profile is closed.
IN_PROC_BROWSER_TEST_F(PrerenderIncognitoBrowserTest,
PrerenderIncognitoClosed) {
scoped_ptr<TestPrerender> prerender =
PrerenderTestURL("files/prerender/prerender_page.html",
FINAL_STATUS_PROFILE_DESTROYED, 1);
current_browser()->window()->Close();
prerender->WaitForStop();
}
class PrerenderOmniboxBrowserTest : public PrerenderBrowserTest {
public:
LocationBar* GetLocationBar() {
return current_browser()->window()->GetLocationBar();
}
OmniboxView* GetOmniboxView() {
return GetLocationBar()->GetOmniboxView();
}
void WaitForAutocompleteDone(OmniboxView* omnibox_view) {
AutocompleteController* controller =
omnibox_view->model()->popup_model()->autocomplete_controller();
while (!controller->done()) {
content::WindowedNotificationObserver ready_observer(
chrome::NOTIFICATION_AUTOCOMPLETE_CONTROLLER_RESULT_READY,
content::Source<AutocompleteController>(controller));
ready_observer.Wait();
}
}
predictors::AutocompleteActionPredictor* GetAutocompleteActionPredictor() {
Profile* profile = current_browser()->profile();
return predictors::AutocompleteActionPredictorFactory::GetForProfile(
profile);
}
scoped_ptr<TestPrerender> StartOmniboxPrerender(
const GURL& url,
FinalStatus expected_final_status) {
scoped_ptr<TestPrerender> prerender =
ExpectPrerender(expected_final_status);
WebContents* web_contents = GetActiveWebContents();
GetAutocompleteActionPredictor()->StartPrerendering(
url,
web_contents->GetController().GetSessionStorageNamespaceMap(),
gfx::Size(50, 50));
prerender->WaitForStart();
return prerender.Pass();
}
};
// Checks that closing the omnibox popup cancels an omnibox prerender.
IN_PROC_BROWSER_TEST_F(PrerenderOmniboxBrowserTest, PrerenderOmniboxCancel) {
// Ensure the cookie store has been loaded.
if (!GetPrerenderManager()->cookie_store_loaded()) {
base::RunLoop loop;
GetPrerenderManager()->set_on_cookie_store_loaded_cb_for_testing(
loop.QuitClosure());
loop.Run();
}
// Fake an omnibox prerender.
scoped_ptr<TestPrerender> prerender = StartOmniboxPrerender(
test_server()->GetURL("files/empty.html"),
FINAL_STATUS_CANCELLED);
// Revert the location bar. This should cancel the prerender.
GetLocationBar()->Revert();
prerender->WaitForStop();
}
// Checks that accepting omnibox input abandons an omnibox prerender.
IN_PROC_BROWSER_TEST_F(PrerenderOmniboxBrowserTest, PrerenderOmniboxAbandon) {
// Set the abandon timeout to something high so it does not introduce
// flakiness if the prerender times out before the test completes.
GetPrerenderManager()->mutable_config().abandon_time_to_live =
base::TimeDelta::FromDays(999);
// Ensure the cookie store has been loaded.
if (!GetPrerenderManager()->cookie_store_loaded()) {
base::RunLoop loop;
GetPrerenderManager()->set_on_cookie_store_loaded_cb_for_testing(
loop.QuitClosure());
loop.Run();
}
// Enter a URL into the Omnibox.
OmniboxView* omnibox_view = GetOmniboxView();
omnibox_view->OnBeforePossibleChange();
omnibox_view->SetUserText(
base::UTF8ToUTF16(test_server()->GetURL("files/empty.html?1").spec()));
omnibox_view->OnAfterPossibleChange();
WaitForAutocompleteDone(omnibox_view);
// Fake an omnibox prerender for a different URL.
scoped_ptr<TestPrerender> prerender = StartOmniboxPrerender(
test_server()->GetURL("files/empty.html?2"),
FINAL_STATUS_APP_TERMINATING);
// The final status may be either FINAL_STATUS_APP_TERMINATING or
// FINAL_STATUS_CANCELLED. Although closing the omnibox will not cancel an
// abandoned prerender, the AutocompleteActionPredictor will cancel the
// predictor on destruction.
prerender->contents()->set_skip_final_checks(true);
// Navigate to the URL entered.
omnibox_view->model()->AcceptInput(CURRENT_TAB, false);
// Prerender should be running, but abandoned.
EXPECT_TRUE(
GetAutocompleteActionPredictor()->IsPrerenderAbandonedForTesting());
}
} // namespace prerender