Sticky keys modifies an entire scroll sequence instead of just a single event.

ui/events/x/events_x_utils.cc

 // Copyright (c) 2013 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/x/events_x_utils.h"
 
 #include <X11/extensions/XI2.h>
 #include <X11/keysym.h>
 #include <X11/X.h>
 #include <X11/Xlib.h>
 
 #include "base/logging.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/keycodes/keyboard_code_conversion_x.h"
 #include "ui/events/x/touch_factory_x11.h"
 
 namespace {
 
-const int kScrollValuatorNum = 5;
+const int kScrollValuatorNum = 8;
 const int kScrollValuatorMap[kScrollValuatorNum][4] = {
   // { valuator_index, valuator_type, min_val, max_val }
   { 0, ui::DeviceDataManager::DT_CMT_SCROLL_X, -100, 100 },
   { 1, ui::DeviceDataManager::DT_CMT_SCROLL_Y, -100, 100 },
-  { 2, ui::DeviceDataManager::DT_CMT_ORDINAL_X, -100, 100 },
-  { 3, ui::DeviceDataManager::DT_CMT_ORDINAL_Y, -100, 100 },
-  { 4, ui::DeviceDataManager::DT_CMT_FINGER_COUNT, 0, 3},
+  { 2, ui::DeviceDataManager::DT_CMT_FLING_X, -100, 100 },
+  { 3, ui::DeviceDataManager::DT_CMT_FLING_Y, -100, 100 },
+  { 4, ui::DeviceDataManager::DT_CMT_ORDINAL_X, -100, 100 },
+  { 5, ui::DeviceDataManager::DT_CMT_ORDINAL_Y, -100, 100 },
+  { 6, ui::DeviceDataManager::DT_CMT_FINGER_COUNT, 0, 3},
+  { 7, ui::DeviceDataManager::DT_CMT_FLING_STATE, 0, 1},
 };
 
 #if defined(USE_XI2_MT)
 const int kTouchValuatorNum = 3;
 const int kTouchValuatorMap[kTouchValuatorNum][4] = {
   // { valuator_index, valuator_type, min_val, max_val }
   { 0, ui::DeviceDataManager::DT_TOUCH_MAJOR, 0, 1000},
   { 1, ui::DeviceDataManager::DT_TOUCH_ORIENTATION, 0, 1},
   { 2, ui::DeviceDataManager::DT_TOUCH_PRESSURE, 0, 1000},
 };
@@ skipping 62 matching lines @@
       return Button1;
     case ui::EF_MIDDLE_MOUSE_BUTTON:
       return Button2;
     case ui::EF_RIGHT_MOUSE_BUTTON:
       return Button3;
   }
 
   return 0;
 }
 
