hle: kernel: Refactor IPC interfaces to not use std::shared_ptr.

src/core/hle/kernel/client_port.cpp

@@ -28,7 +28,7 @@ ResultVal<std::shared_ptr<ClientSession>> ClientPort::Connect() {
     auto [client, server] = Kernel::Session::Create(kernel, name);
 
     if (server_port->HasHLEHandler()) {
-        server_port->GetHLEHandler()->ClientConnected(std::move(server));
+        server_port->GetHLEHandler()->ClientConnected(client, std::move(server));
     } else {
         server_port->AppendPendingSession(std::move(server));
     }

src/core/hle/kernel/hle_ipc.cpp

@@ -35,15 +35,17 @@ SessionRequestHandler::SessionRequestHandler() = default;
 
 SessionRequestHandler::~SessionRequestHandler() = default;
 
-void SessionRequestHandler::ClientConnected(std::shared_ptr<ServerSession> server_session) {
+void SessionRequestHandler::ClientConnected(std::shared_ptr<ClientSession> client_session,
+                                            std::shared_ptr<ServerSession> server_session) {
     server_session->SetHleHandler(shared_from_this());
-    connected_sessions.push_back(std::move(server_session));
+    client_sessions.push_back(std::move(client_session));
+    server_sessions.push_back(std::move(server_session));
 }
 
 void SessionRequestHandler::ClientDisconnected(
     const std::shared_ptr<ServerSession>& server_session) {
     server_session->SetHleHandler(nullptr);
-    boost::range::remove_erase(connected_sessions, server_session);
+    boost::range::remove_erase(server_sessions, server_session);
 }
 
 HLERequestContext::HLERequestContext(KernelCore& kernel_, Core::Memory::Memory& memory_,
@@ -223,12 +225,12 @@ ResultCode HLERequestContext::WriteToOutgoingCommandBuffer(KThread& thread) {
         // for specific values in each of these descriptors.
         for (auto& object : copy_objects) {
             ASSERT(object != nullptr);
-            dst_cmdbuf[current_offset++] = handle_table.Create(object).Unwrap();
+            dst_cmdbuf[current_offset++] = handle_table.Create(SharedFrom(object)).Unwrap();
         }
 
         for (auto& object : move_objects) {
             ASSERT(object != nullptr);
-            dst_cmdbuf[current_offset++] = handle_table.Create(object).Unwrap();
+            dst_cmdbuf[current_offset++] = handle_table.Create(SharedFrom(object)).Unwrap();
         }
     }
 

src/core/hle/kernel/hle_ipc.h

@@ -39,6 +39,7 @@ class HandleTable;
 class HLERequestContext;
 class KernelCore;
 class Process;
+class ClientSession;
 class ServerSession;
 class KThread;
 class KReadableEvent;
@@ -71,7 +72,8 @@ public:
      * associated ServerSession alive for the duration of the connection.
      * @param server_session Owning pointer to the ServerSession associated with the connection.
      */
-    void ClientConnected(std::shared_ptr<ServerSession> server_session);
+    void ClientConnected(
+        std::shared_ptr<ClientSession> client_session, std::shared_ptr<ServerSession> server_session);
 
     /**
      * Signals that a client has just disconnected from this HLE handler and releases the
@@ -84,7 +86,8 @@ protected:
     /// List of sessions that are connected to this handler.
     /// A ServerSession whose server endpoint is an HLE implementation is kept alive by this list
     /// for the duration of the connection.
-    std::vector<std::shared_ptr<ServerSession>> connected_sessions;
+    std::vector<std::shared_ptr<ClientSession>> client_sessions;
+    std::vector<std::shared_ptr<ServerSession>> server_sessions;
 };
 
 /**
@@ -218,21 +221,21 @@ public:
     }
 
     template <typename T>
-    std::shared_ptr<T> GetCopyObject(std::size_t index) {
+    T* GetCopyObject(std::size_t index) {
         return DynamicObjectCast<T>(copy_objects.at(index));
     }
 
     template <typename T>
-    std::shared_ptr<T> GetMoveObject(std::size_t index) {
+    T* GetMoveObject(std::size_t index) {
         return DynamicObjectCast<T>(move_objects.at(index));
     }
 
-    void AddMoveObject(std::shared_ptr<Object> object) {
-        move_objects.emplace_back(std::move(object));
+    void AddMoveObject(Object* object) {
+        move_objects.emplace_back(object);
     }
 
-    void AddCopyObject(std::shared_ptr<Object> object) {
-        copy_objects.emplace_back(std::move(object));
+    void AddCopyObject(Object* object) {
+        copy_objects.emplace_back(object);
     }
 
     void AddDomainObject(std::shared_ptr<SessionRequestHandler> object) {

src/core/hle/kernel/k_event.h

@@ -32,8 +32,8 @@ public:
         return HANDLE_TYPE;
     }
 
-    std::shared_ptr<KReadableEvent>& GetReadableEvent() {
-        return readable_event;
+    KReadableEvent* GetReadableEvent() {
+        return readable_event.get();
     }
 
     std::shared_ptr<KWritableEvent>& GetWritableEvent() {

src/core/hle/kernel/svc.cpp

@@ -1976,7 +1976,7 @@ static ResultCode CreateEvent(Core::System& system, Handle* out_write, Handle* o
     auto handle_guard = SCOPE_GUARD({ handle_table.Remove(*write_create_result); });
 
     // Add the readable event to the handle table.
-    const auto read_create_result = handle_table.Create(event->GetReadableEvent());
+    const auto read_create_result = handle_table.Create(SharedFrom(event->GetReadableEvent()));
     if (read_create_result.Failed()) {
         return read_create_result.Code();
     }