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/Xfixes.h>
 #include <X11/extensions/XInput2.h>
@@ skipping 183 matching lines @@
       // Scale the screen area back to the full resolution of the screen.
       y = (y * resolution_y) / (resolution_y - (bottom_ + top_));
     }
 
     // Set the modified coordinate back to the event.
     if (event->root_location() == event->location()) {
       // Usually those will be equal,
       // if not, I am not sure what the correct value should be.
       event->set_root_location(gfx::Point(x, y));
     }
+
     event->set_location(gfx::Point(x, y));
 #endif  // defined(USE_XI2_MT)
   }
 
  private:
   // Overridden from base::MessagePumpObserver:
   virtual base::EventStatus WillProcessEvent(
       const base::NativeEvent& event) OVERRIDE {
 #if defined(USE_XI2_MT)
     if (event->type == GenericEvent &&
@@ skipping 28 matching lines @@
 ////////////////////////////////////////////////////////////////////////////////
 // WindowTreeHostX11
 
 WindowTreeHostX11::WindowTreeHostX11(const gfx::Rect& bounds)
     : xdisplay_(gfx::GetXDisplay()),
       xwindow_(0),
       x_root_window_(DefaultRootWindow(xdisplay_)),
       current_cursor_(ui::kCursorNull),
       window_mapped_(false),
       bounds_(bounds),
-      is_internal_display_(false),
       touch_calibrate_(new internal::TouchEventCalibrate),
       atom_cache_(xdisplay_, kAtomsToCache) {
   XSetWindowAttributes swa;
   memset(&swa, 0, sizeof(swa));
   swa.background_pixmap = None;
   swa.override_redirect = default_override_redirect;
   xwindow_ = XCreateWindow(
       xdisplay_, x_root_window_,
       bounds.x(), bounds.y(), bounds.width(), bounds.height(),
       0,               // border width
@@ skipping 139 matching lines @@
       DCHECK_EQ(xwindow_, xev->xconfigure.event);
       DCHECK_EQ(xwindow_, xev->xconfigure.window);
       // It's possible that the X window may be resized by some other means
       // than from within aura (e.g. the X window manager can change the
       // size). Make sure the root window size is maintained properly.
       gfx::Rect bounds(xev->xconfigure.x, xev->xconfigure.y,
           xev->xconfigure.width, xev->xconfigure.height);
       bool size_changed = bounds_.size() != bounds.size();
       bool origin_changed = bounds_.origin() != bounds.origin();
       bounds_ = bounds;
-      UpdateIsInternalDisplay();
       // Always update barrier and mouse location because |bounds_| might
       // have already been updated in |SetBounds|.
       if (pointer_barriers_) {
         UnConfineCursor();
         ConfineCursorToRootWindow();
       }
       if (size_changed)
         OnHostResized(bounds.size());
       if (origin_changed)
         OnHostMoved(bounds_.origin());
@@ skipping 126 matching lines @@
   }
   if (value_mask)
     XConfigureWindow(xdisplay_, xwindow_, value_mask, &changes);
 
   // Assume that the resize will go through as requested, which should be the
   // case if we're running without a window manager.  If there's a window
   // manager, it can modify or ignore the request, but (per ICCCM) we'll get a
   // (possibly synthetic) ConfigureNotify about the actual size and correct
   // |bounds_| later.
   bounds_ = bounds;
-  UpdateIsInternalDisplay();
   if (origin_changed)
     OnHostMoved(bounds.origin());
   if (size_changed || current_scale != new_scale) {
     OnHostResized(bounds.size());
   } else {
     window()->SchedulePaintInRect(window()->bounds());
   }
 }
 
 gfx::Insets WindowTreeHostX11::GetInsets() const {
@@ skipping 147 matching lines @@
 }
 
 void WindowTreeHostX11::OnCursorVisibilityChangedNative(bool show) {
   SetCrOSTapPaused(!show);
 }
 
 void WindowTreeHostX11::OnWindowInitialized(Window* window) {
 }
 
 void WindowTreeHostX11::OnHostInitialized(WindowTreeHost* host) {
-  // TODO(beng): I'm not sure that this comment makes much sense anymore??
-  // UpdateIsInternalDisplay relies on WED's kDisplayIdKey property being set
-  // available by the time WED::Init is called. (set in
-  // DisplayManager::CreateRootWindowForDisplay)
-  // Ready when NotifyHostInitialized is called from WED::Init.
   if (host != this)
     return;
-  UpdateIsInternalDisplay();
 
   // We have to enable Tap-to-click by default because the cursor is set to
   // visible in Shell::InitRootWindowController.
   SetCrOSTapPaused(false);
 }
 
 ui::EventProcessor* WindowTreeHostX11::GetEventProcessor() {
   return dispatcher();
 }
 
@@ skipping 10 matching lines @@
 
   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)))
