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

cc/resources/picture_pile_impl.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 <algorithm>
 #include <limits>
 
 #include "base/debug/trace_event.h"
 #include "cc/base/region.h"
 #include "cc/debug/debug_colors.h"
@@ skipping 52 matching lines @@
 }
 
 PicturePileImpl* PicturePileImpl::GetCloneForDrawingOnThread(
     unsigned thread_index) const {
   CHECK_GT(clones_for_drawing_.clones_.size(), thread_index);
   return clones_for_drawing_.clones_[thread_index].get();
 }
 
 void PicturePileImpl::RasterDirect(
     SkCanvas* canvas,
-    gfx::Rect canvas_rect,
+    const gfx::Rect& canvas_rect,
     float contents_scale,
     RenderingStatsInstrumentation* rendering_stats_instrumentation) {
   RasterCommon(canvas,
                NULL,
                canvas_rect,
                contents_scale,
                rendering_stats_instrumentation,
                false);
 }
 
 void PicturePileImpl::RasterForAnalysis(
     skia::AnalysisCanvas* canvas,
-    gfx::Rect canvas_rect,
+    const gfx::Rect& canvas_rect,
     float contents_scale,
     RenderingStatsInstrumentation* stats_instrumentation) {
   RasterCommon(
       canvas, canvas, canvas_rect, contents_scale, stats_instrumentation, true);
 }
 
 void PicturePileImpl::RasterToBitmap(
     SkCanvas* canvas,
-    gfx::Rect canvas_rect,
+    const gfx::Rect& canvas_rect,
     float contents_scale,
     RenderingStatsInstrumentation* rendering_stats_instrumentation) {
   if (clear_canvas_with_debug_color_) {
     // Any non-painted areas will be left in this color.
     canvas->clear(DebugColors::NonPaintedFillColor());
   }
 
   // If this picture has opaque contents, it is guaranteeing that it will
   // draw an opaque rect the size of the layer.  If it is not, then we must
   // clear this canvas ourselves.
@@ skipping 32 matching lines @@
   }
 
   RasterCommon(canvas,
                NULL,
                canvas_rect,
                contents_scale,
                rendering_stats_instrumentation,
                false);
 }
 
-void PicturePileImpl::CoalesceRasters(gfx::Rect canvas_rect,
-                                      gfx::Rect content_rect,
+void PicturePileImpl::CoalesceRasters(const gfx::Rect& canvas_rect,
+                                      const gfx::Rect& content_rect,
                                       float contents_scale,
                                       PictureRegionMap* results) {
   DCHECK(results);
   // Rasterize the collection of relevant picture piles.
   gfx::Rect layer_rect = gfx::ScaleToEnclosingRect(
       content_rect, 1.f / contents_scale);
 
   // Coalesce rasters of the same picture into different rects:
   //  - Compute the clip of each of the pile chunks,
   //  - Subtract it from the canvas rect to get difference region
@@ skipping 40 matching lines @@
     }
 
     Region& region = it->second;
     region.Subtract(content_clip);
   }
 }
 
 void PicturePileImpl::RasterCommon(
     SkCanvas* canvas,
     SkDrawPictureCallback* callback,
-    gfx::Rect canvas_rect,
+    const gfx::Rect& canvas_rect,
     float contents_scale,
     RenderingStatsInstrumentation* rendering_stats_instrumentation,
     bool is_analysis) {
   DCHECK(contents_scale >= min_contents_scale_);
 
   canvas->translate(-canvas_rect.x(), -canvas_rect.y());
   gfx::SizeF total_content_size = gfx::ScaleSize(tiling_.total_size(),
                                                  contents_scale);
   gfx::Rect total_content_rect(gfx::ToCeiledSize(total_content_size));
   gfx::Rect content_rect = total_content_rect;
@@ skipping 81 matching lines @@
       layer_rect.height(),
       SkPicture::kUsePathBoundsForClip_RecordingFlag);
 
   RasterToBitmap(canvas, layer_rect, 1.0, NULL);
   picture->endRecording();
 
   return picture;
 }
 
 void PicturePileImpl::AnalyzeInRect(
-    gfx::Rect content_rect,
+    const gfx::Rect& content_rect,
     float contents_scale,
     PicturePileImpl::Analysis* analysis) {
   AnalyzeInRect(content_rect, contents_scale, analysis, NULL);
 }
 
 void PicturePileImpl::AnalyzeInRect(
-    gfx::Rect content_rect,
+    const gfx::Rect& content_rect,
     float contents_scale,
     PicturePileImpl::Analysis* analysis,
     RenderingStatsInstrumentation* stats_instrumentation) {
   DCHECK(analysis);
   TRACE_EVENT0("cc", "PicturePileImpl::AnalyzeInRect");
 
   gfx::Rect layer_rect = gfx::ScaleToEnclosingRect(
       content_rect, 1.0f / contents_scale);
 
   layer_rect.Intersect(gfx::Rect(tiling_.total_size()));
@@ skipping 13 matching lines @@
 
 PicturePileImpl::Analysis::Analysis()
     : is_solid_color(false),
       has_text(false) {
 }
 
 PicturePileImpl::Analysis::~Analysis() {
 }
 
 PicturePileImpl::PixelRefIterator::PixelRefIterator(
-    gfx::Rect content_rect,
+    const gfx::Rect& content_rect,
     float contents_scale,
     const PicturePileImpl* picture_pile)
     : picture_pile_(picture_pile),
       layer_rect_(gfx::ScaleToEnclosingRect(
           content_rect, 1.f / contents_scale)),
       tile_iterator_(&picture_pile_->tiling_, layer_rect_) {
   // Early out if there isn't a single tile.
   if (!tile_iterator_)
     return;
 
@@ skipping 41 matching lines @@
        ++it) {
     Picture* picture = it->second.GetPicture();
     if (picture && (processed_pictures.count(picture) == 0)) {
       picture->EmitTraceSnapshot();
       processed_pictures.insert(picture);
     }
   }
 }
 
 }  // namespace cc