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

cc/trees/layer_tree_host_common_unittest.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_host_common.h"
 
 #include <algorithm>
 #include <set>
 
 #include "cc/animation/keyframed_animation_curve.h"
@@ skipping 2289 matching lines @@
   gfx::Transform layer_to_surface_transform;
   layer_to_surface_transform.MakeIdentity();
   layer_to_surface_transform.ApplyPerspectiveDepth(1.0);
   layer_to_surface_transform.Translate3d(0.0, 0.0, -5.0);
   layer_to_surface_transform.RotateAboutYAxis(45.0);
   layer_to_surface_transform.RotateAboutXAxis(80.0);
 
   // Sanity check that un-projection does indeed cause w < 0, otherwise this
   // code is not testing the intended scenario.
   bool clipped;
-  gfx::RectF clipped_rect =
-      MathUtil::MapClippedRect(layer_to_surface_transform, layer_content_rect);
+  gfx::RectF clipped_rect = MathUtil::MapClippedRect(
+      layer_to_surface_transform, gfx::RectF(layer_content_rect));
   MathUtil::ProjectQuad(
       Inverse(layer_to_surface_transform), gfx::QuadF(clipped_rect), &clipped);
   ASSERT_TRUE(clipped);
 
   // Only the corner of the layer is not visible on the surface because of being
   // clipped. But, the net result of rounding visible region to an axis-aligned
   // rect is that the entire layer should still be considered visible.
   gfx::Rect expected = gfx::Rect(-10, -10, 20, 20);
   gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
       target_surface_rect, layer_content_rect, layer_to_surface_transform);
   EXPECT_EQ(expected, actual);
 }
 
 TEST_F(LayerTreeHostCommonTest,
        VisibleRectsForPositionedRootLayerClippedByViewport) {
   LayerImpl* root = root_layer();
   root->SetDrawsContent(true);
 
   gfx::Transform identity_matrix;
   // Root layer is positioned at (60, 70). The default device viewport size
   // is (0, 0, 100x100) in target space. So the root layer's visible rect
   // will be clipped by the viewport to be (0, 0, 40x30) in layer's space.
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(60, 70), gfx::Size(100, 100), true,
                                false, true);
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_EQ(gfx::Rect(0, 0, 100, 100),
+  EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
   // In target space, not clipped.
   EXPECT_EQ(gfx::Rect(60, 70, 100, 100), root->drawable_content_rect());
   // In layer space, clipped.
-  EXPECT_EQ(gfx::Rect(0, 0, 40, 30), root->visible_layer_rect());
+  EXPECT_EQ(gfx::Rect(40, 30), root->visible_layer_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsForSimpleLayers) {
   LayerImpl* root = root_layer();
   LayerImpl* child1_layer = AddChildToRoot<LayerImpl>();
   child1_layer->SetDrawsContent(true);
   LayerImpl* child2_layer = AddChildToRoot<LayerImpl>();
   child2_layer->SetDrawsContent(true);
   LayerImpl* child3_layer = AddChildToRoot<LayerImpl>();
   child3_layer->SetDrawsContent(true);
 
   gfx::Transform identity_matrix;
   SetLayerPropertiesForTesting(root, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(100, 100), true, false,
                                true);
   SetLayerPropertiesForTesting(child1_layer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(50, 50), true, false,
                                false);
   SetLayerPropertiesForTesting(child2_layer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(75.f, 75.f), gfx::Size(50, 50), true,
                                false, false);
   SetLayerPropertiesForTesting(child3_layer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(125.f, 125.f), gfx::Size(50, 50),
                                true, false, false);
 
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_EQ(gfx::Rect(0, 0, 100, 100),
+  EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
-  EXPECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect());
+  EXPECT_EQ(gfx::Rect(100, 100), root->drawable_content_rect());
 
   // Layers that do not draw content should have empty visible_layer_rects.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
 
   // layer visible_layer_rects are clipped by their target surface.
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1_layer->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 25, 25), child2_layer->visible_layer_rect());
   EXPECT_TRUE(child3_layer->visible_layer_rect().IsEmpty());
 
   // layer drawable_content_rects are not clipped.
