Implemented smooth scrolling using xinput2 in X11.

ui/events/x/device_data_manager_x11.h

 // Copyright 2014 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.
 
 #ifndef UI_EVENTS_X_DEVICE_DATA_MANAGER_X11_H_
 #define UI_EVENTS_X_DEVICE_DATA_MANAGER_X11_H_
 
 // Generically-named #defines from Xlib is conflicting with symbols in GTest.
 // So many tests .cc file #undef Bool before including device_data_manager.h,
 // which makes Bool unrecognized in XInput2.h.
@@ skipping 131 matching lines @@
   bool IsXIDeviceEvent(const base::NativeEvent& native_event) const;
 
   // Check if the event comes from touchpad devices.
   bool IsTouchpadXInputEvent(const base::NativeEvent& native_event) const;
 
   // Check if the event comes from devices running CMT driver or using
   // CMT valuators (e.g. mouses). Note that doesn't necessarily mean the event
   // is a CMT event (e.g. it could be a mouse pointer move).
   bool IsCMTDeviceEvent(const base::NativeEvent& native_event) const;
 
+  // Check if the event comes from devices that have a ScrollClass (ie. support
+  // smooth scrolling).
+  bool IsScrollClassEvent(const base::NativeEvent& native_event) const;
+
+  // Check if the device has a vertical ScrollClass
+  bool IsScrollClassVerticalDevice(const base::NativeEvent& native_event) const;
+
+  // Check if the device has a horizontal ScrollClass
+  bool IsScrollClassHorizontalDevice(
+      const base::NativeEvent& native_event) const;
+

[sadrul, 2014/12/22 17:11:12]

Instead of these three, let's have a single

  ScrollType GetScrollClassDetail(event);

where

  enum ScrollType {
    SCROLL_TYPE_NO_SCROLL = 0,
    SCROLL_TYPE_HORIZONTAL = 1 << 0,
    SCROLL_TYPE_VERTICAL = 1 << 1,
  };

   // Check if the event is one of the CMT gesture events (scroll, fling,
   // metrics etc.).
   bool IsCMTGestureEvent(const base::NativeEvent& native_event) const;
 
   // Returns true if the event is of the specific type, false if not.
   bool IsScrollEvent(const base::NativeEvent& native_event) const;
   bool IsFlingEvent(const base::NativeEvent& native_event) const;
   bool IsCMTMetricsEvent(const base::NativeEvent& native_event) const;
 
   // Returns true if the event has CMT start/end timestamps.
   bool HasGestureTimes(const base::NativeEvent& native_event) const;
 
   // Extract data from a scroll event (a motion event with the necessary
   // valuators). User must first verify the event type with IsScrollEvent.
   // Pointers shouldn't be NULL.
   void GetScrollOffsets(const base::NativeEvent& native_event,
                         float* x_offset,
                         float* y_offset,
                         float* x_offset_ordinal,
                         float* y_offset_ordinal,
                         int* finger_count);
 
+  // Extract data from a scroll class event (smooth scrolling). User must
+  // first verify the event type with IsScrollClassEvent.
+  // Pointers shouldn't be NULL.
+  void GetScrollClassOffsets(const base::NativeEvent& native_event,
+                        double* x_offset,
+                        double* y_offset);

[sadrul, 2014/12/22 17:11:12]

indenting is off

+
+  // Invalidate stored scroll class counters, since they can change when
+  // pointing at other windows.
+  void InvalidateScrollClasses();
+
   // Extract data from a fling event. User must first verify the event type
   // with IsFlingEvent. Pointers shouldn't be NULL.
   void GetFlingData(const base::NativeEvent& native_event,
                     float* vx,
                     float* vy,
                     float* vx_ordinal,
                     float* vy_ordinal,
                     bool* is_cancel);
 
   // Extract data from a CrOS metrics gesture event. User must first verify
@@ skipping 17 matching lines @@
                        double* end_time);
 
   // Normalize the data value on deviceid to fall into [0, 1].
   // *value = (*value - min_value_of_tp) / (max_value_of_tp - min_value_of_tp)
   // Returns true and sets the normalized value in|value| if normalization is
   // successful. Returns false and |value| is unchanged otherwise.
   bool NormalizeData(unsigned int deviceid,
                      const DataType type,
                      double* value);
 
