[lacros] Add support of xdg-decoration protocol (1/n)

For xdg-stable shell, this CL implements xdg-decoration protocol
handshake between exo-server and client. This implementation makes the
client and server to agree on decoration mode(CSD or SSD).

The class |WaylandXdgToplevelDecoration| added on the server-side to
maintain decoration state and communicate with the client. Current
changes in CL are not integrated with decoration attributes like
maximize and resize. Future CLs will add window decoration based on
decoration mode.

Bug: 1067535
Change-Id: I64980c1e71036e68750c909c1aad9f9b737fcd58
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2330170
Commit-Queue: Abhijeet Kandalkar <abhijeet@igalia.com>
Reviewed-by: Mitsuru Oshima (Slow: gardener) <oshima@chromium.org>
Reviewed-by: Nick Yamane <nickdiego@igalia.com>
Reviewed-by: Maksim Sisov (GMT+3) <msisov@igalia.com>
Cr-Commit-Position: refs/heads/master@{#806448}

components/exo/wayland/BUILD.gn

@@ -98,6 +98,7 @@ source_set("wayland") {
     "//third_party/wayland-protocols:text_input_protocol",
     "//third_party/wayland-protocols:viewporter_protocol",
     "//third_party/wayland-protocols:vsync_feedback_protocol",
+    "//third_party/wayland-protocols:xdg_decoration_protocol",
     "//third_party/wayland-protocols:xdg_shell_protocol",
     "//ui/aura",
     "//ui/base",
@@ -182,6 +183,7 @@ source_set("wayland") {
       "zwp_relative_pointer_manager.h",
       "zwp_text_input_manager.cc",
       "zwp_text_input_manager.h",
+      "zxdg_decoration_manager.h",
       "zxdg_shell.cc",
       "zxdg_shell.h",
     ]

components/exo/wayland/server.cc

@@ -28,6 +28,7 @@
 #include <vsync-feedback-unstable-v1-server-protocol.h>
 #include <wayland-server-core.h>
 #include <wayland-server-protocol-core.h>
+#include <xdg-decoration-unstable-v1-server-protocol.h>
 #include <xdg-shell-server-protocol.h>
 #include <xdg-shell-unstable-v6-server-protocol.h>
 
@@ -76,6 +77,7 @@
 #include "components/exo/wayland/zwp_pointer_gestures.h"
 #include "components/exo/wayland/zwp_relative_pointer_manager.h"
 #include "components/exo/wayland/zwp_text_input_manager.h"
+#include "components/exo/wayland/zxdg_decoration_manager.h"
 #include "components/exo/wayland/zxdg_shell.h"
 #endif
 
@@ -206,6 +208,8 @@ Server::Server(Display* display)
                    bind_relative_pointer_manager);
   wl_global_create(wl_display_.get(), &zcr_color_space_v1_interface, 1,
                    display_, bind_color_space);
+  wl_global_create(wl_display_.get(), &zxdg_decoration_manager_v1_interface, 1,
+                   display_, bind_zxdg_decoration_manager);
 
   zwp_text_manager_data_ =
       std::make_unique<WaylandTextInputManager>(serial_tracker_.get());

components/exo/wayland/xdg_shell.cc

@@ -6,6 +6,7 @@
 
 #include <wayland-server-core.h>
 #include <wayland-server-protocol-core.h>
+#include <xdg-decoration-unstable-v1-server-protocol.h>
 #include <xdg-shell-server-protocol.h>
 
 #include "ash/public/cpp/shell_window_ids.h"
@@ -158,6 +159,36 @@ struct WaylandXdgSurface {
   DISALLOW_COPY_AND_ASSIGN(WaylandXdgSurface);
 };
 
+class WaylandXdgToplevelDecoration {
+ public:
+  WaylandXdgToplevelDecoration(wl_resource* resource) : resource_(resource) {}
+
+  WaylandXdgToplevelDecoration(const WaylandXdgToplevelDecoration&) = delete;
+  WaylandXdgToplevelDecoration& operator=(const WaylandXdgToplevelDecoration&) =
+      delete;
+
+  uint32_t decoration_mode() const { return default_mode_; }
+  void SetDecorationMode(uint32_t mode) {
+    if (default_mode_ != mode) {
+      default_mode_ = mode;
+      OnConfigure(mode);
+    }
+  }
+
+ private:
+  void OnConfigure(uint32_t mode) {
+    switch (mode) {
+      case ZXDG_TOPLEVEL_DECORATION_V1_MODE_SERVER_SIDE:
+      case ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE:
+        zxdg_toplevel_decoration_v1_send_configure(resource_, mode);
+        break;
+    }
+  }
+
+  wl_resource* const resource_;
+  uint32_t default_mode_ = ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE;
+};
+
 // Wrapper around shell surface that allows us to handle the case where the
 // xdg surface resource is destroyed before the toplevel resource.
 class WaylandToplevel : public aura::WindowObserver {
@@ -176,6 +207,7 @@ class WaylandToplevel : public aura::WindowObserver {
             base::BindRepeating(&WaylandToplevel::OnConfigure,
                                 weak_ptr_factory_.GetWeakPtr())));
   }
