// Copyright (c) 2011 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 "base/command_line.h"
#include "base/path_service.h"
#include "base/string_util.h"
#include "chrome/browser/prerender/prerender_contents.h"
#include "chrome/browser/prerender/prerender_manager.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/task_manager/task_manager.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/browser_window.h"
#include "chrome/common/chrome_paths.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/test/in_process_browser_test.h"
#include "chrome/test/ui_test_utils.h"
#include "content/browser/tab_contents/tab_contents.h"
#include "grit/generated_resources.h"
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_context_getter.h"
#include "ui/base/l10n/l10n_util.h"
#include <deque>
// 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 {
std::string CreateClientRedirect(const std::string& dest_url) {
const char* const kClientRedirectBase = "client-redirect?";
return kClientRedirectBase + dest_url;
}
std::string CreateServerRedirect(const std::string& dest_url) {
const char* const kServerRedirectBase = "server-redirect?";
return kServerRedirectBase + dest_url;
}
// PrerenderContents that stops the UI message loop on DidStopLoading().
class TestPrerenderContents : public PrerenderContents {
public:
TestPrerenderContents(
PrerenderManager* prerender_manager, Profile* profile, const GURL& url,
const std::vector<GURL>& alias_urls,
const GURL& referrer,
int number_of_loads,
FinalStatus expected_final_status)
: PrerenderContents(prerender_manager, profile, url, alias_urls,
referrer),
number_of_loads_(0),
expected_number_of_loads_(number_of_loads),
expected_final_status_(expected_final_status) {
}
virtual ~TestPrerenderContents() {
EXPECT_EQ(expected_final_status_, final_status()) <<
" when testing URL " << prerender_url().path();
// In the event we are destroyed, say if the prerender was canceled, quit
// the UI message loop.
MessageLoopForUI::current()->Quit();
}
virtual void DidStopLoading() {
PrerenderContents::DidStopLoading();
++number_of_loads_;
if (expected_final_status_ == FINAL_STATUS_USED &&
number_of_loads_ >= expected_number_of_loads_) {
MessageLoopForUI::current()->Quit();
}
}
private:
int number_of_loads_;
int expected_number_of_loads_;
FinalStatus expected_final_status_;
};
// PrerenderManager that uses TestPrerenderContents.
class WaitForLoadPrerenderContentsFactory : public PrerenderContents::Factory {
public:
WaitForLoadPrerenderContentsFactory(
int number_of_loads,
const std::deque<FinalStatus>& expected_final_status_queue)
: number_of_loads_(number_of_loads) {
expected_final_status_queue_.resize(expected_final_status_queue.size());
std::copy(expected_final_status_queue.begin(),
expected_final_status_queue.end(),
expected_final_status_queue_.begin());
LOG(INFO) << "Factory created with queue length " <<
expected_final_status_queue_.size();
}
virtual PrerenderContents* CreatePrerenderContents(
PrerenderManager* prerender_manager, Profile* profile, const GURL& url,
const std::vector<GURL>& alias_urls, const GURL& referrer) {
CHECK(!expected_final_status_queue_.empty()) <<
"Creating prerender contents for " << url.path() <<
" with no expected final status";
FinalStatus expected_final_status = expected_final_status_queue_.front();
expected_final_status_queue_.pop_front();
LOG(INFO) << "Creating prerender contents for " << url.path() <<
" with expected final status " << expected_final_status;
LOG(INFO) << expected_final_status_queue_.size() << " left in the queue.";
return new TestPrerenderContents(prerender_manager, profile, url,
alias_urls, referrer,
number_of_loads_,
expected_final_status);
}
private:
int number_of_loads_;
std::deque<FinalStatus> expected_final_status_queue_;
};
} // namespace
class PrerenderBrowserTest : public InProcessBrowserTest {
public:
PrerenderBrowserTest()
: prc_factory_(NULL),
use_https_src_server_(false) {
EnableDOMAutomation();
}
virtual void SetUpCommandLine(CommandLine* command_line) {
command_line->AppendSwitchASCII(switches::kPrerender,
switches::kPrerenderSwitchValueEnabled);
#if defined(OS_MACOSX)
// The plugins directory isn't read by default on the Mac, so it needs to be
// explicitly registered.
FilePath app_dir;
PathService::Get(chrome::DIR_APP, &app_dir);
command_line->AppendSwitchPath(
switches::kExtraPluginDir,
app_dir.Append(FILE_PATH_LITERAL("plugins")));
#endif
}
// Overload for a single expected final status
void PrerenderTestURL(const std::string& html_file,
FinalStatus expected_final_status,
int total_navigations) {
std::deque<FinalStatus> expected_final_status_queue(1,
expected_final_status);
PrerenderTestURLImpl(html_file,
expected_final_status_queue,
total_navigations);
}
void PrerenderTestURL(
const std::string& html_file,
const std::deque<FinalStatus>& expected_final_status_queue,
int total_navigations) {
PrerenderTestURLImpl(html_file,
expected_final_status_queue,
total_navigations);
}
void NavigateToDestURL() const {
ui_test_utils::NavigateToURL(browser(), dest_url_);
// Make sure the PrerenderContents found earlier was used or removed
EXPECT_TRUE(prerender_manager()->FindEntry(dest_url_) == NULL);
// Check if page behaved as expected when actually displayed.
bool display_test_result = false;
ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
browser()->GetSelectedTabContents()->render_view_host(), L"",
L"window.domAutomationController.send(DidDisplayPass())",
&display_test_result));
EXPECT_TRUE(display_test_result);
}
bool UrlIsInPrerenderManager(const std::string& html_file) {
GURL dest_url = test_server()->GetURL(html_file);
return (prerender_manager()->FindEntry(dest_url) != NULL);
}
bool UrlIsInPrerenderManager(const GURL& url) {
return (prerender_manager()->FindEntry(url) != NULL);
}
bool UrlIsPendingInPrerenderManager(const std::string& html_file) {
GURL dest_url = test_server()->GetURL(html_file);
return (prerender_manager()->FindPendingEntry(dest_url) != NULL);
}
void set_use_https_src(bool use_https_src_server) {
use_https_src_server_ = use_https_src_server;
}
TaskManagerModel* model() const {
return TaskManager::GetInstance()->model();
}
void set_dest_url(const GURL& dest_url) { dest_url_ = dest_url; }
private:
void PrerenderTestURLImpl(
const std::string& html_file,
const std::deque<FinalStatus>& expected_final_status_queue,
int total_navigations) {
ASSERT_TRUE(test_server()->Start());
dest_url_ = test_server()->GetURL(html_file);
std::vector<net::TestServer::StringPair> replacement_text;
replacement_text.push_back(
make_pair("REPLACE_WITH_PREFETCH_URL", dest_url_.spec()));
std::string replacement_path;
ASSERT_TRUE(net::TestServer::GetFilePathWithReplacements(
"files/prerender/prerender_loader.html",
replacement_text,
&replacement_path));
net::TestServer* src_server = test_server();
scoped_ptr<net::TestServer> https_src_server;
if (use_https_src_server_) {
https_src_server.reset(
new net::TestServer(net::TestServer::TYPE_HTTPS,
FilePath(FILE_PATH_LITERAL("chrome/test/data"))));
ASSERT_TRUE(https_src_server->Start());
src_server = https_src_server.get();
}
GURL src_url = src_server->GetURL(replacement_path);
// This is needed to exit the event loop once the prerendered page has
// stopped loading or was cancelled.
ASSERT_TRUE(prerender_manager());
prerender_manager()->rate_limit_enabled_ = false;
ASSERT_TRUE(prc_factory_ == NULL);
prc_factory_ =
new WaitForLoadPrerenderContentsFactory(total_navigations,
expected_final_status_queue);
prerender_manager()->SetPrerenderContentsFactory(prc_factory_);
FinalStatus expected_final_status = expected_final_status_queue.front();
// ui_test_utils::NavigateToURL uses its own observer and message loop.
// Since the test needs to wait until the prerendered page has stopped
// loading, rathather than the page directly navigated to, need to
// handle browser navigation directly.
browser()->OpenURL(src_url, GURL(), CURRENT_TAB, PageTransition::TYPED);
TestPrerenderContents* prerender_contents = NULL;
ui_test_utils::RunMessageLoop();
prerender_contents =
static_cast<TestPrerenderContents*>(
prerender_manager()->FindEntry(dest_url_));
switch (expected_final_status) {
case FINAL_STATUS_USED: {
ASSERT_TRUE(prerender_contents != NULL);
// Check if page behaves as expected while in prerendered state.
bool prerender_test_result = false;
ASSERT_TRUE(ui_test_utils::ExecuteJavaScriptAndExtractBool(
prerender_contents->render_view_host(), L"",
L"window.domAutomationController.send(DidPrerenderPass())",
&prerender_test_result));
EXPECT_TRUE(prerender_test_result);
break;
}
default:
// In the failure case, we should have removed dest_url_ from the
// prerender_manager.
EXPECT_TRUE(prerender_contents == NULL);
break;
}
}
PrerenderManager* prerender_manager() const {
Profile* profile = browser()->GetSelectedTabContents()->profile();
PrerenderManager* prerender_manager = profile->GetPrerenderManager();
return prerender_manager;
}
WaitForLoadPrerenderContentsFactory* prc_factory_;
GURL dest_url_;
bool use_https_src_server_;
};
// Checks that a page is correctly prerendered in the case of a
// <link rel=prefetch> tag and then loaded into a tab in response to a
// navigation.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderPage) {
PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
NavigateToDestURL();
}
// 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,
1);
}
// 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.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderDelayLoadPlugin) {
PrerenderTestURL("files/prerender/plugin_delay_load.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// Checks that plugins in an iframe are not loaded while a page is
// being preloaded, but are loaded when the page is displayed.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, 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,
1);
}
// 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);
set_dest_url(test_server()->GetURL("files/prerender/prerender_page.html"));
NavigateToDestURL();
}
// Checks that client-issued redirects to an https page will cancel prerenders.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderClientRedirectToHttps) {
net::TestServer https_server(net::TestServer::TYPE_HTTPS,
FilePath(FILE_PATH_LITERAL("chrome/test/data")));
ASSERT_TRUE(https_server.Start());
GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
PrerenderTestURL(CreateClientRedirect(https_url.spec()),
FINAL_STATUS_HTTPS,
1);
}
// 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::TestServer::StringPair> replacement_text;
replacement_text.push_back(
std::make_pair("REPLACE_WITH_URL", "/" + redirect_path));
std::string replacement_path;
ASSERT_TRUE(net::TestServer::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();
}
// Checks that client-issued redirects within an iframe in a prerendered
// page to an https page will not cancel the prerender, nor will it
// count as an "alias" for the prerendered page.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderClientRedirectToHttpsInIframe) {
net::TestServer https_server(net::TestServer::TYPE_HTTPS,
FilePath(FILE_PATH_LITERAL("chrome/test/data")));
ASSERT_TRUE(https_server.Start());
GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
std::string redirect_path = CreateClientRedirect(https_url.spec());
std::vector<net::TestServer::StringPair> replacement_text;
replacement_text.push_back(
std::make_pair("REPLACE_WITH_URL", "/" + redirect_path));
std::string replacement_path;
ASSERT_TRUE(net::TestServer::GetFilePathWithReplacements(
"files/prerender/prerender_with_iframe.html",
replacement_text,
&replacement_path));
PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
EXPECT_FALSE(UrlIsInPrerenderManager(https_url));
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) {
std::string redirect_path;
PrerenderTestURL(
CreateServerRedirect("files/prerender/prerender_page.html"),
FINAL_STATUS_USED,
1);
set_dest_url(test_server()->GetURL("files/prerender/prerender_page.html"));
NavigateToDestURL();
}
// TODO(cbentzel): Add server-redirect-to-https test. http://crbug.com/79182
// 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::TestServer::StringPair> replacement_text;
replacement_text.push_back(
std::make_pair("REPLACE_WITH_URL", "/" + redirect_path));
std::string replacement_path;
ASSERT_TRUE(net::TestServer::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();
}
// Checks that server-issued redirects within an iframe in a prerendered
// page to an https page will not cancel the prerender, nor will it
// count as an "alias" for the prerendered page.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
PrerenderServerRedirectToHttpsInIframe) {
net::TestServer https_server(net::TestServer::TYPE_HTTPS,
FilePath(FILE_PATH_LITERAL("chrome/test/data")));
ASSERT_TRUE(https_server.Start());
GURL https_url = https_server.GetURL("files/prerender/prerender_page.html");
std::string redirect_path = CreateServerRedirect(https_url.spec());
std::vector<net::TestServer::StringPair> replacement_text;
replacement_text.push_back(
std::make_pair("REPLACE_WITH_URL", "/" + redirect_path));
std::string replacement_path;
ASSERT_TRUE(net::TestServer::GetFilePathWithReplacements(
"files/prerender/prerender_with_iframe.html",
replacement_text,
&replacement_path));
PrerenderTestURL(replacement_path, FINAL_STATUS_USED, 1);
EXPECT_FALSE(UrlIsInPrerenderManager(https_url));
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,
1);
}
// 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) {
set_use_https_src(true);
PrerenderTestURL("files/prerender/prerender_no_referrer.html",
FINAL_STATUS_USED,
1);
NavigateToDestURL();
}
// 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,
1);
}
// Checks that renderers using excessive memory will be terminated.
// Disabled, http://crbug.com/77870.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
DISABLED_PrerenderExcessiveMemory) {
PrerenderTestURL("files/prerender/prerender_excessive_memory.html",
FINAL_STATUS_MEMORY_LIMIT_EXCEEDED,
1);
}
// Checks that we don't prerender in an infinite loop.
// Disabled, http://crbug.com/77870.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, DISABLED_PrerenderInfiniteLoop) {
const char* const kHtmlFileA = "prerender_infinite_a.html";
const char* const kHtmlFileB = "prerender_infinite_b.html";
std::deque<FinalStatus> expected_final_status_queue;
expected_final_status_queue.push_back(FINAL_STATUS_USED);
expected_final_status_queue.push_back(FINAL_STATUS_APP_TERMINATING);
PrerenderTestURL(kHtmlFileA, expected_final_status_queue, 1);
// Next url should be in pending list but not an active entry.
EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileB));
EXPECT_TRUE(UrlIsPendingInPrerenderManager(kHtmlFileB));
NavigateToDestURL();
// Make sure the PrerenderContents for the next url is now in the manager
// and not pending.
EXPECT_TRUE(UrlIsInPrerenderManager(kHtmlFileB));
EXPECT_FALSE(UrlIsPendingInPrerenderManager(kHtmlFileB));
}
// Checks that we don't prerender in an infinite loop and multiple links are
// handled correctly.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest,
FLAKY_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";
// We need to set the final status to expect here before starting any
// prerenders. We set them on a queue so whichever we see first is expected to
// be evicted, and the second should stick around until we exit.
std::deque<FinalStatus> expected_final_status_queue;
expected_final_status_queue.push_back(FINAL_STATUS_USED);
expected_final_status_queue.push_back(FINAL_STATUS_EVICTED);
expected_final_status_queue.push_back(FINAL_STATUS_APP_TERMINATING);
PrerenderTestURL(kHtmlFileA, expected_final_status_queue, 1);
// Next url should be in pending list but not an active entry.
EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileB));
EXPECT_FALSE(UrlIsInPrerenderManager(kHtmlFileC));
EXPECT_TRUE(UrlIsPendingInPrerenderManager(kHtmlFileB));
EXPECT_TRUE(UrlIsPendingInPrerenderManager(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.
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) &&
!(url_b_is_active_prerender && url_c_is_active_prerender));
EXPECT_FALSE(UrlIsPendingInPrerenderManager(kHtmlFileB));
EXPECT_FALSE(UrlIsPendingInPrerenderManager(kHtmlFileC));
}
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, TaskManager) {
// Show the task manager. This populates the model.
browser()->window()->ShowTaskManager();
// Start with two resources.
EXPECT_EQ(2, model()->ResourceCount());
PrerenderTestURL("files/prerender/prerender_page.html", FINAL_STATUS_USED, 1);
// The prerender makes three.
EXPECT_EQ(3, model()->ResourceCount());
// It shouldn't have a TabContents associated with it.
ASSERT_TRUE(model()->GetResourceTabContents(1) == NULL);
// The prefix should be "Prerender:"
string16 prefix =
l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_PRERENDER_PREFIX,
string16());
ASSERT_TRUE(StartsWith(model()->GetResourceTitle(1), prefix, true));
NavigateToDestURL();
// Prerender task should be killed and removed from the Task Manager.
EXPECT_EQ(2, model()->ResourceCount());
}
// Checks that prerenderers will terminate when an audio tag is encountered.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5Audio) {
PrerenderTestURL("files/prerender/prerender_html5_audio.html",
FINAL_STATUS_HTML5_MEDIA,
1);
}
// Checks that prerenderers will terminate when a video tag is encountered.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5Video) {
PrerenderTestURL("files/prerender/prerender_html5_video.html",
FINAL_STATUS_HTML5_MEDIA,
1);
}
// Checks that prerenderers will terminate when a video tag is inserted via
// javascript.
IN_PROC_BROWSER_TEST_F(PrerenderBrowserTest, PrerenderHTML5VideoJs) {
PrerenderTestURL("files/prerender/prerender_html5_video_script.html",
FINAL_STATUS_HTML5_MEDIA,
1);
}
} // namespace prerender