gfx: Make conversions from gfx::Point to PointF explicit.

ui/aura/gestures/gesture_recognizer_unittest.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 <list>
 
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/timer/timer.h"
@@ skipping 544 matching lines @@
       case ui::ET_TOUCH_RELEASED:
         touch_released_count_++;
         break;
       case ui::ET_TOUCH_PRESSED:
         touch_pressed_count_++;
         break;
       case ui::ET_TOUCH_MOVED:
         touch_moved_count_++;
         break;
       case ui::ET_TOUCH_CANCELLED:
-        cancelled_touch_points_.push_back(event->location());
+        cancelled_touch_points_.push_back(event->location_f());
         break;
       default:
         break;
     }
   }
 
   void Reset() {
     touch_released_count_ = 0;
     touch_pressed_count_ = 0;
     touch_moved_count_ = 0;
@@ skipping 97 matching lines @@
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->show_press());
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_TRUE(delegate->begin());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_FALSE(delegate->long_press());
 
   delegate->Reset();
   delegate->WaitUntilReceivedGesture(ui::ET_GESTURE_SHOW_PRESS);
   EXPECT_TRUE(delegate->show_press());
   EXPECT_FALSE(delegate->tap_down());
 
   // Make sure there is enough delay before the touch is released so that it is
   // recognized as a tap.
   delegate->Reset();
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                          kTouchId, tes.LeapForward(50));
 
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_TRUE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_TRUE(delegate->end());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
@@ skipping 11 matching lines @@
   const int kWindowWidth = 800;
   const int kWindowHeight = 600;
   const int kTouchId = 2;
   gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   // Test with no ET_TOUCH_MOVED events.
   {
      delegate->Reset();
-     ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+     ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                           kTouchId, tes.Now());
      press.set_radius_x(5);
      press.set_radius_y(12);
      DispatchEventUsingWindowDispatcher(&press);
      EXPECT_FALSE(delegate->tap());
      EXPECT_TRUE(delegate->tap_down());
      EXPECT_FALSE(delegate->tap_cancel());
      EXPECT_TRUE(delegate->begin());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
      EXPECT_FALSE(delegate->long_press());
 
      // Make sure there is enough delay before the touch is released so that it
      // is recognized as a tap.
      delegate->Reset();
-     ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+     ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                             kTouchId, tes.LeapForward(50));
      release.set_radius_x(5);
      release.set_radius_y(12);
 
      DispatchEventUsingWindowDispatcher(&release);
      EXPECT_TRUE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
      EXPECT_FALSE(delegate->tap_cancel());
      EXPECT_FALSE(delegate->begin());
      EXPECT_TRUE(delegate->end());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
 
      EXPECT_EQ(1, delegate->tap_count());
      gfx::Point actual_point(delegate->tap_location());
      EXPECT_EQ(24, delegate->bounding_box().width());
      EXPECT_EQ(24, delegate->bounding_box().height());
      EXPECT_EQ(101, actual_point.x());
      EXPECT_EQ(201, actual_point.y());
   }
 
   // Test with no ET_TOUCH_MOVED events but different touch points and radii.
   {
      delegate->Reset();
-     ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(365, 290),
+     ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(365.f, 290.f),
                           kTouchId, tes.Now());
      press.set_radius_x(8);
      press.set_radius_y(14);
      DispatchEventUsingWindowDispatcher(&press);
      EXPECT_FALSE(delegate->tap());
      EXPECT_TRUE(delegate->tap_down());
      EXPECT_FALSE(delegate->tap_cancel());
      EXPECT_TRUE(delegate->begin());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
      EXPECT_FALSE(delegate->long_press());
 
      delegate->Reset();
-     ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(367, 291),
+     ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(367.f, 291.f),
                             kTouchId, tes.LeapForward(50));
      release.set_radius_x(20);
      release.set_radius_y(13);
 
      DispatchEventUsingWindowDispatcher(&release);
      EXPECT_TRUE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
      EXPECT_FALSE(delegate->tap_cancel());
      EXPECT_FALSE(delegate->begin());
      EXPECT_TRUE(delegate->end());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
 
      EXPECT_EQ(1, delegate->tap_count());
      gfx::Point actual_point(delegate->tap_location());
      EXPECT_EQ(40, delegate->bounding_box().width());
      EXPECT_EQ(40, delegate->bounding_box().height());
      EXPECT_EQ(367, actual_point.x());
      EXPECT_EQ(291, actual_point.y());
   }
 
   // Test with a single ET_TOUCH_MOVED event.
   {
      delegate->Reset();
-     ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(46, 205),
+     ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(46.f, 205.f),
                           kTouchId, tes.Now());
      press.set_radius_x(6);
      press.set_radius_y(10);
      DispatchEventUsingWindowDispatcher(&press);
      EXPECT_FALSE(delegate->tap());
      EXPECT_TRUE(delegate->tap_down());
      EXPECT_FALSE(delegate->tap_cancel());
      EXPECT_TRUE(delegate->begin());
      EXPECT_FALSE(delegate->tap_cancel());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
      EXPECT_FALSE(delegate->long_press());
 
      delegate->Reset();
-     ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(49, 204),
-                         kTouchId, tes.LeapForward(50));
+     ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(49.f, 204.f), kTouchId,
+                         tes.LeapForward(50));
      move.set_radius_x(8);
      move.set_radius_y(12);
      DispatchEventUsingWindowDispatcher(&move);
      EXPECT_FALSE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
      EXPECT_FALSE(delegate->tap_cancel());
      EXPECT_FALSE(delegate->begin());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
      EXPECT_FALSE(delegate->long_press());
 
      delegate->Reset();
-     ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(49, 204),
+     ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(49.f, 204.f),
                             kTouchId, tes.LeapForward(50));
      release.set_radius_x(4);
      release.set_radius_y(8);
 
      DispatchEventUsingWindowDispatcher(&release);
      EXPECT_TRUE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
      EXPECT_FALSE(delegate->tap_cancel());
      EXPECT_FALSE(delegate->begin());
      EXPECT_TRUE(delegate->end());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
 
      EXPECT_EQ(1, delegate->tap_count());
      gfx::Point actual_point(delegate->tap_location());
      EXPECT_EQ(16, delegate->bounding_box().width());
      EXPECT_EQ(16, delegate->bounding_box().height());
      EXPECT_EQ(49, actual_point.x());
      EXPECT_EQ(204, actual_point.y());
   }
 
   // Test with a few ET_TOUCH_MOVED events.
   {
      delegate->Reset();
-     ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(400, 150),
+     ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(400.f, 150.f),
                           kTouchId, tes.Now());
      press.set_radius_x(7);
      press.set_radius_y(10);
      DispatchEventUsingWindowDispatcher(&press);
      EXPECT_FALSE(delegate->tap());
      EXPECT_TRUE(delegate->tap_down());
      EXPECT_FALSE(delegate->tap_cancel());
      EXPECT_TRUE(delegate->begin());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
      EXPECT_FALSE(delegate->long_press());
 
      delegate->Reset();
-     ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(397, 151),
+     ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(397.f, 151.f),
                          kTouchId, tes.LeapForward(50));
      move.set_radius_x(13);
      move.set_radius_y(12);
      DispatchEventUsingWindowDispatcher(&move);
      EXPECT_FALSE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
      EXPECT_FALSE(delegate->tap_cancel());
      EXPECT_FALSE(delegate->begin());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
      EXPECT_FALSE(delegate->long_press());
 
      delegate->Reset();
-     ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(397, 149),
+     ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::PointF(397.f, 149.f),
                           kTouchId, tes.LeapForward(50));
      move1.set_radius_x(16);
      move1.set_radius_y(16);
      DispatchEventUsingWindowDispatcher(&move1);
      EXPECT_FALSE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
      EXPECT_FALSE(delegate->tap_cancel());
      EXPECT_FALSE(delegate->begin());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
      EXPECT_FALSE(delegate->long_press());
 
      delegate->Reset();
-     ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(400, 150),
+     ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::PointF(400.f, 150.f),
                           kTouchId, tes.LeapForward(50));
      move2.set_radius_x(14);
      move2.set_radius_y(10);
      DispatchEventUsingWindowDispatcher(&move2);
      EXPECT_FALSE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
      EXPECT_FALSE(delegate->tap_cancel());
      EXPECT_FALSE(delegate->begin());
      EXPECT_FALSE(delegate->scroll_begin());
      EXPECT_FALSE(delegate->scroll_update());
      EXPECT_FALSE(delegate->scroll_end());
      EXPECT_FALSE(delegate->long_press());
 
      delegate->Reset();
-     ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(401, 149),
+     ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(401.f, 149.f),
                             kTouchId, tes.LeapForward(50));
      release.set_radius_x(8);
      release.set_radius_y(9);
 
      DispatchEventUsingWindowDispatcher(&release);
      EXPECT_TRUE(delegate->tap());
      EXPECT_FALSE(delegate->tap_down());
      EXPECT_FALSE(delegate->tap_cancel());
      EXPECT_FALSE(delegate->begin());
      EXPECT_TRUE(delegate->end());
@@ skipping 21 matching lines @@
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 5;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_2_EVENTS(delegate->events(),
                   ui::ET_GESTURE_BEGIN,
                   ui::ET_GESTURE_TAP_DOWN);
 
   // Move the touch-point enough so that it is considered as a scroll. This
   // should generate both SCROLL_BEGIN and SCROLL_UPDATE gestures.
   // The first movement is diagonal, to ensure that we have a free scroll,
   // and not a rail scroll.
@@ skipping 22 matching lines @@
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 
   tes.SendScrollEvent(event_processor(), 50, 124, kTouchId, delegate.get());
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
   EXPECT_EQ(30, delegate->scroll_x());
   EXPECT_EQ(4, delegate->scroll_y());
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 
   // Release the touch. This should end the scroll.
   delegate->Reset();
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
-                         kTouchId,
-                         tes.LeapForward(50));
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
+                         kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_2_EVENTS(delegate->events(),
                   ui::ET_SCROLL_FLING_START,
                   ui::ET_GESTURE_END);
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 }
 
 // Check that predicted scroll update positions are correct.
 TEST_F(GestureRecognizerTest, GestureEventScrollPrediction) {
   // We'll start by moving the touch point by (5, 5). We want all of that
   // distance to be consumed by the slop, so we set the slop radius to
   // sqrt(5 * 5 + 5 * 5).
   ui::GestureConfiguration::GetInstance()
       ->set_max_touch_move_in_pixels_for_click(sqrt(5.f * 5 + 5 * 5));
 
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 5;
   gfx::Rect bounds(95, 195, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
   // Tracks the total scroll since we want to verify that the correct position
   // will be scrolled to throughout the prediction.
   gfx::Vector2dF total_scroll;
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(96, 196),
-                       kTouchId, tes.Now());
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(96.f, 196.f), kTouchId,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_2_EVENTS(delegate->events(),
                   ui::ET_GESTURE_BEGIN,
                   ui::ET_GESTURE_TAP_DOWN);
   delegate->Reset();
 
   // Get rid of touch slop.
-  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(111, 211),
-                      kTouchId, tes.Now());
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(111.f, 211.f), kTouchId,
+                      tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   EXPECT_3_EVENTS(delegate->events(),
                   ui::ET_GESTURE_TAP_CANCEL,
                   ui::ET_GESTURE_SCROLL_BEGIN,
                   ui::ET_GESTURE_SCROLL_UPDATE);
   total_scroll.set_x(total_scroll.x() + delegate->scroll_x());
   total_scroll.set_y(total_scroll.y() + delegate->scroll_y());
 
   // Move the touch-point enough so that it is considered as a scroll. This
   // should generate both SCROLL_BEGIN and SCROLL_UPDATE gestures.
@@ skipping 14 matching lines @@
   total_scroll.set_y(total_scroll.y() + delegate->scroll_y());
 
   tes.LeapForward(30);
   tes.SendScrollEvent(event_processor(), 140, 215, kTouchId, delegate.get());
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
   total_scroll.set_x(total_scroll.x() + delegate->scroll_x());
   total_scroll.set_y(total_scroll.y() + delegate->scroll_y());
 
   // Release the touch. This should end the scroll.
   delegate->Reset();
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
-                         kTouchId,
-                         tes.LeapForward(50));
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
+                         kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release);
 }
 
 // Check that the bounding box during a scroll event is correct.
 TEST_F(GestureRecognizerTest, GestureEventScrollBoundingBox) {
   TimedEvents tes;
   for (int radius = 1; radius <= 10; ++radius) {
     ui::GestureConfiguration::GetInstance()->set_default_radius(radius);
     scoped_ptr<GestureEventConsumeDelegate> delegate(
         new GestureEventConsumeDelegate());
@@ skipping 46 matching lines @@
 // if the user was on a horizontal rail
 TEST_F(GestureRecognizerTest, GestureEventHorizontalRailFling) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
-                       kTouchId, tes.Now());
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(), kTouchId,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
 
   // Get rid of touch slop.
-  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(10, 0),
-                       kTouchId, tes.Now());
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(10.f, 0.f), kTouchId,
+                      tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   delegate->Reset();
 
 
   // Move the touch-point horizontally enough that it is considered a
   // horizontal scroll.
   tes.SendScrollEvent(event_processor(), 30, 1, kTouchId, delegate.get());
   EXPECT_FLOAT_EQ(0, delegate->scroll_y());
   EXPECT_FLOAT_EQ(20, delegate->scroll_x());
 
   // Get a high x velocity, while still staying on the rail
   const int kScrollAmount = 8;
   tes.SendScrollEvents(event_processor(),
                        1,
                        1,
                        100,
                        10,
                        kTouchId,
                        1,
                        kScrollAmount,
                        delegate.get());
 
   delegate->Reset();
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                          kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&release);
 
   EXPECT_TRUE(delegate->fling());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_GT(delegate->velocity_x(), 0);
   EXPECT_EQ(0, delegate->velocity_y());
 }
 
 // Check Scroll End Events report correct velocities
 // if the user was on a vertical rail
 TEST_F(GestureRecognizerTest, GestureEventVerticalRailFling) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
