wine/gecko
0
0
Fork 0
mirror of https://gitlab.winehq.org/wine/wine-gecko.git synced 2024-09-13 09:24:08 -07:00
Code Issues Packages Projects Releases Wiki Activity

Bug 1160566 - Make FrameMetrics.mCompositionBounds private and add a getter/setter for it. r=botond

Browse Source
This commit is contained in:
Kartikaya Gupta 2015-05-07 14:44:03 -04:00
parent e598c796f0
commit 0a1d70ba2d
13 changed files with 78 additions and 70 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
dom/ipc/TabChild.cpp
View File

@ -195,9 +195,9 @@ TabChildBase::InitializeRootMetrics()
// be keeping, as well as putting the scroll offset back to
// the top-left of the page.
mLastRootMetrics.SetViewport(CSSRect(CSSPoint(), kDefaultViewportSize));
mLastRootMetrics.mCompositionBounds = ParentLayerRect(
mLastRootMetrics.SetCompositionBounds(ParentLayerRect(
ParentLayerPoint(),
ParentLayerSize(ViewAs<ParentLayerPixel>(mInnerSize, PixelCastJustification::ScreenIsParentLayerForRoot)));
ParentLayerSize(ViewAs<ParentLayerPixel>(mInnerSize, PixelCastJustification::ScreenIsParentLayerForRoot))));
mLastRootMetrics.SetZoom(CSSToParentLayerScale2D(mLastRootMetrics.CalculateIntrinsicScale()));
mLastRootMetrics.SetDevPixelsPerCSSPixel(WebWidget()->GetDefaultScale());
// We use ParentLayerToLayerScale(1) below in order to turn the
@ -336,9 +336,9 @@ TabChildBase::HandlePossibleViewportChange(const ScreenIntSize& aOldScreenSize)
FrameMetrics metrics(mLastRootMetrics);
metrics.SetViewport(CSSRect(CSSPoint(), viewport));
metrics.mCompositionBounds = ParentLayerRect(
metrics.SetCompositionBounds(ParentLayerRect(
ParentLayerPoint(),
ParentLayerSize(ViewAs<ParentLayerPixel>(mInnerSize, PixelCastJustification::ScreenIsParentLayerForRoot)));
ParentLayerSize(ViewAs<ParentLayerPixel>(mInnerSize, PixelCastJustification::ScreenIsParentLayerForRoot))));
metrics.SetRootCompositionSize(
ScreenSize(mInnerSize) * ScreenToLayoutDeviceScale(1.0f) / metrics.GetDevPixelsPerCSSPixel());

52
gfx/layers/FrameMetrics.h
View File

