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

cc/resources/picture.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.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 
@@ skipping 63 matching lines @@
   scoped_ptr<SkBitmap> decoded_jpeg(gfx::JPEGCodec::Decode(data, size));
   if (decoded_jpeg) {
     *bm = *decoded_jpeg;
     return true;
   }
   return false;
 }
 
 }  // namespace
 
-scoped_refptr<Picture> Picture::Create(gfx::Rect layer_rect) {
+scoped_refptr<Picture> Picture::Create(const gfx::Rect& layer_rect) {
   return make_scoped_refptr(new Picture(layer_rect));
 }
 
-Picture::Picture(gfx::Rect layer_rect)
+Picture::Picture(const gfx::Rect& layer_rect)
   : layer_rect_(layer_rect),
     cell_size_(layer_rect.size()) {
   // Instead of recording a trace event for object creation here, we wait for
   // the picture to be recorded in Picture::Record.
 }
 
 scoped_refptr<Picture> Picture::CreateFromSkpValue(const base::Value* value) {
   // Decode the picture from base64.
   std::string encoded;
   if (!value->GetAsString(&encoded))
@@ skipping 46 matching lines @@
 
   // Read the picture. This creates an empty picture on failure.
   SkPicture* skpicture = SkPicture::CreateFromStream(&stream, &DecodeBitmap);
   if (skpicture == NULL)
     return NULL;
 
   return make_scoped_refptr(new Picture(skpicture, layer_rect, opaque_rect));
 }
 
 Picture::Picture(SkPicture* picture,
-                 gfx::Rect layer_rect,
-                 gfx::Rect opaque_rect) :
+                 const gfx::Rect& layer_rect,
+                 const gfx::Rect& opaque_rect) :
     layer_rect_(layer_rect),
     opaque_rect_(opaque_rect),
     picture_(skia::AdoptRef(picture)),
     cell_size_(layer_rect.size()) {
 }
 
 Picture::Picture(const skia::RefPtr<SkPicture>& picture,
-                 gfx::Rect layer_rect,
-                 gfx::Rect opaque_rect,
+                 const gfx::Rect& layer_rect,
+                 const gfx::Rect& opaque_rect,
                  const PixelRefMap& pixel_refs) :
     layer_rect_(layer_rect),
     opaque_rect_(opaque_rect),
     picture_(picture),
     pixel_refs_(pixel_refs),
     cell_size_(layer_rect.size()) {
 }
 
 Picture::~Picture() {
   TRACE_EVENT_OBJECT_DELETED_WITH_ID(
@@ skipping 202 matching lines @@
     : picture_(NULL),
       current_pixel_refs_(empty_pixel_refs_.Pointer()),
       current_index_(0),
       min_point_(-1, -1),
       max_point_(-1, -1),
       current_x_(0),
       current_y_(0) {
 }
 
 Picture::PixelRefIterator::PixelRefIterator(
-    gfx::Rect query_rect,
+    const gfx::Rect& rect,
     const Picture* picture)
     : picture_(picture),
       current_pixel_refs_(empty_pixel_refs_.Pointer()),
       current_index_(0) {
   gfx::Rect layer_rect = picture->layer_rect_;
   gfx::Size cell_size = picture->cell_size_;
   DCHECK(!cell_size.IsEmpty());
 
+  gfx::Rect query_rect(rect);
   // Early out if the query rect doesn't intersect this picture.
   if (!query_rect.Intersects(layer_rect)) {
     min_point_ = gfx::Point(0, 0);
     max_point_ = gfx::Point(0, 0);
     current_x_ = 1;
     current_y_ = 1;
     return;
   }
 
   // First, subtract the layer origin as cells are stored in layer space.
@@ skipping 74 matching lines @@
 scoped_refptr<base::debug::ConvertableToTraceFormat>
     Picture::AsTraceableRecordData() const {
   scoped_ptr<base::DictionaryValue> record_data(new base::DictionaryValue());
   record_data->Set("picture_id", TracedValue::CreateIDRef(this).release());
   record_data->SetInteger("width", layer_rect_.width());
   record_data->SetInteger("height", layer_rect_.height());
   return TracedValue::FromValue(record_data.release());
 }
 
 }  // namespace cc