Disable touch calibration on external touchscreen.

ui/base/events/event.h

 // 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.
 
 #ifndef UI_BASE_EVENTS_EVENT_H_
 #define UI_BASE_EVENTS_EVENT_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/event_types.h"
 #include "base/logging.h"
+#include "base/memory/singleton.h"
 #include "base/time.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/events/event_constants.h"
 #include "ui/base/gestures/gesture_types.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/ui_export.h"
 #include "ui/gfx/point.h"
 
 namespace gfx {
 class Transform;
@@ skipping 415 matching lines @@
   // The amount to scroll. This is in multiples of kWheelDelta.
   // Note: offset() > 0 means scroll up / left.
   int offset() const { return offset_; }
 
  private:
   int offset_;
 
   DISALLOW_COPY_AND_ASSIGN(MouseWheelEvent);
 };
 
+#if defined(USE_XI2_MT)
+// A singleton, which reads touch event calibration parameters
+// from the command line once - in constructor.
+// These parameters are then used in Calibrate() to compensate
+// for the bezels on the internal touchscreen.
+class TouchCoordinatesCalibrator {

[Ben Goodger (Google), 2013/03/15 03:36:35]

can this and the calibrate function below move to event_utils instead?

[ynovikov, 2013/03/15 18:34:33]

Technically, they can, but I fail to see the advantage of that, while I can see
many disadvantages:
1. event_utils deal with NativeEvent, while I need at least LocatedEvent, while
the code is really specific only to TouchEvent.
2. Calibrate is currently a member of TouchEvent, which makes a lot of sense,
since only TouchEvents need calibration. event_utils offer global functions,
which is not as good an encapsulation as a class member.
3. This code has several dependencies, like LocatedEvent and Rect, which are not
there in event_utils, but already are in event, so why add them in event_utils
as well?
4. This code is ChromeOS specific (for example it uses a command line flag which
will be there only if USE_XI2_MT is defined), while event_utils seem to be
platform-independent.

+ public:
+  static TouchCoordinatesCalibrator* GetInstance();
+  // Modify the location of the |event|,
+  // expanding it from |bounds| to (|bounds| + bezels).
+  // Required when touchscreen is bigger than screen (i.e. has bezels),
+  // because we receive events in touchscreen coordinates,
+  // which need to be expanded when converting to screen coordinates,
+  // so that location on bezels will be outside of screen area.
+  void Calibrate(TouchEvent* event, const gfx::Rect& bounds);
+ private:
+  TouchCoordinatesCalibrator();
+  friend struct DefaultSingletonTraits<TouchCoordinatesCalibrator>;
+
+  // The calibration values for the four border sides.
+  int left_;
+  int right_;
+  int top_;
+  int bottom_;
+
+  DISALLOW_COPY_AND_ASSIGN(TouchCoordinatesCalibrator);
+};
+#endif  // defined(USE_XI2_MT)
+
 class UI_EXPORT TouchEvent : public LocatedEvent {
  public:
   explicit TouchEvent(const base::NativeEvent& native_event);
 
   // Create a new TouchEvent which is identical to the provided model.
   // If source / target windows are provided, the model location will be
   // converted from |source| coordinate system to |target| coordinate system.
   template <class T>
   TouchEvent(const TouchEvent& model, T* source, T* target)
       : LocatedEvent(model, source, target),
@@ skipping 25 matching lines @@
   float radius_x() const { return radius_x_; }
   float radius_y() const { return radius_y_; }
   float rotation_angle() const { return rotation_angle_; }
   float force() const { return force_; }
 
   // Relocate the touch-point to a new |origin|.
   // This is useful when touch event is in X Root Window coordinates,
   // and it needs to be mapped into Aura Root Window coordinates.
   void Relocate(const gfx::Point& origin);
 
+#if defined(USE_XI2_MT)
+  // Apply bezels calibration, given |bounds| screen size,
+  // and bezel sizes previously read from command line.
+  void Calibrate(const gfx::Rect& bounds);
+#endif  // defined(USE_XI2_MT)
+
   // Used for unit tests.
   void set_radius_x(const float r) { radius_x_ = r; }
   void set_radius_y(const float r) { radius_y_ = r; }
 
   // Overridden from LocatedEvent.
   virtual void UpdateForRootTransform(
       const gfx::Transform& root_transform) OVERRIDE;
 
  protected:
   void set_radius(float radius_x, float radius_y) {
@@ skipping 208 matching lines @@
   // This value is stored as a bitfield because the number of touch ids varies,
   // but we currently don't need more than 32 touches at a time.
   const unsigned int touch_ids_bitfield_;
 
   DISALLOW_COPY_AND_ASSIGN(GestureEvent);
 };
 
 }  // namespace ui
 
 #endif  // UI_BASE_EVENTS_EVENT_H_