cc: Avoid pointless gfx::Point/Size contructors when making Rects.

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 "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/base/thread.h"
 #include "cc/layers/content_layer.h"
@@ skipping 2814 matching lines @@
   std::vector<scoped_refptr<Layer> > render_surface_layer_list;
   int dummy_max_texture_size = 512;
   LayerTreeHostCommon::CalculateDrawProperties(parent.get(),
                                                parent->bounds(),
                                                1.f,
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list);
 
-  EXPECT_RECT_EQ(gfx::Rect(gfx::Point(5, 5), gfx::Size(10, 10)),
+  EXPECT_RECT_EQ(gfx::Rect(5, 5, 10, 10),
                  grand_child1->drawable_content_rect());
-  EXPECT_RECT_EQ(gfx::Rect(gfx::Point(15, 15), gfx::Size(5, 5)),
+  EXPECT_RECT_EQ(gfx::Rect(15, 15, 5, 5),
                  grand_child3->drawable_content_rect());
-  EXPECT_RECT_EQ(gfx::Rect(gfx::Point(15, 15), gfx::Size(5, 5)),
+  EXPECT_RECT_EQ(gfx::Rect(15, 15, 5, 5),
                  grand_child3->drawable_content_rect());
   EXPECT_TRUE(grand_child4->drawable_content_rect().IsEmpty());
 }
 
 TEST(LayerTreeHostCommonTest, ClipRectIsPropagatedCorrectlyToSurfaces) {
   // Verify that render surfaces (and their layers) get the appropriate
   // clip rects when their parent masksToBounds is true.
   //
   // Layers that own render surfaces (at least for now) do not inherit any
   // clipping; instead the surface will enforce the clip for the entire subtree.
@@ skipping 127 matching lines @@
 
   ASSERT_TRUE(grand_child1->render_surface());
   ASSERT_TRUE(grand_child2->render_surface());
   ASSERT_TRUE(grand_child3->render_surface());
   // Because grand_child4 is entirely clipped, it is expected to not have a
   // render surface.
   EXPECT_FALSE(grand_child4->render_surface());
 
   // Surfaces are clipped by their parent, but un-affected by the owning layer's
   // masksToBounds.
-  EXPECT_RECT_EQ(gfx::Rect(gfx::Point(), gfx::Size(20, 20)),
+  EXPECT_RECT_EQ(gfx::Rect(0, 0, 20, 20),
                  grand_child1->render_surface()->clip_rect());
-  EXPECT_RECT_EQ(gfx::Rect(gfx::Point(), gfx::Size(20, 20)),
+  EXPECT_RECT_EQ(gfx::Rect(0, 0, 20, 20),
                  grand_child2->render_surface()->clip_rect());
-  EXPECT_RECT_EQ(gfx::Rect(gfx::Point(), gfx::Size(20, 20)),
+  EXPECT_RECT_EQ(gfx::Rect(0, 0, 20, 20),
                  grand_child3->render_surface()->clip_rect());
 }
 
 TEST(LayerTreeHostCommonTest, AnimationsForRenderSurfaceHierarchy) {
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<Layer> render_surface1 = Layer::Create();
   scoped_refptr<Layer> render_surface2 = Layer::Create();
   scoped_refptr<Layer> child_of_root = Layer::Create();
   scoped_refptr<Layer> child_of_rs1 = Layer::Create();
   scoped_refptr<Layer> child_of_rs2 = Layer::Create();
@@ skipping 200 matching lines @@
       4.0, child_of_rs2->screen_space_transform().matrix().getDouble(1, 3));
   EXPECT_FLOAT_EQ(
       5.0,
       grand_child_of_rs2->screen_space_transform().matrix().getDouble(1, 3));
 }
 
 TEST(LayerTreeHostCommonTest, VisibleRectForIdentityTransform) {
   // Test the calculateVisibleRect() function works correctly for identity
   // transforms.
 
-  gfx::Rect target_surface_rect = gfx::Rect(gfx::Point(), gfx::Size(100, 100));
+  gfx::Rect target_surface_rect = gfx::Rect(0, 0, 100, 100);
   gfx::Transform layer_to_surface_transform;
 
   // Case 1: Layer is contained within the surface.
   gfx::Rect layer_content_rect =
-      gfx::Rect(gfx::Point(10, 10), gfx::Size(30, 30));
-  gfx::Rect expected = gfx::Rect(gfx::Point(10, 10), gfx::Size(30, 30));
+      gfx::Rect(10, 10, 30, 30);
+  gfx::Rect expected = gfx::Rect(10, 10, 30, 30);
   gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
       target_surface_rect, layer_content_rect, layer_to_surface_transform);
   EXPECT_RECT_EQ(expected, actual);
 
   // Case 2: Layer is outside the surface rect.
-  layer_content_rect = gfx::Rect(gfx::Point(120, 120), gfx::Size(30, 30));
+  layer_content_rect = gfx::Rect(120, 120, 30, 30);
   actual = LayerTreeHostCommon::CalculateVisibleRect(
       target_surface_rect, layer_content_rect, layer_to_surface_transform);
   EXPECT_TRUE(actual.IsEmpty());
 
   // Case 3: Layer is partially overlapping the surface rect.
-  layer_content_rect = gfx::Rect(gfx::Point(80, 80), gfx::Size(30, 30));
-  expected = gfx::Rect(gfx::Point(80, 80), gfx::Size(20, 20));
+  layer_content_rect = gfx::Rect(80, 80, 30, 30);
+  expected = gfx::Rect(80, 80, 20, 20);
   actual = LayerTreeHostCommon::CalculateVisibleRect(
       target_surface_rect, layer_content_rect, layer_to_surface_transform);
   EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(LayerTreeHostCommonTest, VisibleRectForTranslations) {
   // Test the calculateVisibleRect() function works correctly for scaling
   // transforms.
 
-  gfx::Rect target_surface_rect = gfx::Rect(gfx::Point(), gfx::Size(100, 100));
-  gfx::Rect layer_content_rect = gfx::Rect(gfx::Point(), gfx::Size(30, 30));
+  gfx::Rect target_surface_rect = gfx::Rect(0, 0, 100, 100);
+  gfx::Rect layer_content_rect = gfx::Rect(0, 0, 30, 30);
   gfx::Transform layer_to_surface_transform;
 
   // Case 1: Layer is contained within the surface.
   layer_to_surface_transform.MakeIdentity();
   layer_to_surface_transform.Translate(10.0, 10.0);
-  gfx::Rect expected = gfx::Rect(gfx::Point(), gfx::Size(30, 30));
+  gfx::Rect expected = gfx::Rect(0, 0, 30, 30);
   gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
       target_surface_rect, layer_content_rect, layer_to_surface_transform);
   EXPECT_RECT_EQ(expected, actual);
 
   // Case 2: Layer is outside the surface rect.
   layer_to_surface_transform.MakeIdentity();
   layer_to_surface_transform.Translate(120.0, 120.0);
   actual = LayerTreeHostCommon::CalculateVisibleRect(
       target_surface_rect, layer_content_rect, layer_to_surface_transform);
   EXPECT_TRUE(actual.IsEmpty());
 
   // Case 3: Layer is partially overlapping the surface rect.
   layer_to_surface_transform.MakeIdentity();
   layer_to_surface_transform.Translate(80.0, 80.0);
-  expected = gfx::Rect(gfx::Point(), gfx::Size(20, 20));
+  expected = gfx::Rect(0, 0, 20, 20);
   actual = LayerTreeHostCommon::CalculateVisibleRect(
       target_surface_rect, layer_content_rect, layer_to_surface_transform);
   EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(LayerTreeHostCommonTest, VisibleRectFor2DRotations) {
   // Test the calculateVisibleRect() function works correctly for rotations
   // about z-axis (i.e. 2D rotations).  Remember that calculateVisibleRect()
   // should return the g in the layer's space.
 
-  gfx::Rect target_surface_rect = gfx::Rect(gfx::Point(), gfx::Size(100, 100));
-  gfx::Rect layer_content_rect = gfx::Rect(gfx::Point(), gfx::Size(30, 30));
+  gfx::Rect target_surface_rect = gfx::Rect(0, 0, 100, 100);
+  gfx::Rect layer_content_rect = gfx::Rect(0, 0, 30, 30);
   gfx::Transform layer_to_surface_transform;
 
   // Case 1: Layer is contained within the surface.
   layer_to_surface_transform.MakeIdentity();
   layer_to_surface_transform.Translate(50.0, 50.0);
   layer_to_surface_transform.Rotate(45.0);
-  gfx::Rect expected = gfx::Rect(gfx::Point(), gfx::Size(30, 30));
+  gfx::Rect expected = gfx::Rect(0, 0, 30, 30);
   gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
       target_surface_rect, layer_content_rect, layer_to_surface_transform);
   EXPECT_RECT_EQ(expected, actual);
 
   // Case 2: Layer is outside the surface rect.
   layer_to_surface_transform.MakeIdentity();
   layer_to_surface_transform.Translate(-50.0, 0.0);
   layer_to_surface_transform.Rotate(45.0);
   actual = LayerTreeHostCommon::CalculateVisibleRect(
       target_surface_rect, layer_content_rect, layer_to_surface_transform);
   EXPECT_TRUE(actual.IsEmpty());
 
   // Case 3: The layer is rotated about its top-left corner. In surface space,
   // the layer is oriented diagonally, with the left half outside of the render
   // surface. In this case, the g should still be the entire layer
   // (remember the g is computed in layer space); both the top-left
   // and bottom-right corners of the layer are still visible.
   layer_to_surface_transform.MakeIdentity();
   layer_to_surface_transform.Rotate(45.0);
-  expected = gfx::Rect(gfx::Point(), gfx::Size(30, 30));
+  expected = gfx::Rect(0, 0, 30, 30);
   actual = LayerTreeHostCommon::CalculateVisibleRect(
       target_surface_rect, layer_content_rect, layer_to_surface_transform);
   EXPECT_RECT_EQ(expected, actual);
 
   // Case 4: The layer is rotated about its top-left corner, and translated
   // upwards. In surface space, the layer is oriented diagonally, with only the
   // top corner of the surface overlapping the layer. In layer space, the render
   // surface overlaps the right side of the layer. The g should be
   // the layer's right half.
   layer_to_surface_transform.MakeIdentity();
   layer_to_surface_transform.Translate(0.0, -sqrt(2.0) * 15.0);
   layer_to_surface_transform.Rotate(45.0);
-  expected = gfx::Rect(gfx::Point(15, 0),
-                       gfx::Size(15, 30));  // right half of layer bounds.
+  expected = gfx::Rect(15, 0, 15, 30);  // Right half of layer bounds.
   actual = LayerTreeHostCommon::CalculateVisibleRect(
       target_surface_rect, layer_content_rect, layer_to_surface_transform);
   EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(LayerTreeHostCommonTest, VisibleRectFor3dOrthographicTransform) {
   // Test that the calculateVisibleRect() function works correctly for 3d
   // transforms.
 
-  gfx::Rect target_surface_rect = gfx::Rect(gfx::Point(), gfx::Size(100, 100));
-  gfx::Rect layer_content_rect = gfx::Rect(gfx::Point(), gfx::Size(100, 100));
+  gfx::Rect target_surface_rect = gfx::Rect(0, 0, 100, 100);
+  gfx::Rect layer_content_rect = gfx::Rect(0, 0, 100, 100);
   gfx::Transform layer_to_surface_transform;
 
   // Case 1: Orthographic projection of a layer rotated about y-axis by 45
   // degrees, should be fully contained in the render surface.
   layer_to_surface_transform.MakeIdentity();
   layer_to_surface_transform.RotateAboutYAxis(45.0);
-  gfx::Rect expected = gfx::Rect(gfx::Point(), gfx::Size(100, 100));
+  gfx::Rect expected = gfx::Rect(0, 0, 100, 100);
   gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
       target_surface_rect, layer_content_rect, layer_to_surface_transform);
   EXPECT_RECT_EQ(expected, actual);
 
   // Case 2: Orthographic projection of a layer rotated about y-axis by 45
   // degrees, but shifted to the side so only the right-half the layer would be
   // visible on the surface.
   // 100 is the un-rotated layer width; divided by sqrt(2) is the rotated width.
   double half_width_of_rotated_layer = (100.0 / sqrt(2.0)) * 0.5;
   layer_to_surface_transform.MakeIdentity();
   layer_to_surface_transform.Translate(-half_width_of_rotated_layer, 0.0);
   layer_to_surface_transform.RotateAboutYAxis(
-      45.0);  // rotates about the left edge of the layer
-  expected = gfx::Rect(gfx::Point(50, 0),
-                       gfx::Size(50, 100));  // right half of the layer.
+      45.0);  // Rotates about the left edge of the layer.
+  expected = gfx::Rect(50, 0, 50, 100);  // Tight half of the layer.
   actual = LayerTreeHostCommon::CalculateVisibleRect(
       target_surface_rect, layer_content_rect, layer_to_surface_transform);
   EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(LayerTreeHostCommonTest, VisibleRectFor3dPerspectiveTransform) {
   // Test the calculateVisibleRect() function works correctly when the layer has
   // a perspective projection onto the target surface.
 
-  gfx::Rect target_surface_rect = gfx::Rect(gfx::Point(), gfx::Size(100, 100));
-  gfx::Rect layer_content_rect =
-      gfx::Rect(gfx::Point(-50, -50), gfx::Size(200, 200));
+  gfx::Rect target_surface_rect = gfx::Rect(0, 0, 100, 100);
+  gfx::Rect layer_content_rect = gfx::Rect(-50, -50, 200, 200);
   gfx::Transform layer_to_surface_transform;
 
   // Case 1: Even though the layer is twice as large as the surface, due to
   // perspective foreshortening, the layer will fit fully in the surface when
   // its translated more than the perspective amount.
   layer_to_surface_transform.MakeIdentity();
 
   // The following sequence of transforms applies the perspective about the
   // center of the surface.
   layer_to_surface_transform.Translate(50.0, 50.0);
   layer_to_surface_transform.ApplyPerspectiveDepth(9.0);
   layer_to_surface_transform.Translate(-50.0, -50.0);
 
   // This translate places the layer in front of the surface's projection plane.
   layer_to_surface_transform.Translate3d(0.0, 0.0, -27.0);
 
-  gfx::Rect expected = gfx::Rect(gfx::Point(-50, -50), gfx::Size(200, 200));
+  gfx::Rect expected = gfx::Rect(-50, -50, 200, 200);
   gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
       target_surface_rect, layer_content_rect, layer_to_surface_transform);
   EXPECT_RECT_EQ(expected, actual);
 
   // Case 2: same projection as before, except that the layer is also translated
   // to the side, so that only the right half of the layer should be visible.
   //
   // Explanation of expected result: The perspective ratio is (z distance
   // between layer and camera origin) / (z distance between projection plane and
   // camera origin) == ((-27 - 9) / 9) Then, by similar triangles, if we want to
   // move a layer by translating -50 units in projected surface units (so that
   // only half of it is visible), then we would need to translate by (-36 / 9) *
   // -50 == -200 in the layer's units.
   layer_to_surface_transform.Translate3d(-200.0, 0.0, 0.0);
   expected = gfx::Rect(
       gfx::Point(50, -50),
       gfx::Size(100, 200));  // The right half of the layer's bounding rect.
   actual = LayerTreeHostCommon::CalculateVisibleRect(
       target_surface_rect, layer_content_rect, layer_to_surface_transform);
   EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(LayerTreeHostCommonTest,
      VisibleRectFor3dOrthographicIsNotClippedBehindSurface) {
   // There is currently no explicit concept of an orthographic projection plane
   // in our code (nor in the CSS spec to my knowledge). Therefore, layers that
   // are technically behind the surface in an orthographic world should not be
   // clipped when they are flattened to the surface.
 
-  gfx::Rect target_surface_rect = gfx::Rect(gfx::Point(), gfx::Size(100, 100));
-  gfx::Rect layer_content_rect = gfx::Rect(gfx::Point(), gfx::Size(100, 100));
+  gfx::Rect target_surface_rect = gfx::Rect(0, 0, 100, 100);
+  gfx::Rect layer_content_rect = gfx::Rect(0, 0, 100, 100);
   gfx::Transform layer_to_surface_transform;
 
   // This sequence of transforms effectively rotates the layer about the y-axis
   // at the center of the layer.
   layer_to_surface_transform.MakeIdentity();
   layer_to_surface_transform.Translate(50.0, 0.0);
   layer_to_surface_transform.RotateAboutYAxis(45.0);
   layer_to_surface_transform.Translate(-50.0, 0.0);
 
-  gfx::Rect expected = gfx::Rect(gfx::Point(), gfx::Size(100, 100));
+  gfx::Rect expected = gfx::Rect(0, 0, 100, 100);
   gfx::Rect actual = LayerTreeHostCommon::CalculateVisibleRect(
       target_surface_rect, layer_content_rect, layer_to_surface_transform);
   EXPECT_RECT_EQ(expected, actual);
 }
 
 TEST(LayerTreeHostCommonTest, VisibleRectFor3dPerspectiveWhenClippedByW) {
   // Test the calculateVisibleRect() function works correctly when projecting a
   // surface onto a layer, but the layer is partially behind the camera (not
   // just behind the projection plane). In this case, the cartesian coordinates
   // may seem to be valid, but actually they are not. The visible rect needs to
   // be properly clipped by the w = 0 plane in homogeneous coordinates before
   // converting to cartesian coordinates.
 
-  gfx::Rect target_surface_rect =
-      gfx::Rect(gfx::Point(-50, -50), gfx::Size(100, 100));
+  gfx::Rect target_surface_rect = gfx::Rect(-50, -50, 100, 100);
   gfx::Rect layer_content_rect =
-      gfx::Rect(gfx::Point(-10, -1), gfx::Size(20, 2));
+      gfx::Rect(-10, -1, 20, 2);
   gfx::Transform layer_to_surface_transform;
 
   // The layer is positioned so that the right half of the layer should be in
   // front of the camera, while the other half is behind the surface's
   // projection plane. The following sequence of transforms applies the
   // perspective and rotation about the center of the layer.
   layer_to_surface_transform.MakeIdentity();
   layer_to_surface_transform.ApplyPerspectiveDepth(1.0);
   layer_to_surface_transform.Translate3d(-2.0, 0.0, 1.0);
   layer_to_surface_transform.RotateAboutYAxis(45.0);
@@ skipping 17 matching lines @@
 TEST(LayerTreeHostCommonTest, VisibleRectForPerspectiveUnprojection) {
   // To determine visible rect in layer space, there needs to be an
   // un-projection from surface space to layer space. When the original
   // transform was a perspective projection that was clipped, it returns a rect
   // that encloses the clipped bounds.  Un-projecting this new rect may require
   // clipping again.
 
   // This sequence of transforms causes one corner of the layer to protrude
   // across the w = 0 plane, and should be clipped.
   gfx::Rect target_surface_rect =
-      gfx::Rect(gfx::Point(-50, -50), gfx::Size(100, 100));
+      gfx::Rect(-50, -50, 100, 100);
   gfx::Rect layer_content_rect =
-      gfx::Rect(gfx::Point(-10, -10), gfx::Size(20, 20));
+      gfx::Rect(-10, -10, 20, 20);
   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);
   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(gfx::Point(-10, -10), gfx::Size(20, 20));
+  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_RECT_EQ(expected, actual);
 }
 
 TEST(LayerTreeHostCommonTest, DrawableAndVisibleContentRectsForSimpleLayers) {
   scoped_refptr<Layer> root = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> child1 =
       make_scoped_refptr(new LayerWithForcedDrawsContent());
   scoped_refptr<LayerWithForcedDrawsContent> child2 =
@@ skipping 1132 matching lines @@
       render_surface_layer_list[1]->render_surface()->layer_list()[0]->id());
   EXPECT_EQ(
       child_of_animating_surface->id(),
       render_surface_layer_list[1]->render_surface()->layer_list()[1]->id());
 
   EXPECT_FALSE(child2->visible_content_rect().IsEmpty());
 
   // The animating layers should have a visible content rect that represents the
   // area of the front face that is within the viewport.
   EXPECT_EQ(animating_child->visible_content_rect(),
-            gfx::Rect(gfx::Point(), animating_child->content_bounds()));
+            gfx::Rect(animating_child->content_bounds()));
   EXPECT_EQ(animating_surface->visible_content_rect(),
-            gfx::Rect(gfx::Point(), animating_surface->content_bounds()));
+            gfx::Rect(animating_surface->content_bounds()));
   // And layers in the subtree of the animating layer should have valid visible
   // content rects also.
   EXPECT_EQ(
       child_of_animating_surface->visible_content_rect(),
-      gfx::Rect(gfx::Point(), child_of_animating_surface->content_bounds()));
+      gfx::Rect(child_of_animating_surface->content_bounds()));
 }
 
 TEST(LayerTreeHostCommonTest,
      BackFaceCullingWithPreserves3dForFlatteningSurface) {
   // Verify the behavior of back-face culling for a render surface that is
   // created when it flattens its subtree, and its parent has preserves-3d.
 
   const gfx::Transform identity_matrix;
   scoped_refptr<Layer> parent = Layer::Create();
   scoped_refptr<LayerWithForcedDrawsContent> front_facing_surface =
@@ skipping 589 matching lines @@
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list,
                                                false);
 
   // Sanity check the scenario we just created.
   // The visible content rect for test_layer is actually 100x100, even though
   // its layout size is 50x50, positioned at 25x25.
   LayerImpl* test_layer = root->children()[0];
