components/exo: Extend pointer to use v5 protocol

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 <scaler-server-protocol.h>
 #include <stddef.h>
@@ skipping 1221 matching lines @@
   void OnPointerEnter(Surface* surface,
                       const gfx::Point& location,
                       int button_flags) override {
     wl_resource* surface_resource = surface->GetProperty(kSurfaceResourceKey);
     DCHECK(surface_resource);
     // Should we be sending button events to the client before the enter event
     // if client's pressed button state is different from |button_flags|?
     wl_pointer_send_enter(pointer_resource_, next_serial(), surface_resource,
                           wl_fixed_from_int(location.x()),
                           wl_fixed_from_int(location.y()));
-    wl_client_flush(client());
   }
   void OnPointerLeave(Surface* surface) override {
     wl_resource* surface_resource = surface->GetProperty(kSurfaceResourceKey);
     DCHECK(surface_resource);
     wl_pointer_send_leave(pointer_resource_, next_serial(), surface_resource);
-    wl_client_flush(client());
   }
   void OnPointerMotion(base::TimeDelta time_stamp,
                        const gfx::Point& location) override {
     wl_pointer_send_motion(pointer_resource_, time_stamp.InMilliseconds(),
                            wl_fixed_from_int(location.x()),
                            wl_fixed_from_int(location.y()));
-    wl_client_flush(client());
   }
   void OnPointerButton(base::TimeDelta time_stamp,
                        int button_flags,
                        bool pressed) override {
     struct {
       ui::EventFlags flag;
       uint32_t value;
     } buttons[] = {
         {ui::EF_LEFT_MOUSE_BUTTON, BTN_LEFT},
         {ui::EF_RIGHT_MOUSE_BUTTON, BTN_RIGHT},
         {ui::EF_MIDDLE_MOUSE_BUTTON, BTN_MIDDLE},
         {ui::EF_FORWARD_MOUSE_BUTTON, BTN_FORWARD},
         {ui::EF_BACK_MOUSE_BUTTON, BTN_BACK},
     };
     uint32_t serial = next_serial();
     for (auto button : buttons) {
       if (button_flags & button.flag) {
         wl_pointer_send_button(pointer_resource_, serial,
                                time_stamp.InMilliseconds(), button.value,
                                pressed ? WL_POINTER_BUTTON_STATE_PRESSED
                                        : WL_POINTER_BUTTON_STATE_RELEASED);
       }
     }
-    wl_client_flush(client());
   }
-  void OnPointerWheel(base::TimeDelta time_stamp,
-                      const gfx::Vector2d& offset) override {
+
+  void OnPointerScroll(base::TimeDelta time_stamp,
+                       const gfx::Vector2dF& offset,
+                       bool discrete) override {
     // Same as Weston, the reference compositor.
     const double kAxisStepDistance = 10.0 / ui::MouseWheelEvent::kWheelDelta;
 
+    if (wl_resource_get_version(pointer_resource_) >=
+        WL_POINTER_AXIS_SOURCE_SINCE_VERSION) {
+      int32_t axis_source = discrete ? WL_POINTER_AXIS_SOURCE_WHEEL
+                                     : WL_POINTER_AXIS_SOURCE_FINGER;
+      wl_pointer_send_axis_source(pointer_resource_, axis_source);
+    }
+
     double x_value = offset.x() * kAxisStepDistance;
-    if (x_value) {
-      wl_pointer_send_axis(pointer_resource_, time_stamp.InMilliseconds(),
-                           WL_POINTER_AXIS_HORIZONTAL_SCROLL,
-                           wl_fixed_from_double(-x_value));
+    wl_pointer_send_axis(pointer_resource_, time_stamp.InMilliseconds(),
+                         WL_POINTER_AXIS_HORIZONTAL_SCROLL,
+                         wl_fixed_from_double(-x_value));
+
+    double y_value = offset.y() * kAxisStepDistance;
+    wl_pointer_send_axis(pointer_resource_, time_stamp.InMilliseconds(),
+                         WL_POINTER_AXIS_VERTICAL_SCROLL,
+                         wl_fixed_from_double(-y_value));
+  }
+
+  void OnPointerScrollCancel(base::TimeDelta time_stamp) override {
+    // Wayland doesn't know the concept of a canceling kinetic scrolling.
+    // But we can send a 0 distance scroll to emulate this behavior.
+    OnPointerScroll(time_stamp, gfx::Vector2dF(0, 0), false);
+    OnPointerScrollStop(time_stamp);
+  }
+
+  void OnPointerScrollStop(base::TimeDelta time_stamp) override {
+    if (wl_resource_get_version(pointer_resource_) >=
+        WL_POINTER_AXIS_STOP_SINCE_VERSION) {
+      wl_pointer_send_axis_stop(pointer_resource_, time_stamp.InMilliseconds(),
+                                WL_POINTER_AXIS_HORIZONTAL_SCROLL);
+      wl_pointer_send_axis_stop(pointer_resource_, time_stamp.InMilliseconds(),
+                                WL_POINTER_AXIS_VERTICAL_SCROLL);
     }
-    double y_value = offset.y() * kAxisStepDistance;
-    if (y_value) {
-      wl_pointer_send_axis(pointer_resource_, time_stamp.InMilliseconds(),
-                           WL_POINTER_AXIS_VERTICAL_SCROLL,
-                           wl_fixed_from_double(-y_value));
+  }
+
+  void OnPointerFrame() override {
+    if (wl_resource_get_version(pointer_resource_) >=
+        WL_POINTER_FRAME_SINCE_VERSION) {
+      wl_pointer_send_frame(pointer_resource_);
     }
     wl_client_flush(client());
   }
 
  private:
   // The client who own this pointer instance.
   wl_client* client() const {
     return wl_resource_get_client(pointer_resource_);
   }
 
@@ skipping 280 matching lines @@
 
 void seat_get_touch(wl_client* client, wl_resource* resource, uint32_t id) {
   wl_resource* touch_resource = wl_resource_create(
       client, &wl_touch_interface, wl_resource_get_version(resource), id);
 
   SetImplementation(
       touch_resource, &touch_implementation,
       make_scoped_ptr(new Touch(new WaylandTouchDelegate(touch_resource))));
 }
 
+void seat_release(wl_client* client, wl_resource* resource) {
+  wl_resource_destroy(resource);
+}
+
 const struct wl_seat_interface seat_implementation = {
-    seat_get_pointer, seat_get_keyboard, seat_get_touch};
+    seat_get_pointer, seat_get_keyboard, seat_get_touch, seat_release};
 
-const uint32_t seat_version = 4;
+const uint32_t seat_version = 5;
 
 void bind_seat(wl_client* client, void* data, uint32_t version, uint32_t id) {
   wl_resource* resource = wl_resource_create(
       client, &wl_seat_interface, std::min(version, seat_version), id);
 
   wl_resource_set_implementation(resource, &seat_implementation, data, nullptr);
 
   if (version >= WL_SEAT_NAME_SINCE_VERSION)
     wl_seat_send_name(resource, "default");
 
@@ skipping 224 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