@@ skipping 26 matching lines @@
   SetLayerPropertiesForTesting(grand_child2, identity_matrix, gfx::Point3F(),
                                gfx::PointF(75.f, 75.f), gfx::Size(50, 50), true,
                                false, false);
   SetLayerPropertiesForTesting(grand_child3, identity_matrix, gfx::Point3F(),
                                gfx::PointF(125.f, 125.f), gfx::Size(50, 50),
                                true, false, false);
 
   child->SetMasksToBounds(true);
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_EQ(gfx::Rect(0, 0, 100, 100),
+  EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
-  EXPECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect());
+  EXPECT_EQ(gfx::Rect(100, 100), root->drawable_content_rect());
 
   // Layers that do not draw content should have empty visible content rects.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), child->visible_layer_rect());
 
   // All grandchild visible content rects should be clipped by child.
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), grand_child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 25, 25), grand_child2->visible_layer_rect());
   EXPECT_TRUE(grand_child3->visible_layer_rect().IsEmpty());
 
@@ skipping 60 matching lines @@
                                gfx::PointF(75.f, 75.f), gfx::Size(50, 50), true,
                                false, false);
   SetLayerPropertiesForTesting(child3, identity_matrix, gfx::Point3F(),
                                gfx::PointF(125.f, 125.f), gfx::Size(50, 50),
                                true, false, false);
 
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(render_surface->render_surface());
 
-  EXPECT_EQ(gfx::Rect(0, 0, 100, 100),
+  EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
-  EXPECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect());
+  EXPECT_EQ(gfx::Rect(100, 100), root->drawable_content_rect());
 
   // Layers that do not draw content should have empty visible content rects.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface->visible_layer_rect());
 
   // An unclipped surface grows its DrawableContentRect to include all drawable
   // regions of the subtree.
-  EXPECT_EQ(gfx::Rect(5, 5, 170, 170),
+  EXPECT_EQ(gfx::RectF(5.f, 5.f, 170.f, 170.f),
             render_surface->render_surface()->DrawableContentRect());
 
   // All layers that draw content into the unclipped surface are also unclipped.
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_layer_rect());
 
   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(125, 125, 50, 50), child3->drawable_content_rect());
@@ skipping 305 matching lines @@
   SetLayerPropertiesForTesting(child3, identity_matrix, gfx::Point3F(),
                                gfx::PointF(125.f, 125.f), gfx::Size(50, 50),
                                true, false, false);
 
   root->SetMasksToBounds(true);
 
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(render_surface->render_surface());
 
-  EXPECT_EQ(gfx::Rect(0, 0, 100, 100),
+  EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
-  EXPECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect());
+  EXPECT_EQ(gfx::Rect(100, 100), root->drawable_content_rect());
 
   // Layers that do not draw content should have empty visible content rects.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface->visible_layer_rect());
 
   // A clipped surface grows its DrawableContentRect to include all drawable
   // regions of the subtree, but also gets clamped by the ancestor's clip.
-  EXPECT_EQ(gfx::Rect(5, 5, 95, 95),
+  EXPECT_EQ(gfx::RectF(5.f, 5.f, 95.f, 95.f),
             render_surface->render_surface()->DrawableContentRect());
 
   // All layers that draw content into the surface have their visible content
   // rect clipped by the surface clip rect.
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 25, 25), child2->visible_layer_rect());
   EXPECT_TRUE(child3->visible_layer_rect().IsEmpty());
 
   // But the DrawableContentRects are unclipped.
   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
@@ skipping 34 matching lines @@
                                gfx::PointF(125.f, 125.f), gfx::Size(50, 50),
                                true, false, false);
 
   root->SetMasksToBounds(true);
 
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(render_surface1->render_surface());
   ASSERT_TRUE(render_surface2->render_surface());
 
-  EXPECT_EQ(gfx::Rect(0, 0, 100, 100),
+  EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
-  EXPECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect());
+  EXPECT_EQ(gfx::Rect(100, 100), root->drawable_content_rect());
 
   // Layers that do not draw content should have empty visible content rects.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface2->visible_layer_rect());
 
   // A clipped surface grows its DrawableContentRect to include all drawable
   // regions of the subtree, but also gets clamped by the ancestor's clip.
