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

cc/output/delegating_renderer.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/output/delegating_renderer.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 78 matching lines @@
 static ResourceProvider::ResourceId AppendToArray(
     ResourceProvider::ResourceIdArray* array,
     ResourceProvider::ResourceId id) {
   array->push_back(id);
   return id;
 }
 
 void DelegatingRenderer::DrawFrame(RenderPassList* render_passes_in_draw_order,
                                    ContextProvider* offscreen_context_provider,
                                    float device_scale_factor,
-                                   gfx::Rect device_viewport_rect,
-                                   gfx::Rect device_clip_rect,
+                                   const gfx::Rect& device_viewport_rect,
+                                   const gfx::Rect& device_clip_rect,
                                    bool allow_partial_swap,
                                    bool disable_picture_quad_image_filtering) {
   TRACE_EVENT0("cc", "DelegatingRenderer::DrawFrame");
 
   DCHECK(!delegated_frame_data_);
 
   delegated_frame_data_ = make_scoped_ptr(new DelegatedFrameData);
   DelegatedFrameData& out_data = *delegated_frame_data_;
   // Move the render passes and resources into the |out_frame|.
   out_data.render_pass_list.swap(*render_passes_in_draw_order);
@@ skipping 11 matching lines @@
 }
 
 void DelegatingRenderer::SwapBuffers(const CompositorFrameMetadata& metadata) {
   TRACE_EVENT0("cc", "DelegatingRenderer::SwapBuffers");
   CompositorFrame compositor_frame;
   compositor_frame.metadata = metadata;
   compositor_frame.delegated_frame_data = delegated_frame_data_.Pass();
   output_surface_->SwapBuffers(&compositor_frame);
 }
 
-void DelegatingRenderer::GetFramebufferPixels(void* pixels, gfx::Rect rect) {
+void DelegatingRenderer::GetFramebufferPixels(void* pixels,
+                                              const gfx::Rect& rect) {
   NOTREACHED();
 }
 
 void DelegatingRenderer::ReceiveSwapBuffersAck(
     const CompositorFrameAck& ack) {
   resource_provider_->ReceiveReturnsFromParent(ack.resources);
 }
 
 bool DelegatingRenderer::IsContextLost() {
   ContextProvider* context_provider = output_surface_->context_provider();
@@ skipping 33 matching lines @@
   gpu::ManagedMemoryStats stats;
   stats.bytes_required = bytes_visible;
   stats.bytes_nice_to_have = bytes_visible_and_nearby;
   stats.bytes_allocated = bytes_allocated;
   stats.backbuffer_requested = false;
 
   context_provider->ContextSupport()->SendManagedMemoryStats(stats);
 }
 
 }  // namespace cc