aura: Stop converting Rect to RectF implicitly.

ash/rotator/screen_rotation_animator.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 "ash/rotator/screen_rotation_animator.h"
 
 #include <string>
 #include <vector>
 
 #include "ash/ash_switches.h"
@@ skipping 160 matching lines @@
                   int rotation_degree_offset,
                   gfx::Tween::Type tween_type,
                   bool should_scale) {
   aura::Window* root_window = Shell::GetInstance()
                                   ->window_tree_host_manager()
                                   ->GetRootWindowForDisplayId(display_id);
 
   const gfx::Display::Rotation initial_orientation =
       GetCurrentRotation(display_id);
 
-  const gfx::RectF original_screen_bounds = root_window->GetTargetBounds();
+  const gfx::Rect original_screen_bounds = root_window->GetTargetBounds();
   // 180 degree rotations should animate clock-wise.
   const int rotation_factor =
       (initial_orientation + 3) % 4 == new_rotation ? 1 : -1;
 
   scoped_ptr<ui::LayerTreeOwner> old_layer_tree =
       wm::RecreateLayers(root_window);
 
   // Add the cloned layer tree in to the root, so it will be rendered.
   root_window->layer()->Add(old_layer_tree->root());
   root_window->layer()->StackAtTop(old_layer_tree->root());
 
   scoped_ptr<LayerCleanupObserver> layer_cleanup_observer(
       new LayerCleanupObserver(old_layer_tree.Pass()));
 
   Shell::GetInstance()->display_manager()->SetDisplayRotation(
       display_id, new_rotation, source);
 
-  const gfx::RectF rotated_screen_bounds = root_window->GetTargetBounds();
+  const gfx::Rect rotated_screen_bounds = root_window->GetTargetBounds();
   const gfx::Point pivot = gfx::Point(rotated_screen_bounds.width() / 2,
                                       rotated_screen_bounds.height() / 2);
 
   gfx::Point3F new_layer_initial_scale = gfx::Point3F(1.0f, 1.0f, 1.0f);
   gfx::Point3F old_layer_target_scale = gfx::Point3F(1.0f, 1.0f, 1.0f);
 
   if (should_scale) {
-    new_layer_initial_scale = gfx::Point3F(
-        original_screen_bounds.width() / rotated_screen_bounds.width(),
-        original_screen_bounds.height() / rotated_screen_bounds.height(), 1.0f);
+    new_layer_initial_scale =
+        gfx::Point3F(static_cast<float>(original_screen_bounds.width()) /
+                         rotated_screen_bounds.width(),
+                     static_cast<float>(original_screen_bounds.height()) /
+                         rotated_screen_bounds.height(),
+                     1.0f);
 
-    old_layer_target_scale = gfx::Point3F(
-        rotated_screen_bounds.width() / original_screen_bounds.width(),
-        rotated_screen_bounds.height() / original_screen_bounds.height(), 1.0f);
+    old_layer_target_scale =
+        gfx::Point3F(static_cast<float>(rotated_screen_bounds.width()) /
+                         original_screen_bounds.width(),
+                     static_cast<float>(rotated_screen_bounds.height()) /
+                         original_screen_bounds.height(),
+                     1.0f);
   }
 
   // We must animate each non-cloned child layer individually because the cloned
   // layer was added as a child to |root_window|'s layer so that it will be
   // rendered.
   // TODO(bruthig): Add a NOT_DRAWN layer in between the root_window's layer and
   // its current children so that we only need to initiate two
   // LayerAnimationSequences. One for the new layers and one for the old layer.
   for (ui::Layer* child_layer : root_window->layer()->children()) {
     // Skip the cloned layer because it has a different animation.
@@ skipping 95 matching lines @@
     RotateScreen(display_id_, new_rotation, source,
                  base::TimeDelta::FromMilliseconds(kRotationDurationInMs),
                  rotation_degrees, 0 /* rotation_degree_offset */,
                  gfx::Tween::FAST_OUT_LINEAR_IN, true /* should_scale */);
   } else {
     NOTREACHED();
   }
 }
 
 }  // namespace ash