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 484 matching lines @@
   base::TimeDelta LeapForward(int time_in_millis) {
     simulated_now_ += time_in_millis;
     return base::TimeDelta::FromMilliseconds(simulated_now_);
   }
 
   base::TimeDelta InFuture(int time_in_millis) {
     return base::TimeDelta::FromMilliseconds(simulated_now_ + time_in_millis);
   }
 
   void SendScrollEvents(ui::EventProcessor* dispatcher,
-                        float x_start,
-                        float y_start,
+                        int x_start,
+                        int y_start,
                         int dx,
                         int dy,
                         int touch_id,
                         int time_step,
                         int num_steps,
                         GestureEventConsumeDelegate* delegate) {
     float x = x_start;
     float y = y_start;
 
     for (int i = 0; i < num_steps; i++) {
       x += dx;
       y += dy;
-      ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(x, y),
-                          touch_id,
+      ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(x, y), touch_id,
                           base::TimeDelta::FromMilliseconds(simulated_now_));
       ui::EventDispatchDetails details = dispatcher->OnEventFromSource(&move);
       ASSERT_FALSE(details.dispatcher_destroyed);
       simulated_now_ += time_step;
     }
   }
 
   void SendScrollEvent(ui::EventProcessor* dispatcher,
                        float x,
                        float y,
                        int touch_id,
                        GestureEventConsumeDelegate* delegate) {
     delegate->Reset();
-    ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(x, y),
-                        touch_id,
+    ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(), touch_id,
                         base::TimeDelta::FromMilliseconds(simulated_now_));
+    move.set_location_f(gfx::PointF(x, y));
+    move.set_root_location_f(gfx::PointF(x, y));
     ui::EventDispatchDetails details = dispatcher->OnEventFromSource(&move);
     ASSERT_FALSE(details.dispatcher_destroyed);
     simulated_now_++;
   }
 };
 
 // An event handler to keep track of events.
 class TestEventHandler : public ui::EventHandler {
  public:
   TestEventHandler()
       : touch_released_count_(0),
         touch_pressed_count_(0),
         touch_moved_count_(0) {}
 
   ~TestEventHandler() override {}
 
   void OnTouchEvent(ui::TouchEvent* event) override {
     switch (event->type()) {
       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 533 matching lines @@
     ui::GestureConfiguration::GetInstance()->set_default_radius(radius);
     scoped_ptr<GestureEventConsumeDelegate> delegate(
         new GestureEventConsumeDelegate());
     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()));
 
-    const float kPositionX = 101;
-    const float kPositionY = 201;
+    const int kPositionX = 101;
+    const int kPositionY = 201;
     delegate->Reset();
     ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
-                         gfx::PointF(kPositionX, kPositionY),
-                         kTouchId,
+                         gfx::Point(kPositionX, kPositionY), kTouchId,
                          tes.Now());
     DispatchEventUsingWindowDispatcher(&press);
     EXPECT_EQ(gfx::Rect(kPositionX - radius, kPositionY - radius, radius * 2,
                         radius * 2),
               delegate->bounding_box());
 
     const int kScrollAmount = 50;
     tes.SendScrollEvents(event_processor(), kPositionX, kPositionY,
                          1, 1, kTouchId, 1, kScrollAmount, delegate.get());
     EXPECT_EQ(gfx::Point(1, 1).ToString(),
               delegate->scroll_begin_position().ToString());
     EXPECT_EQ(
         gfx::Rect(kPositionX + kScrollAmount - radius,
                   kPositionY + kScrollAmount - radius, radius * 2, radius * 2),
         delegate->bounding_box());
 
     // Release the touch. This should end the scroll.
     delegate->Reset();
-    ui::TouchEvent release(ui::ET_TOUCH_RELEASED,
-                               gfx::PointF(kPositionX + kScrollAmount,
-                                           kPositionY + kScrollAmount),
-                               kTouchId, press.time_stamp() +
-                               base::TimeDelta::FromMilliseconds(50));
+    ui::TouchEvent release(
+        ui::ET_TOUCH_RELEASED,
+        gfx::Point(kPositionX + kScrollAmount, kPositionY + kScrollAmount),
+        kTouchId, press.time_stamp() + base::TimeDelta::FromMilliseconds(50));
     DispatchEventUsingWindowDispatcher(&release);
     EXPECT_EQ(
         gfx::Rect(kPositionX + kScrollAmount - radius,
                   kPositionY + kScrollAmount - radius, radius * 2, radius * 2),
         delegate->bounding_box());
   }
   ui::GestureConfiguration::GetInstance()->set_default_radius(0);
 }
 
 // Check Scroll End Events report correct velocities
@@ skipping 688 matching lines @@
   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());
 
   // Move the second touch-point enough so that it is considered a pinch. This
   // should generate both SCROLL_BEGIN and PINCH_BEGIN gestures.
   queued_delegate->Reset();
   delegate->Reset();
-  ui::TouchEvent move(
-      ui::ET_TOUCH_MOVED,
-      gfx::PointF(203 +
-                      ui::GestureConfiguration::GetInstance()
-                          ->max_touch_move_in_pixels_for_click(),
-                  303),
-      kTouchId2,
-      tes.Now());
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED,
+                      gfx::Point(203 +
+                                     ui::GestureConfiguration::GetInstance()
+                                         ->max_touch_move_in_pixels_for_click(),
+                                 303),
+                      kTouchId2, tes.Now());
   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(queued_delegate->tap());
   EXPECT_FALSE(queued_delegate->tap_down());
@@ skipping 303 matching lines @@
     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());
     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),
                        kNumWindows, tes.Now());
   DispatchEventUsingWindowDispatcher(&press);
   ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(250, 250),
                       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),
                        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
@@ skipping 1387 matching lines @@
   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;
@@ skipping 225 matching lines @@
 
   ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(12, 10), 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,
+  ui::TouchEvent move3(ui::ET_TOUCH_MOVED, gfx::Point(), kTouchId,
                        tes.LeapForward(40));
+  move3.set_location_f(gfx::PointF(13.1f, 10.f));
+  move3.set_root_location_f(gfx::PointF(13.1f, 10.f));
   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,
                        tes.LeapForward(40));
   DispatchEventUsingWindowDispatcher(&move4);
@@ skipping 462 matching lines @@
   // 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