-                       kTouchId, tes.Now());
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(), kTouchId,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
 
   // Get rid of touch slop.
-  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(0, 10),
-                       kTouchId, tes.Now());
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(0.f, 10.f), kTouchId,
+                      tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   delegate->Reset();
 
   // Move the touch-point vertically enough that it is considered a
   // vertical scroll.
   tes.SendScrollEvent(event_processor(), 1, 30, kTouchId, delegate.get());
   EXPECT_EQ(20, delegate->scroll_y());
   EXPECT_EQ(0, delegate->scroll_x());
   EXPECT_EQ(0, delegate->scroll_velocity_x());
 
   // Get a high y velocity, while still staying on the rail
   const int kScrollAmount = 8;
   tes.SendScrollEvents(event_processor(),
                        1,
                        6,
                        10,
                        100,
                        kTouchId,
                        1,
                        kScrollAmount,
                        delegate.get());
   EXPECT_EQ(0, delegate->scroll_velocity_x());
 
   delegate->Reset();
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 206),
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 206.f),
                          kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&release);
 
   EXPECT_TRUE(delegate->fling());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_EQ(0, delegate->velocity_x());
   EXPECT_GT(delegate->velocity_y(), 0);
 }
 
 // Check Scroll End Events report non-zero velocities if the user is not on a
 // rail
 TEST_F(GestureRecognizerTest, GestureEventNonRailFling) {
   ui::GestureConfiguration::GetInstance()
       ->set_max_touch_move_in_pixels_for_click(0);
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
-                       kTouchId, tes.Now());
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(), kTouchId,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
 
   // Move the touch-point such that a non-rail scroll begins, and we're outside
   // the snap channel for the unified GR.
   tes.SendScrollEvent(event_processor(), 50, 50, kTouchId, delegate.get());
   EXPECT_EQ(50, delegate->scroll_y());
   EXPECT_EQ(50, delegate->scroll_x());
 
   const int kScrollAmount = 8;
   tes.SendScrollEvents(event_processor(),
                        1,
                        1,
                        10,
                        100,
                        kTouchId,
                        1,
                        kScrollAmount,
                        delegate.get());
 
   delegate->Reset();
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                          kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&release);
 
   EXPECT_TRUE(delegate->fling());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_GT(delegate->velocity_x(), 0);
   EXPECT_GT(delegate->velocity_y(), 0);
 }
 
 // Check that appropriate touch events generate long press events
 TEST_F(GestureRecognizerTest, GestureEventLongPress) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
 
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED,
-                        gfx::Point(101, 201),
-                        kTouchId,
-                        ui::EventTimeForNow());
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
+                        kTouchId, ui::EventTimeForNow());
   DispatchEventUsingWindowDispatcher(&press1);
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_TRUE(delegate->begin());
   EXPECT_FALSE(delegate->tap_cancel());
 
   // We haven't pressed long enough for a long press to occur
   EXPECT_FALSE(delegate->long_press());
 
   // Wait until the timer runs out
   delegate->WaitUntilReceivedGesture(ui::ET_GESTURE_LONG_PRESS);
   EXPECT_TRUE(delegate->long_press());
   EXPECT_FALSE(delegate->tap_cancel());
 
   delegate->Reset();
-  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED,
-                          gfx::Point(101, 201),
-                          kTouchId,
-                          ui::EventTimeForNow());
+  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
+                          kTouchId, ui::EventTimeForNow());
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_FALSE(delegate->long_press());
 
   // Note the tap cancel isn't dispatched until the release
   EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->tap());
 }
 
 // Check that scrolling prevents a long press.
 TEST_F(GestureRecognizerTest, GestureEventLongPressCancelledByScroll) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 6;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
 
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                         kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
   EXPECT_TRUE(delegate->tap_down());
 
   // We haven't pressed long enough for a long press to occur
   EXPECT_FALSE(delegate->long_press());
   EXPECT_FALSE(delegate->tap_cancel());
 
   // Scroll around, to cancel the long press
   tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get());
 
   // Wait until a long press event would have fired, if it hadn't been
   // cancelled.
   DelayByLongPressTimeout();
 
   EXPECT_FALSE(delegate->long_press());
   EXPECT_TRUE(delegate->tap_cancel());
 
   delegate->Reset();
-  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                           kTouchId, tes.LeapForward(10));
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_FALSE(delegate->long_press());
   EXPECT_FALSE(delegate->tap_cancel());
 }
 
 // Check that appropriate touch events generate long tap events
 TEST_F(GestureRecognizerTest, GestureEventLongTap) {
   ui::GestureConfiguration::GetInstance()
       ->set_max_touch_down_duration_for_click_in_ms(3);
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
 
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED,
-                        gfx::Point(101, 201),
-                        kTouchId,
-                        ui::EventTimeForNow());
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
+                        kTouchId, ui::EventTimeForNow());
   DispatchEventUsingWindowDispatcher(&press1);
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_TRUE(delegate->begin());
   EXPECT_FALSE(delegate->tap_cancel());
 
   // We haven't pressed long enough for a long press to occur
   EXPECT_FALSE(delegate->long_press());
 
   // Wait until the timer runs out
   delegate->WaitUntilReceivedGesture(ui::ET_GESTURE_LONG_PRESS);
   EXPECT_TRUE(delegate->long_press());
   EXPECT_FALSE(delegate->tap_cancel());
 
   delegate->Reset();
-  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED,
-                          gfx::Point(101, 201),
-                          kTouchId,
-                          ui::EventTimeForNow());
+  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
+                          kTouchId, ui::EventTimeForNow());
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_FALSE(delegate->long_press());
   EXPECT_TRUE(delegate->long_tap());
 
   // Note the tap cancel isn't dispatched until the release
   EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->tap());
 }
 
 // Check that second tap cancels a long press
 TEST_F(GestureRecognizerTest, GestureEventLongPressCancelledBySecondTap) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 300;
   const int kWindowHeight = 400;
   const int kTouchId1 = 8;
   const int kTouchId2 = 2;
   gfx::Rect bounds(5, 5, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                        kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_TRUE(delegate->begin());
 
   // We haven't pressed long enough for a long press to occur
   EXPECT_FALSE(delegate->long_press());
 
   // Second tap, to cancel the long press
   delegate->Reset();
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(10.f, 10.f),
                         kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
   EXPECT_FALSE(delegate->tap_down());  // no touch down for second tap.
   EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_TRUE(delegate->begin());
 
   // Wait until the timer runs out
   DelayByLongPressTimeout();
 
   // No long press occurred
   EXPECT_FALSE(delegate->long_press());
 
   delegate->Reset();
-  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                           kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_FALSE(delegate->long_press());
   EXPECT_TRUE(delegate->two_finger_tap());
   EXPECT_FALSE(delegate->tap_cancel());
 }
 
 // Check that horizontal scroll gestures cause scrolls on horizontal rails.
 // Also tests that horizontal rails can be broken.
 TEST_F(GestureRecognizerTest, GestureEventHorizontalRailScroll) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
-                       kTouchId, tes.Now());
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(), kTouchId,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
 
   // Get rid of touch slop.
-  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(5, 0),
-                      kTouchId, tes.Now());
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(5.f, 0.f), kTouchId,
+                      tes.Now());
 
   DispatchEventUsingWindowDispatcher(&move);
   delegate->Reset();
 
   // Move the touch-point horizontally enough that it is considered a
   // horizontal scroll.
   tes.SendScrollEvent(event_processor(), 25, 0, kTouchId, delegate.get());
   EXPECT_EQ(0, delegate->scroll_y());
   EXPECT_EQ(20, delegate->scroll_x());
 
@@ skipping 29 matching lines @@
 // Also tests that vertical rails can be broken.
 TEST_F(GestureRecognizerTest, GestureEventVerticalRailScroll) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
-                       kTouchId, tes.Now());
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(), kTouchId,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
 
   // Get rid of touch slop.
-  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(0, 5),
-                       kTouchId, tes.Now());
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(0.f, 5.f), kTouchId,
+                      tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   delegate->Reset();
 
   // Move the touch-point vertically enough that it is considered a
   // vertical scroll.
   tes.SendScrollEvent(event_processor(), 0, 25, kTouchId, delegate.get());
   EXPECT_EQ(0, delegate->scroll_x());
   EXPECT_EQ(20, delegate->scroll_y());
 
   tes.SendScrollEvent(event_processor(), 6, 30, kTouchId, delegate.get());
@@ skipping 37 matching lines @@
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 3;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   // Make sure there is enough delay before the touch is released so that it is
   // recognized as a tap.
   delegate->Reset();
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                          kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_TRUE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   // Now, do a scroll gesture. Delay it sufficiently so that it doesn't trigger
   // a double-tap.
   delegate->Reset();
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                         kTouchId, tes.LeapForward(1000));
   DispatchEventUsingWindowDispatcher(&press1);
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   // Get rid of touch slop.
-  ui::TouchEvent move_remove_slop(ui::ET_TOUCH_MOVED, gfx::Point(116, 216),
+  ui::TouchEvent move_remove_slop(ui::ET_TOUCH_MOVED, gfx::PointF(116.f, 216.f),
                                   kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&move_remove_slop);
   EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_TRUE(delegate->scroll_begin());
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_EQ(15, delegate->scroll_x_hint());
   EXPECT_EQ(15, delegate->scroll_y_hint());
 
   delegate->Reset();
 
   // Move the touch-point enough so that it is considered as a scroll. This
   // should generate both SCROLL_BEGIN and SCROLL_UPDATE gestures.
   // The first movement is diagonal, to ensure that we have a free scroll,
   // and not a rail scroll.
   delegate->Reset();
-  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(135, 235),
-                      kTouchId, tes.Now());
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(135.f, 235.f), kTouchId,
+                      tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_EQ(19, delegate->scroll_x());
   EXPECT_EQ(19, delegate->scroll_y());
 
   // Move some more to generate a few more scroll updates.
   delegate->Reset();
-  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(115, 216),
-                       kTouchId, tes.Now());
+  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::PointF(115.f, 216.f), kTouchId,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move1);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_EQ(-20, delegate->scroll_x());
   EXPECT_EQ(-19, delegate->scroll_y());
   EXPECT_EQ(0, delegate->scroll_x_hint());
   EXPECT_EQ(0, delegate->scroll_y_hint());
 
   delegate->Reset();
-  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(145, 220),
-                       kTouchId, tes.Now());
+  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::PointF(145.f, 220.f), kTouchId,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move2);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_EQ(30, delegate->scroll_x());
   EXPECT_EQ(4, delegate->scroll_y());
 
   // Release the touch. This should end the scroll.
   delegate->Reset();
-  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                           kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_TRUE(delegate->fling());
 }
 
 TEST_F(GestureRecognizerTest, AsynchronousGestureRecognition) {
   scoped_ptr<QueueTouchEventDelegate> queued_delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId1 = 6;
   const int kTouchId2 = 4;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> queue(CreateTestWindowWithDelegate(
       queued_delegate.get(), -1234, bounds, root_window()));
 
   queued_delegate->set_window(queue.get());
 
   // Touch down on the window. This should not generate any gesture event.
   queued_delegate->Reset();
-  ui::TouchEvent press(
-      ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), kTouchId1, tes.Now());
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
+                       kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_FALSE(queued_delegate->tap());
   EXPECT_FALSE(queued_delegate->tap_down());
   EXPECT_FALSE(queued_delegate->tap_cancel());
   EXPECT_FALSE(queued_delegate->begin());
   EXPECT_FALSE(queued_delegate->scroll_begin());
   EXPECT_FALSE(queued_delegate->scroll_update());
   EXPECT_FALSE(queued_delegate->scroll_end());
 
   // Introduce some delay before the touch is released so that it is recognized
   // as a tap. However, this still should not create any gesture events.
   queued_delegate->Reset();
   ui::TouchEvent release(
-      ui::ET_TOUCH_RELEASED,
-      gfx::Point(101, 201),
-      kTouchId1,
+      ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f), kTouchId1,
       press.time_stamp() + base::TimeDelta::FromMilliseconds(50));
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_FALSE(queued_delegate->tap());
   EXPECT_FALSE(queued_delegate->tap_down());
   EXPECT_FALSE(queued_delegate->tap_cancel());
   EXPECT_FALSE(queued_delegate->begin());
   EXPECT_FALSE(queued_delegate->end());
   EXPECT_FALSE(queued_delegate->scroll_begin());
   EXPECT_FALSE(queued_delegate->scroll_update());
   EXPECT_FALSE(queued_delegate->scroll_end());
 
   // Create another window, and place a touch-down on it. This should create a
   // tap-down gesture.
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -2345, gfx::Rect(0, 0, 50, 50), root_window()));
   delegate->Reset();
