exo: Implement zcr_linux_explicit_synchronization_v1

components/exo/wayland/server.cc

 // Copyright 2015 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.
 
 #include "components/exo/wayland/server.h"
 
 #include <grp.h>
 #include <linux/input.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <viewporter-server-protocol.h>
 #include <wayland-server-core.h>
 #include <wayland-server-protocol-core.h>
 
 // Note: core wayland headers need to be included before protocol headers.
 #include <alpha-compositing-unstable-v1-server-protocol.h>  // NOLINT
+#include <linux-explicit-synchronization-unstable-v1-server-protocol.h>   // NOLINT
 #include <gaming-input-unstable-v1-server-protocol.h>       // NOLINT
 #include <remote-shell-unstable-v1-server-protocol.h>       // NOLINT
 #include <secure-output-unstable-v1-server-protocol.h>      // NOLINT
 #include <stylus-unstable-v1-server-protocol.h>             // NOLINT
 #include <xdg-shell-unstable-v5-server-protocol.h>          // NOLINT
 #include <vsync-feedback-unstable-v1-server-protocol.h>     // NOLINT
 
 #include <algorithm>
 #include <cstdlib>
 #include <iterator>
@@ skipping 26 matching lines @@
 #include "components/exo/pointer_delegate.h"
 #include "components/exo/pointer_stylus_delegate.h"
 #include "components/exo/shared_memory.h"
 #include "components/exo/shell_surface.h"
 #include "components/exo/sub_surface.h"
 #include "components/exo/surface.h"
 #include "components/exo/surface_property.h"
 #include "components/exo/touch.h"
 #include "components/exo/touch_delegate.h"
 #include "components/exo/wm_helper.h"
+#include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "ipc/unix_domain_socket_util.h"
 #include "third_party/skia/include/core/SkRegion.h"
+#include "ui/aura/env.h"
 #include "ui/aura/window_property.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/compositor_vsync_manager.h"
 #include "ui/display/display_observer.h"
 #include "ui/display/manager/managed_display_info.h"
 #include "ui/display/screen.h"
 #include "ui/events/keycodes/dom/keycode_converter.h"
 #include "ui/gfx/buffer_format_util.h"
 #include "ui/gfx/buffer_types.h"
 #include "ui/views/widget/widget.h"
