ui: Make gfx::Size::Scale() mutate the class. Add gfx::ScaleSize() similar to Rect/Point.

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 82 matching lines @@
 
     m_minPageScaleFactor = minPageScaleFactor;
     m_maxPageScaleFactor = maxPageScaleFactor;
 
     m_pageScaleFactor = pageScaleFactor;
     return true;
 }
 
 gfx::RectF PinchZoomViewport::bounds() const
 {
-    gfx::SizeF scaledViewportSize = m_layoutViewportSize;
-    scaledViewportSize = scaledViewportSize.Scale(1 / totalPageScaleFactor());
-
-    gfx::RectF bounds(gfx::PointF(), scaledViewportSize);
+    gfx::RectF bounds(gfx::PointF(), m_layoutViewportSize);
+    bounds.Scale(1 / totalPageScaleFactor());
     bounds.Offset(m_pinchViewportScrollDelta);
-
     return bounds;
 }
 
 gfx::Vector2dF PinchZoomViewport::applyScroll(const gfx::Vector2dF& delta)
 {
     gfx::Vector2dF overflow;
     gfx::RectF pinchedBounds = bounds();
 
     pinchedBounds.Offset(delta);
     if (pinchedBounds.x() < 0) {
@@ skipping 176 matching lines @@
 }
 
 void LayerTreeHostImpl::startPageScaleAnimation(gfx::Vector2d targetOffset, bool anchorPoint, float pageScale, base::TimeTicks startTime, base::TimeDelta duration)
 {
     if (!m_rootScrollLayerImpl)
         return;
 
     gfx::Vector2dF scrollTotal = m_rootScrollLayerImpl->scrollOffset() + m_rootScrollLayerImpl->scrollDelta();
     scrollTotal.Scale(m_pinchZoomViewport.pageScaleDelta());
     float scaleTotal = m_pinchZoomViewport.totalPageScaleFactor();
-    gfx::Size scaledContentSize = gfx::ToFlooredSize(contentSize().Scale(m_pinchZoomViewport.pageScaleDelta()));
+    gfx::Size scaledContentSize = gfx::ToFlooredSize(gfx::ScaleSize(contentSize(), m_pinchZoomViewport.pageScaleDelta()));
 
     double startTimeSeconds = (startTime - base::TimeTicks()).InSecondsF();
     m_pageScaleAnimation = PageScaleAnimation::create(gfx::ToFlooredVector2d(scrollTotal), scaleTotal, m_deviceViewportSize, scaledContentSize, startTimeSeconds);
 
     if (anchorPoint) {
         gfx::Vector2dF windowAnchor = targetOffset;
         windowAnchor.Scale(scaleTotal / pageScale);
         windowAnchor -= scrollTotal;
         m_pageScaleAnimation->zoomWithAnchor(gfx::ToFlooredVector2d(windowAnchor), pageScale, duration.InSecondsF());
     } else
@@ skipping 658 matching lines @@
 }
 
 void LayerTreeHostImpl::updateMaxScrollOffset()
 {
     if (!m_rootScrollLayerImpl || !m_rootScrollLayerImpl->children().size())
         return;
 
     gfx::SizeF viewBounds = m_deviceViewportSize;
     if (LayerImpl* clipLayer = m_rootScrollLayerImpl->parent()) {
         // Compensate for non-overlay scrollbars.
-        if (clipLayer->masksToBounds()) {
-            viewBounds = clipLayer->bounds();
-            viewBounds = viewBounds.Scale(m_deviceScaleFactor);
-        }
+        if (clipLayer->masksToBounds())
+            viewBounds = gfx::ScaleSize(clipLayer->bounds(), m_deviceScaleFactor);
     }
 
     gfx::Size contentBounds = contentSize();
     if (Settings::pageScalePinchZoomEnabled()) {
         // Pinch with pageScale scrolls entirely in layout space.  contentSize
         // returns the bounds including the page scale factor, so calculate the
         // pre page-scale layout size here.
         float pageScaleFactor = m_pinchZoomViewport.pageScaleFactor();
         contentBounds.set_width(contentBounds.width() / pageScaleFactor);
         contentBounds.set_height(contentBounds.height() / pageScaleFactor);
     } else {
-        viewBounds = viewBounds.Scale(1 / m_pinchZoomViewport.pageScaleDelta());
+        viewBounds.Scale(1 / m_pinchZoomViewport.pageScaleDelta());
     }
 
     gfx::Vector2dF maxScroll = BottomRight(gfx::Rect(contentBounds)) - BottomRight(gfx::RectF(viewBounds));
     maxScroll.Scale(1 / m_deviceScaleFactor);
 
     // The viewport may be larger than the contents in some cases, such as
     // having a vertical scrollbar but no horizontal overflow.
     maxScroll = ClampFromBelow(maxScroll, gfx::Vector2dF());
 
     m_rootScrollLayerImpl->setMaxScrollOffset(gfx::ToFlooredVector2d(maxScroll));
@@ skipping 269 matching lines @@
     const float pinchZoomOutSensitivity = 0.95f;
     if (m_pinchZoomViewport.pageScaleDelta() > pinchZoomOutSensitivity)
         return;
 
     // Compute where the scroll offset/page scale would be if fully pinch-zoomed
     // out from the anchor point.
     gfx::Vector2dF scrollBegin = m_rootScrollLayerImpl->scrollOffset() + m_rootScrollLayerImpl->scrollDelta();
     scrollBegin.Scale(m_pinchZoomViewport.pageScaleDelta());
     float scaleBegin = m_pinchZoomViewport.totalPageScaleFactor();
     float pageScaleDeltaToSend = m_pinchZoomViewport.minPageScaleFactor() / m_pinchZoomViewport.pageScaleFactor();
-    gfx::SizeF scaledContentsSize = contentSize().Scale(pageScaleDeltaToSend);
+    gfx::SizeF scaledContentsSize = gfx::ScaleSize(contentSize(), pageScaleDeltaToSend);
 
     gfx::Vector2d anchorOffset = m_previousPinchAnchor.OffsetFromOrigin();
     gfx::Vector2dF scrollEnd = scrollBegin + anchorOffset;
     scrollEnd.Scale(m_pinchZoomViewport.minPageScaleFactor() / scaleBegin);
     scrollEnd -= anchorOffset;
     scrollEnd = ClampFromAbove(scrollEnd, BottomRight(gfx::RectF(scaledContentsSize)) - BottomRight(gfx::Rect(m_deviceViewportSize)));
     scrollEnd = ClampFromBelow(scrollEnd, gfx::Vector2d());
     scrollEnd.Scale(1 / pageScaleDeltaToSend);
     scrollEnd.Scale(m_deviceScaleFactor);
 
@@ skipping 189 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