Remove TouchEvent interface, and rename TouchEventImpl to TouchEvent

ui/base/gestures/gesture_point.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/base/gestures/gesture_point.h"
 
 #include <cmath>
 
 #include "base/basictypes.h"
+#include "ui/base/event.h"
 #include "ui/base/events.h"
 #include "ui/base/gestures/gesture_configuration.h"
 #include "ui/base/gestures/gesture_util.h"
 #include "ui/base/gestures/gesture_types.h"
 
 namespace ui {
 
 GesturePoint::GesturePoint()
     : first_touch_time_(0.0),
       last_touch_time_(0.0),
@@ skipping 12 matching lines @@
   point_id_ = -1;
   clear_enclosing_rectangle();
 }
 
 void GesturePoint::ResetVelocity() {
   velocity_calculator_.ClearHistory();
 }
 
 void GesturePoint::UpdateValues(const TouchEvent& event) {
   const int64 event_timestamp_microseconds =
-      event.GetTimestamp().InMicroseconds();
-  if (event.GetEventType() == ui::ET_TOUCH_MOVED) {
-    velocity_calculator_.PointSeen(event.GetLocation().x(),
-                                   event.GetLocation().y(),
+      event.time_stamp().InMicroseconds();
+  if (event.type() == ui::ET_TOUCH_MOVED) {
+    velocity_calculator_.PointSeen(event.location().x(),
+                                   event.location().y(),
                                    event_timestamp_microseconds);
   }
 
-  last_touch_time_ = event.GetTimestamp().InSecondsF();
-  last_touch_position_ = event.GetLocation();
+  last_touch_time_ = event.time_stamp().InSecondsF();
+  last_touch_position_ = event.location();
 
-  if (event.GetEventType() == ui::ET_TOUCH_PRESSED) {
+  if (event.type() == ui::ET_TOUCH_PRESSED) {
     first_touch_time_ = last_touch_time_;
-    first_touch_position_ = event.GetLocation();
+    first_touch_position_ = event.location();
     velocity_calculator_.ClearHistory();
-    velocity_calculator_.PointSeen(event.GetLocation().x(),
-                                   event.GetLocation().y(),
+    velocity_calculator_.PointSeen(event.location().x(),
+                                   event.location().y(),
                                    event_timestamp_microseconds);
     clear_enclosing_rectangle();
   }
 
   UpdateEnclosingRectangle(event);
 }
 
 void GesturePoint::UpdateForTap() {
   // Update the tap-position and time, and reset every other state.
   last_tap_time_ = last_touch_time_;
@@ skipping 11 matching lines @@
 bool GesturePoint::IsInClickWindow(const TouchEvent& event) const {
   return IsInClickTimeWindow() && IsInsideManhattanSquare(event);
 }
 
 bool GesturePoint::IsInDoubleClickWindow(const TouchEvent& event) const {
   return IsInSecondClickTimeWindow() &&
          IsSecondClickInsideManhattanSquare(event);
 }
 
 bool GesturePoint::IsInScrollWindow(const TouchEvent& event) const {
-  return event.GetEventType() == ui::ET_TOUCH_MOVED &&
+  return event.type() == ui::ET_TOUCH_MOVED &&
          !IsInsideManhattanSquare(event);
 }
 
 bool GesturePoint::IsInFlickWindow(const TouchEvent& event) {
   return IsOverMinFlickSpeed() &&
-         event.GetEventType() != ui::ET_TOUCH_CANCELLED;
+         event.type() != ui::ET_TOUCH_CANCELLED;
 }
 
 bool GesturePoint::DidScroll(const TouchEvent& event, int dist) const {
   return abs(last_touch_position_.x() - first_touch_position_.x()) > dist ||
          abs(last_touch_position_.y() - first_touch_position_.y()) > dist;
 }
 
 bool GesturePoint::HasEnoughDataToEstablishRail() const {
   int dx = x_delta();
   int dy = y_delta();
@@ skipping 35 matching lines @@
       duration <
       GestureConfiguration::max_touch_down_duration_in_seconds_for_click();
 }
 
 bool GesturePoint::IsInSecondClickTimeWindow() const {
   double duration =  last_touch_time_ - last_tap_time_;
   return duration < GestureConfiguration::max_seconds_between_double_click();
 }
 
 bool GesturePoint::IsInsideManhattanSquare(const TouchEvent& event) const {
-  return ui::gestures::IsInsideManhattanSquare(event.GetLocation(),
+  return ui::gestures::IsInsideManhattanSquare(event.location(),
                                                first_touch_position_);
 }
 
 bool GesturePoint::IsSecondClickInsideManhattanSquare(
     const TouchEvent& event) const {
-  return ui::gestures::IsInsideManhattanSquare(event.GetLocation(),
+  return ui::gestures::IsInsideManhattanSquare(event.location(),
                                                last_tap_position_);
 }
 
 bool GesturePoint::IsOverMinFlickSpeed() {
   return velocity_calculator_.VelocitySquared() >
       GestureConfiguration::min_flick_speed_squared();
 }
 
 void GesturePoint::UpdateEnclosingRectangle(const TouchEvent& event) {
   int radius;
 
   // Ignore this TouchEvent if it has a radius larger than the maximum
   // allowed radius size.
-  if (event.RadiusX() > GestureConfiguration::max_radius() ||
-      event.RadiusY() > GestureConfiguration::max_radius())
+  if (event.radius_x() > GestureConfiguration::max_radius() ||
+      event.radius_y() > GestureConfiguration::max_radius())
     return;
 
   // If the device provides at least one of the radius values, take the larger
   // of the two and use this as both the x radius and the y radius of the
   // touch region. Otherwise use the default radius value.
   // TODO(tdanderson): Implement a more specific check for the exact
   // information provided by the device (0-2 radii values, force, angle) and
   // use this to compute a more representative rectangular touch region.
-  if (event.RadiusX() || event.RadiusY())
-    radius = std::max(event.RadiusX(), event.RadiusY());
+  if (event.radius_x() || event.radius_y())
+    radius = std::max(event.radius_x(), event.radius_y());
   else
     radius = GestureConfiguration::default_radius();
 
-  gfx::Rect rect(event.GetLocation().x() - radius,
-                 event.GetLocation().y() - radius,
+  gfx::Rect rect(event.location().x() - radius,
+                 event.location().y() - radius,
                  radius * 2,
                  radius * 2);
   if (IsInClickWindow(event))
     enclosing_rect_ = enclosing_rect_.Union(rect);
   else
     enclosing_rect_ = rect;
 }
 
 }  // namespace ui