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

ash/magnifier/magnification_controller.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 "ash/magnifier/magnification_controller.h"
 
 #include "ash/accelerators/accelerator_controller.h"
 #include "ash/accessibility_delegate.h"
 #include "ash/ash_switches.h"
 #include "ash/display/root_window_transformers.h"
@@ skipping 50 matching lines @@
 
 // Threadshold of panning. If the cursor moves to within pixels (in DIP) of
 // |kCursorPanningMargin| from the edge, the view-port moves.
 const int kCursorPanningMargin = 100;
 
 // Threadshold of panning. If the caret moves to within pixels (in DIP) of
 // |kCaretPanningMargin| from the edge, the view-port moves.
 const int kCaretPanningMargin = 50;
 
 void MoveCursorTo(aura::WindowTreeHost* host, const gfx::Point& root_location) {
-  gfx::Point3F host_location_3f(root_location);
+  auto host_location_3f = gfx::Point3F(gfx::PointF(root_location));
   host->GetRootTransform().TransformPoint(&host_location_3f);
   host->MoveCursorToHostLocation(
       gfx::ToCeiledPoint(host_location_3f.AsPointF()));
 }
 
 ui::InputMethod* GetInputMethod(aura::Window* root_window) {
   if (root_window->GetHost())
     return root_window->GetHost()->GetInputMethod();
   return nullptr;
 }
@@ skipping 479 matching lines @@
   ValidateScale(&scale);
   Shell::GetInstance()->accessibility_delegate()->
       SaveScreenMagnifierScale(scale);
   RedrawKeepingMousePosition(scale, animate);
 }
 
 void MagnificationControllerImpl::MoveWindow(int x, int y, bool animate) {
   if (!is_enabled_)
     return;
 
-  Redraw(gfx::Point(x, y), scale_, animate);
+  Redraw(gfx::PointF(x, y), scale_, animate);
 }
 
 void MagnificationControllerImpl::MoveWindow(const gfx::Point& point,
                                              bool animate) {
   if (!is_enabled_)
     return;
 
-  Redraw(point, scale_, animate);
+  Redraw(gfx::PointF(point), scale_, animate);
 }
 
 void MagnificationControllerImpl::SetScrollDirection(
     ScrollDirection direction) {
   scroll_direction_ = direction;
   StartOrStopScrollIfNecessary();
 }
 
 void MagnificationControllerImpl::SetEnabled(bool enabled) {
   Shell* shell = Shell::GetInstance();
@@ skipping 127 matching lines @@
     // Panning up.
     y_diff = point.y() - (top + y_target_margin);
     start_zoom = true;
   } else if (bottom - y_panning_margin < point.y()) {
     // Panning down.
     y_diff = point.y() - (bottom - y_target_margin);
     start_zoom = true;
   }
   int y = top + y_diff;
   if (start_zoom && !is_on_animation_) {
-    bool ret = RedrawDIP(gfx::Point(x, y), scale_,
+    bool ret = RedrawDIP(gfx::PointF(x, y), scale_,
                          0,  // No animation on panning.
                          kDefaultAnimationTweenType);
 
     if (ret) {
       // If the magnified region is moved, hides the mouse cursor and moves it.
       if (x_diff != 0 || y_diff != 0)
         MoveCursorTo(root_window_->GetHost(), point);
     }
   }
 }
 
 void MagnificationControllerImpl::MoveMagnifierWindowCenterPoint(
     const gfx::Point& point) {
   DCHECK(root_window_);
 
   const gfx::Rect window_rect = GetViewportRect();
   if (point == window_rect.CenterPoint())
     return;
 
   if (!is_on_animation_) {
     // With animation on panning.
-    RedrawDIP(window_rect.origin() + (point - window_rect.CenterPoint()),
-              scale_, kDefaultAnimationDurationInMs,
-              kCenterCaretAnimationTweenType);
+    RedrawDIP(
+        gfx::PointF(window_rect.origin() + (point - window_rect.CenterPoint())),
+        scale_, kDefaultAnimationDurationInMs, kCenterCaretAnimationTweenType);
   }
 }
 
 void MagnificationControllerImpl::MoveMagnifierWindowFollowRect(
     const gfx::Rect& rect) {
   DCHECK(root_window_);
   bool should_pan = false;
 
   const gfx::Rect viewport_rect = GetViewportRect();
   const int left = viewport_rect.x();
@@ skipping 16 matching lines @@
     // Panning vertically.
     y = rect_center.y() - viewport_rect.height() / 2;
     should_pan = true;
   }
 
   if (should_pan) {
     if (is_on_animation_) {
       root_window_->layer()->GetAnimator()->StopAnimating();
       is_on_animation_ = false;
     }
-    RedrawDIP(gfx::Point(x, y), scale_,
+    RedrawDIP(gfx::PointF(x, y), scale_,
               0,  // No animation on panning.
               kDefaultAnimationTweenType);
   }
 }
 
 void MagnificationControllerImpl::OnMoveMagnifierTimer() {
   MoveMagnifierWindowCenterPoint(caret_point_);
 }
 
 void MagnificationControllerImpl::OnCaretBoundsChanged(
@@ skipping 47 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // MagnificationController:
 
 // static
 MagnificationController* MagnificationController::CreateInstance() {
   return new MagnificationControllerImpl();
 }
 
 }  // namespace ash