ui: Make gfx::Point::Scale() mutate the class, similar to gfx::Rect.

cc/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 "config.h"
 
 #include "cc/layer_tree_host_impl.h"
 
 #include <algorithm>
 
@@ skipping 1027 matching lines @@
 InputHandlerClient::ScrollStatus LayerTreeHostImpl::scrollBegin(gfx::Point viewportPoint, InputHandlerClient::ScrollInputType type)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::scrollBegin");
 
     DCHECK(!m_currentlyScrollingLayerImpl);
     clearCurrentlyScrollingLayer();
 
     if (!ensureRenderSurfaceLayerList())
         return ScrollIgnored;
 
-    gfx::PointF deviceViewportPoint = viewportPoint.Scale(m_deviceScaleFactor);
+    gfx::PointF deviceViewportPoint = gfx::ScalePoint(viewportPoint, m_deviceScaleFactor);
 
     // First find out which layer was hit from the saved list of visible layers
     // in the most recent frame.
     LayerImpl* layerImpl = LayerTreeHostCommon::findLayerThatIsHitByPoint(deviceViewportPoint, m_renderSurfaceLayerList);
 
     // Walk up the hierarchy and look for a scrollable layer.
     LayerImpl* potentiallyScrollingLayerImpl = 0;
     for (; layerImpl; layerImpl = layerImpl->parent()) {
         // The content layer can also block attempts to scroll outside the main thread.
         if (layerImpl->tryScroll(deviceViewportPoint, type) == ScrollOnMainThread) {
@@ skipping 29 matching lines @@
     return ScrollIgnored;
 }
 
 static gfx::Vector2dF scrollLayerWithViewportSpaceDelta(PinchZoomViewport* viewport, LayerImpl& layerImpl, float scaleFromViewportToScreenSpace, gfx::PointF viewportPoint, gfx::Vector2dF viewportDelta)
 {
     // Layers with non-invertible screen space transforms should not have passed the scroll hit
     // test in the first place.
     DCHECK(layerImpl.screenSpaceTransform().isInvertible());
     WebTransformationMatrix inverseScreenSpaceTransform = layerImpl.screenSpaceTransform().inverse();
 
-    gfx::PointF screenSpacePoint = viewportPoint.Scale(scaleFromViewportToScreenSpace);
+    gfx::PointF screenSpacePoint = gfx::ScalePoint(viewportPoint, scaleFromViewportToScreenSpace);
 
     gfx::Vector2dF screenSpaceDelta = viewportDelta;
     screenSpaceDelta.Scale(scaleFromViewportToScreenSpace);
 
     // First project the scroll start and end points to local layer space to find the scroll delta
     // in layer coordinates.
     bool startClipped, endClipped;
     gfx::PointF screenSpaceEndPoint = screenSpacePoint + screenSpaceDelta;
     gfx::PointF localStartPoint = MathUtil::projectPoint(inverseScreenSpaceTransform, screenSpacePoint, startClipped);
     gfx::PointF localEndPoint = MathUtil::projectPoint(inverseScreenSpaceTransform, screenSpaceEndPoint, endClipped);
 
     // In general scroll point coordinates should not get clipped.
     DCHECK(!startClipped);
     DCHECK(!endClipped);
     if (startClipped || endClipped)
         return gfx::Vector2dF();
 
     // localStartPoint and localEndPoint are in content space but we want to move them to layer space for scrolling.
     float widthScale = 1 / layerImpl.contentsScaleX();
     float heightScale = 1 / layerImpl.contentsScaleY();
-    localStartPoint = localStartPoint.Scale(widthScale, heightScale);
-    localEndPoint = localEndPoint.Scale(widthScale, heightScale);
+    localStartPoint.Scale(widthScale, heightScale);
+    localEndPoint.Scale(widthScale, heightScale);
 
     // Apply the scroll delta.
     gfx::Vector2dF previousDelta = layerImpl.scrollDelta();
     gfx::Vector2dF unscrolled = layerImpl.scrollBy(localEndPoint - localStartPoint);
 
     if (viewport)
         viewport->applyScroll(unscrolled);
 
     // Get the end point in the layer's content space so we can apply its screenSpaceTransform.
     gfx::PointF actualLocalEndPoint = localStartPoint + layerImpl.scrollDelta() - previousDelta;
-    gfx::PointF actualLocalContentEndPoint = actualLocalEndPoint.Scale(1 / widthScale, 1 / heightScale);
+    gfx::PointF actualLocalContentEndPoint = gfx::ScalePoint(actualLocalEndPoint, 1 / widthScale, 1 / heightScale);
 
     // Calculate the applied scroll delta in viewport space coordinates.
     gfx::PointF actualScreenSpaceEndPoint = MathUtil::mapPoint(layerImpl.screenSpaceTransform(), actualLocalContentEndPoint, endClipped);
     DCHECK(!endClipped);
     if (endClipped)
         return gfx::Vector2dF();
-    gfx::PointF actualViewportEndPoint = actualScreenSpaceEndPoint.Scale(1 / scaleFromViewportToScreenSpace);
+    gfx::PointF actualViewportEndPoint = gfx::ScalePoint(actualScreenSpaceEndPoint, 1 / scaleFromViewportToScreenSpace);
     return actualViewportEndPoint - viewportPoint;
 }
 
 static gfx::Vector2dF scrollLayerWithLocalDelta(LayerImpl& layerImpl, gfx::Vector2dF localDelta)
 {
     gfx::Vector2dF previousDelta(layerImpl.scrollDelta());
     layerImpl.scrollBy(localDelta);
     return layerImpl.scrollDelta() - previousDelta;
 }
 
@@ skipping 71 matching lines @@
 
     if (!m_rootScrollLayerImpl)
         return;
 
     if (m_previousPinchAnchor == gfx::Point())
         m_previousPinchAnchor = anchor;
 
     // Keep the center-of-pinch anchor specified by (x, y) in a stable
     // position over the course of the magnify.
     float pageScaleDelta = m_pinchZoomViewport.pageScaleDelta();
-    gfx::PointF previousScaleAnchor = m_previousPinchAnchor.Scale(1 / pageScaleDelta);
+    gfx::PointF previousScaleAnchor = gfx::ScalePoint(m_previousPinchAnchor, 1 / pageScaleDelta);
     setPageScaleDelta(pageScaleDelta * magnifyDelta);
     pageScaleDelta = m_pinchZoomViewport.pageScaleDelta();
-    gfx::PointF newScaleAnchor = anchor.Scale(1 / pageScaleDelta);
+    gfx::PointF newScaleAnchor = gfx::ScalePoint(anchor, 1 / pageScaleDelta);
     gfx::Vector2dF move = previousScaleAnchor - newScaleAnchor;
 
     m_previousPinchAnchor = anchor;
 
     if (Settings::pageScalePinchZoomEnabled()) {
         // Compute the application of the delta with respect to the current page zoom of the page.
         move.Scale(1 / (m_pinchZoomViewport.pageScaleFactor() * m_deviceScaleFactor));
     }
 
     gfx::Vector2dF scrollOverflow = Settings::pageScalePinchZoomEnabled() ? m_pinchZoomViewport.applyScroll(move) : move;
@@ skipping 245 matching lines @@
     ScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
     double monotonicTime = (time - base::TimeTicks()).InSecondsF();
     if (scrollbarController && scrollbarController->animate(monotonicTime))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         animateScrollbarsRecursive(layer->children()[i], time);
 }
 
 }  // namespace cc