From fb8f0cf40a7640501558903f8ddfba52116750d2 Mon Sep 17 00:00:00 2001 From: Botond Ballo Date: Thu, 13 Mar 2014 02:34:34 -0400 Subject: [PATCH] Bug 980493 - Transition FrameMetrics::mScrollOffset to use a getter/setter. r=kats --- dom/ipc/TabChild.cpp | 6 +- gfx/layers/FrameMetrics.h | 55 ++++++++++++------- gfx/layers/LayersLogging.cpp | 2 +- gfx/layers/client/ClientLayerManager.cpp | 2 +- gfx/layers/client/ClientTiledThebesLayer.cpp | 2 +- .../client/SimpleTiledContentClient.cpp | 2 +- gfx/layers/client/TiledContentClient.cpp | 6 +- .../composite/AsyncCompositionManager.cpp | 6 +- .../composite/LayerManagerComposite.cpp | 4 +- gfx/layers/ipc/AsyncPanZoomController.cpp | 54 +++++++++--------- gfx/layers/ipc/Axis.cpp | 2 +- .../gtest/TestAsyncPanZoomController.cpp | 32 +++++------ layout/base/nsDisplayList.cpp | 2 +- layout/ipc/RenderFrameParent.cpp | 4 +- widget/android/AndroidBridge.cpp | 2 +- widget/xpwidgets/APZCCallbackHelper.cpp | 12 ++-- 16 files changed, 104 insertions(+), 89 deletions(-) diff --git a/dom/ipc/TabChild.cpp b/dom/ipc/TabChild.cpp index 02817b6f24ca..4c6e3306bd70 100644 --- a/dom/ipc/TabChild.cpp +++ b/dom/ipc/TabChild.cpp @@ -330,7 +330,7 @@ TabChild::InitializeRootMetrics() // This is the root layer, so the cumulative resolution is the same // as the resolution. mLastRootMetrics.mResolution = mLastRootMetrics.mCumulativeResolution / LayoutDeviceToParentLayerScale(1); - mLastRootMetrics.mScrollOffset = CSSPoint(0, 0); + mLastRootMetrics.SetScrollOffset(CSSPoint(0, 0)); } bool @@ -1526,8 +1526,8 @@ TabChild::ProcessUpdateFrame(const FrameMetrics& aFrameMetrics) // for other functions it performs, such as double tap handling. // Note, %f must not be used because it is locale specific! nsCString data; - data.AppendPrintf("{ \"x\" : %d", NS_lround(newMetrics.mScrollOffset.x)); - data.AppendPrintf(", \"y\" : %d", NS_lround(newMetrics.mScrollOffset.y)); + data.AppendPrintf("{ \"x\" : %d", NS_lround(newMetrics.GetScrollOffset().x)); + data.AppendPrintf(", \"y\" : %d", NS_lround(newMetrics.GetScrollOffset().y)); data.AppendLiteral(", \"viewport\" : "); data.AppendLiteral("{ \"width\" : "); data.AppendFloat(newMetrics.mViewport.width); diff --git a/gfx/layers/FrameMetrics.h b/gfx/layers/FrameMetrics.h index 6e7f069cc02c..8fef3d8c2e5e 100644 --- a/gfx/layers/FrameMetrics.h +++ b/gfx/layers/FrameMetrics.h @@ -71,7 +71,6 @@ public: , mDisplayPort(0, 0, 0, 0) , mCriticalDisplayPort(0, 0, 0, 0) , mViewport(0, 0, 0, 0) - , mScrollOffset(0, 0) , mScrollId(NULL_SCROLL_ID) , mScrollableRect(0, 0, 0, 0) , mResolution(1) @@ -83,6 +82,7 @@ public: , mMayHaveTouchListeners(false) , mIsRoot(false) , mHasScrollgrab(false) + , mScrollOffset(0, 0) , mUpdateScrollOffset(false) , mScrollGeneration(0) {} @@ -97,7 +97,6 @@ public: mDisplayPort.IsEqualEdges(aOther.mDisplayPort) && mCriticalDisplayPort.IsEqualEdges(aOther.mCriticalDisplayPort) && mViewport.IsEqualEdges(aOther.mViewport) && - mScrollOffset == aOther.mScrollOffset && mScrollId == aOther.mScrollId && mScrollableRect.IsEqualEdges(aOther.mScrollableRect) && mResolution == aOther.mResolution && @@ -106,6 +105,7 @@ public: mMayHaveTouchListeners == aOther.mMayHaveTouchListeners && mPresShellId == aOther.mPresShellId && mIsRoot == aOther.mIsRoot && + mScrollOffset == aOther.mScrollOffset && mHasScrollgrab == aOther.mHasScrollgrab && mUpdateScrollOffset == aOther.mUpdateScrollOffset; } @@ -139,7 +139,7 @@ public: LayerPoint GetScrollOffsetInLayerPixels() const { - return mScrollOffset * LayersPixelsPerCSSPixel(); + return GetScrollOffset() * LayersPixelsPerCSSPixel(); } LayoutDeviceToParentLayerScale GetParentResolution() const @@ -194,6 +194,11 @@ public: return gfx::RoundedIn(mCompositionBounds / GetZoomToParent()); } + void ScrollBy(const CSSPoint& aPoint) + { + mScrollOffset += aPoint; + } + // --------------------------------------------------------------------------- // The following metrics are all in widget space/device pixels. // @@ -258,23 +263,6 @@ public: // meaningless and invalid. CSSRect mViewport; - // The position of the top-left of the CSS viewport, relative to the document - // (or the document relative to the viewport, if that helps understand it). - // - // Thus it is relative to the document. It is in the same coordinate space as - // |mScrollableRect|, but a different coordinate space than |mViewport| and - // |mDisplayPort|. - // - // It is required that the rect: - // { x = mScrollOffset.x, y = mScrollOffset.y, - // width = mCompositionBounds.x / mResolution.scale, - // height = mCompositionBounds.y / mResolution.scale } - // Be within |mScrollableRect|. - // - // This is valid for any layer, but is always relative to this frame and - // not any parents, regardless of parent transforms. - CSSPoint mScrollOffset; - // A unique ID assigned to each scrollable frame. ViewID mScrollId; @@ -340,6 +328,16 @@ public: bool mHasScrollgrab; public: + void SetScrollOffset(const CSSPoint& aScrollOffset) + { + mScrollOffset = aScrollOffset; + } + + const CSSPoint& GetScrollOffset() const + { + return mScrollOffset; + } + void SetScrollOffsetUpdated(uint32_t aScrollGeneration) { mUpdateScrollOffset = true; @@ -370,6 +368,23 @@ private: // New fields from now on should be made private and old fields should // be refactored to be private. + // The position of the top-left of the CSS viewport, relative to the document + // (or the document relative to the viewport, if that helps understand it). + // + // Thus it is relative to the document. It is in the same coordinate space as + // |mScrollableRect|, but a different coordinate space than |mViewport| and + // |mDisplayPort|. + // + // It is required that the rect: + // { x = mScrollOffset.x, y = mScrollOffset.y, + // width = mCompositionBounds.x / mResolution.scale, + // height = mCompositionBounds.y / mResolution.scale } + // Be within |mScrollableRect|. + // + // This is valid for any layer, but is always relative to this frame and + // not any parents, regardless of parent transforms. + CSSPoint mScrollOffset; + // Whether mScrollOffset was updated by something other than the APZ code, and // if the APZC receiving this metrics should update its local copy. bool mUpdateScrollOffset; diff --git a/gfx/layers/LayersLogging.cpp b/gfx/layers/LayersLogging.cpp index d170fb97c93f..78b1541edddf 100644 --- a/gfx/layers/LayersLogging.cpp +++ b/gfx/layers/LayersLogging.cpp @@ -118,7 +118,7 @@ AppendToString(nsACString& s, const FrameMetrics& m, { s += pfx; AppendToString(s, m.mViewport, "{ viewport="); - AppendToString(s, m.mScrollOffset, " viewportScroll="); + AppendToString(s, m.GetScrollOffset(), " viewportScroll="); AppendToString(s, m.mDisplayPort, " displayport="); AppendToString(s, m.mScrollableRect, " scrollableRect="); AppendToString(s, m.mScrollId, " scrollId=", " }"); diff --git a/gfx/layers/client/ClientLayerManager.cpp b/gfx/layers/client/ClientLayerManager.cpp index 8690b931a292..d561213a4345 100644 --- a/gfx/layers/client/ClientLayerManager.cpp +++ b/gfx/layers/client/ClientLayerManager.cpp @@ -549,7 +549,7 @@ ClientLayerManager::ProgressiveUpdateCallback(bool aHasPendingNewThebesContent, const CSSRect& metricsDisplayPort = (aDrawingCritical && !metrics.mCriticalDisplayPort.IsEmpty()) ? metrics.mCriticalDisplayPort : metrics.mDisplayPort; - LayerRect displayPort = (metricsDisplayPort + metrics.mScrollOffset) * paintScale; + LayerRect displayPort = (metricsDisplayPort + metrics.GetScrollOffset()) * paintScale; return AndroidBridge::Bridge()->ProgressiveUpdateCallback( aHasPendingNewThebesContent, displayPort, paintScale.scale, aDrawingCritical, diff --git a/gfx/layers/client/ClientTiledThebesLayer.cpp b/gfx/layers/client/ClientTiledThebesLayer.cpp index 7eeed12f5596..389a303a119d 100644 --- a/gfx/layers/client/ClientTiledThebesLayer.cpp +++ b/gfx/layers/client/ClientTiledThebesLayer.cpp @@ -129,7 +129,7 @@ ClientTiledThebesLayer::BeginPaint() Layer* primaryScrollable = ClientManager()->GetPrimaryScrollableLayer(); if (primaryScrollable) { const FrameMetrics& metrics = primaryScrollable->AsContainerLayer()->GetFrameMetrics(); - mPaintData.mScrollOffset = metrics.mScrollOffset * metrics.mZoom; + mPaintData.mScrollOffset = metrics.GetScrollOffset() * metrics.mZoom; mPaintData.mCompositionBounds = ApplyParentLayerToLayoutTransform(mPaintData.mTransformParentLayerToLayout, ParentLayerRect(metrics.mCompositionBounds)); diff --git a/gfx/layers/client/SimpleTiledContentClient.cpp b/gfx/layers/client/SimpleTiledContentClient.cpp index 4d2c7bf35b00..1d017d94c2aa 100644 --- a/gfx/layers/client/SimpleTiledContentClient.cpp +++ b/gfx/layers/client/SimpleTiledContentClient.cpp @@ -341,7 +341,7 @@ SimpleClientTiledThebesLayer::BeginPaint() Layer* primaryScrollable = ClientManager()->GetPrimaryScrollableLayer(); if (primaryScrollable) { const FrameMetrics& metrics = primaryScrollable->AsContainerLayer()->GetFrameMetrics(); - mPaintData.mScrollOffset = metrics.mScrollOffset * metrics.mZoom; + mPaintData.mScrollOffset = metrics.GetScrollOffset() * metrics.mZoom; mPaintData.mCompositionBounds = ApplyParentLayerToLayoutTransform(mPaintData.mTransformParentLayerToLayout, ParentLayerRect(metrics.mCompositionBounds)); diff --git a/gfx/layers/client/TiledContentClient.cpp b/gfx/layers/client/TiledContentClient.cpp index 53e20379849a..5ad47d7f8a7f 100644 --- a/gfx/layers/client/TiledContentClient.cpp +++ b/gfx/layers/client/TiledContentClient.cpp @@ -186,8 +186,8 @@ SharedFrameMetricsHelper::UpdateFromCompositorFrameMetrics( // display-port. If we abort updating when we shouldn't, we can end up // with blank regions on the screen and we open up the risk of entering // an endless updating cycle. - if (fabsf(contentMetrics.mScrollOffset.x - compositorMetrics.mScrollOffset.x) <= 2 && - fabsf(contentMetrics.mScrollOffset.y - compositorMetrics.mScrollOffset.y) <= 2 && + if (fabsf(contentMetrics.GetScrollOffset().x - compositorMetrics.GetScrollOffset().x) <= 2 && + fabsf(contentMetrics.GetScrollOffset().y - compositorMetrics.GetScrollOffset().y) <= 2 && fabsf(contentMetrics.mDisplayPort.x - compositorMetrics.mDisplayPort.x) <= 2 && fabsf(contentMetrics.mDisplayPort.y - compositorMetrics.mDisplayPort.y) <= 2 && fabsf(contentMetrics.mDisplayPort.width - compositorMetrics.mDisplayPort.width) <= 2 && @@ -241,7 +241,7 @@ bool SharedFrameMetricsHelper::AboutToCheckerboard(const FrameMetrics& aContentMetrics, const FrameMetrics& aCompositorMetrics) { - return !aContentMetrics.mDisplayPort.Contains(CSSRect(aCompositorMetrics.CalculateCompositedRectInCssPixels()) - aCompositorMetrics.mScrollOffset); + return !aContentMetrics.mDisplayPort.Contains(CSSRect(aCompositorMetrics.CalculateCompositedRectInCssPixels()) - aCompositorMetrics.GetScrollOffset()); } ClientTiledLayerBuffer::ClientTiledLayerBuffer(ClientTiledThebesLayer* aThebesLayer, diff --git a/gfx/layers/composite/AsyncCompositionManager.cpp b/gfx/layers/composite/AsyncCompositionManager.cpp index 0a506536952c..be57e1c68d11 100644 --- a/gfx/layers/composite/AsyncCompositionManager.cpp +++ b/gfx/layers/composite/AsyncCompositionManager.cpp @@ -662,7 +662,7 @@ AsyncCompositionManager::TransformScrollableLayer(Layer* aLayer) CSSToLayerScale geckoZoom = metrics.LayersPixelsPerCSSPixel(); - LayerIntPoint scrollOffsetLayerPixels = RoundedToInt(metrics.mScrollOffset * geckoZoom); + LayerIntPoint scrollOffsetLayerPixels = RoundedToInt(metrics.GetScrollOffset() * geckoZoom); if (mIsFirstPaint) { mContentRect = metrics.mScrollableRect; @@ -694,7 +694,7 @@ AsyncCompositionManager::TransformScrollableLayer(Layer* aLayer) // however, we can assume there is no async zooming in progress and so the following statement // works fine. CSSToScreenScale userZoom(metrics.mDevPixelsPerCSSPixel * metrics.mCumulativeResolution * LayerToScreenScale(1)); - ScreenPoint userScroll = metrics.mScrollOffset * userZoom; + ScreenPoint userScroll = metrics.GetScrollOffset() * userZoom; SyncViewportInfo(displayPort, geckoZoom, mLayersUpdated, userScroll, userZoom, fixedLayerMargins, offset); @@ -713,7 +713,7 @@ AsyncCompositionManager::TransformScrollableLayer(Layer* aLayer) LayerPoint geckoScroll(0, 0); if (metrics.IsScrollable()) { - geckoScroll = metrics.mScrollOffset * geckoZoom; + geckoScroll = metrics.GetScrollOffset() * geckoZoom; } LayerPoint translation = (userScroll / zoomAdjust) - geckoScroll; diff --git a/gfx/layers/composite/LayerManagerComposite.cpp b/gfx/layers/composite/LayerManagerComposite.cpp index 9a19438de0ab..b20104bfc6d1 100644 --- a/gfx/layers/composite/LayerManagerComposite.cpp +++ b/gfx/layers/composite/LayerManagerComposite.cpp @@ -686,8 +686,8 @@ LayerManagerComposite::ComputeRenderIntegrity() // Clip the screen rect to the document bounds gfxRect documentBounds = - transform.TransformBounds(gfxRect(metrics.mScrollableRect.x - metrics.mScrollOffset.x, - metrics.mScrollableRect.y - metrics.mScrollOffset.y, + transform.TransformBounds(gfxRect(metrics.mScrollableRect.x - metrics.GetScrollOffset().x, + metrics.mScrollableRect.y - metrics.GetScrollOffset().y, metrics.mScrollableRect.width, metrics.mScrollableRect.height)); documentBounds.RoundOut(); diff --git a/gfx/layers/ipc/AsyncPanZoomController.cpp b/gfx/layers/ipc/AsyncPanZoomController.cpp index 2c8ad9bbae77..5377f074e4f6 100644 --- a/gfx/layers/ipc/AsyncPanZoomController.cpp +++ b/gfx/layers/ipc/AsyncPanZoomController.cpp @@ -1286,10 +1286,10 @@ bool FlingAnimation::Sample(FrameMetrics& aFrameMetrics, // the same swipe should move you a shorter distance). CSSPoint cssOffset = offset / aFrameMetrics.mZoom; CSSPoint overscroll; - aFrameMetrics.mScrollOffset += CSSPoint( + aFrameMetrics.ScrollBy(CSSPoint( mApzc.mX.AdjustDisplacement(cssOffset.x, overscroll.x), mApzc.mY.AdjustDisplacement(cssOffset.y, overscroll.y) - ); + )); // If the fling has caused us to reach the end of our scroll range, hand // off the fling to the next APZC in the overscroll handoff chain. @@ -1351,7 +1351,7 @@ void AsyncPanZoomController::SetCrossProcessCompositorParent(PCompositorParent* } void AsyncPanZoomController::ScrollBy(const CSSPoint& aOffset) { - mFrameMetrics.mScrollOffset += aOffset; + mFrameMetrics.ScrollBy(aOffset); } void AsyncPanZoomController::ScaleWithFocus(float aScale, @@ -1361,7 +1361,7 @@ void AsyncPanZoomController::ScaleWithFocus(float aScale, // at the same position on the screen before and after the change in zoom. The below code // accomplishes this; see https://bugzilla.mozilla.org/show_bug.cgi?id=923431#c6 for an // in-depth explanation of how. - mFrameMetrics.mScrollOffset = (mFrameMetrics.mScrollOffset + aFocus) - (aFocus / aScale); + mFrameMetrics.SetScrollOffset((mFrameMetrics.GetScrollOffset() + aFocus) - (aFocus / aScale)); } /** @@ -1415,7 +1415,7 @@ const CSSRect AsyncPanZoomController::CalculatePendingDisplayPort( { CSSRect compositionBounds(aFrameMetrics.CalculateCompositedRectInCssPixels()); CSSPoint velocity = aVelocity / aFrameMetrics.mZoom; - CSSPoint scrollOffset = aFrameMetrics.mScrollOffset; + CSSPoint scrollOffset = aFrameMetrics.GetScrollOffset(); CSSRect scrollableRect = aFrameMetrics.GetExpandedScrollableRect(); // Calculate the displayport size based on how fast we're moving along each axis. @@ -1472,18 +1472,18 @@ void AsyncPanZoomController::RequestContentRepaint(FrameMetrics& aFrameMetrics) // If we're trying to paint what we already think is painted, discard this // request since it's a pointless paint. CSSRect oldDisplayPort = mLastPaintRequestMetrics.mDisplayPort - + mLastPaintRequestMetrics.mScrollOffset; + + mLastPaintRequestMetrics.GetScrollOffset(); CSSRect newDisplayPort = aFrameMetrics.mDisplayPort - + aFrameMetrics.mScrollOffset; + + aFrameMetrics.GetScrollOffset(); if (fabsf(oldDisplayPort.x - newDisplayPort.x) < EPSILON && fabsf(oldDisplayPort.y - newDisplayPort.y) < EPSILON && fabsf(oldDisplayPort.width - newDisplayPort.width) < EPSILON && fabsf(oldDisplayPort.height - newDisplayPort.height) < EPSILON && - fabsf(mLastPaintRequestMetrics.mScrollOffset.x - - aFrameMetrics.mScrollOffset.x) < EPSILON && - fabsf(mLastPaintRequestMetrics.mScrollOffset.y - - aFrameMetrics.mScrollOffset.y) < EPSILON && + fabsf(mLastPaintRequestMetrics.GetScrollOffset().x - + aFrameMetrics.GetScrollOffset().x) < EPSILON && + fabsf(mLastPaintRequestMetrics.GetScrollOffset().y - + aFrameMetrics.GetScrollOffset().y) < EPSILON && aFrameMetrics.mZoom == mLastPaintRequestMetrics.mZoom && fabsf(aFrameMetrics.mViewport.width - mLastPaintRequestMetrics.mViewport.width) < EPSILON && fabsf(aFrameMetrics.mViewport.height - mLastPaintRequestMetrics.mViewport.height) < EPSILON) { @@ -1509,7 +1509,7 @@ AsyncPanZoomController::DispatchRepaintRequest(const FrameMetrics& aFrameMetrics APZC_LOG_FM(aFrameMetrics, "%p requesting content repaint", this); LogRendertraceRect(GetGuid(), "requested displayport", "yellow", - aFrameMetrics.mDisplayPort + aFrameMetrics.mScrollOffset); + aFrameMetrics.mDisplayPort + aFrameMetrics.GetScrollOffset()); controller->RequestContentRepaint(aFrameMetrics); mLastDispatchedPaintMetrics = aFrameMetrics; @@ -1533,7 +1533,7 @@ bool ZoomAnimation::Sample(FrameMetrics& aFrameMetrics, if (animPosition >= 1.0) { aFrameMetrics.mZoom = mEndZoom; - aFrameMetrics.mScrollOffset = mEndOffset; + aFrameMetrics.SetScrollOffset(mEndOffset); return false; } @@ -1547,10 +1547,10 @@ bool ZoomAnimation::Sample(FrameMetrics& aFrameMetrics, (sampledPosition / mEndZoom.scale + (1 - sampledPosition) / mStartZoom.scale)); - aFrameMetrics.mScrollOffset = CSSPoint::FromUnknownPoint(gfx::Point( + aFrameMetrics.SetScrollOffset(CSSPoint::FromUnknownPoint(gfx::Point( mEndOffset.x * sampledPosition + mStartOffset.x * (1 - sampledPosition), mEndOffset.y * sampledPosition + mStartOffset.y * (1 - sampledPosition) - )); + ))); return true; } @@ -1591,14 +1591,14 @@ bool AsyncPanZoomController::SampleContentTransformForFrame(const TimeStamp& aSa requestAnimationFrame = UpdateAnimation(aSampleTime); - aScrollOffset = mFrameMetrics.mScrollOffset * mFrameMetrics.mZoom; + aScrollOffset = mFrameMetrics.GetScrollOffset() * mFrameMetrics.mZoom; *aNewTransform = GetCurrentAsyncTransform(); LogRendertraceRect(GetGuid(), "viewport", "red", - CSSRect(mFrameMetrics.mScrollOffset, + CSSRect(mFrameMetrics.GetScrollOffset(), ParentLayerSize(mFrameMetrics.mCompositionBounds.Size()) / mFrameMetrics.GetZoomToParent())); - mCurrentAsyncScrollOffset = mFrameMetrics.mScrollOffset; + mCurrentAsyncScrollOffset = mFrameMetrics.GetScrollOffset(); } // Execute tasks queued up by mAnimation's Sample() (called by @@ -1642,10 +1642,10 @@ ViewTransform AsyncPanZoomController::GetCurrentAsyncTransform() { CSSPoint lastPaintScrollOffset; if (mLastContentPaintMetrics.IsScrollable()) { - lastPaintScrollOffset = mLastContentPaintMetrics.mScrollOffset; + lastPaintScrollOffset = mLastContentPaintMetrics.GetScrollOffset(); } - CSSPoint currentScrollOffset = mFrameMetrics.mScrollOffset + + CSSPoint currentScrollOffset = mFrameMetrics.GetScrollOffset() + mTestAsyncScrollOffset; // If checkerboarding has been disallowed, clamp the scroll position to stay @@ -1684,7 +1684,7 @@ gfx3DMatrix AsyncPanZoomController::GetNontransientAsyncTransform() { gfx3DMatrix AsyncPanZoomController::GetTransformToLastDispatchedPaint() { ReentrantMonitorAutoEnter lock(mMonitor); - LayerPoint scrollChange = (mLastContentPaintMetrics.mScrollOffset - mLastDispatchedPaintMetrics.mScrollOffset) + LayerPoint scrollChange = (mLastContentPaintMetrics.GetScrollOffset() - mLastDispatchedPaintMetrics.GetScrollOffset()) * mLastContentPaintMetrics.LayersPixelsPerCSSPixel(); float zoomChange = mLastContentPaintMetrics.mZoom.scale / mLastDispatchedPaintMetrics.mZoom.scale; return gfx3DMatrix::Translation(scrollChange.x, scrollChange.y, 0) * @@ -1703,7 +1703,7 @@ void AsyncPanZoomController::NotifyLayersUpdated(const FrameMetrics& aLayerMetri LogRendertraceRect(GetGuid(), "page", "brown", aLayerMetrics.mScrollableRect); LogRendertraceRect(GetGuid(), "painted displayport", "green", - aLayerMetrics.mDisplayPort + aLayerMetrics.mScrollOffset); + aLayerMetrics.mDisplayPort + aLayerMetrics.GetScrollOffset()); mPaintThrottler.TaskComplete(GetFrameTime()); bool needContentRepaint = false; @@ -1760,7 +1760,7 @@ void AsyncPanZoomController::NotifyLayersUpdated(const FrameMetrics& aLayerMetri mFrameMetrics.mScrollOffset.x, mFrameMetrics.mScrollOffset.y, aLayerMetrics.mScrollOffset.x, aLayerMetrics.mScrollOffset.y); - mFrameMetrics.mScrollOffset = aLayerMetrics.mScrollOffset; + mFrameMetrics.SetScrollOffset(aLayerMetrics.GetScrollOffset()); // Because of the scroll offset update, any inflight paint requests are // going to be ignored by layout, and so mLastDispatchedPaintMetrics @@ -1807,7 +1807,7 @@ void AsyncPanZoomController::ZoomToRect(CSSRect aRect) { ParentLayerIntRect compositionBounds = mFrameMetrics.mCompositionBounds; CSSRect cssPageRect = mFrameMetrics.mScrollableRect; - CSSPoint scrollOffset = mFrameMetrics.mScrollOffset; + CSSPoint scrollOffset = mFrameMetrics.GetScrollOffset(); CSSToParentLayerScale currentZoom = mFrameMetrics.GetZoomToParent(); CSSToParentLayerScale targetZoom; @@ -1867,16 +1867,16 @@ void AsyncPanZoomController::ZoomToRect(CSSRect aRect) { aRect.x = aRect.x > 0 ? aRect.x : 0; } - endZoomToMetrics.mScrollOffset = aRect.TopLeft(); + endZoomToMetrics.SetScrollOffset(aRect.TopLeft()); endZoomToMetrics.mDisplayPort = CalculatePendingDisplayPort(endZoomToMetrics, ScreenPoint(0,0), 0); StartAnimation(new ZoomAnimation( - mFrameMetrics.mScrollOffset, + mFrameMetrics.GetScrollOffset(), mFrameMetrics.mZoom, - endZoomToMetrics.mScrollOffset, + endZoomToMetrics.GetScrollOffset(), endZoomToMetrics.mZoom)); // Schedule a repaint now, so the new displayport will be painted before the diff --git a/gfx/layers/ipc/Axis.cpp b/gfx/layers/ipc/Axis.cpp index b25760f5ba51..3d08ae2faf1c 100644 --- a/gfx/layers/ipc/Axis.cpp +++ b/gfx/layers/ipc/Axis.cpp @@ -267,7 +267,7 @@ float Axis::GetPageEnd() { } float Axis::GetOrigin() { - CSSPoint origin = mAsyncPanZoomController->GetFrameMetrics().mScrollOffset; + CSSPoint origin = mAsyncPanZoomController->GetFrameMetrics().GetScrollOffset(); return GetPointOffset(origin); } diff --git a/gfx/tests/gtest/TestAsyncPanZoomController.cpp b/gfx/tests/gtest/TestAsyncPanZoomController.cpp index 32e28d953bc9..226f70922af4 100644 --- a/gfx/tests/gtest/TestAsyncPanZoomController.cpp +++ b/gfx/tests/gtest/TestAsyncPanZoomController.cpp @@ -349,7 +349,7 @@ TEST(AsyncPanZoomController, Pinch) { fm.mViewport = CSSRect(0, 0, 980, 480); fm.mCompositionBounds = ParentLayerIntRect(200, 200, 100, 200); fm.mScrollableRect = CSSRect(0, 0, 980, 1000); - fm.mScrollOffset = CSSPoint(300, 300); + fm.SetScrollOffset(CSSPoint(300, 300)); fm.mZoom = CSSToScreenScale(2.0); apzc->SetFrameMetrics(fm); apzc->UpdateZoomConstraints(ZoomConstraints(true, true, CSSToScreenScale(0.25), CSSToScreenScale(4.0))); @@ -363,13 +363,13 @@ TEST(AsyncPanZoomController, Pinch) { // the visible area of the document in CSS pixels is now x=305 y=310 w=40 h=80 fm = apzc->GetFrameMetrics(); EXPECT_EQ(fm.mZoom.scale, 2.5f); - EXPECT_EQ(fm.mScrollOffset.x, 305); - EXPECT_EQ(fm.mScrollOffset.y, 310); + EXPECT_EQ(fm.GetScrollOffset().x, 305); + EXPECT_EQ(fm.GetScrollOffset().y, 310); // part 2 of the test, move to the top-right corner of the page and pinch and // make sure we stay in the correct spot fm.mZoom = CSSToScreenScale(2.0); - fm.mScrollOffset = CSSPoint(930, 5); + fm.SetScrollOffset(CSSPoint(930, 5)); apzc->SetFrameMetrics(fm); // the visible area of the document in CSS pixels is x=930 y=5 w=50 h=100 @@ -378,8 +378,8 @@ TEST(AsyncPanZoomController, Pinch) { // the visible area of the document in CSS pixels is now x=880 y=0 w=100 h=200 fm = apzc->GetFrameMetrics(); EXPECT_EQ(fm.mZoom.scale, 1.0f); - EXPECT_EQ(fm.mScrollOffset.x, 880); - EXPECT_EQ(fm.mScrollOffset.y, 0); + EXPECT_EQ(fm.GetScrollOffset().x, 880); + EXPECT_EQ(fm.GetScrollOffset().y, 0); apzc->Destroy(); } @@ -392,7 +392,7 @@ TEST(AsyncPanZoomController, PinchWithTouchActionNone) { fm.mViewport = CSSRect(0, 0, 980, 480); fm.mCompositionBounds = ParentLayerIntRect(200, 200, 100, 200); fm.mScrollableRect = CSSRect(0, 0, 980, 1000); - fm.mScrollOffset = CSSPoint(300, 300); + fm.SetScrollOffset(CSSPoint(300, 300)); fm.mZoom = CSSToScreenScale(2.0); apzc->SetFrameMetrics(fm); // the visible area of the document in CSS pixels is x=300 y=300 w=50 h=100 @@ -414,8 +414,8 @@ TEST(AsyncPanZoomController, PinchWithTouchActionNone) { // apzc ignore pinch gestures. fm = apzc->GetFrameMetrics(); EXPECT_EQ(fm.mZoom.scale, 2.0f); - EXPECT_EQ(fm.mScrollOffset.x, 300); - EXPECT_EQ(fm.mScrollOffset.y, 300); + EXPECT_EQ(fm.GetScrollOffset().x, 300); + EXPECT_EQ(fm.GetScrollOffset().y, 300); } TEST(AsyncPanZoomController, Overzoom) { @@ -426,7 +426,7 @@ TEST(AsyncPanZoomController, Overzoom) { fm.mViewport = CSSRect(0, 0, 100, 100); fm.mCompositionBounds = ParentLayerIntRect(0, 0, 100, 100); fm.mScrollableRect = CSSRect(0, 0, 125, 150); - fm.mScrollOffset = CSSPoint(10, 0); + fm.SetScrollOffset(CSSPoint(10, 0)); fm.mZoom = CSSToScreenScale(1.0); apzc->SetFrameMetrics(fm); apzc->UpdateZoomConstraints(ZoomConstraints(true, true, CSSToScreenScale(0.25), CSSToScreenScale(4.0))); @@ -441,8 +441,8 @@ TEST(AsyncPanZoomController, Overzoom) { EXPECT_EQ(fm.mZoom.scale, 0.8f); // bug 936721 - PGO builds introduce rounding error so // use a fuzzy match instead - EXPECT_LT(abs(fm.mScrollOffset.x), 1e-5); - EXPECT_LT(abs(fm.mScrollOffset.y), 1e-5); + EXPECT_LT(abs(fm.GetScrollOffset().x), 1e-5); + EXPECT_LT(abs(fm.GetScrollOffset().y), 1e-5); } TEST(AsyncPanZoomController, SimpleTransform) { @@ -505,7 +505,7 @@ TEST(AsyncPanZoomController, ComplexTransform) { metrics.mCompositionBounds = ParentLayerIntRect(0, 0, 24, 24); metrics.mDisplayPort = CSSRect(-1, -1, 6, 6); metrics.mViewport = CSSRect(0, 0, 4, 4); - metrics.mScrollOffset = CSSPoint(10, 10); + metrics.SetScrollOffset(CSSPoint(10, 10)); metrics.mScrollableRect = CSSRect(0, 0, 50, 50); metrics.mCumulativeResolution = LayoutDeviceToLayerScale(2); metrics.mResolution = ParentLayerToLayerScale(2); @@ -539,13 +539,13 @@ TEST(AsyncPanZoomController, ComplexTransform) { EXPECT_EQ(ScreenPoint(60, 60), pointOut); // do an async scroll by 5 pixels and check the transform - metrics.mScrollOffset += CSSPoint(5, 0); + metrics.ScrollBy(CSSPoint(5, 0)); apzc->SetFrameMetrics(metrics); apzc->SampleContentTransformForFrame(testStartTime, &viewTransformOut, pointOut); EXPECT_EQ(ViewTransform(LayerPoint(-30, 0), ParentLayerToScreenScale(2)), viewTransformOut); EXPECT_EQ(ScreenPoint(90, 60), pointOut); - childMetrics.mScrollOffset += CSSPoint(5, 0); + childMetrics.ScrollBy(CSSPoint(5, 0)); childApzc->SetFrameMetrics(childMetrics); childApzc->SampleContentTransformForFrame(testStartTime, &viewTransformOut, pointOut); EXPECT_EQ(ViewTransform(LayerPoint(-30, 0), ParentLayerToScreenScale(2)), viewTransformOut); @@ -932,7 +932,7 @@ SetScrollableFrameMetrics(Layer* aLayer, FrameMetrics::ViewID aScrollId, metrics.mCompositionBounds = ParentLayerIntRect(layerBound.x, layerBound.y, layerBound.width, layerBound.height); metrics.mScrollableRect = aScrollableRect; - metrics.mScrollOffset = CSSPoint(0, 0); + metrics.SetScrollOffset(CSSPoint(0, 0)); container->SetFrameMetrics(metrics); } diff --git a/layout/base/nsDisplayList.cpp b/layout/base/nsDisplayList.cpp index dd7809109678..457acb905bc7 100644 --- a/layout/base/nsDisplayList.cpp +++ b/layout/base/nsDisplayList.cpp @@ -682,7 +682,7 @@ static void RecordFrameMetrics(nsIFrame* aForFrame, contentBounds.width += scrollableFrame->GetScrollPortRect().width; contentBounds.height += scrollableFrame->GetScrollPortRect().height; metrics.mScrollableRect = CSSRect::FromAppUnits(contentBounds); - metrics.mScrollOffset = CSSPoint::FromAppUnits(scrollPosition); + metrics.SetScrollOffset(CSSPoint::FromAppUnits(scrollPosition)); // If the frame was scrolled since the last layers update, and by // something other than the APZ code, we want to tell the APZ to update diff --git a/layout/ipc/RenderFrameParent.cpp b/layout/ipc/RenderFrameParent.cpp index ec251fea2cc0..c6d4d61bfbc5 100644 --- a/layout/ipc/RenderFrameParent.cpp +++ b/layout/ipc/RenderFrameParent.cpp @@ -422,8 +422,8 @@ BuildViewMap(ViewMap& oldContentViews, ViewMap& newContentViews, // The default scale is 1, so no need to propagate scale down. ViewConfig config; config.mScrollOffset = nsPoint( - NSIntPixelsToAppUnits(metrics.mScrollOffset.x, auPerCSSPixel) * aXScale, - NSIntPixelsToAppUnits(metrics.mScrollOffset.y, auPerCSSPixel) * aYScale); + NSIntPixelsToAppUnits(metrics.GetScrollOffset().x, auPerCSSPixel) * aXScale, + NSIntPixelsToAppUnits(metrics.GetScrollOffset().y, auPerCSSPixel) * aYScale); view = new nsContentView(aFrameLoader, scrollId, metrics.mIsRoot, config); view->mParentScaleX = aAccConfigXScale; view->mParentScaleY = aAccConfigYScale; diff --git a/widget/android/AndroidBridge.cpp b/widget/android/AndroidBridge.cpp index 08cd891b5995..bc24c83efac1 100644 --- a/widget/android/AndroidBridge.cpp +++ b/widget/android/AndroidBridge.cpp @@ -1881,7 +1881,7 @@ AndroidBridge::RequestContentRepaint(const mozilla::layers::FrameMetrics& aFrame ALOG_BRIDGE("AndroidBridge::RequestContentRepaint"); CSSToScreenScale resolution = aFrameMetrics.mZoom; - ScreenRect dp = (aFrameMetrics.mDisplayPort + aFrameMetrics.mScrollOffset) * resolution; + ScreenRect dp = (aFrameMetrics.mDisplayPort + aFrameMetrics.GetScrollOffset()) * resolution; mNativePanZoomController->RequestContentRepaintWrapper(dp.x, dp.y, dp.width, dp.height, resolution.scale); } diff --git a/widget/xpwidgets/APZCCallbackHelper.cpp b/widget/xpwidgets/APZCCallbackHelper.cpp index 60ce0b09ed29..e22cbe792f6b 100644 --- a/widget/xpwidgets/APZCCallbackHelper.cpp +++ b/widget/xpwidgets/APZCCallbackHelper.cpp @@ -68,7 +68,7 @@ MaybeAlignAndClampDisplayPort(mozilla::layers::FrameMetrics& aFrameMetrics, // Correct the display-port by the difference between the requested scroll // offset and the resulting scroll offset after setting the requested value. CSSRect& displayPort = aFrameMetrics.mDisplayPort; - displayPort += aFrameMetrics.mScrollOffset - aActualScrollOffset; + displayPort += aFrameMetrics.GetScrollOffset() - aActualScrollOffset; // Expand the display port to the next tile boundaries, if tiled thebes layers // are enabled. @@ -162,7 +162,7 @@ APZCCallbackHelper::UpdateRootFrame(nsIDOMWindowUtils* aUtils, // Scroll the window to the desired spot nsIScrollableFrame* sf = nsLayoutUtils::FindScrollableFrameFor(aMetrics.mScrollId); bool scrollUpdated = false; - CSSPoint actualScrollOffset = ScrollFrameTo(sf, aMetrics.mScrollOffset, scrollUpdated); + CSSPoint actualScrollOffset = ScrollFrameTo(sf, aMetrics.GetScrollOffset(), scrollUpdated); if (!scrollUpdated) { // For whatever reason we couldn't update the scroll offset on the scroll frame, @@ -179,7 +179,7 @@ APZCCallbackHelper::UpdateRootFrame(nsIDOMWindowUtils* aUtils, // enabled), and clamp it to the scrollable rect. MaybeAlignAndClampDisplayPort(aMetrics, actualScrollOffset); - aMetrics.mScrollOffset = actualScrollOffset; + aMetrics.SetScrollOffset(actualScrollOffset); // The mZoom variable on the frame metrics stores the CSS-to-screen scale for this // frame. This scale includes all of the (cumulative) resolutions set on the presShells @@ -232,7 +232,7 @@ APZCCallbackHelper::UpdateSubFrame(nsIContent* aContent, nsIScrollableFrame* sf = nsLayoutUtils::FindScrollableFrameFor(aMetrics.mScrollId); bool scrollUpdated = false; - CSSPoint actualScrollOffset = ScrollFrameTo(sf, aMetrics.mScrollOffset, scrollUpdated); + CSSPoint actualScrollOffset = ScrollFrameTo(sf, aMetrics.GetScrollOffset(), scrollUpdated); nsCOMPtr element = do_QueryInterface(aContent); if (element) { @@ -247,7 +247,7 @@ APZCCallbackHelper::UpdateSubFrame(nsIContent* aContent, element, 0); } - aMetrics.mScrollOffset = actualScrollOffset; + aMetrics.SetScrollOffset(actualScrollOffset); } already_AddRefed @@ -338,7 +338,7 @@ APZCCallbackHelper::UpdateCallbackTransform(const FrameMetrics& aApzcMetrics, co if (!content) { return; } - CSSPoint scrollDelta = aApzcMetrics.mScrollOffset - aActualMetrics.mScrollOffset; + CSSPoint scrollDelta = aApzcMetrics.GetScrollOffset() - aActualMetrics.GetScrollOffset(); content->SetProperty(nsGkAtoms::apzCallbackTransform, new CSSPoint(scrollDelta), DestroyCSSPoint); }