cc: Remove implicit conversions from Rect to RectF in src/cc/.

cc/trees/layer_tree_impl.cc

 // Copyright 2011 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 "cc/trees/layer_tree_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
@@ skipping 1213 matching lines @@
 }
 
 template <typename LayerType>
 static inline bool LayerClipsSubtree(LayerType* layer) {
   return layer->masks_to_bounds() || layer->mask_layer();
 }
 
 static bool PointHitsRect(
     const gfx::PointF& screen_space_point,
     const gfx::Transform& local_space_to_screen_space_transform,
-    const gfx::RectF& local_space_rect,
+    const gfx::Rect& local_space_rect,
     float* distance_to_camera) {
   // If the transform is not invertible, then assume that this point doesn't hit
   // this rect.
   gfx::Transform inverse_local_space_to_screen_space(
       gfx::Transform::kSkipInitialization);
   if (!local_space_to_screen_space_transform.GetInverse(
           &inverse_local_space_to_screen_space))
     return false;
 
   // Transform the hit test point from screen space to the local space of the
   // given rect.
   bool clipped = false;
   gfx::Point3F planar_point = MathUtil::ProjectPoint3D(
       inverse_local_space_to_screen_space, screen_space_point, &clipped);
   gfx::PointF hit_test_point_in_local_space =
       gfx::PointF(planar_point.x(), planar_point.y());
 
   // If ProjectPoint could not project to a valid value, then we assume that
   // this point doesn't hit this rect.
   if (clipped)
     return false;
 
-  if (!local_space_rect.Contains(hit_test_point_in_local_space))
+  if (!gfx::RectF(local_space_rect).Contains(hit_test_point_in_local_space))
     return false;
 
   if (distance_to_camera) {
     // To compute the distance to the camera, we have to take the planar point
     // and pull it back to world space and compute the displacement along the
     // z-axis.
     gfx::Point3F planar_point_in_screen_space(planar_point);
     local_space_to_screen_space_transform.TransformPoint(
         &planar_point_in_screen_space);
     *distance_to_camera = planar_point_in_screen_space.z();
@@ skipping 55 matching lines @@
   }
 
   // If we have finished walking all ancestors without having already exited,
   // then the point is not clipped by any ancestors.
   return false;
 }
 
 static bool PointHitsLayer(const LayerImpl* layer,
                            const gfx::PointF& screen_space_point,
                            float* distance_to_intersection) {
-  gfx::RectF content_rect(layer->bounds());
+  gfx::Rect content_rect(layer->bounds());
   if (!PointHitsRect(screen_space_point,
                      layer->screen_space_transform(),
                      content_rect,
                      distance_to_intersection))
     return false;
 
   // At this point, we think the point does hit the layer, but we need to walk
   // up the parents to ensure that the layer was not clipped in such a way
   // that the hit point actually should not hit the layer.
   if (PointIsClippedBySurfaceOrClipRect(screen_space_point, layer))
@@ skipping 410 matching lines @@
                                                    const gfx::BoxF& box,
                                                    gfx::BoxF* bounds) const {
   *bounds = gfx::BoxF();
   return layer_tree_host_impl_->animation_host()
              ? layer_tree_host_impl_->animation_host()
                    ->TransformAnimationBoundsForBox(layer->id(), box, bounds)
              : true;
 }
 
 }  // namespace cc