linux aura: Support touch events.

ui/base/x/x11_util.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.
 
 // This file defines utility functions for X11 (Linux only). This code has been
 // ported from XCB since we can't use XCB on Ubuntu while its 32-bit support
 // remains woefully incomplete.
 
 #include "ui/base/x/x11_util.h"
 
@@ skipping 426 matching lines @@
 }
 
 
 int CoalescePendingMotionEvents(const XEvent* xev,
                                 XEvent* last_event) {
   XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(xev->xcookie.data);
   int num_coalesced = 0;
   XDisplay* display = xev->xany.display;
   int event_type = xev->xgeneric.evtype;
 
-  DCHECK_EQ(event_type, XI_Motion);
+  DCHECK(event_type == XI_Motion || event_type == XI_TouchUpdate);
 
   while (XPending(display)) {
     XEvent next_event;
     XPeekEvent(display, &next_event);
 
     // If we can't get the cookie, abort the check.
     if (!XGetEventData(next_event.xgeneric.display, &next_event.xcookie))
       return num_coalesced;
 
     // If this isn't from a valid device, throw the event away, as
     // that's what the message pump would do. Device events come in pairs
     // with one from the master and one from the slave so there will
     // always be at least one pending.
     if (!ui::TouchFactory::GetInstance()->ShouldProcessXI2Event(&next_event)) {
       XFreeEventData(display, &next_event.xcookie);
       XNextEvent(display, &next_event);
       continue;
     }
 
     if (next_event.type == GenericEvent &&
         next_event.xgeneric.evtype == event_type &&
         !ui::DeviceDataManager::GetInstance()->IsCMTGestureEvent(
             &next_event)) {
       XIDeviceEvent* next_xievent =
           static_cast<XIDeviceEvent*>(next_event.xcookie.data);
       // Confirm that the motion event is targeted at the same window
       // and that no buttons or modifiers have changed.
       if (xievent->event == next_xievent->event &&
           xievent->child == next_xievent->child &&
+          xievent->detail == next_xievent->detail &&
           xievent->buttons.mask_len == next_xievent->buttons.mask_len &&
           (memcmp(xievent->buttons.mask,
                   next_xievent->buttons.mask,
                   xievent->buttons.mask_len) == 0) &&
           xievent->mods.base == next_xievent->mods.base &&
           xievent->mods.latched == next_xievent->mods.latched &&
           xievent->mods.locked == next_xievent->mods.locked &&
           xievent->mods.effective == next_xievent->mods.effective) {
         XFreeEventData(display, &next_event.xcookie);
         // Free the previous cookie.
         if (num_coalesced > 0)
           XFreeEventData(display, &last_event->xcookie);
         // Get the event and its cookie data.
         XNextEvent(display, last_event);
         XGetEventData(display, &last_event->xcookie);
         ++num_coalesced;
         continue;
       }
     }
     // This isn't an event we want so free its cookie data.
     XFreeEventData(display, &next_event.xcookie);
     break;
   }
 
-  if (num_coalesced > 0) {
+  if (event_type == XI_Motion && num_coalesced > 0) {
     base::TimeDelta delta = ui::EventTimeFromNative(last_event) -
         ui::EventTimeFromNative(const_cast<XEvent*>(xev));
     UMA_HISTOGRAM_COUNTS_10000("Event.CoalescedCount.Mouse", num_coalesced);
     UMA_HISTOGRAM_TIMES("Event.CoalescedLatency.Mouse", delta);
   }
   return num_coalesced;
 }
 #endif
 
 void HideHostCursor() {
@@ skipping 1020 matching lines @@
       << "request_code " << static_cast<int>(error_event.request_code) << ", "
       << "minor_code " << static_cast<int>(error_event.minor_code)
       << " (" << request_str << ")";
 }
 
 // ----------------------------------------------------------------------------
 // End of x11_util_internal.h
 
 
 }  // namespace ui