+  // Normalize the scroll amount according to the increment size.
+  // *value /= increment
+  // *value is expected to be 1 or -1.
+  // Returns true and sets the normalized value in |value| if normalization is
+  // successful. Returns false and |value| is unchanged otherwise.
+  bool NormalizeScrollData(unsigned int deviceid,
+                     bool horizontal,
+                     double* value);

[sadrul, 2014/12/22 17:11:12]

indent

+
   // Extract the range of the data type. Return true if the range is available
   // and written into min & max, false if the range is not available.
   bool GetDataRange(unsigned int deviceid,
                     const DataType type,
                     double* min,
                     double* max);
 
   // Sets up relevant valuator informations for device ids in the device lists.
   // This function is only for test purpose. It does not query the X server for
   // the actual device info, but rather inits the relevant valuator structures
@@ skipping 45 matching lines @@
   // Major opcode for the XInput extension. Used to identify XInput events.
   int xi_opcode_;
 
   // A quick lookup table for determining if the XI event is an XIDeviceEvent.
   std::bitset<kMaxXIEventType> xi_device_event_types_;
 
   // A quick lookup table for determining if events from the pointer device
   // should be processed.
   std::bitset<kMaxDeviceNum> cmt_devices_;
   std::bitset<kMaxDeviceNum> touchpads_;
+  std::bitset<kMaxDeviceNum> scrollclass_devices_;
 
   // A quick lookup table for determining if events from the XI device
   // should be blocked.
   std::bitset<kMaxDeviceNum> blocked_devices_;
 
   // The set of keys allowed while the keyboard is blocked.
   scoped_ptr<std::set<KeyboardCode> > blocked_keyboard_allowed_keys_;
 
   // Number of valuators on the specific device.
   int valuator_count_[kMaxDeviceNum];
 
   // Index table to find the valuator for DataType on the specific device
   // by valuator_lookup_[device_id][data_type].
   std::vector<int> valuator_lookup_[kMaxDeviceNum];
 
+  // Index table to find the horizontal scroll valuator number from the device
+  // ID.
+  int scroll_horizontal_number_[kMaxDeviceNum];
+
+  // Index table to find the vertical scroll valuator number from the device
+  // ID.
+  int scroll_vertical_number_[kMaxDeviceNum];
+
+  // Index table to find the horizontal scroll increment from the device ID.
+  double scroll_horizontal_increment_[kMaxDeviceNum];
+
+  // Index table to find the vertical scroll increment from the device ID.
+  double scroll_vertical_increment_[kMaxDeviceNum];
+
+  // Current horizontal scroll position; used to find the difference between
+  // events.
+  double scroll_horizontal_position_[kMaxDeviceNum];
+
+  // Current vertical scroll position; used to find the difference between
+  // events.
+  double scroll_vertical_position_[kMaxDeviceNum];
+
+  // If true, then a horizontal scroll has been seen on this device.
+  bool scroll_horizontal_seen_[kMaxDeviceNum];
+
+  // If true, then a vertical scroll has been seen on this device.
+  bool scroll_vertical_seen_[kMaxDeviceNum];
+

[sadrul, 2014/12/22 17:11:12]

Having to maintain all these scroll specific info in separate arrays here feels
awkward. How about:

  struct ScrollInfo {
    struct AxisInfo {
      int valuator_id;
      double increment_;
      ...
    };
    AxisInfo vertical, horizontal;
  } scroll_info[kMaxDeviceNum];

   // Index table to find the DataType for valuator on the specific device
   // by data_type_lookup_[device_id][valuator].
   std::vector<int> data_type_lookup_[kMaxDeviceNum];
 
   // Index table to find the min & max value of the Valuator on a specific
   // device.
   std::vector<double> valuator_min_[kMaxDeviceNum];
   std::vector<double> valuator_max_[kMaxDeviceNum];
 
   // Table to keep track of the last seen value for the specified valuator for
@@ skipping 14 matching lines @@
 
   unsigned char button_map_[256];
   int button_map_count_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceDataManagerX11);
 };
 
 }  // namespace ui
 
 #endif  // UI_EVENTS_X_DEVICE_DATA_MANAGER_X11_H_