-  ui::TouchEvent press2(
-      ui::ET_TOUCH_PRESSED, gfx::Point(10, 20), kTouchId2, tes.Now());
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(10.f, 20.f),
+                        kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(queued_delegate->begin());
   EXPECT_FALSE(queued_delegate->end());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
-  ui::TouchEvent release2(
-      ui::ET_TOUCH_RELEASED, gfx::Point(10, 20), kTouchId2, tes.Now());
+  ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::PointF(10.f, 20.f),
+                          kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&release2);
 
   // Process the first queued event.
   queued_delegate->Reset();
   queued_delegate->ReceivedAck();
   EXPECT_FALSE(queued_delegate->tap());
   EXPECT_TRUE(queued_delegate->tap_down());
   EXPECT_TRUE(queued_delegate->begin());
   EXPECT_FALSE(queued_delegate->tap_cancel());
   EXPECT_FALSE(queued_delegate->end());
   EXPECT_FALSE(queued_delegate->scroll_begin());
   EXPECT_FALSE(queued_delegate->scroll_update());
   EXPECT_FALSE(queued_delegate->scroll_end());
 
   // Now, process the second queued event.
   queued_delegate->Reset();
   queued_delegate->ReceivedAck();
   EXPECT_TRUE(queued_delegate->tap());
   EXPECT_FALSE(queued_delegate->tap_down());
   EXPECT_FALSE(queued_delegate->tap_cancel());
   EXPECT_FALSE(queued_delegate->begin());
   EXPECT_TRUE(queued_delegate->end());
   EXPECT_FALSE(queued_delegate->scroll_begin());
   EXPECT_FALSE(queued_delegate->scroll_update());
   EXPECT_FALSE(queued_delegate->scroll_end());
 
   // Start all over. Press on the first window, then press again on the second
   // window. The second press should still go to the first window.
   queued_delegate->Reset();
-  ui::TouchEvent press3(
-      ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), kTouchId1, tes.Now());
+  ui::TouchEvent press3(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
+                        kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press3);
   EXPECT_FALSE(queued_delegate->tap());
   EXPECT_FALSE(queued_delegate->tap_down());
   EXPECT_FALSE(queued_delegate->tap_cancel());
   EXPECT_FALSE(queued_delegate->begin());
   EXPECT_FALSE(queued_delegate->end());
   EXPECT_FALSE(queued_delegate->begin());
   EXPECT_FALSE(queued_delegate->end());
   EXPECT_FALSE(queued_delegate->scroll_begin());
   EXPECT_FALSE(queued_delegate->scroll_update());
   EXPECT_FALSE(queued_delegate->scroll_end());
 
   queued_delegate->Reset();
   delegate->Reset();
-  ui::TouchEvent press4(
-      ui::ET_TOUCH_PRESSED, gfx::Point(103, 203), kTouchId2, tes.Now());
+  ui::TouchEvent press4(ui::ET_TOUCH_PRESSED, gfx::PointF(103.f, 203.f),
+                        kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&press4);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->end());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_FALSE(queued_delegate->tap());
@@ skipping 81 matching lines @@
   TimedEvents tes;
   const int kWindowWidth = 300;
   const int kWindowHeight = 400;
   const int kTouchId1 = 5;
   const int kTouchId2 = 3;
   gfx::Rect bounds(5, 5, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                        kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_2_EVENTS(delegate->events(),
                   ui::ET_GESTURE_BEGIN,
                   ui::ET_GESTURE_TAP_DOWN);
 
   // Move the touch-point enough so that it is considered as a scroll. This
   // should generate both SCROLL_BEGIN and SCROLL_UPDATE gestures.
   delegate->Reset();
-  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(130, 301),
-                      kTouchId1, tes.Now());
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(130.f, 301.f), kTouchId1,
+                      tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   EXPECT_3_EVENTS(delegate->events(),
                   ui::ET_GESTURE_TAP_CANCEL,
                   ui::ET_GESTURE_SCROLL_BEGIN,
                   ui::ET_GESTURE_SCROLL_UPDATE);
 
   // Press the second finger. It should cause pinch-begin. Note that we will not
   // transition to two finger tap here because the touch points are far enough.
   delegate->Reset();
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(10.f, 10.f),
                         kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_BEGIN);
   EXPECT_EQ(gfx::Rect(10, 10, 120, 291).ToString(),
             delegate->bounding_box().ToString());
 
   // Move the first finger.
   delegate->Reset();
-  ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::Point(95, 201),
-                       kTouchId1, tes.Now());
+  ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::PointF(95.f, 201.f), kTouchId1,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move3);
   EXPECT_2_EVENTS(delegate->events(),
                   ui::ET_GESTURE_SCROLL_UPDATE,
                   ui::ET_GESTURE_PINCH_BEGIN);
   EXPECT_EQ(gfx::Rect(10, 10, 85, 191).ToString(),
             delegate->bounding_box().ToString());
 
   // Now move the second finger.
   delegate->Reset();
-  ui::TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::Point(55, 15),
-                       kTouchId2, tes.Now());
+  ui::TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::PointF(55.f, 15.f), kTouchId2,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move4);
   EXPECT_2_EVENTS(delegate->events(),
                   ui::ET_GESTURE_SCROLL_UPDATE,
                   ui::ET_GESTURE_PINCH_UPDATE);
   EXPECT_EQ(gfx::Rect(55, 15, 40, 186).ToString(),
             delegate->bounding_box().ToString());
 
   // Release the first finger. This should end pinch.
   delegate->Reset();
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                          kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_2_EVENTS(delegate->events(),
                  ui::ET_GESTURE_PINCH_END,
                  ui::ET_GESTURE_END);
   EXPECT_EQ(gfx::Rect(55, 15, 46, 186).ToString(),
             delegate->bounding_box().ToString());
 
   // Move the second finger. This should still generate a scroll.
   delegate->Reset();
-  ui::TouchEvent move5(ui::ET_TOUCH_MOVED, gfx::Point(25, 10),
-                       kTouchId2, tes.Now());
+  ui::TouchEvent move5(ui::ET_TOUCH_MOVED, gfx::PointF(25.f, 10.f), kTouchId2,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move5);
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 }
 
 TEST_F(GestureRecognizerTest, GestureEventPinchFromScrollFromPinch) {
 scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 300;
   const int kWindowHeight = 400;
   const int kTouchId1 = 5;
   const int kTouchId2 = 3;
   gfx::Rect bounds(5, 5, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 301),
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 301.f),
                        kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   delegate->Reset();
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(10.f, 10.f),
                         kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
   EXPECT_FALSE(delegate->pinch_begin());
 
   // Touch move triggers pinch begin.
   tes.SendScrollEvent(event_processor(), 130, 230, kTouchId1, delegate.get());
   EXPECT_TRUE(delegate->pinch_begin());
   EXPECT_FALSE(delegate->pinch_update());
 
   // Touch move triggers pinch update.
   tes.SendScrollEvent(event_processor(), 160, 200, kTouchId1, delegate.get());
   EXPECT_FALSE(delegate->pinch_begin());
   EXPECT_TRUE(delegate->pinch_update());
 
   // Pinch has started, now release the second finger
   delegate->Reset();
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                          kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_TRUE(delegate->pinch_end());
 
   tes.SendScrollEvent(event_processor(), 130, 230, kTouchId2, delegate.get());
   EXPECT_TRUE(delegate->scroll_update());
 
   // Pinch again
   delegate->Reset();
-  ui::TouchEvent press3(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
+  ui::TouchEvent press3(ui::ET_TOUCH_PRESSED, gfx::PointF(10.f, 10.f),
                         kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press3);
   // Now the touch points are close. So we will go into two finger tap.
   // Move the touch-point enough to break two-finger-tap and enter pinch.
-  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(101, 50),
-                       kTouchId1, tes.Now());
+  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::PointF(101.f, 50.f), kTouchId1,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move2);
   EXPECT_TRUE(delegate->pinch_begin());
 
   tes.SendScrollEvent(event_processor(), 350, 350, kTouchId1, delegate.get());
   EXPECT_TRUE(delegate->pinch_update());
 }
 
 TEST_F(GestureRecognizerTest, GestureEventPinchFromTap) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 300;
   const int kWindowHeight = 400;
   const int kTouchId1 = 3;
   const int kTouchId2 = 5;
   gfx::Rect bounds(5, 5, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 301),
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 301.f),
                        kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_2_EVENTS(delegate->events(),
                   ui::ET_GESTURE_BEGIN,
                   ui::ET_GESTURE_TAP_DOWN);
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 
   // Press the second finger far enough to break two finger tap.
   delegate->Reset();
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(10.f, 10.f),
                         kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
   EXPECT_2_EVENTS(delegate->events(),
                   ui::ET_GESTURE_TAP_CANCEL,
                   ui::ET_GESTURE_BEGIN);
   EXPECT_EQ(gfx::Rect(10, 10, 91, 291).ToString(),
             delegate->bounding_box().ToString());
 
   // Move the first finger.
   delegate->Reset();
-  ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::Point(65, 201),
-                       kTouchId1, tes.Now());
+  ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::PointF(65.f, 201.f), kTouchId1,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move3);
   EXPECT_3_EVENTS(delegate->events(),
                   ui::ET_GESTURE_SCROLL_BEGIN,
                   ui::ET_GESTURE_SCROLL_UPDATE,
                   ui::ET_GESTURE_PINCH_BEGIN);
   EXPECT_EQ(gfx::Rect(10, 10, 55, 191).ToString(),
             delegate->bounding_box().ToString());
 
   // Now move the second finger.
   delegate->Reset();
-  ui::TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::Point(55, 15),
-                       kTouchId2, tes.Now());
+  ui::TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::PointF(55.f, 15.f), kTouchId2,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move4);
   EXPECT_2_EVENTS(delegate->events(),
                   ui::ET_GESTURE_SCROLL_UPDATE,
                   ui::ET_GESTURE_PINCH_UPDATE);
   EXPECT_EQ(gfx::Rect(55, 15, 10, 186).ToString(),
             delegate->bounding_box().ToString());
 
   // Release the first finger. This should end pinch.
   delegate->Reset();
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                          kTouchId1, tes.LeapForward(10));
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_2_EVENTS(delegate->events(),
                   ui::ET_GESTURE_PINCH_END,
                   ui::ET_GESTURE_END);
   EXPECT_EQ(gfx::Rect(55, 15, 46, 186).ToString(),
             delegate->bounding_box().ToString());
 
   // Move the second finger. This should still generate a scroll.
   delegate->Reset();
-  ui::TouchEvent move5(ui::ET_TOUCH_MOVED, gfx::Point(25, 10),
-                       kTouchId2, tes.Now());
+  ui::TouchEvent move5(ui::ET_TOUCH_MOVED, gfx::PointF(25.f, 10.f), kTouchId2,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move5);
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 }
 
 TEST_F(GestureRecognizerTest, GestureEventIgnoresDisconnectedEvents) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
 
-  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
-                          6, tes.Now());
+  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f), 6,
+                          tes.Now());
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
 }
 
 // Check that a touch is locked to the window of the closest current touch
 // within max_separation_for_gesture_touches_in_pixels
 TEST_F(GestureRecognizerTest, GestureEventTouchLockSelectsCorrectWindow) {
   ui::GestureRecognizer* gesture_recognizer = new ui::GestureRecognizerImpl();
   TimedEvents tes;
@@ skipping 16 matching lines @@
 
   scoped_ptr<aura::Window*[]> windows(new aura::Window*[kNumWindows]);
 
   // Instantiate windows with |window_bounds| and touch each window at
   // its origin.
   for (int i = 0; i < kNumWindows; ++i) {
     delegates[i] = new GestureEventConsumeDelegate();
     windows[i] = CreateTestWindowWithDelegate(
         delegates[i], i, window_bounds[i], root_window());
     windows[i]->set_id(i);
-    ui::TouchEvent press(ui::ET_TOUCH_PRESSED, window_bounds[i].origin(),
-                         i, tes.Now());
+    ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
+                         gfx::PointF(window_bounds[i].origin()), i, tes.Now());
     DispatchEventUsingWindowDispatcher(&press);
   }
 
   // Touches should now be associated with the closest touch within
   // ui::GestureConfiguration::max_separation_for_gesture_touches_in_pixels