@@ skipping 15 matching lines @@
 
 namespace exo {
 namespace wayland {
 namespace {
 
 // We don't send configure immediately after tablet mode switch
 // because layout can change due to orientation lock state or accelerometer.
 const int kConfigureDelayAfterLayoutSwitchMs = 300;
 
 // Default wayland socket name.
-const base::FilePath::CharType kSocketName[] = FILE_PATH_LITERAL("wayland-0");
+const base::FilePath::CharType kSocketName[] = FILE_PATH_LITERAL("exosphere-0");

[fooishbar, 2016/10/12 15:50:51]

Sorry, this still crept in from git-cl having squashed my local change in as
well.

[reveman, 2016/10/12 19:20:20]

No problem. If you can remove it when you have a chance so people can apply this
unmodified patch for testing purposes without breaking arc++ that'd be great.

 
 // Group used for wayland socket.
 const char kWaylandSocketGroup[] = "wayland";
 
 template <class T>
 T* GetUserDataAs(wl_resource* resource) {
   return static_cast<T*>(wl_resource_get_user_data(resource));
 }
 
 template <class T>
@@ skipping 36 matching lines @@
 DEFINE_SURFACE_PROPERTY_KEY(bool, kSurfaceHasViewportKey, false);
 
 // A property key containing a boolean set to true if a security object is
 // associated with window.
 DEFINE_SURFACE_PROPERTY_KEY(bool, kSurfaceHasSecurityKey, false);
 
 // A property key containing a boolean set to true if a blending object is
 // associated with window.
 DEFINE_SURFACE_PROPERTY_KEY(bool, kSurfaceHasBlendingKey, false);
 
+#if defined(USE_OZONE)
+// A property key containing a boolean set to true if a blending object is
+// associated with window.
+DEFINE_SURFACE_PROPERTY_KEY(bool, kSurfaceHasSynchronizationKey, false);
+#endif
+
 wl_resource* GetSurfaceResource(Surface* surface) {
   return surface->GetProperty(kSurfaceResourceKey);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // wl_buffer_interface:
 
 void buffer_destroy(wl_client* client, wl_resource* resource) {
   wl_resource_destroy(resource);
 }
@@ skipping 588 matching lines @@
   wl_resource* resource =
       wl_resource_create(client, &zwp_linux_dmabuf_v1_interface, 1, id);
 
   wl_resource_set_implementation(resource, &linux_dmabuf_implementation, data,
                                  nullptr);
 
   for (const auto& supported_format : dmabuf_supported_formats)
     zwp_linux_dmabuf_v1_send_format(resource, supported_format.dmabuf_format);
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// synchronization interface:
+
+class Synchronization : public SurfaceObserver {

[reveman, 2016/10/12 19:20:20]

nit: add the following comment above this class:

// Implements the synchronization interface to a Surface. A window property
// will be set during the lifetime of this class to prevent multiple instances
// from being created for the same Surface.

+ public:
+  explicit Synchronization(Display* display, Surface* surface) :
+      surface_(surface),
+      display_(display) {
+    surface_->AddSurfaceObserver(this);
+    surface_->SetProperty(kSurfaceHasSynchronizationKey, true);
+  }
+  ~Synchronization() override {
+    if (surface_) {
+      surface_->RemoveSurfaceObserver(this);
+      surface_->SetProperty(kSurfaceHasSynchronizationKey, true);

[reveman, 2016/10/12 19:20:20]

s/true/false/ here

+    }
+  }
+
+  bool SetAcquireFence(int fd_raw) {

[reveman, 2016/10/12 19:20:20]

nit: s/int fd_raw/base::ScopedFD fd/ as it's best to add proper ownership asap
in synchronization_set_acquire_fence and avoid passing raw fds around

+    std::unique_ptr<gfx::GpuFence> fence;

[reveman, 2016/10/12 19:20:20]

nit: move down where it's first used

+    base::ScopedFD fd(fd_raw);
+
+    fence = display_->CreateLinuxFence(fd);
+    if (!fence)
+      return false;
+
+    surface_->SetAcquireFence(std::move(fence));
+    return true;
+  }
+
+  void OnSurfaceDestroying(Surface* surface) override {
+    surface->RemoveSurfaceObserver(this);
+    surface_ = nullptr;
+  }
+
+ private:
+  Surface* surface_;
+  Display* display_;
+
+  DISALLOW_COPY_AND_ASSIGN(Synchronization);
+};
+
+void synchronization_destroy(wl_client* client, wl_resource* resource) {
+  wl_resource_destroy(resource);
+}
+
+void synchronization_set_acquire_fence(wl_client* client, wl_resource* resource,
+                                       int fd_raw) {

[reveman, 2016/10/12 19:20:20]

nit: s/int fd_raw/int32_t fd/

+  Synchronization* synchronization = GetUserDataAs<Synchronization>(resource);
+
+  if (!synchronization->SetAcquireFence(fd_raw)) {

[reveman, 2016/10/12 19:20:20]

s/fd_raw/base::ScopedFD(fd)/

+    wl_resource_post_error(resource,
+                           ZCR_SYNCHRONIZATION_V1_ERROR_INVALID_FENCE,
+                           "fence creation failed");
+  }
+}
+
+const struct zcr_synchronization_v1_interface
+    synchronization_implementation = {
+    synchronization_destroy,
+    synchronization_set_acquire_fence};
+
+
+////////////////////////////////////////////////////////////////////////////////
+// linux_explicit_synchronization interface:
+
+void linux_explicit_synchronization_destroy(wl_client* client,
+                                            wl_resource* resource) {
+  wl_resource_destroy(resource);
+}
+
+void linux_explicit_synchronization_get_surface(wl_client* client,
+                                                wl_resource* resource,
+                                                uint32_t id,
+                                                wl_resource* surface_resource) {
+  Display* display = GetUserDataAs<Display>(resource);
+  Surface* surface = GetUserDataAs<Surface>(surface_resource);
+
+  if (surface->GetProperty(kSurfaceHasSynchronizationKey)) {
+    wl_resource_post_error(resource,
+                           ZCR_LINUX_EXPLICIT_SYNCHRONIZATION_V1_ERROR_SYNCHRONIZATION_EXISTS,
+                           "a synchronization object for that surface already exists");
+    return;
+  }
+
+  wl_resource* synchronization_resource =
+      wl_resource_create(client, &zcr_synchronization_v1_interface, 1, id);
+
+  SetImplementation(synchronization_resource, &synchronization_implementation,
+                    base::MakeUnique<Synchronization>(display, surface));
+}
+
+const struct zcr_linux_explicit_synchronization_v1_interface
+  linux_explicit_synchronization_implementation = {
+    linux_explicit_synchronization_destroy,
+    linux_explicit_synchronization_get_surface};
+
+void bind_linux_explicit_synchronization(wl_client* client, void* data,
+                                         uint32_t version, uint32_t id) {
+  wl_resource* resource =
+      wl_resource_create(client,
+                         &zcr_linux_explicit_synchronization_v1_interface,
+                         1,
+                         id);
+  wl_resource_set_implementation(resource,
+                                 &linux_explicit_synchronization_implementation,
+                                 data,
+                                 nullptr);
+}
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////
 // wl_subsurface_interface:
 
 void subsurface_destroy(wl_client* client, wl_resource* resource) {
   wl_resource_destroy(resource);
 }
 
 void subsurface_set_position(wl_client* client,
@@ skipping 2184 matching lines @@
 const struct zcr_stylus_v1_interface stylus_implementation = {
     stylus_get_pointer_stylus};
 
 void bind_stylus(wl_client* client, void* data, uint32_t version, uint32_t id) {
   wl_resource* resource =
       wl_resource_create(client, &zcr_stylus_v1_interface, version, id);
   wl_resource_set_implementation(resource, &stylus_implementation, data,
                                  nullptr);
 }
 
+

[reveman, 2016/10/12 19:20:20]

nit: no need for this blank line

 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // Server, public:
 
 Server::Server(Display* display)
     : display_(display), wl_display_(wl_display_create()) {
   wl_global_create(wl_display_.get(), &wl_compositor_interface,
                    compositor_version, display_, bind_compositor);
   wl_global_create(wl_display_.get(), &wl_shm_interface, 1, display_, bind_shm);
 #if defined(USE_OZONE)
   wl_global_create(wl_display_.get(), &wl_drm_interface, drm_version, display_,
                    bind_drm);
   wl_global_create(wl_display_.get(), &zwp_linux_dmabuf_v1_interface, 1,
                    display_, bind_linux_dmabuf);
+  wl_global_create(wl_display_.get(),
+                   &zcr_linux_explicit_synchronization_v1_interface, 1, display_,
+                   bind_linux_explicit_synchronization);
 #endif
   wl_global_create(wl_display_.get(), &wl_subcompositor_interface, 1, display_,
                    bind_subcompositor);
   wl_global_create(wl_display_.get(), &wl_shell_interface, 1, display_,
                    bind_shell);
   wl_global_create(wl_display_.get(), &wl_output_interface, output_version,
                    display_, bind_output);
   wl_global_create(wl_display_.get(), &xdg_shell_interface, 1, display_,
                    bind_xdg_shell);
   wl_global_create(wl_display_.get(), &zcr_vsync_feedback_v1_interface, 1,
@@ skipping 78 matching lines @@
   DCHECK(event_loop);
   wl_event_loop_dispatch(event_loop, timeout.InMilliseconds());
 }
 
 void Server::Flush() {
   wl_display_flush_clients(wl_display_.get());
 }
 
 }  // namespace wayland
 }  // namespace exo