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

cc/resources/picture_layer_tiling.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/resources/picture_layer_tiling.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 
@@ skipping 84 matching lines @@
     }
   }
 
   // Create a new tile because our twin didn't have a valid one.
   scoped_refptr<Tile> tile = client_->CreateTile(this, tile_rect);
   if (tile.get())
     tiles_[key] = tile;
 }
 
 Region PictureLayerTiling::OpaqueRegionInContentRect(
-    gfx::Rect content_rect) const {
+    const gfx::Rect& content_rect) const {
   Region opaque_region;
   // TODO(enne): implement me
   return opaque_region;
 }
 
 void PictureLayerTiling::SetCanUseLCDText(bool can_use_lcd_text) {
   for (TileMap::iterator it = tiles_.begin(); it != tiles_.end(); ++it)
     it->second->set_can_use_lcd_text(can_use_lcd_text);
 }
 
@@ skipping 72 matching lines @@
       tile_j_(0),
       left_(0),
       top_(0),
       right_(-1),
       bottom_(-1) {
 }
 
 PictureLayerTiling::CoverageIterator::CoverageIterator(
     const PictureLayerTiling* tiling,
     float dest_scale,
-    gfx::Rect dest_rect)
+    const gfx::Rect& dest_rect)
     : tiling_(tiling),
       dest_rect_(dest_rect),
       dest_to_content_scale_(0),
       current_tile_(NULL),
       tile_i_(0),
       tile_j_(0),
       left_(0),
       top_(0),
       right_(-1),
       bottom_(-1) {
@@ skipping 126 matching lines @@
 }
 
 void PictureLayerTiling::Reset() {
   live_tiles_rect_ = gfx::Rect();
   tiles_.clear();
 }
 
 void PictureLayerTiling::UpdateTilePriorities(
     WhichTree tree,
     gfx::Size device_viewport,
-    gfx::Rect viewport_in_layer_space,
-    gfx::Rect visible_layer_rect,
+    const gfx::Rect& viewport_in_layer_space,
+    const gfx::Rect& visible_layer_rect,
     gfx::Size last_layer_bounds,
     gfx::Size current_layer_bounds,
     float last_layer_contents_scale,
     float current_layer_contents_scale,
     const gfx::Transform& last_screen_transform,
     const gfx::Transform& current_screen_transform,
     double current_frame_time_in_seconds,
     size_t max_tiles_for_interest_area) {
   if (!NeedsUpdateForFrameAtTime(current_frame_time_in_seconds)) {
     // This should never be zero for the purposes of has_ever_been_updated().
@@ skipping 195 matching lines @@
           time_to_visible_in_seconds,
           distance_to_visible_in_pixels);
       tile->SetPriority(tree, priority);
     }
   }
 
   last_impl_frame_time_in_seconds_ = current_frame_time_in_seconds;
 }
 
 void PictureLayerTiling::SetLiveTilesRect(
-    gfx::Rect new_live_tiles_rect) {
+    const gfx::Rect& new_live_tiles_rect) {
   DCHECK(new_live_tiles_rect.IsEmpty() ||
          ContentRect().Contains(new_live_tiles_rect));
   if (live_tiles_rect_ == new_live_tiles_rect)
     return;
 
   // Iterate to delete all tiles outside of our new live_tiles rect.
   for (TilingData::DifferenceIterator iter(&tiling_data_,
                                            live_tiles_rect_,
                                            new_live_tiles_rect);
        iter;
@@ skipping 96 matching lines @@
 
   // Compute the delta for our edges using the quadratic equation.
   return a == 0 ? -c / b :
      (-b + static_cast<int>(
          std::sqrt(static_cast<int64>(b) * b - 4.0 * a * c))) / (2 * a);
 }
 
 }  // namespace
 
 gfx::Rect PictureLayerTiling::ExpandRectEquallyToAreaBoundedBy(
-    gfx::Rect starting_rect,
+    const gfx::Rect& starting_rect,
     int64 target_area,
-    gfx::Rect bounding_rect,
+    const gfx::Rect& bounding_rect,
     RectExpansionCache* cache) {
   if (starting_rect.IsEmpty())
     return starting_rect;
 
   if (cache &&
       cache->previous_start == starting_rect &&
       cache->previous_bounds == bounding_rect &&
       cache->previous_target == target_area)
     return cache->previous_result;
 
@@ skipping 94 matching lines @@
       break;
   }
 
   gfx::Rect result(origin_x, origin_y, width, height);
   if (cache)
     cache->previous_result = result;
   return result;
 }
 
 }  // namespace cc