WindowServer: Begin refactoring towards a fully asynchronous protocol.

In order to move the WindowServer to userspace, I have to eliminate its
dependence on system call facilities. The communication channel with each
client needs to be message-based in both directions.

WindowServer/WSMessage.h

@@ -23,6 +23,11 @@ public:
         WindowActivated,
         WindowDeactivated,
         WindowCloseRequest,
+
+        __Begin_API_Client_Requests,
+        APICreateMenubarRequest,
+        APIDestroyMenubarRequest,
+        __End_API_Client_Requests,
     };
 
     WSMessage() { }
@@ -31,6 +36,7 @@ public:
 
     Type type() const { return m_type; }
 
+    bool is_client_request() const { return m_type > __Begin_API_Client_Requests && m_type < __End_API_Client_Requests; }
     bool is_mouse_event() const { return m_type == MouseMove || m_type == MouseDown || m_type == MouseUp; }
     bool is_key_event() const { return m_type == KeyUp || m_type == KeyDown; }
 
@@ -38,6 +44,42 @@ private:
     Type m_type { Invalid };
 };
 
+class WSAPIClientRequest : public WSMessage {
+public:
+    WSAPIClientRequest(Type type, int client_id)
+        : WSMessage(type)
+        , m_client_id(client_id)
+    {
+    }
+
+    int client_id() const { return m_client_id; }
+
+private:
+    int m_client_id { 0 };
+};
+
+class WSAPICreateMenubarRequest : public WSAPIClientRequest {
+public:
+    WSAPICreateMenubarRequest(int client_id)
+        : WSAPIClientRequest(WSMessage::APICreateMenubarRequest, client_id)
+    {
+    }
+};
+
+class WSAPIDestroyMenubarRequest : public WSAPIClientRequest {
+public:
+    WSAPIDestroyMenubarRequest(int client_id, int menubar_id)
+        : WSAPIClientRequest(WSMessage::APIDestroyMenubarRequest, client_id)
+        , m_menubar_id(menubar_id)
+    {
+    }
+
+    int menubar_id() const { return m_menubar_id; }
+
+private:
+    int m_menubar_id { 0 };
+};
+
 class WSClientFinishedPaintMessage final : public WSMessage {
 public:
     explicit WSClientFinishedPaintMessage(const Rect& rect = Rect())

WindowServer/WSMessageLoop.cpp

@@ -67,6 +67,21 @@ int WSMessageLoop::exec()
     }
 }
 
+Process* WSMessageLoop::process_from_client_id(int client_id)
+{
+    // FIXME: This shouldn't work this way lol.
+    return (Process*)client_id;
+}
+
+void WSMessageLoop::post_message_to_client(int client_id, const GUI_Event& message)
+{
+    auto* process = process_from_client_id(client_id);
+    if (!process)
+        return;
+    LOCKER(process->gui_events_lock());
+    process->gui_events().append(move(message));
+}
+
 void WSMessageLoop::post_message(WSMessageReceiver* receiver, OwnPtr<WSMessage>&& message)
 {
     LOCKER(m_lock);
@@ -246,3 +261,19 @@ void WSMessageLoop::drain_keyboard()
         screen.on_receive_keyboard_data(event);
     }
 }
+
+ssize_t WSMessageLoop::on_receive_from_client(int client_id, const byte* data, size_t size)
+{
+    LOCKER(m_lock);
+    ASSERT(size == sizeof(GUI_ClientMessage));
+    auto& message = *reinterpret_cast<const GUI_ClientMessage*>(data);
+    switch (message.type) {
+    case GUI_ClientMessage::Type::CreateMenubar:
+        post_message(&WSWindowManager::the(), make<WSAPICreateMenubarRequest>(client_id));
+        break;
+    case GUI_ClientMessage::Type::DestroyMenubar:
+        post_message(&WSWindowManager::the(), make<WSAPIDestroyMenubarRequest>(client_id, message.menu.menubar_id));
+        break;
+    }
+    return size;
+}

WindowServer/WSMessageLoop.h

@@ -9,6 +9,7 @@
 
 class WSMessageReceiver;
 class Process;
