[#4] Pass gfx structs by const ref (gfx::PointF)

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 2227 matching lines @@
                                              &accumulated_surface_state);
 
   // 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::PointF& screen_space_point,
     const gfx::Transform& local_space_to_screen_space_transform,
     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.
   bool clipped = false;
   gfx::PointF hit_test_point_in_local_space = MathUtil::ProjectPoint(
       inverse_local_space_to_screen_space, screen_space_point, &clipped);
 
   // If ProjectPoint could not project to a valid value, then we assume that
   // this point doesn't hit this rect.
   if (clipped)
     return false;
 
   return local_space_rect.Contains(hit_test_point_in_local_space);
 }
 
-static bool PointHitsRegion(gfx::PointF screen_space_point,
+static bool PointHitsRegion(const gfx::PointF& screen_space_point,
                             const gfx::Transform& screen_space_transform,
                             const Region& layer_space_region,
                             float layer_content_scale_x,
                             float layer_content_scale_y) {
   // If the transform is not invertible, then assume that this point doesn't hit
   // this region.
   gfx::Transform inverse_screen_space_transform(
       gfx::Transform::kSkipInitialization);
   if (!screen_space_transform.GetInverse(&inverse_screen_space_transform))
     return false;
@@ skipping 10 matching lines @@
 
   // If ProjectPoint could not project to a valid value, then we assume that
   // this point doesn't hit this region.
   if (clipped)
     return false;
 
   return layer_space_region.Contains(
       gfx::ToRoundedPoint(hit_test_point_in_layer_space));
 }
 
-static bool PointIsClippedBySurfaceOrClipRect(gfx::PointF screen_space_point,
-                                              LayerImpl* layer) {
+static bool PointIsClippedBySurfaceOrClipRect(
+    const gfx::PointF& screen_space_point,
+    LayerImpl* layer) {
   LayerImpl* current_layer = layer;
 
   // Walk up the layer tree and hit-test any render_surfaces and any layer
   // clip rects that are active.
   while (current_layer) {
     if (current_layer->render_surface() &&
         !PointHitsRect(
             screen_space_point,
             current_layer->render_surface()->screen_space_transform(),
             current_layer->render_surface()->content_rect()))
@@ skipping 12 matching lines @@
 
     current_layer = current_layer->parent();
   }
 
   // If we have finished walking all ancestors without having already exited,
   // then the point is not clipped by any ancestors.
   return false;
 }
 
 LayerImpl* LayerTreeHostCommon::FindLayerThatIsHitByPoint(
-    gfx::PointF screen_space_point,
+    const gfx::PointF& screen_space_point,
     const LayerImplList& render_surface_layer_list) {
   LayerImpl* found_layer = NULL;
 
   typedef LayerIterator<LayerImpl,
                         LayerImplList,
                         RenderSurfaceImpl,
                         LayerIteratorActions::FrontToBack> LayerIteratorType;
   LayerIteratorType end = LayerIteratorType::End(&render_surface_layer_list);
 
   for (LayerIteratorType
@@ skipping 25 matching lines @@
     found_layer = current_layer;
     break;
   }
 
   // This can potentially return NULL, which means the screen_space_point did
   // not successfully hit test any layers, not even the root layer.
   return found_layer;
 }
 
 LayerImpl* LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
-    gfx::PointF screen_space_point,
+    const gfx::PointF& screen_space_point,
     const LayerImplList& render_surface_layer_list) {
   // First find out which layer was hit from the saved list of visible layers
   // in the most recent frame.
   LayerImpl* layer_impl = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       screen_space_point,
       render_surface_layer_list);
 
   // Walk up the hierarchy and look for a layer with a touch event handler
   // region that the given point hits.
   // This walk may not be necessary anymore: http://crbug.com/310817
   for (; layer_impl; layer_impl = layer_impl->parent()) {
     if (LayerTreeHostCommon::LayerHasTouchEventHandlersAt(screen_space_point,
                                                           layer_impl))
       break;
   }
   return layer_impl;
 }
 
 bool LayerTreeHostCommon::LayerHasTouchEventHandlersAt(
-    gfx::PointF screen_space_point,
+    const gfx::PointF& screen_space_point,
     LayerImpl* layer_impl) {
   if (layer_impl->touch_event_handler_region().IsEmpty())
     return false;
 
   if (!PointHitsRegion(screen_space_point,
                        layer_impl->screen_space_transform(),
                        layer_impl->touch_event_handler_region(),
                        layer_impl->contents_scale_x(),
                        layer_impl->contents_scale_y()))
     return false;
 
   // 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