diff --git a/tests/ceftests/cookie_unittest.cc b/tests/ceftests/cookie_unittest.cc index 6fa2974dc..a42e8aed3 100644 --- a/tests/ceftests/cookie_unittest.cc +++ b/tests/ceftests/cookie_unittest.cc @@ -1051,20 +1051,23 @@ TEST(CookieTest, GetCookieManagerCustomInMemory) { namespace { -const char kCookieAccessScheme[] = "http"; +constexpr bool kUseHttpsServerScheme = false; + const char kCookieAccessDomain[] = "test-cookies.com"; -const char* kCookieAccessServerAddress = test_server::kServerAddress; -const uint16 kCookieAccessServerPort = test_server::kServerPort; + +std::string GetCookieAccessScheme() { + return test_server::GetScheme(kUseHttpsServerScheme); +} std::string GetCookieAccessOrigin(const std::string& scheme, bool server_backend) { - std::stringstream ss; if (server_backend) { - ss << scheme << "://" << kCookieAccessServerAddress << ":" - << kCookieAccessServerPort; - } else { - ss << scheme << "://" << kCookieAccessDomain; + EXPECT_STREQ(GetCookieAccessScheme().c_str(), scheme.c_str()); + return test_server::GetOrigin(kUseHttpsServerScheme); } + + std::stringstream ss; + ss << scheme << "://" << kCookieAccessDomain; return ss.str(); } @@ -1262,33 +1265,24 @@ class CookieAccessServerHandler : public test_server::ObserverHelper, // Must be called before CreateServer(). void AddResponse(const std::string& url, CookieAccessData* data) override { - EXPECT_FALSE(initialized_); data_map_.insert(std::make_pair(url, data)); } // Must be called before CreateServer(). - void SetExpectedRequestCount(int count) { - EXPECT_FALSE(initialized_); - expected_http_request_ct_ = count; - } + void SetExpectedRequestCount(int count) { expected_http_request_ct_ = count; } // |complete_callback| will be executed on the UI thread after the server is // started. void CreateServer(base::OnceClosure complete_callback) { EXPECT_UI_THREAD(); - if (expected_http_request_ct_ < 0) { - // Default to the assumption of one request per registered URL. - SetExpectedRequestCount(static_cast(data_map_.size())); - } - EXPECT_FALSE(initialized_); initialized_ = true; EXPECT_TRUE(complete_callback_.is_null()); complete_callback_ = std::move(complete_callback); - Initialize(); + Initialize(kUseHttpsServerScheme); } // Results in a call to VerifyResults() and eventual execution of the @@ -1306,7 +1300,7 @@ class CookieAccessServerHandler : public test_server::ObserverHelper, void OnInitialized(const std::string& server_origin) override { EXPECT_UI_THREAD(); EXPECT_STREQ(server_origin.c_str(), - GetCookieAccessOrigin(kCookieAccessScheme, true).c_str()); + GetCookieAccessOrigin(GetCookieAccessScheme(), true).c_str()); EXPECT_FALSE(got_server_created_); got_server_created_.yes(); @@ -1431,7 +1425,7 @@ class CookieAccessTestHandler : public RoutingTestHandler, bool use_global) : test_mode_(test_mode), test_backend_(test_backend), - scheme_(custom_scheme ? kCustomCookieScheme : kCookieAccessScheme), + scheme_(custom_scheme ? kCustomCookieScheme : GetCookieAccessScheme()), use_global_(use_global) { if (test_mode_ == BLOCK_ALL_COOKIES) CHECK(!use_global_); @@ -1711,14 +1705,12 @@ class CookieAccessTestHandler : public RoutingTestHandler, EXPECT_FALSE(server_handler_); server_handler_ = new CookieAccessServerHandler(); - AddResponses(server_handler_); server_handler_->CreateServer(std::move(complete_callback)); } void StartSchemeHandler(base::OnceClosure complete_callback) { // Add the factory registration. scheme_factory_ = new CookieAccessSchemeHandlerFactory(); - AddResponses(scheme_factory_.get()); if (test_backend_ == SCHEME_HANDLER) { context_->RegisterSchemeHandlerFactory(scheme_, kCookieAccessDomain, scheme_factory_.get()); @@ -1734,6 +1726,15 @@ class CookieAccessTestHandler : public RoutingTestHandler, return; } + if (test_backend_ == SERVER) { + AddResponses(server_handler_); + + // 1 request for each URL. + server_handler_->SetExpectedRequestCount(2); + } else { + AddResponses(scheme_factory_.get()); + } + CreateBrowser(GetCookieAccessUrl1(scheme_, test_backend_ == SERVER), context_); } @@ -1907,7 +1908,7 @@ class CookieRestartTestHandler : public RoutingTestHandler, public CefCookieAccessFilter { public: explicit CookieRestartTestHandler(bool use_global) - : scheme_(kCookieAccessScheme), use_global_(use_global) {} + : scheme_(GetCookieAccessScheme()), use_global_(use_global) {} void RunTest() override { if (use_global_) { @@ -2171,9 +2172,6 @@ class CookieRestartTestHandler : public RoutingTestHandler, EXPECT_FALSE(server_handler_); server_handler_ = new CookieAccessServerHandler(); - AddResponses(server_handler_); - // 2 requests for each URL. - server_handler_->SetExpectedRequestCount(4); server_handler_->CreateServer(std::move(complete_callback)); } @@ -2185,6 +2183,11 @@ class CookieRestartTestHandler : public RoutingTestHandler, return; } + AddResponses(server_handler_); + + // 2 requests for each URL. + server_handler_->SetExpectedRequestCount(4); + CreateBrowser(GetCookieAccessUrl1(scheme_, true), context_); } diff --git a/tests/ceftests/cors_unittest.cc b/tests/ceftests/cors_unittest.cc index c07c03f83..5db44e804 100644 --- a/tests/ceftests/cors_unittest.cc +++ b/tests/ceftests/cors_unittest.cc @@ -43,6 +43,8 @@ class CorsBrowserTest : public client::ClientAppBrowser::Delegate { IMPLEMENT_REFCOUNTING(CorsBrowserTest); }; +constexpr bool kUseHttpsServerScheme = false; + const char kMimeTypeHtml[] = "text/html"; const char kMimeTypeText[] = "text/plain"; @@ -65,7 +67,7 @@ enum class HandlerType { std::string GetOrigin(HandlerType handler) { switch (handler) { case HandlerType::SERVER: - return test_server::kServerOrigin; + return test_server::GetOrigin(kUseHttpsServerScheme); case HandlerType::HTTP_SCHEME: // Use HTTPS because requests from HTTP to the loopback address will be // blocked by https://chromestatus.com/feature/5436853517811712. @@ -90,7 +92,7 @@ std::string GetOrigin(HandlerType handler) { std::string GetScheme(HandlerType handler) { switch (handler) { case HandlerType::SERVER: - return test_server::kServerScheme; + return test_server::GetScheme(kUseHttpsServerScheme); case HandlerType::HTTP_SCHEME: return "https"; case HandlerType::CUSTOM_STANDARD_SCHEME: @@ -301,7 +303,7 @@ class TestServerObserver : public test_server::ObserverHelper { ready_callback_(std::move(ready_callback)), done_callback_(std::move(done_callback)) { DCHECK(setup); - Initialize(); + Initialize(kUseHttpsServerScheme); } ~TestServerObserver() override { std::move(done_callback_).Run(); } diff --git a/tests/ceftests/test_server.cc b/tests/ceftests/test_server.cc index 1de1dc553..3de93cd6f 100644 --- a/tests/ceftests/test_server.cc +++ b/tests/ceftests/test_server.cc @@ -11,10 +11,9 @@ namespace test_server { // Must use a different port than server_unittest.cc. -const char kServerAddress[] = "127.0.0.1"; -const uint16 kServerPort = 8098; -const char kServerScheme[] = "http"; -const char kServerOrigin[] = "http://127.0.0.1:8098"; +const char kHttpServerAddress[] = "127.0.0.1"; +const uint16 kHttpServerPort = 8098; + const char kIncompleteDoNotSendData[] = "DO NOT SEND"; CefRefPtr Create404Response() { @@ -35,4 +34,24 @@ void Stop(base::OnceClosure callback) { /*https_server=*/true); } +std::string GetOrigin(bool https_server) { + return Manager::GetOrigin(https_server); +} + +std::string GetScheme(bool https_server) { + return https_server ? "https" : "http"; +} + +std::string GetHost(bool https_server, bool include_port) { + const auto& origin = GetOrigin(https_server); + + const auto scheme_offset = origin.find("//"); + const auto& origin_without_scheme = origin.substr(scheme_offset + 2); + if (include_port) + return origin_without_scheme; + + const auto port_offset = origin_without_scheme.find(':'); + return origin_without_scheme.substr(0, port_offset); +} + } // namespace test_server diff --git a/tests/ceftests/test_server.h b/tests/ceftests/test_server.h index 49108905f..4a1c1e531 100644 --- a/tests/ceftests/test_server.h +++ b/tests/ceftests/test_server.h @@ -15,10 +15,10 @@ namespace test_server { -extern const char kServerAddress[]; -extern const uint16 kServerPort; -extern const char kServerScheme[]; -extern const char kServerOrigin[]; +// Use of these values is deprecated. Instead use GetOrigin/GetHost in the +// browser process after server initialization. +extern const char kHttpServerAddress[]; +extern const uint16 kHttpServerPort; // Used with incomplete tests for data that should not be sent. extern const char kIncompleteDoNotSendData[]; @@ -34,6 +34,17 @@ using ResponseCallback = // UI thread. This method will be called by the test framework on shutdown. void Stop(base::OnceClosure callback); +// Returns the origin for the currently running server (e.g. +// "[http|https]://127.0.0.1:"). +std::string GetOrigin(bool https_server); + +// Returns the scheme for the currently running server (e.g. "http" or "https"). +std::string GetScheme(bool https_server); + +// Returns the host for the currently running server (e.g. +// "127.0.0.1[:]"). +std::string GetHost(bool https_server, bool include_port); + } // namespace test_server #endif // CEF_TESTS_CEFTESTS_TEST_SERVER_H_ diff --git a/tests/ceftests/test_server_manager.cc b/tests/ceftests/test_server_manager.cc index 04c6c0940..0080eb9df 100644 --- a/tests/ceftests/test_server_manager.cc +++ b/tests/ceftests/test_server_manager.cc @@ -155,6 +155,15 @@ CefRefPtr Manager::AddObserverAndStart( https_server); } +// static +std::string Manager::GetOrigin(bool https_server) { + if (auto manager = Manager::GetInstance(https_server)) { + return manager->origin_; + } + NOTREACHED(); + return std::string(); +} + void Manager::StartImpl(StartDoneCallback callback) { CEF_REQUIRE_UI_THREAD(); EXPECT_FALSE(stopping_); diff --git a/tests/ceftests/test_server_manager.h b/tests/ceftests/test_server_manager.h index 632bf7d96..d28890693 100644 --- a/tests/ceftests/test_server_manager.h +++ b/tests/ceftests/test_server_manager.h @@ -52,6 +52,9 @@ class Manager : public Runner::Delegate { StartDoneCallback callback, bool https_server); + // Returns the origin for an existing server. + static std::string GetOrigin(bool https_server); + private: friend class ObserverRegistration; diff --git a/tests/ceftests/test_server_observer.h b/tests/ceftests/test_server_observer.h index 0e00b4224..cf2fdd460 100644 --- a/tests/ceftests/test_server_observer.h +++ b/tests/ceftests/test_server_observer.h @@ -47,12 +47,13 @@ class ObserverHelper : public Observer { // Initialize the registration. If |https_server| is true an HTTPS server will // be used, otherwise an HTTP server will be used. Results in a call to // OnInitialized(). - void Initialize(bool https_server = false); + void Initialize(bool https_server); // Shut down the registration. Results in a call to OnShutdown(). void Shutdown(); // Implement this method to start sending server requests after Initialize(). + // |server_origin| will be value like "http://127.0.0.1:". virtual void OnInitialized(const std::string& server_origin) = 0; // Implement this method to continue the test after Shutdown(). diff --git a/tests/ceftests/test_server_observer_unittest.cc b/tests/ceftests/test_server_observer_unittest.cc index 309e75c61..0e3b001d7 100644 --- a/tests/ceftests/test_server_observer_unittest.cc +++ b/tests/ceftests/test_server_observer_unittest.cc @@ -17,6 +17,8 @@ namespace { struct TestState { + bool https_server = false; + TrackCallback got_initialized_; TrackCallback got_request_; TrackCallback got_response_; @@ -45,7 +47,7 @@ class TestServerObserver : public test_server::ObserverHelper { DCHECK(state); DCHECK(!path.empty()); DCHECK(!done_callback_.is_null()); - Initialize(); + Initialize(state_->https_server); } ~TestServerObserver() override { std::move(done_callback_).Run(); } @@ -161,13 +163,12 @@ void SignalIfDone(CefRefPtr event, } } -} // namespace - -TEST(TestServerObserverTest, HelperSingle) { +void RunHelperSingle(bool https_server) { CefRefPtr event = CefWaitableEvent::CreateWaitableEvent(true, false); TestState state; + state.https_server = https_server; CreateObserverOnUIThread(&state, "/TestServerTest.ObserverHelperSingle", base::BindOnce(&CefWaitableEvent::Signal, event)); event->TimedWait(2000); @@ -175,7 +176,7 @@ TEST(TestServerObserverTest, HelperSingle) { EXPECT_TRUE(state.ExpectAll()); } -TEST(TestServerObserverTest, HelperMultiple) { +void RunHelperMultiple(bool https_server) { CefRefPtr event = CefWaitableEvent::CreateWaitableEvent(true, false); @@ -188,6 +189,7 @@ TEST(TestServerObserverTest, HelperMultiple) { ss << "/TestServerTest.ObserverHelperMultiple" << i; auto done_callback = base::BindOnce(SignalIfDone, event, base::Unretained(&count), size); + states[i].https_server = https_server; CreateObserverOnUIThread(&states[i], ss.str(), std::move(done_callback)); } @@ -198,3 +200,13 @@ TEST(TestServerObserverTest, HelperMultiple) { EXPECT_TRUE(states[i].ExpectAll()) << i; } } + +} // namespace + +TEST(TestServerObserverTest, HelperSingleHttp) { + RunHelperSingle(/*https_server=*/false); +} + +TEST(TestServerObserverTest, HelperMultipleHttp) { + RunHelperMultiple(/*https_server=*/false); +} diff --git a/tests/ceftests/test_server_runner_normal.cc b/tests/ceftests/test_server_runner_normal.cc index 37b421584..87d40689a 100644 --- a/tests/ceftests/test_server_runner_normal.cc +++ b/tests/ceftests/test_server_runner_normal.cc @@ -13,7 +13,7 @@ namespace test_server { namespace { -const int kServerBacklog = 10; +const int kHttpServerBacklog = 10; // Created on the UI thread and called on the dedicated server thread. class ServerHandler : public CefServerHandler { @@ -32,7 +32,7 @@ class ServerHandler : public CefServerHandler { void OnServerCreated(CefRefPtr server) override { EXPECT_TRUE(server->GetTaskRunner()->BelongsToCurrentThread()); server_ = server; - NotifyServerCreated(kServerOrigin); + NotifyServerCreated("http://" + server->GetAddress().ToString()); } void OnServerDestroyed(CefRefPtr server) override { @@ -172,8 +172,8 @@ class ServerRunner : public Runner { CEF_REQUIRE_UI_THREAD(); DCHECK(!handler_); handler_ = new ServerHandler(delegate_); - CefServer::CreateServer(kServerAddress, kServerPort, kServerBacklog, - handler_); + CefServer::CreateServer(kHttpServerAddress, kHttpServerPort, + kHttpServerBacklog, handler_); } void ShutdownServer() override { diff --git a/tests/ceftests/urlrequest_unittest.cc b/tests/ceftests/urlrequest_unittest.cc index c49729880..87197cc1c 100644 --- a/tests/ceftests/urlrequest_unittest.cc +++ b/tests/ceftests/urlrequest_unittest.cc @@ -69,10 +69,11 @@ const char kIncompleteRequestTestMsg[] = "URLRequestTest.IncompleteRequestTest"; const char kRequestSchemeCustom[] = "urcustom"; const char kRequestHostCustom[] = "test"; -// Server backend. -const char* kRequestAddressServer = test_server::kServerAddress; -const uint16 kRequestPortServer = test_server::kServerPort; -const char* kRequestSchemeServer = test_server::kServerScheme; +// Server backend. These values are hard-coded because they're used in both the +// browser and renderer processes. +const char* kRequestAddressServer = test_server::kHttpServerAddress; +const uint16 kRequestPortServer = test_server::kHttpServerPort; +const char kRequestSchemeServer[] = "http"; const char kRequestSendCookieName[] = "urcookie_send"; const char kRequestSaveCookieName[] = "urcookie_save"; @@ -1268,7 +1269,7 @@ class RequestServerHandler : public test_server::ObserverHelper { EXPECT_TRUE(complete_callback_.is_null()); complete_callback_ = std::move(complete_callback); - Initialize(); + Initialize(/*https_server=*/false); } // Results in a call to VerifyResults() and eventual execution of the