Move touch CTM from X into Chrome

ui/aura/window_tree_host_x11.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.
 
 #include "ui/aura/window_tree_host_x11.h"
 
 #include <strings.h>
 #include <X11/cursorfont.h>
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/Xrandr.h>
@@ skipping 170 matching lines @@
   if (ui::PlatformEventSource::GetInstance())
     ui::PlatformEventSource::GetInstance()->RemovePlatformEventDispatcher(this);
 
   DestroyCompositor();
   DestroyDispatcher();
   XDestroyWindow(xdisplay_, xwindow_);
 }
 
 bool WindowTreeHostX11::CanDispatchEvent(const ui::PlatformEvent& event) {
   ::Window target = FindEventTarget(event);
   return target == xwindow_ || target == x_root_window_;

[sadrul, 2014/04/30 16:58:58]

You should update this function to decide whether or not the touch-event should
be dispatched to this window-tree. (or the Ash implementation should override
this to make that decision)

[Yufeng Shen (Slow to review), 2014/04/30 19:16:44]

Perfect. 
Added the logic in AshWindowTreeHostX11::CanDispatchEvent()

 }
 
 uint32_t WindowTreeHostX11::DispatchEvent(const ui::PlatformEvent& event) {
   XEvent* xev = event;
   if (FindEventTarget(xev) == x_root_window_) {
     if (xev->type == GenericEvent)
       DispatchXI2Event(xev);
     return ui::POST_DISPATCH_NONE;
   }
 
@@ skipping 290 matching lines @@
 void WindowTreeHostX11::OnCursorVisibilityChangedNative(bool show) {
 }
 
 ui::EventProcessor* WindowTreeHostX11::GetEventProcessor() {
   return dispatcher();
 }
 
 void WindowTreeHostX11::DispatchXI2Event(const base::NativeEvent& event) {
   ui::TouchFactory* factory = ui::TouchFactory::GetInstance();
   XEvent* xev = event;
+  XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(xev->xcookie.data);
   if (!factory->ShouldProcessXI2Event(xev))
     return;
 
   TRACE_EVENT1("input", "WindowTreeHostX11::DispatchXI2Event",
                "event_latency_us",
                (ui::EventTimeForNow() - ui::EventTimeFromNative(event)).
                  InMicroseconds());
 
   ui::EventType type = ui::EventTypeFromNative(xev);
   XEvent last_event;
   int num_coalesced = 0;
 
   switch (type) {
     case ui::ET_TOUCH_MOVED:
     case ui::ET_TOUCH_PRESSED:
     case ui::ET_TOUCH_CANCELLED:
     case ui::ET_TOUCH_RELEASED: {
-#if defined(OS_CHROMEOS)
       // Bail out early before generating a ui::TouchEvent if this event
       // is not within the range of this RootWindow. Converting an xevent
       // to ui::TouchEvent might change the state of the global touch tracking
       // state, e.g. touch release event can remove the touch id from the
       // record, and doing this multiple time when there are multiple
       // RootWindow will cause problem. So only generate the ui::TouchEvent
       // when we are sure it belongs to this RootWindow.
-      if (base::SysInfo::IsRunningOnChromeOS() &&
-          !bounds().Contains(ui::EventLocationFromNative(xev)))
+      if (!IsTouchEventTargetingThisRootWindow(xev))
         return;
-#endif
       ui::TouchEvent touchev(xev);
+      ui::DeviceDataManager::GetInstance()->CalibrateTouchEvent(
+          &touchev, xiev->deviceid, bounds_);
       TranslateAndDispatchLocatedEvent(&touchev);
       break;
     }
     case ui::ET_MOUSE_MOVED:
     case ui::ET_MOUSE_DRAGGED:
     case ui::ET_MOUSE_PRESSED:
     case ui::ET_MOUSE_RELEASED:
     case ui::ET_MOUSE_ENTERED:
     case ui::ET_MOUSE_EXITED: {
       if (type == ui::ET_MOUSE_MOVED || type == ui::ET_MOUSE_DRAGGED) {
@@ skipping 43 matching lines @@
   XDefineCursor(xdisplay_, xwindow_, cursor.platform());
 }
 
 void WindowTreeHostX11::OnConfigureNotify() {}
 
 void WindowTreeHostX11::TranslateAndDispatchLocatedEvent(
     ui::LocatedEvent* event) {
   SendEventToProcessor(event);
 }
 
+bool WindowTreeHostX11::IsTouchEventTargetingThisRootWindow(XEvent* xev) {
+#if defined(OS_CHROMEOS)
+  XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(xev->xcookie.data);
+  int64 touch_display_id =
+      ui::DeviceDataManager::GetInstance()->GetDisplayForTouchDevice(
+          xiev->deviceid);
+  // If we don't have record of display id for this touch device, check
+  // that if the event is within the bound of the root window. Note
+  // that in multi-monitor case, the event position is in framebuffer
+  // space so the bounds check will not work so well.
+  if (touch_display_id == gfx::Display::kInvalidDisplayID) {
+    if (base::SysInfo::IsRunningOnChromeOS() &&
+        !bounds_.Contains(ui::EventLocationFromNative(xev)))
+      return false;
+  } else if (touch_display_id != display_ids().first &&
+             touch_display_id != display_ids().second) {
+    return false;
+  }

[oshima, 2014/04/30 16:19:05]

Can you move chromeos specific code to ash/host/ash_window_tree_host_x11 ?

[Yufeng Shen (Slow to review), 2014/04/30 16:42:42]

The thing is IsTouchEventTargetingThisRootWindow(xev) has to be called before 
ui::TouchEvent touchev(xev) in DispatchXI2Event()

Maybe I should make IsTouchEventTargetingThisRootWindow virtual 
and move this into the AshWindowTreeHostX11's implementation of
IsTouchEventTargetingThisRootWindow ?

[Yufeng Shen (Slow to review), 2014/04/30 19:16:44]

as Sadrul suggested, moved this into AshWindowTreeHostX11::CanDispatchEvent()

+#endif  // defined(OS_CHROMEOS)
+  return true;
+}
+
 // static
 WindowTreeHost* WindowTreeHost::Create(const gfx::Rect& bounds) {
   return new WindowTreeHostX11(bounds);
 }
 
 // static
 gfx::Size WindowTreeHost::GetNativeScreenSize() {
   ::XDisplay* xdisplay = gfx::GetXDisplay();
   return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0));
 }
 
 namespace test {
 
 void SetUseOverrideRedirectWindowByDefault(bool override_redirect) {
   default_override_redirect = override_redirect;
 }
 
 }  // namespace test
 }  // namespace aura