RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 14:17:36 +00:00
Code Issues Activity Actions

Userland: Rename IPC ClientConnection => ConnectionFromClient

Browse source 
This was done with CLion's automatic rename feature and with:
find . -name ClientConnection.h
    | rename 's/ClientConnection\.h/ConnectionFromClient.h/'

find . -name ClientConnection.cpp
    | rename 's/ClientConnection\.cpp/ConnectionFromClient.cpp/'
This commit is contained in:
Itamar 2022-02-25 12:18:30 +02:00 • committed by Andreas Kling
parent efac862570
commit 3a71748e5d
137 changed files with 896 additions and 896 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Userland/Services/RequestServer/CMakeLists.txt
View file

@ -7,7 +7,7 @@ compile_ipc(RequestServer.ipc RequestServerEndpoint.h)
compile_ipc(RequestClient.ipc RequestClientEndpoint.h)
set(SOURCES
ClientConnection.cpp
ConnectionFromClient.cpp
ConnectionCache.cpp
Request.cpp
RequestClientEndpoint.h

30
Userland/Services/RequestServer/ClientConnection.cpp → Userland/Services/RequestServer/ConnectionFromClient.cpp
View file

@ -5,7 +5,7 @@
*/
#include <AK/Badge.h>
#include <RequestServer/ClientConnection.h>
#include <RequestServer/ConnectionFromClient.h>
#include <RequestServer/Protocol.h>
#include <RequestServer/Request.h>
#include <RequestServer/RequestClientEndpoint.h>
@ -13,32 +13,32 @@
namespace RequestServer {
static HashMap<int, RefPtr<ClientConnection>> s_connections;
static HashMap<int, RefPtr<ConnectionFromClient>> s_connections;
ClientConnection::ClientConnection(NonnullOwnPtr<Core::Stream::LocalSocket> socket)
: IPC::ClientConnection<RequestClientEndpoint, RequestServerEndpoint>(*this, move(socket), 1)
ConnectionFromClient::ConnectionFromClient(NonnullOwnPtr<Core::Stream::LocalSocket> socket)
: IPC::ConnectionFromClient<RequestClientEndpoint, RequestServerEndpoint>(*this, move(socket), 1)
{
s_connections.set(1, *this);
}
ClientConnection::~ClientConnection()
ConnectionFromClient::~ConnectionFromClient()
{
}
void ClientConnection::die()
void ConnectionFromClient::die()
{
s_connections.remove(client_id());
if (s_connections.is_empty())
Core::EventLoop::current().quit(0);
}
Messages::RequestServer::IsSupportedProtocolResponse ClientConnection::is_supported_protocol(String const& protocol)
Messages::RequestServer::IsSupportedProtocolResponse ConnectionFromClient::is_supported_protocol(String const& protocol)
{
bool supported = Protocol::find_by_name(protocol.to_lowercase());
return supported;
}
Messages::RequestServer::StartRequestResponse ClientConnection::start_request(String const& method, URL const& url, IPC::Dictionary const& request_headers, ByteBuffer const& request_body)
Messages::RequestServer::StartRequestResponse ConnectionFromClient::start_request(String const& method, URL const& url, IPC::Dictionary const& request_headers, ByteBuffer const& request_body)
{
if (!url.is_valid()) {
dbgln("StartRequest: Invalid URL requested: '{}'", url);
@ -60,7 +60,7 @@ Messages::RequestServer::StartRequestResponse ClientConnection::start_request(St
return { id, IPC::File(fd, IPC::File::CloseAfterSending) };
}
Messages::RequestServer::StopRequestResponse ClientConnection::stop_request(i32 request_id)
Messages::RequestServer::StopRequestResponse ConnectionFromClient::stop_request(i32 request_id)
{
auto* request = const_cast<Request*>(m_requests.get(request_id).value_or(nullptr));
bool success = false;
@ -72,7 +72,7 @@ Messages::RequestServer::StopRequestResponse ClientConnection::stop_request(i32
return success;
}
void ClientConnection::did_receive_headers(Badge<Request>, Request& request)
void ConnectionFromClient::did_receive_headers(Badge<Request>, Request& request)
{
IPC::Dictionary response_headers;
for (auto& it : request.response_headers())
@ -81,7 +81,7 @@ void ClientConnection::did_receive_headers(Badge<Request>, Request& request)
async_headers_became_available(request.id(), move(response_headers), request.status_code());
}
void ClientConnection::did_finish_request(Badge<Request>, Request& request, bool success)
void ConnectionFromClient::did_finish_request(Badge<Request>, Request& request, bool success)
{
VERIFY(request.total_size().has_value());
@ -90,17 +90,17 @@ void ClientConnection::did_finish_request(Badge<Request>, Request& request, bool
m_requests.remove(request.id());
}
void ClientConnection::did_progress_request(Badge<Request>, Request& request)
void ConnectionFromClient::did_progress_request(Badge<Request>, Request& request)
{
async_request_progress(request.id(), request.total_size(), request.downloaded_size());
}
void ClientConnection::did_request_certificates(Badge<Request>, Request& request)
void ConnectionFromClient::did_request_certificates(Badge<Request>, Request& request)
{
async_certificate_requested(request.id());
}
Messages::RequestServer::SetCertificateResponse ClientConnection::set_certificate(i32 request_id, String const& certificate, String const& key)
Messages::RequestServer::SetCertificateResponse ConnectionFromClient::set_certificate(i32 request_id, String const& certificate, String const& key)
{
auto* request = const_cast<Request*>(m_requests.get(request_id).value_or(nullptr));
bool success = false;
@ -111,7 +111,7 @@ Messages::RequestServer::SetCertificateResponse ClientConnection::set_certificat
return success;
}
void ClientConnection::ensure_connection(URL const& url, ::RequestServer::CacheLevel const& cache_level)
void ConnectionFromClient::ensure_connection(URL const& url, ::RequestServer::CacheLevel const& cache_level)
{
if (!url.is_valid()) {
dbgln("EnsureConnection: Invalid URL requested: '{}'", url);

12
Userland/Services/RequestServer/ClientConnection.h → Userland/Services/RequestServer/ConnectionFromClient.h
View file

@ -7,19 +7,19 @@
#pragma once
#include <AK/HashMap.h>
#include <LibIPC/ClientConnection.h>
#include <LibIPC/ConnectionFromClient.h>
#include <RequestServer/Forward.h>
#include <RequestServer/RequestClientEndpoint.h>
#include <RequestServer/RequestServerEndpoint.h>
namespace RequestServer {
class ClientConnection final
: public IPC::ClientConnection<RequestClientEndpoint, RequestServerEndpoint> {
C_OBJECT(ClientConnection);
class ConnectionFromClient final
: public IPC::ConnectionFromClient<RequestClientEndpoint, RequestServerEndpoint> {
C_OBJECT(ConnectionFromClient);
public:
~ClientConnection() override;
~ConnectionFromClient() override;
virtual void die() override;
@ -29,7 +29,7 @@ public:
void did_request_certificates(Badge<Request>, Request&);
private:
explicit ClientConnection(NonnullOwnPtr<Core::Stream::LocalSocket>);
explicit ConnectionFromClient(NonnullOwnPtr<Core::Stream::LocalSocket>);
virtual Messages::RequestServer::IsSupportedProtocolResponse is_supported_protocol(String const&) override;
virtual Messages::RequestServer::StartRequestResponse start_request(String const&, URL const&, IPC::Dictionary const&, ByteBuffer const&) override;

2
Userland/Services/RequestServer/Forward.h
View file

@ -8,7 +8,7 @@
namespace RequestServer {
class ClientConnection;
class ConnectionFromClient;
class Request;
class GeminiProtocol;
class HttpRequest;

2
Userland/Services/RequestServer/GeminiProtocol.cpp
View file

@ -21,7 +21,7 @@ GeminiProtocol::~GeminiProtocol()
{
}
OwnPtr<Request> GeminiProtocol::start_request(ClientConnection& client, const String&, const URL& url, const HashMap<String, String>&, ReadonlyBytes)
OwnPtr<Request> GeminiProtocol::start_request(ConnectionFromClient& client, const String&, const URL& url, const HashMap<String, String>&, ReadonlyBytes)
{
Gemini::GeminiRequest request;
request.set_url(url);

2
Userland/Services/RequestServer/GeminiProtocol.h
View file

@ -15,7 +15,7 @@ public:
GeminiProtocol();
virtual ~GeminiProtocol() override;
virtual OwnPtr<Request> start_request(ClientConnection&, const String& method, const URL&, const HashMap<String, String>&, ReadonlyBytes body) override;
virtual OwnPtr<Request> start_request(ConnectionFromClient&, const String& method, const URL&, const HashMap<String, String>&, ReadonlyBytes body) override;
};
}

4
Userland/Services/RequestServer/GeminiRequest.cpp
View file

@ -12,7 +12,7 @@
namespace RequestServer {
GeminiRequest::GeminiRequest(ClientConnection& client, NonnullRefPtr<Gemini::Job> job, NonnullOwnPtr<Core::Stream::File>&& output_stream)
GeminiRequest::GeminiRequest(ConnectionFromClient& client, NonnullRefPtr<Gemini::Job> job, NonnullOwnPtr<Core::Stream::File>&& output_stream)
: Request(client, move(output_stream))
, m_job(move(job))
{
@ -57,7 +57,7 @@ GeminiRequest::~GeminiRequest()
m_job->cancel();
}
NonnullOwnPtr<GeminiRequest> GeminiRequest::create_with_job(Badge<GeminiProtocol>, ClientConnection& client, NonnullRefPtr<Gemini::Job> job, NonnullOwnPtr<Core::Stream::File>&& output_stream)
NonnullOwnPtr<GeminiRequest> GeminiRequest::create_with_job(Badge<GeminiProtocol>, ConnectionFromClient& client, NonnullRefPtr<Gemini::Job> job, NonnullOwnPtr<Core::Stream::File>&& output_stream)
{
return adopt_own(*new GeminiRequest(client, move(job), move(output_stream)));
}

4
Userland/Services/RequestServer/GeminiRequest.h
View file

@ -16,14 +16,14 @@ namespace RequestServer {
class GeminiRequest final : public Request {
public:
virtual ~GeminiRequest() override;
static NonnullOwnPtr<GeminiRequest> create_with_job(Badge<GeminiProtocol>, ClientConnection&, NonnullRefPtr<Gemini::Job>, NonnullOwnPtr<Core::Stream::File>&&);
static NonnullOwnPtr<GeminiRequest> create_with_job(Badge<GeminiProtocol>, ConnectionFromClient&, NonnullRefPtr<Gemini::Job>, NonnullOwnPtr<Core::Stream::File>&&);
Gemini::Job const& job() const { return *m_job; }
virtual URL url() const override { return m_job->url(); }
private:
explicit GeminiRequest(ClientConnection&, NonnullRefPtr<Gemini::Job>, NonnullOwnPtr<Core::Stream::File>&&);
explicit GeminiRequest(ConnectionFromClient&, NonnullRefPtr<Gemini::Job>, NonnullOwnPtr<Core::Stream::File>&&);
virtual void set_certificate(String certificate, String key) override;

4
Userland/Services/RequestServer/HttpCommon.h
View file

@ -14,8 +14,8 @@
#include <AK/String.h>
#include <AK/Types.h>
#include <LibHTTP/HttpRequest.h>
#include <RequestServer/ClientConnection.h>
#include <RequestServer/ConnectionCache.h>
#include <RequestServer/ConnectionFromClient.h>
#include <RequestServer/Request.h>
namespace RequestServer::Detail {
@ -61,7 +61,7 @@ void init(TSelf* self, TJob job)
}
template<typename TBadgedProtocol, typename TPipeResult>
OwnPtr<Request> start_request(TBadgedProtocol&& protocol, ClientConnection& client, const String& method, const URL& url, const HashMap<String, String>& headers, ReadonlyBytes body, TPipeResult&& pipe_result)
OwnPtr<Request> start_request(TBadgedProtocol&& protocol, ConnectionFromClient& client, const String& method, const URL& url, const HashMap<String, String>& headers, ReadonlyBytes body, TPipeResult&& pipe_result)
{
using TJob = typename TBadgedProtocol::Type::JobType;
using TRequest = typename TBadgedProtocol::Type::RequestType;

4
Userland/Services/RequestServer/HttpProtocol.cpp
View file

@ -10,7 +10,7 @@
#include <AK/OwnPtr.h>
#include <AK/String.h>
#include <AK/URL.h>
#include <RequestServer/ClientConnection.h>
#include <RequestServer/ConnectionFromClient.h>
#include <RequestServer/HttpCommon.h>
#include <RequestServer/HttpProtocol.h>
#include <RequestServer/Request.h>
@ -22,7 +22,7 @@ HttpProtocol::HttpProtocol()
{
}
OwnPtr<Request> HttpProtocol::start_request(ClientConnection& client, const String& method, const URL& url, const HashMap<String, String>& headers, ReadonlyBytes body)
OwnPtr<Request> HttpProtocol::start_request(ConnectionFromClient& client, const String& method, const URL& url, const HashMap<String, String>& headers, ReadonlyBytes body)
{
return Detail::start_request(Badge<HttpProtocol> {}, client, method, url, headers, body, get_pipe_for_request());
}

4
Userland/Services/RequestServer/HttpProtocol.h
View file

@ -12,7 +12,7 @@
#include <AK/String.h>
#include <AK/URL.h>
#include <LibHTTP/Job.h>
#include <RequestServer/ClientConnection.h>
#include <RequestServer/ConnectionFromClient.h>
#include <RequestServer/HttpRequest.h>
#include <RequestServer/Protocol.h>
#include <RequestServer/Request.h>
@ -27,7 +27,7 @@ public:
HttpProtocol();
~HttpProtocol() override = default;
virtual OwnPtr<Request> start_request(ClientConnection&, const String& method, const URL&, const HashMap<String, String>& headers, ReadonlyBytes body) override;
virtual OwnPtr<Request> start_request(ConnectionFromClient&, const String& method, const URL&, const HashMap<String, String>& headers, ReadonlyBytes body) override;
};
}

4
Userland/Services/RequestServer/HttpRequest.cpp
View file

@ -11,7 +11,7 @@
namespace RequestServer {
HttpRequest::HttpRequest(ClientConnection& client, NonnullRefPtr<HTTP::Job> job, NonnullOwnPtr<Core::Stream::File>&& output_stream)
HttpRequest::HttpRequest(ConnectionFromClient& client, NonnullRefPtr<HTTP::Job> job, NonnullOwnPtr<Core::Stream::File>&& output_stream)
: Request(client, move(output_stream))
, m_job(job)
{
@ -25,7 +25,7 @@ HttpRequest::~HttpRequest()
m_job->cancel();
}
NonnullOwnPtr<HttpRequest> HttpRequest::create_with_job(Badge<HttpProtocol>&&, ClientConnection& client, NonnullRefPtr<HTTP::Job> job, NonnullOwnPtr<Core::Stream::File>&& output_stream)
NonnullOwnPtr<HttpRequest> HttpRequest::create_with_job(Badge<HttpProtocol>&&, ConnectionFromClient& client, NonnullRefPtr<HTTP::Job> job, NonnullOwnPtr<Core::Stream::File>&& output_stream)
{
return adopt_own(*new HttpRequest(client, move(job), move(output_stream)));
}

4
Userland/Services/RequestServer/HttpRequest.h
View file

@ -17,7 +17,7 @@ namespace RequestServer {
class HttpRequest final : public Request {
public:
virtual ~HttpRequest() override;
static NonnullOwnPtr<HttpRequest> create_with_job(Badge<HttpProtocol>&&, ClientConnection&, NonnullRefPtr<HTTP::Job>, NonnullOwnPtr<Core::Stream::File>&&);
static NonnullOwnPtr<HttpRequest> create_with_job(Badge<HttpProtocol>&&, ConnectionFromClient&, NonnullRefPtr<HTTP::Job>, NonnullOwnPtr<Core::Stream::File>&&);
HTTP::Job& job() { return m_job; }
HTTP::Job const& job() const { return m_job; }
@ -25,7 +25,7 @@ public:
virtual URL url() const override { return m_job->url(); }
private:
explicit HttpRequest(ClientConnection&, NonnullRefPtr<HTTP::Job>, NonnullOwnPtr<Core::Stream::File>&&);
explicit HttpRequest(ConnectionFromClient&, NonnullRefPtr<HTTP::Job>, NonnullOwnPtr<Core::Stream::File>&&);
NonnullRefPtr<HTTP::Job> m_job;
};

4
Userland/Services/RequestServer/HttpsProtocol.cpp
View file

@ -10,7 +10,7 @@
#include <AK/OwnPtr.h>
#include <AK/String.h>
#include <AK/URL.h>
#include <RequestServer/ClientConnection.h>
#include <RequestServer/ConnectionFromClient.h>
#include <RequestServer/HttpCommon.h>
#include <RequestServer/HttpsProtocol.h>
#include <RequestServer/Request.h>
@ -22,7 +22,7 @@ HttpsProtocol::HttpsProtocol()
{
}
OwnPtr<Request> HttpsProtocol::start_request(ClientConnection& client, const String& method, const URL& url, const HashMap<String, String>& headers, ReadonlyBytes body)
OwnPtr<Request> HttpsProtocol::start_request(ConnectionFromClient& client, const String& method, const URL& url, const HashMap<String, String>& headers, ReadonlyBytes body)
{
return Detail::start_request(Badge<HttpsProtocol> {}, client, method, url, headers, body, get_pipe_for_request());
}

4
Userland/Services/RequestServer/HttpsProtocol.h
View file

@ -12,7 +12,7 @@
#include <AK/String.h>
#include <AK/URL.h>
#include <LibHTTP/HttpsJob.h>
#include <RequestServer/ClientConnection.h>
#include <RequestServer/ConnectionFromClient.h>
#include <RequestServer/HttpsRequest.h>
#include <RequestServer/Protocol.h>
#include <RequestServer/Request.h>
@ -27,7 +27,7 @@ public:
HttpsProtocol();
~HttpsProtocol() override = default;
virtual OwnPtr<Request> start_request(ClientConnection&, const String& method, const URL&, const HashMap<String, String>& headers, ReadonlyBytes body) override;
virtual OwnPtr<Request> start_request(ConnectionFromClient&, const String& method, const URL&, const HashMap<String, String>& headers, ReadonlyBytes body) override;
};
}

4
Userland/Services/RequestServer/HttpsRequest.cpp
View file

@ -11,7 +11,7 @@
namespace RequestServer {
HttpsRequest::HttpsRequest(ClientConnection& client, NonnullRefPtr<HTTP::HttpsJob> job, NonnullOwnPtr<Core::Stream::File>&& output_stream)
HttpsRequest::HttpsRequest(ConnectionFromClient& client, NonnullRefPtr<HTTP::HttpsJob> job, NonnullOwnPtr<Core::Stream::File>&& output_stream)
: Request(client, move(output_stream))
, m_job(job)
{
@ -30,7 +30,7 @@ HttpsRequest::~HttpsRequest()
m_job->cancel();
}
NonnullOwnPtr<HttpsRequest> HttpsRequest::create_with_job(Badge<HttpsProtocol>&&, ClientConnection& client, NonnullRefPtr<HTTP::HttpsJob> job, NonnullOwnPtr<Core::Stream::File>&& output_stream)
NonnullOwnPtr<HttpsRequest> HttpsRequest::create_with_job(Badge<HttpsProtocol>&&, ConnectionFromClient& client, NonnullRefPtr<HTTP::HttpsJob> job, NonnullOwnPtr<Core::Stream::File>&& output_stream)
{
return adopt_own(*new HttpsRequest(client, move(job), move(output_stream)));
}

4
Userland/Services/RequestServer/HttpsRequest.h
View file

@ -16,7 +16,7 @@ namespace RequestServer {
class HttpsRequest final : public Request {
public:
virtual ~HttpsRequest() override;
static NonnullOwnPtr<HttpsRequest> create_with_job(Badge<HttpsProtocol>&&, ClientConnection&, NonnullRefPtr<HTTP::HttpsJob>, NonnullOwnPtr<Core::Stream::File>&&);
static NonnullOwnPtr<HttpsRequest> create_with_job(Badge<HttpsProtocol>&&, ConnectionFromClient&, NonnullRefPtr<HTTP::HttpsJob>, NonnullOwnPtr<Core::Stream::File>&&);
HTTP::HttpsJob& job() { return m_job; }
HTTP::HttpsJob const& job() const { return m_job; }
@ -24,7 +24,7 @@ public:
virtual URL url() const override { return m_job->url(); }
private:
explicit HttpsRequest(ClientConnection&, NonnullRefPtr<HTTP::HttpsJob>, NonnullOwnPtr<Core::Stream::File>&&);
explicit HttpsRequest(ConnectionFromClient&, NonnullRefPtr<HTTP::HttpsJob>, NonnullOwnPtr<Core::Stream::File>&&);
virtual void set_certificate(String certificate, String key) override;

2
Userland/Services/RequestServer/Protocol.h
View file

@ -17,7 +17,7 @@ public:
virtual ~Protocol();
const String& name() const { return m_name; }
virtual OwnPtr<Request> start_request(ClientConnection&, const String& method, const URL&, const HashMap<String, String>& headers, ReadonlyBytes body) = 0;
virtual OwnPtr<Request> start_request(ConnectionFromClient&, const String& method, const URL&, const HashMap<String, String>& headers, ReadonlyBytes body) = 0;
static Protocol* find_by_name(const String&);

4
Userland/Services/RequestServer/Request.cpp
View file

@ -4,7 +4,7 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <RequestServer/ClientConnection.h>
#include <RequestServer/ConnectionFromClient.h>
#include <RequestServer/Request.h>
namespace RequestServer {
@ -12,7 +12,7 @@ namespace RequestServer {
// FIXME: What about rollover?
static i32 s_next_id = 1;
Request::Request(ClientConnection& client, NonnullOwnPtr<Core::Stream::File>&& output_stream)
Request::Request(ConnectionFromClient& client, NonnullOwnPtr<Core::Stream::File>&& output_stream)
: m_client(client)
, m_id(s_next_id++)
, m_output_stream(move(output_stream))

4
Userland/Services/RequestServer/Request.h
View file

@ -44,10 +44,10 @@ public:
const Core::Stream::File& output_stream() const { return *m_output_stream; }
protected:
explicit Request(ClientConnection&, NonnullOwnPtr<Core::Stream::File>&&);
explicit Request(ConnectionFromClient&, NonnullOwnPtr<Core::Stream::File>&&);
private:
ClientConnection& m_client;
ConnectionFromClient& m_client;
i32 m_id { 0 };
int m_request_fd { -1 }; // Passed to client.
Optional<u32> m_status_code;

4
Userland/Services/RequestServer/main.cpp
View file

@ -11,7 +11,7 @@
#include <LibIPC/SingleServer.h>
#include <LibMain/Main.h>
#include <LibTLS/Certificate.h>
#include <RequestServer/ClientConnection.h>
#include <RequestServer/ConnectionFromClient.h>
#include <RequestServer/GeminiProtocol.h>
#include <RequestServer/HttpProtocol.h>
#include <RequestServer/HttpsProtocol.h>
@ -46,7 +46,7 @@ ErrorOr<int> serenity_main(Main::Arguments)
[[maybe_unused]] auto http = make<RequestServer::HttpProtocol>();
[[maybe_unused]] auto https = make<RequestServer::HttpsProtocol>();
auto client = TRY(IPC::take_over_accepted_client_from_system_server<RequestServer::ClientConnection>());
auto client = TRY(IPC::take_over_accepted_client_from_system_server<RequestServer::ConnectionFromClient>());
auto result = event_loop.exec();