Support 3f swipe for tab scrubbing

ui/base/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/base/events/event_constants.h"
 
 #include <string.h>
 #include <X11/extensions/XInput.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
@@ skipping 22 matching lines @@
 
 // CMT specific timings
 #define AXIS_LABEL_PROP_ABS_START_TIME "Abs Start Timestamp"
 #define AXIS_LABEL_PROP_ABS_END_TIME "Abs End Timestamp"
 
 // Fling properties
 #define AXIS_LABEL_PROP_ABS_FLING_X       "Abs Fling X Velocity"
 #define AXIS_LABEL_PROP_ABS_FLING_Y       "Abs Fling Y Velocity"
 #define AXIS_LABEL_PROP_ABS_FLING_STATE   "Abs Fling State"
 
+#define AXIS_LABEL_PROP_ABS_FINGER_COUNT   "Abs Finger Count"
+
 // New versions of the valuators, with double values instead of fixed point.
 #define AXIS_LABEL_PROP_ABS_DBL_START_TIME "Abs Dbl Start Timestamp"
 #define AXIS_LABEL_PROP_ABS_DBL_END_TIME   "Abs Dbl End Timestamp"
 #define AXIS_LABEL_PROP_ABS_DBL_FLING_VX   "Abs Dbl Fling X Velocity"
 #define AXIS_LABEL_PROP_ABS_DBL_FLING_VY   "Abs Dbl Fling Y Velocity"
 
 namespace {
 
 // Scroll amount for each wheelscroll event. 53 is also the value used for GTK+.
 const int kWheelScrollAmount = 53;
 
 const int kMinWheelButton = 4;
 const int kMaxWheelButton = 7;
 
 const char* kCMTCachedAtoms[] = {
   AXIS_LABEL_PROP_REL_HWHEEL,
   AXIS_LABEL_PROP_REL_WHEEL,
   AXIS_LABEL_PROP_ABS_START_TIME,
   AXIS_LABEL_PROP_ABS_DBL_START_TIME,
   AXIS_LABEL_PROP_ABS_END_TIME,
   AXIS_LABEL_PROP_ABS_DBL_END_TIME,
   AXIS_LABEL_PROP_ABS_FLING_X,
   AXIS_LABEL_PROP_ABS_FLING_Y,
   AXIS_LABEL_PROP_ABS_DBL_FLING_VX,
   AXIS_LABEL_PROP_ABS_DBL_FLING_VY,
   AXIS_LABEL_PROP_ABS_FLING_STATE,
+  AXIS_LABEL_PROP_ABS_FINGER_COUNT,
   NULL
 };
 
 #if defined(USE_XI2_MT)
 // If the calibration values were read, if this is true.
 bool calibration_values_read = false;
 
 // The (positive) calibration values for the four border sides.
 int left_border_touch_calibration = 0;
 int top_border_touch_calibration = 0;
@@ skipping 35 matching lines @@
     Atom start_time = atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_START_TIME);
     Atom start_time_dbl =
         atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_DBL_START_TIME);
     Atom end_time = atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_END_TIME);
     Atom end_time_dbl = atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_DBL_END_TIME);
     Atom fling_vx = atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_FLING_X);
     Atom fling_vx_dbl = atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_DBL_FLING_VX);
     Atom fling_vy = atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_FLING_Y);
     Atom fling_vy_dbl = atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_DBL_FLING_VY);
     Atom fling_state = atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_FLING_STATE);
