[#8] Pass gfx::Point by const ref.

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 458 matching lines @@
 
   SetNeedsRedraw();
   client_->SetNeedsCommitOnImplThread();
   client_->RenewTreePriority();
 }
 
 void LayerTreeHostImpl::ScheduleAnimation() {
   SetNeedsRedraw();
 }
 
-bool LayerTreeHostImpl::HaveTouchEventHandlersAt(gfx::Point viewport_point) {
+bool LayerTreeHostImpl::HaveTouchEventHandlersAt(
+    const gfx::Point& viewport_point) {
   if (!settings_.touch_hit_testing)
     return true;
   if (!EnsureRenderSurfaceLayerList())
     return false;
 
   gfx::PointF device_viewport_point =
       gfx::ScalePoint(viewport_point, device_scale_factor_);
 
   LayerImpl* layer_impl =
       LayerTreeHostCommon::FindLayerThatIsHitByPointInTouchHandlerRegion(
@@ skipping 1572 matching lines @@
     }
 
     if (status == ScrollStarted && !potentially_scrolling_layer_impl)
       potentially_scrolling_layer_impl = scroll_layer_impl;
   }
 
   return potentially_scrolling_layer_impl;
 }
 
 InputHandler::ScrollStatus LayerTreeHostImpl::ScrollBegin(
-    gfx::Point viewport_point, InputHandler::ScrollInputType type) {
+    const gfx::Point& viewport_point,
+    InputHandler::ScrollInputType type) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBegin");
 
   if (top_controls_manager_)
     top_controls_manager_->ScrollBegin();
 
   DCHECK(!CurrentlyScrollingLayer());
   ClearCurrentlyScrollingLayer();
 
   if (!EnsureRenderSurfaceLayerList())
     return ScrollIgnored;
@@ skipping 107 matching lines @@
   return actual_viewport_end_point - viewport_point;
 }
 
 static gfx::Vector2dF ScrollLayerWithLocalDelta(LayerImpl* layer_impl,
     const gfx::Vector2dF& local_delta) {
   gfx::Vector2dF previous_delta(layer_impl->ScrollDelta());
   layer_impl->ScrollBy(local_delta);
   return layer_impl->ScrollDelta() - previous_delta;
 }
 
-bool LayerTreeHostImpl::ScrollBy(gfx::Point viewport_point,
+bool LayerTreeHostImpl::ScrollBy(const gfx::Point& viewport_point,
                                  const gfx::Vector2dF& scroll_delta) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::ScrollBy");
   if (!CurrentlyScrollingLayer())
     return false;
 
   gfx::Vector2dF pending_delta = scroll_delta;
   gfx::Vector2dF unused_root_delta;
   bool did_scroll_x = false;
   bool did_scroll_y = false;
   // TODO(wjmaclean) Should we guard against CurrentlyScrollingLayer() == 0
@@ skipping 108 matching lines @@
     params.current_fling_velocity = current_fling_velocity_;
     input_handler_client_->DidOverscroll(params);
   }
 
   return did_scroll;
 }
 
 // This implements scrolling by page as described here:
 // http://msdn.microsoft.com/en-us/library/windows/desktop/ms645601(v=vs.85).aspx#_win32_The_Mouse_Wheel
 // for events with WHEEL_PAGESCROLL set.
-bool LayerTreeHostImpl::ScrollVerticallyByPage(gfx::Point viewport_point,
+bool LayerTreeHostImpl::ScrollVerticallyByPage(const gfx::Point& viewport_point,
                                                ScrollDirection direction) {
   DCHECK(wheel_scrolling_);
 
   for (LayerImpl* layer_impl = CurrentlyScrollingLayer();
        layer_impl;
        layer_impl = layer_impl->parent()) {
     if (!layer_impl->scrollable())
       continue;
 
     if (!layer_impl->HasScrollbar(VERTICAL))
@@ skipping 86 matching lines @@
       layer_impl->content_bounds());
 
   gfx::RectF device_viewport_layer_impl_bounds = MathUtil::MapClippedRect(
       layer_impl->screen_space_transform(),
       layer_impl_bounds);
 
   return device_viewport_layer_impl_bounds.ManhattanDistanceToPoint(
       device_viewport_point);
 }
 
-void LayerTreeHostImpl::MouseMoveAt(gfx::Point viewport_point) {
+void LayerTreeHostImpl::MouseMoveAt(const gfx::Point& viewport_point) {
   if (!EnsureRenderSurfaceLayerList())
     return;
 
   gfx::PointF device_viewport_point = gfx::ScalePoint(viewport_point,
                                                       device_scale_factor_);
 
   LayerImpl* layer_impl = LayerTreeHostCommon::FindLayerThatIsHitByPoint(
       device_viewport_point,
       active_tree_->RenderSurfaceLayerList());
   if (HandleMouseOverScrollbar(layer_impl, device_viewport_point))
@@ skipping 77 matching lines @@
         active_tree_->OuterViewportScrollLayer());
   } else {
     active_tree_->SetCurrentlyScrollingLayer(
         active_tree_->InnerViewportScrollLayer());
   }
   if (top_controls_manager_)
     top_controls_manager_->PinchBegin();
 }
 
 void LayerTreeHostImpl::PinchGestureUpdate(float magnify_delta,
-                                           gfx::Point anchor) {
+                                           const gfx::Point& anchor) {
   if (!InnerViewportScrollLayer())
     return;
 
   TRACE_EVENT0("cc", "LayerTreeHostImpl::PinchGestureUpdate");
 
   // Keep the center-of-pinch anchor specified by (x, y) in a stable
   // position over the course of the magnify.
   float page_scale_delta = active_tree_->page_scale_delta();
   gfx::PointF previous_scale_anchor =
       gfx::ScalePoint(anchor, 1.f / page_scale_delta);
@@ skipping 478 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