Implemented smooth scrolling using xinput2 in X11.

ui/events/devices/x11/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_DEVICES_X11_DEVICE_DATA_MANAGER_X11_H_
 #define UI_EVENTS_DEVICES_X11_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 22 matching lines @@
 typedef union _XEvent XEvent;
 
 namespace ui {
 
 // CrOS touchpad metrics gesture types
 enum GestureMetricsType {
   kGestureMetricsTypeNoisyGround = 0,
   kGestureMetricsTypeUnknown,
 };
 
+// A bitfield describing which scroll axes are enabled for a device.
+enum ScrollType {
+  SCROLL_TYPE_NO_SCROLL = 0,
+  SCROLL_TYPE_HORIZONTAL = 1 << 0,
+  SCROLL_TYPE_VERTICAL = 1 << 1,
+};
+
 // A class that extracts and tracks the input events data. It currently handles
 // mouse, touchpad and touchscreen devices.
 class EVENTS_DEVICES_EXPORT DeviceDataManagerX11 : public DeviceDataManager {
  public:
   // Enumerate additional data that one might be interested on an input event,
   // which are usually wrapped in X valuators. If you modify any of this,
   // make sure to update the kCachedAtoms data structure in the source file
   // and the k*Type[Start/End] constants used by IsCMTDataType and
   // IsTouchDataType.
   enum DataType {
@@ skipping 92 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 contains information about a ScrollClass, and
+  // report which scroll axes are contained in this event, defined by
+  // ScrollType.
+  int GetScrollClassEventDetail(const base::NativeEvent& native_event) const;
+
+  // Check if the event comes from a device that has a ScrollClass, and
+  // report which scroll axes it supports as a bit field, defined by
+  // ScrollType.
+  int GetScrollClassDeviceDetail(const base::NativeEvent& native_event) const;
+
   // 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 GetScrollClassEventDetail.
+  // Pointers shouldn't be NULL.
+  void GetScrollClassOffsets(const base::NativeEvent& native_event,
+                             double* x_offset,
+                             double* y_offset);
+
+  // 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 61 matching lines @@
   const std::vector<int>& master_pointers() const {
     return master_pointers_;
   }
 
  protected:
   // DeviceHotplugEventObserver:
   void OnKeyboardDevicesUpdated(
       const std::vector<KeyboardDevice>& devices) override;
 
  private:
+  // Information about scroll valuators
+  struct ScrollInfo {
+    struct AxisInfo {
+      // The scroll valuator number of this scroll axis.
+      int number;
+      // The scroll increment; a value of n indicates n movement equals one
+      // traditional scroll unit.
+      double increment;
+      // Current scroll position; used to find the difference between events.
+      double position;
+      // If true then scroll has been seen in this direction.
+      bool seen;
+    };
+
+    AxisInfo vertical, horizontal;
+  };
+
   DeviceDataManagerX11();
   ~DeviceDataManagerX11() override;
 
   // Initialize the XInput related system information.
   bool InitializeXInputInternal();
 
   void InitializeValuatorsForTest(int deviceid,
                                   int start_valuator,
                                   int end_valuator,
                                   double min_value,
                                   double max_value);
 
+  // Updates a device based on a Valuator class info. Returns true if the
+  // device is a possible CMT device.
+  bool UpdateValuatorClassDevice(XIValuatorClassInfo* valuator_class_info,
+                                 Atom* atoms,
+                                 int deviceid);
+
+  // Updates a device based on a Scroll class info.
+  void UpdateScrollClassDevice(XIScrollClassInfo* scroll_class_info,
+                               int deviceid);
+
+  // 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.
+  double  ExtractAndUpdateScrollOffset(

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

single space after double

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

Done.

+      DeviceDataManagerX11::ScrollInfo::AxisInfo* axis,
+      double valuator) const;
+
   static const int kMaxXIEventType = XI_LASTEVENT + 1;
   static const int kMaxSlotNum = 10;
 
   // 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_;
 
   // List of the master pointer devices.
   std::vector<int> master_pointers_;
 
   // 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 and vertical scroll valuator
+  // numbers, scroll increments and scroll position.
+  ScrollInfo scroll_data_[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_DEVICES_X11_DEVICE_DATA_MANAGER_X11_H_