ozone/platform/wayland: Implement pointer handling

ui/ozone/platform/wayland/fake_server.cc

 // Copyright 2016 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 "ui/ozone/platform/wayland/fake_server.h"
 
 #include <sys/socket.h>
 #include <wayland-server.h>
 #include <xdg-shell-unstable-v5-server-protocol.h>
 
 #include "base/bind.h"
 #include "base/files/scoped_file.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 
 namespace wl {
 namespace {
 
 const uint32_t kCompositorVersion = 4;
+const uint32_t kSeatVersion = 4;
 const uint32_t kXdgShellVersion = 1;
 
 void DestroyResource(wl_client* client, wl_resource* resource) {
   wl_resource_destroy(resource);
 }
 
 // wl_compositor
 
 void CreateSurface(wl_client* client, wl_resource* resource, uint32_t id) {
   auto compositor =
@@ skipping 84 matching lines @@
 }
 
 const struct xdg_shell_interface xdg_shell_impl = {
     &DestroyResource,     // destroy
     &UseUnstableVersion,  // use_unstable_version
     &GetXdgSurface,       // get_xdg_surface
     nullptr,              // get_xdg_popup
     &Pong,                // pong
 };
 
+// wl_seat
+
+void GetPointer(wl_client* client, wl_resource* resource, uint32_t id) {
+  auto seat = static_cast<MockSeat*>(wl_resource_get_user_data(resource));
+  wl_resource* pointer_resource = wl_resource_create(
+      client, &wl_pointer_interface, wl_resource_get_version(resource), id);
+  if (!pointer_resource) {
+    wl_client_post_no_memory(client);
+    return;
+  }
+  seat->pointer.reset(new MockPointer(pointer_resource));
+}
+
+const struct wl_seat_interface seat_impl = {
+    &GetPointer,       // get_pointer
+    nullptr,           // get_keyboard
+    nullptr,           // get_touch,
+    &DestroyResource,  // release
+};
+
+// wl_pointer
+
+const struct wl_pointer_interface pointer_impl = {
+    nullptr,           // set_cursor
+    &DestroyResource,  // release
+};
+
 // xdg_surface
 
 void SetTitle(wl_client* client, wl_resource* resource, const char* title) {
   static_cast<MockXdgSurface*>(wl_resource_get_user_data(resource))
       ->SetTitle(title);
 }
 
 void SetAppId(wl_client* client, wl_resource* resource, const char* app_id) {
   static_cast<MockXdgSurface*>(wl_resource_get_user_data(resource))
       ->SetAppId(app_id);
@@ skipping 67 matching lines @@
   if (xdg_surface && xdg_surface->resource())
     wl_resource_destroy(xdg_surface->resource());
 }
 
 MockSurface* MockSurface::FromResource(wl_resource* resource) {
   if (!wl_resource_instance_of(resource, &wl_surface_interface, &surface_impl))
     return nullptr;
   return static_cast<MockSurface*>(wl_resource_get_user_data(resource));
 }
 
+MockPointer::MockPointer(wl_resource* resource) : ServerObject(resource) {
+  wl_resource_set_implementation(resource, &pointer_impl, this,
+                                 &ServerObject::OnResourceDestroyed);
+}
+
+MockPointer::~MockPointer() {}
+
 void GlobalDeleter::operator()(wl_global* global) {
   wl_global_destroy(global);
 }
 
 Global::Global(const wl_interface* interface,
                const void* implementation,
                uint32_t version)
     : interface_(interface),
       implementation_(implementation),
       version_(version) {}
@@ skipping 32 matching lines @@
 
 MockCompositor::MockCompositor()
     : Global(&wl_compositor_interface, &compositor_impl, kCompositorVersion) {}
 
 MockCompositor::~MockCompositor() {}
 
 void MockCompositor::AddSurface(scoped_ptr<MockSurface> surface) {
   surfaces_.push_back(std::move(surface));
 }
 
+MockSeat::MockSeat() : Global(&wl_seat_interface, &seat_impl, kSeatVersion) {}
+
+MockSeat::~MockSeat() {}
+
 MockXdgShell::MockXdgShell()
     : Global(&xdg_shell_interface, &xdg_shell_impl, kXdgShellVersion) {}
 
 MockXdgShell::~MockXdgShell() {}
 
 void DisplayDeleter::operator()(wl_display* display) {
   wl_display_destroy(display);
 }
 
 FakeServer::FakeServer()
@@ skipping 15 matching lines @@
   int fd[2];
   if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, fd) < 0)
     return false;
   base::ScopedFD server_fd(fd[0]);
   base::ScopedFD client_fd(fd[1]);
 
   if (wl_display_init_shm(display_.get()) < 0)
     return false;
   if (!compositor_.Initialize(display_.get()))
     return false;
+  if (!seat_.Initialize(display_.get()))
+    return false;
   if (!xdg_shell_.Initialize(display_.get()))
     return false;
 
   client_ = wl_client_create(display_.get(), server_fd.get());
   if (!client_)
     return false;
   (void)server_fd.release();
 
   base::Thread::Options options;
   options.message_pump_factory =
@@ skipping 33 matching lines @@
 }
 
 void FakeServer::OnFileCanReadWithoutBlocking(int fd) {
   wl_event_loop_dispatch(event_loop_, 0);
   wl_display_flush_clients(display_.get());
 }
 
 void FakeServer::OnFileCanWriteWithoutBlocking(int fd) {}
 
 }  // namespace wl