bcarrella/cef
1
0
Fork 0
mirror of https://bitbucket.org/chromiumembedded/cef synced 2025-06-05 21:39:12 +02:00
Code Issues Packages Projects Releases Wiki Activity

ceftests: Generalize the test_server::Observer interface (see issue #3348)

Browse Source 
Don't expose CefServer implementation details to consumers.
This commit is contained in:
Marshall Greenblatt
2022-07-29 16:05:20 -04:00
parent 8353564d92
commit 68be2b8938
5 changed files with 143 additions and 345 deletions
Download Patch File Download Diff File Expand all files Collapse all files

72
tests/ceftests/cookie_unittest.cc
View File

@@ -1325,35 +1325,16 @@ class CookieAccessServerHandler : public test_server::ObserverHelper,
delete this; delete this;
} }
bool OnHttpRequest(CefRefPtr<CefServer> server, bool OnHttpRequest(CefRefPtr<CefRequest> request,
int connection_id, const ResponseCallback& response_callback) override {
const CefString& client_address,
CefRefPtr<CefRequest> request) override {
EXPECT_UI_THREAD(); EXPECT_UI_THREAD();
EXPECT_FALSE(client_address.empty());
// Log the requests for better error reporting. // Log the requests for better error reporting.
request_log_ += request->GetMethod().ToString() + " " + request_log_ += request->GetMethod().ToString() + " " +
request->GetURL().ToString() + "\n"; request->GetURL().ToString() + "\n";
HandleRequest(server, connection_id, request);
actual_http_request_ct_++; actual_http_request_ct_++;
return true;
}
private:
void VerifyResults() {
EXPECT_TRUE(got_server_created_);
EXPECT_TRUE(got_server_destroyed_);
EXPECT_EQ(expected_http_request_ct_, actual_http_request_ct_)
<< request_log_;
}
void HandleRequest(CefRefPtr<CefServer> server,
int connection_id,
CefRefPtr<CefRequest> request) {
const std::string& url = request->GetURL(); const std::string& url = request->GetURL();
ResponseDataMap::const_iterator it = data_map_.find(url); ResponseDataMap::const_iterator it = data_map_.find(url);
if (it != data_map_.end()) { if (it != data_map_.end()) {
@@ -1365,48 +1346,21 @@ class CookieAccessServerHandler : public test_server::ObserverHelper,
TestCookieString(cookie_str, it->second->cookie_js_ct_, TestCookieString(cookie_str, it->second->cookie_js_ct_,
it->second->cookie_net_ct_); it->second->cookie_net_ct_);
SendResponse(server, connection_id, it->second->response, response_callback.Run(it->second->response, it->second->response_data);
it->second->response_data); return true;
} else { } else if (!IgnoreURL(url)) {
// Unknown test. // Unknown test.
if (!IgnoreURL(url)) { ADD_FAILURE() << "Unexpected url: " << url;
ADD_FAILURE() << "Unexpected url: " << url;
}
server->SendHttp500Response(connection_id, "Unknown test");
} }
return false;
} }
static void SendResponse(CefRefPtr<CefServer> server, private:
int connection_id, void VerifyResults() {
CefRefPtr<CefResponse> response, EXPECT_TRUE(got_server_created_);
const std::string& response_data) { EXPECT_TRUE(got_server_destroyed_);
// Execute on the server thread because some methods require it. EXPECT_EQ(expected_http_request_ct_, actual_http_request_ct_)
CefRefPtr<CefTaskRunner> task_runner = server->GetTaskRunner(); << request_log_;
if (!task_runner->BelongsToCurrentThread()) {
task_runner->PostTask(CefCreateClosureTask(
base::BindOnce(CookieAccessServerHandler::SendResponse, server,
connection_id, response, response_data)));
return;
}
int response_code = response->GetStatus();
const CefString& content_type = response->GetMimeType();
int64 content_length = static_cast<int64>(response_data.size());
CefResponse::HeaderMap extra_headers;
response->GetHeaderMap(extra_headers);
server->SendHttpResponse(connection_id, response_code, content_type,
content_length, extra_headers);
if (content_length != 0) {
server->SendRawData(connection_id, response_data.data(),
response_data.size());
server->CloseConnection(connection_id);
}
// The connection should be closed.
EXPECT_FALSE(server->IsValidConnection(connection_id));
} }
void RunCompleteCallback() { void RunCompleteCallback() {

9
tests/ceftests/cors_unittest.cc
View File

@@ -311,10 +311,8 @@ class TestServerObserver : public test_server::ObserverHelper {
std::move(ready_callback_).Run(); std::move(ready_callback_).Run();
} }
bool OnHttpRequest(CefRefPtr<CefServer> server, bool OnHttpRequest(CefRefPtr<CefRequest> request,
int connection_id, const ResponseCallback& response_callback) override {
const CefString& client_address,
CefRefPtr<CefRequest> request) override {
CEF_REQUIRE_UI_THREAD(); CEF_REQUIRE_UI_THREAD();
Resource* resource = setup_->GetResource(request); Resource* resource = setup_->GetResource(request);
if (!resource) { if (!resource) {
@@ -325,8 +323,7 @@ class TestServerObserver : public test_server::ObserverHelper {
resource->response_ct++; resource->response_ct++;
EXPECT_TRUE(resource->VerifyRequest(request)) EXPECT_TRUE(resource->VerifyRequest(request))
<< request->GetURL().ToString(); << request->GetURL().ToString();
test_server::SendResponse(server, connection_id, resource->response, response_callback.Run(resource->response, resource->response_data);
resource->response_data);
// Stop propagating the callback. // Stop propagating the callback.
return true; return true;

195
tests/ceftests/test_server.cc
View File

@@ -6,8 +6,10 @@
#include <vector> #include <vector>
#include "include/cef_server.h"
#include "include/wrapper/cef_closure_task.h" #include "include/wrapper/cef_closure_task.h"
#include "include/wrapper/cef_helpers.h" #include "include/wrapper/cef_helpers.h"
#include "tests/gtest/include/gtest/gtest.h"
namespace test_server { namespace test_server {
@@ -16,6 +18,7 @@ const char kServerAddress[] = "127.0.0.1";
const uint16 kServerPort = 8098; const uint16 kServerPort = 8098;
const char kServerScheme[] = "http"; const char kServerScheme[] = "http";
const char kServerOrigin[] = "http://127.0.0.1:8098"; const char kServerOrigin[] = "http://127.0.0.1:8098";
const char kIncompleteDoNotSendData[] = "DO NOT SEND";
namespace { namespace {
@@ -33,7 +36,7 @@ class ServerHandler : public CefServerHandler {
} }
~ServerHandler() override { ~ServerHandler() override {
DCHECK(!server_); EXPECT_FALSE(server_);
NotifyServerHandlerDeleted(); NotifyServerHandlerDeleted();
} }
@@ -53,15 +56,13 @@ class ServerHandler : public CefServerHandler {
void OnClientConnected(CefRefPtr<CefServer> server, void OnClientConnected(CefRefPtr<CefServer> server,
int connection_id) override { int connection_id) override {
DCHECK(server->HasConnection()); EXPECT_TRUE(server->HasConnection());
DCHECK(server->IsValidConnection(connection_id)); EXPECT_TRUE(server->IsValidConnection(connection_id));
NotifyClientConnected(server, connection_id);
} }
void OnClientDisconnected(CefRefPtr<CefServer> server, void OnClientDisconnected(CefRefPtr<CefServer> server,
int connection_id) override { int connection_id) override {
DCHECK(!server->IsValidConnection(connection_id)); EXPECT_FALSE(server->IsValidConnection(connection_id));
NotifyClientDisconnected(server, connection_id);
} }
void OnHttpRequest(CefRefPtr<CefServer> server, void OnHttpRequest(CefRefPtr<CefServer> server,
@@ -87,10 +88,6 @@ class ServerHandler : public CefServerHandler {
static void NotifyServerCreated(const std::string& server_origin); static void NotifyServerCreated(const std::string& server_origin);
static void NotifyServerDestroyed(); static void NotifyServerDestroyed();
static void NotifyServerHandlerDeleted(); static void NotifyServerHandlerDeleted();
static void NotifyClientConnected(CefRefPtr<CefServer> server,
int connection_id);
static void NotifyClientDisconnected(CefRefPtr<CefServer> server,
int connection_id);
static void NotifyHttpRequest(CefRefPtr<CefServer> server, static void NotifyHttpRequest(CefRefPtr<CefServer> server,
int connection_id, int connection_id,
const CefString& client_address, const CefString& client_address,
@@ -107,15 +104,15 @@ class ServerManager {
public: public:
ServerManager() { ServerManager() {
CEF_REQUIRE_UI_THREAD(); CEF_REQUIRE_UI_THREAD();
DCHECK(!g_manager); EXPECT_FALSE(g_manager);
g_manager = this; g_manager = this;
} }
~ServerManager() { ~ServerManager() {
CEF_REQUIRE_UI_THREAD(); CEF_REQUIRE_UI_THREAD();
DCHECK(observer_list_.empty()); EXPECT_TRUE(observer_list_.empty());
DCHECK(start_callback_list_.empty()); EXPECT_TRUE(start_callback_list_.empty());
DCHECK(stop_callback_.is_null()); EXPECT_TRUE(stop_callback_.is_null());
g_manager = nullptr; g_manager = nullptr;
} }
@@ -147,7 +144,7 @@ class ServerManager {
} }
// Only 1 stop callback supported. // Only 1 stop callback supported.
DCHECK(stop_callback_.is_null()); EXPECT_TRUE(stop_callback_.is_null());
stop_callback_ = std::move(callback); stop_callback_ = std::move(callback);
handler_->Shutdown(); handler_->Shutdown();
@@ -169,13 +166,13 @@ class ServerManager {
break; break;
} }
} }
DCHECK(found); EXPECT_TRUE(found);
} }
void NotifyServerCreated(const std::string& server_origin) { void NotifyServerCreated(const std::string& server_origin) {
CEF_REQUIRE_UI_THREAD(); CEF_REQUIRE_UI_THREAD();
DCHECK(origin_.empty()); EXPECT_TRUE(origin_.empty());
origin_ = server_origin; origin_ = server_origin;
for (auto& callback : start_callback_list_) { for (auto& callback : start_callback_list_) {
@@ -195,47 +192,12 @@ class ServerManager {
void NotifyServerHandlerDeleted() { void NotifyServerHandlerDeleted() {
CEF_REQUIRE_UI_THREAD(); CEF_REQUIRE_UI_THREAD();
DCHECK(!stop_callback_.is_null()); EXPECT_FALSE(stop_callback_.is_null());
std::move(stop_callback_).Run(); std::move(stop_callback_).Run();
delete this; delete this;
} }
void NotifyClientConnected(CefRefPtr<CefServer> server, int connection_id) {
CEF_REQUIRE_UI_THREAD();
if (observer_list_.empty())
return;
// Use a copy in case |observer_list_| is modified during iteration.
ObserverList list = observer_list_;
ObserverList::const_iterator it = list.begin();
for (; it != list.end(); ++it) {
if ((*it)->OnClientConnected(server, connection_id)) {
break;
}
}
}
void NotifyClientDisconnected(CefRefPtr<CefServer> server,
int connection_id) {
CEF_REQUIRE_UI_THREAD();
if (observer_list_.empty())
return;
// Use a copy in case |observer_list_| is modified during iteration.
ObserverList list = observer_list_;
ObserverList::const_iterator it = list.begin();
for (; it != list.end(); ++it) {
if ((*it)->OnClientDisconnected(server, connection_id)) {
break;
}
}
}
void NotifyHttpRequest(CefRefPtr<CefServer> server, void NotifyHttpRequest(CefRefPtr<CefServer> server,
int connection_id, int connection_id,
const CefString& client_address, const CefString& client_address,
@@ -252,17 +214,19 @@ class ServerManager {
return; return;
} }
DCHECK(!observer_list_.empty()) << url; EXPECT_FALSE(observer_list_.empty()) << url;
// Use a copy in case |observer_list_| is modified during iteration. // Use a copy in case |observer_list_| is modified during iteration.
ObserverList list = observer_list_; ObserverList list = observer_list_;
bool handled = false; bool handled = false;
auto response_callback = base::BindRepeating(&ServerManager::SendResponse,
server, connection_id);
ObserverList::const_iterator it = list.begin(); ObserverList::const_iterator it = list.begin();
for (; it != list.end(); ++it) { for (; it != list.end(); ++it) {
if ((*it)->OnHttpRequest(server, connection_id, client_address, if ((*it)->OnHttpRequest(request, response_callback)) {
request)) {
handled = true; handled = true;
break; break;
} }
@@ -274,6 +238,52 @@ class ServerManager {
} }
private: private:
static void SendResponse(CefRefPtr<CefServer> server,
int connection_id,
CefRefPtr<CefResponse> response,
const std::string& response_data) {
// Execute on the server thread because some methods require it.
CefRefPtr<CefTaskRunner> task_runner = server->GetTaskRunner();
if (!task_runner->BelongsToCurrentThread()) {
task_runner->PostTask(CefCreateClosureTask(
base::BindOnce(ServerManager::SendResponse, server, connection_id,
response, response_data)));
return;
}
// No response should be sent yet.
EXPECT_TRUE(server->IsValidConnection(connection_id));
const int response_code = response->GetStatus();
if (response_code <= 0) {
// Intentionally not responding for incomplete request tests.
return;
}
const CefString& content_type = response->GetMimeType();
int64 content_length = static_cast<int64>(response_data.size());
CefResponse::HeaderMap extra_headers;
response->GetHeaderMap(extra_headers);
server->SendHttpResponse(connection_id, response_code, content_type,
content_length, extra_headers);
if (response_data == kIncompleteDoNotSendData) {
// Intentionally not sending data for incomplete request tests.
return;
}
if (content_length != 0) {
server->SendRawData(connection_id, response_data.data(),
response_data.size());
server->CloseConnection(connection_id);
}
// The connection should be closed.
EXPECT_FALSE(server->IsValidConnection(connection_id));
}
CefRefPtr<ServerHandler> handler_; CefRefPtr<ServerHandler> handler_;
std::string origin_; std::string origin_;
@@ -295,7 +305,7 @@ ServerManager* GetServerManager() {
ServerManager* GetOrCreateServerManager() { ServerManager* GetOrCreateServerManager() {
if (!g_manager) { if (!g_manager) {
new ServerManager(); new ServerManager();
DCHECK(g_manager); EXPECT_TRUE(g_manager);
} }
return g_manager; return g_manager;
} }
@@ -332,30 +342,6 @@ void ServerHandler::NotifyServerHandlerDeleted() {
GetServerManager()->NotifyServerHandlerDeleted(); GetServerManager()->NotifyServerHandlerDeleted();
} }
// static
void ServerHandler::NotifyClientConnected(CefRefPtr<CefServer> server,
int connection_id) {
if (!CefCurrentlyOn(TID_UI)) {
CefPostTask(TID_UI, base::BindOnce(ServerHandler::NotifyClientConnected,
server, connection_id));
return;
}
GetServerManager()->NotifyClientConnected(server, connection_id);
}
// static
void ServerHandler::NotifyClientDisconnected(CefRefPtr<CefServer> server,
int connection_id) {
if (!CefCurrentlyOn(TID_UI)) {
CefPostTask(TID_UI, base::BindOnce(ServerHandler::NotifyClientDisconnected,
server, connection_id));
return;
}
GetServerManager()->NotifyClientDisconnected(server, connection_id);
}
// static // static
void ServerHandler::NotifyHttpRequest(CefRefPtr<CefServer> server, void ServerHandler::NotifyHttpRequest(CefRefPtr<CefServer> server,
int connection_id, int connection_id,
@@ -376,7 +362,7 @@ class ObserverRegistration : public CefRegistration {
public: public:
explicit ObserverRegistration(Observer* const observer) explicit ObserverRegistration(Observer* const observer)
: observer_(observer) { : observer_(observer) {
DCHECK(observer_); EXPECT_TRUE(observer_);
} }
~ObserverRegistration() override { ~ObserverRegistration() override {
@@ -410,7 +396,7 @@ void InitializeRegistration(CefRefPtr<ObserverRegistration> registration,
return; return;
} }
DCHECK(!g_stopping); EXPECT_FALSE(g_stopping);
registration->Initialize(); registration->Initialize();
if (!callback.is_null()) if (!callback.is_null())
@@ -420,26 +406,26 @@ void InitializeRegistration(CefRefPtr<ObserverRegistration> registration,
} // namespace } // namespace
void Start(StartDoneCallback callback) { void Start(StartDoneCallback callback) {
DCHECK(!callback.is_null()); EXPECT_FALSE(callback.is_null());
if (!CefCurrentlyOn(TID_UI)) { if (!CefCurrentlyOn(TID_UI)) {
CefPostTask(TID_UI, base::BindOnce(Start, std::move(callback))); CefPostTask(TID_UI, base::BindOnce(Start, std::move(callback)));
return; return;
} }
DCHECK(!g_stopping); EXPECT_FALSE(g_stopping);
GetOrCreateServerManager()->Start(std::move(callback)); GetOrCreateServerManager()->Start(std::move(callback));
} }
void Stop(DoneCallback callback) { void Stop(DoneCallback callback) {
DCHECK(!callback.is_null()); EXPECT_FALSE(callback.is_null());
if (!CefCurrentlyOn(TID_UI)) { if (!CefCurrentlyOn(TID_UI)) {
CefPostTask(TID_UI, base::BindOnce(Stop, std::move(callback))); CefPostTask(TID_UI, base::BindOnce(Stop, std::move(callback)));
return; return;
} }
// Stop will be called one time on test framework shutdown. // Stop will be called one time on test framework shutdown.
DCHECK(!g_stopping); EXPECT_FALSE(g_stopping);
g_stopping = true; g_stopping = true;
ServerManager* manager = GetServerManager(); ServerManager* manager = GetServerManager();
@@ -452,7 +438,7 @@ void Stop(DoneCallback callback) {
CefRefPtr<CefRegistration> AddObserver(Observer* observer, CefRefPtr<CefRegistration> AddObserver(Observer* observer,
DoneCallback callback) { DoneCallback callback) {
DCHECK(observer); EXPECT_TRUE(observer);
CefRefPtr<ObserverRegistration> registration = CefRefPtr<ObserverRegistration> registration =
new ObserverRegistration(observer); new ObserverRegistration(observer);
InitializeRegistration(registration, std::move(callback)); InitializeRegistration(registration, std::move(callback));
@@ -464,27 +450,6 @@ CefRefPtr<CefRegistration> AddObserverAndStart(Observer* observer,
return AddObserver(observer, base::BindOnce(Start, std::move(callback))); return AddObserver(observer, base::BindOnce(Start, std::move(callback)));
} }
void SendResponse(CefRefPtr<CefServer> server,
int connection_id,
CefRefPtr<CefResponse> response,
const std::string& response_data) {
const int response_code = response->GetStatus();
const CefString& content_type = response->GetMimeType();
int64 content_length = static_cast<int64>(response_data.size());
CefResponse::HeaderMap extra_headers;
response->GetHeaderMap(extra_headers);
server->SendHttpResponse(connection_id, response_code, content_type,
content_length, extra_headers);
if (content_length != 0) {
server->SendRawData(connection_id, response_data.data(),
response_data.size());
server->CloseConnection(connection_id);
}
}
// ObserverHelper // ObserverHelper
ObserverHelper::ObserverHelper() : weak_ptr_factory_(this) { ObserverHelper::ObserverHelper() : weak_ptr_factory_(this) {
@@ -492,12 +457,12 @@ ObserverHelper::ObserverHelper() : weak_ptr_factory_(this) {
} }
ObserverHelper::~ObserverHelper() { ObserverHelper::~ObserverHelper() {
DCHECK(state_ == State::NONE); EXPECT_TRUE(state_ == State::NONE);
} }
void ObserverHelper::Initialize() { void ObserverHelper::Initialize() {
CEF_REQUIRE_UI_THREAD(); CEF_REQUIRE_UI_THREAD();
DCHECK(state_ == State::NONE); EXPECT_TRUE(state_ == State::NONE);
state_ = State::INITIALIZING; state_ = State::INITIALIZING;
registration_ = registration_ =
AddObserverAndStart(this, base::BindOnce(&ObserverHelper::OnStartDone, AddObserverAndStart(this, base::BindOnce(&ObserverHelper::OnStartDone,
@@ -506,23 +471,23 @@ void ObserverHelper::Initialize() {
void ObserverHelper::Shutdown() { void ObserverHelper::Shutdown() {
CEF_REQUIRE_UI_THREAD(); CEF_REQUIRE_UI_THREAD();
DCHECK(state_ == State::INITIALIZED); EXPECT_TRUE(state_ == State::INITIALIZED);
state_ = State::SHUTTINGDOWN; state_ = State::SHUTTINGDOWN;
registration_ = nullptr; registration_ = nullptr;
} }
void ObserverHelper::OnStartDone(const std::string& server_origin) { void ObserverHelper::OnStartDone(const std::string& server_origin) {
DCHECK(state_ == State::INITIALIZING); EXPECT_TRUE(state_ == State::INITIALIZING);
state_ = State::INITIALIZED; state_ = State::INITIALIZED;
OnInitialized(server_origin); OnInitialized(server_origin);
} }
void ObserverHelper::OnRegistered() { void ObserverHelper::OnRegistered() {
DCHECK(state_ == State::INITIALIZING); EXPECT_TRUE(state_ == State::INITIALIZING);
} }
void ObserverHelper::OnUnregistered() { void ObserverHelper::OnUnregistered() {
DCHECK(state_ == State::SHUTTINGDOWN); EXPECT_TRUE(state_ == State::SHUTTINGDOWN);
state_ = State::NONE; state_ = State::NONE;
OnShutdown(); OnShutdown();
} }

48
tests/ceftests/test_server.h
View File

@@ -12,7 +12,6 @@
#include "include/cef_registration.h" #include "include/cef_registration.h"
#include "include/cef_request.h" #include "include/cef_request.h"
#include "include/cef_response.h" #include "include/cef_response.h"
#include "include/cef_server.h"
namespace test_server { namespace test_server {
@@ -21,6 +20,9 @@ extern const uint16 kServerPort;
extern const char kServerScheme[]; extern const char kServerScheme[];
extern const char kServerOrigin[]; extern const char kServerOrigin[];
// Used with incomplete tests for data that should not be sent.
extern const char kIncompleteDoNotSendData[];
using DoneCallback = base::OnceClosure; using DoneCallback = base::OnceClosure;
using StartDoneCallback = using StartDoneCallback =
@@ -35,8 +37,7 @@ void Start(StartDoneCallback callback);
// UI thread. This method will be called by the test framework on shutdown. // UI thread. This method will be called by the test framework on shutdown.
void Stop(DoneCallback callback); void Stop(DoneCallback callback);
// Observer for CefServerHandler callbacks. Methods will be called on the UI // Observer for server callbacks. Methods will be called on the UI thread.
// thread.
class Observer { class Observer {
public: public:
// Called when this Observer is registered. // Called when this Observer is registered.
@@ -45,30 +46,25 @@ class Observer {
// Called when this Observer is unregistered. // Called when this Observer is unregistered.
virtual void OnUnregistered() = 0; virtual void OnUnregistered() = 0;
// See CefServerHandler documentation for usage. Return true if the callback using ResponseCallback =
// was handled. base::RepeatingCallback<void(CefRefPtr<CefResponse> response,
virtual bool OnClientConnected(CefRefPtr<CefServer> server, const std::string& response_data)>;
int connection_id) {
return false; // Return true and execute |response_callback| either synchronously or
} // asynchronously if the request was handled. Do not execute
virtual bool OnClientDisconnected(CefRefPtr<CefServer> server, // |response_callback| when returning false.
int connection_id) { virtual bool OnHttpRequest(CefRefPtr<CefRequest> request,
return false; const ResponseCallback& response_callback) = 0;
}
virtual bool OnHttpRequest(CefRefPtr<CefServer> server,
int connection_id,
const CefString& client_address,
CefRefPtr<CefRequest> request) = 0;
protected: protected:
virtual ~Observer() {} virtual ~Observer() {}
}; };
// Add an observer for CefServerHandler callbacks. Remains registered until the // Add an observer for server callbacks. Remains registered until the returned
// returned CefRegistration object is destroyed. Registered observers will be // CefRegistration object is destroyed. Registered observers will be executed in
// executed in the order of registration until one returns true to indicate that // the order of registration until one returns true to indicate that it handled
// it handled the callback. |callback| will be executed on the UI thread after // the callback. |callback| will be executed on the UI thread after registration
// registration is complete. // is complete.
CefRefPtr<CefRegistration> AddObserver(Observer* observer, CefRefPtr<CefRegistration> AddObserver(Observer* observer,
DoneCallback callback); DoneCallback callback);
@@ -76,15 +72,9 @@ CefRefPtr<CefRegistration> AddObserver(Observer* observer,
CefRefPtr<CefRegistration> AddObserverAndStart(Observer* observer, CefRefPtr<CefRegistration> AddObserverAndStart(Observer* observer,
StartDoneCallback callback); StartDoneCallback callback);
// Helper for sending a fully qualified response.
void SendResponse(CefRefPtr<CefServer> server,
int connection_id,
CefRefPtr<CefResponse> response,
const std::string& response_data);
// Helper for managing Observer registration and callbacks. Only used on the UI // Helper for managing Observer registration and callbacks. Only used on the UI
// thread. // thread.
class ObserverHelper : Observer { class ObserverHelper : public Observer {
public: public:
ObserverHelper(); ObserverHelper();
~ObserverHelper() override; ~ObserverHelper() override;

164
tests/ceftests/urlrequest_unittest.cc
View File

@@ -79,9 +79,6 @@ const char kRequestSaveCookieName[] = "urcookie_save";
const char kCacheControlHeader[] = "cache-control"; const char kCacheControlHeader[] = "cache-control";
// Used with incomplete tests for data that should not be sent.
const char kIncompleteDoNotSendData[] = "DO NOT SEND";
enum RequestTestMode { enum RequestTestMode {
REQTEST_GET = 0, REQTEST_GET = 0,
REQTEST_GET_NODATA, REQTEST_GET_NODATA,
@@ -1238,8 +1235,6 @@ class RequestServerHandler : public test_server::ObserverHelper {
public: public:
RequestServerHandler() RequestServerHandler()
: initialized_(false), : initialized_(false),
expected_connection_ct_(-1),
actual_connection_ct_(0),
expected_http_request_ct_(-1), expected_http_request_ct_(-1),
actual_http_request_ct_(0) {} actual_http_request_ct_(0) {}
@@ -1254,7 +1249,7 @@ class RequestServerHandler : public test_server::ObserverHelper {
// Must be called before CreateServer(). // Must be called before CreateServer().
void SetExpectedRequestCount(int count) { void SetExpectedRequestCount(int count) {
EXPECT_FALSE(initialized_); EXPECT_FALSE(initialized_);
expected_connection_ct_ = expected_http_request_ct_ = count; expected_http_request_ct_ = count;
} }
// |complete_callback| will be executed on the UI thread after the server is // |complete_callback| will be executed on the UI thread after the server is
@@ -1262,7 +1257,7 @@ class RequestServerHandler : public test_server::ObserverHelper {
void CreateServer(base::OnceClosure complete_callback) { void CreateServer(base::OnceClosure complete_callback) {
EXPECT_UI_THREAD(); EXPECT_UI_THREAD();
if (expected_connection_ct_ < 0) { if (expected_http_request_ct_ < 0) {
// Default to the assumption of one request per registered URL. // Default to the assumption of one request per registered URL.
SetExpectedRequestCount(static_cast<int>(data_map_.size())); SetExpectedRequestCount(static_cast<int>(data_map_.size()));
} }
@@ -1308,116 +1303,60 @@ class RequestServerHandler : public test_server::ObserverHelper {
delete this; delete this;
} }
bool OnClientConnected(CefRefPtr<CefServer> server, bool OnHttpRequest(CefRefPtr<CefRequest> request,
int connection_id) override { const ResponseCallback& response_callback) override {
EXPECT_UI_THREAD(); EXPECT_UI_THREAD();
if (!IsChromeRuntimeEnabled()) {
EXPECT_TRUE(connection_id_set_.find(connection_id) ==
connection_id_set_.end());
connection_id_set_.insert(connection_id);
}
actual_connection_ct_++;
return true;
}
bool OnClientDisconnected(CefRefPtr<CefServer> server,
int connection_id) override {
EXPECT_UI_THREAD();
if (!IsChromeRuntimeEnabled()) {
ConnectionIdSet::iterator it = connection_id_set_.find(connection_id);
EXPECT_TRUE(it != connection_id_set_.end());
connection_id_set_.erase(it);
}
return true;
}
bool OnHttpRequest(CefRefPtr<CefServer> server,
int connection_id,
const CefString& client_address,
CefRefPtr<CefRequest> request) override {
EXPECT_UI_THREAD();
if (!IsChromeRuntimeEnabled()) {
EXPECT_TRUE(VerifyConnection(connection_id));
}
EXPECT_FALSE(client_address.empty());
// Log the requests for better error reporting. // Log the requests for better error reporting.
request_log_ += request->GetMethod().ToString() + " " + request_log_ += request->GetMethod().ToString() + " " +
request->GetURL().ToString() + "\n"; request->GetURL().ToString() + "\n";
// TODO(chrome-runtime): Debug why favicon requests don't always have the
// correct resource type.
const std::string& url = request->GetURL();
if (request->GetResourceType() == RT_FAVICON ||
url.find("/favicon.ico") != std::string::npos) {
// We don't currently handle favicon requests.
server->SendHttp404Response(connection_id);
return true;
}
HandleRequest(server, connection_id, request);
actual_http_request_ct_++; actual_http_request_ct_++;
return true; return HandleRequest(request, response_callback);
} }
private: private:
bool VerifyConnection(int connection_id) {
return connection_id_set_.find(connection_id) != connection_id_set_.end();
}
void VerifyResults() { void VerifyResults() {
EXPECT_TRUE(got_initialized_); EXPECT_TRUE(got_initialized_);
EXPECT_TRUE(got_shutdown_); EXPECT_TRUE(got_shutdown_);
if (!IsChromeRuntimeEnabled()) { EXPECT_EQ(expected_http_request_ct_, actual_http_request_ct_)
EXPECT_TRUE(connection_id_set_.empty()); << request_log_;
EXPECT_EQ(expected_connection_ct_, actual_connection_ct_) << request_log_;
EXPECT_EQ(expected_http_request_ct_, actual_http_request_ct_)
<< request_log_;
}
} }
void HandleRequest(CefRefPtr<CefServer> server, bool HandleRequest(CefRefPtr<CefRequest> request,
int connection_id, const ResponseCallback& response_callback) {
CefRefPtr<CefRequest> request) {
RequestDataMap::Entry entry = data_map_.Find(request->GetURL()); RequestDataMap::Entry entry = data_map_.Find(request->GetURL());
if (entry.type == RequestDataMap::Entry::TYPE_NORMAL) { if (entry.type == RequestDataMap::Entry::TYPE_NORMAL) {
const bool needs_auth = entry.settings->expect_authentication && const bool needs_auth = entry.settings->expect_authentication &&
!IsAuthorized(request, entry.settings->username, !IsAuthorized(request, entry.settings->username,
entry.settings->password); entry.settings->password);
if (needs_auth) { if (needs_auth) {
HandleAuthRequest(server, connection_id, request); return HandleAuthRequest(request, response_callback);
return;
} }
HandleNormalRequest(server, connection_id, request, entry.settings); return HandleNormalRequest(request, response_callback, entry.settings);
} else if (entry.type == RequestDataMap::Entry::TYPE_REDIRECT) { } else if (entry.type == RequestDataMap::Entry::TYPE_REDIRECT) {
HandleRedirectRequest(server, connection_id, request, return HandleRedirectRequest(request, response_callback,
entry.redirect_request, entry.redirect_response); entry.redirect_request,
entry.redirect_response);
} else { } else {
// Unknown test. // Unknown test.
ADD_FAILURE() << "url: " << request->GetURL().ToString(); ADD_FAILURE() << "url: " << request->GetURL().ToString();
server->SendHttp500Response(connection_id, "Unknown test");
} }
return false;
} }
static void HandleAuthRequest(CefRefPtr<CefServer> server, static bool HandleAuthRequest(CefRefPtr<CefRequest> request,
int connection_id, const ResponseCallback& response_callback) {
CefRefPtr<CefRequest> request) {
CefRefPtr<CefResponse> response = CefResponse::Create(); CefRefPtr<CefResponse> response = CefResponse::Create();
GetAuthResponse(response); GetAuthResponse(response);
SendResponse(server, connection_id, response, std::string()); response_callback.Run(response, std::string());
return true;
} }
static void HandleNormalRequest(CefRefPtr<CefServer> server, static bool HandleNormalRequest(CefRefPtr<CefRequest> request,
int connection_id, const ResponseCallback& response_callback,
CefRefPtr<CefRequest> request,
RequestRunSettings* settings) { RequestRunSettings* settings) {
VerifyNormalRequest(settings, request, true); VerifyNormalRequest(settings, request, true);
@@ -1432,12 +1371,12 @@ class RequestServerHandler : public test_server::ObserverHelper {
response_data = settings->response_data.substr(expected_offset); response_data = settings->response_data.substr(expected_offset);
} }
SendResponse(server, connection_id, response, response_data); response_callback.Run(response, response_data);
return true;
} }
static void HandleRedirectRequest(CefRefPtr<CefServer> server, static bool HandleRedirectRequest(CefRefPtr<CefRequest> request,
int connection_id, const ResponseCallback& response_callback,
CefRefPtr<CefRequest> request,
CefRefPtr<CefRequest> redirect_request, CefRefPtr<CefRequest> redirect_request,
CefRefPtr<CefResponse> redirect_response) { CefRefPtr<CefResponse> redirect_response) {
if (redirect_response->GetStatus() == 302) { if (redirect_response->GetStatus() == 302) {
@@ -1455,50 +1394,8 @@ class RequestServerHandler : public test_server::ObserverHelper {
// Verify that the request was sent correctly. // Verify that the request was sent correctly.
TestRequestEqual(redirect_request, request, true); TestRequestEqual(redirect_request, request, true);
SendResponse(server, connection_id, redirect_response, std::string()); response_callback.Run(redirect_response, std::string());
} return true;
static void SendResponse(CefRefPtr<CefServer> server,
int connection_id,
CefRefPtr<CefResponse> response,
const std::string& response_data) {
// Execute on the server thread because some methods require it.
CefRefPtr<CefTaskRunner> task_runner = server->GetTaskRunner();
if (!task_runner->BelongsToCurrentThread()) {
task_runner->PostTask(CefCreateClosureTask(
base::BindOnce(RequestServerHandler::SendResponse, server,
connection_id, response, response_data)));
return;
}
const int response_code = response->GetStatus();
if (response_code <= 0) {
// Intentionally not responding for incomplete request tests.
return;
}
const CefString& content_type = response->GetMimeType();
int64 content_length = static_cast<int64>(response_data.size());
CefResponse::HeaderMap extra_headers;
response->GetHeaderMap(extra_headers);
server->SendHttpResponse(connection_id, response_code, content_type,
content_length, extra_headers);
if (response_data == kIncompleteDoNotSendData) {
// Intentionally not sending data for incomplete request tests.
return;
}
if (content_length != 0) {
server->SendRawData(connection_id, response_data.data(),
response_data.size());
server->CloseConnection(connection_id);
}
// The connection should be closed.
EXPECT_FALSE(server->IsValidConnection(connection_id));
} }
void RunCompleteCallback(bool startup) { void RunCompleteCallback(bool startup) {
@@ -1526,11 +1423,6 @@ class RequestServerHandler : public test_server::ObserverHelper {
TrackCallback got_initialized_; TrackCallback got_initialized_;
TrackCallback got_shutdown_; TrackCallback got_shutdown_;
typedef std::set<int> ConnectionIdSet;
ConnectionIdSet connection_id_set_;
int expected_connection_ct_;
int actual_connection_ct_;
int expected_http_request_ct_; int expected_http_request_ct_;
int actual_http_request_ct_; int actual_http_request_ct_;
@@ -2397,7 +2289,7 @@ class RequestTestRunner : public base::RefCountedThreadSafe<RequestTestRunner> {
// There will be a response but the request will be aborted without // There will be a response but the request will be aborted without
// receiving any data. // receiving any data.
settings_.response_data = kIncompleteDoNotSendData; settings_.response_data = test_server::kIncompleteDoNotSendData;
settings_.expected_error_code = ERR_ABORTED; settings_.expected_error_code = ERR_ABORTED;
settings_.expected_status = UR_FAILED; settings_.expected_status = UR_FAILED;
// TODO(network): Download progress notifications are sent for incomplete // TODO(network): Download progress notifications are sent for incomplete