-  EXPECT_RECT_EQ(gfx::Rect(gfx::Point(), gfx::Size(100, 100)),
+  EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100),
                  test_layer->visible_content_rect());
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
 
   // Hit testing for a point outside the layer should return a null pointer (the
   // root layer does not draw content, so it will not be hit tested either).
   gfx::Point test_point(101, 101);
   LayerImpl* result_layer = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       test_point, render_surface_layer_list);
   EXPECT_FALSE(result_layer);
@@ skipping 1014 matching lines @@
                                                1.f,
                                                dummy_max_texture_size,
                                                false,
                                                &render_surface_layer_list,
                                                false);
 
   // Sanity check the scenario we just created.
   // The visible content rect for test_layer is actually 100x100, even though
   // its layout size is 50x50, positioned at 25x25.
   LayerImpl* test_layer = root->children()[0];
-  EXPECT_RECT_EQ(gfx::Rect(gfx::Point(), gfx::Size(100, 100)),
-                 test_layer->visible_content_rect());
+  EXPECT_RECT_EQ(gfx::Rect(0, 0, 100, 100), test_layer->visible_content_rect());
   ASSERT_EQ(1u, render_surface_layer_list.size());
   ASSERT_EQ(1u, root->render_surface()->layer_list().size());
 
   // Hit checking for a point outside the layer should return a null pointer
   // (the root layer does not draw content, so it will not be tested either).
   gfx::Point test_point(76, 76);
   LayerImpl* result_layer =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
           test_point, render_surface_layer_list);
   EXPECT_FALSE(result_layer);
