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

cc/trees/layer_tree_host_impl.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_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 1963 matching lines @@
   input_handler_client_ = client;
 }
 
 static LayerImpl* NextScrollLayer(LayerImpl* layer) {
   if (LayerImpl* scroll_parent = layer->scroll_parent())
     return scroll_parent;
   return layer->parent();
 }
 
 LayerImpl* LayerTreeHostImpl::FindScrollLayerForDeviceViewportPoint(
-    gfx::PointF device_viewport_point, InputHandler::ScrollInputType type,
+    const gfx::PointF& device_viewport_point,
+    InputHandler::ScrollInputType type,
     LayerImpl* layer_impl, bool* scroll_on_main_thread) const {
   DCHECK(scroll_on_main_thread);
 
   // Walk up the hierarchy and look for a scrollable layer.
   LayerImpl* potentially_scrolling_layer_impl = 0;
   for (; layer_impl; layer_impl = NextScrollLayer(layer_impl)) {
     // The content layer can also block attempts to scroll outside the main
     // thread.
     ScrollStatus status = layer_impl->TryScroll(device_viewport_point, type);
     if (status == ScrollOnMainThread) {
@@ skipping 58 matching lines @@
     client_->RenewTreePriority();
     UMA_HISTOGRAM_BOOLEAN("TryScroll.SlowScroll", false);
     return ScrollStarted;
   }
   return ScrollIgnored;
 }
 
 gfx::Vector2dF LayerTreeHostImpl::ScrollLayerWithViewportSpaceDelta(
     LayerImpl* layer_impl,
     float scale_from_viewport_to_screen_space,
-    gfx::PointF viewport_point,
+    const gfx::PointF& viewport_point,
     gfx::Vector2dF viewport_delta) {
   // Layers with non-invertible screen space transforms should not have passed
   // the scroll hit test in the first place.
   DCHECK(layer_impl->screen_space_transform().IsInvertible());
   gfx::Transform inverse_screen_space_transform(
       gfx::Transform::kSkipInitialization);
   bool did_invert = layer_impl->screen_space_transform().GetInverse(
       &inverse_screen_space_transform);
   // TODO(shawnsingh): With the advent of impl-side crolling for non-root
   // layers, we may need to explicitly handle uninvertible transforms here.
@@ skipping 266 matching lines @@
   }
 
   return ScrollStarted;
 }
 
 void LayerTreeHostImpl::NotifyCurrentFlingVelocity(gfx::Vector2dF velocity) {
   current_fling_velocity_ = velocity;
 }
 
 float LayerTreeHostImpl::DeviceSpaceDistanceToLayer(
-    gfx::PointF device_viewport_point,
+    const gfx::PointF& device_viewport_point,
     LayerImpl* layer_impl) {
   if (!layer_impl)
     return std::numeric_limits<float>::max();
 
   gfx::Rect layer_impl_bounds(
       layer_impl->content_bounds());
 
   gfx::RectF device_viewport_layer_impl_bounds = MathUtil::MapClippedRect(
       layer_impl->screen_space_transform(),
       layer_impl_bounds);
@@ skipping 47 matching lines @@
       DeviceSpaceDistanceToLayer(device_viewport_point,
           scroll_layer_impl->vertical_scrollbar_layer()));
 
   bool should_animate = animation_controller->DidMouseMoveNear(
       CurrentPhysicalTimeTicks(), distance_to_scrollbar / device_scale_factor_);
   if (should_animate)
     StartScrollbarAnimation();
 }
 
 bool LayerTreeHostImpl::HandleMouseOverScrollbar(LayerImpl* layer_impl,
-    gfx::PointF device_viewport_point) {
+    const gfx::PointF& device_viewport_point) {
   if (layer_impl && layer_impl->ToScrollbarLayer()) {
     int scroll_layer_id = layer_impl->ToScrollbarLayer()->ScrollLayerId();
     layer_impl = active_tree_->LayerById(scroll_layer_id);
     if (layer_impl && layer_impl->scrollbar_animation_controller()) {
       scroll_layer_id_when_mouse_over_scrollbar_ = scroll_layer_id;
       bool should_animate =
           layer_impl->scrollbar_animation_controller()->DidMouseMoveNear(
               CurrentPhysicalTimeTicks(), 0);
       if (should_animate)
         StartScrollbarAnimation();
@@ skipping 479 matching lines @@
   swap_promise_monitor_.erase(monitor);
 }
 
 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfSetNeedsRedraw() {
   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnSetNeedsRedrawOnImpl();
 }
 
 }  // namespace cc