+
   ~WaylandToplevel() override {
     if (shell_surface_data_)
       shell_surface_data_->shell_surface->host_window()->RemoveObserver(this);
@@ -657,8 +689,81 @@ const struct xdg_wm_base_interface xdg_wm_base_implementation = {
     xdg_wm_base_destroy, xdg_wm_base_create_positioner,
     xdg_wm_base_get_xdg_surface, xdg_wm_base_pong};
 
+////////////////////////////////////////////////////////////////////////////////
+// Top level decoration
+void toplevel_decoration_handle_destroy(wl_client* client,
+                                        wl_resource* resource) {
+  wl_resource_destroy(resource);
+}
+
+void toplevel_decoration_handle_set_mode(wl_client* client,
+                                         wl_resource* resource,
+                                         uint32_t mode) {
+  GetUserDataAs<WaylandXdgToplevelDecoration>(resource)->SetDecorationMode(
+      mode);
+}
+
+void toplevel_decoration_handle_unset_mode(wl_client* client,
+                                           wl_resource* resource) {
+  NOTIMPLEMENTED();
+}
+
+const struct zxdg_toplevel_decoration_v1_interface toplevel_decoration_impl = {
+    .destroy = toplevel_decoration_handle_destroy,
+    .set_mode = toplevel_decoration_handle_set_mode,
+    .unset_mode = toplevel_decoration_handle_unset_mode,
+};
+
+// Decoration manager
+void decoration_manager_handle_destroy(wl_client* client,
+                                       wl_resource* manager_resource) {
+  wl_resource_destroy(manager_resource);
+}
+
+void decoration_manager_handle_get_toplevel_decoration(
+    wl_client* client,
+    wl_resource* manager_resource,
+    uint32_t id,
+    wl_resource* toplevel_resource) {
+  uint32_t version = wl_resource_get_version(manager_resource);
+  wl_resource* decoration_resource = wl_resource_create(
+      client, &zxdg_toplevel_decoration_v1_interface, version, id);
+  if (!decoration_resource) {
+    wl_client_post_no_memory(client);
+    return;
+  }
+
+  auto xdg_toplevel_decoration =
+      std::make_unique<WaylandXdgToplevelDecoration>(decoration_resource);
+
+  // Enables client-side decoration
+  xdg_toplevel_decoration->SetDecorationMode(
+      ZXDG_TOPLEVEL_DECORATION_V1_MODE_CLIENT_SIDE);
+
+  SetImplementation(decoration_resource, &toplevel_decoration_impl,
+                    std::move(xdg_toplevel_decoration));
+}
+
+static const struct zxdg_decoration_manager_v1_interface
+    decoration_manager_impl = {
+        .destroy = decoration_manager_handle_destroy,
+        .get_toplevel_decoration =
+            decoration_manager_handle_get_toplevel_decoration,
+};
+
 }  // namespace
 