@@ skipping 385 matching lines @@
   EXPECT_EQ(1u, render_surface_layer_list.size());
 
   // Verify parent transforms
   gfx::Transform expected_parent_transform;
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
                                   parent->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
                                   parent->draw_transform());
 
   // Verify results of transformed parent rects
-  gfx::RectF parent_content_bounds(gfx::PointF(),
-                                   gfx::SizeF(parent->content_bounds()));
+  gfx::RectF parent_content_bounds(parent->content_bounds());
 
   gfx::RectF parent_draw_rect =
       MathUtil::MapClippedRect(parent->draw_transform(), parent_content_bounds);
   gfx::RectF parent_screen_space_rect = MathUtil::MapClippedRect(
       parent->screen_space_transform(), parent_content_bounds);
 
-  gfx::RectF expected_parent_draw_rect(gfx::PointF(), parent->bounds());
+  gfx::RectF expected_parent_draw_rect(parent->bounds());
   expected_parent_draw_rect.Scale(device_scale_factor);
   EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_draw_rect);
   EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_screen_space_rect);
 
   // Verify child and child_empty transforms. They should match.
   gfx::Transform expected_child_transform;
   expected_child_transform.Translate(
       device_scale_factor * child->position().x(),
       device_scale_factor * child->position().y());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_empty->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child_empty->screen_space_transform());
 
   // Verify results of transformed child and child_empty rects. They should
   // match.