+    Atom finger_count = atom_cache_.GetAtom(AXIS_LABEL_PROP_ABS_FINGER_COUNT);
 
     for (int i = 0; i < count; ++i) {
       XIDeviceInfo* info = info_list + i;
 
       if (info->use != XISlavePointer && info->use != XIFloatingSlave)
         continue;
 
       Valuators valuators;
       bool is_cmt = false;
       for (int j = 0; j < info->num_classes; ++j) {
         if (info->classes[j]->type == XIScrollClass) {
           is_cmt = false;
           break;
         }
         if (info->classes[j]->type != XIValuatorClass)
           continue;
 
         XIValuatorClassInfo* v =
             reinterpret_cast<XIValuatorClassInfo*>(info->classes[j]);
         int number = v->number;
         if (number > valuators.max)
           valuators.max = number;
         if (v->label == x_axis) {
           valuators.scroll_x = number;
           is_cmt = true;
         } else if (v->label == y_axis) {
           valuators.scroll_y = number;
           is_cmt = true;
+        } else if (v->label == finger_count) {
+          valuators.finger_count = number;
+          is_cmt = true;
         } else if (v->label == start_time) {
           valuators.start_time = number;
           is_cmt = true;
         } else if (v->label == start_time_dbl) {
           valuators.start_time_dbl = number;
           is_cmt = true;
         } else if (v->label == end_time) {
           valuators.end_time = number;
           is_cmt = true;
         } else if (v->label == end_time_dbl) {
@@ skipping 53 matching lines @@
     // Natural scroll is touchpad-only.
     if (!touchpads_[sourceid])
       return -1.0f;
 
     return natural_scroll_enabled_ ? 1.0f : -1.0f;
   }
 
   // Returns true if this is a scroll event (a motion event with the necessary
   // valuators. Also returns the offsets. |x_offset| and |y_offset| can be
   // NULL.
-  bool GetScrollOffsets(const XEvent& xev, float* x_offset, float* y_offset) {
+  bool GetScrollOffsets(const XEvent& xev,
+                        float* x_offset,
+                        float* y_offset,
+                        int* finger_count) {
     XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(xev.xcookie.data);
 
     if (x_offset)
       *x_offset = 0;
     if (y_offset)
       *y_offset = 0;
+    if (finger_count)
+      *finger_count = 2;
 
     const int sourceid = xiev->sourceid;
     if (!cmt_devices_[sourceid])
       return false;
 
     const float natural_scroll_factor = GetNaturalScrollFactor(sourceid);
     const Valuators v = device_to_valuators_[sourceid];
     const bool has_x_offset = XIMaskIsSet(xiev->valuators.mask, v.scroll_x);
     const bool has_y_offset = XIMaskIsSet(xiev->valuators.mask, v.scroll_y);
     const bool is_scroll = has_x_offset || has_y_offset;
 
     if (!is_scroll || (!x_offset && !y_offset))
       return is_scroll;
 
     double* valuators = xiev->valuators.values;
     for (int i = 0; i <= v.max; ++i) {
       if (XIMaskIsSet(xiev->valuators.mask, i)) {
         if (x_offset && v.scroll_x == i)
           *x_offset = *valuators * natural_scroll_factor;
         else if (y_offset && v.scroll_y == i)
           *y_offset = *valuators * natural_scroll_factor;
+        else if (finger_count && v.finger_count == i)
+          *finger_count = static_cast<int>(*valuators);
         valuators++;
       }
     }
 
     return true;
   }
 
   bool GetFlingData(const XEvent& xev,
                     float* vx, float* vy,
                     bool* is_cancel) {
@@ skipping 88 matching lines @@
   }
 
  private:
   // Requirement for Singleton
   friend struct DefaultSingletonTraits<CMTEventData>;
 
   struct Valuators {
     int max;
     int scroll_x;
     int scroll_y;
+    int finger_count;
     int start_time;
     int end_time;
     int fling_vx;
     int fling_vy;
     int fling_state;
     // *_dbl valuators take precedence over the fixed precision versions.
     int start_time_dbl;
     int end_time_dbl;
     int fling_vx_dbl;
     int fling_vy_dbl;
 
     Valuators()
         : max(-1),
           scroll_x(-1),
           scroll_y(-1),
+          finger_count(-1),
           start_time(-1),
           end_time(-1),
           fling_vx(-1),
           fling_vy(-1),
           fling_state(-1),
           start_time_dbl(-1),
           end_time_dbl(-1),
           fling_vx_dbl(-1),
           fling_vy_dbl(-1) {
     }
@@ skipping 356 matching lines @@
           // Drop wheel events; we should've already scrolled on the press.
           if (button >= kMinWheelButton && button <= kMaxWheelButton)
             return ET_UNKNOWN;
           return ET_MOUSE_RELEASED;
         }
         case XI_Motion: {
           float vx, vy;
           bool is_cancel;
           if (GetFlingData(native_event, &vx, &vy, &is_cancel)) {
             return is_cancel ? ET_SCROLL_FLING_CANCEL : ET_SCROLL_FLING_START;
-          } else if (GetScrollOffsets(native_event, NULL, NULL)) {
+          } else if (GetScrollOffsets(native_event, NULL, NULL, NULL)) {
             return ET_SCROLL;
           } else if (GetButtonMaskForX2Event(xievent)) {
             return ET_MOUSE_DRAGGED;
           } else {
             return ET_MOUSE_MOVED;
           }
         }
       }
     }
     default:
@@ skipping 296 matching lines @@
       static_cast<XIDeviceEvent*>(native_event->xcookie.data)->sourceid;
   // Force is normalized to fall into [0, 1]
   if (!ui::ValuatorTracker::GetInstance()->NormalizeValuator(
       deviceid, ui::ValuatorTracker::VAL_PRESSURE, &force))
     force = 0.0;
   return force;
 }
 
 bool GetScrollOffsets(const base::NativeEvent& native_event,
                       float* x_offset,
-                      float* y_offset) {
+                      float* y_offset,
+                      int* finger_count) {
   return CMTEventData::GetInstance()->GetScrollOffsets(
-      *native_event, x_offset, y_offset);
+      *native_event, x_offset, y_offset, finger_count);
 }
 
 bool GetFlingData(const base::NativeEvent& native_event,
                   float* vx,
                   float* vy,
                   bool* is_cancel) {
   return CMTEventData::GetInstance()->GetFlingData(
       *native_event, vx, vy, is_cancel);
 }
 
@@ skipping 31 matching lines @@
     noop->xclient.format = 8;
     DCHECK(!noop->xclient.display);
   }
   // Make sure we use atom from current xdisplay, which may
   // change during the test.
   noop->xclient.message_type = GetNoopEventAtom();
   return noop;
 }
 
 }  // namespace ui