Disable touch calibration on external touchscreen.

ui/aura/root_window_host_linux.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/root_window_host_linux.h"
 
 #include <strings.h>
 #include <X11/cursorfont.h>
 #include <X11/extensions/Xfixes.h>
 #include <X11/extensions/XInput2.h>
@@ skipping 43 matching lines @@
 using std::min;
 
 namespace aura {
 
 namespace {
 
 // Standard Linux mouse buttons for going back and forward.
 const int kBackMouseButton = 8;
 const int kForwardMouseButton = 9;
 
-// These are the same values that are used to calibrate touch events in
-// |CalibrateTouchCoordinates| (in ui/base/x/events_x.cc).
-// TODO(sad|skuhne): Remove the duplication of values (http://crbug.com/147605)
-const int kXRootWindowPaddingLeft = 40;
-const int kXRootWindowPaddingRight = 40;
-const int kXRootWindowPaddingBottom = 30;
-const int kXRootWindowPaddingTop = 0;
-
 const char* kAtomsToCache[] = {
   "WM_DELETE_WINDOW",
   "_NET_WM_PING",
   "_NET_WM_PID",
   "WM_S0",
 #if defined(OS_CHROMEOS)
   "Tap Paused",  // Defined in the gestures library.
 #endif
   NULL
 };
@@ skipping 86 matching lines @@
       return false;
   }
 }
 
 }  // namespace
 
 namespace internal {
 
 // A very lightweight message-pump observer that routes all the touch events to
 // the X root window so that they can be calibrated properly.
-class TouchEventCalibrate : public base::MessagePumpObserver {
+class TouchEventRouter : public base::MessagePumpObserver {
  public:
-  TouchEventCalibrate() {
+  TouchEventRouter() {
     MessageLoopForUI::current()->AddObserver(this);
   }
 
-  virtual ~TouchEventCalibrate() {
+  virtual ~TouchEventRouter() {
     MessageLoopForUI::current()->RemoveObserver(this);
   }
 
  private:
   // Overridden from base::MessagePumpObserver:
   virtual base::EventStatus WillProcessEvent(
       const base::NativeEvent& event) OVERRIDE {
 #if defined(USE_XI2_MT)
     if (event->type == GenericEvent &&
         (event->xgeneric.evtype == XI_TouchBegin ||
          event->xgeneric.evtype == XI_TouchUpdate ||
          event->xgeneric.evtype == XI_TouchEnd)) {
       XIDeviceEvent* xievent = static_cast<XIDeviceEvent*>(event->xcookie.data);
       xievent->event = xievent->root;
       xievent->event_x = xievent->root_x;
       xievent->event_y = xievent->root_y;
     }
 #endif
     return base::EVENT_CONTINUE;
   }
 
   virtual void DidProcessEvent(const base::NativeEvent& event) OVERRIDE {
   }
 
-  DISALLOW_COPY_AND_ASSIGN(TouchEventCalibrate);
+  DISALLOW_COPY_AND_ASSIGN(TouchEventRouter);
 };
 
 }  // namespace internal
 
 ////////////////////////////////////////////////////////////////////////////////
 // RootWindowHostLinux::MouseMoveFilter filters out the move events that
 // jump back and forth between two points. This happens when sub pixel mouse
 // move is enabled and mouse move events could be jumping between two neighbor
 // pixels, e.g. move(0,0), move(1,0), move(0,0), move(1,0) and on and on.
 // The filtering is done by keeping track of the last two event locations and
@@ skipping 38 matching lines @@
 RootWindowHostLinux::RootWindowHostLinux(const gfx::Rect& bounds)
     : delegate_(NULL),
       xdisplay_(base::MessagePumpAuraX11::GetDefaultXDisplay()),
       xwindow_(0),
       x_root_window_(DefaultRootWindow(xdisplay_)),
       current_cursor_(ui::kCursorNull),
       window_mapped_(false),
       bounds_(bounds),
       is_internal_display_(false),
       focus_when_shown_(false),
-      touch_calibrate_(new internal::TouchEventCalibrate),
+      touch_router_(new internal::TouchEventRouter),
       mouse_move_filter_(new MouseMoveFilter),
       atom_cache_(xdisplay_, kAtomsToCache) {
   XSetWindowAttributes swa;
   memset(&swa, 0, sizeof(swa));
   swa.background_pixmap = None;
   xwindow_ = XCreateWindow(
       xdisplay_, x_root_window_,
       bounds.x(), bounds.y(), bounds.width(), bounds.height(),
       0,               // border width
       CopyFromParent,  // depth
@@ skipping 618 matching lines @@
       num_coalesced = ui::CoalescePendingMotionEvents(xev, &last_event);
       if (num_coalesced > 0)
         xev = &last_event;
       // fallthrough
     case ui::ET_TOUCH_PRESSED:
     case ui::ET_TOUCH_CANCELLED:
     case ui::ET_TOUCH_RELEASED: {
       ui::TouchEvent touchev(xev);
 #if defined(OS_CHROMEOS)
       if (base::chromeos::IsRunningOnChromeOS()) {
-        if (!bounds_.Contains(touchev.location())) {
-          // This might still be in the bezel region.
-          gfx::Rect expanded(bounds_);
-          expanded.Inset(-kXRootWindowPaddingLeft,
-                         -kXRootWindowPaddingTop,
-                         -kXRootWindowPaddingRight,
-                         -kXRootWindowPaddingBottom);
-          if (!expanded.Contains(touchev.location()))
-            break;
-        }
+        if (!bounds_.Contains(touchev.location()))
+          break;
+        // 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_)
+          touchev.Calibrate(bounds_);
+#endif  // defined(USE_XI2_MT)
       }
-      // 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());
 #endif  // defined(OS_CHROMEOS)
       delegate_->OnHostTouchEvent(&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: {
@@ skipping 110 matching lines @@
   return new RootWindowHostLinux(bounds);
 }
 
 // static
 gfx::Size RootWindowHost::GetNativeScreenSize() {
   ::Display* xdisplay = base::MessagePumpAuraX11::GetDefaultXDisplay();
   return gfx::Size(DisplayWidth(xdisplay, 0), DisplayHeight(xdisplay, 0));
 }
 
 }  // namespace aura