[#2] Pass gfx structs by const ref (gfx::Rect, gfx::RectF)

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 <algorithm>
 #include <vector>
 
 #include "base/auto_reset.h"
@@ skipping 276 matching lines @@
   CHECK(TileAt(i, j));
 
   return added_tile;
 }
 
 void TiledLayer::SetNeedsDisplayRect(const gfx::RectF& dirty_rect) {
   InvalidateContentRect(LayerRectToContentRect(dirty_rect));
   ContentsScalingLayer::SetNeedsDisplayRect(dirty_rect);
 }
 
-void TiledLayer::InvalidateContentRect(gfx::Rect content_rect) {
+void TiledLayer::InvalidateContentRect(const gfx::Rect& content_rect) {
   UpdateBounds();
   if (tiler_->is_empty() || content_rect.IsEmpty() || skips_draw_)
     return;
 
   for (LayerTilingData::TileMap::const_iterator iter = tiler_->tiles().begin();
        iter != tiler_->tiles().end();
        ++iter) {
     UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
     DCHECK(tile);
     // TODO(enne): This should not ever be null.
@@ skipping 153 matching lines @@
           tile->managed_resource()->ReturnBackingTexture();
         }
       }
 
       paint_rect->Union(tile->dirty_rect);
       tile->MarkForUpdate();
     }
   }
 }
 
-void TiledLayer::UpdateTileTextures(gfx::Rect update_rect,
-                                    gfx::Rect paint_rect,
+void TiledLayer::UpdateTileTextures(const gfx::Rect& update_rect,
+                                    const gfx::Rect& paint_rect,
                                     int left,
                                     int top,
                                     int right,
                                     int bottom,
                                     ResourceUpdateQueue* queue,
                                     const OcclusionTracker* occlusion) {
   // The update_rect should be in layer space. So we have to convert the
   // paint_rect from content space to layer space.
   float width_scale =
       paint_properties().bounds.width() /
@@ skipping 103 matching lines @@
   return content_rect.width() <=
          viewport_size.width() + tiler_->tile_size().width() &&
          content_rect.height() <=
          viewport_size.height() + tiler_->tile_size().height();
 }
 
 namespace {
 // TODO(epenner): 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.
-void SetPriorityForTexture(gfx::Rect visible_rect,
-                           gfx::Rect tile_rect,
+void SetPriorityForTexture(const gfx::Rect& visible_rect,
+                           const gfx::Rect& tile_rect,
                            bool draws_to_root,
                            bool is_small_animated_layer,
                            PrioritizedResource* texture) {
   int priority = PriorityCalculator::LowestPriority();
   if (!visible_rect.IsEmpty()) {
     priority = PriorityCalculator::PriorityFromDistance(
         visible_rect, tile_rect, draws_to_root);
   }
 
   if (is_small_animated_layer) {
@@ skipping 69 matching lines @@
        ++iter) {
     UpdatableTile* tile = static_cast<UpdatableTile*>(iter->second);
     // TODO(enne): This should not ever be null.
     if (!tile)
       continue;
     tile->ResetUpdateState();
   }
 }
 
 namespace {
-gfx::Rect ExpandRectByDelta(gfx::Rect rect, gfx::Vector2d delta) {
+gfx::Rect ExpandRectByDelta(const gfx::Rect& rect, gfx::Vector2d delta) {
   int width = rect.width() + std::abs(delta.x());
   int height = rect.height() + std::abs(delta.y());
   int x = rect.x() + ((delta.x() < 0) ? delta.x() : 0);
   int y = rect.y() + ((delta.y() < 0) ? delta.y() : 0);
   return gfx::Rect(x, y, width, height);
 }
 }
 
 void TiledLayer::UpdateScrollPrediction() {
   // This scroll prediction is very primitive and should be replaced by a
@@ skipping 213 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