LibIPC: Rename base classes to IClientConnection and IServerConnection

This matches what we're already calling the server-side subclasses
better, though we'll probably want to find some better names for the
client-side classes eventually.

16 files changed, 248 insertions, 269 deletions

diff --git a/Libraries/LibAudio/AClientConnection.cpp b/Libraries/LibAudio/AClientConnection.cpp
index 42ffaece93..c8ec8758a9 100644
--- a/Libraries/LibAudio/AClientConnection.cpp
+++ b/Libraries/LibAudio/AClientConnection.cpp
@@ -3,7 +3,7 @@
 #include <SharedBuffer.h>
 
 AClientConnection::AClientConnection()
-    : ConnectionNG(*this, "/tmp/portal/audio")
+    : IServerConnection(*this, "/tmp/portal/audio")
 {
 }
 
diff --git a/Libraries/LibAudio/AClientConnection.h b/Libraries/LibAudio/AClientConnection.h
index d05d37e047..30e971a4c7 100644
--- a/Libraries/LibAudio/AClientConnection.h
+++ b/Libraries/LibAudio/AClientConnection.h
@@ -6,7 +6,7 @@
 
 class ABuffer;
 
-class AClientConnection : public IPC::Client::ConnectionNG<AudioClientEndpoint, AudioServerEndpoint>
+class AClientConnection : public IServerConnection<AudioClientEndpoint, AudioServerEndpoint>
     , public AudioClientEndpoint {
     C_OBJECT(AClientConnection)
 public:
diff --git a/Libraries/LibGUI/GWindowServerConnection.h b/Libraries/LibGUI/GWindowServerConnection.h
index 0cda7e17c7..a20b902dbb 100644
--- a/Libraries/LibGUI/GWindowServerConnection.h
+++ b/Libraries/LibGUI/GWindowServerConnection.h
@@ -5,12 +5,12 @@
 #include <WindowServer/WindowServerEndpoint.h>
 
 class GWindowServerConnection
-    : public IPC::Client::ConnectionNG<WindowClientEndpoint, WindowServerEndpoint>
+    : public IServerConnection<WindowClientEndpoint, WindowServerEndpoint>
     , public WindowClientEndpoint {
     C_OBJECT(GWindowServerConnection)
 public:
     GWindowServerConnection()
-        : ConnectionNG(*this, "/tmp/portal/window")
+        : IServerConnection(*this, "/tmp/portal/window")
     {
         handshake();
     }
diff --git a/Libraries/LibIPC/IClientConnection.h b/Libraries/LibIPC/IClientConnection.h
index 366518ae11..b45de739a8 100644
--- a/Libraries/LibIPC/IClientConnection.h
+++ b/Libraries/LibIPC/IClientConnection.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include <AK/Queue.h>
 #include <LibCore/CEvent.h>
 #include <LibCore/CEventLoop.h>
 #include <LibCore/CIODevice.h>
@@ -10,163 +9,153 @@
 #include <LibIPC/IEndpoint.h>
 #include <LibIPC/IMessage.h>
 #include <errno.h>
-#include <sched.h>
 #include <stdio.h>
 #include <sys/socket.h>
 #include <sys/types.h>
-#include <sys/uio.h>
 #include <unistd.h>
 
-//#define CIPC_DEBUG
-
-namespace IPC {
-namespace Server {
-
-    class Event : public CEvent {
-    public:
-        enum Type {
-            Invalid = 2000,
-            Disconnected,
-        };
-        Event() {}
-        explicit Event(Type type)
-            : CEvent(type)
-        {
-        }
-    };
-
-    class DisconnectedEvent : public Event {
-    public:
-        explicit DisconnectedEvent(int client_id)
-            : Event(Disconnected)
-            , m_client_id(client_id)
-        {
-        }
-
-        int client_id() const { return m_client_id; }
-
-    private:
-        int m_client_id { 0 };
+class IEvent : public CEvent {
+public:
+    enum Type {
+        Invalid = 2000,
+        Disconnected,
     };
-
-    template<typename T, class... Args>
-    NonnullRefPtr<T> new_connection_ng_for_client(Args&&... args)
+    IEvent() {}
+    explicit IEvent(Type type)
+        : CEvent(type)
     {
-        return T::construct(forward<Args>(args)...) /* arghs */;
     }
+};
 
-    template<typename Endpoint>
-    class ConnectionNG : public CObject {
-    public:
-        ConnectionNG(Endpoint& endpoint, CLocalSocket& socket, int client_id)
-            : m_endpoint(endpoint)
-            , m_socket(socket)
-            , m_client_id(client_id)
-        {
-            add_child(socket);
-            m_socket->on_ready_to_read = [this] { drain_messages_from_client(); };
-        }
+class IDisconnectedEvent : public IEvent {
+public:
+    explicit IDisconnectedEvent(int client_id)
+        : IEvent(Disconnected)
+        , m_client_id(client_id)
+    {
+    }
 
-        virtual ~ConnectionNG() override
-        {
-        }
+    int client_id() const { return m_client_id; }
+
+private:
+    int m_client_id { 0 };
+};
+
+template<typename T, class... Args>
+NonnullRefPtr<T> new_client_connection(Args&&... args)
+{
+    return T::construct(forward<Args>(args)...) /* arghs */;
+}
+
+template<typename Endpoint>
+class IClientConnection : public CObject {
+public:
+    IClientConnection(Endpoint& endpoint, CLocalSocket& socket, int client_id)
+        : m_endpoint(endpoint)
+        , m_socket(socket)
+        , m_client_id(client_id)
+    {
+        add_child(socket);
+        m_socket->on_ready_to_read = [this] { drain_messages_from_client(); };
+    }
 
-        void post_message(const IMessage& message)
-        {
-            auto buffer = message.encode();
+    virtual ~IClientConnection() override
+    {
+    }
 
-            int nwritten = write(m_socket->fd(), buffer.data(), (size_t)buffer.size());
-            if (nwritten < 0) {
-                switch (errno) {
-                case EPIPE:
-                    dbg() << "Connection::post_message: Disconnected from peer";
-                    shutdown();
-                    return;
-                case EAGAIN:
-                    dbg() << "Connection::post_message: Client buffer overflowed.";
-                    did_misbehave();
-                    return;
-                default:
-                    perror("Connection::post_message write");
-                    ASSERT_NOT_REACHED();
-                }
+    void post_message(const IMessage& message)
+    {
+        auto buffer = message.encode();
+
+        int nwritten = write(m_socket->fd(), buffer.data(), (size_t)buffer.size());
+        if (nwritten < 0) {
+            switch (errno) {
+            case EPIPE:
+                dbg() << "Connection::post_message: Disconnected from peer";
+                shutdown();
+                return;
+            case EAGAIN:
+                dbg() << "Connection::post_message: Client buffer overflowed.";
+                did_misbehave();
+                return;
+            default:
+                perror("Connection::post_message write");
+                ASSERT_NOT_REACHED();
             }
-
-            ASSERT(nwritten == buffer.size());
         }
 
-        void drain_messages_from_client()
-        {
-            Vector<u8> bytes;
-            for (;;) {
-                u8 buffer[4096];
-                ssize_t nread = recv(m_socket->fd(), buffer, sizeof(buffer), MSG_DONTWAIT);
-                if (nread == 0 || (nread == -1 && errno == EAGAIN)) {
-                    if (bytes.is_empty()) {
-                        CEventLoop::current().post_event(*this, make<DisconnectedEvent>(client_id()));
-                        return;
-                    }
-                    break;
-                }
-                if (nread < 0) {
-                    perror("recv");
-                    ASSERT_NOT_REACHED();
-                }
-                bytes.append(buffer, nread);
-            }
+        ASSERT(nwritten == buffer.size());
+    }
 
-            size_t decoded_bytes = 0;
-            for (size_t index = 0; index < (size_t)bytes.size(); index += decoded_bytes) {
-                auto remaining_bytes = ByteBuffer::wrap(bytes.data() + index, bytes.size() - index);
-                auto message = Endpoint::decode_message(remaining_bytes, decoded_bytes);
-                if (!message) {
-                    dbg() << "drain_messages_from_client: Endpoint didn't recognize message";
-                    did_misbehave();
+    void drain_messages_from_client()
+    {
+        Vector<u8> bytes;
+        for (;;) {
+            u8 buffer[4096];
+            ssize_t nread = recv(m_socket->fd(), buffer, sizeof(buffer), MSG_DONTWAIT);
+            if (nread == 0 || (nread == -1 && errno == EAGAIN)) {
+                if (bytes.is_empty()) {
+                    CEventLoop::current().post_event(*this, make<IDisconnectedEvent>(client_id()));
                     return;
                 }
-                if (auto response = m_endpoint.handle(*message))
-                    post_message(*response);
-                ASSERT(decoded_bytes);
+                break;
+            }
+            if (nread < 0) {
+                perror("recv");
+                ASSERT_NOT_REACHED();
             }
+            bytes.append(buffer, nread);
         }
 
-        void did_misbehave()
-        {
-            dbg() << "Connection{" << this << "} (id=" << m_client_id << ", pid=" << m_client_pid << ") misbehaved, disconnecting.";
-            shutdown();
+        size_t decoded_bytes = 0;
+        for (size_t index = 0; index < (size_t)bytes.size(); index += decoded_bytes) {
+            auto remaining_bytes = ByteBuffer::wrap(bytes.data() + index, bytes.size() - index);
+            auto message = Endpoint::decode_message(remaining_bytes, decoded_bytes);
+            if (!message) {
+                dbg() << "drain_messages_from_client: Endpoint didn't recognize message";
+                did_misbehave();
+                return;
+            }
+            if (auto response = m_endpoint.handle(*message))
+                post_message(*response);
+            ASSERT(decoded_bytes);
         }
+    }
 
-        void shutdown()
-        {
-            m_socket->close();
-            die();
-        }
+    void did_misbehave()
+    {
+        dbg() << "Connection{" << this << "} (id=" << m_client_id << ", pid=" << m_client_pid << ") misbehaved, disconnecting.";
+        shutdown();
+    }
 
-        int client_id() const { return m_client_id; }
-        pid_t client_pid() const { return m_client_pid; }
-        void set_client_pid(pid_t pid) { m_client_pid = pid; }
+    void shutdown()
+    {
+        m_socket->close();
+        die();
+    }
 
-        virtual void die() = 0;
+    int client_id() const { return m_client_id; }
+    pid_t client_pid() const { return m_client_pid; }
+    void set_client_pid(pid_t pid) { m_client_pid = pid; }
 
-    protected:
-        void event(CEvent& event) override
-        {
-            if (event.type() == Event::Disconnected) {
-                int client_id = static_cast<const DisconnectedEvent&>(event).client_id();
-                dbgprintf("Connection: Client disconnected: %d\n", client_id);
-                die();
-                return;
-            }
+    virtual void die() = 0;
 
-            CObject::event(event);
+protected:
+    void event(CEvent& event) override
+    {
+        if (event.type() == IEvent::Disconnected) {
+            int client_id = static_cast<const IDisconnectedEvent&>(event).client_id();
+            dbgprintf("Connection: Client disconnected: %d\n", client_id);
+            die();
+            return;
         }
 
-    private:
-        Endpoint& m_endpoint;
-        RefPtr<CLocalSocket> m_socket;
-        int m_client_id { -1 };
-        int m_client_pid { -1 };
-    };
+        CObject::event(event);
+    }
 
-} // Server
-} // IPC
+private:
+    Endpoint& m_endpoint;
+    RefPtr<CLocalSocket> m_socket;
+    int m_client_id { -1 };
+    int m_client_pid { -1 };
+};
diff --git a/Libraries/LibIPC/IServerConnection.h b/Libraries/LibIPC/IServerConnection.h
index f8d4d15d01..e95f7d7206 100644
--- a/Libraries/LibIPC/IServerConnection.h
+++ b/Libraries/LibIPC/IServerConnection.h
@@ -6,59 +6,71 @@
 #include <LibCore/CNotifier.h>
 #include <LibCore/CSyscallUtils.h>
 #include <LibIPC/IMessage.h>
-#include <sched.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/select.h>
 #include <sys/socket.h>
 #include <sys/types.h>
-#include <sys/uio.h>
 #include <unistd.h>
 
-//#define CIPC_DEBUG
+template<typename LocalEndpoint, typename PeerEndpoint>
+class IServerConnection : public CObject {
+public:
+    IServerConnection(LocalEndpoint& local_endpoint, const StringView& address)
+        : m_local_endpoint(local_endpoint)
+        , m_connection(CLocalSocket::construct(this))
+        , m_notifier(CNotifier::construct(m_connection->fd(), CNotifier::Read, this))
+    {
+        // We want to rate-limit our clients
+        m_connection->set_blocking(true);
+        m_notifier->on_ready_to_read = [this] {
+            drain_messages_from_server();
+        };
 
-namespace IPC {
-namespace Client {
-
-    template<typename LocalEndpoint, typename PeerEndpoint>
-    class ConnectionNG : public CObject {
-    public:
-        ConnectionNG(LocalEndpoint& local_endpoint, const StringView& address)
-            : m_local_endpoint(local_endpoint)
-            , m_connection(CLocalSocket::construct(this))
-            , m_notifier(CNotifier::construct(m_connection->fd(), CNotifier::Read, this))
-        {
-            // We want to rate-limit our clients
-            m_connection->set_blocking(true);
-            m_notifier->on_ready_to_read = [this] {
-                drain_messages_from_server();
-            };
-
-            int retries = 100000;
-            while (retries) {
-                if (m_connection->connect(CSocketAddress::local(address))) {
-                    break;
-                }
-
-                dbgprintf("Client::Connection: connect failed: %d, %s\n", errno, strerror(errno));
-                usleep(10000);
-                --retries;
+        int retries = 100000;
+        while (retries) {
+            if (m_connection->connect(CSocketAddress::local(address))) {
+                break;
             }
-            ASSERT(m_connection->is_connected());
+
+            dbgprintf("Client::Connection: connect failed: %d, %s\n", errno, strerror(errno));
+            usleep(10000);
+            --retries;
         }
+        ASSERT(m_connection->is_connected());
+    }
 
-        virtual void handshake() = 0;
+    virtual void handshake() = 0;
 
-        void set_server_pid(pid_t pid) { m_server_pid = pid; }
-        pid_t server_pid() const { return m_server_pid; }
-        void set_my_client_id(int id) { m_my_client_id = id; }
-        int my_client_id() const { return m_my_client_id; }
+    void set_server_pid(pid_t pid) { m_server_pid = pid; }
+    pid_t server_pid() const { return m_server_pid; }
+    void set_my_client_id(int id) { m_my_client_id = id; }
+    int my_client_id() const { return m_my_client_id; }
 
-        template<typename MessageType>
-        OwnPtr<MessageType> wait_for_specific_message()
-        {
-            // Double check we don't already have the event waiting for us.
-            // Otherwise we might end up blocked for a while for no reason.
+    template<typename MessageType>
+    OwnPtr<MessageType> wait_for_specific_message()
+    {
+        // Double check we don't already have the event waiting for us.
+        // Otherwise we might end up blocked for a while for no reason.
+        for (ssize_t i = 0; i < m_unprocessed_messages.size(); ++i) {
+            if (m_unprocessed_messages[i]->id() == MessageType::static_message_id()) {
+                auto message = move(m_unprocessed_messages[i]);
+                m_unprocessed_messages.remove(i);
+                return message;
+            }
+        }
+        for (;;) {
+            fd_set rfds;
+            FD_ZERO(&rfds);
+            FD_SET(m_connection->fd(), &rfds);
+            int rc = CSyscallUtils::safe_syscall(select, m_connection->fd() + 1, &rfds, nullptr, nullptr, nullptr);
+            if (rc < 0) {
+                perror("select");
+            }
+            ASSERT(rc > 0);
+            ASSERT(FD_ISSET(m_connection->fd(), &rfds));
+            if (!drain_messages_from_server())
+                return nullptr;
             for (ssize_t i = 0; i < m_unprocessed_messages.size(); ++i) {
                 if (m_unprocessed_messages[i]->id() == MessageType::static_message_id()) {
                     auto message = move(m_unprocessed_messages[i]);
@@ -66,96 +78,74 @@ namespace Client {
                     return message;
                 }
             }
-            for (;;) {
-                fd_set rfds;
-                FD_ZERO(&rfds);
-                FD_SET(m_connection->fd(), &rfds);
-                int rc = CSyscallUtils::safe_syscall(select, m_connection->fd() + 1, &rfds, nullptr, nullptr, nullptr);
-                if (rc < 0) {
-                    perror("select");
-                }
-                ASSERT(rc > 0);
-                ASSERT(FD_ISSET(m_connection->fd(), &rfds));
-                if (!drain_messages_from_server())
-                    return nullptr;
-                for (ssize_t i = 0; i < m_unprocessed_messages.size(); ++i) {
-                    if (m_unprocessed_messages[i]->id() == MessageType::static_message_id()) {
-                        auto message = move(m_unprocessed_messages[i]);
-                        m_unprocessed_messages.remove(i);
-                        return message;
-                    }
-                }
-            }
         }
+    }
 
-        bool post_message(const IMessage& message)
-        {
-            auto buffer = message.encode();
-            int nwritten = write(m_connection->fd(), buffer.data(), (size_t)buffer.size());
-            if (nwritten < 0) {
-                perror("write");
-                ASSERT_NOT_REACHED();
-                return false;
-            }
-            ASSERT(nwritten == buffer.size());
-            return true;
+    bool post_message(const IMessage& message)
+    {
+        auto buffer = message.encode();
+        int nwritten = write(m_connection->fd(), buffer.data(), (size_t)buffer.size());
+        if (nwritten < 0) {
+            perror("write");
+            ASSERT_NOT_REACHED();
+            return false;
         }
+        ASSERT(nwritten == buffer.size());
+        return true;
+    }
 
-        template<typename RequestType, typename... Args>
-        OwnPtr<typename RequestType::ResponseType> send_sync(Args&&... args)
-        {
-            bool success = post_message(RequestType(forward<Args>(args)...));
-            ASSERT(success);
-            auto response = wait_for_specific_message<typename RequestType::ResponseType>();
-            ASSERT(response);
-            return response;
-        }
+    template<typename RequestType, typename... Args>
+    OwnPtr<typename RequestType::ResponseType> send_sync(Args&&... args)
+    {
+        bool success = post_message(RequestType(forward<Args>(args)...));
+        ASSERT(success);
+        auto response = wait_for_specific_message<typename RequestType::ResponseType>();
+        ASSERT(response);
+        return response;
+    }
 
-    private:
-        bool drain_messages_from_server()
-        {
-            Vector<u8> bytes;
-            for (;;) {
-                u8 buffer[4096];
-                ssize_t nread = recv(m_connection->fd(), buffer, sizeof(buffer), MSG_DONTWAIT);
-                if (nread < 0) {
-                    if (errno == EAGAIN)
-                        break;
-                    perror("read");
-                    exit(1);
-                    return false;
-                }
-                if (nread == 0) {
-                    dbg() << "EOF on IPC fd";
-                    // FIXME: Dying is definitely not always appropriate!
-                    exit(1);
-                    return false;
-                }
-                bytes.append(buffer, nread);
+private:
+    bool drain_messages_from_server()
+    {
+        Vector<u8> bytes;
+        for (;;) {
+            u8 buffer[4096];
+            ssize_t nread = recv(m_connection->fd(), buffer, sizeof(buffer), MSG_DONTWAIT);
+            if (nread < 0) {
+                if (errno == EAGAIN)
+                    break;
+                perror("read");
+                exit(1);
+                return false;
             }
-
-            size_t decoded_bytes = 0;
-            for (size_t index = 0; index < (size_t)bytes.size(); index += decoded_bytes) {
-                auto remaining_bytes = ByteBuffer::wrap(bytes.data() + index, bytes.size() - index);
-                if (auto message = LocalEndpoint::decode_message(remaining_bytes, decoded_bytes)) {
-                    m_local_endpoint.handle(*message);
-                } else if (auto message = PeerEndpoint::decode_message(remaining_bytes, decoded_bytes)) {
-                    m_unprocessed_messages.append(move(message));
-                } else {
-                    ASSERT_NOT_REACHED();
-                }
-                ASSERT(decoded_bytes);
+            if (nread == 0) {
+                dbg() << "EOF on IPC fd";
+                // FIXME: Dying is definitely not always appropriate!
+                exit(1);
+                return false;
             }
-            return true;
+            bytes.append(buffer, nread);
         }
 
-        LocalEndpoint& m_local_endpoint;
-        RefPtr<CLocalSocket> m_connection;
-        RefPtr<CNotifier> m_notifier;
-        Vector<OwnPtr<IMessage>> m_unprocessed_messages;
-        int m_server_pid { -1 };
-        int m_my_client_id { -1 };
-    };
+        size_t decoded_bytes = 0;
+        for (size_t index = 0; index < (size_t)bytes.size(); index += decoded_bytes) {
+            auto remaining_bytes = ByteBuffer::wrap(bytes.data() + index, bytes.size() - index);
+            if (auto message = LocalEndpoint::decode_message(remaining_bytes, decoded_bytes)) {
+                m_local_endpoint.handle(*message);
+            } else if (auto message = PeerEndpoint::decode_message(remaining_bytes, decoded_bytes)) {
+                m_unprocessed_messages.append(move(message));
+            } else {
+                ASSERT_NOT_REACHED();
+            }
+            ASSERT(decoded_bytes);
+        }
+        return true;
+    }
 
-} // Client
-} // IPC
+    LocalEndpoint& m_local_endpoint;
+    RefPtr<CLocalSocket> m_connection;
+    RefPtr<CNotifier> m_notifier;
+    Vector<OwnPtr<IMessage>> m_unprocessed_messages;
+    int m_server_pid { -1 };
+    int m_my_client_id { -1 };
+};
diff --git a/Libraries/LibProtocol/Client.cpp b/Libraries/LibProtocol/Client.cpp
index cb53ec916e..dd7b1de771 100644
--- a/Libraries/LibProtocol/Client.cpp
+++ b/Libraries/LibProtocol/Client.cpp
@@ -5,7 +5,7 @@
 namespace LibProtocol {
 
 Client::Client()
-    : ConnectionNG(*this, "/tmp/portal/protocol")
+    : IServerConnection(*this, "/tmp/portal/protocol")
 {
     handshake();
 }
diff --git a/Libraries/LibProtocol/Client.h b/Libraries/LibProtocol/Client.h
index fc90dc9320..30a4ecb258 100644
--- a/Libraries/LibProtocol/Client.h
+++ b/Libraries/LibProtocol/Client.h
@@ -8,7 +8,7 @@ namespace LibProtocol {
 
 class Download;
 
-class Client : public IPC::Client::ConnectionNG<ProtocolClientEndpoint, ProtocolServerEndpoint>
+class Client : public IServerConnection<ProtocolClientEndpoint, ProtocolServerEndpoint>
     , public ProtocolClientEndpoint {
     C_OBJECT(Client)
 public:
diff --git a/Servers/AudioServer/ASClientConnection.cpp b/Servers/AudioServer/ASClientConnection.cpp
index b328b228de..5dd25f94fa 100644
--- a/Servers/AudioServer/ASClientConnection.cpp
+++ b/Servers/AudioServer/ASClientConnection.cpp
@@ -23,7 +23,7 @@ void ASClientConnection::for_each(Function<void(ASClientConnection&)> callback)
 }
 
 ASClientConnection::ASClientConnection(CLocalSocket& client_socket, int client_id, ASMixer& mixer)
-    : ConnectionNG(*this, client_socket, client_id)
+    : IClientConnection(*this, client_socket, client_id)
     , m_mixer(mixer)
 {
     s_connections.set(client_id, *this);
diff --git a/Servers/AudioServer/ASClientConnection.h b/Servers/AudioServer/ASClientConnection.h
index 0d9235a7fc..0d62354b0b 100644
--- a/Servers/AudioServer/ASClientConnection.h
+++ b/Servers/AudioServer/ASClientConnection.h
@@ -7,7 +7,7 @@ class ABuffer;
 class ASBufferQueue;
 class ASMixer;
 
-class ASClientConnection final : public IPC::Server::ConnectionNG<AudioServerEndpoint>
+class ASClientConnection final : public IClientConnection<AudioServerEndpoint>
     , public AudioServerEndpoint {
     C_OBJECT(ASClientConnection)
 public:
diff --git a/Servers/AudioServer/ASEventLoop.cpp b/Servers/AudioServer/ASEventLoop.cpp
index 3792bba505..53d52647c3 100644
--- a/Servers/AudioServer/ASEventLoop.cpp
+++ b/Servers/AudioServer/ASEventLoop.cpp
@@ -17,6 +17,6 @@ ASEventLoop::ASEventLoop()
         }
         static int s_next_client_id = 0;
         int client_id = ++s_next_client_id;
-        IPC::Server::new_connection_ng_for_client<ASClientConnection>(*client_socket, client_id, m_mixer);
+        new_client_connection<ASClientConnection>(*client_socket, client_id, m_mixer);
     };
 }
diff --git a/Servers/ProtocolServer/PSClientConnection.cpp b/Servers/ProtocolServer/PSClientConnection.cpp
index be0e67129d..fe7658720f 100644
--- a/Servers/ProtocolServer/PSClientConnection.cpp
+++ b/Servers/ProtocolServer/PSClientConnection.cpp
@@ -7,7 +7,7 @@
 static HashMap<int, RefPtr<PSClientConnection>> s_connections;
 
 PSClientConnection::PSClientConnection(CLocalSocket& socket, int client_id)
-    : ConnectionNG(*this, socket, client_id)
+    : IClientConnection(*this, socket, client_id)
 {
     s_connections.set(client_id, *this);
 }
diff --git a/Servers/ProtocolServer/PSClientConnection.h b/Servers/ProtocolServer/PSClientConnection.h
index cce3ccb2c4..5797b7d460 100644
--- a/Servers/ProtocolServer/PSClientConnection.h
+++ b/Servers/ProtocolServer/PSClientConnection.h
@@ -7,7 +7,7 @@
 class Download;
 class SharedBuffer;
 
-class PSClientConnection final : public IPC::Server::ConnectionNG<ProtocolServerEndpoint>
+class PSClientConnection final : public IClientConnection<ProtocolServerEndpoint>
     , public ProtocolServerEndpoint {
     C_OBJECT(PSClientConnection)
 public:
diff --git a/Servers/ProtocolServer/main.cpp b/Servers/ProtocolServer/main.cpp
index 33df6a085a..6c37475f82 100644
--- a/Servers/ProtocolServer/main.cpp
+++ b/Servers/ProtocolServer/main.cpp
@@ -19,7 +19,7 @@ int main(int, char**)
         }
         static int s_next_client_id = 0;
         int client_id = ++s_next_client_id;
-        IPC::Server::new_connection_ng_for_client<PSClientConnection>(*client_socket, client_id);
+        new_client_connection<PSClientConnection>(*client_socket, client_id);
     };
     return event_loop.exec();
 }
diff --git a/Servers/WindowServer/WSClientConnection.cpp b/Servers/WindowServer/WSClientConnection.cpp
index 0adb383ca0..c798dcc6ab 100644
--- a/Servers/WindowServer/WSClientConnection.cpp
+++ b/Servers/WindowServer/WSClientConnection.cpp
@@ -42,7 +42,7 @@ WSClientConnection* WSClientConnection::from_client_id(int client_id)
 }
 
 WSClientConnection::WSClientConnection(CLocalSocket& client_socket, int client_id)
-    : ConnectionNG(*this, client_socket, client_id)
+    : IClientConnection(*this, client_socket, client_id)
 {
     if (!s_connections)
         s_connections = new HashMap<int, NonnullRefPtr<WSClientConnection>>;
diff --git a/Servers/WindowServer/WSClientConnection.h b/Servers/WindowServer/WSClientConnection.h
index 8d757969d4..8c6444291f 100644
--- a/Servers/WindowServer/WSClientConnection.h
+++ b/Servers/WindowServer/WSClientConnection.h
@@ -15,7 +15,7 @@ class WSMenu;
 class WSMenuBar;
 
 class WSClientConnection final
-    : public IPC::Server::ConnectionNG<WindowServerEndpoint>
+    : public IClientConnection<WindowServerEndpoint>
     , public WindowServerEndpoint {
     C_OBJECT(WSClientConnection)
 public:
diff --git a/Servers/WindowServer/WSEventLoop.cpp b/Servers/WindowServer/WSEventLoop.cpp
index 7909229a3a..aef7d668e8 100644
--- a/Servers/WindowServer/WSEventLoop.cpp
+++ b/Servers/WindowServer/WSEventLoop.cpp
@@ -37,7 +37,7 @@ WSEventLoop::WSEventLoop()
         }
         static int s_next_client_id = 0;
         int client_id = ++s_next_client_id;
-        IPC::Server::new_connection_ng_for_client<WSClientConnection>(*client_socket, client_id);
+        new_client_connection<WSClientConnection>(*client_socket, client_id);
     };
 
     ASSERT(m_keyboard_fd >= 0);