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

cc/input/page_scale_animation.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/input/page_scale_animation.h"
 
 #include <math.h>
 
 #include "base/logging.h"
 #include "cc/animation/timing_function.h"
 #include "ui/gfx/point_f.h"
 #include "ui/gfx/rect_f.h"
 #include "ui/gfx/vector2d_conversions.h"
 
 namespace {
 
 // This takes a viewport-relative vector and returns a vector whose values are
 // between 0 and 1, representing the percentage position within the viewport.
-gfx::Vector2dF NormalizeFromViewport(gfx::Vector2dF denormalized,
+gfx::Vector2dF NormalizeFromViewport(const gfx::Vector2dF& denormalized,
                                      const gfx::SizeF& viewport_size) {
   return gfx::ScaleVector2d(denormalized,
                             1.f / viewport_size.width(),
                             1.f / viewport_size.height());
 }
 
-gfx::Vector2dF DenormalizeToViewport(gfx::Vector2dF normalized,
+gfx::Vector2dF DenormalizeToViewport(const gfx::Vector2dF& normalized,
                                      const gfx::SizeF& viewport_size) {
   return gfx::ScaleVector2d(normalized,
                             viewport_size.width(),
                             viewport_size.height());
 }
 
-gfx::Vector2dF InterpolateBetween(gfx::Vector2dF start,
-                                  gfx::Vector2dF end,
+gfx::Vector2dF InterpolateBetween(const gfx::Vector2dF& start,
+                                  const gfx::Vector2dF& end,
                                   float interp) {
   return start + gfx::ScaleVector2d(end - start, interp);
 }
 
 }  // namespace
 
 namespace cc {
 
 scoped_ptr<PageScaleAnimation> PageScaleAnimation::Create(
-    gfx::Vector2dF start_scroll_offset,
+    const gfx::Vector2dF& start_scroll_offset,
     float start_page_scale_factor,
     const gfx::SizeF& viewport_size,
     const gfx::SizeF& root_layer_size,
     scoped_ptr<TimingFunction> timing_function) {
   return make_scoped_ptr(new PageScaleAnimation(start_scroll_offset,
                                                 start_page_scale_factor,
                                                 viewport_size,
                                                 root_layer_size,
                                                 timing_function.Pass()));
 }
 
 PageScaleAnimation::PageScaleAnimation(
-    gfx::Vector2dF start_scroll_offset,
+    const gfx::Vector2dF& start_scroll_offset,
     float start_page_scale_factor,
     const gfx::SizeF& viewport_size,
     const gfx::SizeF& root_layer_size,
     scoped_ptr<TimingFunction> timing_function)
     : start_page_scale_factor_(start_page_scale_factor),
       target_page_scale_factor_(0.f),
       start_scroll_offset_(start_scroll_offset),
       start_anchor_(),
       target_anchor_(),
       viewport_size_(viewport_size),
       root_layer_size_(root_layer_size),
       start_time_(-1.0),
       duration_(0.0),
       timing_function_(timing_function.Pass()) {}
 
 PageScaleAnimation::~PageScaleAnimation() {}
 
-void PageScaleAnimation::ZoomTo(gfx::Vector2dF target_scroll_offset,
+void PageScaleAnimation::ZoomTo(const gfx::Vector2dF& target_scroll_offset,
                                 float target_page_scale_factor,
                                 double duration) {
   target_page_scale_factor_ = target_page_scale_factor;
   target_scroll_offset_ = target_scroll_offset;
   ClampTargetScrollOffset();
   duration_ = duration;
 
   if (start_page_scale_factor_ == target_page_scale_factor) {
     start_anchor_ = start_scroll_offset_;
     target_anchor_ = target_scroll_offset;
     return;
   }
 
   // For uniform-looking zooming, infer an anchor from the start and target
   // viewport rects.
   InferTargetAnchorFromScrollOffsets();
   start_anchor_ = target_anchor_;
 }
 
-void PageScaleAnimation::ZoomWithAnchor(gfx::Vector2dF anchor,
+void PageScaleAnimation::ZoomWithAnchor(const gfx::Vector2dF& anchor,
                                         float target_page_scale_factor,
                                         double duration) {
   start_anchor_ = anchor;
   target_page_scale_factor_ = target_page_scale_factor;
   duration_ = duration;
 
   // We start zooming out from the anchor tapped by the user. But if
   // the target scale is impossible to attain without hitting the root layer
   // edges, then infer an anchor that doesn't collide with the edges.
   // We will interpolate between the two anchors during the animation.
@@ skipping 127 matching lines @@
 
   // Linearly interpolate the magnitude in log scale.
   float diff = target_page_scale_factor_ / start_page_scale_factor_;
   float log_diff = log(diff);
   log_diff *= interp;
   diff = exp(log_diff);
   return start_page_scale_factor_ * diff;
 }
 
 }  // namespace cc