-  gfx::RectF child_content_bounds(gfx::PointF(),
-                                  gfx::SizeF(child->content_bounds()));
+  gfx::RectF child_content_bounds(child->content_bounds());
 
   gfx::RectF child_draw_rect =
       MathUtil::MapClippedRect(child->draw_transform(), child_content_bounds);
   gfx::RectF child_screen_space_rect = MathUtil::MapClippedRect(
       child->screen_space_transform(), child_content_bounds);
 
   gfx::RectF child_empty_draw_rect = MathUtil::MapClippedRect(
       child_empty->draw_transform(), child_content_bounds);
   gfx::RectF child_empty_screen_space_rect = MathUtil::MapClippedRect(
       child_empty->screen_space_transform(), child_content_bounds);
@@ skipping 187 matching lines @@
   EXPECT_EQ(1u, render_surface_layer_list.size());
 
   // Verify parent transforms
   gfx::Transform expected_parent_transform;
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
                                   parent->screen_space_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_parent_transform,
                                   parent->draw_transform());
 
   // Verify results of transformed parent rects
-  gfx::RectF parent_content_bounds(gfx::PointF(),
-                                   gfx::SizeF(parent->content_bounds()));
+  gfx::RectF parent_content_bounds(parent->content_bounds());
 
   gfx::RectF parent_draw_rect =
       MathUtil::MapClippedRect(parent->draw_transform(), parent_content_bounds);
   gfx::RectF parent_screen_space_rect = MathUtil::MapClippedRect(
       parent->screen_space_transform(), parent_content_bounds);
 