-  target = gesture_recognizer->GetTargetForLocation(gfx::Point(11, 11), -1);
+  target =
+      gesture_recognizer->GetTargetForLocation(gfx::PointF(11.f, 11.f), -1);
   EXPECT_EQ("0", WindowIDAsString(target));
-  target = gesture_recognizer->GetTargetForLocation(gfx::Point(511, 11), -1);
+  target =
+      gesture_recognizer->GetTargetForLocation(gfx::PointF(511.f, 11.f), -1);
   EXPECT_EQ("1", WindowIDAsString(target));
-  target = gesture_recognizer->GetTargetForLocation(gfx::Point(11, 511), -1);
+  target =
+      gesture_recognizer->GetTargetForLocation(gfx::PointF(11.f, 511.f), -1);
   EXPECT_EQ("2", WindowIDAsString(target));
-  target = gesture_recognizer->GetTargetForLocation(gfx::Point(511, 511), -1);
+  target =
+      gesture_recognizer->GetTargetForLocation(gfx::PointF(511.f, 511.f), -1);
   EXPECT_EQ("3", WindowIDAsString(target));
 
   // Add a touch in the middle associated with windows[2]
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 500),
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(0.f, 500.f),
                        kNumWindows, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
-  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(250, 250),
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(250.f, 250.f),
                       kNumWindows, tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
 
-  target = gesture_recognizer->GetTargetForLocation(gfx::Point(250, 250), -1);
+  target =
+      gesture_recognizer->GetTargetForLocation(gfx::PointF(250.f, 250.f), -1);
   EXPECT_EQ("2", WindowIDAsString(target));
 
   // Make sure that ties are broken by distance to a current touch
   // Closer to the point in the bottom right.
-  target = gesture_recognizer->GetTargetForLocation(gfx::Point(380, 380), -1);
+  target =
+      gesture_recognizer->GetTargetForLocation(gfx::PointF(380.f, 380.f), -1);
   EXPECT_EQ("3", WindowIDAsString(target));
 
   // This touch is closer to the point in the middle
-  target = gesture_recognizer->GetTargetForLocation(gfx::Point(300, 300), -1);
+  target =
+      gesture_recognizer->GetTargetForLocation(gfx::PointF(300.f, 300.f), -1);
   EXPECT_EQ("2", WindowIDAsString(target));
 
   // A touch too far from other touches won't be locked to anything
-  target = gesture_recognizer->GetTargetForLocation(gfx::Point(1000, 1000), -1);
+  target =
+      gesture_recognizer->GetTargetForLocation(gfx::PointF(1000.f, 1000.f), -1);
   EXPECT_TRUE(target == NULL);
 
   // Move a touch associated with windows[2] to 1000, 1000
-  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(1000, 1000),
+  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::PointF(1000.f, 1000.f),
                        kNumWindows, tes.Now());
   DispatchEventUsingWindowDispatcher(&move2);
 
-  target = gesture_recognizer->GetTargetForLocation(gfx::Point(1000, 1000), -1);
+  target =
+      gesture_recognizer->GetTargetForLocation(gfx::PointF(1000.f, 1000.f), -1);
   EXPECT_EQ("2", WindowIDAsString(target));
 
   for (int i = 0; i < kNumWindows; ++i) {
     // Delete windows before deleting delegates.
     delete windows[i];
     delete delegates[i];
   }
 }
 
 // Check that a touch's target will not be effected by a touch on a different
 // screen.
 TEST_F(GestureRecognizerTest, GestureEventTouchLockIgnoresOtherScreens) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   gfx::Rect bounds(0, 0, 10, 10);
   scoped_ptr<aura::Window> window(
       CreateTestWindowWithDelegate(delegate.get(), 0, bounds, root_window()));
 
   const int kTouchId1 = 8;
   const int kTouchId2 = 2;
   TimedEvents tes;
 
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(5, 5),
-                        kTouchId1, tes.Now());
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(5.f, 5.f), kTouchId1,
+                        tes.Now());
   ui::EventTestApi test_press1(&press1);
   test_press1.set_source_device_id(1);
   DispatchEventUsingWindowDispatcher(&press1);
 
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(20, 20),
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(20.f, 20.f),
                         kTouchId2, tes.Now());
   ui::EventTestApi test_press2(&press2);
   test_press2.set_source_device_id(2);
   DispatchEventUsingWindowDispatcher(&press2);
 
   // The second press should not have been locked to the same target as the
   // first, as they occured on different displays.
   EXPECT_NE(
       ui::GestureRecognizer::Get()->GetTouchLockedTarget(press1),
       ui::GestureRecognizer::Get()->GetTouchLockedTarget(press2));
 }
 
 // Check that touch events outside the root window are still handled
 // by the root window's gesture sequence.
 TEST_F(GestureRecognizerTest, GestureEventOutsideRootWindowTap) {
   TimedEvents tes;
   scoped_ptr<aura::Window> window(CreateTestWindowWithBounds(
       gfx::Rect(-100, -100, 2000, 2000), root_window()));
 
-  gfx::Point pos1(-10, -10);
+  gfx::PointF pos1(-10.f, -10.f);
   ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, pos1, 0, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
 
-  gfx::Point pos2(1000, 1000);
+  gfx::PointF pos2(1000.f, 1000.f);
   ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, pos2, 1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
 
   // As these presses were outside the root window, they should be
   // associated with the root window.
   EXPECT_EQ(root_window(),
             static_cast<aura::Window*>(
                 ui::GestureRecognizer::Get()->GetTouchLockedTarget(press1)));
   EXPECT_EQ(root_window(),
             static_cast<aura::Window*>(
                 ui::GestureRecognizer::Get()->GetTouchLockedTarget(press2)));
 }
 
 TEST_F(GestureRecognizerTest, NoTapWithPreventDefaultedRelease) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, 100, 100);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
 
   delegate->Reset();
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                          kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release);
 
   delegate->Reset();
   delegate->ReceivedAck();
   EXPECT_TRUE(delegate->tap_down());
   delegate->Reset();
   delegate->ReceivedAckPreventDefaulted();
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_cancel());
 }
 
 TEST_F(GestureRecognizerTest, PinchScrollWithPreventDefaultedRelease) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kTouchId1 = 7;
   const int kTouchId2 = 5;
   gfx::Rect bounds(10, 20, 100, 100);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
 
   {
     delegate->Reset();
-    ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(15, 25), kTouchId1,
-                         tes.Now());
-    ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(20, 95), kTouchId1,
+    ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(15.f, 25.f),
+                         kTouchId1, tes.Now());
+    ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(20.f, 95.f), kTouchId1,
                         tes.LeapForward(200));
-    ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(15, 25), kTouchId1,
-                           tes.LeapForward(50));
+    ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(15.f, 25.f),
+                           kTouchId1, tes.LeapForward(50));
     DispatchEventUsingWindowDispatcher(&press);
     DispatchEventUsingWindowDispatcher(&move);
     DispatchEventUsingWindowDispatcher(&release);
     delegate->Reset();
 
     // Ack the press event.
     delegate->ReceivedAck();
     EXPECT_2_EVENTS(
         delegate->events(), ui::ET_GESTURE_BEGIN, ui::ET_GESTURE_TAP_DOWN);
     delegate->Reset();
 
     // Ack the move event.
     delegate->ReceivedAck();
     EXPECT_3_EVENTS(delegate->events(),
                     ui::ET_GESTURE_TAP_CANCEL,
                     ui::ET_GESTURE_SCROLL_BEGIN,
                     ui::ET_GESTURE_SCROLL_UPDATE);
     delegate->Reset();
 
     // Ack the release event. Although the release event has been processed, it
     // should still generate a scroll-end event.
     delegate->ReceivedAckPreventDefaulted();
     EXPECT_2_EVENTS(
         delegate->events(), ui::ET_GESTURE_SCROLL_END, ui::ET_GESTURE_END);
   }
 
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(15, 25), kTouchId1,
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(15.f, 25.f), kTouchId1,
                        tes.Now());
-  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(20, 95), kTouchId1,
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(20.f, 95.f), kTouchId1,
                       tes.LeapForward(200));
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(15, 25), kTouchId1,
-                         tes.LeapForward(50));
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(55, 25), kTouchId2,
-                        tes.Now());
-  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(145, 85), kTouchId2,
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(15.f, 25.f),
+                         kTouchId1, tes.LeapForward(50));
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(55.f, 25.f),
+                        kTouchId2, tes.Now());
+  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::PointF(145.f, 85.f), kTouchId2,
                        tes.LeapForward(1000));
-  ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(145, 85), kTouchId2,
-                          tes.LeapForward(14));
+  ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::PointF(145.f, 85.f),
+                          kTouchId2, tes.LeapForward(14));
 
   // Do a pinch.
   DispatchEventUsingWindowDispatcher(&press);
   DispatchEventUsingWindowDispatcher(&move);
   DispatchEventUsingWindowDispatcher(&press2);
   DispatchEventUsingWindowDispatcher(&move2);
   DispatchEventUsingWindowDispatcher(&release);
   DispatchEventUsingWindowDispatcher(&release2);
 
   // Ack the press and move events.
@@ skipping 83 matching lines @@
 
   // Create a window and set it as the capture window.
   scoped_ptr<aura::Window> window1(CreateTestWindowWithDelegate(delegate.get(),
       -1234, gfx::Rect(10, 10, 300, 300), root_window()));
   window1->SetCapture();
 
   ui::test::EventGenerator generator(root_window());
   TimedEvents tes;
 
   // Generate two touch-press events on the window.
-  scoped_ptr<ui::TouchEvent> touch0(new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
-                                                       gfx::Point(20, 20), 0,
-                                                       tes.Now()));
-  scoped_ptr<ui::TouchEvent> touch1(new ui::TouchEvent(ui::ET_TOUCH_PRESSED,
-                                                       gfx::Point(30, 30), 1,
-                                                       tes.Now()));
+  scoped_ptr<ui::TouchEvent> touch0(new ui::TouchEvent(
+      ui::ET_TOUCH_PRESSED, gfx::PointF(20.f, 20.f), 0, tes.Now()));
+  scoped_ptr<ui::TouchEvent> touch1(new ui::TouchEvent(
+      ui::ET_TOUCH_PRESSED, gfx::PointF(30.f, 30.f), 1, tes.Now()));
   generator.Dispatch(touch0.get());
   generator.Dispatch(touch1.get());
   RunAllPendingInMessageLoop();
   EXPECT_EQ(2, handler->touch_pressed_count());
 
   // Advance time.
   tes.LeapForward(1000);
 
   // End the two touches, one by a touch-release and one by a touch-cancel; to
   // cover both cases.
-  touch0.reset(new ui::TouchEvent(ui::ET_TOUCH_RELEASED, gfx::Point(20, 20), 0,
-                                  tes.Now()));
-  touch1.reset(new ui::TouchEvent(ui::ET_TOUCH_CANCELLED, gfx::Point(30, 30), 1,
-                                  tes.Now()));
+  touch0.reset(new ui::TouchEvent(ui::ET_TOUCH_RELEASED,
+                                  gfx::PointF(20.f, 20.f), 0, tes.Now()));
+  touch1.reset(new ui::TouchEvent(ui::ET_TOUCH_CANCELLED,
+                                  gfx::PointF(30.f, 30.f), 1, tes.Now()));
   generator.Dispatch(touch0.get());
   generator.Dispatch(touch1.get());
   RunAllPendingInMessageLoop();
   EXPECT_EQ(1, handler->touch_released_count());
   EXPECT_EQ(1, handler->touch_cancelled_count());
 
   // Create a new window and set it as the new capture window.
   scoped_ptr<aura::Window> window2(CreateTestWindowWithBounds(
       gfx::Rect(100, 100, 300, 300), root_window()));
   window2->SetCapture();
   RunAllPendingInMessageLoop();
   // Check that setting capture does not generate any synthetic touch-cancels
   // for the two previously finished touch actions.
   EXPECT_EQ(1, handler->touch_cancelled_count());
 
   root_window()->RemovePreTargetHandler(handler.get());
 }
 
 // Tests that a press with the same touch id as an existing touch is ignored.
 TEST_F(GestureRecognizerTest, PressDoesNotCrash) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
 
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, gfx::Rect(10, 10, 300, 300), root_window()));
 
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(45, 45), 7, tes.Now());
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(45.f, 45.f), 7,
+                       tes.Now());
   press.set_radius_x(40);
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_EQ(gfx::Rect(5, 5, 80, 80).ToString(),
             delegate->bounding_box().ToString());
   delegate->Reset();
 
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(55, 45), 7, tes.Now());
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(55.f, 45.f), 7,
+                        tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
 
   // FIXME(tdresser): this should not generate a tap down; however,
   // there is at least one case where we need to allow a touch press
   // from a currently used touch id. See crbug.com/373125 for details.
   EXPECT_TRUE(delegate->begin());
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_begin());
 }
 
 TEST_F(GestureRecognizerTest, TwoFingerTap) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId1 = 2;
   const int kTouchId2 = 3;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   TimedEvents tes;
 
   delegate->Reset();
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                         kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
   EXPECT_2_EVENTS(
       delegate->events(), ui::ET_GESTURE_BEGIN, ui::ET_GESTURE_TAP_DOWN);
 
   delegate->Reset();
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201),
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(130.f, 201.f),
                         kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
   EXPECT_2_EVENTS(
       delegate->events(), ui::ET_GESTURE_TAP_CANCEL, ui::ET_GESTURE_BEGIN);
 
   // Little bit of touch move should not affect our state.
   delegate->Reset();