@ -39,8 +39,8 @@ public:
static const FrameMetrics sNullMetrics; // We often need an empty metrics
FrameMetrics()
: mCompositionBounds(0, 0, 0, 0)
, mPresShellResolution(1)
: mPresShellResolution(1)
, mCompositionBounds(0, 0, 0, 0)
, mDisplayPort(0, 0, 0, 0)
, mCriticalDisplayPort(0, 0, 0, 0)
, mScrollableRect(0, 0, 0, 0)
@ -239,27 +239,6 @@ public:
return copy;
}
// ---------------------------------------------------------------------------
// The following metrics are all in widget space/device pixels.
//
// This is the area within the widget that we're compositing to. It is in the
// same coordinate space as the reference frame for the scrolled frame.
//
// This is useful because, on mobile, the viewport and composition dimensions
// are not always the same. In this case, we calculate the displayport using
// an area bigger than the region we're compositing to. If we used the
// viewport dimensions to calculate the displayport, we'd run into situations
// where we're prerendering the wrong regions and the content may be clipped,
// or too much of it prerendered. If the composition dimensions are the same as the
// viewport dimensions, there is no need for this and we can just use the viewport
// instead.
//
// This value is valid for nested scrollable layers as well, and is still
// relative to the layer tree origin. This value is provided by Gecko at
// layout/paint time.
ParentLayerRect mCompositionBounds;
public:
void SetPresShellResolution(float aPresShellResolution)
{
@ -271,6 +250,16 @@ public:
return mPresShellResolution;
}
void SetCompositionBounds(const ParentLayerRect& aCompositionBounds)
{
mCompositionBounds = aCompositionBounds;
}
const ParentLayerRect& GetCompositionBounds() const
{
return mCompositionBounds;
}
void SetDisplayPort(const CSSRect& aDisplayPort)
{
mDisplayPort = aDisplayPort;
@ -539,6 +528,23 @@ private:
// it does not convert between any coordinate spaces for which we have names.
float mPresShellResolution;
// This is the area within the widget that we're compositing to. It is in the
// same coordinate space as the reference frame for the scrolled frame.
//
// This is useful because, on mobile, the viewport and composition dimensions
// are not always the same. In this case, we calculate the displayport using
// an area bigger than the region we're compositing to. If we used the
// viewport dimensions to calculate the displayport, we'd run into situations
// where we're prerendering the wrong regions and the content may be clipped,
// or too much of it prerendered. If the composition dimensions are the same
// as the viewport dimensions, there is no need for this and we can just use
// the viewport instead.
//
// This value is valid for nested scrollable layers as well, and is still
// relative to the layer tree origin. This value is provided by Gecko at
// layout/paint time.
ParentLayerRect mCompositionBounds;
// The area of a frame's contents that has been painted, relative to
// mCompositionBounds.
//

2
gfx/layers/LayersLogging.cpp
View File

@ -169,7 +169,7 @@ AppendToString(std::stringstream& aStream, const FrameMetrics& m,
const char* pfx, const char* sfx, bool detailed)
{
aStream << pfx;
AppendToString(aStream, m.mCompositionBounds, "{ [cb=");
AppendToString(aStream, m.GetCompositionBounds(), "{ [cb=");
AppendToString(aStream, m.GetScrollableRect(), "] [sr=");
AppendToString(aStream, m.GetScrollOffset(), "] [s=");
if (m.GetDoSmoothScroll()) {

7
gfx/layers/apz/src/APZCTreeManager.cpp
View File

@ -209,7 +209,7 @@ ComputeClipRegion(GeckoContentController* aController,
// root scrollable layer in a process, or for some of the LayerMetrics
// expansions of a multi-metrics layer), fall back to using the comp
// bounds which should be equivalent.
clipRegion = RoundedToInt(aLayer.Metrics().mCompositionBounds);
clipRegion = RoundedToInt(aLayer.Metrics().GetCompositionBounds());
}
// Optionally, the GeckoContentController can provide a touch-sensitive
@ -244,7 +244,8 @@ APZCTreeManager::PrintAPZCInfo(const LayerMetricsWrapper& aLayer,
const AsyncPanZoomController* apzc)
{
const FrameMetrics& metrics = aLayer.Metrics();
mApzcTreeLog << "APZC " << apzc->GetGuid() << "\tcb=" << metrics.mCompositionBounds
mApzcTreeLog << "APZC " << apzc->GetGuid()
<< "\tcb=" << metrics.GetCompositionBounds()
<< "\tsr=" << metrics.GetScrollableRect()
<< (aLayer.IsScrollInfoLayer() ? "\tscrollinfo" : "")
<< (apzc->HasScrollgrab() ? "\tscrollgrab" : "") << "\t"
@ -272,7 +273,7 @@ GetEventRegions(const LayerMetricsWrapper& aLayer)
{
if (aLayer.IsScrollInfoLayer()) {
return EventRegions(nsIntRegion(ParentLayerIntRect::ToUntyped(
RoundedToInt(aLayer.Metrics().mCompositionBounds))));
RoundedToInt(aLayer.Metrics().GetCompositionBounds()))));
}
return aLayer.GetEventRegions();
}

20
gfx/layers/apz/src/AsyncPanZoomController.cpp
View File

@ -1273,7 +1273,7 @@ nsEventStatus AsyncPanZoomController::OnScaleBegin(const PinchGestureInput& aEve
SetState(PINCHING);
mX.SetVelocity(0);
mY.SetVelocity(0);
mLastZoomFocus = aEvent.mLocalFocusPoint - mFrameMetrics.mCompositionBounds.TopLeft();
mLastZoomFocus = aEvent.mLocalFocusPoint - mFrameMetrics.GetCompositionBounds().TopLeft();
return nsEventStatus_eConsumeNoDefault;
}
@ -1309,7 +1309,7 @@ nsEventStatus AsyncPanZoomController::OnScale(const PinchGestureInput& aEvent) {
ReentrantMonitorAutoEnter lock(mMonitor);
CSSToParentLayerScale userZoom = mFrameMetrics.GetZoom().ToScaleFactor();
ParentLayerPoint focusPoint = aEvent.mLocalFocusPoint - mFrameMetrics.mCompositionBounds.TopLeft();
ParentLayerPoint focusPoint = aEvent.mLocalFocusPoint - mFrameMetrics.GetCompositionBounds().TopLeft();
CSSPoint cssFocusPoint = focusPoint / mFrameMetrics.GetZoom();
CSSPoint focusChange = (mLastZoomFocus - focusPoint) / userZoom;
@ -1327,9 +1327,9 @@ nsEventStatus AsyncPanZoomController::OnScale(const PinchGestureInput& aEvent) {
CSSToParentLayerScale realMinZoom = mZoomConstraints.mMinZoom;
CSSToParentLayerScale realMaxZoom = mZoomConstraints.mMaxZoom;
realMinZoom.scale = std::max(realMinZoom.scale,
mFrameMetrics.mCompositionBounds.width / mFrameMetrics.GetScrollableRect().width);
mFrameMetrics.GetCompositionBounds().width / mFrameMetrics.GetScrollableRect().width);
realMinZoom.scale = std::max(realMinZoom.scale,
mFrameMetrics.mCompositionBounds.height / mFrameMetrics.GetScrollableRect().height);
mFrameMetrics.GetCompositionBounds().height / mFrameMetrics.GetScrollableRect().height);
if (realMaxZoom < realMinZoom) {
realMaxZoom = realMinZoom;
}
@ -1851,7 +1851,7 @@ bool AsyncPanZoomController::Contains(const ScreenIntPoint& aPoint) const
ParentLayerIntRect cb;
{
ReentrantMonitorAutoEnter lock(mMonitor);
GetFrameMetrics().mCompositionBounds.ToIntRect(&cb);
GetFrameMetrics().GetCompositionBounds().ToIntRect(&cb);
}
return cb.Contains(point);
}
@ -2810,8 +2810,8 @@ void AsyncPanZoomController::NotifyLayersUpdated(const FrameMetrics& aLayerMetri
mPaintThrottler.TaskComplete(GetFrameTime());
bool needContentRepaint = false;
bool viewportUpdated = false;
if (FuzzyEqualsAdditive(aLayerMetrics.mCompositionBounds.width, mFrameMetrics.mCompositionBounds.width) &&
FuzzyEqualsAdditive(aLayerMetrics.mCompositionBounds.height, mFrameMetrics.mCompositionBounds.height)) {
if (FuzzyEqualsAdditive(aLayerMetrics.GetCompositionBounds().width, mFrameMetrics.GetCompositionBounds().width) &&
FuzzyEqualsAdditive(aLayerMetrics.GetCompositionBounds().height, mFrameMetrics.GetCompositionBounds().height)) {
// Remote content has sync'd up to the composition geometry
// change, so we can accept the viewport it's calculated.
if (mFrameMetrics.GetViewport().width != aLayerMetrics.GetViewport().width ||
@ -2857,7 +2857,7 @@ void AsyncPanZoomController::NotifyLayersUpdated(const FrameMetrics& aLayerMetri
// in some things into our local mFrameMetrics because these things are
// determined by Gecko and our copy in mFrameMetrics may be stale.
if (FuzzyEqualsAdditive(mFrameMetrics.mCompositionBounds.width, aLayerMetrics.mCompositionBounds.width) &&
if (FuzzyEqualsAdditive(mFrameMetrics.GetCompositionBounds().width, aLayerMetrics.GetCompositionBounds().width) &&
mFrameMetrics.GetDevPixelsPerCSSPixel() == aLayerMetrics.GetDevPixelsPerCSSPixel() &&
!viewportUpdated) {
// Any change to the pres shell resolution was requested by APZ and is
@ -2883,7 +2883,7 @@ void AsyncPanZoomController::NotifyLayersUpdated(const FrameMetrics& aLayerMetri
mFrameMetrics.SetScrollableRect(aLayerMetrics.GetScrollableRect());
needContentRepaint = true;
}
mFrameMetrics.mCompositionBounds = aLayerMetrics.mCompositionBounds;
mFrameMetrics.SetCompositionBounds(aLayerMetrics.GetCompositionBounds());
mFrameMetrics.SetRootCompositionSize(aLayerMetrics.GetRootCompositionSize());
mFrameMetrics.SetPresShellResolution(aLayerMetrics.GetPresShellResolution());
mFrameMetrics.SetCumulativeResolution(aLayerMetrics.GetCumulativeResolution());
@ -2986,7 +2986,7 @@ void AsyncPanZoomController::ZoomToRect(CSSRect aRect) {
{
ReentrantMonitorAutoEnter lock(mMonitor);
ParentLayerRect compositionBounds = mFrameMetrics.mCompositionBounds;
ParentLayerRect compositionBounds = mFrameMetrics.GetCompositionBounds();
CSSRect cssPageRect = mFrameMetrics.GetScrollableRect();
CSSPoint scrollOffset = mFrameMetrics.GetScrollOffset();
CSSToParentLayerScale currentZoom = mFrameMetrics.GetZoom().ToScaleFactor();

4
gfx/layers/apz/src/Axis.cpp
View File

@ -533,7 +533,7 @@ ParentLayerCoord Axis::GetOrigin() const {
}
ParentLayerCoord Axis::GetCompositionLength() const {
return GetRectLength(GetFrameMetrics().mCompositionBounds);
return GetRectLength(GetFrameMetrics().GetCompositionBounds());
}
ParentLayerCoord Axis::GetPageStart() const {
@ -548,7 +548,7 @@ ParentLayerCoord Axis::GetPageLength() const {
bool Axis::ScaleWillOverscrollBothSides(float aScale) const {
const FrameMetrics& metrics = GetFrameMetrics();
ParentLayerRect screenCompositionBounds = metrics.mCompositionBounds
ParentLayerRect screenCompositionBounds = metrics.GetCompositionBounds()
/ ParentLayerToParentLayerScale(aScale);
return GetRectLength(screenCompositionBounds) - GetPageLength() > COORDINATE_EPSILON;
}

4
gfx/layers/client/ClientTiledPaintedLayer.cpp
View File

@ -172,7 +172,7 @@ ClientTiledPaintedLayer::BeginPaint()
if (!hasTransformAnimation) {
ParentLayerRect criticalDisplayPort =
(displayportMetrics.GetCriticalDisplayPort() * displayportMetrics.GetZoom())
+ displayportMetrics.mCompositionBounds.TopLeft();
+ displayportMetrics.GetCompositionBounds().TopLeft();
mPaintData.mCriticalDisplayPort = RoundedToInt(
ApplyParentLayerToLayerTransform(transformDisplayPortToLayer, criticalDisplayPort));
}
@ -189,7 +189,7 @@ ClientTiledPaintedLayer::BeginPaint()
gfx::Matrix4x4 transformToBounds = mPaintData.mTransformToCompBounds;
transformToBounds.Invert();
mPaintData.mCompositionBounds = ApplyParentLayerToLayerTransform(
transformToBounds, scrollMetrics.mCompositionBounds);
transformToBounds, scrollMetrics.GetCompositionBounds());
TILING_LOG("TILING %p: Composition bounds %s\n", this, Stringify(mPaintData.mCompositionBounds).c_str());
// Calculate the scroll offset since the last transaction

2
gfx/layers/client/TiledContentClient.cpp
View File

@ -1350,7 +1350,7 @@ GetCompositorSideCompositionBounds(const LayerMetricsWrapper& aScrollAncestor,
{
Matrix4x4 transform = aTransformToCompBounds * Matrix4x4(aAPZTransform);
return TransformTo<LayerPixel>(transform.Inverse(),
aScrollAncestor.Metrics().mCompositionBounds);
aScrollAncestor.Metrics().GetCompositionBounds());
}
bool

18
gfx/layers/composite/AsyncCompositionManager.cpp
View File

@ -642,7 +642,7 @@ AsyncCompositionManager::ApplyAsyncContentTransformToTree(Layer *aLayer)
ParentLayerRect transformed = TransformTo<ParentLayerPixel>(
(Matrix4x4(asyncTransformWithoutOverscroll) * overscrollTransform),
ParentLayerRect(*clipRect));
clipRect = Some(RoundedOut(transformed.Intersect(metrics.mCompositionBounds)));
clipRect = Some(RoundedOut(transformed.Intersect(metrics.GetCompositionBounds())));
}
}
@ -1010,28 +1010,28 @@ AsyncCompositionManager::TransformScrollableLayer(Layer* aLayer)
Point3D overscrollTranslation;
if (userScroll.x < contentScreenRect.x) {
overscrollTranslation.x = contentScreenRect.x - userScroll.x;
} else if (userScroll.x + metrics.mCompositionBounds.width > contentScreenRect.XMost()) {
} else if (userScroll.x + metrics.GetCompositionBounds().width > contentScreenRect.XMost()) {
overscrollTranslation.x = contentScreenRect.XMost() -
(userScroll.x + metrics.mCompositionBounds.width);
(userScroll.x + metrics.GetCompositionBounds().width);
}
if (userScroll.y < contentScreenRect.y) {
overscrollTranslation.y = contentScreenRect.y - userScroll.y;
} else if (userScroll.y + metrics.mCompositionBounds.height > contentScreenRect.YMost()) {
} else if (userScroll.y + metrics.GetCompositionBounds().height > contentScreenRect.YMost()) {
overscrollTranslation.y = contentScreenRect.YMost() -
(userScroll.y + metrics.mCompositionBounds.height);
(userScroll.y + metrics.GetCompositionBounds().height);
}
oldTransform.PreTranslate(overscrollTranslation.x,
overscrollTranslation.y,
overscrollTranslation.z);
gfx::Size underZoomScale(1.0f, 1.0f);
if (mContentRect.width * userZoom.scale < metrics.mCompositionBounds.width) {
if (mContentRect.width * userZoom.scale < metrics.GetCompositionBounds().width) {
underZoomScale.width = (mContentRect.width * userZoom.scale) /
metrics.mCompositionBounds.width;
metrics.GetCompositionBounds().width;
}
if (mContentRect.height * userZoom.scale < metrics.mCompositionBounds.height) {
if (mContentRect.height * userZoom.scale < metrics.GetCompositionBounds().height) {
underZoomScale.height = (mContentRect.height * userZoom.scale) /
metrics.mCompositionBounds.height;
metrics.GetCompositionBounds().height;
}
oldTransform.PreScale(underZoomScale.width, underZoomScale.height, 1);

2
gfx/layers/composite/ContainerLayerComposite.cpp
View File

@ -396,7 +396,7 @@ RenderLayers(ContainerT* aContainer,
if (layer->GetFrameMetrics(i - 1).IsScrollable()) {
// Since the composition bounds are in the parent layer's coordinates,
// use the parent's effective transform rather than the layer's own.
ParentLayerRect compositionBounds = layer->GetFrameMetrics(i - 1).mCompositionBounds;
ParentLayerRect compositionBounds = layer->GetFrameMetrics(i - 1).GetCompositionBounds();
aManager->GetCompositor()->DrawDiagnostics(DiagnosticFlags::CONTAINER,
compositionBounds.ToUnknownRect(),
gfx::Rect(aClipRect.ToUnknownRect()),

2
gfx/layers/composite/LayerManagerComposite.cpp
View File

@ -1075,7 +1075,7 @@ LayerManagerComposite::ComputeRenderIntegrity()
// the root layer.
rootMetrics = LayerMetricsWrapper(root).Metrics();
}
ParentLayerIntRect bounds = RoundedToInt(rootMetrics.mCompositionBounds);
ParentLayerIntRect bounds = RoundedToInt(rootMetrics.GetCompositionBounds());
IntRect screenRect(bounds.x,
bounds.y,
bounds.width,

12
gfx/tests/gtest/TestAsyncPanZoomController.cpp
View File

@ -227,7 +227,7 @@ TestFrameMetrics()
FrameMetrics fm;
fm.SetDisplayPort(CSSRect(0, 0, 10, 10));
fm.mCompositionBounds = ParentLayerRect(0, 0, 10, 10);
fm.SetCompositionBounds(ParentLayerRect(0, 0, 10, 10));
fm.SetCriticalDisplayPort(CSSRect(0, 0, 10, 10));
fm.SetScrollableRect(CSSRect(0, 0, 100, 100));
@ -706,7 +706,7 @@ protected:
FrameMetrics GetPinchableFrameMetrics()
{
FrameMetrics fm;
fm.mCompositionBounds = ParentLayerRect(200, 200, 100, 200);
fm.SetCompositionBounds(ParentLayerRect(200, 200, 100, 200));
fm.SetScrollableRect(CSSRect(0, 0, 980, 1000));
fm.SetScrollOffset(CSSPoint(300, 300));
fm.SetZoom(CSSToParentLayerScale2D(2.0, 2.0));
@ -852,7 +852,7 @@ TEST_F(APZCPinchGestureDetectorTester, Pinch_PreventDefault) {
TEST_F(APZCBasicTester, Overzoom) {
// the visible area of the document in CSS pixels is x=10 y=0 w=100 h=100
FrameMetrics fm;
fm.mCompositionBounds = ParentLayerRect(0, 0, 100, 100);
fm.SetCompositionBounds(ParentLayerRect(0, 0, 100, 100));
fm.SetScrollableRect(CSSRect(0, 0, 125, 150));
fm.SetScrollOffset(CSSPoint(10, 0));
fm.SetZoom(CSSToParentLayerScale2D(1.0, 1.0));
@ -920,7 +920,7 @@ TEST_F(APZCBasicTester, ComplexTransform) {
nsRefPtr<Layer> root = CreateLayerTree(layerTreeSyntax, layerVisibleRegion, transforms, lm, layers);
FrameMetrics metrics;
metrics.mCompositionBounds = ParentLayerRect(0, 0, 24, 24);
metrics.SetCompositionBounds(ParentLayerRect(0, 0, 24, 24));
metrics.SetDisplayPort(CSSRect(-1, -1, 6, 6));
metrics.SetScrollOffset(CSSPoint(10, 10));
metrics.SetScrollableRect(CSSRect(0, 0, 50, 50));
@ -1866,8 +1866,8 @@ protected:
FrameMetrics metrics;
metrics.SetScrollId(aScrollId);
IntRect layerBound = aLayer->GetVisibleRegion().GetBounds();
metrics.mCompositionBounds = ParentLayerRect(layerBound.x, layerBound.y,
layerBound.width, layerBound.height);
metrics.SetCompositionBounds(ParentLayerRect(layerBound.x, layerBound.y,
layerBound.width, layerBound.height));
metrics.SetScrollableRect(aScrollableRect);
metrics.SetScrollOffset(CSSPoint(0, 0));
aLayer->SetFrameMetrics(metrics);

15
layout/base/nsLayoutUtils.cpp
View File

@ -2909,10 +2909,10 @@ CalculateFrameMetricsForDisplayPort(nsIScrollableFrame* aScrollFrame) {
} else {
compBoundsScale = cumulativeResolution * layerToParentLayerScale;
}
metrics.mCompositionBounds
= LayoutDeviceRect::FromAppUnits(nsRect(nsPoint(0, 0), compositionSize),
metrics.SetCompositionBounds(
LayoutDeviceRect::FromAppUnits(nsRect(nsPoint(0, 0), compositionSize),
presContext->AppUnitsPerDevPixel())
* compBoundsScale;
* compBoundsScale);
metrics.SetRootCompositionSize(
nsLayoutUtils::CalculateRootCompositionSize(frame, false, metrics));
@ -7720,7 +7720,7 @@ nsLayoutUtils::CalculateRootCompositionSize(nsIFrame* aFrame,
{
if (aIsRootContentDocRootScrollFrame) {
return ViewAs<LayerPixel>(aMetrics.mCompositionBounds.Size(),
return ViewAs<LayerPixel>(aMetrics.GetCompositionBounds().Size(),
PixelCastJustification::ParentLayerToLayerForRootComposition)
* LayerToScreenScale(1.0f)
/ aMetrics.DisplayportPixelsPerCSSPixel();
@ -8271,7 +8271,6 @@ nsLayoutUtils::ComputeFrameMetrics(nsIFrame* aForFrame,
ParentLayerRect frameBounds = LayoutDeviceRect::FromAppUnits(compositionBounds, auPerDevPixel)
* metrics.GetCumulativeResolution()
* layerToParentLayerScale;
metrics.mCompositionBounds = frameBounds;
// For the root scroll frame of the root content document (RCD-RSF), the above calculation
// will yield the size of the viewport frame as the composition bounds, which
@ -8285,7 +8284,7 @@ nsLayoutUtils::ComputeFrameMetrics(nsIFrame* aForFrame,
bool isRootContentDocRootScrollFrame = isRootScrollFrame
&& presContext->IsRootContentDocument();
if (isRootContentDocRootScrollFrame) {
UpdateCompositionBoundsForRCDRSF(metrics.mCompositionBounds, presContext,
UpdateCompositionBoundsForRCDRSF(frameBounds, presContext,
compositionBounds, true, metrics.GetCumulativeResolution());
}
@ -8294,9 +8293,11 @@ nsLayoutUtils::ComputeFrameMetrics(nsIFrame* aForFrame,
nsMargin sizes = scrollableFrame->GetActualScrollbarSizes();
// Scrollbars are not subject to scaling, so CSS pixels = layer pixels for them.
ParentLayerMargin boundMargins = CSSMargin::FromAppUnits(sizes) * CSSToParentLayerScale(1.0f);
metrics.mCompositionBounds.Deflate(boundMargins);
frameBounds.Deflate(boundMargins);
}
metrics.SetCompositionBounds(frameBounds);
metrics.SetRootCompositionSize(
nsLayoutUtils::CalculateRootCompositionSize(aScrollFrame ? aScrollFrame : aForFrame,
isRootContentDocRootScrollFrame, metrics));