Rewrite release event only if press event was rewritten for a given device.

ui/events/test/events_test_utils_x11.cc

 // Copyright 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/test/events_test_utils_x11.h"
 
 #include <X11/extensions/XI2.h>
 #include <X11/keysym.h>
 #include <X11/X.h>
 #include <X11/Xlib.h>
@@ skipping 10 matching lines @@
   return
       ((flags & ui::EF_SHIFT_DOWN) ? ShiftMask : 0) |
       ((flags & ui::EF_CONTROL_DOWN) ? ControlMask : 0) |
       ((flags & ui::EF_ALT_DOWN) ? Mod1Mask : 0) |
       ((flags & ui::EF_CAPS_LOCK_DOWN) ? LockMask : 0) |
       ((flags & ui::EF_LEFT_MOUSE_BUTTON) ? Button1Mask: 0) |
       ((flags & ui::EF_MIDDLE_MOUSE_BUTTON) ? Button2Mask: 0) |
       ((flags & ui::EF_RIGHT_MOUSE_BUTTON) ? Button3Mask: 0);
 }
 
+/*
+int XButtonNum(int flags) {
+  if (flags & ui::EF_LEFT_MOUSE_BUTTON)
+    return 1;
+  if (flags & ui::EF_MIDDLE_MOUSE_BUTTON)
+    return 2;
+  if (flags & ui::EF_RIGHT_MOUSE_BUTTON)
+    return 3;
+  NOTREACHED();
+  return 0;
+}
+*/

[sadrul, 2014/01/30 02:14:21]

Just remove this.

[oshima, 2014/01/30 02:16:41]

oops sorry. done.

+
 // Converts EventType to XKeyEvent type.
 int XKeyEventType(ui::EventType type) {
   switch (type) {
     case ui::ET_KEY_PRESSED:
       return KeyPress;
     case ui::ET_KEY_RELEASED:
       return KeyRelease;
     default:
       return 0;
   }
 }
 
+int XIButtonEventType(ui::EventType type) {
+  switch (type) {
+    case ui::ET_MOUSEWHEEL:
+    case ui::ET_MOUSE_PRESSED:
+      // The button release X events for mouse wheels are dropped by Aura.
+      return XI_ButtonPress;
+    case ui::ET_MOUSE_RELEASED:
+      return XI_ButtonRelease;
+    default:
+      NOTREACHED();
+      return 0;
+  }
+}
+
 // Converts EventType to XButtonEvent type.
 int XButtonEventType(ui::EventType type) {
   switch (type) {
     case ui::ET_MOUSEWHEEL:
     case ui::ET_MOUSE_PRESSED:
       // The button release X events for mouse wheels are dropped by Aura.
       return ButtonPress;
     case ui::ET_MOUSE_RELEASED:
       return ButtonRelease;
     default:
@@ skipping 14 matching lines @@
 }
 
 // Converts Aura event type and flag to X button event.
 unsigned int XButtonEventButton(ui::EventType type,
                                 int flags) {
   // Aura events don't keep track of mouse wheel button, so just return
   // the first mouse wheel button.
   if (type == ui::ET_MOUSEWHEEL)
     return Button4;
 
-  switch (flags) {
-    case ui::EF_LEFT_MOUSE_BUTTON:
-      return Button1;
-    case ui::EF_MIDDLE_MOUSE_BUTTON:
-      return Button2;
-    case ui::EF_RIGHT_MOUSE_BUTTON:
-      return Button3;
-  }
+  if (flags & ui::EF_LEFT_MOUSE_BUTTON)
+    return Button1;
+  if (flags & ui::EF_MIDDLE_MOUSE_BUTTON)
+    return Button2;
+  if (flags & ui::EF_RIGHT_MOUSE_BUTTON)
+    return Button3;
 
   return 0;
 }
 
 void InitValuatorsForXIDeviceEvent(XIDeviceEvent* xiev) {
   int valuator_count = ui::DeviceDataManager::DT_LAST_ENTRY;
   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];
 }
 
 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);
   memset(xiev, 0, sizeof(XIDeviceEvent));
   xiev->deviceid = deviceid;
   xiev->sourceid = deviceid;
   xiev->evtype = evtype;
   xiev->detail = tracking_id;
   xiev->event_x = location.x();
   xiev->event_y = location.y();
-
+  if (evtype == XI_ButtonPress || evtype == XI_ButtonRelease) {
+    xiev->buttons.mask_len = 8;
+    xiev->buttons.mask = new unsigned char[xiev->buttons.mask_len];
+    memset(xiev->buttons.mask, 0, xiev->buttons.mask_len);
+  }
   return event;
 }
 
 }  // namespace
 
 namespace ui {
 
 ScopedXI2Event::ScopedXI2Event() {}
 ScopedXI2Event::~ScopedXI2Event() {
   Cleanup();
@@ skipping 17 matching lines @@
   event_->xkey.subwindow = 0;
   event_->xkey.x = 0;
   event_->xkey.y = 0;
   event_->xkey.x_root = 0;
   event_->xkey.y_root = 0;
   event_->xkey.state = XEventState(flags);
   event_->xkey.keycode = XKeyEventKeyCode(key_code, flags, display);
   event_->xkey.same_screen = 1;
 }
 
+void ScopedXI2Event::InitGenericButtonEvent(int deviceid,
+                                            EventType type,
+                                            int flags) {
+  Cleanup();
+  event_.reset(CreateXInput2Event(deviceid,
+                                  XIButtonEventType(type), 0, gfx::Point()));
+  XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(event_->xcookie.data);
+  xievent->mods.effective = XEventState(flags);
+  xievent->detail = XButtonEventButton(type, flags);
+  XISetMask(xievent->buttons.mask, xievent->detail);
+}
+
 void ScopedXI2Event::InitButtonEvent(EventType type,
                                      int flags) {
   Cleanup();
   event_.reset(new XEvent);
   memset(event_.get(), 0, sizeof(XEvent));
   event_->type = XButtonEventType(type);
   CHECK_NE(0, event_->type);
   event_->xbutton.serial = 0;
   event_->xbutton.send_event = 0;
   event_->xbutton.display = gfx::GetXDisplay();
@@ skipping 69 matching lines @@
   SetUpValuators(valuators);
 }
 
 void ScopedXI2Event::Cleanup() {
   if (event_.get() && event_->type == GenericEvent) {
     XIDeviceEvent* xiev =
         static_cast<XIDeviceEvent*>(event_->xcookie.data);
     if (xiev) {
       delete[] xiev->valuators.mask;
       delete[] xiev->valuators.values;
+      delete[] xiev->buttons.mask;
       delete xiev;
     }
   }
   event_.reset();
 }
 
 void ScopedXI2Event::SetUpValuators(const std::vector<Valuator>& valuators) {
   CHECK(event_.get());
   CHECK_EQ(GenericEvent, event_->type);
   XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(event_->xcookie.data);
@@ skipping 14 matching lines @@
   manager->SetDeviceListForTest(std::vector<unsigned int>(), device_list);
 }
 
 void SetUpTouchDevicesForTest(const std::vector<unsigned int>& devices) {
   TouchFactory::GetInstance()->SetTouchDeviceForTest(devices);
   ui::DeviceDataManager* manager = ui::DeviceDataManager::GetInstance();
   manager->SetDeviceListForTest(devices, std::vector<unsigned int>());
 }
 
 }  // namespace ui