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

ui/aura/window_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 "ui/aura/window.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 789 matching lines @@
   EXPECT_EQ(0, delegate.capture_lost_count());
   EXPECT_EQ(0, delegate.capture_changed_event_count());
   ui::test::EventGenerator generator(root_window(), gfx::Point(50, 50));
   generator.PressLeftButton();
   EXPECT_EQ(1, delegate.mouse_event_count());
   generator.ReleaseLeftButton();
 
   EXPECT_EQ(2, delegate.mouse_event_count());
   delegate.ResetCounts();
 
-  ui::TouchEvent touchev(
-      ui::ET_TOUCH_PRESSED, gfx::Point(50, 50), 0, getTime());
+  ui::TouchEvent touchev(ui::ET_TOUCH_PRESSED, gfx::PointF(50.f, 50.f), 0,
+                         getTime());
   DispatchEventUsingWindowDispatcher(&touchev);
   EXPECT_EQ(1, delegate.touch_event_count());
   delegate.ResetCounts();
 
   window->ReleaseCapture();
   EXPECT_FALSE(window->HasCapture());
   EXPECT_EQ(1, delegate.capture_lost_count());
   EXPECT_EQ(1, delegate.capture_changed_event_count());
   EXPECT_EQ(1, delegate.mouse_event_count());
   EXPECT_EQ(0, delegate.touch_event_count());
 
   generator.PressLeftButton();
   EXPECT_EQ(1, delegate.mouse_event_count());
 
-  ui::TouchEvent touchev2(
-      ui::ET_TOUCH_PRESSED, gfx::Point(250, 250), 1, getTime());
+  ui::TouchEvent touchev2(ui::ET_TOUCH_PRESSED, gfx::PointF(250.f, 250.f), 1,
+                          getTime());
   DispatchEventUsingWindowDispatcher(&touchev2);
   EXPECT_EQ(0, delegate.touch_event_count());
 
   // Removing the capture window from parent should reset the capture window
   // in the root window.
   window->SetCapture();
   EXPECT_EQ(window.get(), aura::client::GetCaptureWindow(root_window()));
   window->parent()->RemoveChild(window.get());
   EXPECT_FALSE(window->HasCapture());
   EXPECT_EQ(NULL, aura::client::GetCaptureWindow(root_window()));
 }
 
 TEST_F(WindowTest, TouchCaptureCancelsOtherTouches) {
   CaptureWindowDelegateImpl delegate1;
   scoped_ptr<Window> w1(CreateTestWindowWithDelegate(
       &delegate1, 0, gfx::Rect(0, 0, 50, 50), root_window()));
   CaptureWindowDelegateImpl delegate2;
   scoped_ptr<Window> w2(CreateTestWindowWithDelegate(
       &delegate2, 0, gfx::Rect(50, 50, 50, 50), root_window()));
 
   // Press on w1.
-  ui::TouchEvent press1(
-      ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, getTime());
+  ui::TouchEvent press1(ui::ET_TOUCH_PRESSED, gfx::PointF(10.f, 10.f), 0,
+                        getTime());
   DispatchEventUsingWindowDispatcher(&press1);
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN.
   EXPECT_EQ(2, delegate1.gesture_event_count());
   delegate1.ResetCounts();
 
   // Capturing to w2 should cause the touch to be canceled.
   w2->SetCapture();
   EXPECT_EQ(1, delegate1.touch_event_count());
   EXPECT_EQ(0, delegate2.touch_event_count());
   delegate1.ResetCounts();
   delegate2.ResetCounts();
 
   // Events are now untargetted.
-  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(10, 20), 0, getTime());
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(10.f, 20.f), 0,
+                      getTime());
   DispatchEventUsingWindowDispatcher(&move);
   EXPECT_EQ(0, delegate1.gesture_event_count());
   EXPECT_EQ(0, delegate1.touch_event_count());
   EXPECT_EQ(0, delegate2.gesture_event_count());
   EXPECT_EQ(0, delegate2.touch_event_count());
 
-  ui::TouchEvent release(
-      ui::ET_TOUCH_RELEASED, gfx::Point(10, 20), 0, getTime());
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(10.f, 20.f), 0,
+                         getTime());
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_EQ(0, delegate1.gesture_event_count());
   EXPECT_EQ(0, delegate2.gesture_event_count());
 
   // A new press is captured by w2.
