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

ui/events/event_processor_unittest.cc

 // Copyright (c) 2013 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 <vector>
 
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 #include "ui/events/event_target_iterator.h"
 #include "ui/events/event_targeter.h"
@@ skipping 46 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(EventProcessorTest);
 };
 
 TEST_F(EventProcessorTest, Basic) {
   scoped_ptr<TestEventTarget> child(new TestEventTarget());
   child->SetEventTargeter(
       make_scoped_ptr(new TestEventTargeter(child.get(), false)));
   SetTarget(child.get());
   root()->AddChild(child.Pass());
 
-  MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
-                   EventTimeForNow(), EF_NONE, EF_NONE);
+  MouseEvent mouse(ET_MOUSE_MOVED, gfx::PointF(10.f, 10.f),
+                   gfx::PointF(10.f, 10.f), EventTimeForNow(), EF_NONE,
+                   EF_NONE);
   DispatchEvent(&mouse);
   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
 
   SetTarget(root());
   root()->RemoveChild(root()->child_at(0));
   DispatchEvent(&mouse);
   EXPECT_TRUE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
 }
 
@@ skipping 58 matching lines @@
 
   // Indicate that an event which is dispatched to the child target owned by the
   // first event processor should be handled by |target_handler| instead.
   scoped_ptr<TestEventHandler> target_handler(
       new ReDispatchEventHandler(second_processor.get(), root()->child_at(0)));
   root()->child_at(0)->set_target_handler(target_handler.get());
 
   // Dispatch a mouse event to the tree of event targets owned by the first
   // event processor, checking in ReDispatchEventHandler that the phase and
   // target information of the event is correct.
-  MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
-                   EventTimeForNow(), EF_NONE, EF_NONE);
+  MouseEvent mouse(ET_MOUSE_MOVED, gfx::PointF(10.f, 10.f),
+                   gfx::PointF(10.f, 10.f), EventTimeForNow(), EF_NONE,
+                   EF_NONE);
   DispatchEvent(&mouse);
 
   // Verify also that |mouse| was seen by the child nodes contained in both
   // event processors and that the event was not handled.
   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_TRUE(second_root->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_FALSE(mouse.handled());
   second_root->child_at(0)->ResetReceivedEvents();
   root()->child_at(0)->ResetReceivedEvents();
 
   // Indicate that the child of the second root should handle events, and
   // dispatch another mouse event to verify that it is marked as handled.
   second_root->child_at(0)->set_mark_events_as_handled(true);
-  MouseEvent mouse2(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
-                    EventTimeForNow(), EF_NONE, EF_NONE);
+  MouseEvent mouse2(ET_MOUSE_MOVED, gfx::PointF(10.f, 10.f),
+                    gfx::PointF(10.f, 10.f), EventTimeForNow(), EF_NONE,
+                    EF_NONE);
   DispatchEvent(&mouse2);
   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_TRUE(second_root->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_TRUE(mouse2.handled());
 }
 
 // Verifies that OnEventProcessingFinished() is called when an event
 // has been handled.
 TEST_F(EventProcessorTest, OnEventProcessingFinished) {
   scoped_ptr<TestEventTarget> child(new TestEventTarget());
   child->set_mark_events_as_handled(true);
   SetTarget(child.get());
   root()->AddChild(child.Pass());
 
   // Dispatch a mouse event. We expect the event to be seen by the target,
   // handled, and we expect OnEventProcessingFinished() to be invoked once.
-  MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
-                   EventTimeForNow(), EF_NONE, EF_NONE);
+  MouseEvent mouse(ET_MOUSE_MOVED, gfx::PointF(10.f, 10.f),
+                   gfx::PointF(10.f, 10.f), EventTimeForNow(), EF_NONE,
+                   EF_NONE);
   DispatchEvent(&mouse);
   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_TRUE(mouse.handled());
   EXPECT_EQ(1, processor()->num_times_processing_finished());
 }
 
 // Verifies that OnEventProcessingStarted() has been called when starting to
 // process an event, and that processing does not take place if
 // OnEventProcessingStarted() marks the event as handled. Also verifies that
 // OnEventProcessingFinished() is also called in either case.
 TEST_F(EventProcessorTest, OnEventProcessingStarted) {
   scoped_ptr<TestEventTarget> child(new TestEventTarget());
   SetTarget(child.get());
   root()->AddChild(child.Pass());
 
   // Dispatch a mouse event. We expect the event to be seen by the target,
   // OnEventProcessingStarted() should be called once, and
   // OnEventProcessingFinished() should be called once. The event should
   // remain unhandled.
-  MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
-                   EventTimeForNow(), EF_NONE, EF_NONE);
+  MouseEvent mouse(ET_MOUSE_MOVED, gfx::PointF(10.f, 10.f),
+                   gfx::PointF(10.f, 10.f), EventTimeForNow(), EF_NONE,
+                   EF_NONE);
   DispatchEvent(&mouse);
   EXPECT_TRUE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_FALSE(mouse.handled());
   EXPECT_EQ(1, processor()->num_times_processing_started());
   EXPECT_EQ(1, processor()->num_times_processing_finished());
   processor()->Reset();
   root()->ResetReceivedEvents();
   root()->child_at(0)->ResetReceivedEvents();
 
   // Dispatch another mouse event, but with OnEventProcessingStarted() marking
   // the event as handled to prevent processing. We expect the event to not be
   // seen by the target this time, but OnEventProcessingStarted() and
   // OnEventProcessingFinished() should both still be called once.
   processor()->set_should_processing_occur(false);
-  MouseEvent mouse2(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
-                    EventTimeForNow(), EF_NONE, EF_NONE);
+  MouseEvent mouse2(ET_MOUSE_MOVED, gfx::PointF(10.f, 10.f),
+                    gfx::PointF(10.f, 10.f), EventTimeForNow(), EF_NONE,
+                    EF_NONE);
   DispatchEvent(&mouse2);
   EXPECT_FALSE(root()->child_at(0)->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_FALSE(root()->DidReceiveEvent(ET_MOUSE_MOVED));
   EXPECT_TRUE(mouse2.handled());
   EXPECT_EQ(1, processor()->num_times_processing_started());
   EXPECT_EQ(1, processor()->num_times_processing_finished());
 }
 
 // Tests that unhandled events are correctly dispatched to the next-best
 // target as decided by the TestEventTargeter.
@@ skipping 119 matching lines @@
   TestEventHandler post_child;
   post_child.set_handler_name("PostC");
   post_child.set_recorder(&recorder);
   child_r->AddPostTargetHandler(&post_child);
 
   TestEventHandler post_grandchild;
   post_grandchild.set_handler_name("PostG");
   post_grandchild.set_recorder(&recorder);
   grandchild_r->AddPostTargetHandler(&post_grandchild);
 
-  MouseEvent mouse(ET_MOUSE_MOVED, gfx::Point(10, 10), gfx::Point(10, 10),
-                   EventTimeForNow(), EF_NONE, EF_NONE);
+  MouseEvent mouse(ET_MOUSE_MOVED, gfx::PointF(10.f, 10.f),
+                   gfx::PointF(10.f, 10.f), EventTimeForNow(), EF_NONE,
+                   EF_NONE);
   DispatchEvent(&mouse);
 
   std::string expected[] = { "PreR", "PreC", "PreG", "G", "PostG", "PostC",
       "PostR", "PreR", "PreC", "C", "PostC", "PostR", "PreR", "R", "PostR" };
   EXPECT_EQ(std::vector<std::string>(
       expected, expected + arraysize(expected)), recorder);
 }
 
 }  // namespace test
 }  // namespace ui