blob: 656561dad2d11b4954d9644cff309d064999e545 [file] [log] [blame]
// Copyright 2013 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 "content/browser/frame_host/navigation_controller_impl.h"
#include <stddef.h>
#include <stdint.h>
#include <memory>
#include <string>
#include <tuple>
#include <utility>
#include "base/bind.h"
#include "base/files/file_util.h"
#include "base/memory/ptr_util.h"
#include "base/stl_util.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/test/bind_test_util.h"
#include "base/test/gtest_util.h"
#include "base/time/time.h"
#include "build/build_config.h"
#include "content/browser/browser_url_handler_impl.h"
#include "content/browser/frame_host/frame_navigation_entry.h"
#include "content/browser/frame_host/navigation_entry_impl.h"
#include "content/browser/frame_host/navigation_handle_impl.h"
#include "content/browser/frame_host/navigation_request.h"
#include "content/browser/frame_host/navigator.h"
#include "content/browser/frame_host/navigator_impl.h"
#include "content/browser/site_instance_impl.h"
#include "content/browser/web_contents/web_contents_impl.h"
#include "content/common/frame_messages.h"
#include "content/common/frame_owner_properties.h"
#include "content/common/view_messages.h"
#include "content/public/browser/render_view_host.h"
#include "content/public/browser/web_contents_delegate.h"
#include "content/public/browser/web_contents_observer.h"
#include "content/public/common/bindings_policy.h"
#include "content/public/common/page_state.h"
#include "content/public/common/page_type.h"
#include "content/public/common/previews_state.h"
#include "content/public/common/url_constants.h"
#include "content/public/test/browser_side_navigation_test_utils.h"
#include "content/public/test/mock_render_process_host.h"
#include "content/public/test/navigation_simulator.h"
#include "content/public/test/test_navigation_ui_data.h"
#include "content/public/test/test_utils.h"
#include "content/test/navigation_simulator_impl.h"
#include "content/test/test_render_frame_host.h"
#include "content/test/test_render_view_host.h"
#include "content/test/test_web_contents.h"
#include "services/network/public/cpp/resource_request_body.h"
#include "skia/ext/platform_canvas.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/blink/public/common/frame/frame_policy.h"
using base::Time;
namespace {
// Creates an image with a 1x1 SkBitmap of the specified |color|.
gfx::Image CreateImage(SkColor color) {
SkBitmap bitmap;
bitmap.allocN32Pixels(1, 1);
bitmap.eraseColor(color);
return gfx::Image::CreateFrom1xBitmap(bitmap);
}
// Returns true if images |a| and |b| have the same pixel data.
bool DoImagesMatch(const gfx::Image& a, const gfx::Image& b) {
// Assume that if the 1x bitmaps match, the images match.
SkBitmap a_bitmap = a.AsBitmap();
SkBitmap b_bitmap = b.AsBitmap();
if (a_bitmap.width() != b_bitmap.width() ||
a_bitmap.height() != b_bitmap.height()) {
return false;
}
return memcmp(a_bitmap.getPixels(), b_bitmap.getPixels(),
a_bitmap.computeByteSize()) == 0;
}
} // namespace
namespace content {
// TimeSmoother tests ----------------------------------------------------------
// With no duplicates, GetSmoothedTime should be the identity
// function.
TEST(TimeSmoother, Basic) {
NavigationControllerImpl::TimeSmoother smoother;
for (int64_t i = 1; i < 1000; ++i) {
base::Time t = base::Time::FromInternalValue(i);
EXPECT_EQ(t, smoother.GetSmoothedTime(t));
}
}
// With a single duplicate and timestamps thereafter increasing by one
// microsecond, the smoothed time should always be one behind.
TEST(TimeSmoother, SingleDuplicate) {
NavigationControllerImpl::TimeSmoother smoother;
base::Time t = base::Time::FromInternalValue(1);
EXPECT_EQ(t, smoother.GetSmoothedTime(t));
for (int64_t i = 1; i < 1000; ++i) {
base::Time expected_t = base::Time::FromInternalValue(i + 1);
t = base::Time::FromInternalValue(i);
EXPECT_EQ(expected_t, smoother.GetSmoothedTime(t));
}
}
// With k duplicates and timestamps thereafter increasing by one
// microsecond, the smoothed time should always be k behind.
TEST(TimeSmoother, ManyDuplicates) {
const int64_t kNumDuplicates = 100;
NavigationControllerImpl::TimeSmoother smoother;
base::Time t = base::Time::FromInternalValue(1);
for (int64_t i = 0; i < kNumDuplicates; ++i) {
base::Time expected_t = base::Time::FromInternalValue(i + 1);
EXPECT_EQ(expected_t, smoother.GetSmoothedTime(t));
}
for (int64_t i = 1; i < 1000; ++i) {
base::Time expected_t =
base::Time::FromInternalValue(i + kNumDuplicates);
t = base::Time::FromInternalValue(i);
EXPECT_EQ(expected_t, smoother.GetSmoothedTime(t));
}
}
// If the clock jumps far back enough after a run of duplicates, it
// should immediately jump to that value.
TEST(TimeSmoother, ClockBackwardsJump) {
const int64_t kNumDuplicates = 100;
NavigationControllerImpl::TimeSmoother smoother;
base::Time t = base::Time::FromInternalValue(1000);
for (int64_t i = 0; i < kNumDuplicates; ++i) {
base::Time expected_t = base::Time::FromInternalValue(i + 1000);
EXPECT_EQ(expected_t, smoother.GetSmoothedTime(t));
}
t = base::Time::FromInternalValue(500);
EXPECT_EQ(t, smoother.GetSmoothedTime(t));
}
// NavigationControllerTest ----------------------------------------------------
class NavigationControllerTest
: public RenderViewHostImplTestHarness,
public WebContentsObserver {
public:
NavigationControllerTest() {}
void SetUp() override {
RenderViewHostImplTestHarness::SetUp();
WebContents* web_contents = RenderViewHostImplTestHarness::web_contents();
ASSERT_TRUE(web_contents); // The WebContents should be created by now.
WebContentsObserver::Observe(web_contents);
}
// WebContentsObserver:
void DidStartNavigationToPendingEntry(const GURL& url,
ReloadType reload_type) override {
navigated_url_ = url;
last_reload_type_ = reload_type;
}
void NavigationEntryCommitted(
const LoadCommittedDetails& load_details) override {
navigation_entry_committed_counter_++;
}
void NavigationEntryChanged(
const EntryChangedDetails& load_details) override {
navigation_entry_changed_counter_++;
}
void NavigationListPruned(const PrunedDetails& details) override {
navigation_list_pruned_counter_++;
last_navigation_entry_pruned_details_ = details;
}
void NavigationEntriesDeleted() override {
navigation_entries_deleted_counter_++;
}
const GURL& navigated_url() const {
return navigated_url_;
}
NavigationControllerImpl& controller_impl() {
return static_cast<NavigationControllerImpl&>(controller());
}
bool HasNavigationRequest() {
return contents()->GetFrameTree()->root()->navigation_request() != nullptr;
}
const GURL GetLastNavigationURL() {
NavigationRequest* navigation_request =
contents()->GetFrameTree()->root()->navigation_request();
CHECK(navigation_request);
return navigation_request->common_params().url;
}
content::PreviewsState GetLastNavigationPreviewsState() {
NavigationRequest* navigation_request =
contents()->GetFrameTree()->root()->navigation_request();
CHECK(navigation_request);
return navigation_request->common_params().previews_state;
}
TestRenderFrameHost* GetNavigatingRenderFrameHost() {
return AreAllSitesIsolatedForTesting() ? contents()->GetPendingMainFrame()
: contents()->GetMainFrame();
}
protected:
GURL navigated_url_;
size_t navigation_entry_committed_counter_ = 0;
size_t navigation_entry_changed_counter_ = 0;
size_t navigation_list_pruned_counter_ = 0;
size_t navigation_entries_deleted_counter_ = 0;
PrunedDetails last_navigation_entry_pruned_details_;
ReloadType last_reload_type_;
};
class TestWebContentsDelegate : public WebContentsDelegate {
public:
TestWebContentsDelegate()
: navigation_state_change_count_(0), repost_form_warning_count_(0) {}
int navigation_state_change_count() {
return navigation_state_change_count_;
}
int repost_form_warning_count() {
return repost_form_warning_count_;
}
// Keep track of whether the tab has notified us of a navigation state change.
void NavigationStateChanged(WebContents* source,
InvalidateTypes changed_flags) override {
navigation_state_change_count_++;
}
void ShowRepostFormWarningDialog(WebContents* source) override {
repost_form_warning_count_++;
}
private:
// The number of times NavigationStateChanged has been called.
int navigation_state_change_count_;
// The number of times ShowRepostFormWarningDialog() was called.
int repost_form_warning_count_;
};
// Observer that records the LoadCommittedDetails from the most recent commit.
class LoadCommittedDetailsObserver : public WebContentsObserver {
public:
// Observes navigation for the specified |web_contents|.
explicit LoadCommittedDetailsObserver(WebContents* web_contents)
: WebContentsObserver(web_contents),
navigation_type_(NAVIGATION_TYPE_UNKNOWN),
reload_type_(ReloadType::NONE),
is_same_document_(false),
is_main_frame_(false),
did_replace_entry_(false) {}
NavigationType navigation_type() { return navigation_type_; }
const GURL& previous_url() { return previous_url_; }
ReloadType reload_type() { return reload_type_; }
bool is_same_document() { return is_same_document_; }
bool is_main_frame() { return is_main_frame_; }
bool did_replace_entry() { return did_replace_entry_; }
bool has_navigation_ui_data() { return has_navigation_ui_data_; }
private:
void DidFinishNavigation(NavigationHandle* navigation_handle) override {
if (!navigation_handle->HasCommitted())
return;
navigation_type_ = static_cast<NavigationHandleImpl*>(navigation_handle)
->navigation_type();
previous_url_ = navigation_handle->GetPreviousURL();
reload_type_ = navigation_handle->GetReloadType();
is_same_document_ = navigation_handle->IsSameDocument();
is_main_frame_ = navigation_handle->IsInMainFrame();
did_replace_entry_ = navigation_handle->DidReplaceEntry();
has_navigation_ui_data_ = navigation_handle->GetNavigationUIData();
}
NavigationType navigation_type_;
GURL previous_url_;
ReloadType reload_type_;
bool is_same_document_;
bool is_main_frame_;
bool did_replace_entry_;
bool has_navigation_ui_data_;
};
// "Legacy" class that was used to run NavigationControllerTest with the now
// defunct --enable-browser-side-navigation flag.
// TODO(clamy): Make those regular NavigationControllerTests.
class NavigationControllerTestWithBrowserSideNavigation
: public NavigationControllerTest {
public:
void SetUp() override {
NavigationControllerTest::SetUp();
}
};
// -----------------------------------------------------------------------------
TEST_F(NavigationControllerTest, Defaults) {
NavigationControllerImpl& controller = controller_impl();
EXPECT_FALSE(controller.GetPendingEntry());
EXPECT_FALSE(controller.GetVisibleEntry());
EXPECT_FALSE(controller.GetLastCommittedEntry());
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), -1);
EXPECT_EQ(controller.GetEntryCount(), 0);
EXPECT_FALSE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoForward());
}
TEST_F(NavigationControllerTest, GoToOffset) {
NavigationControllerImpl& controller = controller_impl();
const int kNumUrls = 5;
std::vector<GURL> urls(kNumUrls);
for (int i = 0; i < kNumUrls; ++i) {
urls[i] = GURL(base::StringPrintf("http://www.a.com/%d", i));
}
NavigationSimulator::NavigateAndCommitFromDocument(urls[0], main_test_rfh());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_EQ(urls[0], controller.GetVisibleEntry()->GetVirtualURL());
EXPECT_FALSE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoForward());
EXPECT_FALSE(controller.CanGoToOffset(1));
for (int i = 1; i <= 4; ++i) {
NavigationSimulator::NavigateAndCommitFromDocument(urls[i],
main_test_rfh());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_EQ(urls[i], controller.GetVisibleEntry()->GetVirtualURL());
EXPECT_TRUE(controller.CanGoToOffset(-i));
EXPECT_FALSE(controller.CanGoToOffset(-(i + 1)));
EXPECT_FALSE(controller.CanGoToOffset(1));
}
// We have loaded 5 pages, and are currently at the last-loaded page.
int url_index = 4;
enum Tests {
GO_TO_MIDDLE_PAGE = -2,
GO_FORWARDS = 1,
GO_BACKWARDS = -1,
GO_TO_BEGINNING = -2,
GO_TO_END = 4,
NUM_TESTS = 5,
};
const int test_offsets[NUM_TESTS] = {
GO_TO_MIDDLE_PAGE,
GO_FORWARDS,
GO_BACKWARDS,
GO_TO_BEGINNING,
GO_TO_END
};
for (int test = 0; test < NUM_TESTS; ++test) {
int offset = test_offsets[test];
auto navigation =
NavigationSimulator::CreateHistoryNavigation(offset, contents());
navigation->Start();
url_index += offset;
// Check that the GoToOffset will land on the expected page.
EXPECT_EQ(urls[url_index], controller.GetPendingEntry()->GetVirtualURL());
navigation->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// Check that we can go to any valid offset into the history.
for (size_t j = 0; j < urls.size(); ++j)
EXPECT_TRUE(controller.CanGoToOffset(j - url_index));
// Check that we can't go beyond the beginning or end of the history.
EXPECT_FALSE(controller.CanGoToOffset(-(url_index + 1)));
EXPECT_FALSE(controller.CanGoToOffset(urls.size() - url_index));
}
}
// Tests that receiving a DidFailProvisionalLoad from the renderer that is
// trying to commit an error page won't reset the pending entry of a navigation
// that just started.
TEST_F(NavigationControllerTestWithBrowserSideNavigation,
DontDiscardWrongPendingEntry) {
NavigationControllerImpl& controller = controller_impl();
GURL initial_url("http://www.google.com");
GURL url_1("http://google.com/foo");
GURL url_2("http://foo2.com");
// Navigate inititally. This is the url that could erroneously be the visible
// entry when url_1 fails.
NavigateAndCommit(initial_url);
// Set the pending entry as url_1 and create the NavigationHandle.
auto navigation =
NavigationSimulator::CreateBrowserInitiated(url_1, contents());
navigation->Start();
EXPECT_EQ(url_1, controller.GetVisibleEntry()->GetURL());
// The navigation fails and needs to show an error page. This resets the
// pending entry.
navigation->Fail(net::ERR_TIMED_OUT);
EXPECT_EQ(initial_url, controller.GetVisibleEntry()->GetURL());
// A navigation to url_2 starts, creating a pending navigation entry.
controller.LoadURL(url_2, Referrer(), ui::PAGE_TRANSITION_TYPED,
std::string());
EXPECT_EQ(url_2, controller.GetVisibleEntry()->GetURL());
// The DidFailProvsionalLoad mojo call is received from the current RFH that
// is committing an error page. This should not reset the pending entry for
// the new ongoing navigation.
main_test_rfh()->DidFailProvisionalLoadWithError(url_1, net::ERR_TIMED_OUT,
base::string16(), false);
EXPECT_EQ(url_2, controller.GetVisibleEntry()->GetURL());
}
TEST_F(NavigationControllerTest, LoadURL) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo1");
const GURL url2("http://foo2");
controller.LoadURL(
url1, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
int entry_id = controller.GetPendingEntry()->GetUniqueID();
// Creating a pending notification should not have issued any of the
// notifications we're listening for.
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
// The load should now be pending.
EXPECT_EQ(controller.GetEntryCount(), 0);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), -1);
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_FALSE(controller.GetLastCommittedEntry());
ASSERT_TRUE(controller.GetPendingEntry());
EXPECT_EQ(controller.GetPendingEntry(), controller.GetVisibleEntry());
EXPECT_FALSE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoForward());
// Neither the timestamp nor the status code should have been set yet.
EXPECT_TRUE(controller.GetPendingEntry()->GetTimestamp().is_null());
EXPECT_EQ(0, controller.GetPendingEntry()->GetHttpStatusCode());
// We should have gotten no notifications from the preceeding checks.
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
auto navigation1 = NavigationSimulator::CreateFromPending(contents());
navigation1->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// The load should now be committed.
EXPECT_EQ(controller.GetEntryCount(), 1);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_FALSE(controller.GetPendingEntry());
ASSERT_TRUE(controller.GetVisibleEntry());
EXPECT_FALSE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoForward());
EXPECT_EQ(0, controller.GetLastCommittedEntry()->bindings());
// The timestamp should have been set.
EXPECT_FALSE(controller.GetVisibleEntry()->GetTimestamp().is_null());
// Simulate a user gesture so that the above entry is not marked to be skipped
// on back.
main_test_rfh()->frame_tree_node()->UpdateUserActivationState(
blink::UserActivationUpdateType::kNotifyActivation);
// Load another...
controller.LoadURL(
url2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
entry_id = controller.GetPendingEntry()->GetUniqueID();
// The load should now be pending.
EXPECT_EQ(controller.GetEntryCount(), 1);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_TRUE(controller.GetLastCommittedEntry());
ASSERT_TRUE(controller.GetPendingEntry());
EXPECT_EQ(controller.GetPendingEntry(), controller.GetVisibleEntry());
// TODO(darin): maybe this should really be true?
EXPECT_FALSE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoForward());
EXPECT_TRUE(controller.GetPendingEntry()->GetTimestamp().is_null());
auto navigation2 = NavigationSimulator::CreateFromPending(contents());
navigation2->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// The load should now be committed.
EXPECT_EQ(controller.GetEntryCount(), 2);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 1);
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_FALSE(controller.GetPendingEntry());
ASSERT_TRUE(controller.GetVisibleEntry());
EXPECT_TRUE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoForward());
EXPECT_FALSE(controller.GetVisibleEntry()->GetTimestamp().is_null());
}
namespace {
base::Time GetFixedTime(base::Time time) {
return time;
}
} // namespace
TEST_F(NavigationControllerTest, LoadURLSameTime) {
NavigationControllerImpl& controller = controller_impl();
// Set the clock to always return a timestamp of 1.
controller.SetGetTimestampCallbackForTest(
base::Bind(&GetFixedTime, base::Time::FromInternalValue(1)));
const GURL url1("http://foo1");
const GURL url2("http://foo2");
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), url1);
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// Load another...
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), url2);
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// The two loads should now be committed.
ASSERT_EQ(controller.GetEntryCount(), 2);
// Timestamps should be distinct despite the clock returning the
// same value.
EXPECT_EQ(1u,
controller.GetEntryAtIndex(0)->GetTimestamp().ToInternalValue());
EXPECT_EQ(2u,
controller.GetEntryAtIndex(1)->GetTimestamp().ToInternalValue());
}
void CheckNavigationEntryMatchLoadParams(
const NavigationController::LoadURLParams& load_params,
NavigationEntryImpl* entry) {
EXPECT_EQ(load_params.url, entry->GetURL());
EXPECT_EQ(load_params.referrer.url, entry->GetReferrer().url);
EXPECT_EQ(load_params.referrer.policy, entry->GetReferrer().policy);
EXPECT_TRUE(ui::PageTransitionTypeIncludingQualifiersIs(
entry->GetTransitionType(), load_params.transition_type));
std::string extra_headers_crlf;
base::ReplaceChars(load_params.extra_headers, "\n", "\r\n",
&extra_headers_crlf);
EXPECT_EQ(extra_headers_crlf, entry->extra_headers());
EXPECT_EQ(load_params.is_renderer_initiated, entry->is_renderer_initiated());
EXPECT_EQ(load_params.base_url_for_data_url, entry->GetBaseURLForDataURL());
if (!load_params.virtual_url_for_data_url.is_empty()) {
EXPECT_EQ(load_params.virtual_url_for_data_url, entry->GetVirtualURL());
}
#if defined(OS_ANDROID)
EXPECT_EQ(load_params.data_url_as_string, entry->GetDataURLAsString());
#endif
if (NavigationController::UA_OVERRIDE_INHERIT !=
load_params.override_user_agent) {
bool should_override = (NavigationController::UA_OVERRIDE_TRUE ==
load_params.override_user_agent);
EXPECT_EQ(should_override, entry->GetIsOverridingUserAgent());
}
EXPECT_EQ(load_params.post_data, entry->GetPostData());
EXPECT_EQ(load_params.reload_type, entry->reload_type());
}
TEST_F(NavigationControllerTest, LoadURLWithParams) {
// Start a navigation in order to have enough state to fake a transfer.
const GURL url1("http://foo");
const GURL url2("http://bar");
const GURL url3("http://foo/2");
contents()->NavigateAndCommit(url1);
auto navigation =
NavigationSimulator::CreateBrowserInitiated(url2, contents());
navigation->Start();
NavigationControllerImpl& controller = controller_impl();
auto navigation2 =
NavigationSimulatorImpl::CreateBrowserInitiated(url3, contents());
NavigationController::LoadURLParams load_url_params(url3);
load_url_params.initiator_origin = url::Origin::Create(url1);
load_url_params.referrer = Referrer(GURL("http://referrer"),
network::mojom::ReferrerPolicy::kDefault);
load_url_params.transition_type = ui::PAGE_TRANSITION_GENERATED;
load_url_params.extra_headers = "content-type: text/plain;\nX-Foo: Bar";
load_url_params.load_type = NavigationController::LOAD_TYPE_DEFAULT;
load_url_params.is_renderer_initiated = true;
load_url_params.override_user_agent = NavigationController::UA_OVERRIDE_TRUE;
navigation2->SetLoadURLParams(&load_url_params);
navigation2->Start();
NavigationEntryImpl* entry = controller.GetPendingEntry();
// The timestamp should not have been set yet.
ASSERT_TRUE(entry);
EXPECT_TRUE(entry->GetTimestamp().is_null());
CheckNavigationEntryMatchLoadParams(load_url_params, entry);
}
TEST_F(NavigationControllerTest, LoadURLWithParams_Reload) {
NavigationControllerImpl& controller = controller_impl();
GURL url("https://reload");
auto navigation =
NavigationSimulatorImpl::CreateBrowserInitiated(url, contents());
NavigationController::LoadURLParams load_url_params(url);
load_url_params.initiator_origin = url::Origin::Create(url);
load_url_params.referrer = Referrer(GURL("http://referrer"),
network::mojom::ReferrerPolicy::kDefault);
load_url_params.transition_type = ui::PAGE_TRANSITION_GENERATED;
load_url_params.extra_headers = "content-type: text/plain;\nX-Foo: Bar";
load_url_params.load_type = NavigationController::LOAD_TYPE_DEFAULT;
load_url_params.is_renderer_initiated = true;
load_url_params.override_user_agent = NavigationController::UA_OVERRIDE_TRUE;
load_url_params.reload_type = ReloadType::BYPASSING_CACHE;
navigation->SetLoadURLParams(&load_url_params);
navigation->Start();
NavigationEntryImpl* entry = controller.GetPendingEntry();
CheckNavigationEntryMatchLoadParams(load_url_params, entry);
}
TEST_F(NavigationControllerTest, LoadURLWithExtraParams_Data) {
NavigationControllerImpl& controller = controller_impl();
GURL url("data:text/html,dataurl");
auto navigation =
NavigationSimulatorImpl::CreateBrowserInitiated(url, contents());
NavigationController::LoadURLParams load_url_params(url);
load_url_params.load_type = NavigationController::LOAD_TYPE_DATA;
load_url_params.base_url_for_data_url = GURL("http://foo");
load_url_params.virtual_url_for_data_url = GURL(url::kAboutBlankURL);
load_url_params.override_user_agent = NavigationController::UA_OVERRIDE_FALSE;
navigation->SetLoadURLParams(&load_url_params);
navigation->Start();
NavigationEntryImpl* entry = controller.GetPendingEntry();
CheckNavigationEntryMatchLoadParams(load_url_params, entry);
}
#if defined(OS_ANDROID)
TEST_F(NavigationControllerTest, LoadURLWithExtraParams_Data_Android) {
NavigationControllerImpl& controller = controller_impl();
GURL url("data:,");
auto navigation =
NavigationSimulatorImpl::CreateBrowserInitiated(url, contents());
NavigationController::LoadURLParams load_url_params(url);
load_url_params.load_type = NavigationController::LOAD_TYPE_DATA;
load_url_params.base_url_for_data_url = GURL("http://foo");
load_url_params.virtual_url_for_data_url = GURL(url::kAboutBlankURL);
std::string s("data:,data");
load_url_params.data_url_as_string = base::RefCountedString::TakeString(&s);
load_url_params.override_user_agent = NavigationController::UA_OVERRIDE_FALSE;
navigation->SetLoadURLParams(&load_url_params);
navigation->Start();
NavigationEntryImpl* entry = controller.GetPendingEntry();
CheckNavigationEntryMatchLoadParams(load_url_params, entry);
}
#endif
TEST_F(NavigationControllerTest, LoadURLWithExtraParams_HttpPost) {
NavigationControllerImpl& controller = controller_impl();
GURL url("https://posturl");
auto navigation =
NavigationSimulatorImpl::CreateBrowserInitiated(url, contents());
NavigationController::LoadURLParams load_url_params(url);
load_url_params.transition_type = ui::PAGE_TRANSITION_TYPED;
load_url_params.load_type = NavigationController::LOAD_TYPE_HTTP_POST;
load_url_params.override_user_agent = NavigationController::UA_OVERRIDE_TRUE;
const char* raw_data = "d\n\0a2";
const int length = 5;
load_url_params.post_data =
network::ResourceRequestBody::CreateFromBytes(raw_data, length);
navigation->SetLoadURLParams(&load_url_params);
navigation->Start();
NavigationEntryImpl* entry = controller.GetPendingEntry();
CheckNavigationEntryMatchLoadParams(load_url_params, entry);
}
// Tests what happens when the same page is loaded again. Should not create a
// new session history entry. This is what happens when you press enter in the
// URL bar to reload: a pending entry is created and then it is discarded when
// the load commits (because WebCore didn't actually make a new entry).
TEST_F(NavigationControllerTest, LoadURL_SamePage) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo1");
auto navigation1 =
NavigationSimulator::CreateBrowserInitiated(url1, contents());
navigation1->Start();
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
navigation1->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
ASSERT_TRUE(controller.GetVisibleEntry());
const base::Time timestamp = controller.GetVisibleEntry()->GetTimestamp();
EXPECT_FALSE(timestamp.is_null());
const std::string new_extra_headers("Foo: Bar\nBar: Baz");
controller.LoadURL(
url1, Referrer(), ui::PAGE_TRANSITION_TYPED, new_extra_headers);
auto navigation2 = NavigationSimulator::CreateFromPending(contents());
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
navigation2->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// We should not have produced a new session history entry.
EXPECT_EQ(controller.GetEntryCount(), 1);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_FALSE(controller.GetPendingEntry());
ASSERT_TRUE(controller.GetVisibleEntry());
EXPECT_FALSE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoForward());
// The extra headers should have been updated.
std::string new_extra_headers_crlf;
base::ReplaceChars(new_extra_headers, "\n", "\r\n", &new_extra_headers_crlf);
EXPECT_EQ(new_extra_headers_crlf,
controller.GetVisibleEntry()->extra_headers());
// The timestamp should have been updated.
//
// TODO(akalin): Change this EXPECT_GE (and other similar ones) to
// EXPECT_GT once we guarantee that timestamps are unique.
EXPECT_GE(controller.GetVisibleEntry()->GetTimestamp(), timestamp);
}
// Load the same page twice, once as a GET and once as a POST.
// We should update the post state on the NavigationEntry.
TEST_F(NavigationControllerTest, LoadURL_SamePage_DifferentMethod) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo1");
auto navigation1 =
NavigationSimulatorImpl::CreateBrowserInitiated(url1, contents());
navigation1->SetIsPostWithId(123);
navigation1->Commit();
// The post data should be visible.
NavigationEntry* entry = controller.GetVisibleEntry();
ASSERT_TRUE(entry);
EXPECT_TRUE(entry->GetHasPostData());
EXPECT_EQ(entry->GetPostID(), 123);
auto navigation2 =
NavigationSimulatorImpl::CreateBrowserInitiated(url1, contents());
navigation2->set_did_create_new_entry(false);
navigation2->Commit();
// We should not have produced a new session history entry.
ASSERT_EQ(controller.GetVisibleEntry(), entry);
// The post data should have been cleared due to the GET.
EXPECT_FALSE(entry->GetHasPostData());
EXPECT_EQ(entry->GetPostID(), -1);
}
// Tests loading a URL but discarding it before the load commits.
TEST_F(NavigationControllerTest, LoadURL_Discarded) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo1");
const GURL url2("http://foo2");
auto navigation =
NavigationSimulator::CreateBrowserInitiated(url1, contents());
navigation->Start();
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
navigation->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
ASSERT_TRUE(controller.GetVisibleEntry());
const base::Time timestamp = controller.GetVisibleEntry()->GetTimestamp();
EXPECT_FALSE(timestamp.is_null());
controller.LoadURL(
url2, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
controller.DiscardNonCommittedEntries();
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
// Should not have produced a new session history entry.
EXPECT_EQ(controller.GetEntryCount(), 1);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_FALSE(controller.GetPendingEntry());
ASSERT_TRUE(controller.GetVisibleEntry());
EXPECT_FALSE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoForward());
// Timestamp should not have changed.
EXPECT_EQ(timestamp, controller.GetVisibleEntry()->GetTimestamp());
}
// Tests navigations that come in unrequested. This happens when the user
// navigates from the web page, and here we test that there is no pending entry.
TEST_F(NavigationControllerTest, LoadURL_NoPending) {
NavigationControllerImpl& controller = controller_impl();
// First make an existing committed entry.
const GURL kExistingURL1("http://eh");
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), kExistingURL1);
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// Do a new navigation without making a pending one.
const GURL kNewURL("http://see");
NavigationSimulator::NavigateAndCommitFromDocument(kNewURL, main_test_rfh());
// There should no longer be any pending entry, and the second navigation we
// just made should be committed.
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_EQ(-1, controller.GetPendingEntryIndex());
EXPECT_EQ(1, controller.GetLastCommittedEntryIndex());
EXPECT_EQ(kNewURL, controller.GetVisibleEntry()->GetURL());
}
// Tests navigating to a new URL when there is a new pending navigation that is
// not the one that just loaded. This will happen if the user types in a URL to
// somewhere slow, and then navigates the current page before the typed URL
// commits.
TEST_F(NavigationControllerTest, LoadURL_NewPending) {
NavigationControllerImpl& controller = controller_impl();
// First make an existing committed entry.
const GURL kExistingURL1("http://eh");
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), kExistingURL1);
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// Make a pending entry to somewhere new.
const GURL kExistingURL2("http://bee");
auto navigation =
NavigationSimulator::CreateBrowserInitiated(kExistingURL2, contents());
navigation->Start();
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
// After the beforeunload but before it commits...
navigation->ReadyToCommit();
// ... Do a new navigation.
const GURL kNewURL("http://see");
NavigationSimulator::NavigateAndCommitFromDocument(kNewURL, main_test_rfh());
// There should no longer be any pending entry, and the third navigation we
// just made should be committed.
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_EQ(-1, controller.GetPendingEntryIndex());
EXPECT_EQ(1, controller.GetLastCommittedEntryIndex());
EXPECT_EQ(kNewURL, controller.GetVisibleEntry()->GetURL());
}
// Tests navigating to a new URL when there is a pending back/forward
// navigation. This will happen if the user hits back, but before that commits,
// they navigate somewhere new.
TEST_F(NavigationControllerTest, LoadURL_ExistingPending) {
NavigationControllerImpl& controller = controller_impl();
// First make some history.
const GURL kExistingURL1("http://foo/eh");
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), kExistingURL1);
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// Simulate a user gesture so that the above entry is not marked to be skipped
// on back.
main_test_rfh()->frame_tree_node()->UpdateUserActivationState(
blink::UserActivationUpdateType::kNotifyActivation);
const GURL kExistingURL2("http://foo/bee");
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), kExistingURL2);
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// Now make a pending back/forward navigation. The zeroth entry should be
// pending.
controller.GoBack();
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
EXPECT_EQ(0, controller.GetPendingEntryIndex());
EXPECT_EQ(1, controller.GetLastCommittedEntryIndex());
// Before that commits, do a new navigation.
const GURL kNewURL("http://foo/see");
NavigationSimulator::NavigateAndCommitFromDocument(kNewURL, main_test_rfh());
// There should no longer be any pending entry, and the new navigation we
// just made should be committed.
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_EQ(-1, controller.GetPendingEntryIndex());
EXPECT_EQ(2, controller.GetLastCommittedEntryIndex());
EXPECT_EQ(kNewURL, controller.GetVisibleEntry()->GetURL());
}
// Tests navigating to a new URL when there is a pending back/forward
// navigation to a cross-process, privileged URL. This will happen if the user
// hits back, but before that commits, they navigate somewhere new.
TEST_F(NavigationControllerTest, LoadURL_PrivilegedPending) {
NavigationControllerImpl& controller = controller_impl();
// First make some history, starting with a privileged URL.
const GURL kExistingURL1("http://privileged");
auto navigation =
NavigationSimulator::CreateBrowserInitiated(kExistingURL1, contents());
navigation->Start();
navigation->ReadyToCommit();
// Pretend it has bindings so we can tell if we incorrectly copy it. This has
// to be done after ReadyToCommit, otherwise we won't use the current RFH to
// commit since its bindings don't match the URL.
main_test_rfh()->AllowBindings(BINDINGS_POLICY_MOJO_WEB_UI);
navigation->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_EQ(BINDINGS_POLICY_MOJO_WEB_UI,
controller.GetLastCommittedEntry()->bindings());
// Simulate a user gesture so that the above entry is not marked to be skipped
// on back.
main_test_rfh()->frame_tree_node()->UpdateUserActivationState(
blink::UserActivationUpdateType::kNotifyActivation);
// Navigate cross-process to a second URL.
const GURL kExistingURL2("http://foo/eh");
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), kExistingURL2);
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_EQ(0, controller.GetLastCommittedEntry()->bindings());
// Now make a pending back/forward navigation to a privileged entry.
// The zeroth entry should be pending.
auto back_navigation =
NavigationSimulator::CreateHistoryNavigation(-1, contents());
back_navigation->ReadyToCommit();
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
EXPECT_EQ(0, controller.GetPendingEntryIndex());
EXPECT_EQ(1, controller.GetLastCommittedEntryIndex());
EXPECT_EQ(BINDINGS_POLICY_MOJO_WEB_UI,
controller.GetPendingEntry()->bindings());
// Before that commits, do a new navigation.
const GURL kNewURL("http://foo/bee");
NavigationSimulator::NavigateAndCommitFromDocument(kNewURL, main_test_rfh());
// There should no longer be any pending entry, and the new navigation we
// just made should be committed.
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_EQ(-1, controller.GetPendingEntryIndex());
EXPECT_EQ(2, controller.GetLastCommittedEntryIndex());
EXPECT_EQ(kNewURL, controller.GetVisibleEntry()->GetURL());
EXPECT_EQ(0, controller.GetLastCommittedEntry()->bindings());
}
// Tests navigating to an existing URL when there is a pending new navigation.
// This will happen if the user enters a URL, but before that commits, the
// current page fires history.back().
TEST_F(NavigationControllerTest, LoadURL_BackPreemptsPending) {
NavigationControllerImpl& controller = controller_impl();
// First make some history.
const GURL kExistingURL1("http://foo/eh");
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), kExistingURL1);
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
const GURL kExistingURL2("http://foo/bee");
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), kExistingURL2);
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// A back navigation comes in from the renderer...
auto back_navigation =
NavigationSimulator::CreateHistoryNavigation(-1, contents());
back_navigation->ReadyToCommit();
// ...while the user tries to navigate to a new page...
const GURL kNewURL("http://foo/see");
auto new_navigation =
NavigationSimulator::CreateBrowserInitiated(kNewURL, contents());
new_navigation->Start();
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
EXPECT_EQ(-1, controller.GetPendingEntryIndex());
EXPECT_EQ(1, controller.GetLastCommittedEntryIndex());
// ...and the back navigation commits.
back_navigation->Commit();
// There should no longer be any pending entry, and the back navigation should
// be committed.
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_EQ(-1, controller.GetPendingEntryIndex());
EXPECT_EQ(0, controller.GetLastCommittedEntryIndex());
EXPECT_EQ(kExistingURL1, controller.GetVisibleEntry()->GetURL());
}
// Verify that a direct commit message from the renderer properly cancels a
// pending new navigation. This will happen if the user enters a URL, but
// before that commits, the current blank page reloads.
// Original bug: http://crbug.com/77507.
TEST_F(NavigationControllerTest, LoadURL_IgnorePreemptsPending) {
NavigationControllerImpl& controller = controller_impl();
// Set a WebContentsDelegate to listen for state changes.
std::unique_ptr<TestWebContentsDelegate> delegate(
new TestWebContentsDelegate());
EXPECT_FALSE(contents()->GetDelegate());
contents()->SetDelegate(delegate.get());
// Without any navigations, the renderer starts at about:blank.
const GURL kExistingURL(url::kAboutBlankURL);
// Now make a pending new navigation.
const GURL kNewURL("http://eh");
auto navigation =
NavigationSimulator::CreateBrowserInitiated(kNewURL, contents());
navigation->Start();
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
EXPECT_EQ(-1, controller.GetPendingEntryIndex());
EXPECT_TRUE(controller.GetPendingEntry());
EXPECT_EQ(-1, controller.GetLastCommittedEntryIndex());
EXPECT_EQ(1, delegate->navigation_state_change_count());
// Certain rare cases can make a direct DidCommitProvisionalLoad call without
// going to the browser. Renderer reload of an about:blank is such a case.
main_test_rfh()->SendNavigate(0, false, kExistingURL);
// This should clear the pending entry and notify of a navigation state
// change, so that we do not keep displaying kNewURL.
EXPECT_EQ(-1, controller.GetPendingEntryIndex());
EXPECT_FALSE(controller.GetPendingEntry());
EXPECT_EQ(-1, controller.GetLastCommittedEntryIndex());
EXPECT_EQ(2, delegate->navigation_state_change_count());
contents()->SetDelegate(nullptr);
}
// Tests that the pending entry state is correct after an abort.
// We do not want to clear the pending entry, so that the user doesn't
// lose a typed URL. (See http://crbug.com/9682.)
TEST_F(NavigationControllerTest, LoadURL_AbortDoesntCancelPending) {
NavigationControllerImpl& controller = controller_impl();
// Set a WebContentsDelegate to listen for state changes.
std::unique_ptr<TestWebContentsDelegate> delegate(
new TestWebContentsDelegate());
EXPECT_FALSE(contents()->GetDelegate());
contents()->SetDelegate(delegate.get());
// Start with a pending new navigation.
const GURL kNewURL("http://eh");
controller.LoadURL(
kNewURL, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
main_test_rfh()->PrepareForCommit();
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
EXPECT_EQ(-1, controller.GetPendingEntryIndex());
EXPECT_TRUE(controller.GetPendingEntry());
EXPECT_EQ(-1, controller.GetLastCommittedEntryIndex());
EXPECT_EQ(1, delegate->navigation_state_change_count());
// It may abort before committing, if it's a download or due to a stop or
// a new navigation from the user.
main_test_rfh()->DidFailProvisionalLoadWithError(kNewURL, net::ERR_ABORTED,
base::string16(), false);
// This should not clear the pending entry or notify of a navigation state
// change, so that we keep displaying kNewURL (until the user clears it).
EXPECT_EQ(-1, controller.GetPendingEntryIndex());
EXPECT_TRUE(controller.GetPendingEntry());
EXPECT_EQ(-1, controller.GetLastCommittedEntryIndex());
EXPECT_EQ(1, delegate->navigation_state_change_count());
NavigationEntry* pending_entry = controller.GetPendingEntry();
// Ensure that a reload keeps the same pending entry.
controller.Reload(ReloadType::NORMAL, true);
EXPECT_EQ(-1, controller.GetPendingEntryIndex());
EXPECT_TRUE(controller.GetPendingEntry());
EXPECT_EQ(pending_entry, controller.GetPendingEntry());
EXPECT_EQ(-1, controller.GetLastCommittedEntryIndex());
contents()->SetDelegate(nullptr);
}
// Tests that the pending URL is not visible during a renderer-initiated
// redirect and abort. See http://crbug.com/83031.
TEST_F(NavigationControllerTest, LoadURL_RedirectAbortDoesntShowPendingURL) {
NavigationControllerImpl& controller = controller_impl();
// First make an existing committed entry.
const GURL kExistingURL("http://foo/eh");
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), kExistingURL);
main_test_rfh()->OnMessageReceived(FrameHostMsg_DidStopLoading(0));
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// Set a WebContentsDelegate to listen for state changes.
std::unique_ptr<TestWebContentsDelegate> delegate(
new TestWebContentsDelegate());
EXPECT_FALSE(contents()->GetDelegate());
contents()->SetDelegate(delegate.get());
// Now make a pending new navigation, initiated by the renderer.
const GURL kNewURL("http://foo/bee");
auto navigation =
NavigationSimulator::CreateRendererInitiated(kNewURL, main_test_rfh());
navigation->Start();
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
EXPECT_EQ(-1, controller.GetPendingEntryIndex());
EXPECT_TRUE(controller.GetPendingEntry());
EXPECT_EQ(0, controller.GetLastCommittedEntryIndex());
// The delegate should have been notified twice: once for the loading state
// change, and once for the url change.
EXPECT_EQ(2, delegate->navigation_state_change_count());
// The visible entry should be the last committed URL, not the pending one.
EXPECT_EQ(kExistingURL, controller.GetVisibleEntry()->GetURL());
// Now the navigation redirects.
const GURL kRedirectURL("http://foo/see");
navigation->Redirect(kRedirectURL);
// We don't want to change the NavigationEntry's url, in case it cancels.
// Prevents regression of http://crbug.com/77786.
EXPECT_EQ(kNewURL, controller.GetPendingEntry()->GetURL());
// It may abort before committing, if it's a download or due to a stop or
// a new navigation from the user.
navigation->Fail(net::ERR_ABORTED);
// Because the pending entry is renderer initiated and not visible, we
// clear it when it fails.
EXPECT_EQ(-1, controller.GetPendingEntryIndex());
EXPECT_FALSE(controller.GetPendingEntry());
EXPECT_EQ(0, controller.GetLastCommittedEntryIndex());
// The delegate should have been notified twice: once for the loading state
// change, and once for the url change.
EXPECT_EQ(4, delegate->navigation_state_change_count());
// The visible entry should be the last committed URL, not the pending one,
// so that no spoof is possible.
EXPECT_EQ(kExistingURL, controller.GetVisibleEntry()->GetURL());
contents()->SetDelegate(nullptr);
}
// Ensure that NavigationEntries track which bindings their RenderViewHost had
// at the time they committed. http://crbug.com/173672.
TEST_F(NavigationControllerTest, LoadURL_WithBindings) {
NavigationControllerImpl& controller = controller_impl();
std::vector<GURL> url_chain;
const GURL url1("http://foo1");
const GURL url2("http://foo2");
// Navigate to a first, unprivileged URL.
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), url1);
EXPECT_EQ(controller.GetEntryCount(), 1);
EXPECT_EQ(0, controller.GetLastCommittedEntryIndex());
EXPECT_EQ(0, controller.GetLastCommittedEntry()->bindings());
// Manually increase the number of active frames in the SiteInstance
// that orig_rfh belongs to, to prevent it from being destroyed when
// it gets swapped out, so that we can reuse orig_rfh when the
// controller goes back.
main_test_rfh()->GetSiteInstance()->IncrementActiveFrameCount();
// Navigate to a second URL, simulate the beforeunload ack for the cross-site
// transition, and set bindings on the pending RenderFrameHost to simulate a
// privileged url.
auto navigation =
NavigationSimulator::CreateBrowserInitiated(url2, contents());
navigation->ReadyToCommit();
TestRenderFrameHost* new_rfh = contents()->GetPendingMainFrame();
new_rfh->AllowBindings(BINDINGS_POLICY_WEB_UI);
navigation->Commit();
// The second load should be committed, and bindings should be remembered.
EXPECT_EQ(controller.GetEntryCount(), 2);
EXPECT_EQ(1, controller.GetLastCommittedEntryIndex());
EXPECT_TRUE(controller.CanGoBack());
EXPECT_EQ(1, controller.GetLastCommittedEntry()->bindings());
// Going back, the first entry should still appear unprivileged.
NavigationSimulator::GoBack(contents());
EXPECT_EQ(0, controller.GetLastCommittedEntryIndex());
EXPECT_EQ(0, controller.GetLastCommittedEntry()->bindings());
}
TEST_F(NavigationControllerTest, Reload) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo1");
auto navigation =
NavigationSimulator::CreateBrowserInitiated(url1, contents());
navigation->Start();
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
navigation->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
ASSERT_TRUE(controller.GetVisibleEntry());
controller.Reload(ReloadType::NORMAL, true);
navigation = NavigationSimulator::CreateFromPending(
RenderViewHostTestHarness::web_contents());
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
const base::Time timestamp = controller.GetVisibleEntry()->GetTimestamp();
EXPECT_FALSE(timestamp.is_null());
// The reload is pending.
EXPECT_EQ(controller.GetEntryCount(), 1);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
EXPECT_EQ(controller.GetPendingEntryIndex(), 0);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_TRUE(controller.GetPendingEntry());
EXPECT_FALSE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoForward());
navigation->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// Now the reload is committed.
EXPECT_EQ(controller.GetEntryCount(), 1);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_FALSE(controller.GetPendingEntry());
EXPECT_FALSE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoForward());
// The timestamp should have been updated.
ASSERT_TRUE(controller.GetVisibleEntry());
EXPECT_GE(controller.GetVisibleEntry()->GetTimestamp(), timestamp);
}
// Tests what happens when a reload navigation produces a new page.
TEST_F(NavigationControllerTest, Reload_GeneratesNewPage) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo1");
const GURL url2("http://foo2");
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), url1);
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
controller.Reload(ReloadType::NORMAL, true);
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
auto reload = NavigationSimulator::CreateFromPending(contents());
reload->Redirect(url2);
reload->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// Now the reload is committed.
EXPECT_EQ(controller.GetEntryCount(), 1);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_FALSE(controller.GetPendingEntry());
EXPECT_FALSE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoForward());
}
// This test ensures that when a guest renderer reloads, the reload goes through
// without ending up in the "we have a wrong process for the URL" branch in
// NavigationControllerImpl::ReloadInternal.
TEST_F(NavigationControllerTest, ReloadWithGuest) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo1");
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), url1);
ASSERT_TRUE(controller.GetVisibleEntry());
// Make the entry believe its RenderProcessHost is a guest.
NavigationEntryImpl* entry1 = controller.GetVisibleEntry();
reinterpret_cast<MockRenderProcessHost*>(
entry1->site_instance()->GetProcess())->set_is_for_guests_only(true);
// And reload.
controller.Reload(ReloadType::NORMAL, true);
// The reload is pending. Check that the NavigationEntry didn't get replaced
// because of having the wrong process.
EXPECT_EQ(controller.GetEntryCount(), 1);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
EXPECT_EQ(controller.GetPendingEntryIndex(), 0);
NavigationEntryImpl* entry2 = controller.GetPendingEntry();
EXPECT_EQ(entry1, entry2);
}
TEST_F(NavigationControllerTest, ReloadOriginalRequestURL) {
NavigationControllerImpl& controller = controller_impl();
const GURL original_url("http://foo1");
const GURL final_url("http://foo2");
// Load up the original URL, but get redirected.
auto navigation =
NavigationSimulator::CreateBrowserInitiated(original_url, contents());
navigation->Start();
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
navigation->Redirect(final_url);
navigation->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// The NavigationEntry should save both the original URL and the final
// redirected URL.
EXPECT_EQ(
original_url, controller.GetVisibleEntry()->GetOriginalRequestURL());
EXPECT_EQ(final_url, controller.GetVisibleEntry()->GetURL());
// Reload using the original URL.
controller.Reload(ReloadType::ORIGINAL_REQUEST_URL, false);
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
// The reload is pending. The request should point to the original URL.
EXPECT_EQ(original_url, navigated_url());
EXPECT_EQ(controller.GetEntryCount(), 1);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
EXPECT_EQ(controller.GetPendingEntryIndex(), 0);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_TRUE(controller.GetPendingEntry());
EXPECT_FALSE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoForward());
// Send that the navigation has proceeded; say it got redirected again.
navigation = NavigationSimulator::CreateFromPending(
RenderViewHostTestHarness::web_contents());
navigation->Redirect(final_url);
navigation->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// Now the reload is committed.
EXPECT_EQ(controller.GetEntryCount(), 1);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_FALSE(controller.GetPendingEntry());
EXPECT_FALSE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoForward());
}
// Test that certain non-persisted NavigationEntryImpl values get reset after
// commit.
TEST_F(NavigationControllerTest, ResetEntryValuesAfterCommit) {
NavigationControllerImpl& controller = controller_impl();
// The value of "should replace entry" will be tested, but it's an error to
// specify it when there are no entries. Create a simple entry to be replaced.
const GURL url0("http://foo/0");
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), url0);
// Set up the pending entry.
const GURL url1("http://foo/1");
auto navigation =
NavigationSimulatorImpl::CreateBrowserInitiated(url1, contents());
navigation->Start();
// Set up some sample values.
const char* raw_data = "post\n\n\0data";
const int length = 11;
// Set non-persisted values on the pending entry.
NavigationEntryImpl* pending_entry = controller.GetPendingEntry();
pending_entry->SetPostData(
network::ResourceRequestBody::CreateFromBytes(raw_data, length));
pending_entry->set_is_renderer_initiated(true);
pending_entry->set_should_replace_entry(true);
pending_entry->set_should_clear_history_list(true);
EXPECT_TRUE(pending_entry->GetPostData());
EXPECT_TRUE(pending_entry->is_renderer_initiated());
EXPECT_TRUE(pending_entry->should_replace_entry());
EXPECT_TRUE(pending_entry->should_clear_history_list());
// Fake a commit response.
navigation->set_should_replace_current_entry(true);
navigation->Commit();
// Certain values that are only used for pending entries get reset after
// commit.
NavigationEntryImpl* committed_entry = controller.GetLastCommittedEntry();
EXPECT_FALSE(committed_entry->GetPostData());
EXPECT_FALSE(committed_entry->is_renderer_initiated());
EXPECT_FALSE(committed_entry->should_replace_entry());
EXPECT_FALSE(committed_entry->should_clear_history_list());
}
namespace {
void SetRedirects(const std::vector<GURL>& redirects,
FrameHostMsg_DidCommitProvisionalLoad_Params* params) {
params->redirects = redirects;
}
}
// Test that Redirects are preserved after a commit.
TEST_F(NavigationControllerTest, RedirectsAreNotResetByCommit) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo1");
const GURL url2("http://foo2");
auto navigation =
NavigationSimulator::CreateBrowserInitiated(url1, contents());
navigation->Start();
// Set up some redirect values.
std::vector<GURL> redirects;
redirects.push_back(url2);
auto set_redirects_callback = base::Bind(SetRedirects, redirects);
// Set redirects on the pending entry.
NavigationEntryImpl* pending_entry = controller.GetPendingEntry();
pending_entry->SetRedirectChain(redirects);
EXPECT_EQ(1U, pending_entry->GetRedirectChain().size());
EXPECT_EQ(url2, pending_entry->GetRedirectChain()[0]);
// Normal navigation will preserve redirects in the committed entry.
navigation->Redirect(url2);
navigation->Commit();
NavigationEntryImpl* committed_entry = controller.GetLastCommittedEntry();
ASSERT_EQ(1U, committed_entry->GetRedirectChain().size());
EXPECT_EQ(url2, committed_entry->GetRedirectChain()[0]);
}
// Tests that webkit preferences are updated when user agent override changes.
TEST_F(NavigationControllerTest, GoBackWithUserAgentOverrideChange) {
NavigationControllerImpl& controller = controller_impl();
// Set up a simple NavigationEntry stack of two pages.
const GURL url1("http://foo/1");
const GURL url2("http://foo/2");
auto navigation1 =
NavigationSimulator::CreateBrowserInitiated(url1, contents());
navigation1->Start();
EXPECT_FALSE(controller.GetPendingEntry()->GetIsOverridingUserAgent());
navigation1->Commit();
auto navigation2 =
NavigationSimulator::CreateBrowserInitiated(url2, contents());
navigation2->Start();
EXPECT_FALSE(controller.GetPendingEntry()->GetIsOverridingUserAgent());
navigation2->Commit();
// Simulate the behavior of "Request Desktop Site" being checked in
// NavigationControllerAndroid::SetUseDesktopUserAgent.
controller.GetVisibleEntry()->SetIsOverridingUserAgent(true);
controller.Reload(ReloadType::ORIGINAL_REQUEST_URL, true);
auto reload = NavigationSimulator::CreateFromPending(contents());
reload->Commit();
EXPECT_TRUE(controller.GetLastCommittedEntry()->GetIsOverridingUserAgent());
// Test that OnWebkitPreferencesChanged is called when going back to propagate
// change in viewport_meta WebSetting.
int change_counter = 0;
test_rvh()->set_webkit_preferences_changed_counter(&change_counter);
auto back_navigation =
NavigationSimulator::CreateHistoryNavigation(-1, contents());
back_navigation->Start();
EXPECT_FALSE(controller.GetPendingEntry()->GetIsOverridingUserAgent());
back_navigation->Commit();
EXPECT_EQ(1, change_counter);
}
// Tests what happens when we navigate back successfully
TEST_F(NavigationControllerTest, Back) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo1");
NavigationSimulator::NavigateAndCommitFromDocument(url1, main_test_rfh());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
const GURL url2("http://foo2");
NavigationSimulator::NavigateAndCommitFromDocument(url2, main_test_rfh());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
auto back_navigation =
NavigationSimulator::CreateHistoryNavigation(-1, contents());
back_navigation->Start();
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
// We should now have a pending navigation to go back.
EXPECT_EQ(controller.GetEntryCount(), 2);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 1);
EXPECT_EQ(controller.GetPendingEntryIndex(), 0);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_TRUE(controller.GetPendingEntry());
EXPECT_FALSE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoToOffset(-1));
EXPECT_TRUE(controller.CanGoForward());
EXPECT_TRUE(controller.CanGoToOffset(1));
EXPECT_FALSE(controller.CanGoToOffset(2)); // Cannot go forward 2 steps.
// Timestamp for entry 1 should be on or after that of entry 0.
EXPECT_FALSE(controller.GetEntryAtIndex(0)->GetTimestamp().is_null());
EXPECT_GE(controller.GetEntryAtIndex(1)->GetTimestamp(),
controller.GetEntryAtIndex(0)->GetTimestamp());
back_navigation->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// The back navigation completed successfully.
EXPECT_EQ(controller.GetEntryCount(), 2);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_FALSE(controller.GetPendingEntry());
EXPECT_FALSE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoToOffset(-1));
EXPECT_TRUE(controller.CanGoForward());
EXPECT_TRUE(controller.CanGoToOffset(1));
EXPECT_FALSE(controller.CanGoToOffset(2)); // Cannot go foward 2 steps.
// Timestamp for entry 0 should be on or after that of entry 1
// (since we went back to it).
EXPECT_GE(controller.GetEntryAtIndex(0)->GetTimestamp(),
controller.GetEntryAtIndex(1)->GetTimestamp());
}
// Tests what happens when a back navigation produces a new page.
TEST_F(NavigationControllerTest, Back_GeneratesNewPage) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo/1");
const GURL url2("http://foo/2");
const GURL url3("http://foo/3");
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), url1);
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), url2);
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
auto navigation =
NavigationSimulator::CreateHistoryNavigation(-1, contents());
navigation->Start();
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
// We should now have a pending navigation to go back.
EXPECT_EQ(controller.GetEntryCount(), 2);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 1);
EXPECT_EQ(controller.GetPendingEntryIndex(), 0);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_TRUE(controller.GetPendingEntry());
EXPECT_FALSE(controller.CanGoBack());
EXPECT_TRUE(controller.CanGoForward());
navigation->Redirect(url3);
navigation->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// The first NavigationEntry should have been used.
EXPECT_EQ(controller.GetEntryCount(), 2);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_FALSE(controller.GetPendingEntry());
EXPECT_FALSE(controller.CanGoBack());
EXPECT_TRUE(controller.CanGoForward());
}
// Receives a back message when there is a new pending navigation entry.
TEST_F(NavigationControllerTest, Back_NewPending) {
NavigationControllerImpl& controller = controller_impl();
const GURL kUrl1("http://foo1");
const GURL kUrl2("http://foo2");
const GURL kUrl3("http://foo3");
// First navigate two places so we have some back history.
NavigationSimulator::NavigateAndCommitFromDocument(kUrl1, main_test_rfh());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// Simulate a user gesture so that the above entry is not marked to be skipped
// on back.
main_test_rfh()->frame_tree_node()->UpdateUserActivationState(
blink::UserActivationUpdateType::kNotifyActivation);
// controller.LoadURL(kUrl2, ui::PAGE_TRANSITION_TYPED);
NavigationSimulator::NavigateAndCommitFromDocument(kUrl2, main_test_rfh());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// Now start a new pending navigation and go back before it commits.
controller.LoadURL(
kUrl3, Referrer(), ui::PAGE_TRANSITION_TYPED, std::string());
EXPECT_EQ(-1, controller.GetPendingEntryIndex());
EXPECT_EQ(kUrl3, controller.GetPendingEntry()->GetURL());
controller.GoBack();
// The pending navigation should now be the "back" item and the new one
// should be gone.
EXPECT_EQ(0, controller.GetPendingEntryIndex());
EXPECT_EQ(kUrl1, controller.GetPendingEntry()->GetURL());
}
// Tests what happens when we navigate forward successfully.
TEST_F(NavigationControllerTest, Forward) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo1");
const GURL url2("http://foo2");
NavigationSimulator::NavigateAndCommitFromDocument(url1, main_test_rfh());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
NavigationSimulator::NavigateAndCommitFromDocument(url2, main_test_rfh());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
NavigationSimulator::GoBack(contents());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
auto forward_navigation =
NavigationSimulator::CreateHistoryNavigation(1, contents());
forward_navigation->Start();
// We should now have a pending navigation to go forward.
EXPECT_EQ(controller.GetEntryCount(), 2);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
EXPECT_EQ(controller.GetPendingEntryIndex(), 1);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_TRUE(controller.GetPendingEntry());
EXPECT_TRUE(controller.CanGoBack());
EXPECT_TRUE(controller.CanGoToOffset(-1));
EXPECT_FALSE(controller.CanGoToOffset(-2)); // Cannot go back 2 steps.
EXPECT_FALSE(controller.CanGoForward());
EXPECT_FALSE(controller.CanGoToOffset(1));
// Timestamp for entry 0 should be on or after that of entry 1
// (since we went back to it).
EXPECT_FALSE(controller.GetEntryAtIndex(0)->GetTimestamp().is_null());
EXPECT_GE(controller.GetEntryAtIndex(0)->GetTimestamp(),
controller.GetEntryAtIndex(1)->GetTimestamp());
forward_navigation->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// The forward navigation completed successfully.
EXPECT_EQ(controller.GetEntryCount(), 2);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 1);
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_FALSE(controller.GetPendingEntry());
EXPECT_TRUE(controller.CanGoBack());
EXPECT_TRUE(controller.CanGoToOffset(-1));
EXPECT_FALSE(controller.CanGoToOffset(-2)); // Cannot go back 2 steps.
EXPECT_FALSE(controller.CanGoForward());
EXPECT_FALSE(controller.CanGoToOffset(1));
// Timestamp for entry 1 should be on or after that of entry 0
// (since we went forward to it).
EXPECT_GE(controller.GetEntryAtIndex(1)->GetTimestamp(),
controller.GetEntryAtIndex(0)->GetTimestamp());
}
// Tests what happens when a forward navigation produces a new page.
TEST_F(NavigationControllerTest, Forward_GeneratesNewPage) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo1");
const GURL url2("http://foo2");
const GURL url3("http://foo3");
NavigationSimulator::NavigateAndCommitFromDocument(url1, main_test_rfh());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
NavigationSimulator::NavigateAndCommitFromDocument(url2, main_test_rfh());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
NavigationSimulator::GoBack(contents());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
auto forward_navigation =
NavigationSimulator::CreateHistoryNavigation(1, contents());
forward_navigation->Start();
EXPECT_EQ(0U, navigation_list_pruned_counter_);
// Should now have a pending navigation to go forward.
EXPECT_EQ(controller.GetEntryCount(), 2);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
EXPECT_EQ(controller.GetPendingEntryIndex(), 1);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_TRUE(controller.GetPendingEntry());
EXPECT_TRUE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoForward());
forward_navigation->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_EQ(0U, navigation_list_pruned_counter_);
EXPECT_EQ(controller.GetEntryCount(), 2);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 1);
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_FALSE(controller.GetPendingEntry());
EXPECT_TRUE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoForward());
}
// Two consecutive navigations for the same URL entered in should be considered
// as SAME_PAGE navigation even when we are redirected to some other page.
TEST_F(NavigationControllerTest, Redirect) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo1");
const GURL url2("http://foo2"); // Redirection target
// First request.
auto navigation =
NavigationSimulatorImpl::CreateBrowserInitiated(url1, contents());
navigation->Start();
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
navigation->Redirect(url2);
navigation->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// Second request.
auto navigation2 =
NavigationSimulatorImpl::CreateBrowserInitiated(url1, contents());
navigation2->Start();
EXPECT_TRUE(controller.GetPendingEntry());
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_EQ(url1, controller.GetVisibleEntry()->GetURL());
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
LoadCommittedDetailsObserver observer(contents());
navigation2->set_did_create_new_entry(false);
navigation2->Redirect(url2);
navigation2->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_EQ(NAVIGATION_TYPE_SAME_PAGE, observer.navigation_type());
EXPECT_EQ(controller.GetEntryCount(), 1);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_FALSE(controller.GetPendingEntry());
EXPECT_EQ(url2, controller.GetVisibleEntry()->GetURL());
EXPECT_FALSE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoForward());
}
// Similar to Redirect above, but the first URL is requested by POST,
// the second URL is requested by GET. NavigationEntry::has_post_data_
// must be cleared. http://crbug.com/21245
TEST_F(NavigationControllerTest, PostThenRedirect) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo1");
const GURL url2("http://foo2"); // Redirection target
// First request as POST.
auto navigation =
NavigationSimulatorImpl::CreateBrowserInitiated(url1, contents());
navigation->SetMethod("POST");
navigation->Start();
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
navigation->Redirect(url2);
navigation->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// Second request.
auto navigation2 =
NavigationSimulatorImpl::CreateBrowserInitiated(url1, contents());
navigation2->Start();
EXPECT_TRUE(controller.GetPendingEntry());
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_EQ(url1, controller.GetVisibleEntry()->GetURL());
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
LoadCommittedDetailsObserver observer(contents());
navigation2->set_did_create_new_entry(false);
navigation2->Redirect(GURL("http://foo2"));
navigation2->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_EQ(NAVIGATION_TYPE_SAME_PAGE, observer.navigation_type());
EXPECT_EQ(controller.GetEntryCount(), 1);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_FALSE(controller.GetPendingEntry());
EXPECT_EQ(url2, controller.GetVisibleEntry()->GetURL());
EXPECT_FALSE(controller.GetVisibleEntry()->GetHasPostData());
EXPECT_FALSE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoForward());
}
// A redirect right off the bat should be a NEW_PAGE.
TEST_F(NavigationControllerTest, ImmediateRedirect) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo1");
const GURL url2("http://foo2"); // Redirection target
// First request
auto navigation =
NavigationSimulatorImpl::CreateBrowserInitiated(url1, contents());
navigation->Start();
EXPECT_TRUE(controller.GetPendingEntry());
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_EQ(url1, controller.GetVisibleEntry()->GetURL());
EXPECT_EQ(0U, navigation_entry_changed_counter_);
EXPECT_EQ(0U, navigation_list_pruned_counter_);
LoadCommittedDetailsObserver observer(contents());
navigation->Redirect(GURL("http://foo2"));
navigation->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_EQ(NAVIGATION_TYPE_NEW_PAGE, observer.navigation_type());
EXPECT_EQ(controller.GetEntryCount(), 1);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 0);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_FALSE(controller.GetPendingEntry());
EXPECT_EQ(url2, controller.GetVisibleEntry()->GetURL());
EXPECT_FALSE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoForward());
}
// If something is pumping the event loop in the browser process and is loading
// pages rapidly one after the other, there can be a race with two closely-
// spaced load requests. Once the first load request is sent, will the renderer
// be fast enough to get the load committed, send a DidCommitProvisionalLoad
// IPC, and have the browser process handle that IPC before the caller makes
// another load request, replacing the pending entry of the first request?
//
// This test is about what happens in such a race when that pending entry
// replacement happens. If it happens, and the first load had the same URL as
// the page before it, we must make sure that the replacement of the pending
// entry correctly turns a SAME_PAGE classification into an EXISTING_PAGE one.
//
// (This is a unit test rather than a browser test because it's not currently
// possible to force this sequence of events with a browser test.)
TEST_F(NavigationControllerTest,
NavigationTypeClassification_ExistingPageRace) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo1");
const GURL url2("http://foo2");
// Start with a loaded page.
NavigationSimulator::NavigateAndCommitFromDocument(url1, main_test_rfh());
EXPECT_EQ(nullptr, controller_impl().GetPendingEntry());
// Start a load of the same page again.
auto navigation1 =
NavigationSimulatorImpl::CreateBrowserInitiated(url1, contents());
navigation1->ReadyToCommit();
int entry_id1 = controller.GetPendingEntry()->GetUniqueID();
// Before it can commit, start loading a different page...
auto navigation2 =
NavigationSimulator::CreateBrowserInitiated(url2, contents());
navigation2->ReadyToCommit();
int entry_id2 = controller.GetPendingEntry()->GetUniqueID();
EXPECT_NE(entry_id1, entry_id2);
// ... and now the renderer sends a commit for the first navigation.
LoadCommittedDetailsObserver observer(contents());
navigation1->set_intended_as_new_entry(true);
navigation1->Commit();
EXPECT_EQ(NAVIGATION_TYPE_EXISTING_PAGE, observer.navigation_type());
}
// Tests navigation via link click within a subframe. A new navigation entry
// should be created.
TEST_F(NavigationControllerTest, NewSubframe) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo1");
NavigationSimulator::NavigateAndCommitFromDocument(url1, main_test_rfh());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// Prereq: add a subframe with an initial auto-subframe navigation.
const GURL subframe_url("http://foo1/subframe");
TestRenderFrameHost* subframe = main_test_rfh()->AppendChild("subframe");
NavigationSimulator::NavigateAndCommitFromDocument(subframe_url, subframe);
EXPECT_EQ(1u, navigation_entry_changed_counter_);
// Now do a new navigation in the frame.
const GURL url2("http://foo2");
LoadCommittedDetailsObserver observer(contents());
NavigationSimulator::NavigateAndCommitFromDocument(url2, subframe);
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_EQ(url1, observer.previous_url());
EXPECT_FALSE(observer.is_same_document());
EXPECT_FALSE(observer.is_main_frame());
// The new entry should be appended.
NavigationEntryImpl* entry = controller.GetLastCommittedEntry();
EXPECT_EQ(2, controller.GetEntryCount());
// New entry should refer to the new page, but the old URL (entries only
// reflect the toplevel URL).
EXPECT_EQ(url1, entry->GetURL());
// The entry should have a subframe FrameNavigationEntry.
ASSERT_EQ(1U, entry->root_node()->children.size());
EXPECT_EQ(url2, entry->root_node()->children[0]->frame_entry->url());
}
// Auto subframes are ones the page loads automatically like ads. They should
// not create new navigation entries.
// TODO(creis): Test updating entries for history auto subframe navigations.
TEST_F(NavigationControllerTest, AutoSubframe) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo/1");
NavigationSimulator::NavigateAndCommitFromDocument(url1, main_test_rfh());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
constexpr auto kOwnerType = blink::FrameOwnerElementType::kIframe;
// Add a subframe and navigate it.
std::string unique_name0("uniqueName0");
main_test_rfh()->OnCreateChildFrame(
process()->GetNextRoutingID(),
TestRenderFrameHost::CreateStubInterfaceProviderRequest(),
TestRenderFrameHost::CreateStubDocumentInterfaceBrokerReceiver(),
TestRenderFrameHost::CreateStubDocumentInterfaceBrokerReceiver(),
TestRenderFrameHost::CreateStubBrowserInterfaceBrokerReceiver(),
blink::WebTreeScopeType::kDocument, std::string(), unique_name0, false,
base::UnguessableToken::Create(), blink::FramePolicy(),
FrameOwnerProperties(), kOwnerType);
TestRenderFrameHost* subframe = static_cast<TestRenderFrameHost*>(
contents()->GetFrameTree()->root()->child_at(0)->current_frame_host());
const GURL url2("http://foo/2");
{
// Navigating should do nothing.
auto subframe_navigation =
NavigationSimulator::CreateRendererInitiated(url2, subframe);
subframe_navigation->SetTransition(ui::PAGE_TRANSITION_AUTO_SUBFRAME);
subframe_navigation->Commit();
// We notify of a PageState update here rather than during UpdateState for
// auto subframe navigations.
EXPECT_EQ(1u, navigation_entry_changed_counter_);
navigation_entry_changed_counter_ = 0;
}
// There should still be only one entry.
EXPECT_EQ(1, controller.GetEntryCount());
NavigationEntryImpl* entry = controller.GetLastCommittedEntry();
EXPECT_EQ(url1, entry->GetURL());
FrameNavigationEntry* root_entry = entry->root_node()->frame_entry.get();
EXPECT_EQ(url1, root_entry->url());
// The entry should now have a subframe FrameNavigationEntry.
ASSERT_EQ(1U, entry->root_node()->children.size());
FrameNavigationEntry* frame_entry =
entry->root_node()->children[0]->frame_entry.get();
EXPECT_EQ(url2, frame_entry->url());
// Add a second subframe and navigate.
std::string unique_name1("uniqueName1");
main_test_rfh()->OnCreateChildFrame(
process()->GetNextRoutingID(),
TestRenderFrameHost::CreateStubInterfaceProviderRequest(),
TestRenderFrameHost::CreateStubDocumentInterfaceBrokerReceiver(),
TestRenderFrameHost::CreateStubDocumentInterfaceBrokerReceiver(),
TestRenderFrameHost::CreateStubBrowserInterfaceBrokerReceiver(),
blink::WebTreeScopeType::kDocument, std::string(), unique_name1, false,
base::UnguessableToken::Create(), blink::FramePolicy(),
FrameOwnerProperties(), kOwnerType);
TestRenderFrameHost* subframe2 = static_cast<TestRenderFrameHost*>(
contents()->GetFrameTree()->root()->child_at(1)->current_frame_host());
const GURL url3("http://foo/3");
{
// Navigating should do nothing.
auto subframe_navigation =
NavigationSimulator::CreateRendererInitiated(url3, subframe2);
subframe_navigation->SetTransition(ui::PAGE_TRANSITION_AUTO_SUBFRAME);
subframe_navigation->Commit();
// We notify of a PageState update here rather than during UpdateState for
// auto subframe navigations.
EXPECT_EQ(1u, navigation_entry_changed_counter_);
navigation_entry_changed_counter_ = 0;
}
// There should still be only one entry, mostly unchanged.
EXPECT_EQ(1, controller.GetEntryCount());
EXPECT_EQ(entry, controller.GetLastCommittedEntry());
EXPECT_EQ(url1, entry->GetURL());
EXPECT_EQ(root_entry, entry->root_node()->frame_entry.get());
EXPECT_EQ(url1, root_entry->url());
// The entry should now have 2 subframe FrameNavigationEntries.
ASSERT_EQ(2U, entry->root_node()->children.size());
FrameNavigationEntry* new_frame_entry =
entry->root_node()->children[1]->frame_entry.get();
EXPECT_EQ(url3, new_frame_entry->url());
// Add a nested subframe and navigate.
std::string unique_name2("uniqueName2");
subframe->OnCreateChildFrame(
process()->GetNextRoutingID(),
TestRenderFrameHost::CreateStubInterfaceProviderRequest(),
TestRenderFrameHost::CreateStubDocumentInterfaceBrokerReceiver(),
TestRenderFrameHost::CreateStubDocumentInterfaceBrokerReceiver(),
TestRenderFrameHost::CreateStubBrowserInterfaceBrokerReceiver(),
blink::WebTreeScopeType::kDocument, std::string(), unique_name2, false,
base::UnguessableToken::Create(), blink::FramePolicy(),
FrameOwnerProperties(), kOwnerType);
TestRenderFrameHost* subframe3 =
static_cast<TestRenderFrameHost*>(contents()
->GetFrameTree()
->root()
->child_at(0)
->child_at(0)
->current_frame_host());
const GURL url4("http://foo/4");
{
// Navigating should do nothing.
auto subframe_navigation =
NavigationSimulator::CreateRendererInitiated(url4, subframe3);
subframe_navigation->SetTransition(ui::PAGE_TRANSITION_AUTO_SUBFRAME);
subframe_navigation->Commit();
// We notify of a PageState update here rather than during UpdateState for
// auto subframe navigations.
EXPECT_EQ(1u, navigation_entry_changed_counter_);
navigation_entry_changed_counter_ = 0;
}
// There should still be only one entry, mostly unchanged.
EXPECT_EQ(1, controller.GetEntryCount());
EXPECT_EQ(entry, controller.GetLastCommittedEntry());
EXPECT_EQ(url1, entry->GetURL());
EXPECT_EQ(root_entry, entry->root_node()->frame_entry.get());
EXPECT_EQ(url1, root_entry->url());
// The entry should now have a nested FrameNavigationEntry.
EXPECT_EQ(2U, entry->root_node()->children.size());
ASSERT_EQ(1U, entry->root_node()->children[0]->children.size());
new_frame_entry =
entry->root_node()->children[0]->children[0]->frame_entry.get();
EXPECT_EQ(url4, new_frame_entry->url());
}
// Tests navigation and then going back to a subframe navigation.
TEST_F(NavigationControllerTest, BackSubframe) {
NavigationControllerImpl& controller = controller_impl();
// Main page.
const GURL url1("http://foo1");
NavigationSimulator::NavigateAndCommitFromDocument(url1, main_test_rfh());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
NavigationEntry* entry1 = controller.GetLastCommittedEntry();
navigation_entry_committed_counter_ = 0;
// Prereq: add a subframe with an initial auto-subframe navigation.
std::string unique_name("uniqueName0");
main_test_rfh()->OnCreateChildFrame(
process()->GetNextRoutingID(),
TestRenderFrameHost::CreateStubInterfaceProviderRequest(),
TestRenderFrameHost::CreateStubDocumentInterfaceBrokerReceiver(),
TestRenderFrameHost::CreateStubDocumentInterfaceBrokerReceiver(),
TestRenderFrameHost::CreateStubBrowserInterfaceBrokerReceiver(),
blink::WebTreeScopeType::kDocument, std::string(), unique_name, false,
base::UnguessableToken::Create(), blink::FramePolicy(),
FrameOwnerProperties(), blink::FrameOwnerElementType::kIframe);
FrameTreeNode* subframe = contents()->GetFrameTree()->root()->child_at(0);
TestRenderFrameHost* subframe_rfh =
static_cast<TestRenderFrameHost*>(subframe->current_frame_host());
const GURL subframe_url("http://foo1/subframe");
// Navigating should do nothing.
auto navigation1 =
NavigationSimulator::CreateRendererInitiated(subframe_url, subframe_rfh);
navigation1->SetTransition(ui::PAGE_TRANSITION_AUTO_SUBFRAME);
navigation1->Commit();
// We notify of a PageState update here rather than during UpdateState for
// auto subframe navigations.
EXPECT_EQ(1u, navigation_entry_changed_counter_);
// First manual subframe_rfh navigation.
const GURL url2("http://foo2");
auto navigation2 =
NavigationSimulator::CreateRendererInitiated(url2, subframe_rfh);
navigation2->SetTransition(ui::PAGE_TRANSITION_MANUAL_SUBFRAME);
navigation2->Commit();
NavigationEntryImpl* entry2 = controller.GetLastCommittedEntry();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_EQ(2, controller.GetEntryCount());
// The entry should have a subframe FrameNavigationEntry.
ASSERT_EQ(1U, entry2->root_node()->children.size());
EXPECT_EQ(url2, entry2->root_node()->children[0]->frame_entry->url());
// Second manual subframe navigation should also make a new entry.
const GURL url3("http://foo3");
subframe_rfh =
static_cast<TestRenderFrameHost*>(subframe->current_frame_host());
auto navigation3 =
NavigationSimulator::CreateRendererInitiated(url3, subframe_rfh);
navigation3->SetTransition(ui::PAGE_TRANSITION_MANUAL_SUBFRAME);
navigation3->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
NavigationEntryImpl* entry3 = controller.GetLastCommittedEntry();
EXPECT_EQ(3, controller.GetEntryCount());
EXPECT_EQ(2, controller.GetCurrentEntryIndex());
// The entry should have a subframe FrameNavigationEntry.
ASSERT_EQ(1U, entry3->root_node()->children.size());
EXPECT_EQ(url3, entry3->root_node()->children[0]->frame_entry->url());
// Go back one.
controller.GoToOffset(-1);
auto back_navigation1 =
NavigationSimulatorImpl::CreateFromPendingInFrame(subframe);
back_navigation1->SetTransition(ui::PAGE_TRANSITION_AUTO_SUBFRAME);
back_navigation1->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_EQ(entry2, controller.GetLastCommittedEntry());
EXPECT_EQ(3, controller.GetEntryCount());
EXPECT_EQ(1, controller.GetCurrentEntryIndex());
EXPECT_EQ(-1, controller.GetPendingEntryIndex());
EXPECT_FALSE(controller.GetPendingEntry());
// Go back one more.
controller.GoToOffset(-1);
auto back_navigation2 =
NavigationSimulatorImpl::CreateFromPendingInFrame(subframe);
back_navigation2->SetTransition(ui::PAGE_TRANSITION_AUTO_SUBFRAME);
back_navigation2->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_EQ(entry1, controller.GetLastCommittedEntry());
EXPECT_EQ(3, controller.GetEntryCount());
EXPECT_EQ(0, controller.GetCurrentEntryIndex());
EXPECT_EQ(-1, controller.GetPendingEntryIndex());
EXPECT_FALSE(controller.GetPendingEntry());
}
TEST_F(NavigationControllerTest, LinkClick) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo1");
const GURL url2("http://foo2");
NavigationSimulator::NavigateAndCommitFromDocument(url1, main_test_rfh());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// Simulate a user gesture.
main_test_rfh()->frame_tree_node()->UpdateUserActivationState(
blink::UserActivationUpdateType::kNotifyActivation);
NavigationSimulator::NavigateAndCommitFromDocument(url2, main_test_rfh());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// Should have produced a new session history entry.
EXPECT_EQ(controller.GetEntryCount(), 2);
EXPECT_EQ(controller.GetLastCommittedEntryIndex(), 1);
EXPECT_EQ(controller.GetPendingEntryIndex(), -1);
EXPECT_TRUE(controller.GetLastCommittedEntry());
EXPECT_FALSE(controller.GetPendingEntry());
EXPECT_TRUE(controller.CanGoBack());
EXPECT_FALSE(controller.CanGoForward());
}
TEST_F(NavigationControllerTest, SameDocument) {
NavigationControllerImpl& controller = controller_impl();
// Main page.
const GURL url1("http://foo");
NavigationSimulator::NavigateAndCommitFromDocument(url1, main_test_rfh());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// Ensure renderer-initiated main frame navigation to same url replaces the
// current entry. This behavior differs from the browser-initiated case.
LoadCommittedDetailsObserver observer(contents());
auto renderer_initiated_navigation =
NavigationSimulatorImpl::CreateRendererInitiated(url1, main_test_rfh());
renderer_initiated_navigation->set_should_replace_current_entry(true);
renderer_initiated_navigation->Commit();
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_FALSE(observer.is_same_document());
EXPECT_TRUE(observer.did_replace_entry());
EXPECT_EQ(1, controller.GetEntryCount());
// Fragment navigation to a new page.
const GURL url2("http://foo#a");
auto same_document_navigation =
NavigationSimulator::CreateRendererInitiated(url2, main_test_rfh());
same_document_navigation->CommitSameDocument();
// This should generate a new entry.
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_TRUE(observer.is_same_document());
EXPECT_FALSE(observer.did_replace_entry());
EXPECT_EQ(2, controller.GetEntryCount());
// Go back one.
NavigationSimulator::GoBack(contents());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_TRUE(observer.is_same_document());
EXPECT_EQ(2, controller.GetEntryCount());
EXPECT_EQ(0, controller.GetCurrentEntryIndex());
EXPECT_EQ(url1, controller.GetLastCommittedEntry()->GetURL());
// Go forward.
NavigationSimulator::GoForward(contents());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_EQ(2, controller.GetEntryCount());
EXPECT_EQ(1, controller.GetCurrentEntryIndex());
EXPECT_EQ(url2, controller.GetVisibleEntry()->GetURL());
// Now go back and forward again. This is to work around a bug where we would
// compare the incoming URL with the last committed entry rather than the
// one identified by an existing page ID. This would result in the second URL
// losing the reference fragment when you navigate away from it and then back.
NavigationSimulator::GoBack(contents());
NavigationSimulator::GoForward(contents());
EXPECT_EQ(2U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_EQ(url2, controller.GetVisibleEntry()->GetURL());
// Finally, navigate to an unrelated URL to make sure same_document is not
// sticky.
const GURL url3("http://bar");
NavigationSimulator::NavigateAndCommitFromDocument(url3, main_test_rfh());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_FALSE(observer.is_same_document());
EXPECT_EQ(3, controller.GetEntryCount());
EXPECT_EQ(2, controller.GetCurrentEntryIndex());
}
TEST_F(NavigationControllerTest, SameDocument_Replace) {
NavigationControllerImpl& controller = controller_impl();
// Main page.
const GURL url1("http://foo");
NavigationSimulator::NavigateAndCommitFromDocument(url1, main_test_rfh());
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
// First navigation (using location.replace).
const GURL url2("http://foo#a");
FrameHostMsg_DidCommitProvisionalLoad_Params params;
params.nav_entry_id = 0;
params.did_create_new_entry = false;
params.should_replace_current_entry = true;
params.url = url2;
params.transition = ui::PAGE_TRANSITION_LINK;
params.should_update_history = false;
params.gesture = NavigationGestureUser;
params.method = "GET";
params.page_state = PageState::CreateFromURL(url2);
// This should NOT generate a new entry, nor prune the list.
LoadCommittedDetailsObserver observer(contents());
main_test_rfh()->SendNavigateWithParams(&params, true);
EXPECT_EQ(1U, navigation_entry_committed_counter_);
navigation_entry_committed_counter_ = 0;
EXPECT_TRUE(observer.is_same_document());
EXPECT_TRUE(observer.did_replace_entry());
EXPECT_EQ(1, controller.GetEntryCount());
}
TEST_F(NavigationControllerTest, PushStateWithoutPreviousEntry) {
ASSERT_FALSE(controller_impl().GetLastCommittedEntry());
FrameHostMsg_DidCommitProvisionalLoad_Params params;
GURL url("http://foo");
params.nav_entry_id = 0;
params.did_create_new_entry = true;
params.url = url;
params.page_state = PageState::CreateFromURL(url);
main_test_rfh()->SendRendererInitiatedNavigationRequest(url, false);
main_test_rfh()->PrepareForCommit();
contents()->GetMainFrame()->SendNavigateWithParams(&params, true);
// We pass if we don't crash.
}
// Tests that we limit the number of navigation entries created correctly.
TEST_F(NavigationControllerTest, EnforceMaxNavigationCount) {
NavigationControllerImpl& controller = controller_impl();
size_t original_count = NavigationControllerImpl::max_entry_count();
const int kMaxEntryCount = 5;
NavigationControllerImpl::set_max_entry_count_for_testing(kMaxEntryCount);
int url_index;
// Load up to the max count, all entries should be there.
for (url_index = 0; url_index < kMaxEntryCount; url_index++) {
GURL url(base::StringPrintf("http://www.a.com/%d", url_index));
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), url);
}
EXPECT_EQ(controller.GetEntryCount(), kMaxEntryCount);
// Navigate some more.
GURL url(base::StringPrintf("http://www.a.com/%d", url_index));
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), url);
url_index++;
// We should have got a pruned navigation.
EXPECT_EQ(1U, navigation_list_pruned_counter_);
EXPECT_EQ(0, last_navigation_entry_pruned_details_.index);
EXPECT_EQ(1, last_navigation_entry_pruned_details_.count);
// We expect http://www.a.com/0 to be gone.
EXPECT_EQ(controller.GetEntryCount(), kMaxEntryCount);
EXPECT_EQ(controller.GetEntryAtIndex(0)->GetURL(),
GURL("http://www.a.com/1"));
// More navigations.
for (int i = 0; i < 3; i++) {
url = GURL(base::StringPrintf("http://www.a.com/%d", url_index));
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), url);
url_index++;
}
EXPECT_EQ(controller.GetEntryCount(), kMaxEntryCount);
EXPECT_EQ(controller.GetEntryAtIndex(0)->GetURL(),
GURL("http://www.a.com/4"));
NavigationControllerImpl::set_max_entry_count_for_testing(original_count);
}
// Tests that we can do a restore and navigate to the restored entries and
// everything is updated properly. This can be tricky since there is no
// SiteInstance for the entries created initially.
TEST_F(NavigationControllerTest, RestoreNavigate) {
// Create a NavigationController with a restored set of tabs.
GURL url("http://foo");
std::vector<std::unique_ptr<NavigationEntry>> entries;
std::unique_ptr<NavigationEntry> entry =
NavigationController::CreateNavigationEntry(
url, Referrer(), base::nullopt, ui::PAGE_TRANSITION_RELOAD, false,
std::string(), browser_context(),
nullptr /* blob_url_loader_factory */);
entry->SetTitle(base::ASCIIToUTF16("Title"));
entry->SetPageState(PageState::CreateFromEncodedData("state"));
const base::Time timestamp = base::Time::Now();
entry->SetTimestamp(timestamp);
entries.push_back(std::move(entry));
std::unique_ptr<WebContents> our_contents =
WebContents::Create(WebContents::CreateParams(browser_context()));
WebContentsImpl* raw_our_contents =
static_cast<WebContentsImpl*>(our_contents.get());
NavigationControllerImpl& our_controller = raw_our_contents->GetController();
our_controller.Restore(0, RestoreType::LAST_SESSION_EXITED_CLEANLY, &entries);
ASSERT_EQ(0u, entries.size());
// Before navigating to the restored entry, it should have a restore_type
// and no SiteInstance.
ASSERT_EQ(1, our_controller.GetEntryCount());
EXPECT_EQ(RestoreType::LAST_SESSION_EXITED_CLEANLY,
our_controller.GetEntryAtIndex(0)->restore_type());
EXPECT_FALSE(our_controller.GetEntryAtIndex(0)->site_instance());
// After navigating, we should have one entry, and it should be "pending".
EXPECT_TRUE(our_controller.NeedsReload());
our_controller.LoadIfNecessary();
EXPECT_EQ(1, our_controller.GetEntryCount());
EXPECT_EQ(our_controller.GetEntryAtIndex(0),
our_controller.GetPendingEntry());
// Timestamp should remain the same before the navigation finishes.
EXPECT_EQ(timestamp, our_controller.GetEntryAtIndex(0)->GetTimestamp());
// Say we navigated to that entry.
auto navigation = NavigationSimulator::CreateFromPending(raw_our_contents);
navigation->Commit();
// There should be no longer any pending entry and one committed one. This
// means that we were able to locate the entry, assign its site instance, and
// commit it properly.
EXPECT_EQ(1, our_controller.GetEntryCount());
EXPECT_EQ(0, our_controller.GetLastCommittedEntryIndex());
EXPECT_FALSE(our_controller.GetPendingEntry());
if (AreDefaultSiteInstancesEnabled()) {
// Verify we get the default SiteInstance since |url| does not require a
// dedicated process.
EXPECT_TRUE(our_controller.GetLastCommittedEntry()
->site_instance()
->IsDefaultSiteInstance());
} else {
EXPECT_EQ(
url,
our_controller.GetLastCommittedEntry()->site_instance()->GetSiteURL());
}
EXPECT_EQ(RestoreType::NONE,
our_controller.GetEntryAtIndex(0)->restore_type());
// Timestamp should have been updated.
EXPECT_GE(our_controller.GetEntryAtIndex(0)->GetTimestamp(), timestamp);
}
// Tests that we can still navigate to a restored entry after a different
// navigation fails and clears the pending entry. http://crbug.com/90085
TEST_F(NavigationControllerTest, RestoreNavigateAfterFailure) {
// Create a NavigationController with a restored set of tabs.
GURL url("http://foo");
std::vector<std::unique_ptr<NavigationEntry>> entries;
std::unique_ptr<NavigationEntry> new_entry =
NavigationController::CreateNavigationEntry(
url, Referrer(), base::nullopt, ui::PAGE_TRANSITION_RELOAD, false,
std::string(), browser_context(),
nullptr /* blob_url_loader_factory */);
new_entry->SetTitle(base::ASCIIToUTF16("Title"));
new_entry->SetPageState(PageState::CreateFromEncodedData("state"));
entries.push_back(std::move(new_entry));
std::unique_ptr<WebContents> our_contents =
WebContents::Create(WebContents::CreateParams(browser_context()));
WebContentsImpl* raw_our_contents =
static_cast<WebContentsImpl*>(our_contents.get());
NavigationControllerImpl& our_controller = raw_our_contents->GetController();
our_controller.Restore(0, RestoreType::LAST_SESSION_EXITED_CLEANLY, &entries);
ASSERT_EQ(0u, entries.size());
// Ensure the RenderFrame is initialized before simulating events coming from
// it.
main_test_rfh()->InitializeRenderFrameIfNeeded();
// Before navigating to the restored entry, it should have a restore_type
// and no SiteInstance.
EXPECT_EQ(RestoreType::LAST_SESSION_EXITED_CLEANLY,
our_controller.GetEntryAtIndex(0)->restore_type());
EXPECT_FALSE(our_controller.GetEntryAtIndex(0)->site_instance());
// After navigating, we should have one entry, and it should be "pending".
EXPECT_TRUE(our_controller.NeedsReload());
our_controller.LoadIfNecessary();
auto restore_navigation =
NavigationSimulator::CreateFromPending(raw_our_contents);
restore_navigation->ReadyToCommit();
EXPECT_EQ(1, our_controller.GetEntryCount());
EXPECT_EQ(our_controller.GetEntryAtIndex(0),
our_controller.GetPendingEntry());
// This pending navigation may have caused a different navigation to fail,
// which causes the pending entry to be cleared.
NavigationSimulator::NavigateAndFailFromDocument(url, net::ERR_ABORTED,
main_test_rfh());
// Now the pending restored entry commits.
restore_navigation->Commit();
// There should be no pending entry and one committed one.
EXPECT_EQ(1, our_controller.GetEntryCount());
EXPECT_EQ(0, our_controller.GetLastCommittedEntryIndex());
EXPECT_FALSE(our_controller.GetPendingEntry());
if (AreDefaultSiteInstancesEnabled()) {
// Verify we get the default SiteInstance since |url| does not require a
// dedicated process.
EXPECT_TRUE(our_controller.GetLastCommittedEntry()
->site_instance()
->IsDefaultSiteInstance());
} else {
EXPECT_EQ(
url,
our_controller.GetLastCommittedEntry()->site_instance()->GetSiteURL());
}
EXPECT_EQ(RestoreType::NONE,
our_controller.GetEntryAtIndex(0)->restore_type());
}
// Make sure that the page type and stuff is correct after an interstitial.
TEST_F(NavigationControllerTest, Interstitial) {
NavigationControllerImpl& controller = controller_impl();
// First navigate somewhere normal.
const GURL url1("http://foo");
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), url1);
// Now navigate somewhere with an interstitial.
const GURL url2("http://bar");
std::unique_ptr<NavigationSimulator> simulator =
NavigationSimulator::CreateBrowserInitiated(url2, contents());
simulator->Start();
controller.GetPendingEntry()->set_page_type(PAGE_TYPE_INTERSTITIAL);
// At this point the interstitial will be displayed and the load will still
// be pending. If the user continues, the load will commit.
simulator->Commit();
// The page should be a normal page again.
EXPECT_EQ(url2, controller.GetLastCommittedEntry()->GetURL());
EXPECT_EQ(PAGE_TYPE_NORMAL,
controller.GetLastCommittedEntry()->GetPageType());
}
TEST_F(NavigationControllerTest, RemoveEntry) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo/1");
const GURL url2("http://foo/2");
const GURL url3("http://foo/3");
const GURL url4("http://foo/4");
const GURL url5("http://foo/5");
const GURL pending_url("http://foo/pending");
const GURL default_url("http://foo/default");
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), url1);
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), url2);
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), url3);
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), url4);
NavigationSimulator::NavigateAndCommitFromBrowser(contents(), url5);
// Try to remove the last entry. Will fail because it is the current entry.
EXPECT_FALSE(controller.RemoveEntryAtIndex(controller.GetEntryCount() - 1));
EXPECT_EQ(5, controller.GetEntryCount());
EXPECT_EQ(4, controller.GetLastCommittedEntryIndex());
// Go back, but don't commit yet. Check that we can't delete the current
// and pending entries.
auto back_navigation =
NavigationSimulator::CreateHistoryNavigation(-1, contents());
back_navigation->Start();
EXPECT_FALSE(controller.RemoveEntryAtIndex(controller.GetEntryCount() - 1));
EXPECT_FALSE(controller.RemoveEntryAtIndex(controller.GetEntryCount() - 2));
// Now commit and delete the last entry.
back_navigation->Commit();
EXPECT_TRUE(controller.RemoveEntryAtIndex(controller.GetEntryCount() - 1));
EXPECT_EQ(4, controller.GetEntryCount());
EXPECT_EQ(3, controller.GetLastCommittedEntryIndex());
EXPECT_FALSE(controller.GetPendingEntry());
// Remove an entry which is not the last committed one.
EXPECT_TRUE(controller.RemoveEntryAtIndex(0));
EXPECT_EQ(3, controller.GetEntryCount());
EXPECT_EQ(2, controller.GetLastCommittedEntryIndex());
EXPECT_FALSE(controller.GetPendingEntry());
// Remove the 2 remaining entries.
controller.RemoveEntryAtIndex(1);
controller.RemoveEntryAtIndex(0);
// This should leave us with only the last committed entry.
EXPECT_EQ(1, controller.GetEntryCount());
EXPECT_EQ(0, controller.GetLastCommittedEntryIndex());
}
TEST_F(NavigationControllerTest, RemoveEntryWithPending) {
NavigationControllerImpl& controller = controller_impl();
const GURL url1("http://foo/1");
const GURL url2("http://foo/2");
const GURL url3("http://foo/3");
const GURL default_url("http://foo/default");
NavigationSimulator::Navigate