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

cc/layers/tiled_layer_impl_unittest.cc

 // Copyright 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 "cc/layers/tiled_layer_impl.h"
 
 #include "cc/layers/append_quads_data.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/resources/layer_tiling_data.h"
 #include "cc/test/fake_impl_proxy.h"
@@ skipping 18 matching lines @@
       gfx::Size layer_size,
       LayerTilingData::BorderTexelOption border_texels) {
     scoped_ptr<TiledLayerImpl> layer =
         TiledLayerImpl::Create(host_impl_.active_tree(), 1);
     scoped_ptr<LayerTilingData> tiler =
         LayerTilingData::Create(tile_size, border_texels);
     tiler->SetBounds(layer_size);
     layer->SetTilingData(*tiler);
     layer->set_skips_draw(false);
     layer->draw_properties().visible_content_rect =
-        gfx::Rect(gfx::Point(), layer_size);
+        gfx::Rect(layer_size);
     layer->draw_properties().opacity = 1;
     layer->SetBounds(layer_size);
     layer->SetContentBounds(layer_size);
     layer->CreateRenderSurface();
     layer->draw_properties().render_target = layer.get();
 
     ResourceProvider::ResourceId resource_id = 1;
     for (int i = 0; i < tiler->num_tiles_x(); ++i) {
       for (int j = 0; j < tiler->num_tiles_y(); ++j) {
         layer->PushTileProperties(
@@ skipping 53 matching lines @@
     AppendQuadsData data;
     layer->AppendQuads(&quad_culler, &data);
     EXPECT_EQ(quad_culler.quad_list().size(), 0u);
   }
 
   // Layer with non-intersecting visible layer rect produces no quads
   {
     scoped_ptr<TiledLayerImpl> layer =
         CreateLayer(tile_size, layer_size, LayerTilingData::NO_BORDER_TEXELS);
 
-    gfx::Rect outside_bounds(gfx::Point(-100, -100), gfx::Size(50, 50));
+    gfx::Rect outside_bounds(-100, -100, 50, 50);
     layer->draw_properties().visible_content_rect = outside_bounds;
 
     MockQuadCuller quad_culler;
     AppendQuadsData data;
     layer->AppendQuads(&quad_culler, &data);
     EXPECT_EQ(quad_culler.quad_list().size(), 0u);
   }
 
   // Layer with skips draw produces no quads
   {
@@ skipping 60 matching lines @@
   void CoverageVisibleRectOnTileBoundaries(
       LayerTilingData::BorderTexelOption borders) {
     gfx::Size layer_size(1000, 1000);
     QuadList quads;
     SharedQuadStateList shared_states;
     GetQuads(&quads,
              &shared_states,
              gfx::Size(100, 100),
              layer_size,
              borders,
-             gfx::Rect(gfx::Point(), layer_size));
-    LayerTestCommon::VerifyQuadsExactlyCoverRect(
-        quads, gfx::Rect(gfx::Point(), layer_size));
+             gfx::Rect(layer_size));
+    LayerTestCommon::VerifyQuadsExactlyCoverRect(quads, gfx::Rect(layer_size));
   }
 
   void CoverageVisibleRectIntersectsTiles(
       LayerTilingData::BorderTexelOption borders) {
     // This rect intersects the middle 3x3 of the 5x5 tiles.
     gfx::Point top_left(65, 73);
     gfx::Point bottom_right(182, 198);
     gfx::Rect visible_content_rect = gfx::BoundingRect(top_left, bottom_right);
 
     gfx::Size layer_size(250, 250);
@@ skipping 32 matching lines @@
 TEST_F(TiledLayerImplTest, TextureInfoForLayerNoBorders) {
   gfx::Size tile_size(50, 50);
   gfx::Size layer_size(250, 250);
   QuadList quads;
   SharedQuadStateList shared_states;
   GetQuads(&quads,
            &shared_states,
            tile_size,
            layer_size,
            LayerTilingData::NO_BORDER_TEXELS,
-           gfx::Rect(gfx::Point(), layer_size));
+           gfx::Rect(layer_size));
 
   for (size_t i = 0; i < quads.size(); ++i) {
     const TileDrawQuad* quad = TileDrawQuad::MaterialCast(quads[i]);
 
     EXPECT_NE(0u, quad->resource_id) << LayerTestCommon::quad_string << i;
     EXPECT_EQ(gfx::RectF(gfx::PointF(), tile_size), quad->tex_coord_rect)
         << LayerTestCommon::quad_string << i;
     EXPECT_EQ(tile_size, quad->texture_size) << LayerTestCommon::quad_string
                                              << i;
     EXPECT_EQ(gfx::Rect(0, 0, 1, 1), quad->opaque_rect)
         << LayerTestCommon::quad_string << i;
   }
 }
 
 }  // namespace
 }  // namespace cc