ui::LocatedEvent location() returns gfx::PointF

ui/events/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/events/gestures/gesture_point.h"
 
 #include <cmath>
 
 #include "base/basictypes.h"
 #include "ui/events/event.h"
@@ skipping 37 matching lines @@
 }
 
 gfx::Vector2dF GesturePoint::ScrollDelta() const {
   return last_touch_position_ - second_last_touch_position_;
 }
 
 void GesturePoint::UpdateValues(const TouchEvent& event) {
   const int64 event_timestamp_microseconds =
       event.time_stamp().InMicroseconds();
   if (event.type() == ui::ET_TOUCH_MOVED) {
-    velocity_calculator_.PointSeen(event.location().x(),
-                                   event.location().y(),
+    velocity_calculator_.PointSeen(gfx::ToFlooredPoint(event.location()).x(),
+                                   gfx::ToFlooredPoint(event.location()).y(),
                                    event_timestamp_microseconds);
     gfx::Vector2d sd(ScrollVelocityDirection(velocity_calculator_.XVelocity()),
                      ScrollVelocityDirection(velocity_calculator_.YVelocity()));
   }
 
   last_touch_time_ = event.time_stamp().InSecondsF();
-  last_touch_position_ = event.location_f();
+  last_touch_position_ = event.location();
 
   if (event.type() == ui::ET_TOUCH_PRESSED) {
     ResetVelocity();
     clear_enclosing_rectangle();
     first_touch_time_ = last_touch_time_;
-    first_touch_position_ = event.location();
+    first_touch_position_ = gfx::ToFlooredPoint(event.location());
     second_last_touch_position_ = last_touch_position_;
     second_last_touch_time_ = last_touch_time_;
-    velocity_calculator_.PointSeen(event.location().x(),
-                                   event.location().y(),
+    velocity_calculator_.PointSeen(gfx::ToFlooredPoint(event.location()).x(),
+                                   gfx::ToFlooredPoint(event.location()).y(),
                                    event_timestamp_microseconds);
   }
 
   UpdateEnclosingRectangle(event);
 }
 
 void GesturePoint::UpdateForTap() {
   // Update the tap-position and time, and reset every other state.
   second_last_tap_position_ = last_tap_position_;
   second_last_tap_time_ = last_tap_time_;
   last_tap_time_ = last_touch_time_;
   last_tap_position_ = last_touch_position_;
 }
 
 void GesturePoint::UpdateForScroll() {
   second_last_touch_position_ = last_touch_position_;
   second_last_touch_time_ = last_touch_time_;
 }
 
 bool GesturePoint::IsInClickWindow(const TouchEvent& event) const {
   return IsInClickTimeWindow() && IsInsideTouchSlopRegion(event);
 }
 
 bool GesturePoint::IsInDoubleClickWindow(const TouchEvent& event) const {
   return IsInClickAggregateTimeWindow(last_tap_time_, last_touch_time_) &&
          IsPointInsideDoubleTapTouchSlopRegion(
-             event.location(), last_tap_position_);
+             gfx::ToFlooredPoint(event.location()), last_tap_position_);
 }
 
 bool GesturePoint::IsInTripleClickWindow(const TouchEvent& event) const {
   return IsInClickAggregateTimeWindow(last_tap_time_, last_touch_time_) &&
          IsInClickAggregateTimeWindow(second_last_tap_time_, last_tap_time_) &&
          IsPointInsideDoubleTapTouchSlopRegion(
-             event.location(), last_tap_position_) &&
+             gfx::ToFlooredPoint(event.location()), last_tap_position_) &&
          IsPointInsideDoubleTapTouchSlopRegion(last_tap_position_,
-                                      second_last_tap_position_);
+                                               second_last_tap_position_);
 }
 
 bool GesturePoint::IsInScrollWindow(const TouchEvent& event) const {
   return event.type() == ui::ET_TOUCH_MOVED &&
          !IsInsideTouchSlopRegion(event);
 }
 
 bool GesturePoint::IsInFlickWindow(const TouchEvent& event) {
   return IsOverMinFlickSpeed() &&
          event.type() != ui::ET_TOUCH_CANCELLED;
@@ skipping 47 matching lines @@
       GestureConfiguration::max_touch_down_duration_in_seconds_for_click();
 }
 
 bool GesturePoint::IsInClickAggregateTimeWindow(double before,
                                                 double after) const {
   double duration =  after - before;
   return duration < GestureConfiguration::max_seconds_between_double_click();
 }
 
 bool GesturePoint::IsInsideTouchSlopRegion(const TouchEvent& event) const {
-  const gfx::PointF& p1 = event.location();
+  const gfx::PointF& p1 = gfx::ToFlooredPoint(event.location());
   const gfx::PointF& p2 = first_touch_position_;
   float dx = p1.x() - p2.x();
   float dy = p1.y() - p2.y();
   float distance = dx * dx + dy * dy;
   return distance < max_touch_move_in_pixels_for_click_squared_;
 }
 
 bool GesturePoint::IsPointInsideDoubleTapTouchSlopRegion(gfx::PointF p1,
                                                          gfx::PointF p2) const {
   float dx = p1.x() - p2.x();
@@ skipping 20 matching lines @@
   // 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.radius_x() || event.radius_y())
     radius = std::max(event.radius_x(), event.radius_y());
   else
     radius = GestureConfiguration::default_radius();
 
-  gfx::RectF rect(event.location_f().x() - radius,
-                  event.location_f().y() - radius,
+  gfx::RectF rect(event.location().x() - radius,
+                  event.location().y() - radius,
                   radius * 2,
                   radius * 2);
   if (IsInClickWindow(event))
     enclosing_rect_.Union(rect);
   else
     enclosing_rect_ = rect;
 }
 
 }  // namespace ui