-  EXPECT_EQ(gfx::Rect(5, 5, 95, 95),
+  EXPECT_EQ(gfx::RectF(5.f, 5.f, 95.f, 95.f),
             render_surface1->render_surface()->DrawableContentRect());
 
   // render_surface1 lives in the "unclipped universe" of render_surface1, and
   // is only implicitly clipped by render_surface1's content rect. So,
   // render_surface2 grows to enclose all drawable content of its subtree.
-  EXPECT_EQ(gfx::Rect(5, 5, 170, 170),
+  EXPECT_EQ(gfx::RectF(5.f, 5.f, 170.f, 170.f),
             render_surface2->render_surface()->DrawableContentRect());
 
   // All layers that draw content into render_surface2 think they are unclipped.
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child2->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child3->visible_layer_rect());
 
   // DrawableContentRects are also unclipped.
   EXPECT_EQ(gfx::Rect(5, 5, 50, 50), child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(75, 75, 50, 50), child2->drawable_content_rect());
@@ skipping 19 matching lines @@
                                gfx::PointF(), gfx::Size(3, 4), true, false,
                                true);
   SetLayerPropertiesForTesting(
       child1, child_rotation, gfx::Point3F(25, 25, 0.f),
       gfx::PointF(25.f, 25.f), gfx::Size(50, 50), true, false, false);
 
   ExecuteCalculateDrawProperties(root);
 
   ASSERT_TRUE(render_surface->render_surface());
 
