cc: Don't pass simple well-defined classes by reference.

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 349 matching lines @@
 static LayerImpl* NextTargetSurface(LayerImpl* layer) {
   return layer->parent() ? layer->parent()->render_target() : 0;
 }
 
 // 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,
-    const gfx::Vector2dF& position_offset) {
+    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 24 matching lines @@
       // Note: Again, Concat is used to conver the result coordinate space from
       //       the container render surface to the container layer.
       target_surface_space_to_container_layer_space.ConcatTransform(
           container_target_surface_space_to_container_layer_space);
     }
   }
 
   // Apply step 3
   gfx::Transform container_layer_space_to_target_surface_space;
   if (target_surface_space_to_container_layer_space.GetInverse(
-      &container_layer_space_to_target_surface_space))
+          &container_layer_space_to_target_surface_space)) {
     result_transform.PreconcatTransform(
         container_layer_space_to_target_surface_space);
-  else {
+  } else {
     // FIXME: A non-invertible matrix could still make meaningful projection.
     // For example ScaleZ(0) is non-invertible but the layer is still visible.
     return gfx::Transform();
   }
 
   // Apply step 2
   result_transform.Translate(position_offset.x(), position_offset.y());
 
   // Apply step 1
   result_transform.PreconcatTransform(
       target_surface_space_to_container_layer_space);
 
   return result_transform;
 }
 
 void ApplyPositionAdjustment(
     Layer* layer,
     Layer* container,
     const gfx::Transform& scroll_compensation,
-    gfx::Transform* combined_transform) { }
+    gfx::Transform* combined_transform) {}
 void ApplyPositionAdjustment(
     LayerImpl* layer,
     LayerImpl* container,
     const gfx::Transform& scroll_compensation,
-    gfx::Transform* combined_transform)
-{
+    gfx::Transform* combined_transform) {
   if (!layer->position_constraint().is_fixed_position())
     return;
 
   // Special case: this layer is a composited fixed-position layer; we need to
   // explicitly compensate for all ancestors' nonzero scroll_deltas to keep
   // this layer fixed correctly.
   // Note carefully: this is Concat, not Preconcat
   // (current_scroll_compensation * combined_transform).
   combined_transform->ConcatTransform(scroll_compensation);
 
@@ skipping 1260 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