+struct GUI_Event;
 
 class WSMessageLoop {
 public:
@@ -29,6 +30,11 @@ public:
     int start_timer(int ms, Function<void()>&&);
     int stop_timer(int timer_id);
 
+    void post_message_to_client(int client_id, const GUI_Event&);
+    ssize_t on_receive_from_client(int client_id, const byte*, size_t);
+
+    static Process* process_from_client_id(int client_id);
+
 private:
     void wait_for_message();
     void drain_mouse();

WindowServer/WSWindowManager.cpp

@@ -733,12 +733,46 @@ void WSWindowManager::on_message(WSMessage& message)
         compose();
         return;
     }
+
+    if (message.is_client_request()) {
+        auto& request = static_cast<WSAPIClientRequest&>(message);
+        switch (request.type()) {
+        case WSMessage::APICreateMenubarRequest: {
+            int menubar_id = m_next_menubar_id++;
+            auto menubar = make<WSMenuBar>(menubar_id, *WSMessageLoop::process_from_client_id(request.client_id()));
+            m_menubars.set(menubar_id, move(menubar));
+            GUI_Event event;
+            event.type = GUI_Event::Type::DidCreateMenubar;
+            event.menu.menubar_id = menubar_id;
+            WSMessageLoop::the().post_message_to_client(request.client_id(), event);
+            break;
+        }
+        case WSMessage::APIDestroyMenubarRequest: {
+            int menubar_id = static_cast<WSAPIDestroyMenubarRequest&>(request).menubar_id();
+            auto it = m_menubars.find(menubar_id);
+            if (it == m_menubars.end()) {
+                ASSERT_NOT_REACHED();
+                // FIXME: Send an error.
+                return;
+            }
+            auto& menubar = *(*it).value;
+            if (&menubar == m_current_menubar)
+                set_current_menubar(nullptr);
+            m_menubars.remove(it);
+            GUI_Event event;
+            event.type = GUI_Event::Type::DidDestroyMenubar;
+            event.menu.menubar_id = menubar_id;
+            WSMessageLoop::the().post_message_to_client(request.client_id(), event);
+        }
+        default:
+            break;
+        }
+    }
 }
 
 void WSWindowManager::set_active_window(WSWindow* window)
 {
     LOCKER(m_lock);
-    dbgprintf("set_active_window %p\n", window);
     if (window == m_active_window.ptr())
         return;
 
@@ -751,6 +785,7 @@ void WSWindowManager::set_active_window(WSWindow* window)
         WSMessageLoop::the().post_message(m_active_window.ptr(), make<WSMessage>(WSMessage::WindowActivated));
         invalidate(*m_active_window);
 
+        ASSERT(window->process());
         auto it = m_app_menubars.find(window->process());
         if (it != m_app_menubars.end()) {
             auto* menubar = (*it).value;
@@ -855,29 +890,6 @@ WSMenu& WSWindowManager::create_menu(String&& name)
     return *menu_ptr;
 }
 
-
-int WSWindowManager::api$menubar_create()
-{
-    LOCKER(m_lock);
-    int menubar_id = m_next_menubar_id++;
-    auto menubar = make<WSMenuBar>(menubar_id, *current);
-    m_menubars.set(menubar_id, move(menubar));
-    return menubar_id;
-}
-
-int WSWindowManager::api$menubar_destroy(int menubar_id)
-{
-    LOCKER(m_lock);
-    auto it = m_menubars.find(menubar_id);
-    if (it == m_menubars.end())
-        return -EBADMENUBAR;
-    auto& menubar = *(*it).value;
-    if (&menubar == m_current_menubar)
-        set_current_menubar(nullptr);
-    m_menubars.remove(it);
-    return 0;
-}
-
 int WSWindowManager::api$menubar_add_menu(int menubar_id, int menu_id)
 {
     LOCKER(m_lock);
@@ -984,5 +996,5 @@ void WSWindowManager::destroy_all_menus(Process& process)
         set_current_menubar(nullptr);
     for (int menubar_id : menubar_ids)
         m_menubars.remove(menubar_id);
-    m_app_menubars.remove(current);
+    m_app_menubars.remove(&process);
 }

WindowServer/WSWindowManager.h

@@ -59,8 +59,6 @@ public:
     Color menu_selection_color() const { return m_menu_selection_color; }
     int menubar_menu_margin() const;
 
-    int api$menubar_create();
-    int api$menubar_destroy(int menubar_id);
     int api$menubar_add_menu(int menubar_id, int menu_id);
     int api$menu_create(String&&);
     int api$menu_destroy(int menu_id);