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

ash/drag_drop/drag_drop_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/drag_drop/drag_drop_controller.h"
 
 #include "ash/drag_drop/drag_drop_tracker.h"
 #include "ash/drag_drop/drag_image_view.h"
 #include "ash/shell.h"
 #include "base/bind.h"
@@ skipping 33 matching lines @@
 static const int kTouchDragImageVerticalOffset = -25;
 
 // Adjusts the drag image bounds such that the new bounds are scaled by |scale|
 // and translated by the |drag_image_offset| and and additional
 // |vertical_offset|.
 gfx::Rect AdjustDragImageBoundsForScaleAndOffset(
     const gfx::Rect& drag_image_bounds,
     int vertical_offset,
     float scale,
     gfx::Vector2d* drag_image_offset) {
-  gfx::PointF final_origin = drag_image_bounds.origin();
+  gfx::Point final_origin = drag_image_bounds.origin();
   gfx::SizeF final_size = gfx::SizeF(drag_image_bounds.size());
   final_size.Scale(scale);
   drag_image_offset->set_x(drag_image_offset->x() * scale);
   drag_image_offset->set_y(drag_image_offset->y() * scale);
-  float total_x_offset = drag_image_offset->x();
-  float total_y_offset = drag_image_offset->y() - vertical_offset;
+  int total_x_offset = drag_image_offset->x();
+  int total_y_offset = drag_image_offset->y() - vertical_offset;
   final_origin.Offset(-total_x_offset, -total_y_offset);
-  return gfx::ToEnclosingRect(gfx::RectF(final_origin, final_size));
+  return gfx::ToEnclosingRect(
+      gfx::RectF(gfx::PointF(final_origin), final_size));
 }
 
 void DispatchGestureEndToWindow(aura::Window* window) {
   if (window && window->delegate()) {
     ui::GestureEvent gesture_end(0,
                                  0,
                                  0,
                                  ui::EventTimeForNow(),
                                  ui::GestureEventDetails(ui::ET_GESTURE_END));
     window->delegate()->OnGestureEvent(&gesture_end);
@@ skipping 183 matching lines @@
       if (drag_window_ != drag_source_window_)
         drag_window_->RemoveObserver(this);
     }
     drag_window_ = target;
     // We are already an observer of |drag_source_window_| so no need to add.
     if (drag_window_ != drag_source_window_)
       drag_window_->AddObserver(this);
     aura::client::DragDropDelegate* delegate =
         aura::client::GetDragDropDelegate(drag_window_);
     if (delegate) {
-      ui::DropTargetEvent e(*drag_data_, event.location_f(),
-                            event.root_location_f(), drag_operation_);
+      ui::DropTargetEvent e(*drag_data_, gfx::Point(), gfx::Point(),
+                            drag_operation_);
+      e.set_location_f(event.location_f());
+      e.set_root_location_f(event.root_location_f());
       e.set_flags(event.flags());
       delegate->OnDragEntered(e);
     }
   } else {
     aura::client::DragDropDelegate* delegate =
         aura::client::GetDragDropDelegate(drag_window_);
     if (delegate) {
-      ui::DropTargetEvent e(*drag_data_, event.location_f(),
-                            event.root_location_f(), drag_operation_);
+      ui::DropTargetEvent e(*drag_data_, gfx::Point(), gfx::Point(),
+                            drag_operation_);
+      e.set_location_f(event.location_f());
+      e.set_root_location_f(event.root_location_f());
       e.set_flags(event.flags());
       op = delegate->OnDragUpdated(e);
       gfx::NativeCursor cursor = ui::kCursorNoDrop;
       if (op & ui::DragDropTypes::DRAG_COPY)
         cursor = ui::kCursorCopy;
       else if (op & ui::DragDropTypes::DRAG_LINK)
         cursor = ui::kCursorAlias;
       else if (op & ui::DragDropTypes::DRAG_MOVE)
         cursor = ui::kCursorGrabbing;
       ash::Shell::GetInstance()->cursor_manager()->SetCursor(cursor);
@@ skipping 18 matching lines @@
   // We must guarantee that a target gets a OnDragEntered before Drop. WebKit
   // depends on not getting a Drop without DragEnter. This behavior is
   // consistent with drag/drop on other platforms.
   if (target != drag_window_)
     DragUpdate(target, event);
   DCHECK(target == drag_window_);
 
   aura::client::DragDropDelegate* delegate =
       aura::client::GetDragDropDelegate(target);
   if (delegate) {
-    ui::DropTargetEvent e(*drag_data_, event.location_f(),
-                          event.root_location_f(), drag_operation_);
+    ui::DropTargetEvent e(*drag_data_, gfx::Point(), gfx::Point(),
+                          drag_operation_);
+    e.set_location_f(event.location_f());
+    e.set_root_location_f(event.root_location_f());
     e.set_flags(event.flags());
     drag_operation_ = delegate->OnPerformDrop(e);
     if (drag_operation_ == 0)
       StartCanceledAnimation(kCancelAnimationDuration);
     else
       drag_image_.reset();
   } else {
     drag_image_.reset();
   }
 
@@ skipping 86 matching lines @@
     return;
 
   // Apply kTouchDragImageVerticalOffset to the location.
   ui::GestureEvent touch_offset_event(*event,
                                       static_cast<aura::Window*>(NULL),
                                       static_cast<aura::Window*>(NULL));
   gfx::PointF touch_offset_location = touch_offset_event.location_f();
   gfx::PointF touch_offset_root_location = touch_offset_event.root_location_f();
   touch_offset_location.Offset(0, kTouchDragImageVerticalOffset);
   touch_offset_root_location.Offset(0, kTouchDragImageVerticalOffset);
-  touch_offset_event.set_location(touch_offset_location);
-  touch_offset_event.set_root_location(touch_offset_root_location);
+  touch_offset_event.set_location_f(touch_offset_location);
+  touch_offset_event.set_root_location_f(touch_offset_root_location);
 
   aura::Window* translated_target =
       drag_drop_tracker_->GetTarget(touch_offset_event);
   if (!translated_target) {
     DragCancel();
     event->SetHandled();
     return;
   }
   scoped_ptr<ui::LocatedEvent> translated_event(
       drag_drop_tracker_->ConvertEvent(translated_target, touch_offset_event));
@@ skipping 120 matching lines @@
   if (drag_window_)
     drag_window_->RemoveObserver(this);
   drag_window_ = NULL;
   drag_data_ = NULL;
   // Cleanup can be called again while deleting DragDropTracker, so delete
   // the pointer with a local variable to avoid double free.
   scoped_ptr<ash::DragDropTracker> holder = drag_drop_tracker_.Pass();
 }
 
 }  // namespace ash