-  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(102, 202),
-                       kTouchId1, tes.Now());
+  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::PointF(102.f, 202.f), kTouchId1,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move1);
-  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(131, 202),
-                       kTouchId2, tes.Now());
+  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::PointF(131.f, 202.f), kTouchId2,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move2);
   EXPECT_3_EVENTS(delegate->events(), ui::ET_GESTURE_SCROLL_BEGIN,
                   ui::ET_GESTURE_SCROLL_UPDATE, ui::ET_GESTURE_SCROLL_UPDATE);
 
   // Make sure there is enough delay before the touch is released so that it is
   // recognized as a tap.
   delegate->Reset();
-  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                           kTouchId1, tes.LeapForward(50));
 
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_2_EVENTS(
       delegate->events(), ui::ET_GESTURE_TWO_FINGER_TAP, ui::ET_GESTURE_END);
 
   // Lift second finger.
   // Make sure there is enough delay before the touch is released so that it is
   // recognized as a tap.
   delegate->Reset();
-  ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(130, 201),
+  ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::PointF(130.f, 201.f),
                           kTouchId2, tes.LeapForward(50));
 
   DispatchEventUsingWindowDispatcher(&release2);
   EXPECT_2_EVENTS(
       delegate->events(), ui::ET_GESTURE_SCROLL_END, ui::ET_GESTURE_END);
 }
 
 TEST_F(GestureRecognizerTest, TwoFingerTapExpired) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId1 = 2;
   const int kTouchId2 = 3;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   TimedEvents tes;
 
   delegate->Reset();
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                         kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
 
   delegate->Reset();
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201),
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(130.f, 201.f),
                         kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
 
   // Send release event after sufficient delay so that two finger time expires.
   delegate->Reset();
-  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                           kTouchId1, tes.LeapForward(1000));
 
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_FALSE(delegate->two_finger_tap());
 
   // Lift second finger.
   // Make sure there is enough delay before the touch is released so that it is
   // recognized as a tap.
   delegate->Reset();
-  ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(130, 201),
+  ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::PointF(130.f, 201.f),
                           kTouchId2, tes.LeapForward(50));
 
   DispatchEventUsingWindowDispatcher(&release2);
   EXPECT_FALSE(delegate->two_finger_tap());
 }
 
 TEST_F(GestureRecognizerTest, TwoFingerTapChangesToPinch) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId1 = 2;
   const int kTouchId2 = 3;
   TimedEvents tes;
 
   // Test moving first finger
   {
     gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
     scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
         delegate.get(), -1234, bounds, root_window()));
 
     delegate->Reset();
-    ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+    ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                           kTouchId1, tes.Now());
     DispatchEventUsingWindowDispatcher(&press1);
 
     delegate->Reset();
-    ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201),
+    ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(130.f, 201.f),
                           kTouchId2, tes.Now());
     DispatchEventUsingWindowDispatcher(&press2);
 
     tes.SendScrollEvent(event_processor(), 230, 330, kTouchId1, delegate.get());
     EXPECT_FALSE(delegate->two_finger_tap());
     EXPECT_TRUE(delegate->pinch_begin());
 
     // Make sure there is enough delay before the touch is released so that it
     // is recognized as a tap.
     delegate->Reset();
-    ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+    ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                            kTouchId2, tes.LeapForward(50));
 
     DispatchEventUsingWindowDispatcher(&release);
     EXPECT_FALSE(delegate->two_finger_tap());
     EXPECT_TRUE(delegate->pinch_end());
   }
 
   // Test moving second finger
   {
     gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
     scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
         delegate.get(), -1234, bounds, root_window()));
 
     delegate->Reset();
-    ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+    ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                           kTouchId1, tes.Now());
     DispatchEventUsingWindowDispatcher(&press1);
 
     delegate->Reset();
-    ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201),
+    ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(130.f, 201.f),
                           kTouchId2, tes.Now());
     DispatchEventUsingWindowDispatcher(&press2);
 
     tes.SendScrollEvent(event_processor(), 301, 230, kTouchId2, delegate.get());
     EXPECT_FALSE(delegate->two_finger_tap());
     EXPECT_TRUE(delegate->pinch_begin());
 
     // Make sure there is enough delay before the touch is released so that it
     // is recognized as a tap.
     delegate->Reset();
-    ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+    ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                            kTouchId1, tes.LeapForward(50));
 
     DispatchEventUsingWindowDispatcher(&release);
     EXPECT_FALSE(delegate->two_finger_tap());
     EXPECT_TRUE(delegate->pinch_end());
   }
 }
 
 TEST_F(GestureRecognizerTest, NoTwoFingerTapWhenFirstFingerHasScrolled) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId1 = 2;
   const int kTouchId2 = 3;
   TimedEvents tes;
 
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                         kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
   tes.SendScrollEvent(event_processor(), 130, 230, kTouchId1, delegate.get());
 
   delegate->Reset();
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201),
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(130.f, 201.f),
                         kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
 
   EXPECT_FALSE(delegate->pinch_begin());
 
   // Make sure there is enough delay before the touch is released so that it
   // is recognized as a tap.
   delegate->Reset();
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                          kTouchId2, tes.LeapForward(50));
 
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_FALSE(delegate->two_finger_tap());
   EXPECT_FALSE(delegate->pinch_end());
 }
 
 TEST_F(GestureRecognizerTest, MultiFingerSwipe) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
@@ skipping 65 matching lines @@
   const int kTouchId2 = 3;
   TimedEvents tes;
 
   // Test canceling first finger.
   {
     gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
     scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
         delegate.get(), -1234, bounds, root_window()));
 
     delegate->Reset();
-    ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+    ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                           kTouchId1, tes.Now());
     DispatchEventUsingWindowDispatcher(&press1);
 
     delegate->Reset();
-    ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201),
+    ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(130.f, 201.f),
                           kTouchId2, tes.Now());
     DispatchEventUsingWindowDispatcher(&press2);
 
     delegate->Reset();
-    ui::TouchEvent cancel(ui::ET_TOUCH_CANCELLED, gfx::Point(130, 201),
+    ui::TouchEvent cancel(ui::ET_TOUCH_CANCELLED, gfx::PointF(130.f, 201.f),
                           kTouchId1, tes.Now());
     DispatchEventUsingWindowDispatcher(&cancel);
     EXPECT_FALSE(delegate->two_finger_tap());
 
     // Make sure there is enough delay before the touch is released so that it
     // is recognized as a tap.
     delegate->Reset();
-    ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+    ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                            kTouchId2, tes.LeapForward(50));
 
     DispatchEventUsingWindowDispatcher(&release);
     EXPECT_FALSE(delegate->two_finger_tap());
   }
 
   // Test canceling second finger
   {
     gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
     scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
         delegate.get(), -1234, bounds, root_window()));
 
     delegate->Reset();
-    ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+    ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                           kTouchId1, tes.Now());
     DispatchEventUsingWindowDispatcher(&press1);
 
     delegate->Reset();
-    ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201),
+    ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(130.f, 201.f),
                           kTouchId2, tes.Now());
     DispatchEventUsingWindowDispatcher(&press2);
 
     delegate->Reset();
-    ui::TouchEvent cancel(ui::ET_TOUCH_CANCELLED, gfx::Point(130, 201),
+    ui::TouchEvent cancel(ui::ET_TOUCH_CANCELLED, gfx::PointF(130.f, 201.f),
                           kTouchId2, tes.Now());
     DispatchEventUsingWindowDispatcher(&cancel);
     EXPECT_FALSE(delegate->two_finger_tap());
 
     // Make sure there is enough delay before the touch is released so that it
     // is recognized as a tap.
     delegate->Reset();
-    ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+    ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                            kTouchId1, tes.LeapForward(50));
 
     DispatchEventUsingWindowDispatcher(&release);
     EXPECT_FALSE(delegate->two_finger_tap());
   }
 }
 
 TEST_F(GestureRecognizerTest, VeryWideTwoFingerTouchDownShouldBeAPinch) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 523;
   const int kWindowHeight = 45;
   const int kTouchId1 = 2;
   const int kTouchId2 = 3;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   TimedEvents tes;
 
   delegate->Reset();
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                         kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_FALSE(delegate->long_press());
   EXPECT_FALSE(delegate->two_finger_tap());
 
   delegate->Reset();
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(430, 201),
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(430.f, 201.f),
                         kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());  // no touch down for second tap.
   EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_FALSE(delegate->long_press());
   EXPECT_FALSE(delegate->two_finger_tap());
   EXPECT_FALSE(delegate->pinch_begin());
 
   delegate->Reset();
-  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(530, 301),
-                       kTouchId2, tes.Now());
+  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::PointF(530.f, 301.f), kTouchId2,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move2);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   // Pinch & Scroll only when there is enough movement.
   EXPECT_TRUE(delegate->scroll_begin());
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_FALSE(delegate->long_press());
   EXPECT_FALSE(delegate->two_finger_tap());
   EXPECT_TRUE(delegate->pinch_begin());
 }
 
 // Verifies if a window is the target of multiple touch-ids and we hide the
 // window everything is cleaned up correctly.
 TEST_F(GestureRecognizerTest, FlushAllOnHide) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   gfx::Rect bounds(0, 0, 200, 200);
   scoped_ptr<aura::Window> window(
       CreateTestWindowWithDelegate(delegate.get(), 0, bounds, root_window()));
   const int kTouchId1 = 8;
   const int kTouchId2 = 2;
   TimedEvents tes;
 
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(10.f, 10.f),
                         kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(20, 20),
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(20.f, 20.f),
                         kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
   window->Hide();
   EXPECT_EQ(NULL,
       ui::GestureRecognizer::Get()->GetTouchLockedTarget(press1));
   EXPECT_EQ(NULL,
       ui::GestureRecognizer::Get()->GetTouchLockedTarget(press2));
 }
 
 TEST_F(GestureRecognizerTest, LongPressTimerStopsOnPreventDefaultedTouchMoves) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, 100, 100);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
   TimedEvents tes;
 
   delegate->Reset();
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   // Scroll around, to cancel the long press
   tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get());
 
   delegate->Reset();
   delegate->ReceivedAck();
   EXPECT_TRUE(delegate->tap_down());
 
   // Wait long enough that long press would have fired if the touchmove hadn't
@@ skipping 33 matching lines @@
       new ConsumesTouchMovesDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 5;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   TimedEvents tes;
 
   delegate->Reset();
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_TRUE(delegate->begin());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   // Move the touch-point enough so that it would normally be considered a
   // scroll. But since the touch-moves will be consumed, the scroll should not
   // start.
   tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get());
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   EXPECT_TRUE(delegate->scroll_begin());
 
   // Release the touch back at the start point. This should end without causing
   // a tap.
   delegate->Reset();
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(130, 230),
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(130.f, 230.f),
                          kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_TRUE(delegate->end());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
 
   EXPECT_TRUE(delegate->scroll_end());
 }
 
 // Tests the behavior of 2F scroll when some of the touch-move events are
 // consumed.
 TEST_F(GestureRecognizerTest, GestureEventScrollTwoFingerTouchMoveConsumed) {
   scoped_ptr<ConsumesTouchMovesDelegate> delegate(
       new ConsumesTouchMovesDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 100;
   const int kTouchId1 = 2;
   const int kTouchId2 = 3;
   TimedEvents tes;
 
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                         kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
   tes.SendScrollEvent(event_processor(), 131, 231, kTouchId1, delegate.get());
 
   EXPECT_2_EVENTS(delegate->events(),
                   ui::ET_GESTURE_TAP_CANCEL,
                   ui::ET_GESTURE_SCROLL_BEGIN);
 
   delegate->Reset();
   // Second finger touches down and moves.
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(130, 201),
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(130.f, 201.f),
                         kTouchId2, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&press2);
   tes.SendScrollEvent(event_processor(), 161, 231, kTouchId2, delegate.get());
   EXPECT_0_EVENTS(delegate->events());
 
   delegate->Reset();
   // Move first finger again, no PinchUpdate & ScrollUpdate.
   tes.SendScrollEvent(event_processor(), 161, 261, kTouchId1, delegate.get());
   EXPECT_0_EVENTS(delegate->events());
 
   // Stops consuming touch-move.
   delegate->set_consume_touch_move(false);
 
   delegate->Reset();
   // Making a pinch gesture.
   tes.SendScrollEvent(event_processor(), 161, 260, kTouchId1, delegate.get());
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
 
   delegate->Reset();
   tes.SendScrollEvent(event_processor(), 161, 261, kTouchId2, delegate.get());
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
 
   delegate->Reset();
-  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                           kTouchId1, tes.Now());
-  ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(130, 201),
+  ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::PointF(130.f, 201.f),
                           kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&release1);
   DispatchEventUsingWindowDispatcher(&release2);
 
   EXPECT_3_EVENTS(delegate->events(),
                   ui::ET_GESTURE_END,
                   ui::ET_SCROLL_FLING_START,
                   ui::ET_GESTURE_END);
 }
 
 // Like as GestureEventTouchMoveConsumed but tests the different behavior
 // depending on whether the events were consumed before or after the scroll
 // started.
 TEST_F(GestureRecognizerTest, GestureEventScrollTouchMovePartialConsumed) {
   scoped_ptr<ConsumesTouchMovesDelegate> delegate(
       new ConsumesTouchMovesDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 5;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   TimedEvents tes;
 
   delegate->Reset();
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_FALSE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_TRUE(delegate->begin());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
@@ skipping 49 matching lines @@
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
   EXPECT_EQ(0, delegate->scroll_x());
   EXPECT_EQ(0, delegate->scroll_y());
 
   // Release the touch.
   delegate->Reset();
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                          kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->begin());
   EXPECT_TRUE(delegate->end());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->fling());
 
   EXPECT_TRUE(delegate->scroll_end());
 }
 
 // Check that appropriate touch events generate double tap gesture events.
 TEST_F(GestureRecognizerTest, GestureEventDoubleTap) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   TimedEvents tes;
 
   // First tap (tested in GestureEventTap)
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(104, 201),
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(104.f, 201.f),
                         kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