+void bind_zxdg_decoration_manager(wl_client* client,
+                                  void* data,
+                                  uint32_t version,
+                                  uint32_t id) {
+  wl_resource* resource = wl_resource_create(
+      client, &zxdg_decoration_manager_v1_interface, version, id);
+
+  wl_resource_set_implementation(resource, &decoration_manager_impl, data,
+                                 nullptr);
+}
+
 void bind_xdg_shell(wl_client* client,
                     void* data,
                     uint32_t version,

components/exo/wayland/zxdg_decoration_manager.h

+// Copyright 2020 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef COMPONENTS_EXO_WAYLAND_ZXDG_DECORATION_MANAGER_H_
+#define COMPONENTS_EXO_WAYLAND_ZXDG_DECORATION_MANAGER_H_
+
+#include <stdint.h>
+
+struct wl_client;
+
+namespace exo {
+namespace wayland {
+
+void bind_zxdg_decoration_manager(wl_client* client,
+                                  void* data,
+                                  uint32_t version,
+                                  uint32_t id);
+
+}  // namespace wayland
+}  // namespace exo
+
+#endif  // COMPONENTS_EXO_WAYLAND_ZXDG_DECORATION_MANAGER_H_

third_party/wayland-protocols/BUILD.gn

@@ -27,6 +27,10 @@ wayland_protocol("linux_dmabuf_protocol") {
   sources = [ "src/unstable/linux-dmabuf/linux-dmabuf-unstable-v1.xml" ]
 }
 
+wayland_protocol("xdg_decoration_protocol") {
+  sources = [ "src/unstable/xdg-decoration/xdg-decoration-unstable-v1.xml" ]
+}
+
 wayland_protocol("viewporter_protocol") {
   sources = [ "src/stable/viewporter/viewporter.xml" ]
 }

ui/ozone/platform/wayland/BUILD.gn

@@ -158,6 +158,7 @@ source_set("wayland") {
     "//third_party/wayland-protocols:presentation_time_protocol",
     "//third_party/wayland-protocols:text_input_protocol",
     "//third_party/wayland-protocols:wayland_drm_protocol",
+    "//third_party/wayland-protocols:xdg_decoration_protocol",
     "//third_party/wayland-protocols:xdg_foreign",
     "//third_party/wayland-protocols:xdg_shell_protocol",
     "//ui/base",

ui/ozone/platform/wayland/common/wayland_object.cc

@@ -12,6 +12,7 @@
 #include <presentation-time-client-protocol.h>
 #include <text-input-unstable-v1-client-protocol.h>
 #include <wayland-drm-client-protocol.h>
+#include <xdg-decoration-unstable-v1-client-protocol.h>
 #include <xdg-foreign-unstable-v1-client-protocol.h>
 #include <xdg-shell-client-protocol.h>
 #include <xdg-shell-unstable-v6-client-protocol.h>
@@ -58,6 +59,16 @@ void delete_data_device(wl_data_device* data_device) {
 
 }  // namespace
 
+const wl_interface* ObjectTraits<zxdg_decoration_manager_v1>::interface =
+    &zxdg_decoration_manager_v1_interface;
+void (*ObjectTraits<zxdg_decoration_manager_v1>::deleter)(
+    zxdg_decoration_manager_v1*) = &zxdg_decoration_manager_v1_destroy;
+
+const wl_interface* ObjectTraits<zxdg_toplevel_decoration_v1>::interface =
+    &zxdg_toplevel_decoration_v1_interface;
+void (*ObjectTraits<zxdg_toplevel_decoration_v1>::deleter)(
+    zxdg_toplevel_decoration_v1*) = &zxdg_toplevel_decoration_v1_destroy;
+
 const wl_interface*
     ObjectTraits<gtk_primary_selection_device_manager>::interface =
         &gtk_primary_selection_device_manager_interface;

ui/ozone/platform/wayland/common/wayland_object.h

@@ -57,12 +57,26 @@ struct zwp_text_input_manager_v1;
 struct zwp_text_input_v1;
 struct zxdg_exporter_v1;
 struct zxdg_exported_v1;
+struct zxdg_decoration_manager_v1;
+struct zxdg_toplevel_decoration_v1;
 
 namespace wl {
 
 template <typename T>
 struct ObjectTraits;
 
+template <>
+struct ObjectTraits<zxdg_decoration_manager_v1> {
+  static const wl_interface* interface;
+  static void (*deleter)(zxdg_decoration_manager_v1*);
+};
+
+template <>
+struct ObjectTraits<zxdg_toplevel_decoration_v1> {
+  static const wl_interface* interface;
+  static void (*deleter)(zxdg_toplevel_decoration_v1*);
+};
+
 template <>
 struct ObjectTraits<gtk_primary_selection_device_manager> {
   static const wl_interface* interface;

ui/ozone/platform/wayland/host/wayland_connection.cc

@@ -57,6 +57,7 @@ constexpr uint32_t kMaxExplicitSyncVersion = 2;
 constexpr uint32_t kMinAuraShellVersion = 10;
 constexpr uint32_t kMinWlDrmVersion = 2;
 constexpr uint32_t kMinWlOutputVersion = 2;
+constexpr uint32_t kMaxXdgDecorationVersion = 1;
 }  // namespace
 
 WaylandConnection::WaylandConnection() = default;
@@ -386,6 +387,11 @@ void WaylandConnection::Global(void* data,
       LOG(ERROR) << "Failed to bind zaura_shell";
       return;
     }
+  } else if (!connection->xdg_decoration_manager_ &&
+             strcmp(interface, "zxdg_decoration_manager_v1") == 0) {
+    connection->xdg_decoration_manager_ =
+        wl::Bind<struct zxdg_decoration_manager_v1>(registry, name,
+                                                    kMaxXdgDecorationVersion);
   }
 
   connection->ScheduleFlush();

ui/ozone/platform/wayland/host/wayland_connection.h

@@ -72,6 +72,9 @@ class WaylandConnection {
       const {
     return linux_explicit_synchronization_.get();
   }
+  zxdg_decoration_manager_v1* xdg_decoration_manager_v1() const {
+    return xdg_decoration_manager_.get();
+  }
 
   void set_serial(uint32_t serial, EventType event_type) {
     serial_ = {serial, event_type};
@@ -186,6 +189,7 @@ class WaylandConnection {
   wl::Object<zaura_shell> aura_shell_;
   wl::Object<zwp_linux_explicit_synchronization_v1>
       linux_explicit_synchronization_;
+  wl::Object<zxdg_decoration_manager_v1> xdg_decoration_manager_;
 
   // Event source instance. Must be declared before input objects so it
   // outlives them so thus being able to properly handle their destruction.

ui/ozone/platform/wayland/host/xdg_surface_wrapper_impl.cc

@@ -203,6 +203,13 @@ void XDGSurfaceWrapperImpl::CloseTopLevelStable(
   surface->wayland_window_->OnCloseRequest();
 }
 
+void XDGSurfaceWrapperImpl::SetTopLevelDecorationMode(
+    zxdg_toplevel_decoration_v1_mode requested_mode) {
+  zxdg_toplevel_decoration_mode_ = requested_mode;
+  zxdg_toplevel_decoration_v1_set_mode(zxdg_toplevel_decoration_.get(),
+                                       requested_mode);
+}
+
 // static
 void XDGSurfaceWrapperImpl::ConfigureV6(void* data,
                                         struct zxdg_surface_v6* zxdg_surface_v6,
@@ -254,6 +261,17 @@ xdg_surface* XDGSurfaceWrapperImpl::xdg_surface() const {
   return xdg_surface_.get();
 }
 
+// static
+void XDGSurfaceWrapperImpl::ConfigureDecoration(
+    void* data,
+    struct zxdg_toplevel_decoration_v1* decoration,
+    uint32_t mode) {
+  auto* surface = static_cast<XDGSurfaceWrapperImpl*>(data);
+  DCHECK(surface);
+  surface->SetTopLevelDecorationMode(
+      static_cast<zxdg_toplevel_decoration_v1_mode>(mode));
+}
+
 bool XDGSurfaceWrapperImpl::InitializeStable(bool with_toplevel) {
   static const xdg_surface_listener xdg_surface_listener = {
       &XDGSurfaceWrapperImpl::ConfigureStable,
@@ -286,8 +304,11 @@ bool XDGSurfaceWrapperImpl::InitializeStable(bool with_toplevel) {
     LOG(ERROR) << "Failed to create xdg_toplevel";
     return false;
   }
+
   xdg_toplevel_add_listener(xdg_toplevel_.get(), &xdg_toplevel_listener, this);
 
+  InitializeXdgDecoration();
+
   wayland_window_->root_surface()->Commit();
   connection_->ScheduleFlush();
   return true;
@@ -334,4 +355,18 @@ bool XDGSurfaceWrapperImpl::InitializeV6(bool with_toplevel) {
   return true;
 }
 
+void XDGSurfaceWrapperImpl::InitializeXdgDecoration() {
+  if (connection_->xdg_decoration_manager_v1()) {
+    DCHECK(!zxdg_toplevel_decoration_);
+    static const zxdg_toplevel_decoration_v1_listener decoration_listener = {
+        &XDGSurfaceWrapperImpl::ConfigureDecoration,
+    };
+    zxdg_toplevel_decoration_.reset(
+        zxdg_decoration_manager_v1_get_toplevel_decoration(
+            connection_->xdg_decoration_manager_v1(), xdg_toplevel_.get()));
+    zxdg_toplevel_decoration_v1_add_listener(zxdg_toplevel_decoration_.get(),
+                                             &decoration_listener, this);
+  }
+}
+
 }  // namespace ui

ui/ozone/platform/wayland/host/xdg_surface_wrapper_impl.h

@@ -7,6 +7,8 @@
 
 #include "ui/ozone/platform/wayland/host/shell_surface_wrapper.h"
 
+#include <xdg-decoration-unstable-v1-client-protocol.h>
+
 #include "base/macros.h"
 #include "base/strings/string16.h"
 #include "ui/ozone/platform/wayland/common/wayland_object.h"
@@ -68,6 +70,14 @@ class XDGSurfaceWrapperImpl : public ShellSurfaceWrapper {
   static void CloseTopLevelV6(void* data,
                               struct zxdg_toplevel_v6* zxdg_toplevel_v6);
 
+  void SetTopLevelDecorationMode(
+      zxdg_toplevel_decoration_v1_mode requested_mode);
+  // zxdg_decoration_listener
+  static void ConfigureDecoration(
+      void* data,
+      struct zxdg_toplevel_decoration_v1* decoration,
+      uint32_t mode);
+
   struct xdg_surface* xdg_surface() const;
   zxdg_surface_v6* zxdg_surface() const;
 
@@ -77,6 +87,9 @@ class XDGSurfaceWrapperImpl : public ShellSurfaceWrapper {
   // Initializes using XDG Shell V6 protocol.
   bool InitializeV6(bool with_toplevel);
 
+  // Initializes the xdg-decoration protocol extension, if available.
+  void InitializeXdgDecoration();
+
   // Non-owing WaylandWindow that uses this surface wrapper.
   WaylandWindow* const wayland_window_;
   WaylandConnection* const connection_;
@@ -87,8 +100,10 @@ class XDGSurfaceWrapperImpl : public ShellSurfaceWrapper {
   wl::Object<zxdg_toplevel_v6> zxdg_toplevel_v6_;
   wl::Object<struct xdg_surface> xdg_surface_;
   wl::Object<xdg_toplevel> xdg_toplevel_;
+  wl::Object<zxdg_toplevel_decoration_v1> zxdg_toplevel_decoration_;
 
   bool surface_for_popup_ = false;
+  enum zxdg_toplevel_decoration_v1_mode zxdg_toplevel_decoration_mode_;
 
   DISALLOW_COPY_AND_ASSIGN(XDGSurfaceWrapperImpl);
 };