-void InitValuatorsForXIDeviceEvent(XIDeviceEvent* xiev, int valuator_count) {
+void ClearValuatorsForXIDeviceEvent(XIDeviceEvent* xiev, int valuator_count) {
   xiev->valuators.mask_len = (valuator_count / 8) + 1;
   xiev->valuators.mask = new unsigned char[xiev->valuators.mask_len];
   memset(xiev->valuators.mask, 0, xiev->valuators.mask_len);
   xiev->valuators.values = new double[valuator_count];
 }
 
+void SetValuatorsForXIDeviceEvent(XIDeviceEvent* xiev,
+                                  const int* valuator_data,
+                                  int valuator_data_count,
+                                  int total_valuator_count,
+                                  const unsigned char* valuator_mask) {
+  ClearValuatorsForXIDeviceEvent(xiev, total_valuator_count);
+  memcpy(xiev->valuators.mask, valuator_mask, xiev->valuators.mask_len);
+  for(int i = 0; i < valuator_data_count; ++i) {
+    xiev->valuators.values[i] = valuator_data[i];
+  }
+}
+
 XEvent* CreateXInput2Event(int deviceid,
                            int evtype,
                            int tracking_id,
                            const gfx::Point& location) {
   XEvent* event = new XEvent;
   memset(event, 0, sizeof(*event));
   event->type = GenericEvent;
   event->xcookie.data = new XIDeviceEvent;
   XIDeviceEvent* xiev =
       static_cast<XIDeviceEvent*>(event->xcookie.data);
@@ skipping 58 matching lines @@
   button_event.y = 0;
   button_event.x_root = 0;
   button_event.y_root = 0;
   button_event.state = XEventState(flags);
   button_event.button = XButtonEventButton(type, flags);
   button_event.same_screen = 1;
   event->type = button_event.type;
   event->xbutton = button_event;
 }
 
-EVENTS_EXPORT void InitXMouseWheelEventForTesting(int wheel_delta,
-                                                  int flags,
-                                                  XEvent* event) {
+void InitXMouseWheelEventForTesting(int wheel_delta,
+                                    int flags,
+                                    XEvent* event) {
   InitXButtonEventForTesting(ui::ET_MOUSEWHEEL, flags, event);
   // MouseWheelEvents are not taking horizontal scrolls into account
   // at the moment.
   event->xbutton.button = wheel_delta > 0 ? Button4 : Button5;
 }
 
 ScopedXI2Event::ScopedXI2Event(XEvent* event) : event_(event) {
 }
 
 ScopedXI2Event::~ScopedXI2Event() {
   XIDeviceEvent* xiev =
       static_cast<XIDeviceEvent*>(event_->xcookie.data);
   if (xiev) {
     delete[] xiev->valuators.mask;
     delete[] xiev->valuators.values;
     delete xiev;
   }
 }
 
-EVENTS_EXPORT XEvent* CreateScrollEventForTest(
+XEvent* CreateScrollEventForTest(
     int deviceid,
     int x_offset,
     int y_offset,
     int x_offset_ordinal,
     int y_offset_ordinal,
     int finger_count) {
   XEvent* event = CreateXInput2Event(
       deviceid, XI_Motion, deviceid, gfx::Point(0, 0));
 
+  // Set the valuator data for the event. Please ensure that |valuator_mask|
+  // is the same size as the valuators mask length.
+  unsigned char valuator_mask = 0x73; // 01110011
   int valuator_data[kScrollValuatorNum] =
-      { x_offset, y_offset, x_offset_ordinal, y_offset_ordinal, finger_count };
-  XIDeviceEvent* xiev =
-      static_cast<XIDeviceEvent*>(event->xcookie.data);
-  InitValuatorsForXIDeviceEvent(xiev, kScrollValuatorNum);
-  for(int i = 0; i < kScrollValuatorNum; i++) {
-    XISetMask(xiev->valuators.mask, i);
-    xiev->valuators.values[i] = valuator_data[i];
-  }
+      { x_offset, y_offset, x_offset_ordinal, y_offset_ordinal, finger_count};
 
+  SetValuatorsForXIDeviceEvent(
+      static_cast<XIDeviceEvent*>(event->xcookie.data),
+      valuator_data,
+      5,
+      kScrollValuatorNum,
+      &valuator_mask);
   return event;
 }
 
-EVENTS_EXPORT void SetUpScrollDeviceForTest(unsigned int deviceid) {
+XEvent* CreateFlingEventForTest(
+    int deviceid,
+    int x_velocity,
+    int y_velocity,
+    int x_velocity_ordinal,
+    int y_velocity_ordinal,
+    bool is_cancel) {
+  XEvent* event = CreateXInput2Event(
+      deviceid, XI_Motion, deviceid, gfx::Point(0, 0));
+
+  // Set the valuator data for the event. Please ensure that |valuator_mask|
+  // is the same size as the valuators mask length.
+  unsigned char valuator_mask = 0xBC; // 10111100
+  int valuator_data[kScrollValuatorNum] =
+      { x_velocity, y_velocity, x_velocity_ordinal, y_velocity_ordinal,
+        is_cancel ? 1 : 0 };
+
+  SetValuatorsForXIDeviceEvent(
+      static_cast<XIDeviceEvent*>(event->xcookie.data),
+      valuator_data,
+      5,
+      kScrollValuatorNum,
+      &valuator_mask);
+  return event;
+}
+
+void SetUpScrollDeviceForTest(unsigned int deviceid) {
   std::vector<unsigned int> device_list;
   device_list.push_back(deviceid);
 
   TouchFactory::GetInstance()->SetPointerDeviceForTest(device_list);
   ui::DeviceDataManager* manager = ui::DeviceDataManager::GetInstance();
   manager->SetDeviceListForTest(device_list, device_list, device_list);
 
   for (int i = 0; i < kScrollValuatorNum; i++) {
     manager->SetDeviceValuatorForTest(
         deviceid,
         kScrollValuatorMap[i][0],
         static_cast<DeviceDataManager::DataType>(kScrollValuatorMap[i][1]),
         kScrollValuatorMap[i][2],
         kScrollValuatorMap[i][3]);
   }
 }
 
 #if defined(USE_XI2_MT)
 
 XEvent* CreateTouchEventForTest(int deviceid,
                                 int evtype,
                                 int tracking_id,
                                 const gfx::Point& location,
                                 const std::vector<Valuator>& valuators) {
   XEvent* event = CreateXInput2Event(
       deviceid, evtype, tracking_id, location);
 
   XIDeviceEvent* xiev =
       static_cast<XIDeviceEvent*>(event->xcookie.data);
-  InitValuatorsForXIDeviceEvent(xiev, valuators.size());
+  ClearValuatorsForXIDeviceEvent(xiev, valuators.size());
   int val_count = 0;
   for (int i = 0; i < kTouchValuatorNum; i++) {
     for(size_t j = 0; j < valuators.size(); j++) {
       if (valuators[j].data_type == kTouchValuatorMap[i][1]) {
         XISetMask(xiev->valuators.mask, kTouchValuatorMap[i][0]);
         xiev->valuators.values[val_count++] = valuators[j].value;
       }
     }
   }
 
@@ skipping 13 matching lines @@
           static_cast<DeviceDataManager::DataType>(kTouchValuatorMap[j][1]),
           kTouchValuatorMap[j][2],
           kTouchValuatorMap[j][3]);
     }
   }
 }
 
 #endif  // defined(USE_XI2_MT)
 
 }  // namespace ui