ceftests: Add test_server support for CefTestServer (see issue #3348)

tests/ceftests/test_server_runner_test.cc

@@ -4,14 +4,145 @@
 
 #include "tests/ceftests/test_server_runner.h"
 
-#include "include/base/cef_logging.h"
+#include "include/test/cef_test_server.h"
+#include "include/wrapper/cef_closure_task.h"
+#include "include/wrapper/cef_helpers.h"
+#include "tests/gtest/include/gtest/gtest.h"
 
 namespace test_server {
 
+namespace {
+
+// Created on the UI thread and called on the dedicated server thread.
+class ServerHandler : public CefTestServerHandler {
+ public:
+  ServerHandler(Runner::Delegate* delegate, bool https_server)
+      : delegate_(delegate), https_server_(https_server) {}
+
+  ~ServerHandler() override {
+    CEF_REQUIRE_UI_THREAD();
+
+    EXPECT_FALSE(server_);
+    delegate_->OnServerHandlerDeleted();
+  }
+
+  void Start() {
+    CEF_REQUIRE_UI_THREAD();
+
+    // Use any available port number for HTTPS and the legacy port number for
+    // HTTP.
+    server_ = CefTestServer::CreateAndStart(https_server_ ? 0 : kHttpServerPort,
+                                            https_server_, this);
+
+    // Always execute asynchronously.
+    CefPostTask(TID_UI, base::BindOnce(&ServerHandler::NotifyServerCreated,
+                                       this, server_->GetOrigin()));
+  }
+
+  void Shutdown() {
+    CEF_REQUIRE_UI_THREAD();
+
+    server_->Stop();
+    server_ = nullptr;
+
+    // Always execute asynchronously.
+    CefPostTask(TID_UI,
+                base::BindOnce(&ServerHandler::NotifyServerDestroyed, this));
+  }
+
+  bool OnTestServerRequest(
+      CefRefPtr<CefTestServer> server,
+      CefRefPtr<CefRequest> request,
+      CefRefPtr<CefTestServerConnection> connection) override {
+    NotifyHttpRequest(request, connection);
+    return true;
+  }
+
+ private:
+  void NotifyServerCreated(const std::string& server_origin) {
+    CEF_REQUIRE_UI_THREAD();
+    delegate_->OnServerCreated(server_origin);
+  }
+
+  void NotifyServerDestroyed() {
+    CEF_REQUIRE_UI_THREAD();
+    delegate_->OnServerDestroyed();
+  }
+
+  void NotifyHttpRequest(CefRefPtr<CefRequest> request,
+                         CefRefPtr<CefTestServerConnection> connection) {
+    if (!CefCurrentlyOn(TID_UI)) {
+      CefPostTask(TID_UI, base::BindOnce(&ServerHandler::NotifyHttpRequest,
+                                         this, request, connection));
+      return;
+    }
+
+    auto response_callback =
+        base::BindRepeating(&ServerHandler::SendResponse, connection);
+    delegate_->OnHttpRequest(request, response_callback);
+  }
+
+  static void SendResponse(CefRefPtr<CefTestServerConnection> connection,
+                           CefRefPtr<CefResponse> response,
+                           const std::string& response_data) {
+    const int response_code = response->GetStatus();
+    if (response_code <= 0) {
+      // Intentionally not responding for incomplete request tests.
+      return;
+    }
+
+    // Incomplete response data is not supported.
+    EXPECT_NE(kIncompleteDoNotSendData, response_data.c_str());
+
+    const CefString& content_type = response->GetMimeType();
+    EXPECT_TRUE(!content_type.empty());
+
+    CefResponse::HeaderMap extra_headers;
+    response->GetHeaderMap(extra_headers);
+
+    connection->SendHttpResponse(response_code, content_type,
+                                 response_data.c_str(), response_data.size(),
+                                 extra_headers);
+  }
+
+  Runner::Delegate* const delegate_;
+  const bool https_server_;
+
+  CefRefPtr<CefTestServer> server_;
+
+  IMPLEMENT_REFCOUNTING(ServerHandler);
+  DISALLOW_COPY_AND_ASSIGN(ServerHandler);
+};
+
+class ServerRunner : public Runner {
+ public:
+  ServerRunner(Delegate* delegate, bool https_server)
+      : Runner(delegate), https_server_(https_server) {}
+
+  void StartServer() override {
+    CEF_REQUIRE_UI_THREAD();
+    DCHECK(!handler_);
+    handler_ = new ServerHandler(delegate_, https_server_);
+    handler_->Start();
+  }
+
+  void ShutdownServer() override {
+    CEF_REQUIRE_UI_THREAD();
+    DCHECK(handler_);
+    handler_->Shutdown();
+    handler_ = nullptr;
+  }
+
+ private:
+  const bool https_server_;
+  CefRefPtr<ServerHandler> handler_;
+};
+
+}  // namespace
+
 std::unique_ptr<Runner> Runner::CreateTest(Delegate* delegate,
                                            bool https_server) {
-  NOTREACHED();
-  return nullptr;
+  return std::make_unique<ServerRunner>(delegate, https_server);
 }
 
 }  // namespace test_server