-  ui::TouchEvent press2(
-      ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, getTime());
+  ui::TouchEvent press2(ui::ET_TOUCH_PRESSED, gfx::PointF(10.f, 10.f), 0,
+                        getTime());
   DispatchEventUsingWindowDispatcher(&press2);
   EXPECT_EQ(0, delegate1.gesture_event_count());
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN.
   EXPECT_EQ(2, delegate2.gesture_event_count());
   delegate1.ResetCounts();
   delegate2.ResetCounts();
 
   // And releasing capture changes nothing.
   w2->ReleaseCapture();
   EXPECT_EQ(0, delegate1.gesture_event_count());
   EXPECT_EQ(0, delegate1.touch_event_count());
   EXPECT_EQ(0, delegate2.gesture_event_count());
   EXPECT_EQ(0, delegate2.touch_event_count());
 }
 
 TEST_F(WindowTest, TouchCaptureDoesntCancelCapturedTouches) {
   CaptureWindowDelegateImpl delegate;
   scoped_ptr<Window> window(CreateTestWindowWithDelegate(
       &delegate, 0, gfx::Rect(0, 0, 50, 50), root_window()));
   base::TimeDelta time = getTime();
   const int kTimeDelta = 100;
 
-  ui::TouchEvent press(
-      ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, time);
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED, gfx::PointF(10.f, 10.f), 0, time);
   DispatchEventUsingWindowDispatcher(&press);
 
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN.
   EXPECT_EQ(2, delegate.gesture_event_count());
   EXPECT_EQ(1, delegate.touch_event_count());
   delegate.ResetCounts();
 
   window->SetCapture();
   EXPECT_EQ(0, delegate.gesture_event_count());
   EXPECT_EQ(0, delegate.touch_event_count());
   delegate.ResetCounts();
 
   // On move We will get TOUCH_MOVED, GESTURE_TAP_CANCEL,
   // GESTURE_SCROLL_START and GESTURE_SCROLL_UPDATE.
   time += base::TimeDelta::FromMilliseconds(kTimeDelta);
-  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::Point(10, 20), 0, time);
+  ui::TouchEvent move(ui::ET_TOUCH_MOVED, gfx::PointF(10.f, 20.f), 0, time);
   DispatchEventUsingWindowDispatcher(&move);
   EXPECT_EQ(1, delegate.touch_event_count());
   EXPECT_EQ(3, delegate.gesture_event_count());
   delegate.ResetCounts();
 
   // Release capture shouldn't change anything.
   window->ReleaseCapture();
   EXPECT_EQ(0, delegate.touch_event_count());
   EXPECT_EQ(0, delegate.gesture_event_count());
   delegate.ResetCounts();
 
   // On move we still get TOUCH_MOVED and GESTURE_SCROLL_UPDATE.
   time += base::TimeDelta::FromMilliseconds(kTimeDelta);
-  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(10, 30), 0, time);
+  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::PointF(10.f, 30.f), 0, time);
   DispatchEventUsingWindowDispatcher(&move2);
   EXPECT_EQ(1, delegate.touch_event_count());
   EXPECT_EQ(1, delegate.gesture_event_count());
   delegate.ResetCounts();
 
   // And on release we get TOUCH_RELEASED, GESTURE_SCROLL_END, GESTURE_END
   time += base::TimeDelta::FromMilliseconds(kTimeDelta);
-  ui::TouchEvent release(
-      ui::ET_TOUCH_RELEASED, gfx::Point(10, 20), 0, time);
+  ui::TouchEvent release(ui::ET_TOUCH_RELEASED, gfx::PointF(10.f, 20.f), 0,
+                         time);
   DispatchEventUsingWindowDispatcher(&release);
   EXPECT_EQ(1, delegate.touch_event_count());
   EXPECT_EQ(2, delegate.gesture_event_count());
 }
 
 
 // Assertions around SetCapture() and touch/gestures.
 TEST_F(WindowTest, TransferCaptureTouchEvents) {
   // Touch on |w1|.
   CaptureWindowDelegateImpl d1;
   scoped_ptr<Window> w1(CreateTestWindowWithDelegate(
       &d1, 0, gfx::Rect(0, 0, 20, 20), root_window()));
-  ui::TouchEvent p1(ui::ET_TOUCH_PRESSED, gfx::Point(10, 10), 0, getTime());
+  ui::TouchEvent p1(ui::ET_TOUCH_PRESSED, gfx::PointF(10.f, 10.f), 0,
+                    getTime());
   DispatchEventUsingWindowDispatcher(&p1);
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN.
   EXPECT_EQ(1, d1.touch_event_count());
   EXPECT_EQ(2, d1.gesture_event_count());
   d1.ResetCounts();
 
   // Touch on |w2| with a different id.
   CaptureWindowDelegateImpl d2;
   scoped_ptr<Window> w2(CreateTestWindowWithDelegate(
       &d2, 0, gfx::Rect(40, 0, 40, 20), root_window()));
-  ui::TouchEvent p2(ui::ET_TOUCH_PRESSED, gfx::Point(41, 10), 1, getTime());
+  ui::TouchEvent p2(ui::ET_TOUCH_PRESSED, gfx::PointF(41.f, 10.f), 1,
+                    getTime());
   DispatchEventUsingWindowDispatcher(&p2);
   EXPECT_EQ(0, d1.touch_event_count());
   EXPECT_EQ(0, d1.gesture_event_count());
   // We will get both GESTURE_BEGIN and GESTURE_TAP_DOWN for new target window.
   EXPECT_EQ(1, d2.touch_event_count());
   EXPECT_EQ(2, d2.gesture_event_count());
   d1.ResetCounts();
   d2.ResetCounts();
 
   // Set capture on |w2|, this should send a cancel (TAP_CANCEL, END) to |w1|
@@ skipping 14 matching lines @@
   EXPECT_EQ(0, d1.touch_event_count());
   EXPECT_EQ(0, d1.gesture_event_count());
   EXPECT_EQ(1, d2.touch_event_count());
   EXPECT_EQ(2, d2.gesture_event_count());
   EXPECT_EQ(0, d3.touch_event_count());
   EXPECT_EQ(0, d3.gesture_event_count());
   d2.ResetCounts();
 
   // Move touch id originally associated with |w2|. The touch has been
   // cancelled, so no events should be dispatched.
-  ui::TouchEvent m3(ui::ET_TOUCH_MOVED, gfx::Point(110, 105), 1, getTime());
+  ui::TouchEvent m3(ui::ET_TOUCH_MOVED, gfx::PointF(110.f, 105.f), 1,
+                    getTime());
   DispatchEventUsingWindowDispatcher(&m3);
   EXPECT_EQ(0, d1.touch_event_count());
   EXPECT_EQ(0, d1.gesture_event_count());
   EXPECT_EQ(0, d2.touch_event_count());
   EXPECT_EQ(0, d2.gesture_event_count());
   EXPECT_EQ(0, d3.touch_event_count());
   EXPECT_EQ(0, d3.gesture_event_count());
 
   // When we release capture, no touches are canceled.
   w3->ReleaseCapture();
   EXPECT_EQ(0, d1.touch_event_count());
   EXPECT_EQ(0, d1.gesture_event_count());
   EXPECT_EQ(0, d2.touch_event_count());
   EXPECT_EQ(0, d2.gesture_event_count());
   EXPECT_EQ(0, d3.touch_event_count());
   EXPECT_EQ(0, d3.gesture_event_count());
 
   // The touch has been cancelled, so no events are dispatched.
-  ui::TouchEvent m4(ui::ET_TOUCH_MOVED, gfx::Point(120, 105), 1, getTime());
+  ui::TouchEvent m4(ui::ET_TOUCH_MOVED, gfx::PointF(120.f, 105.f), 1,
+                    getTime());
   DispatchEventUsingWindowDispatcher(&m4);
   EXPECT_EQ(0, d1.touch_event_count());
   EXPECT_EQ(0, d1.gesture_event_count());
   EXPECT_EQ(0, d2.touch_event_count());
   EXPECT_EQ(0, d2.gesture_event_count());
   EXPECT_EQ(0, d3.touch_event_count());
   EXPECT_EQ(0, d3.gesture_event_count());
 }
 
 // Changes capture while capture is already ongoing.