-  gfx::RectF expected_parent_draw_rect(gfx::PointF(), parent->bounds());
+  gfx::RectF expected_parent_draw_rect(parent->bounds());
   expected_parent_draw_rect.Scale(device_scale_factor);
   expected_parent_draw_rect.set_width(ceil(expected_parent_draw_rect.width()));
   expected_parent_draw_rect.set_height(
       ceil(expected_parent_draw_rect.height()));
   EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_draw_rect);
   EXPECT_FLOAT_RECT_EQ(expected_parent_draw_rect, parent_screen_space_rect);
 
   // Verify child transforms
   gfx::Transform expected_child_transform;
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child->draw_transform());
   EXPECT_TRANSFORMATION_MATRIX_EQ(expected_child_transform,
                                   child->screen_space_transform());
 
   // Verify results of transformed child rects
-  gfx::RectF child_content_bounds(gfx::PointF(),
-                                  gfx::SizeF(child->content_bounds()));
+  gfx::RectF child_content_bounds(child->content_bounds());
 
   gfx::RectF child_draw_rect =
       MathUtil::MapClippedRect(child->draw_transform(), child_content_bounds);
   gfx::RectF child_screen_space_rect = MathUtil::MapClippedRect(
       child->screen_space_transform(), child_content_bounds);
 
-  gfx::RectF expected_child_draw_rect(gfx::PointF(), child->bounds());
+  gfx::RectF expected_child_draw_rect(child->bounds());
   expected_child_draw_rect.Scale(device_scale_factor);
   expected_child_draw_rect.set_width(ceil(expected_child_draw_rect.width()));
   expected_child_draw_rect.set_height(ceil(expected_child_draw_rect.height()));
   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_draw_rect);
   EXPECT_FLOAT_RECT_EQ(expected_child_draw_rect, child_screen_space_rect);
 
   // Verify child_no_scale transforms
   gfx::Transform expected_child_no_scale_transform = child->draw_transform();
   // All transforms operate on content rects. The child's content rect
   // incorporates device scale, but the child_no_scale does not; add it here.
@@ skipping 1115 matching lines @@
   EXPECT_EQ(can_use_lcd_text_, child_->can_use_lcd_text());
   EXPECT_EQ(can_use_lcd_text_, grand_child_->can_use_lcd_text());
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostCommonTest,
                         LCDTextTest,
                         testing::Combine(testing::Bool(), testing::Bool()));
 
 }  // namespace
 }  // namespace cc