[#5] Pass gfx structs by const ref (gfx::Vector2dF)

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 654 matching lines @@
 
   return false;
 }
 
 // This function returns a translation matrix that can be applied on a vector
 // that's in the layer's target surface coordinate, while the position offset is
 // specified in some ancestor layer's coordinate.
 gfx::Transform ComputeSizeDeltaCompensation(
     LayerImpl* layer,
     LayerImpl* container,
-    gfx::Vector2dF position_offset) {
+    const gfx::Vector2dF& position_offset) {
   gfx::Transform result_transform;
 
   // To apply a translate in the container's layer space,
   // the following steps need to be done:
   //     Step 1a. transform from target surface space to the container's target
   //              surface space
   //     Step 1b. transform from container's target surface space to the
   //              container's layer space
   //     Step 2. apply the compensation
   //     Step 3. transform back to target surface space
@@ skipping 82 matching lines @@
 
   // Note: Again, this is Concat. The compensation matrix will be applied on
   //       the vector in target surface space.
   combined_transform->ConcatTransform(
       ComputeSizeDeltaCompensation(layer, container, position_offset));
 }
 
 gfx::Transform ComputeScrollCompensationForThisLayer(
     LayerImpl* scrolling_layer,
     const gfx::Transform& parent_matrix,
-    gfx::Vector2dF scroll_delta) {
+    const gfx::Vector2dF& scroll_delta) {
   // For every layer that has non-zero scroll_delta, we have to compute a
   // transform that can undo the scroll_delta translation. In particular, we
   // want this matrix to premultiply a fixed-position layer's parent_matrix, so
   // we design this transform in three steps as follows. The steps described
   // here apply from right-to-left, so Step 1 would be the right-most matrix:
   //
   //     Step 1. transform from target surface space to the exact space where
   //           scroll_delta is actually applied.
   //           -- this is inverse of parent_matrix
   //     Step 2. undo the scroll_delta
@@ skipping 19 matching lines @@
   }
   scroll_compensation_for_this_layer.PreconcatTransform(
       inverse_parent_matrix);  // Step 1
   return scroll_compensation_for_this_layer;
 }
 
 gfx::Transform ComputeScrollCompensationMatrixForChildren(
     Layer* current_layer,
     const gfx::Transform& current_parent_matrix,
     const gfx::Transform& current_scroll_compensation,
-    gfx::Vector2dF scroll_delta) {
+    const gfx::Vector2dF& scroll_delta) {
   // The main thread (i.e. Layer) does not need to worry about scroll
   // compensation.  So we can just return an identity matrix here.
   return gfx::Transform();
 }
 
 gfx::Transform ComputeScrollCompensationMatrixForChildren(
     LayerImpl* layer,
     const gfx::Transform& parent_matrix,
     const gfx::Transform& current_scroll_compensation_matrix,
-    gfx::Vector2dF scroll_delta) {
+    const gfx::Vector2dF& scroll_delta) {
   // "Total scroll compensation" is the transform needed to cancel out all
   // scroll_delta translations that occurred since the nearest container layer,
   // even if there are render_surfaces in-between.
   //
   // There are some edge cases to be aware of, that are not explicit in the
   // code:
   //  - A layer that is both a fixed-position and container should not be its
   //  own container, instead, that means it is fixed to an ancestor, and is a
   //  container for any fixed-position descendants.
   //  - A layer that is a fixed-position container and has a render_surface
@@ skipping 1578 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