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

cc/debug/overdraw_metrics.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/debug/overdraw_metrics.h"
 
 #include "base/debug/trace_event.h"
 #include "base/metrics/histogram.h"
 #include "cc/base/math_util.h"
 #include "cc/trees/layer_tree_host.h"
@@ skipping 37 matching lines @@
                                      const gfx::QuadF& quad) {
   gfx::PointF clipped_quad[8];
   int num_vertices_in_clipped_quad = 0;
   MathUtil::MapClippedQuad(transform,
                            quad,
                            clipped_quad,
                            &num_vertices_in_clipped_quad);
   return PolygonArea(clipped_quad, num_vertices_in_clipped_quad);
 }
 
-void OverdrawMetrics::DidPaint(gfx::Rect painted_rect) {
+void OverdrawMetrics::DidPaint(const gfx::Rect& painted_rect) {
   if (!record_metrics_for_frame_)
     return;
 
   pixels_painted_ +=
       static_cast<float>(painted_rect.width()) * painted_rect.height();
 }
 
 void OverdrawMetrics::DidCullTilesForUpload(int count) {
   if (record_metrics_for_frame_)
     tiles_culled_for_upload_ += count;
 }
 
 void OverdrawMetrics::DidUpload(const gfx::Transform& transform_to_target,
-                                gfx::Rect upload_rect,
-                                gfx::Rect opaque_rect) {
+                                const gfx::Rect& upload_rect,
+                                const gfx::Rect& opaque_rect) {
   if (!record_metrics_for_frame_)
     return;
 
   float upload_area =
       AreaOfMappedQuad(transform_to_target, gfx::QuadF(upload_rect));
   float upload_opaque_area =
       AreaOfMappedQuad(transform_to_target,
                        gfx::QuadF(gfx::IntersectRects(opaque_rect,
                                                       upload_rect)));
 
@@ skipping 12 matching lines @@
 void OverdrawMetrics::DidUseRenderSurfaceTextureMemoryBytes(
     size_t render_surface_use_bytes) {
   if (!record_metrics_for_frame_)
     return;
 
   render_surface_texture_use_bytes_ += render_surface_use_bytes;
 }
 
 void OverdrawMetrics::DidCullForDrawing(
     const gfx::Transform& transform_to_target,
-    gfx::Rect before_cull_rect,
-    gfx::Rect after_cull_rect) {
+    const gfx::Rect& before_cull_rect,
+    const gfx::Rect& after_cull_rect) {
   if (!record_metrics_for_frame_)
     return;
 
   float before_cull_area =
       AreaOfMappedQuad(transform_to_target, gfx::QuadF(before_cull_rect));
   float after_cull_area =
       AreaOfMappedQuad(transform_to_target, gfx::QuadF(after_cull_rect));
 
   pixels_culled_for_drawing_ += before_cull_area - after_cull_area;
 }
 
 void OverdrawMetrics::DidDraw(const gfx::Transform& transform_to_target,
-                              gfx::Rect after_cull_rect,
-                              gfx::Rect opaque_rect) {
+                              const gfx::Rect& after_cull_rect,
+                              const gfx::Rect& opaque_rect) {
   if (!record_metrics_for_frame_)
     return;
 
   float after_cull_area =
       AreaOfMappedQuad(transform_to_target, gfx::QuadF(after_cull_rect));
   float after_cull_opaque_area =
       AreaOfMappedQuad(transform_to_target,
                        gfx::QuadF(gfx::IntersectRects(opaque_rect,
                                                       after_cull_rect)));
 
@@ skipping 127 matching lines @@
                      contents_texture_use_bytes_,
                      "RenderSurfaceTextureBytes",
                      render_surface_texture_use_bytes_);
       }
       break;
     }
   }
 }
 
 }  // namespace cc