ui: Prefer +/- operators to apply offsets.

cc/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 "config.h"
 
 #include "cc/page_scale_animation.h"
 #include "ui/gfx/point_f.h"
 #include "ui/gfx/rect_f.h"
 
 #include <algorithm>
 #include <math.h>
 
 namespace {
 
 gfx::PointF toPointF(const gfx::Vector2dF& vector)
 {
     return gfx::PointF(vector.x(), vector.y());
 }
 
 // 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(const gfx::Vector2dF& denormalized, const gfx::SizeF& viewportSize)
 {
-    gfx::Vector2dF normalized(denormalized);
-    normalized.Scale(1 / viewportSize.width(), 1 / viewportSize.height());
-    return normalized;
+    return gfx::ScaleVector2d(denormalized, 1 / viewportSize.width(), 1 / viewportSize.height());
 }
 
 gfx::Vector2dF denormalizeToViewport(const gfx::Vector2dF& normalized, const gfx::SizeF& viewportSize)
 {
-    gfx::Vector2dF denormalized(normalized);
-    denormalized.Scale(viewportSize.width(), viewportSize.height());
-    return denormalized;
+    return gfx::ScaleVector2d(normalized, viewportSize.width(), viewportSize.height());
 }
 
 gfx::Vector2dF interpolateBetween(const gfx::Vector2dF& start, const gfx::Vector2dF end, float interp)
 {
     gfx::Vector2dF result;
     result.set_x(start.x() + interp * (end.x() - start.x()));
     result.set_y(start.y() + interp * (end.y() - start.y()));
     return result;
 }
 
@@ skipping 131 matching lines @@
         return m_startScrollOffset;
     if (interp >= 1)
         return m_targetScrollOffset;
 
     return anchorAt(interp) - viewportRelativeAnchorAt(interp);
 }
 
 gfx::Vector2dF PageScaleAnimation::anchorAt(float interp) const
 {
     // Interpolate from start to target anchor in absolute space.
-    gfx::Vector2dF delta = m_targetAnchor - m_startAnchor;
-    delta.Scale(interp);
+    gfx::Vector2dF delta = gfx::ScaleVector2d(m_targetAnchor - m_startAnchor, interp);
     return m_startAnchor + delta;
 }
 
 gfx::Vector2dF PageScaleAnimation::viewportRelativeAnchorAt(float interp) const
 {
     // Interpolate from start to target anchor in the space relative to the
     // viewport at its current scale level.
     gfx::Vector2dF anchorRelativeToStartViewport = m_startAnchor - m_startScrollOffset;
     gfx::Vector2dF anchorRelativeToTargetViewport = m_targetAnchor - m_targetScrollOffset;
 
@@ skipping 14 matching lines @@
 
     // Linearly interpolate the magnitude in log scale.
     float diff = m_targetPageScaleFactor / m_startPageScaleFactor;
     float logDiff = log(diff);
     logDiff *= interp;
     diff = exp(logDiff);
     return m_startPageScaleFactor * diff;
 }
 
 }  // namespace cc