@@ skipping 209 matching lines @@
   scoped_ptr<Window> w1(
       CreateTestWindowWithDelegate(&d1, 1, gfx::Rect(10, 10, 50, 50),
                                    root_window()));
 
   ui::test::EventGenerator generator(root_window());
   generator.MoveMouseToCenterOf(w1.get());
   EXPECT_TRUE(d1.entered());
   EXPECT_FALSE(d1.exited());
   d1.ResetExpectations();
 
-  ui::MouseEvent exit_event(ui::ET_MOUSE_EXITED, gfx::Point(), gfx::Point(),
+  ui::MouseEvent exit_event(ui::ET_MOUSE_EXITED, gfx::PointF(), gfx::PointF(),
                             ui::EventTimeForNow(), 0, 0);
   DispatchEventUsingWindowDispatcher(&exit_event);
   EXPECT_FALSE(d1.entered());
   EXPECT_TRUE(d1.exited());
 }
 
 // Verifies that the WindowDelegate receives MouseExit and MouseEnter events for
 // mouse transitions from window to window, even if the entered window sets
 // and releases capture.
 TEST_F(WindowTest, MouseEnterExitWithClick) {
@@ skipping 353 matching lines @@
       new GestureTrackPositionDelegate);
   scoped_ptr<Window> window(CreateTestWindowWithDelegate(delegate.get(), -1234,
       gfx::Rect(0, 0, 20, 20), root_window()));
 
   // Rotate the root-window clock-wise 90 degrees.
   gfx::Transform transform;
   transform.Translate(size.height(), 0.0);
   transform.Rotate(90.0);
   host()->SetRootTransform(transform);
 
-  ui::TouchEvent press(
-      ui::ET_TOUCH_PRESSED, gfx::Point(size.height() - 10, 10), 0, getTime());
+  ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
+                       gfx::PointF(size.height() - 10.f, 10.f), 0, getTime());
   DispatchEventUsingWindowDispatcher(&press);
   EXPECT_EQ(gfx::Point(10, 10).ToString(), delegate->position().ToString());
 }
 
 namespace {
 DEFINE_WINDOW_PROPERTY_KEY(int, kIntKey, -2);
 DEFINE_WINDOW_PROPERTY_KEY(const char*, kStringKey, "squeamish");
 }
 
 TEST_F(WindowTest, Property) {
@@ skipping 1285 matching lines @@
 
   EXPECT_TRUE(animator.get());
   EXPECT_FALSE(animator->is_animating());
   EXPECT_TRUE(observer.animation_completed());
   EXPECT_FALSE(observer.animation_aborted());
   animator->RemoveObserver(&observer);
 }
 
 }  // namespace test
 }  // namespace aura