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

components/mus/ws/event_dispatcher_unittest.cc

 // Copyright 2015 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 "components/mus/ws/event_dispatcher.h"
 
 #include "components/mus/public/cpp/event_matcher.h"
 #include "components/mus/ws/event_dispatcher_delegate.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/test_server_window_delegate.h"
@@ skipping 126 matching lines @@
 
   root.SetBounds(gfx::Rect(0, 0, 100, 100));
   child.SetBounds(gfx::Rect(10, 10, 20, 20));
 
   TestEventDispatcherDelegate event_dispatcher_delegate(&root);
   EventDispatcher dispatcher(&event_dispatcher_delegate);
   dispatcher.set_root(&root);
 
   // Send event that is over child.
   const ui::MouseEvent ui_event(
-      ui::ET_MOUSE_PRESSED, gfx::PointF(20.f, 25.f), gfx::PointF(20.f, 25.f),
+      ui::ET_MOUSE_PRESSED, gfx::Point(20, 25), gfx::Point(20, 25),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   dispatcher.OnEvent(
       mojom::Event::From(static_cast<const ui::Event&>(ui_event)));
 
   ASSERT_EQ(&child, event_dispatcher_delegate.last_target());
 
   mojom::EventPtr dispatched_event_mojo =
       event_dispatcher_delegate.GetAndClearLastDispatchedEvent();
   ASSERT_TRUE(dispatched_event_mojo.get());
   scoped_ptr<ui::Event> dispatched_event(
@@ skipping 52 matching lines @@
 
   root.SetBounds(gfx::Rect(0, 0, 100, 100));
   child.SetBounds(gfx::Rect(10, 10, 20, 20));
 
   TestEventDispatcherDelegate event_dispatcher_delegate(&root);
   EventDispatcher dispatcher(&event_dispatcher_delegate);
   dispatcher.set_root(&root);
 
   MouseEventTest tests[] = {
       // Send a mouse down event over child.
-      {ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::PointF(20.f, 25.f),
-                      gfx::PointF(20.f, 25.f), base::TimeDelta(),
+      {ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(20, 25),
+                      gfx::Point(20, 25), base::TimeDelta(),
                       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON),
        &child, gfx::Point(20, 25), gfx::Point(10, 15)},
       // Capture should be activated. Let's send a mouse move outside the bounds
       // of the child.
-      {ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::PointF(50.f, 50.f),
-                      gfx::PointF(50.f, 50.f), base::TimeDelta(),
+      {ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(50, 50),
+                      gfx::Point(50, 50), base::TimeDelta(),
                       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON),
        &child, gfx::Point(50, 50), gfx::Point(40, 40)},
       // Release the mouse and verify that the mouse up event goes to the child.
-      {ui::MouseEvent(ui::ET_MOUSE_RELEASED, gfx::PointF(50.f, 50.f),
-                      gfx::PointF(50.f, 50.f), base::TimeDelta(),
+      {ui::MouseEvent(ui::ET_MOUSE_RELEASED, gfx::Point(50, 50),
+                      gfx::Point(50, 50), base::TimeDelta(),
                       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON),
        &child, gfx::Point(50, 50), gfx::Point(40, 40)},
       // A mouse move at (50, 50) should now go to the root window.
-      {ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::PointF(50.f, 50.f),
-                      gfx::PointF(50.f, 50.f), base::TimeDelta(),
+      {ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(50, 50),
+                      gfx::Point(50, 50), base::TimeDelta(),
                       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON),
        &root, gfx::Point(50, 50), gfx::Point(50, 50)},
 
   };
   RunMouseEventTests(&dispatcher, &event_dispatcher_delegate, tests,
                      arraysize(tests));
 }
 
 TEST(EventDispatcherTest, CaptureMultipleMouseButtons) {
   TestServerWindowDelegate window_delegate;
   ServerWindow root(&window_delegate, WindowId(1, 2));
   window_delegate.set_root_window(&root);
   root.SetVisible(true);
 
   ServerWindow child(&window_delegate, WindowId(1, 3));
   root.Add(&child);
   child.SetVisible(true);
 
   root.SetBounds(gfx::Rect(0, 0, 100, 100));
   child.SetBounds(gfx::Rect(10, 10, 20, 20));
 
   TestEventDispatcherDelegate event_dispatcher_delegate(&root);
   EventDispatcher dispatcher(&event_dispatcher_delegate);
   dispatcher.set_root(&root);
 
   MouseEventTest tests[] = {
       // Send a mouse down event over child with a left mouse button
-      {ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::PointF(20.f, 25.f),
-                      gfx::PointF(20.f, 25.f), base::TimeDelta(),
+      {ui::MouseEvent(ui::ET_MOUSE_PRESSED, gfx::Point(20, 25),
+                      gfx::Point(20, 25), base::TimeDelta(),
                       ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON),
        &child, gfx::Point(20, 25), gfx::Point(10, 15)},
       // Capture should be activated. Let's send a mouse move outside the bounds
       // of the child and press the right mouse button too.
-      {ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::PointF(50.f, 50.f),
-                      gfx::PointF(50.f, 50.f), base::TimeDelta(),
+      {ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(50, 50),
+                      gfx::Point(50, 50), base::TimeDelta(),
                       ui::EF_LEFT_MOUSE_BUTTON | ui::EF_RIGHT_MOUSE_BUTTON, 0),
        &child, gfx::Point(50, 50), gfx::Point(40, 40)},
       // Release the left mouse button and verify that the mouse up event goes
       // to the child.
-      {ui::MouseEvent(ui::ET_MOUSE_RELEASED, gfx::PointF(50.f, 50.f),
-                      gfx::PointF(50.f, 50.f), base::TimeDelta(),
+      {ui::MouseEvent(ui::ET_MOUSE_RELEASED, gfx::Point(50, 50),
+                      gfx::Point(50, 50), base::TimeDelta(),
                       ui::EF_LEFT_MOUSE_BUTTON | ui::EF_RIGHT_MOUSE_BUTTON,
                       ui::EF_RIGHT_MOUSE_BUTTON),
        &child, gfx::Point(50, 50), gfx::Point(40, 40)},
       // A mouse move at (50, 50) should still go to the child.
-      {ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::PointF(50.f, 50.f),
-                      gfx::PointF(50.f, 50.f), base::TimeDelta(),
+      {ui::MouseEvent(ui::ET_MOUSE_MOVED, gfx::Point(50, 50),
+                      gfx::Point(50, 50), base::TimeDelta(),
                       ui::EF_LEFT_MOUSE_BUTTON, 0),
        &child, gfx::Point(50, 50), gfx::Point(40, 40)},
 
   };
   RunMouseEventTests(&dispatcher, &event_dispatcher_delegate, tests,
                      arraysize(tests));
 }
 
 TEST(EventDispatcherTest, ClientAreaGoesToOwner) {
   TestServerWindowDelegate window_delegate;
   ServerWindow root(&window_delegate, WindowId(1, 2));
   window_delegate.set_root_window(&root);
   root.SetVisible(true);
 
   ServerWindow child(&window_delegate, WindowId(1, 3));
   root.Add(&child);
   child.SetVisible(true);
 
   root.SetBounds(gfx::Rect(0, 0, 100, 100));
   child.SetBounds(gfx::Rect(10, 10, 20, 20));
 
   child.SetClientArea(gfx::Rect(5, 5, 10, 10));
 
   TestEventDispatcherDelegate event_dispatcher_delegate(&root);
   EventDispatcher dispatcher(&event_dispatcher_delegate);
   dispatcher.set_root(&root);
 
   // Start move loop by sending mouse event over non-client area.
   const ui::MouseEvent press_event(
-      ui::ET_MOUSE_PRESSED, gfx::PointF(12.f, 12.f), gfx::PointF(12.f, 12.f),
+      ui::ET_MOUSE_PRESSED, gfx::Point(12, 12), gfx::Point(12, 12),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   dispatcher.OnEvent(
       mojom::Event::From(static_cast<const ui::Event&>(press_event)));
 
   // Events should target child and be in the non-client area.
   ASSERT_EQ(&child, event_dispatcher_delegate.last_target());
   EXPECT_TRUE(event_dispatcher_delegate.GetAndClearLastInNonclientArea());
 
   // Move the mouse 5,6 pixels and target is the same.
-  const ui::MouseEvent move_event(ui::ET_MOUSE_MOVED, gfx::PointF(17.f, 18.f),
-                                  gfx::PointF(17.f, 18.f), base::TimeDelta(),
+  const ui::MouseEvent move_event(ui::ET_MOUSE_MOVED, gfx::Point(17, 18),
+                                  gfx::Point(17, 18), base::TimeDelta(),
                                   ui::EF_LEFT_MOUSE_BUTTON, 0);
   dispatcher.OnEvent(
       mojom::Event::From(static_cast<const ui::Event&>(move_event)));
 
   // Still same target.
   ASSERT_EQ(&child, event_dispatcher_delegate.last_target());
   EXPECT_TRUE(event_dispatcher_delegate.GetAndClearLastInNonclientArea());
 
   // Release the mouse.
   const ui::MouseEvent release_event(
-      ui::ET_MOUSE_RELEASED, gfx::PointF(17.f, 18.f), gfx::PointF(17.f, 18.f),
+      ui::ET_MOUSE_RELEASED, gfx::Point(17, 18), gfx::Point(17, 18),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   dispatcher.OnEvent(
       mojom::Event::From(static_cast<const ui::Event&>(release_event)));
 
   // The event should not have been dispatched to the delegate.
   ASSERT_EQ(&child, event_dispatcher_delegate.last_target());
   EXPECT_TRUE(event_dispatcher_delegate.GetAndClearLastInNonclientArea());
 
   // Press in the client area and verify target/client area.
   const ui::MouseEvent press_event2(
-      ui::ET_MOUSE_PRESSED, gfx::PointF(21.f, 22.f), gfx::PointF(21.f, 22.f),
+      ui::ET_MOUSE_PRESSED, gfx::Point(21, 22), gfx::Point(21, 22),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   dispatcher.OnEvent(
       mojom::Event::From(static_cast<const ui::Event&>(press_event2)));
   ASSERT_EQ(&child, event_dispatcher_delegate.last_target());
   EXPECT_FALSE(event_dispatcher_delegate.GetAndClearLastInNonclientArea());
 }
 
 TEST(EventDispatcherTest, DontFocusOnSecondDown) {
   TestServerWindowDelegate window_delegate;
   ServerWindow root(&window_delegate, WindowId(1, 2));
@@ skipping 11 matching lines @@
   root.SetBounds(gfx::Rect(0, 0, 100, 100));
   child1.SetBounds(gfx::Rect(10, 10, 20, 20));
   child2.SetBounds(gfx::Rect(50, 51, 11, 12));
 
   TestEventDispatcherDelegate event_dispatcher_delegate(&root);
   EventDispatcher dispatcher(&event_dispatcher_delegate);
   dispatcher.set_root(&root);
 
   // Press on child1. First press event should change focus.
   const ui::MouseEvent press_event(
-      ui::ET_MOUSE_PRESSED, gfx::PointF(12.f, 12.f), gfx::PointF(12.f, 12.f),
+      ui::ET_MOUSE_PRESSED, gfx::Point(12, 12), gfx::Point(12, 12),
       base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON);
   dispatcher.OnEvent(
       mojom::Event::From(static_cast<const ui::Event&>(press_event)));
   EXPECT_EQ(&child1, event_dispatcher_delegate.last_target());
   EXPECT_EQ(&child1, event_dispatcher_delegate.GetAndClearLastFocusedWindow());
 
   // Press (with a different pointer id) on child2. Event should go to child2,
   // but focus should not change.
-  const ui::TouchEvent touch_event(
-      ui::ET_TOUCH_PRESSED, gfx::PointF(53.f, 54.f), 2, base::TimeDelta());
+  const ui::TouchEvent touch_event(ui::ET_TOUCH_PRESSED, gfx::Point(53, 54), 2,
+                                   base::TimeDelta());
   dispatcher.OnEvent(
       mojom::Event::From(static_cast<const ui::Event&>(touch_event)));
   EXPECT_EQ(&child2, event_dispatcher_delegate.last_target());
   EXPECT_EQ(nullptr, event_dispatcher_delegate.GetAndClearLastFocusedWindow());
 }
 
 TEST(EventDispatcherTest, TwoPointersActive) {
   TestServerWindowDelegate window_delegate;
   ServerWindow root(&window_delegate, WindowId(1, 2));
   window_delegate.set_root_window(&root);
   root.SetVisible(true);
 
   ServerWindow child1(&window_delegate, WindowId(1, 3));
   root.Add(&child1);
   child1.SetVisible(true);
 
   ServerWindow child2(&window_delegate, WindowId(1, 4));
   root.Add(&child2);
   child2.SetVisible(true);
 
   root.SetBounds(gfx::Rect(0, 0, 100, 100));
   child1.SetBounds(gfx::Rect(10, 10, 20, 20));
   child2.SetBounds(gfx::Rect(50, 51, 11, 12));
 
   TestEventDispatcherDelegate event_dispatcher_delegate(&root);
   EventDispatcher dispatcher(&event_dispatcher_delegate);
   dispatcher.set_root(&root);
 
   // Press on child1.
-  const ui::TouchEvent touch_event1(
-      ui::ET_TOUCH_PRESSED, gfx::PointF(12.f, 13.f), 1, base::TimeDelta());
+  const ui::TouchEvent touch_event1(ui::ET_TOUCH_PRESSED, gfx::Point(12, 13), 1,
+                                    base::TimeDelta());
   dispatcher.OnEvent(
       mojom::Event::From(static_cast<const ui::Event&>(touch_event1)));
   EXPECT_EQ(&child1, event_dispatcher_delegate.GetAndClearLastTarget());
 
   // Drag over child2, child1 should get the drag.
-  const ui::TouchEvent drag_event1(ui::ET_TOUCH_MOVED, gfx::PointF(53.f, 54.f),
-                                   1, base::TimeDelta());
+  const ui::TouchEvent drag_event1(ui::ET_TOUCH_MOVED, gfx::Point(53, 54), 1,
+                                   base::TimeDelta());
   dispatcher.OnEvent(
       mojom::Event::From(static_cast<const ui::Event&>(drag_event1)));
   EXPECT_EQ(&child1, event_dispatcher_delegate.GetAndClearLastTarget());
 
   // Press on child2 with a different touch id.
-  const ui::TouchEvent touch_event2(
-      ui::ET_TOUCH_PRESSED, gfx::PointF(54.f, 55.f), 2, base::TimeDelta());
+  const ui::TouchEvent touch_event2(ui::ET_TOUCH_PRESSED, gfx::Point(54, 55), 2,
+                                    base::TimeDelta());
   dispatcher.OnEvent(
       mojom::Event::From(static_cast<const ui::Event&>(touch_event2)));
   EXPECT_EQ(&child2, event_dispatcher_delegate.GetAndClearLastTarget());
 
   // Drag over child1 with id 2, child2 should continue to get the drag.
-  const ui::TouchEvent drag_event2(ui::ET_TOUCH_MOVED, gfx::PointF(13.f, 14.f),
-                                   2, base::TimeDelta());
+  const ui::TouchEvent drag_event2(ui::ET_TOUCH_MOVED, gfx::Point(13, 14), 2,
+                                   base::TimeDelta());
   dispatcher.OnEvent(
       mojom::Event::From(static_cast<const ui::Event&>(drag_event2)));
   EXPECT_EQ(&child2, event_dispatcher_delegate.GetAndClearLastTarget());
 
   // Drag again with id 1, child1 should continue to get it.
   dispatcher.OnEvent(
       mojom::Event::From(static_cast<const ui::Event&>(drag_event1)));
   EXPECT_EQ(&child1, event_dispatcher_delegate.GetAndClearLastTarget());
 
   // Release touch id 1, and click on 2. 2 should get it.
-  const ui::TouchEvent touch_release(
-      ui::ET_TOUCH_RELEASED, gfx::PointF(54.f, 55.f), 1, base::TimeDelta());
+  const ui::TouchEvent touch_release(ui::ET_TOUCH_RELEASED, gfx::Point(54, 55),
+                                     1, base::TimeDelta());
   dispatcher.OnEvent(
       mojom::Event::From(static_cast<const ui::Event&>(touch_release)));
   EXPECT_EQ(&child1, event_dispatcher_delegate.GetAndClearLastTarget());
-  const ui::TouchEvent touch_event3(
-      ui::ET_TOUCH_PRESSED, gfx::PointF(54.f, 55.f), 2, base::TimeDelta());
+  const ui::TouchEvent touch_event3(ui::ET_TOUCH_PRESSED, gfx::Point(54, 55), 2,
+                                    base::TimeDelta());
   dispatcher.OnEvent(
       mojom::Event::From(static_cast<const ui::Event&>(touch_event3)));
   EXPECT_EQ(&child2, event_dispatcher_delegate.GetAndClearLastTarget());
 }
 
 TEST(EventDispatcherTest, DestroyWindowWhileGettingEvents) {
   TestServerWindowDelegate window_delegate;
   ServerWindow root(&window_delegate, WindowId(1, 2));
   window_delegate.set_root_window(&root);
   root.SetVisible(true);
 
   scoped_ptr<ServerWindow> child(
       new ServerWindow(&window_delegate, WindowId(1, 3)));
   root.Add(child.get());
   child->SetVisible(true);
 
   root.SetBounds(gfx::Rect(0, 0, 100, 100));
   child->SetBounds(gfx::Rect(10, 10, 20, 20));
 
   TestEventDispatcherDelegate event_dispatcher_delegate(&root);
   EventDispatcher dispatcher(&event_dispatcher_delegate);
   dispatcher.set_root(&root);
 
   // Press on child.
-  const ui::TouchEvent touch_event1(
-      ui::ET_TOUCH_PRESSED, gfx::PointF(12.f, 13.f), 1, base::TimeDelta());
+  const ui::TouchEvent touch_event1(ui::ET_TOUCH_PRESSED, gfx::Point(12, 13), 1,
+                                    base::TimeDelta());
   dispatcher.OnEvent(
       mojom::Event::From(static_cast<const ui::Event&>(touch_event1)));
   EXPECT_EQ(child.get(), event_dispatcher_delegate.GetAndClearLastTarget());
 
   event_dispatcher_delegate.GetAndClearLastDispatchedEvent();
 
   // Delete child, and continue the drag. Event should not be dispatched.
   child.reset();
 
-  const ui::TouchEvent drag_event1(ui::ET_TOUCH_MOVED, gfx::PointF(53.f, 54.f),
-                                   1, base::TimeDelta());
+  const ui::TouchEvent drag_event1(ui::ET_TOUCH_MOVED, gfx::Point(53, 54), 1,
+                                   base::TimeDelta());
   dispatcher.OnEvent(
       mojom::Event::From(static_cast<const ui::Event&>(drag_event1)));
   EXPECT_EQ(nullptr, event_dispatcher_delegate.GetAndClearLastTarget());
   EXPECT_EQ(nullptr,
             event_dispatcher_delegate.GetAndClearLastDispatchedEvent().get());
 }
 
 }  // namespace ws
 }  // namespace mus