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

cc/layers/tiled_layer.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 "base/auto_reset.h"
 #include "base/basictypes.h"
 #include "build/build_config.h"
 #include "cc/debug/overdraw_metrics.h"
@@ skipping 128 matching lines @@
 }
 
 void TiledLayer::UpdateBounds() {
   gfx::Size old_bounds = tiler_->bounds();
   gfx::Size new_bounds = content_bounds();
   if (old_bounds == new_bounds)
     return;
   tiler_->SetBounds(new_bounds);
 
   // Invalidate any areas that the new bounds exposes.
-  Region old_region = gfx::Rect(gfx::Point(), old_bounds);
-  Region new_region = gfx::Rect(gfx::Point(), new_bounds);
+  Region old_region = gfx::Rect(old_bounds);
+  Region new_region = gfx::Rect(new_bounds);
   new_region.Subtract(old_region);
   for (Region::Iterator new_rects(new_region);
        new_rects.has_rect();
        new_rects.next())
     InvalidateContentRect(new_rects.rect());
 }
 
 void TiledLayer::SetTileSize(gfx::Size size) { tiler_->SetTileSize(size); }
 
 void TiledLayer::SetBorderTexelOption(
@@ skipping 401 matching lines @@
 // This picks a small animated layer to be anything less than one viewport. This
 // is specifically for page transitions which are viewport-sized layers. The
 // extra tile of padding is due to these layers being slightly larger than the
 // viewport in some cases.
 bool TiledLayer::IsSmallAnimatedLayer() const {
   if (!draw_transform_is_animating() && !screen_space_transform_is_animating())
     return false;
   gfx::Size viewport_size =
       layer_tree_host() ? layer_tree_host()->device_viewport_size()
                         : gfx::Size();
-  gfx::Rect content_rect(gfx::Point(), content_bounds());
+  gfx::Rect content_rect(content_bounds());
   return content_rect.width() <=
          viewport_size.width() + tiler_->tile_size().width() &&
          content_rect.height() <=
          viewport_size.height() + tiler_->tile_size().height();
 }
 
 namespace {
 // FIXME: Remove this and make this based on distance once distance can be
 // calculated for offscreen layers. For now, prioritize all small animated
 // layers after 512 pixels of pre-painting.
@@ skipping 25 matching lines @@
 
   if (tiler_->has_empty_bounds())
     return;
 
   bool draws_to_root = !render_target()->parent();
   bool small_animated_layer = IsSmallAnimatedLayer();
 
   // Minimally create the tiles in the desired pre-paint rect.
   gfx::Rect create_tiles_rect = IdlePaintRect();
   if (small_animated_layer)
-    create_tiles_rect = gfx::Rect(gfx::Point(), content_bounds());
+    create_tiles_rect = gfx::Rect(content_bounds());
   if (!create_tiles_rect.IsEmpty()) {
     int left, top, right, bottom;
     tiler_->ContentRectToTileIndices(
         create_tiles_rect, &left, &top, &right, &bottom);
     for (int j = top; j <= bottom; ++j) {
       for (int i = left; i <= right; ++i) {
         if (!TileAt(i, j))
           CreateTile(i, j);
       }
     }
@@ skipping 73 matching lines @@
         gfx::Vector2d(delta.x(), 0) :
         gfx::Vector2d(0, delta.y());
     predicted_visible_rect_ =
         ExpandRectByDelta(visible_content_rect(), major_scroll_delta);
 
     // Bound the prediction to prevent unbounded paints, and clamp to content
     // bounds.
     gfx::Rect bound = visible_content_rect();
     bound.Inset(-tiler_->tile_size().width() * kMaxPredictiveTilesCount,
                 -tiler_->tile_size().height() * kMaxPredictiveTilesCount);
-    bound.Intersect(gfx::Rect(gfx::Point(), content_bounds()));
+    bound.Intersect(gfx::Rect(content_bounds()));
     predicted_visible_rect_.Intersect(bound);
   }
   previous_content_bounds_ = content_bounds();
   previous_visible_rect_ = visible_content_rect();
 }
 
 void TiledLayer::Update(ResourceUpdateQueue* queue,
                         const OcclusionTracker* occlusion,
                         RenderingStats* stats) {
   DCHECK(!skips_draw_ && !failed_update_);  // Did ResetUpdateState get skipped?
   {
     base::AutoReset<bool> ignore_set_needs_commit(&ignore_set_needs_commit_,
                                                   true);
 
     ContentsScalingLayer::Update(queue, occlusion, stats);
     UpdateBounds();
   }
 
   if (tiler_->has_empty_bounds() || !DrawsContent())
     return;
 
   bool did_paint = false;
 
   // Animation pre-paint. If the layer is small, try to paint it all
   // immediately whether or not it is occluded, to avoid paint/upload
   // hiccups while it is animating.
   if (IsSmallAnimatedLayer()) {
     int left, top, right, bottom;
-    tiler_->ContentRectToTileIndices(gfx::Rect(gfx::Point(), content_bounds()),
+    tiler_->ContentRectToTileIndices(gfx::Rect(content_bounds()),
                                      &left,
                                      &top,
                                      &right,
                                      &bottom);
     UpdateTiles(left, top, right, bottom, queue, NULL, stats, &did_paint);
     if (did_paint)
       return;
     // This was an attempt to paint the entire layer so if we fail it's okay,
     // just fallback on painting visible etc. below.
     failed_update_ = false;
@@ skipping 128 matching lines @@
   gfx::Rect prepaint_rect = visible_content_rect();
   prepaint_rect.Inset(-tiler_->tile_size().width() * kPrepaintColumns,
                       -tiler_->tile_size().height() * kPrepaintRows);
   gfx::Rect content_rect(content_bounds());
   prepaint_rect.Intersect(content_rect);
 
   return prepaint_rect;
 }
 
 }  // namespace cc