ceftests: Deprecate the use of test_server constants (see issue #3348)

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 << ":"
+    EXPECT_STREQ(GetCookieAccessScheme().c_str(), scheme.c_str());
-       << kCookieAccessServerPort;
+    return test_server::GetOrigin(kUseHttpsServerScheme);
-  } else {
-    ss << scheme << "://" << kCookieAccessDomain;
   }
+
+  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) {
+  void SetExpectedRequestCount(int count) { expected_http_request_ct_ = count; }
-    EXPECT_FALSE(initialized_);
-    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<int>(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_);
   }
 

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(); }

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 char kHttpServerAddress[] = "127.0.0.1";
-const uint16 kServerPort = 8098;
+const uint16 kHttpServerPort = 8098;
-const char kServerScheme[] = "http";
+
-const char kServerOrigin[] = "http://127.0.0.1:8098";
 const char kIncompleteDoNotSendData[] = "DO NOT SEND";
 
 CefRefPtr<CefResponse> 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

tests/ceftests/test_server.h

@@ -15,10 +15,10 @@
 
 namespace test_server {
 
-extern const char kServerAddress[];
+// Use of these values is deprecated. Instead use GetOrigin/GetHost in the
-extern const uint16 kServerPort;
+// browser process after server initialization.
-extern const char kServerScheme[];
+extern const char kHttpServerAddress[];
-extern const char kServerOrigin[];
+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:<port>").
+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[:<port>]").
+std::string GetHost(bool https_server, bool include_port);
+
 }  // namespace test_server
 
 #endif  // CEF_TESTS_CEFTESTS_TEST_SERVER_H_

tests/ceftests/test_server_manager.cc

@@ -155,6 +155,15 @@ CefRefPtr<CefRegistration> 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_);

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;
 

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:<port>".
   virtual void OnInitialized(const std::string& server_origin) = 0;
 
   // Implement this method to continue the test after Shutdown().

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<CefWaitableEvent> event,
   }
 }
 
-}  // namespace
+void RunHelperSingle(bool https_server) {
-
-TEST(TestServerObserverTest, HelperSingle) {
   CefRefPtr<CefWaitableEvent> 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<CefWaitableEvent> 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);
+}

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<CefServer> server) override {
     EXPECT_TRUE(server->GetTaskRunner()->BelongsToCurrentThread());
     server_ = server;
-    NotifyServerCreated(kServerOrigin);
+    NotifyServerCreated("http://" + server->GetAddress().ToString());
   }
 
   void OnServerDestroyed(CefRefPtr<CefServer> 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,
+    CefServer::CreateServer(kHttpServerAddress, kHttpServerPort,
-                            handler_);
+                            kHttpServerBacklog, handler_);
   }
 
   void ShutdownServer() override {

tests/ceftests/urlrequest_unittest.cc

@@ -69,10 +69,11 @@ const char kIncompleteRequestTestMsg[] = "URLRequestTest.IncompleteRequestTest";
 const char kRequestSchemeCustom[] = "urcustom";
 const char kRequestHostCustom[] = "test";
 
-// Server backend.
+// Server backend. These values are hard-coded because they're used in both the
-const char* kRequestAddressServer = test_server::kServerAddress;
+// browser and renderer processes.
-const uint16 kRequestPortServer = test_server::kServerPort;
+const char* kRequestAddressServer = test_server::kHttpServerAddress;
-const char* kRequestSchemeServer = test_server::kServerScheme;
+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