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

cc/output/gl_renderer.cc

 // Copyright 2010 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/gl_renderer.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 2046 matching lines @@
   QuadRectTransform(&quad_rect_matrix, draw_transform, quad_rect);
   static float gl_matrix[16];
   ToGLMatrix(&gl_matrix[0], frame->projection_matrix * quad_rect_matrix);
   GLC(gl_, gl_->UniformMatrix4fv(matrix_location, 1, false, &gl_matrix[0]));
 
   GLC(gl_, gl_->DrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, 0));
 }
 
 void GLRenderer::CopyTextureToFramebuffer(const DrawingFrame* frame,
                                           int texture_id,
-                                          gfx::Rect rect,
+                                          const gfx::Rect& rect,
                                           const gfx::Transform& draw_matrix,
                                           bool flip_vertically) {
   TexCoordPrecision tex_coord_precision = TexCoordPrecisionRequired(
       gl_, &highp_threshold_cache_, highp_threshold_min_, rect.bottom_right());
 
   const RenderPassProgram* program = GetRenderPassProgram(tex_coord_precision);
   SetUseProgram(program->program());
 
   GLC(gl_, gl_->Uniform1i(program->fragment_shader().sampler_location(), 0));
 
@@ skipping 89 matching lines @@
 }
 
 void GLRenderer::EnsureBackbuffer() {
   if (!is_backbuffer_discarded_)
     return;
 
   output_surface_->EnsureBackbuffer();
   is_backbuffer_discarded_ = false;
 }
 
