cc: Use gfx:: Geometry types for positions, bounds, and related things.

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 "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 77 matching lines @@
     if (m_sentPageScaleDelta == 1 && pageScaleFactor == m_pageScaleFactor && minPageScaleFactor == m_minPageScaleFactor && maxPageScaleFactor == m_maxPageScaleFactor)
         return false;
 
     m_minPageScaleFactor = minPageScaleFactor;
     m_maxPageScaleFactor = maxPageScaleFactor;
 
     m_pageScaleFactor = pageScaleFactor;
     return true;
 }
 
-FloatRect PinchZoomViewport::bounds() const
+gfx::RectF PinchZoomViewport::bounds() const
 {
-    FloatSize scaledViewportSize = m_layoutViewportSize;
-    scaledViewportSize.scale(1 / totalPageScaleFactor());
+    gfx::SizeF scaledViewportSize = m_layoutViewportSize;
+    scaledViewportSize = scaledViewportSize.Scale(1 / totalPageScaleFactor());
 
-    FloatRect bounds(FloatPoint(0, 0), scaledViewportSize);
-    bounds.setLocation(m_pinchViewportScrollDelta);
+    gfx::RectF bounds(gfx::PointF(), scaledViewportSize);
+    bounds.set_origin(m_pinchViewportScrollDelta);
 
     return bounds;
 }
 
 FloatSize PinchZoomViewport::applyScroll(FloatSize& delta)
 {
     FloatSize overflow;
-    FloatRect pinchedBounds = bounds();
+    FloatRect pinchedBounds = cc::FloatRect(bounds());
 
     pinchedBounds.move(delta);
     if (pinchedBounds.x() < 0) {
         overflow.setWidth(pinchedBounds.x());
         pinchedBounds.setX(0);
     }
 
     if (pinchedBounds.y() < 0) {
         overflow.setHeight(pinchedBounds.y());
         pinchedBounds.setY(0);
@@ skipping 141 matching lines @@
 bool LayerTreeHostImpl::canDraw()
 {
     // Note: If you are changing this function or any other function that might
     // affect the result of canDraw, make sure to call m_client->onCanDrawStateChanged
     // in the proper places and update the notifyIfCanDrawChanged test.
 
     if (!m_rootLayerImpl) {
         TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::canDraw no root layer");
         return false;
     }
-    if (deviceViewportSize().isEmpty()) {
+    if (deviceViewportSize().IsEmpty()) {
         TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::canDraw empty viewport");
         return false;
     }
     if (!m_renderer) {
         TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::canDraw no renderer");
         return false;
     }
     if (m_contentsTexturesPurged) {
         TRACE_EVENT_INSTANT0("cc", "LayerTreeHostImpl::canDraw contents textures purged");
         return false;
@@ skipping 14 matching lines @@
 }
 
 void LayerTreeHostImpl::startPageScaleAnimation(const IntSize& targetPosition, bool anchorPoint, float pageScale, double startTime, double duration)
 {
     if (!m_rootScrollLayerImpl)
         return;
 
     IntSize scrollTotal = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());
     scrollTotal.scale(m_pinchZoomViewport.pageScaleDelta());
     float scaleTotal = m_pinchZoomViewport.totalPageScaleFactor();
-    IntSize scaledContentSize = contentSize();
+    IntSize scaledContentSize = cc::IntSize(contentSize());
     scaledContentSize.scale(m_pinchZoomViewport.pageScaleDelta());
 
-    m_pageScaleAnimation = PageScaleAnimation::create(scrollTotal, scaleTotal, m_deviceViewportSize, scaledContentSize, startTime);
+    m_pageScaleAnimation = PageScaleAnimation::create(scrollTotal, scaleTotal, cc::IntSize(m_deviceViewportSize), scaledContentSize, startTime);
 
     if (anchorPoint) {
         IntSize windowAnchor(targetPosition);
         windowAnchor.scale(scaleTotal / pageScale);
         windowAnchor -= scrollTotal;
         m_pageScaleAnimation->zoomWithAnchor(windowAnchor, pageScale, duration);
     } else
         m_pageScaleAnimation->zoomTo(targetPosition, pageScale, duration);
 
     m_client->setNeedsRedrawOnImplThread();
@@ skipping 85 matching lines @@
         RenderPass* targetRenderPass = frame.renderPassesById.get(targetRenderPassId);
 
         occlusionTracker.enterLayer(it);
 
         AppendQuadsData appendQuadsData(targetRenderPass->id());
 
         if (it.representsContributingRenderSurface()) {
             RenderPass::Id contributingRenderPassId = it->renderSurface()->renderPassId();
             RenderPass* contributingRenderPass = frame.renderPassesById.get(contributingRenderPassId);
             targetRenderPass->appendQuadsForRenderSurfaceLayer(*it, contributingRenderPass, &occlusionTracker, appendQuadsData);
-        } else if (it.representsItself() && !it->visibleContentRect().isEmpty()) {
+        } else if (it.representsItself() && !it->visibleContentRect().IsEmpty()) {
             bool hasOcclusionFromOutsideTargetSurface;
             if (occlusionTracker.occluded(*it, it->visibleContentRect(), &hasOcclusionFromOutsideTargetSurface))
                 appendQuadsData.hadOcclusionFromOutsideTargetSurface |= hasOcclusionFromOutsideTargetSurface;
             else {
                 it->willDraw(m_resourceProvider.get());
                 frame.willDrawLayers.push_back(*it);
 
                 if (it->hasContributingDelegatedRenderPasses()) {
                     RenderPass::Id contributingRenderPassId = it->firstContributingRenderPassId();
                     while (frame.renderPassesById.contains(contributingRenderPassId)) {
@@ skipping 75 matching lines @@
 
 void LayerTreeHostImpl::setBackgroundTickingEnabled(bool enabled)
 {
     // Lazily create the timeSource adapter so that we can vary the interval for testing.
     if (!m_timeSourceClientAdapter)
         m_timeSourceClientAdapter = LayerTreeHostImplTimeSourceAdapter::create(this, DelayBasedTimeSource::create(lowFrequencyAnimationInterval(), Proxy::currentThread()));
 
     m_timeSourceClientAdapter->setActive(enabled);
 }
 
-IntSize LayerTreeHostImpl::contentSize() const
+gfx::Size LayerTreeHostImpl::contentSize() const
 {
     // TODO(aelias): Hardcoding the first child here is weird. Think of
     // a cleaner way to get the contentBounds on the Impl side.
     if (!m_rootScrollLayerImpl || m_rootScrollLayerImpl->children().isEmpty())
-        return IntSize();
+        return gfx::Size();
     return m_rootScrollLayerImpl->children()[0]->contentBounds();
 }
 
 static inline RenderPass* findRenderPassById(RenderPass::Id renderPassId, const LayerTreeHostImpl::FrameData& frame)
 {
     RenderPassIdHashMap::const_iterator it = frame.renderPassesById.find(renderPassId);
     DCHECK(it != frame.renderPassesById.end());
     return it->second;
 }
 
@@ skipping 195 matching lines @@
 }
 
 bool LayerTreeHostImpl::swapBuffers()
 {
     DCHECK(m_renderer);
 
     m_fpsCounter->markEndOfFrame();
     return m_renderer->swapBuffers();
 }
 
-const IntSize& LayerTreeHostImpl::deviceViewportSize() const
+const gfx::Size& LayerTreeHostImpl::deviceViewportSize() const
 {
     return m_deviceViewportSize;
 }
 
 const LayerTreeSettings& LayerTreeHostImpl::settings() const
 {
     return m_settings;
 }
 
 void LayerTreeHostImpl::didLoseContext()
 {
     m_client->didLoseContextOnImplThread();
 }
 
 void LayerTreeHostImpl::onSwapBuffersComplete()
 {
     m_client->onSwapBuffersCompleteOnImplThread();
 }
 
-void LayerTreeHostImpl::readback(void* pixels, const IntRect& rect)
+void LayerTreeHostImpl::readback(void* pixels, const gfx::Rect& rect)
 {
     DCHECK(m_renderer);
     m_renderer->getFramebufferPixels(pixels, rect);
 }
 
 static LayerImpl* findRootScrollLayer(LayerImpl* layer)
 {
     if (!layer)
         return 0;
 
@@ skipping 112 matching lines @@
     m_contentsTexturesPurged = true;
     m_client->onCanDrawStateChanged(canDraw());
 }
 
 void LayerTreeHostImpl::resetContentsTexturesPurged()
 {
     m_contentsTexturesPurged = false;
     m_client->onCanDrawStateChanged(canDraw());
 }
 
-void LayerTreeHostImpl::setViewportSize(const IntSize& layoutViewportSize, const IntSize& deviceViewportSize)
+void LayerTreeHostImpl::setViewportSize(const gfx::Size& layoutViewportSize, const gfx::Size& deviceViewportSize)
 {
     if (layoutViewportSize == m_layoutViewportSize && deviceViewportSize == m_deviceViewportSize)
         return;
 
     m_layoutViewportSize = layoutViewportSize;
     m_deviceViewportSize = deviceViewportSize;
 
     m_pinchZoomViewport.setLayoutViewportSize(FloatSize(layoutViewportSize));
 
     updateMaxScrollPosition();
@@ skipping 57 matching lines @@
     m_pinchZoomViewport.setPageScaleDelta(delta);
 
     updateMaxScrollPosition();
 }
 
 void LayerTreeHostImpl::updateMaxScrollPosition()
 {
     if (!m_rootScrollLayerImpl || !m_rootScrollLayerImpl->children().size())
         return;
 
-    FloatSize viewBounds = m_deviceViewportSize;
+    gfx::SizeF viewBounds = m_deviceViewportSize;
     if (LayerImpl* clipLayer = m_rootScrollLayerImpl->parent()) {
         // Compensate for non-overlay scrollbars.
         if (clipLayer->masksToBounds()) {
             viewBounds = clipLayer->bounds();
-            viewBounds.scale(m_deviceScaleFactor);
+            viewBounds = viewBounds.Scale(m_deviceScaleFactor);
         }
     }
 
-    IntSize contentBounds = contentSize();
+    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.setWidth(contentBounds.width() / pageScaleFactor);
-        contentBounds.setHeight(contentBounds.height() / pageScaleFactor);
+        contentBounds.set_width(contentBounds.width() / pageScaleFactor);
+        contentBounds.set_height(contentBounds.height() / pageScaleFactor);
     } else {
-        viewBounds.scale(1 / m_pinchZoomViewport.pageScaleDelta());
+        viewBounds = viewBounds.Scale(1 / m_pinchZoomViewport.pageScaleDelta());
     }
 
-    IntSize maxScroll = contentBounds - expandedIntSize(viewBounds);
+    IntSize maxScroll = cc::IntSize(contentBounds) - expandedIntSize(cc::FloatSize(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.clampNegativeToZero();
 
     m_rootScrollLayerImpl->setMaxScrollPosition(maxScroll);
 }
 
 void LayerTreeHostImpl::setNeedsRedraw()
@@ skipping 86 matching lines @@
     FloatPoint screenSpacePoint = viewportPoint;
     screenSpacePoint.scale(scaleFromViewportToScreenSpace, scaleFromViewportToScreenSpace);
 
     FloatSize screenSpaceDelta = viewportDelta;
     screenSpaceDelta.scale(scaleFromViewportToScreenSpace, scaleFromViewportToScreenSpace);
 
     // First project the scroll start and end points to local layer space to find the scroll delta
     // in layer coordinates.
     bool startClipped, endClipped;
     FloatPoint screenSpaceEndPoint = screenSpacePoint + screenSpaceDelta;
-    FloatPoint localStartPoint = MathUtil::projectPoint(inverseScreenSpaceTransform, screenSpacePoint, startClipped);
-    FloatPoint localEndPoint = MathUtil::projectPoint(inverseScreenSpaceTransform, screenSpaceEndPoint, endClipped);
+    FloatPoint localStartPoint = cc::FloatPoint(MathUtil::projectPoint(inverseScreenSpaceTransform, screenSpacePoint, startClipped));
+    FloatPoint localEndPoint = cc::FloatPoint(MathUtil::projectPoint(inverseScreenSpaceTransform, screenSpaceEndPoint, endClipped));
 
     // In general scroll point coordinates should not get clipped.
     DCHECK(!startClipped);
     DCHECK(!endClipped);
     if (startClipped || endClipped)
         return FloatSize();
 
     // localStartPoint and localEndPoint are in content space but we want to move them to layer space for scrolling.
     float widthScale = 1;
     float heightScale = 1;
-    if (!layerImpl.contentBounds().isEmpty() && !layerImpl.bounds().isEmpty()) {
+    if (!layerImpl.contentBounds().IsEmpty() && !layerImpl.bounds().IsEmpty()) {
         widthScale = layerImpl.bounds().width() / static_cast<float>(layerImpl.contentBounds().width());
         heightScale = layerImpl.bounds().height() / static_cast<float>(layerImpl.contentBounds().height());
     }
     localStartPoint.scale(widthScale, heightScale);
     localEndPoint.scale(widthScale, heightScale);
 
     // Apply the scroll delta.
     FloatSize previousDelta(layerImpl.scrollDelta());
     FloatSize 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.
     FloatPoint actualLocalEndPoint = localStartPoint + layerImpl.scrollDelta() - previousDelta;
-    FloatPoint actualLocalContentEndPoint = actualLocalEndPoint;
-    actualLocalContentEndPoint.scale(1 / widthScale, 1 / heightScale);
+    gfx::PointF actualLocalContentEndPoint = actualLocalEndPoint;
+    actualLocalContentEndPoint = actualLocalContentEndPoint.Scale(1 / widthScale, 1 / heightScale);
 
     // Calculate the applied scroll delta in viewport space coordinates.
-    FloatPoint actualScreenSpaceEndPoint = MathUtil::mapPoint(layerImpl.screenSpaceTransform(), actualLocalContentEndPoint, endClipped);
+    FloatPoint actualScreenSpaceEndPoint = cc::FloatPoint(MathUtil::mapPoint(layerImpl.screenSpaceTransform(), actualLocalContentEndPoint, endClipped));
     DCHECK(!endClipped);
     if (endClipped)
         return FloatSize();
     FloatPoint actualViewportEndPoint = actualScreenSpaceEndPoint;
     actualViewportEndPoint.scale(1 / scaleFromViewportToScreenSpace, 1 / scaleFromViewportToScreenSpace);
     return actualViewportEndPoint - viewportPoint;
 }
 
 static FloatSize scrollLayerWithLocalDelta(LayerImpl& layerImpl, const FloatSize& localDelta)
 {
@@ skipping 64 matching lines @@
 void LayerTreeHostImpl::pinchGestureBegin()
 {
     m_pinchGestureActive = true;
     m_previousPinchAnchor = IntPoint();
 
     if (m_rootScrollLayerImpl && m_rootScrollLayerImpl->scrollbarAnimationController())
         m_rootScrollLayerImpl->scrollbarAnimationController()->didPinchGestureBegin();
 }
 
 void LayerTreeHostImpl::pinchGestureUpdate(float magnifyDelta,
-                                             const IntPoint& anchor)
+                                           const IntPoint& anchor)
 {
     TRACE_EVENT0("cc", "LayerTreeHostImpl::pinchGestureUpdate");
 
     if (!m_rootScrollLayerImpl)
         return;
 
     if (m_previousPinchAnchor == IntPoint::zero())
         m_previousPinchAnchor = anchor;
 
     // Keep the center-of-pinch anchor specified by (x, y) in a stable
@@ skipping 52 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.
     IntSize scrollBegin = flooredIntSize(m_rootScrollLayerImpl->scrollPosition() + m_rootScrollLayerImpl->scrollDelta());
     scrollBegin.scale(m_pinchZoomViewport.pageScaleDelta());
     float scaleBegin = m_pinchZoomViewport.totalPageScaleFactor();
     float pageScaleDeltaToSend = m_pinchZoomViewport.minPageScaleFactor() / m_pinchZoomViewport.pageScaleFactor();
-    FloatSize scaledContentsSize = contentSize();
-    scaledContentsSize.scale(pageScaleDeltaToSend);
+    gfx::SizeF scaledContentsSize = contentSize().Scale(pageScaleDeltaToSend);
 
     FloatSize anchor = toSize(m_previousPinchAnchor);
     FloatSize scrollEnd = scrollBegin + anchor;
     scrollEnd.scale(m_pinchZoomViewport.minPageScaleFactor() / scaleBegin);
     scrollEnd -= anchor;
-    scrollEnd = scrollEnd.shrunkTo(roundedIntSize(scaledContentsSize - m_deviceViewportSize)).expandedTo(FloatSize(0, 0));
+    scrollEnd = scrollEnd.shrunkTo(roundedIntSize(cc::FloatSize(scaledContentsSize) - cc::IntSize(m_deviceViewportSize))).expandedTo(FloatSize(0, 0));
     scrollEnd.scale(1 / pageScaleDeltaToSend);
     scrollEnd.scale(m_deviceScaleFactor);
 
     makeScrollAndScaleSet(scrollInfo, roundedIntSize(scrollEnd), m_pinchZoomViewport.minPageScaleFactor());
 }
 
 void LayerTreeHostImpl::makeScrollAndScaleSet(ScrollAndScaleSet* scrollInfo, const IntSize& scrollOffset, float pageScale)
 {
     if (!m_rootScrollLayerImpl)
         return;
@@ skipping 180 matching lines @@
 
     ScrollbarAnimationController* scrollbarController = layer->scrollbarAnimationController();
     if (scrollbarController && scrollbarController->animate(monotonicTime))
         m_client->setNeedsRedrawOnImplThread();
 
     for (size_t i = 0; i < layer->children().size(); ++i)
         animateScrollbarsRecursive(layer->children()[i], monotonicTime);
 }
 
 }  // namespace cc