Implemented smooth scrolling using xinput2 in X11.

ui/events/x/events_x.cc

 // Copyright (c) 2012 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/events/event_constants.h"
 
 #include <string.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/XKBlib.h>
@@ skipping 422 matching lines @@
         }
         case XI_Motion: {
           bool is_cancel;
           DeviceDataManagerX11* devices = DeviceDataManagerX11::GetInstance();
           if (GetFlingData(native_event, NULL, NULL, NULL, NULL, &is_cancel))
             return is_cancel ? ET_SCROLL_FLING_CANCEL : ET_SCROLL_FLING_START;
           if (devices->IsScrollEvent(native_event)) {
             return devices->IsTouchpadXInputEvent(native_event) ? ET_SCROLL
                                                                 : ET_MOUSEWHEEL;
           }
+          if (devices->GetScrollClassEventDetail(native_event) !=
+              SCROLL_TYPE_NO_SCROLL)
+            return ET_MOUSEWHEEL;
           if (devices->IsCMTMetricsEvent(native_event))
             return ET_UMA_DATA;
           if (GetButtonMaskForX2Event(xievent))
             return ET_MOUSE_DRAGGED;
           if (DeviceDataManagerX11::GetInstance()->HasEventData(
                   xievent, DeviceDataManagerX11::DT_CMT_SCROLL_X) ||
               DeviceDataManagerX11::GetInstance()->HasEventData(
                   xievent, DeviceDataManagerX11::DT_CMT_SCROLL_Y)) {
             // Don't produce mouse move events for mousewheel scrolls.
             return ET_UNKNOWN;
@@ skipping 231 matching lines @@
   float x_offset, y_offset;
   if (GetScrollOffsets(
       native_event, &x_offset, &y_offset, NULL, NULL, NULL)) {
     return gfx::Vector2d(static_cast<int>(x_offset),
                          static_cast<int>(y_offset));
   }
 
   int button = native_event->type == GenericEvent ?
       EventButtonFromNative(native_event) : native_event->xbutton.button;
 
+  int scroll_class_type =
+      DeviceDataManagerX11::GetInstance()->GetScrollClassDeviceDetail(
+          native_event);
+  bool vertical_scroll_class = scroll_class_type & SCROLL_TYPE_VERTICAL;
+  bool horizontal_scroll_class = scroll_class_type & SCROLL_TYPE_HORIZONTAL;

[sadrul, 2016/01/04 18:51:21]

GetScrollOffsets() above should already take care of this, and so
scroll_class_type should never have either of the flags set, right? i.e we
should not need the changes you have in this function? (and thus we should not
need DeviceDataManagerX11::GetScrollClassDeviceDetail() either)?

[Will Shackleton, 2016/01/04 21:07:42]

In the current design this is needed - GetScrollOffsets fetches smooth scroll
offsets if they are present in the current event; when using a smoothscroll
device, we receive Xinput2 smooth events as well as Xinput1 clicky events.
Therefore we still have to check if even though we received a classic event
(with no smooth scroll data) we want to ignore it since we have better
information than that (by checking if the device supports smooth scrolling).

[sadrul, 2016/01/05 16:46:23]

ugh, x11 ...

OK. In that case, can we use only GetScrollClassDeviceDetail(), and get rid of
GetScrollClassEventDetail()? The change should be OK in both
EventTypeFromNative() and GetScrollOffsets(). GetScrollClassOffsets() can be
updated to always set x_offset and y_offset to 0 when the valuators are not set,
so that GetScrollOffsets() returns an empty scroll-vector for the old-style
events. That way, the smooth-scroll specific offsets are extracted in exactly
one place, instead of sometimes in GetScrollClassOffsets() and sometimes here in
GetMouseWheelOffset().

[Will Shackleton, 2016/01/05 21:27:02]

wooooo so even though I've done this and it works we can't remove
|GetScrollClassEventDetail| - it's used in x11_util.cc to stop coalescing of
scroll events with mouse events and in events_x.cc to determine the type of
smooth scroll events.

[Will Shackleton, 2016/01/05 21:27:02]

That seems like a better way of doing this.

+
   switch (button) {
     case 4:
-      return gfx::Vector2d(0, kWheelScrollAmount);
+      return gfx::Vector2d(0, vertical_scroll_class ? 0 : kWheelScrollAmount);
     case 5:
-      return gfx::Vector2d(0, -kWheelScrollAmount);
+      return gfx::Vector2d(0, vertical_scroll_class ? 0 : -kWheelScrollAmount);
     case 6:
-      return gfx::Vector2d(kWheelScrollAmount, 0);
+      return gfx::Vector2d(horizontal_scroll_class ? 0 : kWheelScrollAmount, 0);
     case 7:
-      return gfx::Vector2d(-kWheelScrollAmount, 0);
+      return gfx::Vector2d(horizontal_scroll_class ? 0 : -kWheelScrollAmount,
+                           0);
     default:
       return gfx::Vector2d();
   }
 }
 
 base::NativeEvent CopyNativeEvent(const base::NativeEvent& event) {
   if (!event || event->type == GenericEvent)
     return NULL;
   XEvent* copy = new XEvent;
   *copy = *event;
@@ skipping 63 matching lines @@
     force = 0.0;
   return force;
 }
 
 bool GetScrollOffsets(const base::NativeEvent& native_event,
                       float* x_offset,
                       float* y_offset,
                       float* x_offset_ordinal,
                       float* y_offset_ordinal,
                       int* finger_count) {
-  if (!DeviceDataManagerX11::GetInstance()->IsScrollEvent(native_event))
-    return false;
+  if (DeviceDataManagerX11::GetInstance()->IsScrollEvent(native_event)) {
+    // Temp values to prevent passing NULLs to DeviceDataManager.
+    float x_offset_, y_offset_;
+    float x_offset_ordinal_, y_offset_ordinal_;
+    int finger_count_;
+    if (!x_offset)
+      x_offset = &x_offset_;
+    if (!y_offset)
+      y_offset = &y_offset_;
+    if (!x_offset_ordinal)
+      x_offset_ordinal = &x_offset_ordinal_;
+    if (!y_offset_ordinal)
+      y_offset_ordinal = &y_offset_ordinal_;
+    if (!finger_count)
+      finger_count = &finger_count_;
 
-  // Temp values to prevent passing NULLs to DeviceDataManager.
-  float x_offset_, y_offset_;
-  float x_offset_ordinal_, y_offset_ordinal_;
-  int finger_count_;
-  if (!x_offset)
-    x_offset = &x_offset_;
-  if (!y_offset)
-    y_offset = &y_offset_;
-  if (!x_offset_ordinal)
-    x_offset_ordinal = &x_offset_ordinal_;
-  if (!y_offset_ordinal)
-    y_offset_ordinal = &y_offset_ordinal_;
-  if (!finger_count)
-    finger_count = &finger_count_;
+    DeviceDataManagerX11::GetInstance()->GetScrollOffsets(
+        native_event, x_offset, y_offset, x_offset_ordinal, y_offset_ordinal,
+        finger_count);
+    return true;
+  }
 
-  DeviceDataManagerX11::GetInstance()->GetScrollOffsets(
-      native_event,
-      x_offset, y_offset,
-      x_offset_ordinal, y_offset_ordinal,
-      finger_count);
-  return true;
+  if (DeviceDataManagerX11::GetInstance()->GetScrollClassEventDetail(
+          native_event) != SCROLL_TYPE_NO_SCROLL) {
+    double x_scroll_offset, y_scroll_offset;
+    DeviceDataManagerX11::GetInstance()->GetScrollClassOffsets(
+        native_event, &x_scroll_offset, &y_scroll_offset);
+    *x_offset = x_scroll_offset * kWheelScrollAmount;
+    *y_offset = y_scroll_offset * kWheelScrollAmount;
+    return true;
+  }
+  return false;
 }
 
 bool GetFlingData(const base::NativeEvent& native_event,
                   float* vx,
                   float* vy,
                   float* vx_ordinal,
                   float* vy_ordinal,
                   bool* is_cancel) {
   if (!DeviceDataManagerX11::GetInstance()->IsFlingEvent(native_event))
     return false;
@@ skipping 60 matching lines @@
       xievent->detail =
           UpdateX11EventButton(event->changed_button_flags(), xievent->detail);
       break;
     }
     default:
       break;
   }
 }
 
 }  // namespace ui