-void GLRenderer::GetFramebufferPixels(void* pixels, gfx::Rect rect) {
+void GLRenderer::GetFramebufferPixels(void* pixels, const gfx::Rect& rect) {
   if (!pixels || rect.IsEmpty())
     return;
 
   // This function assumes that it is reading the root frame buffer.
   DCHECK(!current_framebuffer_lock_);
 
   scoped_ptr<PendingAsyncReadPixels> pending_read(new PendingAsyncReadPixels);
   pending_async_read_pixels_.insert(pending_async_read_pixels_.begin(),
                                     pending_read.Pass());
 
   // This is a syncronous call since the callback is null.
   gfx::Rect window_rect = MoveFromDrawToWindowSpace(rect);
   DoGetFramebufferPixels(static_cast<uint8*>(pixels),
                          window_rect,
                          AsyncGetFramebufferPixelsCleanupCallback());
 }
 
 void GLRenderer::GetFramebufferPixelsAsync(
-    gfx::Rect rect,
+    const gfx::Rect& rect,
     scoped_ptr<CopyOutputRequest> request) {
   DCHECK(!request->IsEmpty());
   if (request->IsEmpty())
     return;
   if (rect.IsEmpty())
     return;
 
   gfx::Rect window_rect = MoveFromDrawToWindowSpace(rect);
 
   if (!request->force_bitmap_result()) {
@@ skipping 77 matching lines @@
   pending_read->copy_request = request.Pass();
   pending_async_read_pixels_.insert(pending_async_read_pixels_.begin(),
                                     pending_read.Pass());
 
   // This is an asyncronous call since the callback is not null.
   DoGetFramebufferPixels(pixels, window_rect, cleanup_callback);
 }
 
 void GLRenderer::DoGetFramebufferPixels(
     uint8* dest_pixels,
-    gfx::Rect window_rect,
+    const gfx::Rect& window_rect,
     const AsyncGetFramebufferPixelsCleanupCallback& cleanup_callback) {
   DCHECK_GE(window_rect.x(), 0);
   DCHECK_GE(window_rect.y(), 0);
   DCHECK_LE(window_rect.right(), current_surface_size_.width());
   DCHECK_LE(window_rect.bottom(), current_surface_size_.height());
 
   bool is_async = !cleanup_callback.is_null();
 
   bool do_workaround = NeedsIOSurfaceReadbackWorkaround();
 
@@ skipping 162 matching lines @@
                                 bool success) {
   DCHECK(request->force_bitmap_result());
 
   lock.reset();
   if (success)
     request->SendBitmapResult(bitmap.Pass());
 }
 
 void GLRenderer::GetFramebufferTexture(unsigned texture_id,
                                        ResourceFormat texture_format,
-                                       gfx::Rect window_rect) {
+                                       const gfx::Rect& window_rect) {
   DCHECK(texture_id);
   DCHECK_GE(window_rect.x(), 0);
   DCHECK_GE(window_rect.y(), 0);
   DCHECK_LE(window_rect.right(), current_surface_size_.width());
   DCHECK_LE(window_rect.bottom(), current_surface_size_.height());
 
   GLC(gl_, gl_->BindTexture(GL_TEXTURE_2D, texture_id));
   GLC(gl_,
       gl_->CopyTexImage2D(GL_TEXTURE_2D,
                           0,
                           GLDataFormat(texture_format),
                           window_rect.x(),
                           window_rect.y(),
                           window_rect.width(),
                           window_rect.height(),
                           0));
   GLC(gl_, gl_->BindTexture(GL_TEXTURE_2D, 0));
 }
 
 bool GLRenderer::UseScopedTexture(DrawingFrame* frame,
                                   const ScopedResource* texture,
-                                  gfx::Rect viewport_rect) {
+                                  const gfx::Rect& viewport_rect) {
   DCHECK(texture->id());
   frame->current_render_pass = NULL;
   frame->current_texture = texture;
 
   return BindFramebufferToTexture(frame, texture, viewport_rect);
 }
 
 void GLRenderer::BindFramebufferToOutputSurface(DrawingFrame* frame) {
   current_framebuffer_lock_.reset();
   output_surface_->BindFramebuffer();
 
   if (output_surface_->HasExternalStencilTest()) {
     SetStencilEnabled(true);
     GLC(gl_, gl_->StencilFunc(GL_EQUAL, 1, 1));
   } else {
     SetStencilEnabled(false);
   }
 }
 
 bool GLRenderer::BindFramebufferToTexture(DrawingFrame* frame,
                                           const ScopedResource* texture,
-                                          gfx::Rect target_rect) {
+                                          const gfx::Rect& target_rect) {
   DCHECK(texture->id());
 
   current_framebuffer_lock_.reset();
 
   SetStencilEnabled(false);
   GLC(gl_, gl_->BindFramebuffer(GL_FRAMEBUFFER, offscreen_framebuffer_id_));
   current_framebuffer_lock_ =
       make_scoped_ptr(new ResourceProvider::ScopedWriteLockGL(
           resource_provider_, texture->id()));
   unsigned texture_id = current_framebuffer_lock_->texture_id();
   GLC(gl_,
       gl_->FramebufferTexture2D(
           GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture_id, 0));
 
   DCHECK(gl_->CheckFramebufferStatus(GL_FRAMEBUFFER) ==
              GL_FRAMEBUFFER_COMPLETE ||
          IsContextLost());
 
   InitializeViewport(
       frame, target_rect, gfx::Rect(target_rect.size()), target_rect.size());
   return true;
 }
 
-void GLRenderer::SetScissorTestRect(gfx::Rect scissor_rect) {
+void GLRenderer::SetScissorTestRect(const gfx::Rect& scissor_rect) {
   EnsureScissorTestEnabled();
 
   // Don't unnecessarily ask the context to change the scissor, because it
   // may cause undesired GPU pipeline flushes.
   if (scissor_rect == scissor_rect_ && !scissor_rect_needs_reset_)
     return;
 
   scissor_rect_ = scissor_rect;
   FlushTextureQuadCache();
   GLC(gl_,
       gl_->Scissor(scissor_rect.x(),
                    scissor_rect.y(),
                    scissor_rect.width(),
                    scissor_rect.height()));
 
   scissor_rect_needs_reset_ = false;
 }
 
-void GLRenderer::SetDrawViewport(gfx::Rect window_space_viewport) {
+void GLRenderer::SetDrawViewport(const gfx::Rect& window_space_viewport) {
   viewport_ = window_space_viewport;
   GLC(gl_,
       gl_->Viewport(window_space_viewport.x(),
                     window_space_viewport.y(),
                     window_space_viewport.width(),
                     window_space_viewport.height()));
 }
 
 void GLRenderer::InitializeSharedObjects() {
   TRACE_EVENT0("cc", "GLRenderer::InitializeSharedObjects");
@@ skipping 433 matching lines @@
   is_scissor_enabled_ = false;
   GLC(gl_, gl_->Disable(GL_SCISSOR_TEST));
   scissor_rect_needs_reset_ = true;
 }
 
 bool GLRenderer::IsContextLost() {
   return output_surface_->context_provider()->IsContextLost();
 }
 
 }  // namespace cc