3683 lines
113 KiB
C++
3683 lines
113 KiB
C++
// Copyright (c) 2011 The Chromium Embedded Framework 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 <algorithm>
|
|
#include <list>
|
|
|
|
#include "include/base/cef_callback.h"
|
|
#include "include/cef_callback.h"
|
|
#include "include/cef_request_context.h"
|
|
#include "include/cef_request_context_handler.h"
|
|
#include "include/cef_scheme.h"
|
|
#include "include/wrapper/cef_closure_task.h"
|
|
#include "include/wrapper/cef_scoped_temp_dir.h"
|
|
#include "tests/ceftests/test_handler.h"
|
|
#include "tests/ceftests/test_util.h"
|
|
#include "tests/gtest/include/gtest/gtest.h"
|
|
#include "tests/shared/browser/client_app_browser.h"
|
|
#include "tests/shared/renderer/client_app_renderer.h"
|
|
|
|
// Set to 1 to enable verbose debugging info logging.
|
|
#define VERBOSE_DEBUGGING 0
|
|
|
|
using client::ClientAppBrowser;
|
|
using client::ClientAppRenderer;
|
|
|
|
namespace {
|
|
|
|
const char kHNav1[] = "https://tests-hnav.com/nav1.html";
|
|
const char kHNav2[] = "https://tests-hnav.com/nav2.html";
|
|
const char kHNav3[] = "https://tests-hnav.com/nav3.html";
|
|
const char kHistoryNavMsg[] = "NavigationTest.HistoryNav";
|
|
const char kHistoryNavTestCmdKey[] = "nav-history-test";
|
|
|
|
const cef_transition_type_t kTransitionExplicitLoad =
|
|
static_cast<cef_transition_type_t>(TT_EXPLICIT | TT_DIRECT_LOAD_FLAG);
|
|
|
|
// TT_FORWARD_BACK_FLAG is added to the original transition flags.
|
|
const cef_transition_type_t kTransitionExplicitForwardBack =
|
|
static_cast<cef_transition_type_t>(kTransitionExplicitLoad |
|
|
TT_FORWARD_BACK_FLAG);
|
|
|
|
enum NavAction { NA_LOAD = 1, NA_BACK, NA_FORWARD };
|
|
|
|
#if VERBOSE_DEBUGGING
|
|
const char* NavActionString(NavAction action) {
|
|
switch (action) {
|
|
case NA_LOAD:
|
|
return "LOAD";
|
|
case NA_BACK:
|
|
return "BACK";
|
|
case NA_FORWARD:
|
|
return "FORWARD";
|
|
}
|
|
return "INVALID";
|
|
}
|
|
#endif // VERBOSE_DEBUGGING
|
|
|
|
bool ExpectResourceLoadEvents(NavAction action) {
|
|
if (IsSameSiteBFCacheEnabled()) {
|
|
return action == NA_LOAD;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
typedef struct {
|
|
NavAction action; // What to do
|
|
const char* target; // Where to be after navigation
|
|
bool can_go_back; // After navigation, can go back?
|
|
bool can_go_forward; // After navigation, can go forward?
|
|
} NavListItem;
|
|
|
|
// Array of navigation actions: X = current page, . = history exists
|
|
static NavListItem kHNavList[] = {
|
|
// kHNav1 | kHNav2 | kHNav3
|
|
{NA_LOAD, kHNav1, false, false}, // X
|
|
{NA_LOAD, kHNav2, true, false}, // . X
|
|
{NA_BACK, kHNav1, false, true}, // X .
|
|
{NA_FORWARD, kHNav2, true, false}, // . X
|
|
{NA_LOAD, kHNav3, true, false}, // . . X
|
|
{NA_BACK, kHNav2, true, true}, // . X .
|
|
};
|
|
|
|
#define NAV_LIST_SIZE() (sizeof(kHNavList) / sizeof(NavListItem))
|
|
|
|
// Renderer side.
|
|
class HistoryNavRendererTest : public ClientAppRenderer::Delegate,
|
|
public CefLoadHandler {
|
|
public:
|
|
HistoryNavRendererTest() = default;
|
|
|
|
void OnBrowserCreated(CefRefPtr<ClientAppRenderer> app,
|
|
CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefDictionaryValue> extra_info) override {
|
|
run_test_ = extra_info && extra_info->HasKey(kHistoryNavTestCmdKey);
|
|
}
|
|
|
|
CefRefPtr<CefLoadHandler> GetLoadHandler(
|
|
CefRefPtr<ClientAppRenderer> app) override {
|
|
if (!run_test_) {
|
|
return nullptr;
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
|
|
bool isLoading,
|
|
bool canGoBack,
|
|
bool canGoForward) override {
|
|
const NavListItem& item = kHNavList[nav_];
|
|
#if VERBOSE_DEBUGGING
|
|
LOG(INFO) << "render nav=" << nav_ << " " << NavActionString(item.action)
|
|
<< " OnLoadingStateChange isLoading=" << isLoading;
|
|
#endif
|
|
|
|
const std::string& url = browser->GetMainFrame()->GetURL();
|
|
EXPECT_STREQ(item.target, url.c_str());
|
|
|
|
EXPECT_EQ(item.can_go_back, browser->CanGoBack())
|
|
<< "nav: " << nav_ << " isLoading: " << isLoading;
|
|
EXPECT_EQ(item.can_go_back, canGoBack)
|
|
<< "nav: " << nav_ << " isLoading: " << isLoading;
|
|
EXPECT_EQ(item.can_go_forward, browser->CanGoForward())
|
|
<< "nav: " << nav_ << " isLoading: " << isLoading;
|
|
EXPECT_EQ(item.can_go_forward, canGoForward)
|
|
<< "nav: " << nav_ << " isLoading: " << isLoading;
|
|
|
|
if (isLoading) {
|
|
EXPECT_FALSE(got_loading_state_start_);
|
|
got_loading_state_start_.yes();
|
|
} else {
|
|
EXPECT_FALSE(got_loading_state_end_);
|
|
got_loading_state_end_.yes();
|
|
SendTestResultsIfDone(browser, browser->GetMainFrame());
|
|
}
|
|
}
|
|
|
|
void OnLoadStart(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
TransitionType transition_type) override {
|
|
const NavListItem& item = kHNavList[nav_];
|
|
#if VERBOSE_DEBUGGING
|
|
LOG(INFO) << "render nav=" << nav_ << " " << NavActionString(item.action)
|
|
<< " OnLoadStart";
|
|
#endif
|
|
|
|
EXPECT_FALSE(got_load_start_);
|
|
got_load_start_.yes();
|
|
|
|
const std::string& url = frame->GetURL();
|
|
EXPECT_STREQ(item.target, url.c_str());
|
|
|
|
EXPECT_EQ(TT_EXPLICIT, transition_type);
|
|
|
|
EXPECT_EQ(item.can_go_back, browser->CanGoBack());
|
|
EXPECT_EQ(item.can_go_forward, browser->CanGoForward());
|
|
}
|
|
|
|
void OnLoadEnd(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
int httpStatusCode) override {
|
|
const NavListItem& item = kHNavList[nav_];
|
|
#if VERBOSE_DEBUGGING
|
|
LOG(INFO) << "render nav=" << nav_ << " " << NavActionString(item.action)
|
|
<< " OnLoadEnd";
|
|
#endif
|
|
|
|
EXPECT_FALSE(got_load_end_);
|
|
got_load_end_.yes();
|
|
|
|
const std::string& url = frame->GetURL();
|
|
EXPECT_STREQ(item.target, url.c_str());
|
|
|
|
EXPECT_EQ(item.can_go_back, browser->CanGoBack());
|
|
EXPECT_EQ(item.can_go_forward, browser->CanGoForward());
|
|
|
|
SendTestResultsIfDone(browser, frame);
|
|
}
|
|
|
|
protected:
|
|
void SendTestResultsIfDone(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame) {
|
|
if (got_load_end_ && got_loading_state_end_) {
|
|
SendTestResults(browser, frame);
|
|
}
|
|
}
|
|
|
|
// Send the test results.
|
|
void SendTestResults(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame) {
|
|
#if VERBOSE_DEBUGGING
|
|
const NavListItem& item = kHNavList[nav_];
|
|
LOG(INFO) << "render nav=" << nav_ << " " << NavActionString(item.action)
|
|
<< " SendTestResults";
|
|
#endif
|
|
|
|
EXPECT_TRUE(got_loading_state_start_);
|
|
EXPECT_TRUE(got_loading_state_end_);
|
|
EXPECT_TRUE(got_load_start_);
|
|
EXPECT_TRUE(got_load_end_);
|
|
|
|
// Check if the test has failed.
|
|
bool result = !TestFailed();
|
|
|
|
// Return the result to the browser process.
|
|
CefRefPtr<CefProcessMessage> return_msg =
|
|
CefProcessMessage::Create(kHistoryNavMsg);
|
|
CefRefPtr<CefListValue> args = return_msg->GetArgumentList();
|
|
EXPECT_TRUE(args.get());
|
|
EXPECT_TRUE(args->SetInt(0, nav_));
|
|
EXPECT_TRUE(args->SetBool(1, result));
|
|
frame->SendProcessMessage(PID_BROWSER, return_msg);
|
|
|
|
// Reset the test results for the next navigation.
|
|
got_loading_state_start_.reset();
|
|
got_loading_state_end_.reset();
|
|
got_load_start_.reset();
|
|
got_load_end_.reset();
|
|
|
|
nav_++;
|
|
}
|
|
|
|
bool run_test_ = false;
|
|
int nav_ = 0;
|
|
|
|
TrackCallback got_loading_state_start_;
|
|
TrackCallback got_loading_state_end_;
|
|
TrackCallback got_load_start_;
|
|
TrackCallback got_load_end_;
|
|
|
|
IMPLEMENT_REFCOUNTING(HistoryNavRendererTest);
|
|
};
|
|
|
|
class NavigationEntryVisitor : public CefNavigationEntryVisitor {
|
|
public:
|
|
NavigationEntryVisitor(int nav, TrackCallback* callback)
|
|
: nav_(nav), callback_(callback) {
|
|
// Determine the expected values.
|
|
for (int i = 0; i <= nav_; ++i) {
|
|
if (kHNavList[i].action == NA_LOAD) {
|
|
expected_total_++;
|
|
expected_current_index_++;
|
|
} else if (kHNavList[i].action == NA_BACK) {
|
|
expected_current_index_--;
|
|
} else if (kHNavList[i].action == NA_FORWARD) {
|
|
expected_current_index_++;
|
|
}
|
|
expected_forwardback_[expected_current_index_] =
|
|
(kHNavList[i].action != NA_LOAD);
|
|
}
|
|
}
|
|
|
|
~NavigationEntryVisitor() override {
|
|
EXPECT_EQ(callback_count_, expected_total_);
|
|
callback_->yes();
|
|
}
|
|
|
|
bool Visit(CefRefPtr<CefNavigationEntry> entry,
|
|
bool current,
|
|
int index,
|
|
int total) override {
|
|
// Only 3 loads total.
|
|
EXPECT_LT(index, 3);
|
|
EXPECT_LE(total, 3);
|
|
|
|
EXPECT_EQ((expected_current_index_ == index), current);
|
|
EXPECT_EQ(callback_count_, index);
|
|
EXPECT_EQ(expected_total_, total);
|
|
|
|
std::string expected_url;
|
|
std::string expected_title;
|
|
if (index == 0) {
|
|
expected_url = kHNav1;
|
|
expected_title = "Nav1";
|
|
} else if (index == 1) {
|
|
expected_url = kHNav2;
|
|
expected_title = "Nav2";
|
|
} else if (index == 2) {
|
|
expected_url = kHNav3;
|
|
expected_title = "Nav3";
|
|
}
|
|
|
|
EXPECT_TRUE(entry->IsValid());
|
|
EXPECT_STREQ(expected_url.c_str(), entry->GetURL().ToString().c_str());
|
|
EXPECT_STREQ(expected_url.c_str(),
|
|
entry->GetDisplayURL().ToString().c_str());
|
|
EXPECT_STREQ(expected_url.c_str(),
|
|
entry->GetOriginalURL().ToString().c_str());
|
|
EXPECT_STREQ(expected_title.c_str(), entry->GetTitle().ToString().c_str());
|
|
|
|
const auto transition_type = entry->GetTransitionType();
|
|
if (expected_forwardback_[index]) {
|
|
EXPECT_EQ(kTransitionExplicitForwardBack, transition_type);
|
|
} else {
|
|
EXPECT_EQ(kTransitionExplicitLoad, transition_type);
|
|
}
|
|
|
|
EXPECT_FALSE(entry->HasPostData());
|
|
EXPECT_GT(CefTimeFrom(entry->GetCompletionTime()).GetTimeT(), 0);
|
|
EXPECT_EQ(200, entry->GetHttpStatusCode());
|
|
|
|
callback_count_++;
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
const int nav_;
|
|
TrackCallback* callback_;
|
|
int expected_total_ = 0;
|
|
int expected_current_index_ = -1;
|
|
bool expected_forwardback_[3] = {}; // Only 3 loads total.
|
|
int callback_count_ = 0;
|
|
|
|
IMPLEMENT_REFCOUNTING(NavigationEntryVisitor);
|
|
};
|
|
|
|
// Browser side.
|
|
class HistoryNavTestHandler : public TestHandler {
|
|
public:
|
|
HistoryNavTestHandler() = default;
|
|
|
|
void RunTest() override {
|
|
// Add the resources that we will navigate to/from.
|
|
AddResource(
|
|
kHNav1,
|
|
"<html><head><title>Nav1</title></head><body>Nav1</body></html>",
|
|
"text/html");
|
|
AddResource(kHNav2,
|
|
"<html><head><title>Nav2</title><body>Nav2</body></html>",
|
|
"text/html");
|
|
AddResource(kHNav3,
|
|
"<html><head><title>Nav3</title><body>Nav3</body></html>",
|
|
"text/html");
|
|
|
|
CefRefPtr<CefDictionaryValue> extra_info = CefDictionaryValue::Create();
|
|
extra_info->SetBool(kHistoryNavTestCmdKey, true);
|
|
|
|
// Create the browser.
|
|
CreateBrowser(CefString(), nullptr, extra_info);
|
|
|
|
// Time out the test after a reasonable period of time.
|
|
SetTestTimeout();
|
|
}
|
|
|
|
void RunNav(CefRefPtr<CefBrowser> browser) {
|
|
if (nav_ == NAV_LIST_SIZE()) {
|
|
// End of the nav list.
|
|
DestroyTest();
|
|
return;
|
|
}
|
|
|
|
const NavListItem& item = kHNavList[nav_];
|
|
|
|
// Perform the action.
|
|
switch (item.action) {
|
|
case NA_LOAD:
|
|
browser->GetMainFrame()->LoadURL(item.target);
|
|
break;
|
|
case NA_BACK:
|
|
browser->GoBack();
|
|
break;
|
|
case NA_FORWARD:
|
|
browser->GoForward();
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
void RunNextNavIfReady(CefRefPtr<CefBrowser> browser) {
|
|
#if VERBOSE_DEBUGGING
|
|
LOG(INFO) << "browser nav=" << nav_
|
|
<< " load_end_confirmation_=" << load_end_confirmation_
|
|
<< " load_state_change_loaded_confirmation_="
|
|
<< load_state_change_loaded_confirmation_
|
|
<< " renderer_confirmation_=" << renderer_confirmation_;
|
|
#endif
|
|
|
|
if (load_end_confirmation_ && load_state_change_loaded_confirmation_ &&
|
|
renderer_confirmation_) {
|
|
load_end_confirmation_ = false;
|
|
load_state_change_loaded_confirmation_ = false;
|
|
renderer_confirmation_ = false;
|
|
nav_++;
|
|
RunNav(browser);
|
|
}
|
|
}
|
|
|
|
void OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
|
|
TestHandler::OnAfterCreated(browser);
|
|
|
|
RunNav(browser);
|
|
}
|
|
|
|
bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefRequest> request,
|
|
bool user_gesture,
|
|
bool is_redirect) override {
|
|
const NavListItem& item = kHNavList[nav_];
|
|
|
|
#if VERBOSE_DEBUGGING
|
|
LOG(INFO) << "browser nav=" << nav_ << " " << NavActionString(item.action)
|
|
<< " OnBeforeBrowse";
|
|
#endif
|
|
|
|
EXPECT_FALSE(got_before_browse_[nav_]);
|
|
got_before_browse_[nav_].yes();
|
|
|
|
std::string url = request->GetURL();
|
|
EXPECT_STREQ(item.target, url.c_str());
|
|
|
|
EXPECT_EQ(RT_MAIN_FRAME, request->GetResourceType());
|
|
|
|
const auto transition_type = request->GetTransitionType();
|
|
if (item.action == NA_LOAD) {
|
|
EXPECT_EQ(kTransitionExplicitLoad, transition_type);
|
|
} else if (item.action == NA_BACK || item.action == NA_FORWARD) {
|
|
EXPECT_EQ(kTransitionExplicitForwardBack, transition_type);
|
|
}
|
|
|
|
if (nav_ > 0) {
|
|
const NavListItem& last_item = kHNavList[nav_ - 1];
|
|
EXPECT_EQ(last_item.can_go_back, browser->CanGoBack());
|
|
EXPECT_EQ(last_item.can_go_forward, browser->CanGoForward());
|
|
} else {
|
|
EXPECT_FALSE(browser->CanGoBack());
|
|
EXPECT_FALSE(browser->CanGoForward());
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
cef_return_value_t OnBeforeResourceLoad(
|
|
CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefRequest> request,
|
|
CefRefPtr<CefCallback> callback) override {
|
|
if (IsChromeRuntimeEnabled() && request->GetResourceType() == RT_FAVICON) {
|
|
// Ignore favicon requests.
|
|
return RV_CANCEL;
|
|
}
|
|
|
|
const NavListItem& item = kHNavList[nav_];
|
|
const std::string& url = request->GetURL();
|
|
|
|
EXPECT_EQ(RT_MAIN_FRAME, request->GetResourceType())
|
|
<< "nav=" << nav_ << " url=" << url;
|
|
|
|
const auto transition_type = request->GetTransitionType();
|
|
if (item.action == NA_LOAD) {
|
|
EXPECT_EQ(kTransitionExplicitLoad, transition_type)
|
|
<< "nav=" << nav_ << " url=" << url;
|
|
} else if (item.action == NA_BACK || item.action == NA_FORWARD) {
|
|
EXPECT_EQ(kTransitionExplicitForwardBack, transition_type)
|
|
<< "nav=" << nav_ << " url=" << url;
|
|
}
|
|
|
|
EXPECT_FALSE(got_before_resource_load_[nav_]);
|
|
got_before_resource_load_[nav_].yes();
|
|
|
|
if (url == item.target) {
|
|
got_correct_target_[nav_].yes();
|
|
}
|
|
|
|
return RV_CONTINUE;
|
|
}
|
|
|
|
void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
|
|
bool isLoading,
|
|
bool canGoBack,
|
|
bool canGoForward) override {
|
|
const NavListItem& item = kHNavList[nav_];
|
|
|
|
#if VERBOSE_DEBUGGING
|
|
LOG(INFO) << "browser nav=" << nav_ << " " << NavActionString(item.action)
|
|
<< " OnLoadingStateChange isLoading=" << isLoading;
|
|
#endif
|
|
|
|
if (isLoading) {
|
|
EXPECT_FALSE(got_loading_state_change_loading_[nav_]);
|
|
got_loading_state_change_loading_[nav_].yes();
|
|
return;
|
|
}
|
|
|
|
EXPECT_FALSE(got_loading_state_change_loaded_[nav_]);
|
|
got_loading_state_change_loaded_[nav_].yes();
|
|
|
|
if (item.can_go_back == canGoBack) {
|
|
got_correct_can_go_back_[nav_].yes();
|
|
}
|
|
if (item.can_go_forward == canGoForward) {
|
|
got_correct_can_go_forward_[nav_].yes();
|
|
}
|
|
|
|
load_state_change_loaded_confirmation_ = true;
|
|
RunNextNavIfReady(browser);
|
|
}
|
|
|
|
void OnLoadStart(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
TransitionType transition_type) override {
|
|
if (browser->IsPopup() || !frame->IsMain()) {
|
|
return;
|
|
}
|
|
|
|
const NavListItem& item = kHNavList[nav_];
|
|
|
|
#if VERBOSE_DEBUGGING
|
|
LOG(INFO) << "browser nav=" << nav_ << " " << NavActionString(item.action)
|
|
<< " OnLoadStart";
|
|
#endif
|
|
|
|
EXPECT_FALSE(got_load_start_[nav_]);
|
|
got_load_start_[nav_].yes();
|
|
|
|
if (item.action == NA_LOAD) {
|
|
EXPECT_EQ(kTransitionExplicitLoad, transition_type);
|
|
} else if (item.action == NA_BACK || item.action == NA_FORWARD) {
|
|
EXPECT_EQ(kTransitionExplicitForwardBack, transition_type);
|
|
}
|
|
|
|
std::string url1 = browser->GetMainFrame()->GetURL();
|
|
std::string url2 = frame->GetURL();
|
|
if (url1 == item.target && url2 == item.target) {
|
|
got_correct_load_start_url_[nav_].yes();
|
|
}
|
|
}
|
|
|
|
void OnLoadEnd(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
int httpStatusCode) override {
|
|
if (browser->IsPopup() || !frame->IsMain()) {
|
|
return;
|
|
}
|
|
|
|
const NavListItem& item = kHNavList[nav_];
|
|
|
|
#if VERBOSE_DEBUGGING
|
|
LOG(INFO) << "browser nav=" << nav_ << " " << NavActionString(item.action)
|
|
<< " OnLoadEnd";
|
|
#endif
|
|
|
|
EXPECT_FALSE(got_load_end_[nav_]);
|
|
got_load_end_[nav_].yes();
|
|
|
|
// Test that navigation entries are correct.
|
|
CefRefPtr<NavigationEntryVisitor> visitor =
|
|
new NavigationEntryVisitor(nav_, &got_correct_history_[nav_]);
|
|
browser->GetHost()->GetNavigationEntries(visitor.get(), false);
|
|
visitor = nullptr;
|
|
|
|
std::string url1 = browser->GetMainFrame()->GetURL();
|
|
std::string url2 = frame->GetURL();
|
|
if (url1 == item.target && url2 == item.target) {
|
|
got_correct_load_end_url_[nav_].yes();
|
|
}
|
|
|
|
load_end_confirmation_ = true;
|
|
RunNextNavIfReady(browser);
|
|
}
|
|
|
|
bool OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefProcessId source_process,
|
|
CefRefPtr<CefProcessMessage> message) override {
|
|
if (message->GetName().ToString() == kHistoryNavMsg) {
|
|
EXPECT_FALSE(got_before_navigation_[nav_]);
|
|
got_before_navigation_[nav_].yes();
|
|
|
|
// Test that the renderer side succeeded.
|
|
CefRefPtr<CefListValue> args = message->GetArgumentList();
|
|
EXPECT_TRUE(args.get());
|
|
EXPECT_EQ(nav_, args->GetInt(0));
|
|
EXPECT_TRUE(args->GetBool(1));
|
|
|
|
renderer_confirmation_ = true;
|
|
RunNextNavIfReady(browser);
|
|
return true;
|
|
}
|
|
|
|
// Message not handled.
|
|
return false;
|
|
}
|
|
|
|
int nav_ = 0;
|
|
bool load_end_confirmation_ = false;
|
|
bool load_state_change_loaded_confirmation_ = false;
|
|
bool renderer_confirmation_ = false;
|
|
|
|
TrackCallback got_before_browse_[NAV_LIST_SIZE()];
|
|
TrackCallback got_before_navigation_[NAV_LIST_SIZE()];
|
|
TrackCallback got_before_resource_load_[NAV_LIST_SIZE()];
|
|
TrackCallback got_correct_target_[NAV_LIST_SIZE()];
|
|
TrackCallback got_loading_state_change_loading_[NAV_LIST_SIZE()];
|
|
TrackCallback got_loading_state_change_loaded_[NAV_LIST_SIZE()];
|
|
TrackCallback got_correct_can_go_back_[NAV_LIST_SIZE()];
|
|
TrackCallback got_correct_can_go_forward_[NAV_LIST_SIZE()];
|
|
TrackCallback got_load_start_[NAV_LIST_SIZE()];
|
|
TrackCallback got_correct_load_start_url_[NAV_LIST_SIZE()];
|
|
TrackCallback got_load_end_[NAV_LIST_SIZE()];
|
|
TrackCallback got_correct_history_[NAV_LIST_SIZE()];
|
|
TrackCallback got_correct_load_end_url_[NAV_LIST_SIZE()];
|
|
|
|
IMPLEMENT_REFCOUNTING(HistoryNavTestHandler);
|
|
};
|
|
|
|
} // namespace
|
|
|
|
// Verify history navigation.
|
|
TEST(NavigationTest, History) {
|
|
CefRefPtr<HistoryNavTestHandler> handler = new HistoryNavTestHandler();
|
|
handler->ExecuteTest();
|
|
|
|
for (size_t i = 0; i < NAV_LIST_SIZE(); ++i) {
|
|
if (ExpectResourceLoadEvents(kHNavList[i].action)) {
|
|
EXPECT_TRUE(handler->got_before_browse_[i]) << "i = " << i;
|
|
EXPECT_TRUE(handler->got_before_resource_load_[i]) << "i = " << i;
|
|
EXPECT_TRUE(handler->got_correct_target_[i]) << "i = " << i;
|
|
} else {
|
|
EXPECT_FALSE(handler->got_before_browse_[i]) << "i = " << i;
|
|
EXPECT_FALSE(handler->got_before_resource_load_[i]) << "i = " << i;
|
|
EXPECT_FALSE(handler->got_correct_target_[i]) << "i = " << i;
|
|
}
|
|
|
|
EXPECT_TRUE(handler->got_before_navigation_[i]) << "i = " << i;
|
|
EXPECT_TRUE(handler->got_load_start_[i]) << "i = " << i;
|
|
EXPECT_TRUE(handler->got_correct_load_start_url_[i]) << "i = " << i;
|
|
EXPECT_TRUE(handler->got_load_end_[i]) << "i = " << i;
|
|
EXPECT_TRUE(handler->got_correct_load_end_url_[i]) << "i = " << i;
|
|
EXPECT_TRUE(handler->got_correct_history_[i]) << "i = " << i;
|
|
|
|
EXPECT_TRUE(handler->got_loading_state_change_loading_[i]) << "i = " << i;
|
|
EXPECT_TRUE(handler->got_loading_state_change_loaded_[i]) << "i = " << i;
|
|
EXPECT_TRUE(handler->got_correct_can_go_back_[i]) << "i = " << i;
|
|
EXPECT_TRUE(handler->got_correct_can_go_forward_[i]) << "i = " << i;
|
|
}
|
|
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
namespace {
|
|
|
|
const char kDynIfrNav1[] = "https://tests-dynframe/nav1.html";
|
|
const char kDynIfrNav2[] = "https://tests-dynframe/nav2.html";
|
|
|
|
// Browser side.
|
|
class HistoryDynamicIFramesNavTestHandler : public TestHandler {
|
|
public:
|
|
HistoryDynamicIFramesNavTestHandler() = default;
|
|
|
|
void RunTest() override {
|
|
// Add the resources that we will navigate to/from.
|
|
AddResource(kDynIfrNav1,
|
|
"<html>"
|
|
" <head>"
|
|
" <title>Nav1</title>"
|
|
" <script language='javascript'>"
|
|
" function onload() {"
|
|
" fr = Math.floor(Math.random() * 10);"
|
|
" if(fr == 0) "
|
|
" fr = 1;"
|
|
" console.log('fr=' + fr);"
|
|
" for(i = 1; i <= fr; i++) {"
|
|
" try {"
|
|
" var n = 'DYN_' + Math.floor(Math.random() * 10000);"
|
|
" "
|
|
" d = document.createElement('div');"
|
|
" d.id = 'sf' + i; "
|
|
" d.innerText = n; "
|
|
" document.body.appendChild(d); "
|
|
" "
|
|
" f = document.createElement('iframe'); "
|
|
" f.id = 'f_' + i; "
|
|
" f.name = n; "
|
|
" f.src = 'nav2.html'; "
|
|
" document.body.appendChild(f); "
|
|
" } catch(e) { "
|
|
" console.log('frame[' + i + ']: ' + e); "
|
|
" } "
|
|
" } "
|
|
" } "
|
|
" </script> "
|
|
" </head> "
|
|
" <body onload='onload();'> "
|
|
" Nav1 "
|
|
" </body> "
|
|
"</html>",
|
|
"text/html");
|
|
AddResource(
|
|
kDynIfrNav2,
|
|
"<html><head><title>Nav2</title></head><body>Nav2</body></html>",
|
|
"text/html");
|
|
|
|
// Create the browser.
|
|
CreateBrowser(CefString());
|
|
|
|
// Time out the test after a reasonable period of time.
|
|
SetTestTimeout();
|
|
}
|
|
|
|
void RunNav(CefRefPtr<CefBrowser> browser) {
|
|
EXPECT_LE(nav_, 3);
|
|
EXPECT_FALSE(got_load_start_[nav_]);
|
|
EXPECT_FALSE(got_load_end_[nav_]);
|
|
|
|
if (nav_ == 0) {
|
|
browser->GetMainFrame()->LoadURL(kDynIfrNav1);
|
|
} else if (nav_ == 1) {
|
|
browser->GetMainFrame()->LoadURL(kDynIfrNav2);
|
|
} else if (nav_ == 2) {
|
|
browser->GoBack();
|
|
} else if (nav_ == 3) {
|
|
browser->Reload();
|
|
}
|
|
}
|
|
|
|
void OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
|
|
TestHandler::OnAfterCreated(browser);
|
|
|
|
nav_ = 0;
|
|
RunNav(browser);
|
|
}
|
|
|
|
void OnLoadStart(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
TransitionType transition_type) override {
|
|
if (!frame->IsMain()) {
|
|
return;
|
|
}
|
|
got_load_start_[nav_].yes();
|
|
}
|
|
|
|
void OnLoadEnd(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
int httpStatusCode) override {
|
|
if (!frame->IsMain()) {
|
|
return;
|
|
}
|
|
CefString url = browser->GetMainFrame()->GetURL();
|
|
got_load_end_[nav_].yes();
|
|
|
|
if (nav_ == 3) {
|
|
EXPECT_STREQ(url.ToString().c_str(), kDynIfrNav1);
|
|
DestroyTest();
|
|
return;
|
|
}
|
|
|
|
nav_++;
|
|
RunNav(browser);
|
|
}
|
|
|
|
int nav_ = -1;
|
|
TrackCallback got_load_start_[4];
|
|
TrackCallback got_load_end_[4];
|
|
|
|
IMPLEMENT_REFCOUNTING(HistoryDynamicIFramesNavTestHandler);
|
|
};
|
|
|
|
} // namespace
|
|
|
|
// Verify history navigation of pages containing dynamically created iframes.
|
|
// See issue #2022 for background.
|
|
TEST(NavigationTest, HistoryDynamicIFrames) {
|
|
CefRefPtr<HistoryDynamicIFramesNavTestHandler> handler =
|
|
new HistoryDynamicIFramesNavTestHandler();
|
|
handler->ExecuteTest();
|
|
|
|
for (int i = 0; i < 4; ++i) {
|
|
EXPECT_TRUE(handler->got_load_start_[i]);
|
|
EXPECT_TRUE(handler->got_load_end_[i]);
|
|
}
|
|
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
namespace {
|
|
|
|
const char kRNav1[] = "https://tests/nav1.html";
|
|
const char kRNav2[] = "https://tests/nav2.html";
|
|
const char kRNav3[] = "https://tests/nav3.html";
|
|
const char kRNav4[] = "https://tests/nav4.html";
|
|
|
|
bool g_got_nav1_request = false;
|
|
bool g_got_nav3_request = false;
|
|
bool g_got_nav4_request = false;
|
|
bool g_got_invalid_request = false;
|
|
|
|
class RedirectSchemeHandler : public CefResourceHandler {
|
|
public:
|
|
RedirectSchemeHandler() = default;
|
|
|
|
bool Open(CefRefPtr<CefRequest> request,
|
|
bool& handle_request,
|
|
CefRefPtr<CefCallback> callback) override {
|
|
EXPECT_FALSE(CefCurrentlyOn(TID_UI) || CefCurrentlyOn(TID_IO));
|
|
|
|
std::string url = request->GetURL();
|
|
if (url == kRNav1) {
|
|
// Redirect using HTTP 302
|
|
g_got_nav1_request = true;
|
|
status_ = 302;
|
|
location_ = kRNav2;
|
|
content_ = "<html><body>Redirected Nav1</body></html>";
|
|
} else if (url == kRNav3) {
|
|
// Redirect using redirectUrl
|
|
g_got_nav3_request = true;
|
|
status_ = -1;
|
|
location_ = kRNav4;
|
|
content_ = "<html><body>Redirected Nav3</body></html>";
|
|
} else if (url == kRNav4) {
|
|
g_got_nav4_request = true;
|
|
status_ = 200;
|
|
content_ = "<html><body>Nav4</body></html>";
|
|
}
|
|
|
|
handle_request = true;
|
|
|
|
if (status_ != 0) {
|
|
// Continue request.
|
|
return true;
|
|
}
|
|
|
|
// Cancel request.
|
|
g_got_invalid_request = true;
|
|
return false;
|
|
}
|
|
|
|
void GetResponseHeaders(CefRefPtr<CefResponse> response,
|
|
int64_t& response_length,
|
|
CefString& redirectUrl) override {
|
|
EXPECT_TRUE(CefCurrentlyOn(TID_IO));
|
|
|
|
EXPECT_NE(status_, 0);
|
|
|
|
response->SetStatus(status_);
|
|
response->SetMimeType("text/html");
|
|
response_length = content_.size();
|
|
|
|
if (status_ == 302) {
|
|
// Redirect using HTTP 302
|
|
EXPECT_GT(location_.size(), static_cast<size_t>(0));
|
|
response->SetStatusText("Found");
|
|
CefResponse::HeaderMap headers;
|
|
response->GetHeaderMap(headers);
|
|
headers.insert(std::make_pair("Location", location_));
|
|
response->SetHeaderMap(headers);
|
|
} else if (status_ == -1) {
|
|
// Rdirect using redirectUrl
|
|
EXPECT_GT(location_.size(), static_cast<size_t>(0));
|
|
redirectUrl = location_;
|
|
}
|
|
}
|
|
|
|
void Cancel() override { EXPECT_TRUE(CefCurrentlyOn(TID_IO)); }
|
|
|
|
bool Read(void* data_out,
|
|
int bytes_to_read,
|
|
int& bytes_read,
|
|
CefRefPtr<CefResourceReadCallback> callback) override {
|
|
EXPECT_FALSE(CefCurrentlyOn(TID_UI) || CefCurrentlyOn(TID_IO));
|
|
|
|
bytes_read = 0;
|
|
bool has_data = false;
|
|
|
|
size_t size = content_.size();
|
|
if (offset_ < size) {
|
|
int transfer_size =
|
|
std::min(bytes_to_read, static_cast<int>(size - offset_));
|
|
memcpy(data_out, content_.c_str() + offset_, transfer_size);
|
|
offset_ += transfer_size;
|
|
|
|
bytes_read = transfer_size;
|
|
has_data = true;
|
|
}
|
|
|
|
return has_data;
|
|
}
|
|
|
|
protected:
|
|
std::string content_;
|
|
size_t offset_ = 0;
|
|
int status_ = 0;
|
|
std::string location_;
|
|
|
|
IMPLEMENT_REFCOUNTING(RedirectSchemeHandler);
|
|
DISALLOW_COPY_AND_ASSIGN(RedirectSchemeHandler);
|
|
};
|
|
|
|
class RedirectSchemeHandlerFactory : public CefSchemeHandlerFactory {
|
|
public:
|
|
RedirectSchemeHandlerFactory() {
|
|
g_got_nav1_request = false;
|
|
g_got_nav3_request = false;
|
|
g_got_nav4_request = false;
|
|
g_got_invalid_request = false;
|
|
}
|
|
|
|
CefRefPtr<CefResourceHandler> Create(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
const CefString& scheme_name,
|
|
CefRefPtr<CefRequest> request) override {
|
|
EXPECT_TRUE(CefCurrentlyOn(TID_IO));
|
|
return new RedirectSchemeHandler();
|
|
}
|
|
|
|
IMPLEMENT_REFCOUNTING(RedirectSchemeHandlerFactory);
|
|
DISALLOW_COPY_AND_ASSIGN(RedirectSchemeHandlerFactory);
|
|
};
|
|
|
|
class RedirectTestHandler : public TestHandler {
|
|
public:
|
|
RedirectTestHandler() = default;
|
|
|
|
void RunTest() override {
|
|
// Create the browser.
|
|
CreateBrowser(kRNav1);
|
|
|
|
// Time out the test after a reasonable period of time.
|
|
SetTestTimeout();
|
|
}
|
|
|
|
cef_return_value_t OnBeforeResourceLoad(
|
|
CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefRequest> request,
|
|
CefRefPtr<CefCallback> callback) override {
|
|
if (IsChromeRuntimeEnabled() && request->GetResourceType() == RT_FAVICON) {
|
|
// Ignore favicon requests.
|
|
return RV_CANCEL;
|
|
}
|
|
|
|
// Should be called for all but the second URL.
|
|
std::string url = request->GetURL();
|
|
|
|
EXPECT_EQ(RT_MAIN_FRAME, request->GetResourceType());
|
|
EXPECT_EQ(kTransitionExplicitLoad, request->GetTransitionType());
|
|
|
|
if (url == kRNav1) {
|
|
got_nav1_before_resource_load_.yes();
|
|
} else if (url == kRNav3) {
|
|
got_nav3_before_resource_load_.yes();
|
|
} else if (url == kRNav4) {
|
|
got_nav4_before_resource_load_.yes();
|
|
} else {
|
|
got_invalid_before_resource_load_.yes();
|
|
}
|
|
|
|
return RV_CONTINUE;
|
|
}
|
|
|
|
void OnResourceRedirect(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefRequest> request,
|
|
CefRefPtr<CefResponse> response,
|
|
CefString& new_url) override {
|
|
// Should be called for each redirected URL.
|
|
|
|
const std::string& old_url = request->GetURL();
|
|
if (old_url == kRNav1 && new_url == kRNav2) {
|
|
// Called due to the nav1 redirect response.
|
|
got_nav1_redirect_.yes();
|
|
|
|
EXPECT_EQ(302, response->GetStatus());
|
|
EXPECT_STREQ("Found", response->GetStatusText().ToString().c_str());
|
|
EXPECT_STREQ("", response->GetMimeType().ToString().c_str());
|
|
EXPECT_STREQ(kRNav2,
|
|
response->GetHeaderByName("Location").ToString().c_str());
|
|
|
|
// Change the redirect to the 3rd URL.
|
|
new_url = kRNav3;
|
|
} else if (old_url == kRNav1 && new_url == kRNav3) {
|
|
// Called due to the redirect change above.
|
|
got_nav2_redirect_.yes();
|
|
|
|
EXPECT_EQ(307, response->GetStatus());
|
|
EXPECT_STREQ("Internal Redirect",
|
|
response->GetStatusText().ToString().c_str());
|
|
EXPECT_TRUE(response->GetMimeType().empty());
|
|
EXPECT_STREQ(kRNav3,
|
|
response->GetHeaderByName("Location").ToString().c_str());
|
|
} else if (old_url == kRNav3 && new_url == kRNav4) {
|
|
// Called due to the nav3 redirect response.
|
|
got_nav3_redirect_.yes();
|
|
|
|
EXPECT_EQ(307, response->GetStatus());
|
|
EXPECT_STREQ("Temporary Redirect",
|
|
response->GetStatusText().ToString().c_str());
|
|
EXPECT_STREQ("", response->GetMimeType().ToString().c_str());
|
|
} else {
|
|
got_invalid_redirect_.yes();
|
|
}
|
|
}
|
|
|
|
void OnLoadStart(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
TransitionType transition_type) override {
|
|
// Should only be called for the final loaded URL.
|
|
std::string url = frame->GetURL();
|
|
|
|
EXPECT_EQ(kTransitionExplicitLoad, transition_type);
|
|
|
|
if (url == kRNav4) {
|
|
got_nav4_load_start_.yes();
|
|
} else {
|
|
got_invalid_load_start_.yes();
|
|
}
|
|
}
|
|
|
|
void OnLoadEnd(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
int httpStatusCode) override {
|
|
// Should only be called for the final loaded URL.
|
|
std::string url = frame->GetURL();
|
|
|
|
if (url == kRNav4) {
|
|
got_nav4_load_end_.yes();
|
|
DestroyTest();
|
|
} else {
|
|
got_invalid_load_end_.yes();
|
|
}
|
|
}
|
|
|
|
TrackCallback got_nav1_before_resource_load_;
|
|
TrackCallback got_nav3_before_resource_load_;
|
|
TrackCallback got_nav4_before_resource_load_;
|
|
TrackCallback got_invalid_before_resource_load_;
|
|
TrackCallback got_nav4_load_start_;
|
|
TrackCallback got_invalid_load_start_;
|
|
TrackCallback got_nav4_load_end_;
|
|
TrackCallback got_invalid_load_end_;
|
|
TrackCallback got_nav1_redirect_;
|
|
TrackCallback got_nav2_redirect_;
|
|
TrackCallback got_nav3_redirect_;
|
|
TrackCallback got_invalid_redirect_;
|
|
|
|
IMPLEMENT_REFCOUNTING(RedirectTestHandler);
|
|
};
|
|
|
|
// Like above but destroy the WebContents while the redirect is in-progress.
|
|
class RedirectDestroyTestHandler : public TestHandler {
|
|
public:
|
|
RedirectDestroyTestHandler() = default;
|
|
|
|
void RunTest() override {
|
|
// Create the browser.
|
|
CreateBrowser(kRNav1);
|
|
|
|
// Time out the test after a reasonable period of time.
|
|
SetTestTimeout();
|
|
}
|
|
|
|
void OnResourceRedirect(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefRequest> request,
|
|
CefRefPtr<CefResponse> response,
|
|
CefString& new_url) override {
|
|
const std::string& old_url = request->GetURL();
|
|
if (old_url == kRNav1 && new_url == kRNav2) {
|
|
// Called due to the nav1 redirect response.
|
|
got_nav1_redirect_.yes();
|
|
|
|
new_url = "about:blank";
|
|
|
|
// Destroy the test (and the underlying WebContents) while the redirect
|
|
// is still pending.
|
|
DestroyTest();
|
|
}
|
|
}
|
|
|
|
TrackCallback got_nav1_redirect_;
|
|
|
|
IMPLEMENT_REFCOUNTING(RedirectDestroyTestHandler);
|
|
};
|
|
|
|
} // namespace
|
|
|
|
// Verify frame names and identifiers.
|
|
TEST(NavigationTest, Redirect) {
|
|
CefRegisterSchemeHandlerFactory("https", "tests",
|
|
new RedirectSchemeHandlerFactory());
|
|
WaitForIOThread();
|
|
|
|
CefRefPtr<RedirectTestHandler> handler = new RedirectTestHandler();
|
|
handler->ExecuteTest();
|
|
|
|
CefClearSchemeHandlerFactories();
|
|
WaitForIOThread();
|
|
|
|
EXPECT_TRUE(handler->got_nav1_before_resource_load_);
|
|
EXPECT_TRUE(handler->got_nav3_before_resource_load_);
|
|
EXPECT_TRUE(handler->got_nav4_before_resource_load_);
|
|
EXPECT_FALSE(handler->got_invalid_before_resource_load_);
|
|
EXPECT_TRUE(handler->got_nav4_load_start_);
|
|
EXPECT_FALSE(handler->got_invalid_load_start_);
|
|
EXPECT_TRUE(handler->got_nav4_load_end_);
|
|
EXPECT_FALSE(handler->got_invalid_load_end_);
|
|
EXPECT_TRUE(handler->got_nav1_redirect_);
|
|
EXPECT_FALSE(handler->got_nav2_redirect_);
|
|
EXPECT_TRUE(handler->got_nav3_redirect_);
|
|
EXPECT_FALSE(handler->got_invalid_redirect_);
|
|
EXPECT_TRUE(g_got_nav1_request);
|
|
EXPECT_TRUE(g_got_nav3_request);
|
|
EXPECT_TRUE(g_got_nav4_request);
|
|
EXPECT_FALSE(g_got_invalid_request);
|
|
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
// Verify that destroying the WebContents while the redirect is in-progress does
|
|
// not result in a crash.
|
|
TEST(NavigationTest, RedirectDestroy) {
|
|
CefRegisterSchemeHandlerFactory("https", "tests",
|
|
new RedirectSchemeHandlerFactory());
|
|
WaitForIOThread();
|
|
|
|
CefRefPtr<RedirectDestroyTestHandler> handler =
|
|
new RedirectDestroyTestHandler();
|
|
handler->ExecuteTest();
|
|
|
|
CefClearSchemeHandlerFactories();
|
|
WaitForIOThread();
|
|
|
|
EXPECT_TRUE(handler->got_nav1_redirect_);
|
|
EXPECT_TRUE(g_got_nav1_request);
|
|
EXPECT_FALSE(g_got_nav3_request);
|
|
EXPECT_FALSE(g_got_nav4_request);
|
|
EXPECT_FALSE(g_got_invalid_request);
|
|
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
namespace {
|
|
|
|
const char KONav1[] = "https://tests-onav.com/nav1.html";
|
|
const char KONav2[] = "https://tests-onav.com/nav2.html";
|
|
const char kOrderNavMsg[] = "NavigationTest.OrderNav";
|
|
const char kOrderNavClosedMsg[] = "NavigationTest.OrderNavClosed";
|
|
const char kOrderNavTestCmdKey[] = "nav-order-test";
|
|
|
|
class OrderNavLoadState {
|
|
public:
|
|
OrderNavLoadState(bool is_popup, bool browser_side)
|
|
: is_popup_(is_popup), browser_side_(browser_side) {}
|
|
|
|
void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
|
|
bool isLoading,
|
|
bool canGoBack,
|
|
bool canGoForward) {
|
|
if (isLoading) {
|
|
EXPECT_TRUE(Verify(false, false, false, false));
|
|
|
|
got_loading_state_start_.yes();
|
|
} else {
|
|
EXPECT_TRUE(Verify(true, false, true, true));
|
|
|
|
got_loading_state_end_.yes();
|
|
}
|
|
}
|
|
|
|
void OnLoadStart(CefRefPtr<CefBrowser> browser, CefRefPtr<CefFrame> frame) {
|
|
EXPECT_TRUE(Verify(true, false, false, false));
|
|
|
|
got_load_start_.yes();
|
|
}
|
|
|
|
void OnLoadEnd(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
int httpStatusCode) {
|
|
EXPECT_TRUE(Verify(true, false, true, false));
|
|
|
|
got_load_end_.yes();
|
|
}
|
|
|
|
bool IsStarted() const {
|
|
return got_loading_state_start_ || got_loading_state_end_ ||
|
|
got_load_start_ || got_load_end_;
|
|
}
|
|
|
|
bool IsDone() const {
|
|
return got_loading_state_start_ && got_loading_state_end_ &&
|
|
got_load_start_ && got_load_end_;
|
|
}
|
|
|
|
bool Verify(bool got_loading_state_start,
|
|
bool got_loading_state_end,
|
|
bool got_load_start,
|
|
bool got_load_end) const {
|
|
EXPECT_EQ(got_loading_state_start, got_loading_state_start_)
|
|
<< "Popup: " << is_popup_ << "; Browser Side: " << browser_side_;
|
|
EXPECT_EQ(got_loading_state_end, got_loading_state_end_)
|
|
<< "Popup: " << is_popup_ << "; Browser Side: " << browser_side_;
|
|
EXPECT_EQ(got_load_start, got_load_start_)
|
|
<< "Popup: " << is_popup_ << "; Browser Side: " << browser_side_;
|
|
EXPECT_EQ(got_load_end, got_load_end_)
|
|
<< "Popup: " << is_popup_ << "; Browser Side: " << browser_side_;
|
|
|
|
return got_loading_state_start == got_loading_state_start_ &&
|
|
got_loading_state_end == got_loading_state_end_ &&
|
|
got_load_start == got_load_start_ && got_load_end == got_load_end_;
|
|
}
|
|
|
|
private:
|
|
bool is_popup_;
|
|
bool browser_side_;
|
|
|
|
TrackCallback got_loading_state_start_;
|
|
TrackCallback got_loading_state_end_;
|
|
TrackCallback got_load_start_;
|
|
TrackCallback got_load_end_;
|
|
};
|
|
|
|
// Renderer side.
|
|
class OrderNavRendererTest : public ClientAppRenderer::Delegate,
|
|
public CefLoadHandler {
|
|
public:
|
|
OrderNavRendererTest()
|
|
: state_main_(false, false), state_popup_(true, false) {}
|
|
|
|
void OnWebKitInitialized(CefRefPtr<ClientAppRenderer> app) override {
|
|
EXPECT_FALSE(got_webkit_initialized_);
|
|
|
|
got_webkit_initialized_.yes();
|
|
}
|
|
|
|
void OnBrowserCreated(CefRefPtr<ClientAppRenderer> app,
|
|
CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefDictionaryValue> extra_info) override {
|
|
run_test_ = extra_info && extra_info->HasKey(kOrderNavTestCmdKey);
|
|
if (!run_test_) {
|
|
return;
|
|
}
|
|
|
|
EXPECT_TRUE(got_webkit_initialized_);
|
|
|
|
if (browser->IsPopup()) {
|
|
EXPECT_FALSE(got_browser_created_popup_);
|
|
EXPECT_FALSE(got_browser_destroyed_popup_);
|
|
EXPECT_FALSE(state_popup_.IsStarted());
|
|
|
|
got_browser_created_popup_.yes();
|
|
browser_id_popup_ = browser->GetIdentifier();
|
|
EXPECT_GT(browser->GetIdentifier(), 0);
|
|
} else {
|
|
EXPECT_FALSE(got_browser_created_main_);
|
|
EXPECT_FALSE(got_browser_destroyed_main_);
|
|
EXPECT_FALSE(state_main_.IsStarted());
|
|
|
|
got_browser_created_main_.yes();
|
|
browser_id_main_ = browser->GetIdentifier();
|
|
EXPECT_GT(browser->GetIdentifier(), 0);
|
|
|
|
browser_main_ = browser;
|
|
}
|
|
}
|
|
|
|
void OnBrowserDestroyed(CefRefPtr<ClientAppRenderer> app,
|
|
CefRefPtr<CefBrowser> browser) override {
|
|
if (!run_test_) {
|
|
return;
|
|
}
|
|
|
|
EXPECT_TRUE(got_webkit_initialized_);
|
|
|
|
if (browser->IsPopup()) {
|
|
EXPECT_TRUE(got_browser_created_popup_);
|
|
EXPECT_FALSE(got_browser_destroyed_popup_);
|
|
EXPECT_TRUE(state_popup_.IsDone());
|
|
|
|
got_browser_destroyed_popup_.yes();
|
|
EXPECT_EQ(browser_id_popup_, browser->GetIdentifier());
|
|
EXPECT_GT(browser->GetIdentifier(), 0);
|
|
|
|
// Use |browser_main_| to send the message otherwise it will fail.
|
|
SendTestResults(browser_main_, browser_main_->GetMainFrame(),
|
|
kOrderNavClosedMsg);
|
|
} else {
|
|
EXPECT_TRUE(got_browser_created_main_);
|
|
EXPECT_FALSE(got_browser_destroyed_main_);
|
|
EXPECT_TRUE(state_main_.IsDone());
|
|
|
|
got_browser_destroyed_main_.yes();
|
|
EXPECT_EQ(browser_id_main_, browser->GetIdentifier());
|
|
EXPECT_GT(browser->GetIdentifier(), 0);
|
|
|
|
browser_main_ = nullptr;
|
|
}
|
|
}
|
|
|
|
CefRefPtr<CefLoadHandler> GetLoadHandler(
|
|
CefRefPtr<ClientAppRenderer> app) override {
|
|
if (!run_test_) {
|
|
return nullptr;
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
|
|
bool isLoading,
|
|
bool canGoBack,
|
|
bool canGoForward) override {
|
|
EXPECT_TRUE(got_webkit_initialized_);
|
|
|
|
if (browser->IsPopup()) {
|
|
EXPECT_TRUE(got_browser_created_popup_);
|
|
EXPECT_FALSE(got_browser_destroyed_popup_);
|
|
|
|
state_popup_.OnLoadingStateChange(browser, isLoading, canGoBack,
|
|
canGoForward);
|
|
} else {
|
|
EXPECT_TRUE(got_browser_created_main_);
|
|
EXPECT_FALSE(got_browser_destroyed_main_);
|
|
|
|
state_main_.OnLoadingStateChange(browser, isLoading, canGoBack,
|
|
canGoForward);
|
|
}
|
|
|
|
if (!isLoading) {
|
|
SendTestResultsIfDone(browser, browser->GetMainFrame());
|
|
}
|
|
}
|
|
|
|
void OnLoadStart(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
TransitionType transition_type) override {
|
|
EXPECT_TRUE(got_webkit_initialized_);
|
|
|
|
if (browser->IsPopup()) {
|
|
EXPECT_TRUE(got_browser_created_popup_);
|
|
EXPECT_FALSE(got_browser_destroyed_popup_);
|
|
|
|
state_popup_.OnLoadStart(browser, frame);
|
|
} else {
|
|
EXPECT_TRUE(got_browser_created_main_);
|
|
EXPECT_FALSE(got_browser_destroyed_main_);
|
|
|
|
state_main_.OnLoadStart(browser, frame);
|
|
}
|
|
}
|
|
|
|
void OnLoadEnd(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
int httpStatusCode) override {
|
|
EXPECT_TRUE(got_webkit_initialized_);
|
|
|
|
if (browser->IsPopup()) {
|
|
EXPECT_TRUE(got_browser_created_popup_);
|
|
EXPECT_FALSE(got_browser_destroyed_popup_);
|
|
|
|
state_popup_.OnLoadEnd(browser, frame, httpStatusCode);
|
|
} else {
|
|
EXPECT_TRUE(got_browser_created_main_);
|
|
EXPECT_FALSE(got_browser_destroyed_main_);
|
|
|
|
state_main_.OnLoadEnd(browser, frame, httpStatusCode);
|
|
}
|
|
|
|
SendTestResultsIfDone(browser, frame);
|
|
}
|
|
|
|
void OnLoadError(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
ErrorCode errorCode,
|
|
const CefString& errorText,
|
|
const CefString& failedUrl) override {
|
|
ADD_FAILURE() << "renderer OnLoadError url: " << failedUrl.ToString()
|
|
<< " error: " << errorCode;
|
|
}
|
|
|
|
protected:
|
|
void SendTestResultsIfDone(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame) {
|
|
bool done = false;
|
|
if (browser->IsPopup()) {
|
|
done = state_popup_.IsDone();
|
|
} else {
|
|
done = state_main_.IsDone();
|
|
}
|
|
|
|
if (done) {
|
|
SendTestResults(browser, frame, kOrderNavMsg);
|
|
}
|
|
}
|
|
|
|
// Send the test results.
|
|
void SendTestResults(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
const char* msg_name) {
|
|
// Check if the test has failed.
|
|
bool result = !TestFailed();
|
|
|
|
// Return the result to the browser process.
|
|
CefRefPtr<CefProcessMessage> return_msg =
|
|
CefProcessMessage::Create(msg_name);
|
|
CefRefPtr<CefListValue> args = return_msg->GetArgumentList();
|
|
EXPECT_TRUE(args.get());
|
|
EXPECT_TRUE(args->SetBool(0, result));
|
|
if (browser->IsPopup()) {
|
|
EXPECT_TRUE(args->SetInt(1, browser_id_popup_));
|
|
} else {
|
|
EXPECT_TRUE(args->SetInt(1, browser_id_main_));
|
|
}
|
|
frame->SendProcessMessage(PID_BROWSER, return_msg);
|
|
}
|
|
|
|
bool run_test_ = false;
|
|
|
|
int browser_id_main_ = 0;
|
|
int browser_id_popup_ = 0;
|
|
CefRefPtr<CefBrowser> browser_main_;
|
|
TrackCallback got_webkit_initialized_;
|
|
TrackCallback got_browser_created_main_;
|
|
TrackCallback got_browser_destroyed_main_;
|
|
TrackCallback got_browser_created_popup_;
|
|
TrackCallback got_browser_destroyed_popup_;
|
|
|
|
OrderNavLoadState state_main_;
|
|
OrderNavLoadState state_popup_;
|
|
|
|
IMPLEMENT_REFCOUNTING(OrderNavRendererTest);
|
|
};
|
|
|
|
// Browser side.
|
|
class OrderNavTestHandler : public TestHandler {
|
|
public:
|
|
OrderNavTestHandler() : state_main_(false, true), state_popup_(true, true) {}
|
|
|
|
// Returns state that will be checked in the renderer process via
|
|
// OrderNavRendererTest::OnBrowserCreated.
|
|
CefRefPtr<CefDictionaryValue> GetExtraInfo() {
|
|
CefRefPtr<CefDictionaryValue> extra_info = CefDictionaryValue::Create();
|
|
extra_info->SetBool(kOrderNavTestCmdKey, true);
|
|
return extra_info;
|
|
}
|
|
|
|
void RunTest() override {
|
|
// Add the resources that we will navigate to/from.
|
|
AddResource(KONav1, "<html>Nav1</html>", "text/html");
|
|
AddResource(KONav2, "<html>Nav2</html>", "text/html");
|
|
|
|
// Create the browser.
|
|
CreateBrowser(KONav1, nullptr, GetExtraInfo());
|
|
|
|
// Time out the test after a reasonable period of time.
|
|
SetTestTimeout();
|
|
}
|
|
|
|
void ContinueIfReady(CefRefPtr<CefBrowser> browser) {
|
|
if (!got_message_) {
|
|
return;
|
|
}
|
|
|
|
bool done = false;
|
|
if (browser->IsPopup()) {
|
|
done = state_popup_.IsDone();
|
|
} else {
|
|
done = state_main_.IsDone();
|
|
}
|
|
if (!done) {
|
|
return;
|
|
}
|
|
|
|
got_message_ = false;
|
|
|
|
if (!browser->IsPopup()) {
|
|
GrantPopupPermission(browser->GetHost()->GetRequestContext(),
|
|
browser->GetMainFrame()->GetURL());
|
|
|
|
// Create the popup window.
|
|
browser->GetMainFrame()->ExecuteJavaScript(
|
|
"window.open('" + std::string(KONav2) + "');", CefString(), 0);
|
|
} else {
|
|
// Close the popup window.
|
|
CloseBrowser(browser_popup_, false);
|
|
}
|
|
}
|
|
|
|
bool OnBeforePopup(
|
|
CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
const CefString& target_url,
|
|
const CefString& target_frame_name,
|
|
CefLifeSpanHandler::WindowOpenDisposition target_disposition,
|
|
bool user_gesture,
|
|
const CefPopupFeatures& popupFeatures,
|
|
CefWindowInfo& windowInfo,
|
|
CefRefPtr<CefClient>& client,
|
|
CefBrowserSettings& settings,
|
|
CefRefPtr<CefDictionaryValue>& extra_info,
|
|
bool* no_javascript_access) override {
|
|
extra_info = GetExtraInfo();
|
|
return false;
|
|
}
|
|
|
|
void OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
|
|
TestHandler::OnAfterCreated(browser);
|
|
|
|
if (browser->IsPopup()) {
|
|
browser_id_popup_ = browser->GetIdentifier();
|
|
EXPECT_GT(browser_id_popup_, 0);
|
|
browser_popup_ = browser;
|
|
} else {
|
|
browser_id_main_ = browser->GetIdentifier();
|
|
EXPECT_GT(browser_id_main_, 0);
|
|
}
|
|
}
|
|
|
|
bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefRequest> request,
|
|
bool user_gesture,
|
|
bool is_redirect) override {
|
|
EXPECT_EQ(RT_MAIN_FRAME, request->GetResourceType());
|
|
|
|
if (browser->IsPopup()) {
|
|
EXPECT_EQ(TT_LINK, request->GetTransitionType());
|
|
EXPECT_GT(browser->GetIdentifier(), 0);
|
|
EXPECT_EQ(browser_id_popup_, browser->GetIdentifier());
|
|
got_before_browse_popup_.yes();
|
|
} else {
|
|
EXPECT_EQ(kTransitionExplicitLoad, request->GetTransitionType());
|
|
EXPECT_GT(browser->GetIdentifier(), 0);
|
|
EXPECT_EQ(browser_id_main_, browser->GetIdentifier());
|
|
got_before_browse_main_.yes();
|
|
}
|
|
|
|
std::string url = request->GetURL();
|
|
if (url == KONav1) {
|
|
EXPECT_FALSE(browser->IsPopup());
|
|
} else if (url == KONav2) {
|
|
EXPECT_TRUE(browser->IsPopup());
|
|
} else {
|
|
EXPECT_TRUE(false); // not reached
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
cef_return_value_t OnBeforeResourceLoad(
|
|
CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefRequest> request,
|
|
CefRefPtr<CefCallback> callback) override {
|
|
if (IsChromeRuntimeEnabled() && request->GetResourceType() == RT_FAVICON) {
|
|
// Ignore favicon requests.
|
|
return RV_CANCEL;
|
|
}
|
|
|
|
EXPECT_EQ(RT_MAIN_FRAME, request->GetResourceType());
|
|
|
|
if (browser->IsPopup()) {
|
|
EXPECT_EQ(TT_LINK, request->GetTransitionType());
|
|
EXPECT_GT(browser->GetIdentifier(), 0);
|
|
EXPECT_EQ(browser_id_popup_, browser->GetIdentifier());
|
|
} else {
|
|
EXPECT_EQ(kTransitionExplicitLoad, request->GetTransitionType());
|
|
EXPECT_GT(browser->GetIdentifier(), 0);
|
|
EXPECT_EQ(browser_id_main_, browser->GetIdentifier());
|
|
}
|
|
|
|
return RV_CONTINUE;
|
|
}
|
|
|
|
void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
|
|
bool isLoading,
|
|
bool canGoBack,
|
|
bool canGoForward) override {
|
|
if (browser->IsPopup()) {
|
|
state_popup_.OnLoadingStateChange(browser, isLoading, canGoBack,
|
|
canGoForward);
|
|
} else {
|
|
state_main_.OnLoadingStateChange(browser, isLoading, canGoBack,
|
|
canGoForward);
|
|
}
|
|
|
|
if (!isLoading) {
|
|
ContinueIfReady(browser);
|
|
}
|
|
}
|
|
|
|
void OnLoadStart(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
TransitionType transition_type) override {
|
|
if (browser->IsPopup()) {
|
|
EXPECT_EQ(TT_LINK, transition_type);
|
|
state_popup_.OnLoadStart(browser, frame);
|
|
} else {
|
|
EXPECT_EQ(kTransitionExplicitLoad, transition_type);
|
|
state_main_.OnLoadStart(browser, frame);
|
|
}
|
|
}
|
|
|
|
void OnLoadEnd(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
int httpStatusCode) override {
|
|
if (browser->IsPopup()) {
|
|
state_popup_.OnLoadEnd(browser, frame, httpStatusCode);
|
|
} else {
|
|
state_main_.OnLoadEnd(browser, frame, httpStatusCode);
|
|
}
|
|
|
|
ContinueIfReady(browser);
|
|
}
|
|
|
|
void OnLoadError(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
ErrorCode errorCode,
|
|
const CefString& errorText,
|
|
const CefString& failedUrl) override {
|
|
ADD_FAILURE() << "browser OnLoadError url: " << failedUrl.ToString()
|
|
<< " error: " << errorCode;
|
|
}
|
|
|
|
bool OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefProcessId source_process,
|
|
CefRefPtr<CefProcessMessage> message) override {
|
|
if (browser->IsPopup()) {
|
|
EXPECT_GT(browser->GetIdentifier(), 0);
|
|
EXPECT_EQ(browser_id_popup_, browser->GetIdentifier());
|
|
} else {
|
|
EXPECT_GT(browser->GetIdentifier(), 0);
|
|
EXPECT_EQ(browser_id_main_, browser->GetIdentifier());
|
|
}
|
|
|
|
const std::string& msg_name = message->GetName();
|
|
if (msg_name == kOrderNavMsg || msg_name == kOrderNavClosedMsg) {
|
|
// Test that the renderer side succeeded.
|
|
CefRefPtr<CefListValue> args = message->GetArgumentList();
|
|
EXPECT_TRUE(args.get());
|
|
EXPECT_TRUE(args->GetBool(0));
|
|
|
|
if (browser->IsPopup()) {
|
|
EXPECT_EQ(browser_id_popup_, args->GetInt(1));
|
|
} else {
|
|
EXPECT_EQ(browser_id_main_, args->GetInt(1));
|
|
}
|
|
|
|
if (msg_name == kOrderNavMsg) {
|
|
// Continue with the test.
|
|
got_message_ = true;
|
|
ContinueIfReady(browser);
|
|
} else {
|
|
// Popup was closed. End the test.
|
|
browser_popup_ = nullptr;
|
|
DestroyTest();
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Message not handled.
|
|
return false;
|
|
}
|
|
|
|
protected:
|
|
void DestroyTest() override {
|
|
// Verify test expectations.
|
|
EXPECT_TRUE(got_before_browse_main_);
|
|
EXPECT_TRUE(got_before_browse_popup_);
|
|
|
|
EXPECT_TRUE(state_main_.Verify(true, true, true, true));
|
|
EXPECT_TRUE(state_popup_.Verify(true, true, true, true));
|
|
|
|
TestHandler::DestroyTest();
|
|
}
|
|
|
|
int browser_id_main_ = 0;
|
|
int browser_id_popup_ = 0;
|
|
CefRefPtr<CefBrowser> browser_popup_;
|
|
|
|
TrackCallback got_before_browse_main_;
|
|
TrackCallback got_before_browse_popup_;
|
|
|
|
OrderNavLoadState state_main_;
|
|
OrderNavLoadState state_popup_;
|
|
|
|
bool got_message_ = false;
|
|
|
|
IMPLEMENT_REFCOUNTING(OrderNavTestHandler);
|
|
};
|
|
|
|
} // namespace
|
|
|
|
// Verify the order of navigation-related callbacks.
|
|
TEST(NavigationTest, Order) {
|
|
CefRefPtr<OrderNavTestHandler> handler = new OrderNavTestHandler();
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
namespace {
|
|
|
|
const char kLoadNav1[] = "https://tests-conav1.com/nav1.html";
|
|
const char kLoadNavSameOrigin2[] = "https://tests-conav1.com/nav2.html";
|
|
const char kLoadNavCrossOrigin2[] = "https://tests-conav2.com/nav2.html";
|
|
const char kLoadNavMsg[] = "NavigationTest.LoadNav";
|
|
const char kLoadNavTestCmdKey[] = "nav-load-test";
|
|
|
|
bool IsInitialUrl(const CefString& url) {
|
|
return url == kLoadNav1;
|
|
}
|
|
|
|
// Renderer side.
|
|
class LoadNavRendererTest : public ClientAppRenderer::Delegate,
|
|
public CefLoadHandler {
|
|
public:
|
|
LoadNavRendererTest() = default;
|
|
|
|
void OnBrowserCreated(CefRefPtr<ClientAppRenderer> app,
|
|
CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefDictionaryValue> extra_info) override {
|
|
run_test_ = extra_info && extra_info->HasKey(kLoadNavTestCmdKey);
|
|
if (!run_test_) {
|
|
return;
|
|
}
|
|
|
|
// We'll get multiple calls to OnBrowserCreated for same-site navigations
|
|
// with same-site BFCache enabled.
|
|
const int new_browser_id = browser->GetIdentifier();
|
|
if (browser_id_ != 0) {
|
|
EXPECT_EQ(browser_id_, new_browser_id);
|
|
} else {
|
|
browser_id_ = new_browser_id;
|
|
EXPECT_GT(browser_id_, 0);
|
|
}
|
|
browser_created_ct_++;
|
|
}
|
|
|
|
void OnBrowserDestroyed(CefRefPtr<ClientAppRenderer> app,
|
|
CefRefPtr<CefBrowser> browser) override {
|
|
if (!run_test_) {
|
|
return;
|
|
}
|
|
|
|
EXPECT_GT(load_ct_, 0);
|
|
EXPECT_GT(browser_created_ct_, 0);
|
|
EXPECT_EQ(browser_id_, browser->GetIdentifier());
|
|
}
|
|
|
|
CefRefPtr<CefLoadHandler> GetLoadHandler(
|
|
CefRefPtr<ClientAppRenderer> app) override {
|
|
if (!run_test_) {
|
|
return nullptr;
|
|
}
|
|
|
|
return this;
|
|
}
|
|
|
|
void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
|
|
bool isLoading,
|
|
bool canGoBack,
|
|
bool canGoForward) override {
|
|
if (!isLoading) {
|
|
EXPECT_GT(browser_created_ct_, 0);
|
|
EXPECT_EQ(browser_id_, browser->GetIdentifier());
|
|
|
|
load_ct_++;
|
|
SendTestResults(browser, browser->GetMainFrame());
|
|
}
|
|
}
|
|
|
|
protected:
|
|
// Send the test results.
|
|
void SendTestResults(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame) {
|
|
// Check if the test has failed.
|
|
bool result = !TestFailed();
|
|
|
|
// Return the result to the browser process.
|
|
CefRefPtr<CefProcessMessage> return_msg =
|
|
CefProcessMessage::Create(kLoadNavMsg);
|
|
CefRefPtr<CefListValue> args = return_msg->GetArgumentList();
|
|
EXPECT_TRUE(args.get());
|
|
EXPECT_TRUE(args->SetBool(0, result));
|
|
EXPECT_TRUE(args->SetInt(1, browser->GetIdentifier()));
|
|
EXPECT_TRUE(args->SetInt(2, browser_created_ct_));
|
|
EXPECT_TRUE(args->SetInt(3, load_ct_));
|
|
frame->SendProcessMessage(PID_BROWSER, return_msg);
|
|
}
|
|
|
|
bool run_test_ = false;
|
|
|
|
int browser_id_ = 0;
|
|
int load_ct_ = 0;
|
|
int browser_created_ct_ = 0;
|
|
|
|
IMPLEMENT_REFCOUNTING(LoadNavRendererTest);
|
|
};
|
|
|
|
// Browser side.
|
|
class LoadNavTestHandler : public TestHandler {
|
|
public:
|
|
enum TestMode {
|
|
LOAD,
|
|
LEFT_CLICK,
|
|
MIDDLE_CLICK,
|
|
CTRL_LEFT_CLICK,
|
|
};
|
|
|
|
LoadNavTestHandler(TestMode mode,
|
|
bool same_origin,
|
|
bool cancel_in_open_url = false)
|
|
: mode_(mode),
|
|
same_origin_(same_origin),
|
|
cancel_in_open_url_(cancel_in_open_url) {}
|
|
|
|
std::string GetURL2() const {
|
|
return same_origin_ ? kLoadNavSameOrigin2 : kLoadNavCrossOrigin2;
|
|
}
|
|
|
|
bool ExpectOpenURL() const {
|
|
return mode_ == MIDDLE_CLICK || mode_ == CTRL_LEFT_CLICK;
|
|
}
|
|
|
|
void RunTest() override {
|
|
const std::string& url2 = GetURL2();
|
|
std::string link;
|
|
if (mode_ != LOAD) {
|
|
link = "<a href=\"" + url2 + "\">CLICK ME</a>";
|
|
}
|
|
|
|
// Add the resources that we will navigate to/from.
|
|
AddResource(kLoadNav1,
|
|
"<html><body><h1>" + link + "Nav1</h1></body></html>",
|
|
"text/html");
|
|
AddResource(url2, "<html>Nav2</html>", "text/html");
|
|
|
|
CefRefPtr<CefDictionaryValue> extra_info = CefDictionaryValue::Create();
|
|
extra_info->SetBool(kLoadNavTestCmdKey, true);
|
|
|
|
// Create the browser.
|
|
CreateBrowser(kLoadNav1, nullptr, extra_info);
|
|
|
|
// Time out the test after a reasonable period of time.
|
|
SetTestTimeout();
|
|
}
|
|
|
|
void ContinueIfReady(CefRefPtr<CefBrowser> browser) {
|
|
if (!got_message_ || !got_load_end_) {
|
|
return;
|
|
}
|
|
|
|
if (IsInitialUrl(browser->GetMainFrame()->GetURL())) {
|
|
// Verify the behavior of the previous load.
|
|
EXPECT_TRUE(got_before_browse_);
|
|
EXPECT_TRUE(got_before_resource_load_);
|
|
EXPECT_TRUE(got_load_start_);
|
|
EXPECT_TRUE(got_load_end_);
|
|
EXPECT_FALSE(got_open_url_from_tab_);
|
|
|
|
got_before_browse_.reset();
|
|
got_before_resource_load_.reset();
|
|
got_load_start_.reset();
|
|
got_load_end_.reset();
|
|
got_message_.reset();
|
|
|
|
EXPECT_EQ(1, renderer_load_ct_);
|
|
|
|
// Load the next url.
|
|
if (mode_ == LOAD) {
|
|
browser->GetMainFrame()->LoadURL(GetURL2());
|
|
} else {
|
|
// Navigate to the URL by clicking a link.
|
|
CefMouseEvent mouse_event;
|
|
mouse_event.x = 20;
|
|
mouse_event.y = 20;
|
|
#if defined(OS_MAC)
|
|
// Use cmd instead of ctrl on OS X.
|
|
mouse_event.modifiers =
|
|
(mode_ == CTRL_LEFT_CLICK ? EVENTFLAG_COMMAND_DOWN : 0);
|
|
#else
|
|
mouse_event.modifiers =
|
|
(mode_ == CTRL_LEFT_CLICK ? EVENTFLAG_CONTROL_DOWN : 0);
|
|
#endif
|
|
|
|
cef_mouse_button_type_t button_type =
|
|
(mode_ == MIDDLE_CLICK ? MBT_MIDDLE : MBT_LEFT);
|
|
SendMouseClickEvent(browser, mouse_event, button_type);
|
|
}
|
|
|
|
if (cancel_in_open_url_) {
|
|
// The next navigation should not occur. Therefore call DestroyTest()
|
|
// after a reasonable timeout.
|
|
CefPostDelayedTask(
|
|
TID_UI, base::BindOnce(&LoadNavTestHandler::DestroyTest, this),
|
|
500);
|
|
}
|
|
} else {
|
|
// Done with the test.
|
|
DestroyTest();
|
|
}
|
|
}
|
|
|
|
void OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
|
|
TestHandler::OnAfterCreated(browser);
|
|
|
|
EXPECT_EQ(browser_id_current_, 0);
|
|
browser_id_current_ = browser->GetIdentifier();
|
|
EXPECT_GT(browser_id_current_, 0);
|
|
}
|
|
|
|
cef_transition_type_t ExpectedOpenURLTransitionType() const {
|
|
if (mode_ != LEFT_CLICK && IsChromeRuntimeEnabled()) {
|
|
// Because we triggered the navigation with LoadURL in OnOpenURLFromTab.
|
|
return kTransitionExplicitLoad;
|
|
}
|
|
return TT_LINK;
|
|
}
|
|
|
|
bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefRequest> request,
|
|
bool user_gesture,
|
|
bool is_redirect) override {
|
|
EXPECT_EQ(RT_MAIN_FRAME, request->GetResourceType());
|
|
if (mode_ == LOAD || IsInitialUrl(request->GetURL())) {
|
|
EXPECT_EQ(kTransitionExplicitLoad, request->GetTransitionType());
|
|
if (IsChromeRuntimeEnabled()) {
|
|
// With the Chrome runtime this is true on initial navigation via
|
|
// chrome::AddTabAt()
|
|
EXPECT_EQ(user_gesture, IsInitialUrl(request->GetURL()));
|
|
} else {
|
|
EXPECT_FALSE(user_gesture);
|
|
}
|
|
} else {
|
|
EXPECT_EQ(ExpectedOpenURLTransitionType(), request->GetTransitionType());
|
|
EXPECT_EQ(user_gesture, mode_ == LEFT_CLICK);
|
|
}
|
|
|
|
EXPECT_GT(browser_id_current_, 0);
|
|
EXPECT_EQ(browser_id_current_, browser->GetIdentifier());
|
|
|
|
if (ExpectOpenURL() && request->GetURL() == GetURL2()) {
|
|
// OnOpenURLFromTab should be called first for the file URL navigation.
|
|
EXPECT_TRUE(got_open_url_from_tab_);
|
|
} else {
|
|
EXPECT_FALSE(got_open_url_from_tab_);
|
|
}
|
|
|
|
got_before_browse_.yes();
|
|
|
|
return false;
|
|
}
|
|
|
|
bool OnOpenURLFromTab(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
const CefString& target_url,
|
|
cef_window_open_disposition_t target_disposition,
|
|
bool user_gesture) override {
|
|
EXPECT_TRUE(CefCurrentlyOn(TID_UI));
|
|
|
|
EXPECT_GT(browser_id_current_, 0);
|
|
EXPECT_EQ(browser_id_current_, browser->GetIdentifier());
|
|
|
|
// OnOpenURLFromTab should only be called for the file URL.
|
|
EXPECT_STREQ(GetURL2().c_str(), target_url.ToString().c_str());
|
|
|
|
if (mode_ == LOAD) {
|
|
EXPECT_FALSE(user_gesture);
|
|
} else {
|
|
EXPECT_TRUE(user_gesture);
|
|
}
|
|
|
|
EXPECT_EQ(CEF_WOD_NEW_BACKGROUND_TAB, target_disposition);
|
|
|
|
// OnOpenURLFromTab should be called before OnBeforeBrowse for the file URL.
|
|
EXPECT_FALSE(got_before_browse_);
|
|
|
|
got_open_url_from_tab_.yes();
|
|
|
|
if (!cancel_in_open_url_ && IsChromeRuntimeEnabled()) {
|
|
// The chrome runtime may create a new popup window, which is not the
|
|
// behavior that this test expects. Instead, match the alloy runtime
|
|
// behavior by navigating in the current window.
|
|
browser->GetMainFrame()->LoadURL(target_url);
|
|
return true;
|
|
}
|
|
|
|
return cancel_in_open_url_;
|
|
}
|
|
|
|
cef_return_value_t OnBeforeResourceLoad(
|
|
CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefRequest> request,
|
|
CefRefPtr<CefCallback> callback) override {
|
|
if (IsChromeRuntimeEnabled() && request->GetResourceType() == RT_FAVICON) {
|
|
// Ignore favicon requests.
|
|
return RV_CANCEL;
|
|
}
|
|
|
|
EXPECT_EQ(RT_MAIN_FRAME, request->GetResourceType());
|
|
|
|
const auto transition_type = request->GetTransitionType();
|
|
if (mode_ == LOAD || IsInitialUrl(request->GetURL())) {
|
|
EXPECT_EQ(kTransitionExplicitLoad, transition_type);
|
|
} else {
|
|
EXPECT_EQ(ExpectedOpenURLTransitionType(), transition_type);
|
|
}
|
|
|
|
EXPECT_GT(browser_id_current_, 0);
|
|
EXPECT_EQ(browser_id_current_, browser->GetIdentifier());
|
|
|
|
got_before_resource_load_.yes();
|
|
|
|
return RV_CONTINUE;
|
|
}
|
|
|
|
void OnLoadStart(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
TransitionType transition_type) override {
|
|
EXPECT_GT(browser_id_current_, 0);
|
|
EXPECT_EQ(browser_id_current_, browser->GetIdentifier());
|
|
|
|
if (mode_ == LOAD || IsInitialUrl(frame->GetURL())) {
|
|
EXPECT_EQ(kTransitionExplicitLoad, transition_type);
|
|
} else {
|
|
EXPECT_EQ(ExpectedOpenURLTransitionType(), transition_type);
|
|
}
|
|
|
|
got_load_start_.yes();
|
|
}
|
|
|
|
void OnLoadEnd(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
int httpStatusCode) override {
|
|
EXPECT_GT(browser_id_current_, 0);
|
|
EXPECT_EQ(browser_id_current_, browser->GetIdentifier());
|
|
|
|
got_load_end_.yes();
|
|
ContinueIfReady(browser);
|
|
}
|
|
|
|
bool OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefProcessId source_process,
|
|
CefRefPtr<CefProcessMessage> message) override {
|
|
EXPECT_GT(browser_id_current_, 0);
|
|
EXPECT_EQ(browser_id_current_, browser->GetIdentifier());
|
|
|
|
const std::string& msg_name = message->GetName();
|
|
if (msg_name == kLoadNavMsg) {
|
|
// Test that the renderer side succeeded.
|
|
CefRefPtr<CefListValue> args = message->GetArgumentList();
|
|
EXPECT_TRUE(args.get());
|
|
EXPECT_TRUE(args->GetBool(0));
|
|
|
|
EXPECT_EQ(browser_id_current_, args->GetInt(1));
|
|
|
|
renderer_browser_created_ct_ = args->GetInt(2);
|
|
EXPECT_GE(renderer_browser_created_ct_, 1);
|
|
renderer_load_ct_ = args->GetInt(3);
|
|
EXPECT_GE(renderer_load_ct_, 1);
|
|
|
|
// Continue with the test.
|
|
got_message_.yes();
|
|
ContinueIfReady(browser);
|
|
|
|
return true;
|
|
}
|
|
|
|
// Message not handled.
|
|
return false;
|
|
}
|
|
|
|
void DestroyTest() override {
|
|
if (cancel_in_open_url_) {
|
|
EXPECT_FALSE(got_before_browse_);
|
|
EXPECT_FALSE(got_before_resource_load_);
|
|
EXPECT_FALSE(got_load_start_);
|
|
EXPECT_FALSE(got_load_end_);
|
|
EXPECT_FALSE(got_message_);
|
|
|
|
// We should only navigate a single time if the 2nd load is canceled.
|
|
EXPECT_EQ(1, renderer_load_ct_);
|
|
EXPECT_EQ(1, renderer_browser_created_ct_);
|
|
} else {
|
|
EXPECT_TRUE(got_before_browse_);
|
|
EXPECT_TRUE(got_before_resource_load_);
|
|
EXPECT_TRUE(got_load_start_);
|
|
EXPECT_TRUE(got_load_end_);
|
|
EXPECT_TRUE(got_message_);
|
|
|
|
if (same_origin_) {
|
|
// The renderer process should always be reused.
|
|
EXPECT_EQ(2, renderer_load_ct_);
|
|
if (IsSameSiteBFCacheEnabled()) {
|
|
// We expect multiple calls to OnBrowserCreated for same-site
|
|
// navigations with same-site BFCache enabled.
|
|
EXPECT_EQ(2, renderer_browser_created_ct_);
|
|
} else {
|
|
EXPECT_EQ(1, renderer_browser_created_ct_);
|
|
}
|
|
} else {
|
|
// Each renderer process is only used for a single navigation.
|
|
EXPECT_EQ(1, renderer_load_ct_);
|
|
EXPECT_EQ(1, renderer_browser_created_ct_);
|
|
}
|
|
}
|
|
|
|
if (ExpectOpenURL()) {
|
|
EXPECT_TRUE(got_open_url_from_tab_);
|
|
} else {
|
|
EXPECT_FALSE(got_open_url_from_tab_);
|
|
}
|
|
|
|
TestHandler::DestroyTest();
|
|
}
|
|
|
|
protected:
|
|
const TestMode mode_;
|
|
const bool same_origin_;
|
|
const bool cancel_in_open_url_;
|
|
|
|
int browser_id_current_ = 0;
|
|
int renderer_browser_created_ct_ = 0;
|
|
int renderer_load_ct_ = 0;
|
|
|
|
TrackCallback got_before_browse_;
|
|
TrackCallback got_open_url_from_tab_;
|
|
TrackCallback got_before_resource_load_;
|
|
TrackCallback got_load_start_;
|
|
TrackCallback got_load_end_;
|
|
TrackCallback got_message_;
|
|
|
|
IMPLEMENT_REFCOUNTING(LoadNavTestHandler);
|
|
};
|
|
|
|
} // namespace
|
|
|
|
// Verify navigation-related callbacks when browsing same-origin via LoadURL().
|
|
TEST(NavigationTest, LoadSameOriginLoadURL) {
|
|
CefRefPtr<LoadNavTestHandler> handler =
|
|
new LoadNavTestHandler(LoadNavTestHandler::LOAD, true);
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
// Verify navigation-related callbacks when browsing same-origin via left-click.
|
|
TEST(NavigationTest, LoadSameOriginLeftClick) {
|
|
CefRefPtr<LoadNavTestHandler> handler =
|
|
new LoadNavTestHandler(LoadNavTestHandler::LEFT_CLICK, true);
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
// Verify navigation-related callbacks when browsing same-origin via middle-
|
|
// click.
|
|
TEST(NavigationTest, LoadSameOriginMiddleClick) {
|
|
CefRefPtr<LoadNavTestHandler> handler =
|
|
new LoadNavTestHandler(LoadNavTestHandler::MIDDLE_CLICK, true);
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
// Same as above but cancel the 2nd navigation in OnOpenURLFromTab.
|
|
TEST(NavigationTest, LoadSameOriginMiddleClickCancel) {
|
|
CefRefPtr<LoadNavTestHandler> handler =
|
|
new LoadNavTestHandler(LoadNavTestHandler::MIDDLE_CLICK, true, true);
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
// Verify navigation-related callbacks when browsing same-origin via ctrl+left-
|
|
// click.
|
|
TEST(NavigationTest, LoadSameOriginCtrlLeftClick) {
|
|
CefRefPtr<LoadNavTestHandler> handler =
|
|
new LoadNavTestHandler(LoadNavTestHandler::CTRL_LEFT_CLICK, true);
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
// Same as above but cancel the 2nd navigation in OnOpenURLFromTab.
|
|
TEST(NavigationTest, LoadSameOriginCtrlLeftClickCancel) {
|
|
CefRefPtr<LoadNavTestHandler> handler =
|
|
new LoadNavTestHandler(LoadNavTestHandler::CTRL_LEFT_CLICK, true, true);
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
// Verify navigation-related callbacks when browsing cross-origin via LoadURL().
|
|
TEST(NavigationTest, LoadCrossOriginLoadURL) {
|
|
CefRefPtr<LoadNavTestHandler> handler =
|
|
new LoadNavTestHandler(LoadNavTestHandler::LOAD, false);
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
// Verify navigation-related callbacks when browsing cross-origin via left-
|
|
// click.
|
|
TEST(NavigationTest, LoadCrossOriginLeftClick) {
|
|
CefRefPtr<LoadNavTestHandler> handler =
|
|
new LoadNavTestHandler(LoadNavTestHandler::LEFT_CLICK, false);
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
// Verify navigation-related callbacks when browsing cross-origin via middle-
|
|
// click.
|
|
TEST(NavigationTest, LoadCrossOriginMiddleClick) {
|
|
CefRefPtr<LoadNavTestHandler> handler =
|
|
new LoadNavTestHandler(LoadNavTestHandler::MIDDLE_CLICK, false);
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
// Same as above but cancel the 2nd navigation in OnOpenURLFromTab.
|
|
TEST(NavigationTest, LoadCrossOriginMiddleClickCancel) {
|
|
CefRefPtr<LoadNavTestHandler> handler =
|
|
new LoadNavTestHandler(LoadNavTestHandler::MIDDLE_CLICK, false, true);
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
// Verify navigation-related callbacks when browsing cross-origin via ctrl+left-
|
|
// click.
|
|
TEST(NavigationTest, LoadCrossOriginCtrlLeftClick) {
|
|
CefRefPtr<LoadNavTestHandler> handler =
|
|
new LoadNavTestHandler(LoadNavTestHandler::CTRL_LEFT_CLICK, false);
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
// Same as above but cancel the 2nd navigation in OnOpenURLFromTab.
|
|
TEST(NavigationTest, LoadCrossOriginCtrlLeftClickCancel) {
|
|
CefRefPtr<LoadNavTestHandler> handler =
|
|
new LoadNavTestHandler(LoadNavTestHandler::CTRL_LEFT_CLICK, false, true);
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
namespace {
|
|
|
|
const char kSimultPopupMainUrl[] = "https://www.tests-sp.com/main.html";
|
|
const char kSimultPopupPopupUrl[] = "https://www.tests-sp.com/popup";
|
|
const size_t kSimultPopupCount = 5U;
|
|
|
|
// Test multiple popups simultaniously.
|
|
class PopupSimultaneousTestHandler : public TestHandler {
|
|
public:
|
|
explicit PopupSimultaneousTestHandler(bool same_url) : same_url_(same_url) {}
|
|
|
|
void RunTest() override {
|
|
std::string main_html = "<html><script>\n";
|
|
for (size_t i = 0; i < kSimultPopupCount; ++i) {
|
|
if (same_url_) {
|
|
popup_url_[i] = std::string(kSimultPopupPopupUrl) + ".html";
|
|
} else {
|
|
std::stringstream ss;
|
|
ss << kSimultPopupPopupUrl << i << ".html";
|
|
popup_url_[i] = ss.str();
|
|
}
|
|
main_html += "window.open('" + popup_url_[i] + "');\n";
|
|
AddResource(popup_url_[i], "<html>Popup " + popup_url_[i] + "</html>",
|
|
"text/html");
|
|
}
|
|
main_html += "</script></html>";
|
|
|
|
AddResource(kSimultPopupMainUrl, main_html, "text/html");
|
|
|
|
// Create the browser.
|
|
CreateBrowser(kSimultPopupMainUrl);
|
|
|
|
// Time out the test after a reasonable period of time.
|
|
SetTestTimeout();
|
|
}
|
|
|
|
bool OnBeforePopup(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
const CefString& target_url,
|
|
const CefString& target_frame_name,
|
|
cef_window_open_disposition_t target_disposition,
|
|
bool user_gesture,
|
|
const CefPopupFeatures& popupFeatures,
|
|
CefWindowInfo& windowInfo,
|
|
CefRefPtr<CefClient>& client,
|
|
CefBrowserSettings& settings,
|
|
CefRefPtr<CefDictionaryValue>& extra_info,
|
|
bool* no_javascript_access) override {
|
|
const std::string& url = target_url;
|
|
EXPECT_LT(before_popup_ct_, kSimultPopupCount);
|
|
EXPECT_STREQ(popup_url_[before_popup_ct_].c_str(), url.c_str())
|
|
<< before_popup_ct_;
|
|
before_popup_ct_++;
|
|
return false;
|
|
}
|
|
|
|
void OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
|
|
TestHandler::OnAfterCreated(browser);
|
|
|
|
if (browser->IsPopup()) {
|
|
EXPECT_LT(after_created_ct_, kSimultPopupCount);
|
|
browser_id_[after_created_ct_] = browser->GetIdentifier();
|
|
after_created_ct_++;
|
|
} else {
|
|
GrantPopupPermission(browser->GetHost()->GetRequestContext(),
|
|
kSimultPopupMainUrl);
|
|
}
|
|
}
|
|
|
|
void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
|
|
bool isLoading,
|
|
bool canGoBack,
|
|
bool canGoForward) override {
|
|
if (isLoading) {
|
|
return;
|
|
}
|
|
|
|
if (browser->IsPopup()) {
|
|
const std::string& url = browser->GetMainFrame()->GetURL();
|
|
for (size_t i = 0; i < kSimultPopupCount; ++i) {
|
|
if (browser->GetIdentifier() == browser_id_[i]) {
|
|
EXPECT_STREQ(popup_url_[i].c_str(), url.c_str()) << i;
|
|
|
|
got_loading_state_change_[i].yes();
|
|
CloseBrowser(browser, true);
|
|
return;
|
|
}
|
|
}
|
|
EXPECT_FALSE(true); // Not reached.
|
|
}
|
|
}
|
|
|
|
void OnBeforeClose(CefRefPtr<CefBrowser> browser) override {
|
|
TestHandler::OnBeforeClose(browser);
|
|
|
|
if (browser->IsPopup()) {
|
|
const std::string& url = browser->GetMainFrame()->GetURL();
|
|
for (size_t i = 0; i < kSimultPopupCount; ++i) {
|
|
if (browser->GetIdentifier() == browser_id_[i]) {
|
|
EXPECT_TRUE(got_loading_state_change_[i]);
|
|
EXPECT_STREQ(popup_url_[i].c_str(), url.c_str()) << i;
|
|
|
|
got_before_close_[i].yes();
|
|
|
|
if (++before_close_ct_ == kSimultPopupCount) {
|
|
DestroyTest();
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
EXPECT_FALSE(true); // Not reached.
|
|
}
|
|
}
|
|
|
|
private:
|
|
void DestroyTest() override {
|
|
EXPECT_EQ(kSimultPopupCount, before_popup_ct_);
|
|
EXPECT_EQ(kSimultPopupCount, after_created_ct_);
|
|
EXPECT_EQ(kSimultPopupCount, before_close_ct_);
|
|
|
|
for (size_t i = 0; i < kSimultPopupCount; ++i) {
|
|
EXPECT_GT(browser_id_[i], 0) << i;
|
|
EXPECT_TRUE(got_loading_state_change_[i]) << i;
|
|
EXPECT_TRUE(got_before_close_[i]) << i;
|
|
}
|
|
|
|
TestHandler::DestroyTest();
|
|
}
|
|
|
|
const bool same_url_;
|
|
std::string popup_url_[kSimultPopupCount];
|
|
size_t before_popup_ct_ = 0U;
|
|
int browser_id_[kSimultPopupCount];
|
|
size_t after_created_ct_ = 0U;
|
|
TrackCallback got_loading_state_change_[kSimultPopupCount];
|
|
TrackCallback got_before_close_[kSimultPopupCount];
|
|
size_t before_close_ct_ = 0U;
|
|
|
|
IMPLEMENT_REFCOUNTING(PopupSimultaneousTestHandler);
|
|
};
|
|
|
|
} // namespace
|
|
|
|
// Test simultaneous popups with different URLs.
|
|
TEST(NavigationTest, PopupSimultaneousDifferentUrl) {
|
|
CefRefPtr<PopupSimultaneousTestHandler> handler =
|
|
new PopupSimultaneousTestHandler(false);
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
// Test simultaneous popups with the same URL.
|
|
TEST(NavigationTest, PopupSimultaneousSameUrl) {
|
|
CefRefPtr<PopupSimultaneousTestHandler> handler =
|
|
new PopupSimultaneousTestHandler(true);
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
namespace {
|
|
|
|
const char kPopupJSOpenMainUrl[] = "https://www.tests-pjso.com/main.html";
|
|
const char kPopupJSOpenPopupUrl[] = "https://www.tests-pjso.com/popup.html";
|
|
|
|
// Test a popup where the URL is a JavaScript URI that opens another popup.
|
|
class PopupJSWindowOpenTestHandler : public TestHandler {
|
|
public:
|
|
PopupJSWindowOpenTestHandler(TestRequestContextMode mode,
|
|
const std::string& cache_path)
|
|
: mode_(mode), cache_path_(cache_path) {}
|
|
|
|
void RunTest() override {
|
|
AddResource(kPopupJSOpenMainUrl, "<html>Main</html>", "text/html");
|
|
AddResource(kPopupJSOpenPopupUrl, "<html>Popup</html>", "text/html");
|
|
|
|
// Create a new disk-based request context so that we can grant default
|
|
// popup permission (used for the popup without a valid URL) without
|
|
// impacting the global context.
|
|
CreateTestRequestContext(
|
|
mode_, cache_path_,
|
|
base::BindOnce(&PopupJSWindowOpenTestHandler::RunTestContinue, this));
|
|
|
|
// Time out the test after a reasonable period of time.
|
|
SetTestTimeout();
|
|
}
|
|
|
|
void RunTestContinue(CefRefPtr<CefRequestContext> request_context) {
|
|
EXPECT_UI_THREAD();
|
|
|
|
GrantPopupPermission(request_context, CefString());
|
|
|
|
// Create the browser.
|
|
CreateBrowser(kPopupJSOpenMainUrl, request_context);
|
|
}
|
|
|
|
bool OnBeforePopup(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
const CefString& target_url,
|
|
const CefString& target_frame_name,
|
|
cef_window_open_disposition_t target_disposition,
|
|
bool user_gesture,
|
|
const CefPopupFeatures& popupFeatures,
|
|
CefWindowInfo& windowInfo,
|
|
CefRefPtr<CefClient>& client,
|
|
CefBrowserSettings& settings,
|
|
CefRefPtr<CefDictionaryValue>& extra_info,
|
|
bool* no_javascript_access) override {
|
|
before_popup_ct_++;
|
|
return false;
|
|
}
|
|
|
|
void OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
|
|
TestHandler::OnAfterCreated(browser);
|
|
|
|
if (browser->IsPopup()) {
|
|
after_created_ct_++;
|
|
if (!popup1_) {
|
|
popup1_ = browser;
|
|
} else if (!popup2_) {
|
|
popup2_ = browser;
|
|
} else {
|
|
ADD_FAILURE();
|
|
}
|
|
}
|
|
}
|
|
|
|
void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
|
|
bool isLoading,
|
|
bool canGoBack,
|
|
bool canGoForward) override {
|
|
if (isLoading) {
|
|
return;
|
|
}
|
|
|
|
if (browser->IsPopup()) {
|
|
const std::string& url = browser->GetMainFrame()->GetURL();
|
|
if (url == kPopupJSOpenPopupUrl) {
|
|
EXPECT_TRUE(browser->IsSame(popup2_));
|
|
popup2_ = nullptr;
|
|
|
|
// OnLoadingStateChange is not currently called for browser-side
|
|
// navigations of empty popups. See https://crbug.com/789252.
|
|
// Explicitly close the empty popup here as a workaround.
|
|
CloseBrowser(popup1_, true);
|
|
popup1_ = nullptr;
|
|
} else {
|
|
// Empty popup.
|
|
EXPECT_TRUE(url.empty());
|
|
EXPECT_TRUE(browser->IsSame(popup1_));
|
|
popup1_ = nullptr;
|
|
}
|
|
|
|
load_end_ct_++;
|
|
CloseBrowser(browser, true);
|
|
} else if (browser->GetMainFrame()->GetURL() == kPopupJSOpenMainUrl) {
|
|
// For the popup that has a valid URL.
|
|
GrantPopupPermission(browser->GetHost()->GetRequestContext(),
|
|
kPopupJSOpenMainUrl);
|
|
|
|
// Load the problematic JS URI.
|
|
// This will result in 2 popups being created:
|
|
// - An empty popup
|
|
// - A popup that loads kPopupJSOpenPopupUrl
|
|
browser->GetMainFrame()->LoadURL(
|
|
"javascript:window.open(\"javascript:window.open('" +
|
|
std::string(kPopupJSOpenPopupUrl) + "')\")");
|
|
}
|
|
}
|
|
|
|
void OnLoadError(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
ErrorCode errorCode,
|
|
const CefString& errorText,
|
|
const CefString& failedUrl) override {
|
|
ADD_FAILURE() << "OnLoadError url: " << failedUrl.ToString()
|
|
<< " error: " << errorCode;
|
|
}
|
|
|
|
void OnBeforeClose(CefRefPtr<CefBrowser> browser) override {
|
|
TestHandler::OnBeforeClose(browser);
|
|
|
|
before_close_ct_++;
|
|
if (before_close_ct_ == 2U) {
|
|
DestroyTest();
|
|
}
|
|
}
|
|
|
|
private:
|
|
void DestroyTest() override {
|
|
EXPECT_EQ(2U, before_popup_ct_);
|
|
EXPECT_EQ(2U, after_created_ct_);
|
|
EXPECT_EQ(2U, before_close_ct_);
|
|
|
|
// OnLoadingStateChange is not currently called for browser-side
|
|
// navigations of empty popups. See https://crbug.com/789252.
|
|
EXPECT_EQ(1U, load_end_ct_);
|
|
|
|
TestHandler::DestroyTest();
|
|
}
|
|
|
|
const TestRequestContextMode mode_;
|
|
const std::string cache_path_;
|
|
|
|
CefRefPtr<CefBrowser> popup1_;
|
|
CefRefPtr<CefBrowser> popup2_;
|
|
|
|
size_t before_popup_ct_ = 0U;
|
|
size_t after_created_ct_ = 0U;
|
|
size_t load_end_ct_ = 0U;
|
|
size_t before_close_ct_ = 0U;
|
|
|
|
IMPLEMENT_REFCOUNTING(PopupJSWindowOpenTestHandler);
|
|
};
|
|
|
|
} // namespace
|
|
|
|
// Test a popup where the URL is a JavaScript URI that opens another popup.
|
|
RC_TEST_SINGLE(NavigationTest,
|
|
PopupJSWindowOpen,
|
|
PopupJSWindowOpenTestHandler,
|
|
TEST_RC_MODE_CUSTOM_WITH_HANDLER,
|
|
/*with_cache_path*/ true)
|
|
|
|
namespace {
|
|
|
|
const char kPopupJSEmptyMainUrl[] = "https://www.tests-pjse.com/main.html";
|
|
|
|
// Test creation of a popup where the URL is empty.
|
|
class PopupJSWindowEmptyTestHandler : public TestHandler {
|
|
public:
|
|
PopupJSWindowEmptyTestHandler() = default;
|
|
|
|
void RunTest() override {
|
|
AddResource(kPopupJSEmptyMainUrl, "<html>Main</html>", "text/html");
|
|
|
|
// Create the browser.
|
|
CreateBrowser(kPopupJSEmptyMainUrl);
|
|
|
|
// Time out the test after a reasonable period of time.
|
|
SetTestTimeout();
|
|
}
|
|
|
|
bool OnBeforePopup(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
const CefString& target_url,
|
|
const CefString& target_frame_name,
|
|
cef_window_open_disposition_t target_disposition,
|
|
bool user_gesture,
|
|
const CefPopupFeatures& popupFeatures,
|
|
CefWindowInfo& windowInfo,
|
|
CefRefPtr<CefClient>& client,
|
|
CefBrowserSettings& settings,
|
|
CefRefPtr<CefDictionaryValue>& extra_info,
|
|
bool* no_javascript_access) override {
|
|
got_before_popup_.yes();
|
|
return false;
|
|
}
|
|
|
|
void OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
|
|
TestHandler::OnAfterCreated(browser);
|
|
|
|
if (browser->IsPopup()) {
|
|
got_after_created_popup_.yes();
|
|
}
|
|
}
|
|
|
|
void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
|
|
bool isLoading,
|
|
bool canGoBack,
|
|
bool canGoForward) override {
|
|
if (isLoading) {
|
|
return;
|
|
}
|
|
|
|
if (browser->IsPopup()) {
|
|
got_load_end_popup_.yes();
|
|
CloseBrowser(browser, true);
|
|
} else {
|
|
GrantPopupPermission(browser->GetHost()->GetRequestContext(),
|
|
browser->GetMainFrame()->GetURL());
|
|
|
|
browser->GetMainFrame()->LoadURL("javascript:window.open('')");
|
|
}
|
|
}
|
|
|
|
void OnLoadError(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
ErrorCode errorCode,
|
|
const CefString& errorText,
|
|
const CefString& failedUrl) override {
|
|
ADD_FAILURE() << "OnLoadError url: " << failedUrl.ToString()
|
|
<< " error: " << errorCode;
|
|
}
|
|
|
|
void OnBeforeClose(CefRefPtr<CefBrowser> browser) override {
|
|
TestHandler::OnBeforeClose(browser);
|
|
|
|
if (browser->IsPopup()) {
|
|
got_before_close_popup_.yes();
|
|
DestroyTest();
|
|
}
|
|
}
|
|
|
|
private:
|
|
void DestroyTest() override {
|
|
EXPECT_TRUE(got_before_popup_);
|
|
EXPECT_TRUE(got_after_created_popup_);
|
|
EXPECT_TRUE(got_load_end_popup_);
|
|
EXPECT_TRUE(got_before_close_popup_);
|
|
|
|
TestHandler::DestroyTest();
|
|
}
|
|
|
|
TrackCallback got_before_popup_;
|
|
TrackCallback got_after_created_popup_;
|
|
TrackCallback got_load_end_popup_;
|
|
TrackCallback got_before_close_popup_;
|
|
|
|
IMPLEMENT_REFCOUNTING(PopupJSWindowEmptyTestHandler);
|
|
};
|
|
|
|
} // namespace
|
|
|
|
// Test creation of a popup where the URL is empty.
|
|
TEST(NavigationTest, PopupJSWindowEmpty) {
|
|
CefRefPtr<PopupJSWindowEmptyTestHandler> handler =
|
|
new PopupJSWindowEmptyTestHandler();
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
namespace {
|
|
|
|
const char kBrowseNavPageUrl[] = "https://tests-browsenav/nav.html";
|
|
|
|
// Browser side.
|
|
class BrowseNavTestHandler : public TestHandler {
|
|
public:
|
|
explicit BrowseNavTestHandler(bool allow) : allow_(allow) {}
|
|
|
|
void RunTest() override {
|
|
AddResource(kBrowseNavPageUrl, "<html>Test</html>", "text/html");
|
|
|
|
// Create the browser.
|
|
CreateBrowser(kBrowseNavPageUrl);
|
|
|
|
// Time out the test after a reasonable period of time.
|
|
SetTestTimeout();
|
|
}
|
|
|
|
bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefRequest> request,
|
|
bool user_gesture,
|
|
bool is_redirect) override {
|
|
const std::string& url = request->GetURL();
|
|
EXPECT_STREQ(kBrowseNavPageUrl, url.c_str());
|
|
EXPECT_EQ(GetBrowserId(), browser->GetIdentifier());
|
|
EXPECT_TRUE(frame->IsMain());
|
|
|
|
got_before_browse_.yes();
|
|
|
|
return !allow_;
|
|
}
|
|
|
|
void OnLoadStart(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
TransitionType transition_type) override {
|
|
const std::string& url = frame->GetURL();
|
|
EXPECT_STREQ(kBrowseNavPageUrl, url.c_str());
|
|
EXPECT_EQ(GetBrowserId(), browser->GetIdentifier());
|
|
EXPECT_TRUE(frame->IsMain());
|
|
|
|
got_load_start_.yes();
|
|
}
|
|
|
|
void OnLoadEnd(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
int httpStatusCode) override {
|
|
const std::string& url = frame->GetURL();
|
|
EXPECT_STREQ(kBrowseNavPageUrl, url.c_str());
|
|
EXPECT_EQ(GetBrowserId(), browser->GetIdentifier());
|
|
EXPECT_TRUE(frame->IsMain());
|
|
|
|
got_load_end_.yes();
|
|
DestroyTestIfDone();
|
|
}
|
|
|
|
void OnLoadError(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
ErrorCode errorCode,
|
|
const CefString& errorText,
|
|
const CefString& failedUrl) override {
|
|
const std::string& url = frame->GetURL();
|
|
EXPECT_STREQ("", url.c_str());
|
|
EXPECT_EQ(GetBrowserId(), browser->GetIdentifier());
|
|
EXPECT_TRUE(frame->IsMain());
|
|
|
|
EXPECT_EQ(ERR_ABORTED, errorCode);
|
|
EXPECT_STREQ(kBrowseNavPageUrl, failedUrl.ToString().c_str());
|
|
|
|
got_load_error_.yes();
|
|
DestroyTestIfDone();
|
|
}
|
|
|
|
void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
|
|
bool isLoading,
|
|
bool canGoBack,
|
|
bool canGoForward) override {
|
|
const std::string& url = browser->GetMainFrame()->GetURL();
|
|
EXPECT_EQ(GetBrowserId(), browser->GetIdentifier());
|
|
|
|
if (isLoading) {
|
|
EXPECT_STREQ("", url.c_str());
|
|
|
|
got_loading_state_changed_start_.yes();
|
|
} else {
|
|
if (allow_) {
|
|
EXPECT_STREQ(kBrowseNavPageUrl, url.c_str());
|
|
} else {
|
|
EXPECT_STREQ("", url.c_str());
|
|
}
|
|
|
|
got_loading_state_changed_end_.yes();
|
|
DestroyTestIfDone();
|
|
}
|
|
}
|
|
|
|
private:
|
|
void DestroyTestIfDone() {
|
|
if (destroyed_) {
|
|
return;
|
|
}
|
|
|
|
if (got_loading_state_changed_end_) {
|
|
if (allow_) {
|
|
if (got_load_end_) {
|
|
DestroyTest();
|
|
}
|
|
} else if (got_load_error_) {
|
|
DestroyTest();
|
|
}
|
|
}
|
|
}
|
|
|
|
void DestroyTest() override {
|
|
if (destroyed_) {
|
|
return;
|
|
}
|
|
destroyed_ = true;
|
|
|
|
EXPECT_TRUE(got_before_browse_);
|
|
EXPECT_TRUE(got_loading_state_changed_start_);
|
|
EXPECT_TRUE(got_loading_state_changed_end_);
|
|
|
|
if (allow_) {
|
|
EXPECT_TRUE(got_load_start_);
|
|
EXPECT_TRUE(got_load_end_);
|
|
EXPECT_FALSE(got_load_error_);
|
|
} else {
|
|
EXPECT_FALSE(got_load_start_);
|
|
EXPECT_FALSE(got_load_end_);
|
|
EXPECT_TRUE(got_load_error_);
|
|
}
|
|
|
|
TestHandler::DestroyTest();
|
|
}
|
|
|
|
bool allow_;
|
|
bool destroyed_ = false;
|
|
|
|
TrackCallback got_before_browse_;
|
|
TrackCallback got_load_start_;
|
|
TrackCallback got_load_end_;
|
|
TrackCallback got_load_error_;
|
|
TrackCallback got_loading_state_changed_start_;
|
|
TrackCallback got_loading_state_changed_end_;
|
|
|
|
IMPLEMENT_REFCOUNTING(BrowseNavTestHandler);
|
|
};
|
|
|
|
} // namespace
|
|
|
|
// Test allowing navigation.
|
|
TEST(NavigationTest, BrowseAllow) {
|
|
CefRefPtr<BrowseNavTestHandler> handler = new BrowseNavTestHandler(true);
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
// Test denying navigation.
|
|
TEST(NavigationTest, BrowseDeny) {
|
|
CefRefPtr<BrowseNavTestHandler> handler = new BrowseNavTestHandler(false);
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
namespace {
|
|
|
|
const char kSameNavPageUrl[] = "https://tests-samenav/nav.html";
|
|
|
|
// Browser side.
|
|
class SameNavTestHandler : public TestHandler {
|
|
public:
|
|
SameNavTestHandler() = default;
|
|
|
|
void RunTest() override {
|
|
AddResource(kSameNavPageUrl, "<html>Test</html>", "text/html");
|
|
|
|
// Create the browser.
|
|
expected_url_ = kSameNavPageUrl;
|
|
CreateBrowser(kSameNavPageUrl);
|
|
|
|
// Time out the test after a reasonable period of time.
|
|
SetTestTimeout();
|
|
}
|
|
|
|
bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefRequest> request,
|
|
bool user_gesture,
|
|
bool is_redirect) override {
|
|
const std::string& url = request->GetURL();
|
|
EXPECT_STREQ(expected_url_.c_str(), url.c_str());
|
|
EXPECT_EQ(GetBrowserId(), browser->GetIdentifier());
|
|
EXPECT_TRUE(frame->IsMain());
|
|
|
|
got_before_browse_.yes();
|
|
|
|
return false;
|
|
}
|
|
|
|
void OnLoadStart(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
TransitionType transition_type) override {
|
|
const std::string& url = frame->GetURL();
|
|
EXPECT_STREQ(expected_url_.c_str(), url.c_str());
|
|
EXPECT_EQ(GetBrowserId(), browser->GetIdentifier());
|
|
EXPECT_TRUE(frame->IsMain());
|
|
|
|
got_load_start_.yes();
|
|
}
|
|
|
|
void OnLoadEnd(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
int httpStatusCode) override {
|
|
const std::string& url = frame->GetURL();
|
|
EXPECT_STREQ(expected_url_.c_str(), url.c_str());
|
|
EXPECT_EQ(GetBrowserId(), browser->GetIdentifier());
|
|
EXPECT_TRUE(frame->IsMain());
|
|
|
|
got_load_end_.yes();
|
|
ContinueTestIfDone();
|
|
}
|
|
|
|
void OnLoadError(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
ErrorCode errorCode,
|
|
const CefString& errorText,
|
|
const CefString& failedUrl) override {
|
|
got_load_error_.yes();
|
|
}
|
|
|
|
void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
|
|
bool isLoading,
|
|
bool canGoBack,
|
|
bool canGoForward) override {
|
|
const std::string& url = browser->GetMainFrame()->GetURL();
|
|
EXPECT_EQ(GetBrowserId(), browser->GetIdentifier());
|
|
|
|
if (isLoading) {
|
|
// Verify the previous URL.
|
|
if (step_ == 0) {
|
|
EXPECT_TRUE(url.empty());
|
|
} else {
|
|
EXPECT_STREQ(kSameNavPageUrl, url.c_str());
|
|
}
|
|
|
|
got_loading_state_changed_start_.yes();
|
|
} else {
|
|
EXPECT_STREQ(expected_url_.c_str(), url.c_str());
|
|
|
|
got_loading_state_changed_end_.yes();
|
|
ContinueTestIfDone();
|
|
}
|
|
}
|
|
|
|
private:
|
|
void ContinueTestIfDone() {
|
|
if (step_ == 0) {
|
|
// First navigation should trigger all callbacks except OnLoadError.
|
|
if (got_loading_state_changed_end_ && got_load_end_) {
|
|
EXPECT_TRUE(got_before_browse_);
|
|
EXPECT_TRUE(got_loading_state_changed_start_);
|
|
EXPECT_TRUE(got_load_start_);
|
|
EXPECT_FALSE(got_load_error_);
|
|
|
|
got_before_browse_.reset();
|
|
got_loading_state_changed_start_.reset();
|
|
got_loading_state_changed_end_.reset();
|
|
got_load_start_.reset();
|
|
got_load_end_.reset();
|
|
|
|
step_++;
|
|
expected_url_ = kSameNavPageUrl + std::string("#fragment");
|
|
GetBrowser()->GetMainFrame()->LoadURL(expected_url_);
|
|
}
|
|
} else if (step_ == 1) {
|
|
step_++;
|
|
DestroyTest();
|
|
} else {
|
|
EXPECT_TRUE(false); // Not reached.
|
|
}
|
|
}
|
|
|
|
void DestroyTest() override {
|
|
if (destroyed_) {
|
|
return;
|
|
}
|
|
destroyed_ = true;
|
|
|
|
EXPECT_EQ(2, step_);
|
|
|
|
// Second (fragment) navigation should only trigger OnLoadingStateChange.
|
|
EXPECT_FALSE(got_before_browse_);
|
|
EXPECT_TRUE(got_loading_state_changed_start_);
|
|
EXPECT_TRUE(got_loading_state_changed_end_);
|
|
EXPECT_FALSE(got_load_start_);
|
|
EXPECT_FALSE(got_load_end_);
|
|
EXPECT_FALSE(got_load_error_);
|
|
|
|
TestHandler::DestroyTest();
|
|
}
|
|
|
|
bool destroyed_ = false;
|
|
int step_ = 0;
|
|
std::string expected_url_;
|
|
|
|
TrackCallback got_before_browse_;
|
|
TrackCallback got_load_start_;
|
|
TrackCallback got_load_end_;
|
|
TrackCallback got_load_error_;
|
|
TrackCallback got_loading_state_changed_start_;
|
|
TrackCallback got_loading_state_changed_end_;
|
|
|
|
IMPLEMENT_REFCOUNTING(SameNavTestHandler);
|
|
};
|
|
|
|
} // namespace
|
|
|
|
// Test that same page navigation does not call OnLoadStart/OnLoadEnd.
|
|
TEST(NavigationTest, SamePage) {
|
|
CefRefPtr<SameNavTestHandler> handler = new SameNavTestHandler();
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
namespace {
|
|
|
|
const char kCancelPageUrl[] = "https://tests-cancelnav/nav.html";
|
|
|
|
// A scheme handler that never starts sending data.
|
|
class UnstartedSchemeHandler : public CefResourceHandler {
|
|
public:
|
|
UnstartedSchemeHandler() = default;
|
|
|
|
bool Open(CefRefPtr<CefRequest> request,
|
|
bool& handle_request,
|
|
CefRefPtr<CefCallback> callback) override {
|
|
EXPECT_FALSE(CefCurrentlyOn(TID_UI) || CefCurrentlyOn(TID_IO));
|
|
|
|
// Continue immediately.
|
|
handle_request = true;
|
|
return true;
|
|
}
|
|
|
|
void GetResponseHeaders(CefRefPtr<CefResponse> response,
|
|
int64_t& response_length,
|
|
CefString& redirectUrl) override {
|
|
response->SetStatus(200);
|
|
response->SetMimeType("text/html");
|
|
response_length = 100;
|
|
}
|
|
|
|
void Cancel() override { callback_ = nullptr; }
|
|
|
|
bool Read(void* data_out,
|
|
int bytes_to_read,
|
|
int& bytes_read,
|
|
CefRefPtr<CefResourceReadCallback> callback) override {
|
|
EXPECT_FALSE(CefCurrentlyOn(TID_UI) || CefCurrentlyOn(TID_IO));
|
|
|
|
callback_ = callback;
|
|
|
|
// Pretend that we'll provide the data later.
|
|
bytes_read = 0;
|
|
return true;
|
|
}
|
|
|
|
protected:
|
|
CefRefPtr<CefResourceReadCallback> callback_;
|
|
|
|
IMPLEMENT_REFCOUNTING(UnstartedSchemeHandler);
|
|
DISALLOW_COPY_AND_ASSIGN(UnstartedSchemeHandler);
|
|
};
|
|
|
|
// Browser side.
|
|
class CancelBeforeNavTestHandler : public TestHandler {
|
|
public:
|
|
CancelBeforeNavTestHandler() = default;
|
|
|
|
void RunTest() override {
|
|
// Create the browser.
|
|
CreateBrowser(kCancelPageUrl);
|
|
|
|
// Time out the test after a reasonable period of time.
|
|
SetTestTimeout();
|
|
}
|
|
|
|
bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefRequest> request,
|
|
bool user_gesture,
|
|
bool is_redirect) override {
|
|
EXPECT_TRUE(got_loading_state_changed_start_);
|
|
EXPECT_FALSE(got_before_browse_);
|
|
EXPECT_FALSE(got_get_resource_handler_);
|
|
EXPECT_FALSE(got_load_start_);
|
|
EXPECT_FALSE(got_cancel_load_);
|
|
EXPECT_FALSE(got_load_error_);
|
|
EXPECT_FALSE(got_load_end_);
|
|
EXPECT_FALSE(got_loading_state_changed_end_);
|
|
|
|
const std::string& url = request->GetURL();
|
|
EXPECT_STREQ(kCancelPageUrl, url.c_str());
|
|
EXPECT_EQ(GetBrowserId(), browser->GetIdentifier());
|
|
EXPECT_TRUE(frame->IsMain());
|
|
|
|
got_before_browse_.yes();
|
|
|
|
return false;
|
|
}
|
|
|
|
CefRefPtr<CefResourceHandler> GetResourceHandler(
|
|
CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefRequest> request) override {
|
|
EXPECT_TRUE(got_loading_state_changed_start_);
|
|
EXPECT_TRUE(got_before_browse_);
|
|
EXPECT_FALSE(got_get_resource_handler_);
|
|
EXPECT_FALSE(got_load_start_);
|
|
EXPECT_FALSE(got_cancel_load_);
|
|
EXPECT_FALSE(got_load_error_);
|
|
EXPECT_FALSE(got_load_end_);
|
|
EXPECT_FALSE(got_loading_state_changed_end_);
|
|
|
|
const std::string& url = request->GetURL();
|
|
EXPECT_STREQ(kCancelPageUrl, url.c_str());
|
|
EXPECT_EQ(GetBrowserId(), browser->GetIdentifier());
|
|
EXPECT_TRUE(frame->IsMain());
|
|
|
|
got_get_resource_handler_.yes();
|
|
|
|
CefPostTask(TID_UI,
|
|
base::BindOnce(&CancelBeforeNavTestHandler::CancelLoad, this));
|
|
|
|
return new UnstartedSchemeHandler();
|
|
}
|
|
|
|
void OnLoadStart(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
TransitionType transition_type) override {
|
|
EXPECT_TRUE(false); // Not reached.
|
|
got_load_start_.yes();
|
|
}
|
|
|
|
void OnLoadEnd(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
int httpStatusCode) override {
|
|
EXPECT_TRUE(false); // Not reached.
|
|
got_load_end_.yes();
|
|
}
|
|
|
|
void OnLoadError(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
ErrorCode errorCode,
|
|
const CefString& errorText,
|
|
const CefString& failedUrl) override {
|
|
EXPECT_EQ(GetBrowserId(), browser->GetIdentifier());
|
|
EXPECT_STREQ("", frame->GetURL().ToString().c_str());
|
|
EXPECT_EQ(ERR_ABORTED, errorCode);
|
|
EXPECT_STREQ(kCancelPageUrl, failedUrl.ToString().c_str());
|
|
got_load_error_.yes();
|
|
}
|
|
|
|
void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
|
|
bool isLoading,
|
|
bool canGoBack,
|
|
bool canGoForward) override {
|
|
const std::string& url = browser->GetMainFrame()->GetURL();
|
|
EXPECT_EQ(GetBrowserId(), browser->GetIdentifier());
|
|
EXPECT_TRUE(url.empty());
|
|
|
|
if (isLoading) {
|
|
EXPECT_FALSE(got_loading_state_changed_start_);
|
|
EXPECT_FALSE(got_before_browse_);
|
|
EXPECT_FALSE(got_get_resource_handler_);
|
|
EXPECT_FALSE(got_load_start_);
|
|
EXPECT_FALSE(got_cancel_load_);
|
|
EXPECT_FALSE(got_load_error_);
|
|
EXPECT_FALSE(got_load_end_);
|
|
EXPECT_FALSE(got_loading_state_changed_end_);
|
|
|
|
got_loading_state_changed_start_.yes();
|
|
} else {
|
|
EXPECT_TRUE(got_loading_state_changed_start_);
|
|
EXPECT_TRUE(got_before_browse_);
|
|
EXPECT_TRUE(got_get_resource_handler_);
|
|
EXPECT_FALSE(got_load_start_);
|
|
EXPECT_TRUE(got_cancel_load_);
|
|
EXPECT_TRUE(got_load_error_);
|
|
EXPECT_FALSE(got_load_end_);
|
|
EXPECT_FALSE(got_loading_state_changed_end_);
|
|
|
|
got_loading_state_changed_end_.yes();
|
|
|
|
DestroyTest();
|
|
}
|
|
}
|
|
|
|
private:
|
|
void CancelLoad() {
|
|
got_cancel_load_.yes();
|
|
GetBrowser()->StopLoad();
|
|
}
|
|
|
|
void DestroyTest() override {
|
|
if (destroyed_) {
|
|
return;
|
|
}
|
|
destroyed_ = true;
|
|
|
|
EXPECT_TRUE(got_loading_state_changed_start_);
|
|
EXPECT_TRUE(got_before_browse_);
|
|
EXPECT_TRUE(got_get_resource_handler_);
|
|
EXPECT_FALSE(got_load_start_);
|
|
EXPECT_TRUE(got_cancel_load_);
|
|
EXPECT_TRUE(got_load_error_);
|
|
EXPECT_FALSE(got_load_end_);
|
|
EXPECT_TRUE(got_loading_state_changed_end_);
|
|
|
|
TestHandler::DestroyTest();
|
|
}
|
|
|
|
bool destroyed_ = false;
|
|
|
|
TrackCallback got_loading_state_changed_start_;
|
|
TrackCallback got_before_browse_;
|
|
TrackCallback got_get_resource_handler_;
|
|
TrackCallback got_load_start_;
|
|
TrackCallback got_cancel_load_;
|
|
TrackCallback got_load_error_;
|
|
TrackCallback got_load_end_;
|
|
TrackCallback got_loading_state_changed_end_;
|
|
|
|
IMPLEMENT_REFCOUNTING(CancelBeforeNavTestHandler);
|
|
};
|
|
|
|
} // namespace
|
|
|
|
// Test that navigation canceled before commit does not call
|
|
// OnLoadStart/OnLoadEnd.
|
|
TEST(NavigationTest, CancelBeforeCommit) {
|
|
CefRefPtr<CancelBeforeNavTestHandler> handler =
|
|
new CancelBeforeNavTestHandler();
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
namespace {
|
|
|
|
// A scheme handler that stalls after writing some data.
|
|
class StalledSchemeHandler : public CefResourceHandler {
|
|
public:
|
|
StalledSchemeHandler() = default;
|
|
|
|
bool Open(CefRefPtr<CefRequest> request,
|
|
bool& handle_request,
|
|
CefRefPtr<CefCallback> callback) override {
|
|
EXPECT_FALSE(CefCurrentlyOn(TID_UI) || CefCurrentlyOn(TID_IO));
|
|
|
|
// Continue immediately.
|
|
handle_request = true;
|
|
return true;
|
|
}
|
|
|
|
void GetResponseHeaders(CefRefPtr<CefResponse> response,
|
|
int64_t& response_length,
|
|
CefString& redirectUrl) override {
|
|
response->SetStatus(200);
|
|
response->SetMimeType("text/html");
|
|
content_ = "<html><body>Test</body></html>";
|
|
// Write this number of bytes and then stall.
|
|
write_size_ = content_.size() / 2U;
|
|
response_length = content_.size();
|
|
}
|
|
|
|
void Cancel() override { callback_ = nullptr; }
|
|
|
|
bool Read(void* data_out,
|
|
int bytes_to_read,
|
|
int& bytes_read,
|
|
CefRefPtr<CefResourceReadCallback> callback) override {
|
|
EXPECT_FALSE(CefCurrentlyOn(TID_UI) || CefCurrentlyOn(TID_IO));
|
|
|
|
bytes_read = 0;
|
|
|
|
size_t size = content_.size();
|
|
if (offset_ >= write_size_) {
|
|
// Now stall.
|
|
callback_ = callback;
|
|
return true;
|
|
}
|
|
|
|
bool has_data = false;
|
|
|
|
if (offset_ < size) {
|
|
// Write up to |write_size_| bytes.
|
|
int transfer_size =
|
|
std::min(bytes_to_read, std::min(static_cast<int>(write_size_),
|
|
static_cast<int>(size - offset_)));
|
|
memcpy(data_out, content_.c_str() + offset_, transfer_size);
|
|
offset_ += transfer_size;
|
|
|
|
bytes_read = transfer_size;
|
|
has_data = true;
|
|
}
|
|
|
|
return has_data;
|
|
}
|
|
|
|
protected:
|
|
std::string content_;
|
|
size_t offset_ = 0;
|
|
size_t write_size_ = 0;
|
|
CefRefPtr<CefResourceReadCallback> callback_;
|
|
|
|
IMPLEMENT_REFCOUNTING(StalledSchemeHandler);
|
|
DISALLOW_COPY_AND_ASSIGN(StalledSchemeHandler);
|
|
};
|
|
|
|
// Browser side.
|
|
class CancelAfterNavTestHandler : public TestHandler {
|
|
public:
|
|
CancelAfterNavTestHandler() = default;
|
|
|
|
void RunTest() override {
|
|
// Create the browser.
|
|
CreateBrowser(kCancelPageUrl);
|
|
|
|
// Time out the test after a reasonable period of time.
|
|
SetTestTimeout();
|
|
}
|
|
|
|
bool OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefRequest> request,
|
|
bool user_gesture,
|
|
bool is_redirect) override {
|
|
EXPECT_TRUE(got_loading_state_changed_start_);
|
|
EXPECT_FALSE(got_before_browse_);
|
|
EXPECT_FALSE(got_get_resource_handler_);
|
|
EXPECT_FALSE(got_load_start_);
|
|
EXPECT_FALSE(got_cancel_load_);
|
|
EXPECT_FALSE(got_load_error_);
|
|
EXPECT_FALSE(got_load_end_);
|
|
EXPECT_FALSE(got_loading_state_changed_end_);
|
|
|
|
const std::string& url = request->GetURL();
|
|
EXPECT_STREQ(kCancelPageUrl, url.c_str());
|
|
EXPECT_EQ(GetBrowserId(), browser->GetIdentifier());
|
|
EXPECT_TRUE(frame->IsMain());
|
|
|
|
got_before_browse_.yes();
|
|
|
|
return false;
|
|
}
|
|
|
|
CefRefPtr<CefResourceHandler> GetResourceHandler(
|
|
CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefRefPtr<CefRequest> request) override {
|
|
EXPECT_TRUE(got_loading_state_changed_start_);
|
|
EXPECT_TRUE(got_before_browse_);
|
|
EXPECT_FALSE(got_get_resource_handler_);
|
|
EXPECT_FALSE(got_load_start_);
|
|
EXPECT_FALSE(got_cancel_load_);
|
|
EXPECT_FALSE(got_load_error_);
|
|
EXPECT_FALSE(got_load_end_);
|
|
EXPECT_FALSE(got_loading_state_changed_end_);
|
|
|
|
const std::string& url = request->GetURL();
|
|
EXPECT_STREQ(kCancelPageUrl, url.c_str());
|
|
EXPECT_EQ(GetBrowserId(), browser->GetIdentifier());
|
|
EXPECT_TRUE(frame->IsMain());
|
|
|
|
got_get_resource_handler_.yes();
|
|
|
|
// The required delay is longer when browser-side navigation is enabled.
|
|
CefPostDelayedTask(
|
|
TID_UI, base::BindOnce(&CancelAfterNavTestHandler::CancelLoad, this),
|
|
1000);
|
|
|
|
return new StalledSchemeHandler();
|
|
}
|
|
|
|
void OnLoadStart(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
TransitionType transition_type) override {
|
|
EXPECT_TRUE(got_loading_state_changed_start_);
|
|
EXPECT_TRUE(got_before_browse_);
|
|
EXPECT_TRUE(got_get_resource_handler_);
|
|
EXPECT_FALSE(got_load_start_);
|
|
EXPECT_FALSE(got_cancel_load_);
|
|
EXPECT_FALSE(got_load_error_);
|
|
EXPECT_FALSE(got_load_end_);
|
|
EXPECT_FALSE(got_loading_state_changed_end_);
|
|
|
|
const std::string& url = frame->GetURL();
|
|
EXPECT_STREQ(kCancelPageUrl, url.c_str());
|
|
EXPECT_EQ(GetBrowserId(), browser->GetIdentifier());
|
|
EXPECT_TRUE(frame->IsMain());
|
|
|
|
got_load_start_.yes();
|
|
}
|
|
|
|
void OnLoadEnd(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
int httpStatusCode) override {
|
|
EXPECT_TRUE(got_loading_state_changed_start_);
|
|
EXPECT_TRUE(got_before_browse_);
|
|
EXPECT_TRUE(got_get_resource_handler_);
|
|
EXPECT_TRUE(got_load_start_);
|
|
EXPECT_TRUE(got_cancel_load_);
|
|
EXPECT_TRUE(got_load_error_);
|
|
EXPECT_FALSE(got_load_end_);
|
|
EXPECT_FALSE(got_loading_state_changed_end_);
|
|
|
|
const std::string& url = frame->GetURL();
|
|
EXPECT_STREQ(kCancelPageUrl, url.c_str());
|
|
EXPECT_EQ(GetBrowserId(), browser->GetIdentifier());
|
|
EXPECT_TRUE(frame->IsMain());
|
|
|
|
got_load_end_.yes();
|
|
DestroyTestIfDone();
|
|
}
|
|
|
|
void OnLoadError(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
ErrorCode errorCode,
|
|
const CefString& errorText,
|
|
const CefString& failedUrl) override {
|
|
EXPECT_TRUE(got_loading_state_changed_start_);
|
|
EXPECT_TRUE(got_before_browse_);
|
|
EXPECT_TRUE(got_get_resource_handler_);
|
|
EXPECT_TRUE(got_load_start_);
|
|
EXPECT_TRUE(got_cancel_load_);
|
|
EXPECT_FALSE(got_load_error_);
|
|
EXPECT_FALSE(got_load_end_);
|
|
EXPECT_FALSE(got_loading_state_changed_end_);
|
|
|
|
const std::string& url = failedUrl;
|
|
EXPECT_STREQ(kCancelPageUrl, url.c_str());
|
|
EXPECT_EQ(GetBrowserId(), browser->GetIdentifier());
|
|
EXPECT_TRUE(frame->IsMain());
|
|
|
|
got_load_error_.yes();
|
|
}
|
|
|
|
void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
|
|
bool isLoading,
|
|
bool canGoBack,
|
|
bool canGoForward) override {
|
|
const std::string& url = browser->GetMainFrame()->GetURL();
|
|
EXPECT_EQ(GetBrowserId(), browser->GetIdentifier());
|
|
|
|
if (isLoading) {
|
|
EXPECT_FALSE(got_loading_state_changed_start_);
|
|
EXPECT_FALSE(got_before_browse_);
|
|
EXPECT_FALSE(got_get_resource_handler_);
|
|
EXPECT_FALSE(got_load_start_);
|
|
EXPECT_FALSE(got_cancel_load_);
|
|
EXPECT_FALSE(got_load_error_);
|
|
EXPECT_FALSE(got_load_end_);
|
|
EXPECT_FALSE(got_loading_state_changed_end_);
|
|
|
|
EXPECT_TRUE(url.empty());
|
|
|
|
got_loading_state_changed_start_.yes();
|
|
} else {
|
|
EXPECT_TRUE(got_loading_state_changed_start_);
|
|
EXPECT_TRUE(got_before_browse_);
|
|
EXPECT_TRUE(got_get_resource_handler_);
|
|
EXPECT_TRUE(got_load_start_);
|
|
EXPECT_TRUE(got_cancel_load_);
|
|
EXPECT_TRUE(got_load_error_);
|
|
EXPECT_TRUE(got_load_end_);
|
|
EXPECT_FALSE(got_loading_state_changed_end_);
|
|
|
|
EXPECT_STREQ(kCancelPageUrl, url.c_str());
|
|
|
|
got_loading_state_changed_end_.yes();
|
|
DestroyTestIfDone();
|
|
}
|
|
}
|
|
|
|
private:
|
|
void CancelLoad() {
|
|
got_cancel_load_.yes();
|
|
GetBrowser()->StopLoad();
|
|
}
|
|
|
|
void DestroyTestIfDone() {
|
|
if (got_loading_state_changed_end_ && got_load_end_) {
|
|
DestroyTest();
|
|
}
|
|
}
|
|
|
|
void DestroyTest() override {
|
|
if (destroyed_) {
|
|
return;
|
|
}
|
|
destroyed_ = true;
|
|
|
|
EXPECT_TRUE(got_loading_state_changed_start_);
|
|
EXPECT_TRUE(got_before_browse_);
|
|
EXPECT_TRUE(got_get_resource_handler_);
|
|
EXPECT_TRUE(got_load_start_);
|
|
EXPECT_TRUE(got_cancel_load_);
|
|
EXPECT_TRUE(got_load_error_);
|
|
EXPECT_TRUE(got_load_end_);
|
|
EXPECT_TRUE(got_loading_state_changed_end_);
|
|
|
|
TestHandler::DestroyTest();
|
|
}
|
|
|
|
bool destroyed_ = false;
|
|
|
|
TrackCallback got_loading_state_changed_start_;
|
|
TrackCallback got_before_browse_;
|
|
TrackCallback got_get_resource_handler_;
|
|
TrackCallback got_load_start_;
|
|
TrackCallback got_cancel_load_;
|
|
TrackCallback got_load_error_;
|
|
TrackCallback got_load_end_;
|
|
TrackCallback got_loading_state_changed_end_;
|
|
|
|
IMPLEMENT_REFCOUNTING(CancelAfterNavTestHandler);
|
|
};
|
|
|
|
} // namespace
|
|
|
|
// Test that navigation canceled after commit calls everything.
|
|
TEST(NavigationTest, CancelAfterCommit) {
|
|
CefRefPtr<CancelAfterNavTestHandler> handler =
|
|
new CancelAfterNavTestHandler();
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
namespace {
|
|
|
|
const char kExtraInfoUrl[] = "https://tests-extrainfonav.com/extra.html";
|
|
const char kExtraInfoPopupUrl[] =
|
|
"https://tests-extrainfonav.com/extra_popup.html";
|
|
const char kExtraInfoNavMsg[] = "NavigationTest.ExtraInfoNav";
|
|
const char kExtraInfoTestCmdKey[] = "nav-extra-info-test";
|
|
|
|
void SetBrowserExtraInfo(CefRefPtr<CefDictionaryValue> extra_info) {
|
|
// Necessary for identifying the test case.
|
|
extra_info->SetBool(kExtraInfoTestCmdKey, true);
|
|
|
|
// Arbitrary data for testing.
|
|
extra_info->SetBool("bool", true);
|
|
CefRefPtr<CefDictionaryValue> dict = CefDictionaryValue::Create();
|
|
dict->SetInt("key1", 5);
|
|
dict->SetString("key2", "test string");
|
|
extra_info->SetDictionary("dictionary", dict);
|
|
extra_info->SetDouble("double", 5.43322);
|
|
extra_info->SetString("string", "some string");
|
|
}
|
|
|
|
// Renderer side
|
|
class ExtraInfoNavRendererTest : public ClientAppRenderer::Delegate {
|
|
public:
|
|
ExtraInfoNavRendererTest() = default;
|
|
|
|
void OnBrowserCreated(CefRefPtr<ClientAppRenderer> app,
|
|
CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefDictionaryValue> extra_info) override {
|
|
run_test_ = extra_info && extra_info->HasKey(kExtraInfoTestCmdKey);
|
|
if (!run_test_) {
|
|
return;
|
|
}
|
|
|
|
CefRefPtr<CefDictionaryValue> expected = CefDictionaryValue::Create();
|
|
SetBrowserExtraInfo(expected);
|
|
TestDictionaryEqual(expected, extra_info);
|
|
|
|
SendTestResults(browser, browser->GetMainFrame());
|
|
}
|
|
|
|
protected:
|
|
// Send the test results.
|
|
void SendTestResults(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame) {
|
|
// Check if the test has failed.
|
|
bool result = !TestFailed();
|
|
|
|
CefRefPtr<CefProcessMessage> return_msg =
|
|
CefProcessMessage::Create(kExtraInfoNavMsg);
|
|
CefRefPtr<CefListValue> args = return_msg->GetArgumentList();
|
|
EXPECT_TRUE(args.get());
|
|
EXPECT_TRUE(args->SetBool(0, result));
|
|
EXPECT_TRUE(args->SetBool(1, browser->IsPopup()));
|
|
frame->SendProcessMessage(PID_BROWSER, return_msg);
|
|
}
|
|
|
|
bool run_test_ = false;
|
|
|
|
IMPLEMENT_REFCOUNTING(ExtraInfoNavRendererTest);
|
|
};
|
|
|
|
class ExtraInfoNavTestHandler : public TestHandler {
|
|
public:
|
|
ExtraInfoNavTestHandler() = default;
|
|
|
|
void RunTest() override {
|
|
AddResource(kExtraInfoUrl,
|
|
"<html><head></head><body>ExtraInfo</body></html>",
|
|
"text/html");
|
|
AddResource(kExtraInfoPopupUrl, "<html>ExtraInfoPopup</html>", "text/html");
|
|
|
|
CefRefPtr<CefDictionaryValue> extra_info = CefDictionaryValue::Create();
|
|
SetBrowserExtraInfo(extra_info);
|
|
|
|
// Create the browser.
|
|
CreateBrowser(kExtraInfoUrl, nullptr, extra_info);
|
|
|
|
// Time out the test after a reasonable period of time.
|
|
SetTestTimeout();
|
|
}
|
|
|
|
void OnLoadEnd(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
int httpStatusCode) override {
|
|
if (popup_opened_) {
|
|
DestroyTest();
|
|
} else {
|
|
GrantPopupPermission(browser->GetHost()->GetRequestContext(),
|
|
browser->GetMainFrame()->GetURL());
|
|
|
|
browser->GetMainFrame()->ExecuteJavaScript(
|
|
"window.open('" + std::string(kExtraInfoPopupUrl) + "');",
|
|
CefString(), 0);
|
|
}
|
|
}
|
|
|
|
bool OnBeforePopup(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
const CefString& target_url,
|
|
const CefString& target_frame_name,
|
|
cef_window_open_disposition_t target_disposition,
|
|
bool user_gesture,
|
|
const CefPopupFeatures& popupFeatures,
|
|
CefWindowInfo& windowInfo,
|
|
CefRefPtr<CefClient>& client,
|
|
CefBrowserSettings& settings,
|
|
CefRefPtr<CefDictionaryValue>& extra_info,
|
|
bool* no_javascript_access) override {
|
|
const std::string& url = target_url;
|
|
EXPECT_FALSE(popup_opened_);
|
|
EXPECT_STREQ(kExtraInfoPopupUrl, url.c_str());
|
|
|
|
CefRefPtr<CefDictionaryValue> extra = CefDictionaryValue::Create();
|
|
SetBrowserExtraInfo(extra);
|
|
|
|
extra_info = extra;
|
|
|
|
popup_opened_ = true;
|
|
return false;
|
|
}
|
|
|
|
bool OnProcessMessageReceived(CefRefPtr<CefBrowser> browser,
|
|
CefRefPtr<CefFrame> frame,
|
|
CefProcessId source_process,
|
|
CefRefPtr<CefProcessMessage> message) override {
|
|
if (message->GetName().ToString() == kExtraInfoNavMsg) {
|
|
// Test that the renderer side succeeded.
|
|
CefRefPtr<CefListValue> args = message->GetArgumentList();
|
|
EXPECT_TRUE(args.get());
|
|
EXPECT_TRUE(args->GetBool(0));
|
|
if (popup_opened_) {
|
|
EXPECT_TRUE(args->GetBool(1));
|
|
got_process_message_popup_.yes();
|
|
} else {
|
|
EXPECT_FALSE(args->GetBool(1));
|
|
got_process_message_main_.yes();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// Message not handled.
|
|
return false;
|
|
}
|
|
|
|
protected:
|
|
bool popup_opened_ = false;
|
|
TrackCallback got_process_message_main_;
|
|
TrackCallback got_process_message_popup_;
|
|
|
|
void DestroyTest() override {
|
|
// Verify test expectations.
|
|
EXPECT_TRUE(got_process_message_main_);
|
|
EXPECT_TRUE(got_process_message_popup_);
|
|
|
|
TestHandler::DestroyTest();
|
|
}
|
|
|
|
IMPLEMENT_REFCOUNTING(ExtraInfoNavTestHandler);
|
|
};
|
|
|
|
} // namespace
|
|
|
|
TEST(NavigationTest, ExtraInfo) {
|
|
CefRefPtr<ExtraInfoNavTestHandler> handler = new ExtraInfoNavTestHandler();
|
|
handler->ExecuteTest();
|
|
ReleaseAndWaitForDestructor(handler);
|
|
}
|
|
|
|
// Entry point for creating navigation renderer test objects.
|
|
// Called from client_app_delegates.cc.
|
|
void CreateNavigationRendererTests(ClientAppRenderer::DelegateSet& delegates) {
|
|
delegates.insert(new HistoryNavRendererTest);
|
|
delegates.insert(new OrderNavRendererTest);
|
|
delegates.insert(new LoadNavRendererTest);
|
|
delegates.insert(new ExtraInfoNavRendererTest);
|
|
}
|