-  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(104, 201),
+  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::PointF(104.f, 201.f),
                           kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release1);
   delegate->Reset();
 
   // Second tap
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(101, 203),
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 203.f),
                         kTouchId, tes.LeapForward(200));
   DispatchEventUsingWindowDispatcher(&press2);
-  ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(102, 206),
+  ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::PointF(102.f, 206.f),
                           kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release2);
 
   EXPECT_TRUE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_TRUE(delegate->begin());
   EXPECT_TRUE(delegate->end());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   EXPECT_EQ(2, delegate->tap_count());
 }
 
 // Check that appropriate touch events generate triple tap gesture events.
 TEST_F(GestureRecognizerTest, GestureEventTripleTap) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   TimedEvents tes;
 
   // First tap (tested in GestureEventTap)
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(104, 201),
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(104.f, 201.f),
                         kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
-  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(104, 201),
+  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::PointF(104.f, 201.f),
                           kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release1);
 
   EXPECT_EQ(1, delegate->tap_count());
   delegate->Reset();
 
   // Second tap (tested in GestureEventDoubleTap)
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(101, 203),
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 203.f),
                         kTouchId, tes.LeapForward(200));
   DispatchEventUsingWindowDispatcher(&press2);
-  ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(102, 206),
+  ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::PointF(102.f, 206.f),
                           kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release2);
 
   EXPECT_EQ(2, delegate->tap_count());
   delegate->Reset();
 
   // Third tap
-  ui::TouchEvent press3(ui::ET_TOUCH_PRESSED, gfx::Point(102, 206),
+  ui::TouchEvent press3(ui::ET_TOUCH_PRESSED, gfx::PointF(102.f, 206.f),
                         kTouchId, tes.LeapForward(200));
   DispatchEventUsingWindowDispatcher(&press3);
-  ui::TouchEvent release3(ui::ET_TOUCH_RELEASED, gfx::Point(102, 206),
+  ui::TouchEvent release3(ui::ET_TOUCH_RELEASED, gfx::PointF(102.f, 206.f),
                           kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release3);
 
   // Third, Fourth and Fifth Taps. Taps after the third should have their
   // |tap_count| wrap around back to 1.
   for (int i = 3; i < 5; ++i) {
-    ui::TouchEvent press3(ui::ET_TOUCH_PRESSED,
-                          gfx::Point(102, 206),
-                          kTouchId,
-                          tes.LeapForward(200));
+    ui::TouchEvent press3(ui::ET_TOUCH_PRESSED, gfx::PointF(102.f, 206.f),
+                          kTouchId, tes.LeapForward(200));
     DispatchEventUsingWindowDispatcher(&press3);
-    ui::TouchEvent release3(ui::ET_TOUCH_RELEASED,
-                            gfx::Point(102, 206),
-                            kTouchId,
-                            tes.LeapForward(50));
+    ui::TouchEvent release3(ui::ET_TOUCH_RELEASED, gfx::PointF(102.f, 206.f),
+                            kTouchId, tes.LeapForward(50));
     DispatchEventUsingWindowDispatcher(&release3);
 
     EXPECT_TRUE(delegate->tap());
     EXPECT_TRUE(delegate->tap_down());
     EXPECT_FALSE(delegate->tap_cancel());
     EXPECT_TRUE(delegate->begin());
     EXPECT_TRUE(delegate->end());
     EXPECT_FALSE(delegate->scroll_begin());
     EXPECT_FALSE(delegate->scroll_update());
     EXPECT_FALSE(delegate->scroll_end());
     EXPECT_EQ(1 + (i % 3), delegate->tap_count());
   }
 }
 
 // Check that we don't get a double tap when the two taps are far apart.
 TEST_F(GestureRecognizerTest, TwoTapsFarApart) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   TimedEvents tes;
 
   // First tap (tested in GestureEventTap)
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                         kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
-  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                           kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release1);
   delegate->Reset();
 
   // Second tap, close in time but far in distance
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(201, 201),
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(201.f, 201.f),
                         kTouchId, tes.LeapForward(200));
   DispatchEventUsingWindowDispatcher(&press2);
-  ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(201, 201),
+  ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::PointF(201.f, 201.f),
                           kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release2);
 
   EXPECT_TRUE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_TRUE(delegate->begin());
   EXPECT_TRUE(delegate->end());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   EXPECT_EQ(1, delegate->tap_count());
 }
 
 // Check that we don't get a double tap when the two taps have a long enough
 // delay in between.
 TEST_F(GestureRecognizerTest, TwoTapsWithDelayBetween) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   TimedEvents tes;
 
   // First tap (tested in GestureEventTap)
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                         kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
-  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                           kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release1);
   delegate->Reset();
 
   // Second tap, close in distance but after some delay
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                         kTouchId, tes.LeapForward(2000));
   DispatchEventUsingWindowDispatcher(&press2);
-  ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                           kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release2);
 
   EXPECT_TRUE(delegate->tap());
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_TRUE(delegate->begin());
   EXPECT_TRUE(delegate->end());
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->scroll_end());
 
   EXPECT_EQ(1, delegate->tap_count());
 }
 
 // Checks that if the bounding-box of a gesture changes because of change in
 // radius of a touch-point, and not because of change in position, then there
 // are not gesture events from that.
 TEST_F(GestureRecognizerTest, BoundingBoxRadiusChange) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 234;
   const int kWindowHeight = 345;
   const int kTouchId = 5, kTouchId2 = 7;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   TimedEvents tes;
 
-  ui::TouchEvent press1(
-      ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), kTouchId, tes.Now());
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
+                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
   EXPECT_TRUE(delegate->bounding_box().IsEmpty());
 
   delegate->Reset();
 
-  ui::TouchEvent press2(
-      ui::ET_TOUCH_PRESSED, gfx::Point(201, 201), kTouchId2,
-      tes.LeapForward(400));
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(201.f, 201.f),
+                        kTouchId2, tes.LeapForward(400));
   press2.set_radius_x(5);
   DispatchEventUsingWindowDispatcher(&press2);
   EXPECT_FALSE(delegate->pinch_begin());
   EXPECT_EQ(gfx::Rect(101, 196, 105, 10).ToString(),
             delegate->bounding_box().ToString());
 
   delegate->Reset();
 
-  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(50, 50), kTouchId,
+  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::PointF(50.f, 50.f), kTouchId,
                        tes.LeapForward(40));
   DispatchEventUsingWindowDispatcher(&move1);
   EXPECT_TRUE(delegate->pinch_begin());
   EXPECT_EQ(gfx::Rect(50, 50, 156, 156).ToString(),
             delegate->bounding_box().ToString());
 
   delegate->Reset();
 
   // The position doesn't move, but the radius changes.
-  ui::TouchEvent move2(
-      ui::ET_TOUCH_MOVED, gfx::Point(50, 50), kTouchId, tes.LeapForward(40));
+  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::PointF(50.f, 50.f), kTouchId,
+                       tes.LeapForward(40));
   move2.set_radius_x(50);
   move2.set_radius_y(60);
   DispatchEventUsingWindowDispatcher(&move2);
   EXPECT_FALSE(delegate->tap());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->pinch_update());
 
   delegate->Reset();
 }
 
 // Checks that slow scrolls deliver the correct deltas.
 // In particular, fix for http;//crbug.com/150573.
 TEST_F(GestureRecognizerTest, NoDriftInScroll) {
   ui::GestureConfiguration::GetInstance()
       ->set_max_touch_move_in_pixels_for_click(3);
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 234;
   const int kWindowHeight = 345;
   const int kTouchId = 5;
   TimedEvents tes;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
-  ui::TouchEvent press1(
-      ui::ET_TOUCH_PRESSED, gfx::Point(101, 208), kTouchId, tes.Now());
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 208.f),
+                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
   EXPECT_TRUE(delegate->begin());
 
   delegate->Reset();
 
-  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(101, 206), kTouchId,
+  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::PointF(101.f, 206.f), kTouchId,
                        tes.LeapForward(40));
   DispatchEventUsingWindowDispatcher(&move1);
   EXPECT_FALSE(delegate->scroll_begin());
 
   delegate->Reset();
 
-  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(101, 204), kTouchId,
+  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::PointF(101.f, 204.f), kTouchId,
                        tes.LeapForward(40));
   DispatchEventUsingWindowDispatcher(&move2);
   EXPECT_TRUE(delegate->tap_cancel());
   EXPECT_TRUE(delegate->scroll_begin());
   EXPECT_TRUE(delegate->scroll_update());
   // 3 px consumed by touch slop region.
   EXPECT_EQ(-1, delegate->scroll_y());
   EXPECT_EQ(-4, delegate->scroll_y_hint());
 
   delegate->Reset();
 
-  ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::Point(101, 204), kTouchId,
+  ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::PointF(101.f, 204.f), kTouchId,
                        tes.LeapForward(40));
   DispatchEventUsingWindowDispatcher(&move3);
   EXPECT_FALSE(delegate->scroll_update());
 
   delegate->Reset();
 
-  ui::TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::Point(101, 203), kTouchId,
+  ui::TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::PointF(101.f, 203.f), kTouchId,
                        tes.LeapForward(40));
   DispatchEventUsingWindowDispatcher(&move4);
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_EQ(-1, delegate->scroll_y());
 
   delegate->Reset();
 }
 
 // Ensure that move events which are preventDefaulted will cause a tap
 // cancel gesture event to be fired if the move would normally cause a
 // scroll. See bug http://crbug.com/146397.
 TEST_F(GestureRecognizerTest, GestureEventConsumedTouchMoveCanFireTapCancel) {
   scoped_ptr<ConsumesTouchMovesDelegate> delegate(
       new ConsumesTouchMovesDelegate());
   const int kTouchId = 5;
   gfx::Rect bounds(100, 200, 123, 45);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   TimedEvents tes;
 
   delegate->Reset();
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                        kTouchId, tes.Now());
 
   delegate->set_consume_touch_move(false);
   DispatchEventUsingWindowDispatcher(&press);
   delegate->set_consume_touch_move(true);
   delegate->Reset();
   // Move the touch-point enough so that it would normally be considered a
   // scroll. But since the touch-moves will be consumed, no scrolling should
   // occur.
   // With the unified gesture detector, we will receive a scroll begin gesture,
@@ skipping 17 matching lines @@
   const int kTouchId2 = 2;
   gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   scoped_ptr<TestEventHandler> handler(new TestEventHandler());
   window->AddPreTargetHandler(handler.get());
 
   // Start a gesture sequence on |window|. Then cancel all touches.
   // Make sure |window| receives a touch-cancel event.
   delegate->Reset();
-  ui::TouchEvent press(
-      ui::ET_TOUCH_PRESSED, gfx::Point(101, 201), kTouchId1, tes.Now());
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
+                       kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_2_EVENTS(
       delegate->events(), ui::ET_GESTURE_BEGIN, ui::ET_GESTURE_TAP_DOWN);
   delegate->Reset();
