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

ui/events/event.h

 // 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.
 
 #ifndef UI_EVENTS_EVENT_H_
 #define UI_EVENTS_EVENT_H_
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/event_types.h"
@@ skipping 244 matching lines @@
   CancelModeEvent();
   ~CancelModeEvent() override;
 };
 
 class EVENTS_EXPORT LocatedEvent : public Event {
  public:
   ~LocatedEvent() override;
 
   float x() const { return location_.x(); }
   float y() const { return location_.y(); }
-  void set_location(const gfx::PointF& location) { location_ = location; }
+  void set_location(const gfx::Point& location) {
+    location_ = gfx::PointF(location);
+  }
+  void set_location_f(const gfx::PointF& location) { location_ = location; }
   gfx::Point location() const { return gfx::ToFlooredPoint(location_); }
   const gfx::PointF& location_f() const { return location_; }
-  void set_root_location(const gfx::PointF& root_location) {
+  void set_root_location(const gfx::Point& root_location) {
+    root_location_ = gfx::PointF(root_location);
+  }
+  void set_root_location_f(const gfx::PointF& root_location) {
     root_location_ = root_location;
   }
   gfx::Point root_location() const {
     return gfx::ToFlooredPoint(root_location_);
   }
   const gfx::PointF& root_location_f() const {
     return root_location_;
   }
 
   // Transform the locations using |inverted_root_transform|.
@@ skipping 115 matching lines @@
              int flags)
       : LocatedEvent(model, source, target),
         changed_button_flags_(model.changed_button_flags_),
         pointer_details_(model.pointer_details_) {
     SetType(type);
     set_flags(flags);
   }
 
   // Used for synthetic events in testing, gesture recognizer and Ozone
   MouseEvent(EventType type,
-             const gfx::PointF& location,
-             const gfx::PointF& root_location,
+             const gfx::Point& location,
+             const gfx::Point& root_location,
              base::TimeDelta time_stamp,
              int flags,
              int changed_button_flags);
 
   // Conveniences to quickly test what button is down
   bool IsOnlyLeftMouseButton() const {
     return button_flags() == EF_LEFT_MOUSE_BUTTON;
   }
 
   bool IsLeftMouseButton() const {
@@ skipping 95 matching lines @@
   template <class T>
   MouseWheelEvent(const MouseWheelEvent& model,
                   T* source,
                   T* target)
       : MouseEvent(model, source, target, model.type(), model.flags()),
         offset_(model.x_offset(), model.y_offset()) {
   }
 
   // Used for synthetic events in testing and by the gesture recognizer.
   MouseWheelEvent(const gfx::Vector2d& offset,
-                  const gfx::PointF& location,
-                  const gfx::PointF& root_location,
+                  const gfx::Point& location,
+                  const gfx::Point& root_location,
                   base::TimeDelta time_stamp,
                   int flags,
                   int changed_button_flags);
 
   // The amount to scroll. This is in multiples of kWheelDelta.
   // Note: x_offset() > 0/y_offset() > 0 means scroll left/up.
   int x_offset() const { return offset_.x(); }
   int y_offset() const { return offset_.y(); }
   const gfx::Vector2d& offset() const { return offset_; }
 
@@ skipping 12 matching lines @@
   TouchEvent(const TouchEvent& model, T* source, T* target)
       : LocatedEvent(model, source, target),
         touch_id_(model.touch_id_),
         unique_event_id_(model.unique_event_id_),
         rotation_angle_(model.rotation_angle_),
         may_cause_scrolling_(model.may_cause_scrolling_),
         should_remove_native_touch_id_mapping_(false),
         pointer_details_(model.pointer_details_) {}
 
   TouchEvent(EventType type,
-             const gfx::PointF& location,
+             const gfx::Point& location,
              int touch_id,
              base::TimeDelta time_stamp);
 
   TouchEvent(EventType type,
-             const gfx::PointF& location,
+             const gfx::Point& location,
              int flags,
              int touch_id,
              base::TimeDelta timestamp,
              float radius_x,
              float radius_y,
              float angle,
              float force);
 
   TouchEvent(const TouchEvent& copy);
 
@@ skipping 276 matching lines @@
       : MouseEvent(model, source, target),
         x_offset_(model.x_offset_),
         y_offset_(model.y_offset_),
         x_offset_ordinal_(model.x_offset_ordinal_),
         y_offset_ordinal_(model.y_offset_ordinal_),
         finger_count_(model.finger_count_){
   }
 
   // Used for tests.
   ScrollEvent(EventType type,
-              const gfx::PointF& location,
+              const gfx::Point& location,
               base::TimeDelta time_stamp,
               int flags,
               float x_offset,
               float y_offset,
               float x_offset_ordinal,
               float y_offset_ordinal,
               int finger_count);
 
   // Scale the scroll event's offset value.
   // This is useful in the multi-monitor setup where it needs to be scaled
@@ skipping 38 matching lines @@
 
   const GestureEventDetails& details() const { return details_; }
 
  private:
   GestureEventDetails details_;
 };
 
 }  // namespace ui
 
 #endif  // UI_EVENTS_EVENT_H_