+      // is targeting 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 is targeting this
+      // RootWindow.
+      if (!IsTouchEventTargetingThisRootWindow(xev))
         break;
-#endif  // defined(OS_CHROMEOS)
       ui::TouchEvent touchev(xev);
-#if defined(OS_CHROMEOS)
-      if (base::SysInfo::IsRunningOnChromeOS()) {
-        // X maps the touch-surface to the size of the X root-window.
-        // In multi-monitor setup, Coordinate Transformation Matrix
-        // repositions the touch-surface onto part of X root-window
-        // containing aura root-window corresponding to the touchscreen.
-        // However, if aura root-window has non-zero origin,
-        // we need to relocate the event into aura root-window coordinates.
-        touchev.Relocate(bounds_.origin());
-#if defined(USE_XI2_MT)
-        if (is_internal_display_)
-          touch_calibrate_->Calibrate(&touchev, bounds_);
-#endif  // defined(USE_XI2_MT)
-      }
-#endif  // defined(OS_CHROMEOS)
+      CalibrateTouchEvent(xev, &touchev);
       SendEventToProcessor(&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 58 matching lines @@
     // host window, then convert it back to this host window's coordinate.
     screen_position_client->ConvertHostPointToScreen(root_window, &location);
     screen_position_client->ConvertPointFromScreen(root_window, &location);
     ConvertPointToHost(&location);
     event->set_location(location);
     event->set_root_location(location);
   }
   SendEventToProcessor(event);
 }
 
-void WindowTreeHostX11::UpdateIsInternalDisplay() {
-  Window* root_window = window();
-  gfx::Screen* screen = gfx::Screen::GetScreenFor(root_window);
-  gfx::Display display = screen->GetDisplayNearestWindow(root_window);
-  is_internal_display_ = display.IsInternal();
-}
-
 void WindowTreeHostX11::SetCrOSTapPaused(bool state) {
 #if defined(OS_CHROMEOS)
   if (!ui::IsXInput2Available())
     return;
   // Temporarily pause tap-to-click when the cursor is hidden.
   Atom prop = atom_cache_.GetAtom("Tap Paused");
   unsigned char value = state;
   XIDeviceList dev_list =
       ui::DeviceListCacheX::GetInstance()->GetXI2DeviceList(xdisplay_);
 
@@ skipping 10 matching lines @@
       if (result != Success)
         continue;
       XFree(data);
       XIChangeProperty(xdisplay_, dev_list[i].deviceid, prop, XA_INTEGER, 8,
                        PropModeReplace, &value, 1);
     }
   }
 #endif
 }
 
+bool WindowTreeHostX11::IsTouchEventTargetingThisRootWindow(
+    const base::NativeEvent& event) {
+#if defined(OS_CHROMEOS)
+  XEvent* xev = event;
+  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, then
+  // fall backt to check if this touch event is within the bounds of
+  // this root window.
+  if (touch_display_id == gfx::Display::kInvalidDisplayID) {
+    if (base::SysInfo::IsRunningOnChromeOS() &&
+        !bounds_.Contains(ui::EventLocationFromNative(xev)))
+      return false;
+    // If we do have record of the display id for this touch device,
+    // then check if this touch display id is associated with this
+    // root window.
+  } else if (touch_display_id != display_ids().first &&
+             touch_display_id != display_ids().second) {
+    return false;
+  }
+#endif  // defined(OS_CHROMEOS)
+  return true;
+}
+
+void WindowTreeHostX11::CalibrateTouchEvent(const base::NativeEvent& event,
+                                            ui::TouchEvent* touchev) {
+#if defined(OS_CHROMEOS) && defined(USE_XI2_MT)
+  XEvent* xev = event;
+  XIDeviceEvent* xiev = static_cast<XIDeviceEvent*>(xev->xcookie.data);
+  int64 touch_display_id =
+      ui::DeviceDataManager::GetInstance()->GetDisplayForTouchDevice(
+          xiev->deviceid);
+  // On ChromeOS, if touch event is from internal display, we need to
+  // calibrate its location for bezel region.
+  if (base::SysInfo::IsRunningOnChromeOS() &&
+      touch_display_id == gfx::Display::InternalDisplayId()) {
+    touch_calibrate_->Calibrate(touchev, bounds_);
+  }
+#endif  // defined(OS_CHROMEOS) && defined(USE_XI2_MT)
+}
+
 // 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