-  ui::TouchEvent p2(
-      ui::ET_TOUCH_PRESSED, gfx::Point(50, 50), kTouchId2, tes.Now());
+  ui::TouchEvent p2(ui::ET_TOUCH_PRESSED, gfx::PointF(50.f, 50.f), kTouchId2,
+                    tes.Now());
   DispatchEventUsingWindowDispatcher(&p2);
   EXPECT_2_EVENTS(
       delegate->events(), ui::ET_GESTURE_TAP_CANCEL, ui::ET_GESTURE_BEGIN);
   delegate->Reset();
-  ui::TouchEvent move(
-      ui::ET_TOUCH_MOVED, gfx::Point(350, 300), kTouchId2, tes.Now());
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(350.f, 300.f), kTouchId2,
+                      tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   EXPECT_3_EVENTS(delegate->events(),
                   ui::ET_GESTURE_SCROLL_BEGIN,
                   ui::ET_GESTURE_SCROLL_UPDATE,
                   ui::ET_GESTURE_PINCH_BEGIN);
   EXPECT_EQ(2, handler->touch_pressed_count());
   delegate->Reset();
   handler->Reset();
 
   ui::GestureRecognizer* gesture_recognizer = ui::GestureRecognizer::Get();
   EXPECT_EQ(window.get(),
             gesture_recognizer->GetTouchLockedTarget(press));
 
   ui::GestureRecognizer::Get()->CancelActiveTouchesExcept(nullptr);
 
   EXPECT_EQ(NULL, gesture_recognizer->GetTouchLockedTarget(press));
   EXPECT_4_EVENTS(delegate->events(),
                   ui::ET_GESTURE_PINCH_END,
                   ui::ET_GESTURE_SCROLL_END,
                   ui::ET_GESTURE_END,
                   ui::ET_GESTURE_END);
   const std::vector<gfx::PointF>& points = handler->cancelled_touch_points();
   EXPECT_EQ(2U, points.size());
-  EXPECT_EQ(gfx::Point(101, 201), points[0]);
-  EXPECT_EQ(gfx::Point(350, 300), points[1]);
+  EXPECT_EQ(gfx::PointF(101.f, 201.f), points[0]);
+  EXPECT_EQ(gfx::PointF(350.f, 300.f), points[1]);
 }
 
 // Check that appropriate touch events generate show press events
 TEST_F(GestureRecognizerTest, GestureEventShowPress) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
 
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                         kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
   EXPECT_TRUE(delegate->tap_down());
   EXPECT_TRUE(delegate->begin());
   EXPECT_FALSE(delegate->tap_cancel());
 
   // We haven't pressed long enough for a show press to occur
   EXPECT_FALSE(delegate->show_press());
 
   // Wait until the timer runs out
   delegate->WaitUntilReceivedGesture(ui::ET_GESTURE_SHOW_PRESS);
   EXPECT_TRUE(delegate->show_press());
   EXPECT_FALSE(delegate->tap_cancel());
 
   delegate->Reset();
-  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                           kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_FALSE(delegate->long_press());
 
   // Note the tap isn't dispatched until the release
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_TRUE(delegate->tap());
 }
 
 // Check that scrolling cancels a show press
 TEST_F(GestureRecognizerTest, GestureEventShowPressCancelledByScroll) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 6;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
 
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                         kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
   EXPECT_TRUE(delegate->tap_down());
 
   // We haven't pressed long enough for a show press to occur
   EXPECT_FALSE(delegate->show_press());
   EXPECT_FALSE(delegate->tap_cancel());
 
   // Scroll around, to cancel the show press
   tes.SendScrollEvent(event_processor(), 130, 230, kTouchId, delegate.get());
   // Wait until the timer runs out
   DelayByShowPressTimeout();
   EXPECT_FALSE(delegate->show_press());
   EXPECT_TRUE(delegate->tap_cancel());
 
   delegate->Reset();
-  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                           kTouchId, tes.LeapForward(10));
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_FALSE(delegate->show_press());
   EXPECT_FALSE(delegate->tap_cancel());
 }
 
 // Test that show press events are sent immediately on tap
 TEST_F(GestureRecognizerTest, GestureEventShowPressSentOnTap) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 6;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
 
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                         kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
   EXPECT_TRUE(delegate->tap_down());
 
   // We haven't pressed long enough for a show press to occur
   EXPECT_FALSE(delegate->show_press());
   EXPECT_FALSE(delegate->tap_cancel());
 
   delegate->Reset();
-  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release1(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                           kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release1);
   EXPECT_TRUE(delegate->show_press());
   EXPECT_FALSE(delegate->tap_cancel());
   EXPECT_TRUE(delegate->tap());
 }
 
 // Test that consuming the first move touch event prevents a scroll.
 TEST_F(GestureRecognizerTest, GestureEventConsumedTouchMoveScrollTest) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
 
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
-                       kTouchId, tes.Now());
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(0.f, 0.f), kTouchId,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   delegate->ReceivedAck();
 
   // A touch move within the slop region is never consumed in web contents. The
   // unified GR won't prevent scroll if a touch move within the slop region is
   // consumed, so make sure this touch move exceeds the slop region.
-  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(10, 10),
-                       kTouchId, tes.Now());
+  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::PointF(10.f, 10.f), kTouchId,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move1);
   delegate->ReceivedAckPreventDefaulted();
 
-  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(20, 20),
-                       kTouchId, tes.Now());
+  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::PointF(20.f, 20.f), kTouchId,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move2);
   delegate->ReceivedAck();
 
     // With the unified gesture detector, consuming the first touch move event
     // won't prevent all future scrolling.
     EXPECT_TRUE(delegate->scroll_begin());
     EXPECT_TRUE(delegate->scroll_update());
 }
 
 // Test that consuming the first move touch doesn't prevent a tap.
 TEST_F(GestureRecognizerTest, GestureEventConsumedTouchMoveTapTest) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kTouchId = 7;
   gfx::Rect bounds(0, 0, 1000, 1000);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
 
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
-                       kTouchId, tes.Now());
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(0.f, 0.f), kTouchId,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   delegate->ReceivedAck();
 
-  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(2, 2),
-                       kTouchId, tes.Now());
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(2.f, 2.f), kTouchId,
+                      tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   delegate->ReceivedAckPreventDefaulted();
 
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(2, 2),
-                         kTouchId, tes.LeapForward(50));
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(2.f, 2.f), kTouchId,
+                         tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release);
   delegate->ReceivedAck();
 
   EXPECT_TRUE(delegate->tap());
 }
 
 // Test that consuming the first move touch doesn't prevent a long press.
 TEST_F(GestureRecognizerTest, GestureEventConsumedTouchMoveLongPressTest) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
 
   delegate->Reset();
 
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                         kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
   delegate->ReceivedAck();
 
-  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(103, 203),
-                       kTouchId, tes.Now());
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(103.f, 203.f), kTouchId,
+                      tes.Now());
   DispatchEventUsingWindowDispatcher(&move);
   delegate->ReceivedAckPreventDefaulted();
 
   // Wait until the timer runs out
   delegate->WaitUntilReceivedGesture(ui::ET_GESTURE_LONG_PRESS);
   EXPECT_TRUE(delegate->long_press());
 }
 
 // Tests that the deltas are correct when leaving the slop region very slowly.
 TEST_F(GestureRecognizerTest, TestExceedingSlopSlowly) {
   ui::GestureConfiguration::GetInstance()
       ->set_max_touch_move_in_pixels_for_click(3);
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   const int kWindowWidth = 234;
   const int kWindowHeight = 345;
   const int kTouchId = 5;
   TimedEvents tes;
   gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
-  ui::TouchEvent press(
-      ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), kTouchId, tes.Now());
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(10.f, 10.f), kTouchId,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   delegate->Reset();
 
-  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(11, 10), kTouchId,
+  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::PointF(11.f, 10.f), kTouchId,
                        tes.LeapForward(40));
   DispatchEventUsingWindowDispatcher(&move1);
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_EQ(0, delegate->scroll_x());
   EXPECT_EQ(0, delegate->scroll_x_hint());
   delegate->Reset();
 
-  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(12, 10), kTouchId,
+  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::PointF(12.f, 10.f), kTouchId,
                        tes.LeapForward(40));
   DispatchEventUsingWindowDispatcher(&move2);
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_EQ(0, delegate->scroll_x());
   EXPECT_EQ(0, delegate->scroll_x_hint());
   delegate->Reset();
 
 
   ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::PointF(13.1f, 10.f), kTouchId,
                        tes.LeapForward(40));
   DispatchEventUsingWindowDispatcher(&move3);
   EXPECT_TRUE(delegate->scroll_begin());
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_NEAR(0.1, delegate->scroll_x(), 0.0001);
   EXPECT_FLOAT_EQ(3.1f, delegate->scroll_x_hint());
   delegate->Reset();
 
-  ui::TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::Point(14, 10), kTouchId,
+  ui::TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::PointF(14.f, 10.f), kTouchId,
                        tes.LeapForward(40));
   DispatchEventUsingWindowDispatcher(&move4);
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_NEAR(0.9, delegate->scroll_x(), 0.0001);
   EXPECT_EQ(0.f, delegate->scroll_x_hint());
   delegate->Reset();
 }
 
 TEST_F(GestureRecognizerTest, ScrollAlternatelyConsumedTest) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kWindowWidth = 3000;
   const int kWindowHeight = 3000;
   const int kTouchId = 2;
   gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
 
   delegate->Reset();
 
   int x = 0;
   int y = 0;
 
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(x, y),
-                        kTouchId, tes.Now());
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(x, y), kTouchId,
+                        tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
   delegate->ReceivedAck();
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   delegate->Reset();
 
   x += 100;
   y += 100;
-  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(x, y),
-                       kTouchId, tes.Now());
+  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::PointF(x, y), kTouchId,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move1);
   delegate->ReceivedAck();
   EXPECT_TRUE(delegate->scroll_begin());
   EXPECT_TRUE(delegate->scroll_update());
   delegate->Reset();
 
   for (int i = 0; i < 3; ++i) {
     x += 10;
     y += 10;
-    ui::TouchEvent move2(
-        ui::ET_TOUCH_MOVED, gfx::Point(x, y), kTouchId, tes.Now());
+    ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::PointF(x, y), kTouchId,
+                         tes.Now());
     DispatchEventUsingWindowDispatcher(&move2);
     delegate->ReceivedAck();
     EXPECT_FALSE(delegate->scroll_begin());
     EXPECT_TRUE(delegate->scroll_update());
     EXPECT_EQ(10, delegate->scroll_x());
     EXPECT_EQ(10, delegate->scroll_y());
     delegate->Reset();
 
     x += 20;
     y += 20;
-    ui::TouchEvent move3(
-        ui::ET_TOUCH_MOVED, gfx::Point(x, y), kTouchId, tes.Now());
+    ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::PointF(x, y), kTouchId,
+                         tes.Now());
     DispatchEventUsingWindowDispatcher(&move3);
     delegate->ReceivedAckPreventDefaulted();
     EXPECT_FALSE(delegate->scroll_begin());
     EXPECT_FALSE(delegate->scroll_update());
     delegate->Reset();
   }
 }
 
 TEST_F(GestureRecognizerTest, PinchAlternatelyConsumedTest) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kWindowWidth = 3000;
   const int kWindowHeight = 3000;
   const int kTouchId1 = 5;
   const int kTouchId2 = 7;
   gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
   delegate->Reset();
 
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(0, 0),
-                        kTouchId1, tes.Now());
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(0.f, 0.f), kTouchId1,
+                        tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
   delegate->ReceivedAck();
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   delegate->Reset();
 
   int x = 0;
   int y = 0;
 
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(x, y),
-                        kTouchId2, tes.Now());
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(x, y), kTouchId2,
+                        tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
   delegate->ReceivedAck();
   EXPECT_FALSE(delegate->scroll_begin());
   EXPECT_FALSE(delegate->scroll_update());
   EXPECT_FALSE(delegate->pinch_begin());
   EXPECT_FALSE(delegate->pinch_update());
 
   delegate->Reset();
 
   x += 100;
   y += 100;
-  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(x, y),
-                       kTouchId2, tes.Now());
+  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::PointF(x, y), kTouchId2,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move1);
   delegate->ReceivedAck();
   EXPECT_TRUE(delegate->scroll_begin());
   EXPECT_TRUE(delegate->scroll_update());
   EXPECT_TRUE(delegate->pinch_begin());
   EXPECT_FALSE(delegate->pinch_update());
   delegate->Reset();
 
   const float expected_scales[] = {1.5f, 1.2f, 1.125f};
 
   for (int i = 0; i < 3; ++i) {
     x += 50;
     y += 50;
-    ui::TouchEvent move2(
-        ui::ET_TOUCH_MOVED, gfx::Point(x, y), kTouchId2, tes.Now());
+    ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::PointF(x, y), kTouchId2,
+                         tes.Now());
     DispatchEventUsingWindowDispatcher(&move2);
     delegate->ReceivedAck();
     EXPECT_FALSE(delegate->scroll_begin());
     EXPECT_TRUE(delegate->scroll_update());
     EXPECT_FALSE(delegate->scroll_end());
     EXPECT_FALSE(delegate->pinch_begin());
     EXPECT_TRUE(delegate->pinch_update());
     EXPECT_FALSE(delegate->pinch_end());
     EXPECT_EQ(25, delegate->scroll_x());
     EXPECT_EQ(25, delegate->scroll_y());
     EXPECT_FLOAT_EQ(expected_scales[i], delegate->scale());
     delegate->Reset();
 
     x += 100;
     y += 100;
