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

cc/layers/tiled_layer_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/layers/tiled_layer.h"
 
 #include "cc/debug/overdraw_metrics.h"
 #include "cc/resources/bitmap_content_layer_updater.h"
 #include "cc/resources/layer_painter.h"
 #include "cc/resources/prioritized_resource_manager.h"
@@ skipping 572 matching lines @@
 
     resource_manager_->SetMaxMemoryLimitBytes(memory_for_layer);
 
     scoped_refptr<FakeTiledLayer> layer =
         make_scoped_refptr(new FakeTiledLayer(resource_manager_.get()));
     scoped_ptr<FakeTiledLayerImpl> layer_impl =
         make_scoped_ptr(new FakeTiledLayerImpl(host_impl_->active_tree(), 1));
 
     // Full size layer with half being visible.
     layer->SetBounds(gfx::Size(layer_width, layer_height));
-    gfx::Rect visible_rect(gfx::Point(),
-                           gfx::Size(layer_width / 2, layer_height));
+    gfx::Rect visible_rect(0, 0, layer_width / 2, layer_height);
     CalcDrawProps(layer);
 
     // Pretend the layer is animating.
     layer->draw_properties().target_space_transform_is_animating = true;
     layer->draw_properties().visible_content_rect = visible_rect;
     layer->SetLayerTreeHost(layer_tree_host_.get());
 
     // The layer should paint its entire contents on the first paint
     // if it is close to the viewport size and has the available memory.
     layer->SetTexturePriorities(priority_calculator_);
@@ skipping 244 matching lines @@
   LayerPushPropertiesTo(layer.get(), layer_impl.get());
   EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(0, 0));
   EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(0, 1));
   EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(1, 0));
   EXPECT_FALSE(layer_impl->HasResourceIdForTileAt(1, 1));
 }
 
 TEST_F(TiledLayerTest, SkipsDrawGetsReset) {
   // Create two 300 x 300 tiled layers.
   gfx::Size content_bounds(300, 300);
-  gfx::Rect content_rect(gfx::Point(), content_bounds);
+  gfx::Rect content_rect(content_bounds);
 
   // We have enough memory for only one of the two layers.
   int memory_limit = 4 * 300 * 300;  // 4 bytes per pixel.
 
   scoped_refptr<FakeTiledLayer> root_layer = make_scoped_refptr(
       new FakeTiledLayer(layer_tree_host_->contents_texture_manager()));
   scoped_refptr<FakeTiledLayer> child_layer = make_scoped_refptr(
       new FakeTiledLayer(layer_tree_host_->contents_texture_manager()));
   root_layer->AddChild(child_layer);
 
@@ skipping 60 matching lines @@
 }
 
 class TiledLayerPartialUpdateTest : public TiledLayerTest {
  public:
   TiledLayerPartialUpdateTest() { settings_.max_partial_texture_updates = 4; }
 };
 
 TEST_F(TiledLayerPartialUpdateTest, PartialUpdates) {
   // Create one 300 x 200 tiled layer with 3 x 2 tiles.
   gfx::Size content_bounds(300, 200);
-  gfx::Rect content_rect(gfx::Point(), content_bounds);
+  gfx::Rect content_rect(content_bounds);
 
   scoped_refptr<FakeTiledLayer> layer = make_scoped_refptr(
       new FakeTiledLayer(layer_tree_host_->contents_texture_manager()));
   layer->SetBounds(content_bounds);
   layer->SetPosition(gfx::PointF(0, 0));
   layer->draw_properties().visible_content_rect = content_rect;
   layer->InvalidateContentRect(content_rect);
 
   layer_tree_host_->SetRootLayer(layer);
   layer_tree_host_->SetViewportSize(gfx::Size(300, 200), gfx::Size(300, 200));
@@ skipping 117 matching lines @@
   occlusion_ = &occluded;
 
   // The tile size is 100x100.
 
   layer_tree_host_->SetViewportSize(gfx::Size(600, 600), gfx::Size(600, 600));
   layer->SetBounds(gfx::Size(600, 600));
   CalcDrawProps(layer);
 
   occluded.SetOcclusion(gfx::Rect(200, 200, 300, 100));
   layer->draw_properties().drawable_content_rect =
-      gfx::Rect(gfx::Point(), layer->content_bounds());
+      gfx::Rect(layer->content_bounds());
   layer->draw_properties().visible_content_rect =
-      gfx::Rect(gfx::Point(), layer->content_bounds());
+      gfx::Rect(layer->content_bounds());
   layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
 
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->Update(queue_.get(), &occluded, NULL);
   EXPECT_EQ(36 - 3, layer->fake_layer_updater()->update_count());
 
   EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
   EXPECT_NEAR(
       occluded.overdraw_metrics()->pixels_uploaded_translucent(), 330000, 1);
@@ skipping 154 matching lines @@
   layer_tree_host_->SetViewportSize(gfx::Size(600, 600), gfx::Size(600, 600));
   layer->SetBounds(gfx::Size(600, 600));
   CalcDrawProps(layer);
   gfx::Transform screen_transform;
   screen_transform.Scale(0.5, 0.5);
   layer->draw_properties().screen_space_transform = screen_transform;
   layer->draw_properties().target_space_transform = screen_transform;
 
   occluded.SetOcclusion(gfx::Rect(100, 100, 150, 50));
   layer->draw_properties().drawable_content_rect =
-      gfx::Rect(gfx::Point(), layer->content_bounds());
+      gfx::Rect(layer->content_bounds());
   layer->draw_properties().visible_content_rect =
-      gfx::Rect(gfx::Point(), layer->content_bounds());
+      gfx::Rect(layer->content_bounds());
   layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->Update(queue_.get(), &occluded, NULL);
   EXPECT_EQ(36 - 3, layer->fake_layer_updater()->update_count());
 
   EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
   EXPECT_NEAR(
       occluded.overdraw_metrics()->pixels_uploaded_translucent(), 330000, 1);
   EXPECT_EQ(3, occluded.overdraw_metrics()->tiles_culled_for_upload());
@@ skipping 16 matching lines @@
   CalcDrawProps(layer);
   EXPECT_FLOAT_EQ(layer->contents_scale_x(), layer->contents_scale_y());
   gfx::Transform draw_transform;
   double inv_scale_factor = 1 / layer->contents_scale_x();
   draw_transform.Scale(inv_scale_factor, inv_scale_factor);
   layer->draw_properties().target_space_transform = draw_transform;
   layer->draw_properties().screen_space_transform = draw_transform;
 
   occluded.SetOcclusion(gfx::Rect(200, 200, 300, 100));
   layer->draw_properties().drawable_content_rect =
-      gfx::Rect(gfx::Point(), layer->bounds());
+      gfx::Rect(layer->bounds());
   layer->draw_properties().visible_content_rect =
-      gfx::Rect(gfx::Point(), layer->content_bounds());
+      gfx::Rect(layer->content_bounds());
   layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->Update(queue_.get(), &occluded, NULL);
   // The content is half the size of the layer (so the number of tiles is
   // fewer).  In this case, the content is 300x300, and since the tile size is
   // 100, the number of tiles 3x3.
   EXPECT_EQ(9, layer->fake_layer_updater()->update_count());
 
   EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
   EXPECT_NEAR(
       occluded.overdraw_metrics()->pixels_uploaded_translucent(), 90000, 1);
   EXPECT_EQ(0, occluded.overdraw_metrics()->tiles_culled_for_upload());
 
   layer->fake_layer_updater()->ClearUpdateCount();
 
   // This makes sure the painting works when the content space is scaled to
   // a different layer space. In this case the occluded region catches the
   // blown up tiles.
   occluded.SetOcclusion(gfx::Rect(200, 200, 300, 200));
   layer->draw_properties().drawable_content_rect =
-      gfx::Rect(gfx::Point(), layer->bounds());
+      gfx::Rect(layer->bounds());
   layer->draw_properties().visible_content_rect =
-      gfx::Rect(gfx::Point(), layer->content_bounds());
+      gfx::Rect(layer->content_bounds());
   layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->Update(queue_.get(), &occluded, NULL);
   EXPECT_EQ(9 - 1, layer->fake_layer_updater()->update_count());
 
   EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
   EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(),
               90000 + 80000,
               1);
   EXPECT_EQ(1, occluded.overdraw_metrics()->tiles_culled_for_upload());
 
   layer->fake_layer_updater()->ClearUpdateCount();
 
   // This makes sure content scaling and transforms work together.
   gfx::Transform screen_transform;
   screen_transform.Scale(0.5, 0.5);
   layer->draw_properties().screen_space_transform = screen_transform;
   layer->draw_properties().target_space_transform = screen_transform;
 
   occluded.SetOcclusion(gfx::Rect(100, 100, 150, 100));
 
