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

cc/trees/occlusion_tracker_unittest.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/trees/occlusion_tracker.h"
 
 #include "cc/animation/layer_animation_controller.h"
 #include "cc/base/math_util.h"
 #include "cc/debug/overdraw_metrics.h"
 #include "cc/layers/layer.h"
@@ skipping 182 matching lines @@
     Types::DestroyLayer(&root_);
     render_surface_layer_list_.reset();
     render_surface_layer_list_impl_.clear();
     replica_layers_.clear();
     mask_layers_.clear();
   }
 
   typename Types::HostType* GetHost();
 
   typename Types::ContentLayerType* CreateRoot(const gfx::Transform& transform,
-                                               gfx::PointF position,
+                                               const gfx::PointF& position,
                                                gfx::Size bounds) {
     typename Types::ContentLayerPtrType layer(
         Types::CreateContentLayer(GetHost()));
     typename Types::ContentLayerType* layer_ptr = layer.get();
     SetProperties(layer_ptr, transform, position, bounds);
 
     DCHECK(!root_.get());
     root_ = Types::PassLayerPtr(&layer);
 
     SetRootLayerOnMainThread(layer_ptr);
 
     return layer_ptr;
   }
 
   typename Types::LayerType* CreateLayer(typename Types::LayerType* parent,
                                          const gfx::Transform& transform,
-                                         gfx::PointF position,
+                                         const gfx::PointF& position,
                                          gfx::Size bounds) {
     typename Types::LayerPtrType layer(Types::CreateLayer(GetHost()));
     typename Types::LayerType* layer_ptr = layer.get();
     SetProperties(layer_ptr, transform, position, bounds);
     parent->AddChild(Types::PassLayerPtr(&layer));
     return layer_ptr;
   }
 
   typename Types::LayerType* CreateSurface(typename Types::LayerType* parent,
                                            const gfx::Transform& transform,
-                                           gfx::PointF position,
+                                           const gfx::PointF& position,
                                            gfx::Size bounds) {
     typename Types::LayerType* layer =
         CreateLayer(parent, transform, position, bounds);
     layer->SetForceRenderSurface(true);
     return layer;
   }
 
   typename Types::ContentLayerType* CreateDrawingLayer(
       typename Types::LayerType* parent,
       const gfx::Transform& transform,
-      gfx::PointF position,
+      const gfx::PointF& position,
       gfx::Size bounds,
       bool opaque) {
     typename Types::ContentLayerPtrType layer(
         Types::CreateContentLayer(GetHost()));
     typename Types::ContentLayerType* layer_ptr = layer.get();
     SetProperties(layer_ptr, transform, position, bounds);
 
     if (opaque_layers_) {
       layer_ptr->SetContentsOpaque(opaque);
     } else {
       layer_ptr->SetContentsOpaque(false);
       if (opaque)
         layer_ptr->SetOpaqueContentsRect(gfx::Rect(bounds));
       else
         layer_ptr->SetOpaqueContentsRect(gfx::Rect());
     }
 
     parent->AddChild(Types::PassLayerPtr(&layer));
     return layer_ptr;
   }
 
   typename Types::LayerType* CreateReplicaLayer(
       typename Types::LayerType* owning_layer,
       const gfx::Transform& transform,
-      gfx::PointF position,
+      const gfx::PointF& position,
       gfx::Size bounds) {
     typename Types::ContentLayerPtrType layer(
         Types::CreateContentLayer(GetHost()));
     typename Types::ContentLayerType* layer_ptr = layer.get();
     SetProperties(layer_ptr, transform, position, bounds);
     SetReplica(owning_layer, Types::PassLayerPtr(&layer));
     return layer_ptr;
   }
 
   typename Types::LayerType* CreateMaskLayer(
       typename Types::LayerType* owning_layer,
       gfx::Size bounds) {
     typename Types::ContentLayerPtrType layer(
         Types::CreateContentLayer(GetHost()));
     typename Types::ContentLayerType* layer_ptr = layer.get();
     SetProperties(layer_ptr, identity_matrix, gfx::PointF(), bounds);
     SetMask(owning_layer, Types::PassLayerPtr(&layer));
     return layer_ptr;
   }
 
   typename Types::ContentLayerType* CreateDrawingSurface(
       typename Types::LayerType* parent,
       const gfx::Transform& transform,
-      gfx::PointF position,
+      const gfx::PointF& position,
       gfx::Size bounds,
       bool opaque) {
     typename Types::ContentLayerType* layer =
         CreateDrawingLayer(parent, transform, position, bounds, opaque);
     layer->SetForceRenderSurface(true);
     return layer;
   }
 
 
   void CopyOutputCallback(scoped_ptr<CopyOutputResult> result) {}
@@ skipping 104 matching lines @@
 
  private:
   void SetRootLayerOnMainThread(Layer* root) {
     host_->SetRootLayer(scoped_refptr<Layer>(root));
   }
 
   void SetRootLayerOnMainThread(LayerImpl* root) {}
 
   void SetBaseProperties(typename Types::LayerType* layer,
                          const gfx::Transform& transform,
-                         gfx::PointF position,
+                         const gfx::PointF& position,
                          gfx::Size bounds) {
     layer->SetTransform(transform);
     layer->SetSublayerTransform(gfx::Transform());
     layer->SetAnchorPoint(gfx::PointF());
     layer->SetPosition(position);
     layer->SetBounds(bounds);
   }
 
   void SetProperties(Layer* layer,
                      const gfx::Transform& transform,
-                     gfx::PointF position,
+                     const gfx::PointF& position,
                      gfx::Size bounds) {
     SetBaseProperties(layer, transform, position, bounds);
   }
 
   void SetProperties(LayerImpl* layer,
                      const gfx::Transform& transform,
-                     gfx::PointF position,
+                     const gfx::PointF& position,
                      gfx::Size bounds) {
     SetBaseProperties(layer, transform, position, bounds);
 
     layer->SetContentBounds(layer->bounds());
   }
 
   void SetReplica(Layer* owning_layer, scoped_refptr<Layer> layer) {
     owning_layer->SetReplicaLayer(layer.get());
     replica_layers_.push_back(layer);
   }
@@ skipping 3368 matching lines @@
               occlusion.occlusion_from_outside_target().ToString());
     EXPECT_EQ(gfx::Rect().ToString(),
               occlusion.occlusion_from_inside_target().ToString());
   }
 };
 
 ALL_OCCLUSIONTRACKER_TEST(OcclusionTrackerTestEmptyEventLayerDoesNotOcclude)
 
 }  // namespace
 }  // namespace cc