-  EXPECT_EQ(gfx::Rect(0, 0, 100, 100),
+  EXPECT_EQ(gfx::RectF(100.f, 100.f),
             root->render_surface()->DrawableContentRect());
   EXPECT_EQ(gfx::Rect(0, 0, 100, 100), root->drawable_content_rect());
 
   // Layers that do not draw content should have empty visible content rects.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), render_surface->visible_layer_rect());
 
   // The unclipped surface grows its DrawableContentRect to include all drawable
   // regions of the subtree.
   int diagonal_radius = ceil(sqrt(2.0) * 25.0);
   gfx::Rect expected_surface_drawable_content =
       gfx::Rect(50 - diagonal_radius,
                 50 - diagonal_radius,
                 diagonal_radius * 2,
                 diagonal_radius * 2);
-  EXPECT_EQ(expected_surface_drawable_content,
+  EXPECT_EQ(gfx::RectF(expected_surface_drawable_content),
             render_surface->render_surface()->DrawableContentRect());
 
   // All layers that draw content into the unclipped surface are also unclipped.
   EXPECT_EQ(gfx::Rect(0, 0, 50, 50), child1->visible_layer_rect());
   EXPECT_EQ(expected_surface_drawable_content, child1->drawable_content_rect());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        DrawableAndVisibleContentRectsWithTransformOnClippedSurface) {
   // Layers that have non-axis aligned bounds (due to transforms) have an
@@ skipping 23 matching lines @@
 
   ASSERT_TRUE(render_surface->render_surface());
 
   // The clipped surface clamps the DrawableContentRect that encloses the
   // rotated layer.
   int diagonal_radius = ceil(sqrt(2.0) * 25.0);
   gfx::Rect unclipped_surface_content = gfx::Rect(50 - diagonal_radius,
                                                   50 - diagonal_radius,
                                                   diagonal_radius * 2,
                                                   diagonal_radius * 2);
-  gfx::Rect expected_surface_drawable_content =
-      gfx::IntersectRects(unclipped_surface_content, gfx::Rect(0, 0, 50, 50));
+  gfx::RectF expected_surface_drawable_content(
+      gfx::IntersectRects(unclipped_surface_content, gfx::Rect(50, 50)));
   EXPECT_EQ(expected_surface_drawable_content,
             render_surface->render_surface()->DrawableContentRect());
 
   // On the clipped surface, only a quarter  of the child1 is visible, but when
   // rotating it back to  child1's content space, the actual enclosing rect ends
   // up covering the full left half of child1.
   //
   // Given the floating point math, this number is a little bit fuzzy.
   EXPECT_EQ(gfx::Rect(0, 0, 26, 50), child1->visible_layer_rect());
 
@@ skipping 43 matching lines @@
 
   root->SetMasksToBounds(true);
 
   ExecuteCalculateDrawProperties(root, device_scale_factor);
 
   ASSERT_TRUE(render_surface1->render_surface());
   ASSERT_TRUE(render_surface2->render_surface());
 
   // drawable_content_rects for all layers and surfaces are scaled by
   // device_scale_factor.
-  EXPECT_EQ(gfx::Rect(0, 0, 200, 200),
+  EXPECT_EQ(gfx::RectF(200.f, 200.f),
             root->render_surface()->DrawableContentRect());
   EXPECT_EQ(gfx::Rect(0, 0, 200, 200), root->drawable_content_rect());
-  EXPECT_EQ(gfx::Rect(10, 10, 190, 190),
+  EXPECT_EQ(gfx::RectF(10.f, 10.f, 190.f, 190.f),
             render_surface1->render_surface()->DrawableContentRect());
 
   // render_surface2 lives in the "unclipped universe" of render_surface1, and
   // is only implicitly clipped by render_surface1.
-  EXPECT_EQ(gfx::Rect(10, 10, 350, 350),
+  EXPECT_EQ(gfx::RectF(10.f, 10.f, 350.f, 350.f),
             render_surface2->render_surface()->DrawableContentRect());
 
   EXPECT_EQ(gfx::Rect(10, 10, 100, 100), child1->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(150, 150, 100, 100), child2->drawable_content_rect());
   EXPECT_EQ(gfx::Rect(250, 250, 100, 100), child3->drawable_content_rect());
 
   // The root layer does not actually draw content of its own.
   EXPECT_EQ(gfx::Rect(0, 0, 0, 0), root->visible_layer_rect());
 
   // All layer visible content rects are not expressed in content space of each
@@ skipping 4723 matching lines @@
 
   TransformTree transform_tree =
       root->layer_tree_impl()->property_trees()->transform_tree;
   TransformNode* transform_node =
       transform_tree.Node(significant_transform->transform_tree_index());
   EXPECT_EQ(transform_node->owner_id, significant_transform->id());
 
   ClipTree clip_tree = root->layer_tree_impl()->property_trees()->clip_tree;
   ClipNode* clip_node = clip_tree.Node(render_surface->clip_tree_index());
   EXPECT_TRUE(clip_node->data.inherit_parent_target_space_clip);
-  EXPECT_EQ(test_layer->visible_rect_from_property_trees(), gfx::RectF(30, 21));
+  EXPECT_EQ(gfx::Rect(30, 21), test_layer->visible_rect_from_property_trees());
 }
 
 TEST_F(LayerTreeHostCommonTest, TransformOfParentClipNodeAncestorOfTarget) {
   // Ensure that when parent clip node's transform is an ancestor of current
   // clip node's target, clip is 'projected' from parent space to current
   // target space and visible rects are calculated correctly.
   LayerImpl* root = root_layer();
   LayerImpl* clip_layer = AddChild<LayerImpl>(root);
   LayerImpl* target_layer = AddChild<LayerImpl>(clip_layer);
   LayerImpl* test_layer = AddChild<LayerImpl>(target_layer);
@@ skipping 14 matching lines @@
   SetLayerPropertiesForTesting(target_layer, transform, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
   SetLayerPropertiesForTesting(test_layer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                false);
   ExecuteCalculateDrawProperties(root);
 
   ClipTree clip_tree = root->layer_tree_impl()->property_trees()->clip_tree;
   ClipNode* clip_node = clip_tree.Node(target_layer->clip_tree_index());
-  EXPECT_EQ(clip_node->data.combined_clip, gfx::RectF(30, 30));
-  EXPECT_EQ(test_layer->visible_rect_from_property_trees(), gfx::RectF(30, 30));
+  EXPECT_EQ(gfx::RectF(30, 30), clip_node->data.combined_clip);
+  EXPECT_EQ(gfx::Rect(30, 30), test_layer->visible_rect_from_property_trees());
 }
 
 TEST_F(LayerTreeHostCommonTest,
        RenderSurfaceWithUnclippedDescendantsClipsSubtree) {
   // Ensure clip rect is calculated correctly when render surface has unclipped
   // descendants.
   LayerImpl* root = root_layer();
   LayerImpl* clip_parent = AddChildToRoot<LayerImpl>();
   LayerImpl* between_clip_parent_and_child = AddChild<LayerImpl>(clip_parent);
   LayerImpl* render_surface =
@@ skipping 17 matching lines @@
                                true, false, false);
   SetLayerPropertiesForTesting(render_surface, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                true);
   SetLayerPropertiesForTesting(test_layer, identity_matrix, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(30, 30), true, false,
                                false);
 
   ExecuteCalculateDrawProperties(root);
 
-  EXPECT_EQ(test_layer->clip_rect(), gfx::RectF(-4, -4, 30, 30));
+  EXPECT_EQ(gfx::Rect(-4, -4, 30, 30), test_layer->clip_rect());
 }
 
 }  // namespace
 }  // namespace cc