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

cc/trees/layer_tree_host_common.cc

 // Copyright 2011 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/trees/layer_tree_host_common.h"
 
 #include <algorithm>
 
 #include "base/debug/trace_event.h"
 #include "cc/base/math_util.h"
@@ skipping 46 matching lines @@
   gfx::Vector2dF offset = layer->TotalScrollOffset();
   // The scroll parent's total scroll offset (scroll offset + scroll delta)
   // can't be used because its scroll offset has already been applied to the
   // scroll children's positions by the main thread layer positioning code.
   if (layer->scroll_parent())
     offset += layer->scroll_parent()->ScrollDelta();
   return offset;
 }
 
 inline gfx::Rect CalculateVisibleRectWithCachedLayerRect(
-    gfx::Rect target_surface_rect,
-    gfx::Rect layer_bound_rect,
-    gfx::Rect layer_rect_in_target_space,
+    const gfx::Rect& target_surface_rect,
+    const gfx::Rect& layer_bound_rect,
+    const gfx::Rect& layer_rect_in_target_space,
     const gfx::Transform& transform) {
   if (layer_rect_in_target_space.IsEmpty())
     return gfx::Rect();
 
   // Is this layer fully contained within the target surface?
   if (target_surface_rect.Contains(layer_rect_in_target_space))
     return layer_bound_rect;
 
   // If the layer doesn't fill up the entire surface, then find the part of
   // the surface rect where the layer could be visible. This avoids trying to
@@ skipping 17 matching lines @@
     return layer_bound_rect;
   }
 
   gfx::Rect layer_rect = gfx::ToEnclosingRect(MathUtil::ProjectClippedRect(
       surface_to_layer, gfx::RectF(minimal_surface_rect)));
   layer_rect.Intersect(layer_bound_rect);
   return layer_rect;
 }
 
 gfx::Rect LayerTreeHostCommon::CalculateVisibleRect(
-    gfx::Rect target_surface_rect,
-    gfx::Rect layer_bound_rect,
+    const gfx::Rect& target_surface_rect,
+    const gfx::Rect& layer_bound_rect,
     const gfx::Transform& transform) {
   gfx::Rect layer_in_surface_space =
       MathUtil::MapClippedRect(transform, layer_bound_rect);
   return CalculateVisibleRectWithCachedLayerRect(
       target_surface_rect, layer_bound_rect, layer_in_surface_space, transform);
 }
 
 template <typename LayerType>
 static LayerType* NextTargetSurface(LayerType* layer) {
   return layer->parent() ? layer->parent()->render_target() : 0;
@@ skipping 28 matching lines @@
 }
 
 enum TranslateRectDirection {
   TranslateRectDirectionToAncestor,
   TranslateRectDirectionToDescendant
 };
 
 template <typename LayerType>
 static gfx::Rect TranslateRectToTargetSpace(const LayerType& ancestor_layer,
                                             const LayerType& descendant_layer,
-                                            gfx::Rect rect,
+                                            const gfx::Rect& rect,
                                             TranslateRectDirection direction) {
   gfx::Vector2dF translation = ComputeChangeOfBasisTranslation<LayerType>(
       ancestor_layer, descendant_layer);
   if (direction == TranslateRectDirectionToDescendant)
     translation.Scale(-1.f);
   return gfx::ToEnclosingRect(
       gfx::RectF(rect.origin() + translation, rect.size()));
 }
 
 // Attempts to update the clip rects for the given layer. If the layer has a
@@ skipping 65 matching lines @@
   // The target owning the surface. (We hang onto the target rather than the
   // surface so that we can DCHECK that the surface's draw transform is simply
   // a translation when |render_target| reports that it has no unclipped
   // descendants).
   LayerType* render_target;
 };
 
 template <typename LayerType>
 void UpdateAccumulatedSurfaceState(
     LayerType* layer,
-    gfx::Rect drawable_content_rect,
+    const gfx::Rect& drawable_content_rect,
     std::vector<AccumulatedSurfaceState<LayerType> >*
         accumulated_surface_state) {
   if (IsRootLayer(layer))
     return;
 
   // We will apply our drawable content rect to the accumulated rects for all
   // surfaces between us and |render_target| (inclusive). This is either our
   // clip parent's target if we are a clip child, or else simply our parent's
   // target. We use our parent's target because we're either the owner of a
   // render surface and we'll want to add our rect to our *surface's* target, or
@@ skipping 122 matching lines @@
 }
 
 template <typename LayerType>
 static inline bool LayerClipsSubtree(LayerType* layer) {
   return layer->masks_to_bounds() || layer->mask_layer();
 }
 
 template <typename LayerType>
 static gfx::Rect CalculateVisibleContentRect(
     LayerType* layer,
-    gfx::Rect clip_rect_of_target_surface_in_target_space,
-    gfx::Rect layer_rect_in_target_space) {
+    const gfx::Rect& clip_rect_of_target_surface_in_target_space,
+    const gfx::Rect& layer_rect_in_target_space) {
   DCHECK(layer->render_target());
 
   // Nothing is visible if the layer bounds are empty.
   if (!layer->DrawsContent() || layer->content_bounds().IsEmpty() ||
       layer->drawable_content_rect().IsEmpty())
     return gfx::Rect();
 
   // Compute visible bounds in target surface space.
   gfx::Rect visible_rect_in_target_surface_space =
       layer->drawable_content_rect();
@@ skipping 1842 matching lines @@
   // The dummy layer list should not have been used.
   DCHECK_EQ(0u, dummy_layer_list.size());
   // A root layer render_surface should always exist after
   // CalculateDrawProperties.
   DCHECK(inputs->root_layer->render_surface());
 }
 
 static bool PointHitsRect(
     gfx::PointF screen_space_point,
     const gfx::Transform& local_space_to_screen_space_transform,
-    gfx::RectF local_space_rect) {
+    const gfx::RectF& local_space_rect) {
   // If the transform is not invertible, then assume that this point doesn't hit
   // this rect.
   gfx::Transform inverse_local_space_to_screen_space(
       gfx::Transform::kSkipInitialization);
   if (!local_space_to_screen_space_transform.GetInverse(
           &inverse_local_space_to_screen_space))
     return false;
 
   // Transform the hit test point from screen space to the local space of the
   // given rect.
@@ skipping 155 matching lines @@
   // At this point, we think the point does hit the touch event handler region
   // on the layer, but we need to walk up the parents to ensure that the layer
   // was not clipped in such a way that the hit point actually should not hit
   // the layer.
   if (PointIsClippedBySurfaceOrClipRect(screen_space_point, layer_impl))
     return false;
 
   return true;
 }
 }  // namespace cc