-    ui::TouchEvent move3(
-        ui::ET_TOUCH_MOVED, gfx::Point(x, y), kTouchId2, tes.Now());
+    ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::PointF(x, y), kTouchId2,
+                         tes.Now());
     DispatchEventUsingWindowDispatcher(&move3);
     delegate->ReceivedAckPreventDefaulted();
     EXPECT_FALSE(delegate->scroll_begin());
     EXPECT_FALSE(delegate->scroll_update());
     EXPECT_FALSE(delegate->scroll_end());
     EXPECT_FALSE(delegate->pinch_begin());
     EXPECT_FALSE(delegate->pinch_update());
     EXPECT_FALSE(delegate->pinch_end());
     delegate->Reset();
   }
 }
 
 // Test that touch event flags are passed through to the gesture event.
 TEST_F(GestureRecognizerTest, GestureEventFlagsPassedFromTouchEvent) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 6;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
   delegate->Reset();
 
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                         kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
   EXPECT_TRUE(delegate->tap_down());
 
   int default_flags = delegate->flags();
 
-  ui::TouchEvent move1(
-      ui::ET_TOUCH_MOVED, gfx::Point(397, 149), kTouchId, tes.LeapForward(50));
+  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::PointF(397.f, 149.f), kTouchId,
+                       tes.LeapForward(50));
   move1.set_flags(992);
 
   DispatchEventUsingWindowDispatcher(&move1);
   EXPECT_NE(default_flags, delegate->flags());
 }
 
 // A delegate that deletes a window on long press.
 class GestureEventDeleteWindowOnLongPress : public GestureEventConsumeDelegate {
  public:
   GestureEventDeleteWindowOnLongPress()
@@ skipping 20 matching lines @@
 TEST_F(GestureRecognizerTest, GestureEventLongPressDeletingWindow) {
   GestureEventDeleteWindowOnLongPress delegate;
   const int kWindowWidth = 123;
   const int kWindowHeight = 45;
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, kWindowWidth, kWindowHeight);
   aura::Window* window(CreateTestWindowWithDelegate(
       &delegate, -1234, bounds, root_window()));
   delegate.set_window(&window);
 
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED,
-                        gfx::Point(101, 201),
-                        kTouchId,
-                        ui::EventTimeForNow());
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
+                        kTouchId, ui::EventTimeForNow());
   DispatchEventUsingWindowDispatcher(&press1);
   EXPECT_TRUE(window != NULL);
 
   // Wait until the timer runs out.
   delegate.WaitUntilReceivedGesture(ui::ET_GESTURE_LONG_PRESS);
   EXPECT_EQ(NULL, window);
 }
 
 TEST_F(GestureRecognizerWithSwitchTest, GestureEventSmallPinchDisabled) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 300;
   const int kWindowHeight = 400;
   const int kTouchId1 = 3;
   const int kTouchId2 = 5;
   gfx::Rect bounds(5, 5, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 301),
-                       kTouchId1, tes.Now());
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 301.f),
+                        kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(10.f, 10.f),
                         kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
 
   // Move the first finger.
   delegate->Reset();
-  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(65, 201),
-                       kTouchId1, tes.Now());
+  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::PointF(65.f, 201.f), kTouchId1,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move1);
 
   EXPECT_3_EVENTS(delegate->events(),
                   ui::ET_GESTURE_SCROLL_BEGIN,
                   ui::ET_GESTURE_SCROLL_UPDATE,
                   ui::ET_GESTURE_PINCH_BEGIN);
 
   // No pinch update occurs, as kCompensateForUnstablePinchZoom is on and
   // |min_pinch_update_span_delta| was nonzero, and this is a very small pinch.
   delegate->Reset();
-  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(65, 202),
-                       kTouchId1, tes.Now());
+  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::PointF(65.f, 202.f), kTouchId1,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move2);
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
 }
 
 TEST_F(GestureRecognizerTest, GestureEventSmallPinchEnabled) {
   scoped_ptr<GestureEventConsumeDelegate> delegate(
       new GestureEventConsumeDelegate());
   TimedEvents tes;
   const int kWindowWidth = 300;
   const int kWindowHeight = 400;
   const int kTouchId1 = 3;
   const int kTouchId2 = 5;
   gfx::Rect bounds(5, 5, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
 
-  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::Point(101, 301),
-                       kTouchId1, tes.Now());
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 301.f),
+                        kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
-  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10),
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(10.f, 10.f),
                         kTouchId2, tes.Now());
   DispatchEventUsingWindowDispatcher(&press2);
 
   // Move the first finger.
   delegate->Reset();
-  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::Point(65, 201),
-                       kTouchId1, tes.Now());
+  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::PointF(65.f, 201.f), kTouchId1,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move1);
 
   EXPECT_3_EVENTS(delegate->events(),
                   ui::ET_GESTURE_SCROLL_BEGIN,
                   ui::ET_GESTURE_SCROLL_UPDATE,
                   ui::ET_GESTURE_PINCH_BEGIN);
 
   delegate->Reset();
-  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(65, 202),
-                       kTouchId1, tes.Now());
+  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::PointF(65.f, 202.f), kTouchId1,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move2);
   EXPECT_2_EVENTS(delegate->events(),
                   ui::ET_GESTURE_SCROLL_UPDATE,
                   ui::ET_GESTURE_PINCH_UPDATE);
 }
 
 // Tests that delaying the ack of a touch release doesn't trigger a long press
 // gesture.
 TEST_F(GestureRecognizerTest, EagerGestureDetection) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kTouchId = 2;
   gfx::Rect bounds(100, 200, 100, 100);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
 
   delegate->Reset();
-  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::Point(101, 201),
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 201.f),
                        kTouchId, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
-  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::Point(101, 201),
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(101.f, 201.f),
                          kTouchId, tes.LeapForward(50));
   DispatchEventUsingWindowDispatcher(&release);
 
   delegate->Reset();
   // Ack the touch press.
   delegate->ReceivedAck();
   EXPECT_TRUE(delegate->tap_down());
 
   delegate->Reset();
   // Wait until the long press event would fire (if we weren't eager).
@@ skipping 12 matching lines @@
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kWindowWidth = 300;
   const int kWindowHeight = 400;
   const int kTouchId1 = 3;
   gfx::Rect bounds(5, 5, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
 
-  ui::TouchEvent press1(
-      ui::ET_TOUCH_PRESSED, gfx::Point(101, 301), kTouchId1, tes.Now());
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(101.f, 301.f),
+                        kTouchId1, tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
   delegate->ReceivedAck();
 
   EXPECT_2_EVENTS(
       delegate->events(), ui::ET_GESTURE_BEGIN, ui::ET_GESTURE_TAP_DOWN);
 
   // Move the first finger.
   delegate->Reset();
-  ui::TouchEvent move1(
-      ui::ET_TOUCH_MOVED, gfx::Point(65, 201), kTouchId1, tes.Now());
+  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::PointF(65.f, 201.f), kTouchId1,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move1);
   delegate->ReceivedAck();
 
   EXPECT_3_EVENTS(delegate->events(),
                   ui::ET_GESTURE_TAP_CANCEL,
                   ui::ET_GESTURE_SCROLL_BEGIN,
                   ui::ET_GESTURE_SCROLL_UPDATE);
 
   delegate->Reset();
 
   // Send a valid event, but don't ack it.
-  ui::TouchEvent move2(
-      ui::ET_TOUCH_MOVED, gfx::Point(65, 202), kTouchId1, tes.Now());
+  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::PointF(65.f, 202.f), kTouchId1,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move2);
   EXPECT_0_EVENTS(delegate->events());
 
   // Send a touchmove event at the same location as the previous touchmove
   // event. This shouldn't do anything.
-  ui::TouchEvent move3(
-      ui::ET_TOUCH_MOVED, gfx::Point(65, 202), kTouchId1, tes.Now());
+  ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::PointF(65.f, 202.f), kTouchId1,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move3);
 
   // Ack the previous valid event. The intermediary invalid event shouldn't
   // interfere.
   delegate->ReceivedAck();
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
 }
 
 // Tests that an event stream can have a mix of sync and async acks.
 TEST_F(GestureRecognizerTest,
        MixedSyncAndAsyncAcksDontCauseOutOfOrderDispatch) {
   scoped_ptr<QueueTouchEventDelegate> delegate(
       new QueueTouchEventDelegate(host()->dispatcher()));
   TimedEvents tes;
   const int kWindowWidth = 300;
   const int kWindowHeight = 400;
   const int kTouchId1 = 3;
   gfx::Rect bounds(0, 0, kWindowWidth, kWindowHeight);
   scoped_ptr<aura::Window> window(CreateTestWindowWithDelegate(
       delegate.get(), -1234, bounds, root_window()));
   delegate->set_window(window.get());
 
   // Start a scroll gesture.
-  ui::TouchEvent press1(
-      ui::ET_TOUCH_PRESSED, gfx::Point(0, 0), kTouchId1, tes.Now());
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(0.f, 0.f), kTouchId1,
+                        tes.Now());
   DispatchEventUsingWindowDispatcher(&press1);
   delegate->ReceivedAck();
 
-  ui::TouchEvent move1(
-      ui::ET_TOUCH_MOVED, gfx::Point(100, 100), kTouchId1, tes.Now());
+  ui::TouchEvent move1(ui::ET_TOUCH_MOVED, gfx::PointF(100.f, 100.f), kTouchId1,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move1);
   delegate->ReceivedAck();
 
   delegate->Reset();
   // Dispatch a synchronously consumed touch move, which should be ignored.
   delegate->set_synchronous_ack_for_next_event(true);
-  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(200, 200), kTouchId1,
+  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::PointF(200.f, 200.f), kTouchId1,
                        tes.Now());
   DispatchEventUsingWindowDispatcher(&move2);
   EXPECT_0_EVENTS(delegate->events());
 
   // Dispatch a touch move, but don't ack it.
-  ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::Point(300, 300), kTouchId1,
+  ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::PointF(300.f, 300.f), kTouchId1,
                        tes.Now());
   DispatchEventUsingWindowDispatcher(&move3);
 
   // Dispatch two synchronously consumed touch moves, which should be ignored.
   delegate->set_synchronous_ack_for_next_event(true);
-  ui::TouchEvent move4(
-      ui::ET_TOUCH_MOVED, gfx::Point(400, 400), kTouchId1, tes.Now());
+  ui::TouchEvent move4(ui::ET_TOUCH_MOVED, gfx::PointF(400.f, 400.f), kTouchId1,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move4);
 
   delegate->set_synchronous_ack_for_next_event(true);
-  ui::TouchEvent move5(
-      ui::ET_TOUCH_MOVED, gfx::Point(500, 500), kTouchId1, tes.Now());
+  ui::TouchEvent move5(ui::ET_TOUCH_MOVED, gfx::PointF(500.f, 500.f), kTouchId1,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move5);
 
   EXPECT_0_EVENTS(delegate->events());
   EXPECT_EQ(100, delegate->bounding_box().x());
   // Ack the pending touch move, and ensure the most recent gesture event
   // used its co-ordinates.
   delegate->ReceivedAck();
   EXPECT_EQ(300, delegate->bounding_box().x());
   EXPECT_1_EVENT(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE);
 
   // Dispatch a touch move, but don't ack it.
   delegate->Reset();
-  ui::TouchEvent move6(ui::ET_TOUCH_MOVED, gfx::Point(600, 600), kTouchId1,
+  ui::TouchEvent move6(ui::ET_TOUCH_MOVED, gfx::PointF(600.f, 600.f), kTouchId1,
                        tes.Now());
   DispatchEventUsingWindowDispatcher(&move6);
 
   // Dispatch a synchronously unconsumed touch move.
   delegate->set_synchronous_ack_for_next_event(false);
-  ui::TouchEvent move7(
-      ui::ET_TOUCH_MOVED, gfx::Point(700, 700), kTouchId1, tes.Now());
+  ui::TouchEvent move7(ui::ET_TOUCH_MOVED, gfx::PointF(700.f, 700.f), kTouchId1,
+                       tes.Now());
   DispatchEventUsingWindowDispatcher(&move7);
 
   // The synchronous ack is stuck behind the pending touch move.
   EXPECT_0_EVENTS(delegate->events());
 
   delegate->ReceivedAck();
   EXPECT_2_EVENTS(delegate->events(), ui::ET_GESTURE_SCROLL_UPDATE,
                   ui::ET_GESTURE_SCROLL_UPDATE);
 }
 
 }  // namespace test
 }  // namespace aura