-  gfx::Rect layer_bounds_rect(gfx::Point(), layer->bounds());
+  gfx::Rect layer_bounds_rect(layer->bounds());
   layer->draw_properties().drawable_content_rect =
       gfx::ToEnclosingRect(gfx::ScaleRect(layer_bounds_rect, 0.5));
   layer->draw_properties().visible_content_rect =
-      gfx::Rect(gfx::Point(), layer->content_bounds());
+      gfx::Rect(layer->content_bounds());
   layer->InvalidateContentRect(gfx::Rect(0, 0, 600, 600));
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
   layer->Update(queue_.get(), &occluded, NULL);
   EXPECT_EQ(9 - 1, layer->fake_layer_updater()->update_count());
 
   EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_opaque(), 0, 1);
   EXPECT_NEAR(occluded.overdraw_metrics()->pixels_uploaded_translucent(),
               90000 + 80000 + 80000,
               1);
@@ skipping 412 matching lines @@
 TEST_F(TiledLayerTest,
        NonIntegerContentsScaleIsNotDistortedDuringInvalidation) {
   scoped_refptr<UpdateTrackingTiledLayer> layer =
       make_scoped_refptr(new UpdateTrackingTiledLayer(resource_manager_.get()));
 
   gfx::Rect layer_rect(0, 0, 30, 31);
   layer->SetPosition(layer_rect.origin());
   layer->SetBounds(layer_rect.size());
   layer->UpdateContentsScale(1.3f);
 
-  gfx::Rect content_rect(gfx::Point(), layer->content_bounds());
+  gfx::Rect content_rect(layer->content_bounds());
   layer->draw_properties().visible_content_rect = content_rect;
   layer->draw_properties().drawable_content_rect = content_rect;
 
   layer->SetTexturePriorities(priority_calculator_);
   resource_manager_->PrioritizeTextures();
 
   // Update the whole tile.
   layer->Update(queue_.get(), 0, NULL);
   layer->tracking_layer_painter()->ResetPaintedRect();
 
   EXPECT_RECT_EQ(gfx::Rect(), layer->tracking_layer_painter()->PaintedRect());
   UpdateTextures();
 
   // Invalidate the entire layer in layer space. When painting, the rect given
   // to webkit should match the layer's bounds.
   layer->SetNeedsDisplayRect(layer_rect);
   layer->Update(queue_.get(), 0, NULL);
 
   EXPECT_RECT_EQ(layer_rect, layer->tracking_layer_painter()->PaintedRect());
 }
 
 }  // namespace
 }  // namespace cc