Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-09 11:25:00 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Bug 1561825 - Make layout.* static prefs follow the naming convention. r=KrisWright

Browse Source 
Differential Revision: https://phabricator.services.mozilla.com/D36160

--HG--
extra : rebase_source : 25ec3d8bd549a9229ec8789f2ca604c27082f228
This commit is contained in:
Nicholas Nethercote 2019-06-27 16:28:25 +10:00
parent 4008f58653
commit 59dde0c47e
23 changed files with 122 additions and 107 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
dom/base/nsDOMWindowUtils.cpp
View File

@ -470,7 +470,7 @@ nsDOMWindowUtils::SetDisplayPortForElement(float aXPx, float aYPx,
new DisplayPortPropertyData(displayport, aPriority),
nsINode::DeleteProperty<DisplayPortPropertyData>);
if (StaticPrefs::LayoutUseContainersForRootFrames()) {
if (StaticPrefs::layout_scroll_root_frame_containers()) {
nsIFrame* rootScrollFrame = presShell->GetRootScrollFrame();
if (rootScrollFrame && aElement == rootScrollFrame->GetContent() &&
nsLayoutUtils::UsesAsyncScrolling(rootScrollFrame)) {

2
gfx/gl/GLContextProviderCGL.mm
View File

@ -98,7 +98,7 @@ bool GLContextCGL::MakeCurrentImpl() const {
// If swapInt is 1, then glSwapBuffers will block and wait for a vblank signal.
// When we're iterating as fast as possible, however, we want a non-blocking
// glSwapBuffers, which will happen when swapInt==0.
GLint swapInt = StaticPrefs::LayoutFrameRate() == 0 ? 0 : 1;
GLint swapInt = StaticPrefs::layout_frame_rate() == 0 ? 0 : 1;
[mContext setValues:&swapInt forParameter:NSOpenGLCPSwapInterval];
}
return true;

2
gfx/gl/GLContextProviderGLX.cpp
View File

@ -597,7 +597,7 @@ bool GLContextGLX::MakeCurrentImpl() const {
// Many GLX implementations default to blocking until the next
// VBlank when calling glXSwapBuffers. We want to run unthrottled
// in ASAP mode. See bug 1280744.
const bool isASAP = (StaticPrefs::LayoutFrameRate() == 0);
const bool isASAP = (StaticPrefs::layout_frame_rate() == 0);
mGLX->fSwapInterval(mDisplay, mDrawable, isASAP ? 0 : 1);
}
return succeeded;

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

@ -3322,7 +3322,7 @@ LayerToParentLayerMatrix4x4 APZCTreeManager::ComputeTransformForScrollThumb(
// content resolution, which requires some special handling.
bool scrollbarSubjectToResolution =
aMetrics.IsRootContent() &&
StaticPrefs::LayoutUseContainersForRootFrames();
StaticPrefs::layout_scroll_root_frame_containers();
// |asyncTransform| represents the amount by which we have scrolled and
// zoomed since the last paint. Because the scrollbar was sized and positioned

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

@ -3459,8 +3459,8 @@ void AsyncPanZoomController::SmoothScrollTo(const CSSPoint& aDestination) {
StartAnimation(new SmoothScrollAnimation(
*this, initialPosition, initialVelocity, destination,
StaticPrefs::ScrollBehaviorSpringConstant(),
StaticPrefs::ScrollBehaviorDampingRatio()));
StaticPrefs::layout_css_scroll_behavior_spring_constant(),
StaticPrefs::layout_css_scroll_behavior_damping_ratio()));
}
}

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

@ -85,7 +85,7 @@ static LayerToParentLayerMatrix4x4 GetTransformToAncestorsParentLayer(
iter = iter.GetParent()) {
transform = transform * iter.GetTransform();
if (StaticPrefs::LayoutUseContainersForRootFrames()) {
if (StaticPrefs::layout_scroll_root_frame_containers()) {
// When scrolling containers, layout adds a post-scale into the transform
// of the displayport-ancestor (which we pick up in GetTransform() above)
// to cancel out the pres shell resolution (for historical reasons). The

2
gfx/layers/ipc/CompositorBridgeParent.cpp
View File

@ -298,7 +298,7 @@ static int32_t CalculateCompositionFrameRate() {
StaticPrefs::layers_offmainthreadcomposition_frame_rate();
if (compositionFrameRatePref < 0) {
// Use the same frame rate for composition as for layout.
int32_t layoutFrameRatePref = StaticPrefs::LayoutFrameRate();
int32_t layoutFrameRatePref = StaticPrefs::layout_frame_rate();
if (layoutFrameRatePref < 0) {
// TODO: The main thread frame scheduling code consults the actual
// monitor refresh rate in this case. We should do the same.

2
gfx/layers/ipc/LayerTransactionParent.cpp
View File

@ -755,7 +755,7 @@ mozilla::ipc::IPCResult LayerTransactionParent::RecvGetTransform(
// containers are enabled, then the APZ transform might not be on |layer| but
// instead would be on the parent of |layer|, if that is the root scrollable
// metrics. So we special-case that behaviour.
if (StaticPrefs::LayoutUseContainersForRootFrames() &&
if (StaticPrefs::layout_scroll_root_frame_containers() &&
!layer->HasScrollableFrameMetrics() && layer->GetParent() &&
layer->GetParent()->HasRootScrollableFrameMetrics()) {
transform *= layer->GetParent()->AsHostLayer()->GetShadowBaseTransform();

8
gfx/thebes/gfxPlatform.cpp
View File

@ -990,7 +990,7 @@ void gfxPlatform::Init() {
gLastUsedFrameRate = ForceSoftwareVsync() ? GetSoftwareVsyncRate() : -1;
Preferences::RegisterCallback(
FrameRatePrefChanged,
nsDependentCString(StaticPrefs::GetLayoutFrameRatePrefName()));
nsDependentCString(StaticPrefs::Getlayout_frame_ratePrefName()));
// Set up the vsync source for the parent process.
ReInitFrameRate();
@ -3150,18 +3150,18 @@ bool gfxPlatform::IsInLayoutAsapMode() {
// the second is that the compositor goes ASAP and the refresh driver
// goes at whatever the configurated rate is. This only checks the version
// talos uses, which is the refresh driver and compositor are in lockstep.
return StaticPrefs::LayoutFrameRate() == 0;
return StaticPrefs::layout_frame_rate() == 0;
}
/* static */
bool gfxPlatform::ForceSoftwareVsync() {
return StaticPrefs::LayoutFrameRate() > 0 ||
return StaticPrefs::layout_frame_rate() > 0 ||
recordreplay::IsRecordingOrReplaying();
}
/* static */
int gfxPlatform::GetSoftwareVsyncRate() {
int preferenceRate = StaticPrefs::LayoutFrameRate();
int preferenceRate = StaticPrefs::layout_frame_rate();
if (preferenceRate <= 0) {
return gfxPlatform::GetDefaultFrameRate();
}

6
gfx/thebes/gfxUtils.cpp
View File

@ -1461,10 +1461,10 @@ void gfxUtils::RemoveShaderCacheFromDiskIfNecessary() {
/* static */
bool gfxUtils::DumpDisplayList() {
return StaticPrefs::LayoutDumpDisplayList() ||
(StaticPrefs::LayoutDumpDisplayListParent() &&
return StaticPrefs::layout_display_list_dump() ||
(StaticPrefs::layout_display_list_dump_parent() &&
XRE_IsParentProcess()) ||
(StaticPrefs::LayoutDumpDisplayListContent() &&
(StaticPrefs::layout_display_list_dump_content() &&
XRE_IsContentProcess());
}

4
layout/base/PresShell.cpp
View File

@ -3394,7 +3394,7 @@ static void ScrollToShowRect(PresShell* aPresShell,
bool smoothScroll = (aScrollFlags & ScrollFlags::ScrollSmooth) ||
((aScrollFlags & ScrollFlags::ScrollSmoothAuto) &&
autoBehaviorIsSmooth);
if (StaticPrefs::ScrollBehaviorEnabled() && smoothScroll) {
if (StaticPrefs::layout_css_scroll_behavior_enabled() && smoothScroll) {
scrollMode = ScrollMode::SmoothMsd;
}
nsIFrame* frame = do_QueryFrame(aFrameAsScrollable);
@ -5104,7 +5104,7 @@ void PresShell::AddCanvasBackgroundColorItem(
bool forceUnscrolledItem =
nsLayoutUtils::UsesAsyncScrolling(aFrame) && NS_GET_A(bgcolor) == 255;
if ((aFlags & AddCanvasBackgroundColorFlags::AddForSubDocument) &&
StaticPrefs::LayoutUseContainersForRootFrames()) {
StaticPrefs::layout_scroll_root_frame_containers()) {
// If we're using ContainerLayers for a subdoc, then any items we add here
// will still be scrolled (since we're inside the container at this point),
// so don't bother and we will do it manually later.

16
layout/base/nsLayoutUtils.cpp
View File

@ -543,14 +543,14 @@ bool nsLayoutUtils::IsAnimationLoggingEnabled() {
bool nsLayoutUtils::AreRetainedDisplayListsEnabled() {
#ifdef MOZ_WIDGET_ANDROID
return StaticPrefs::LayoutRetainDisplayList();
return StaticPrefs::layout_display_list_retain();
#else
if (XRE_IsContentProcess()) {
return StaticPrefs::LayoutRetainDisplayList();
return StaticPrefs::layout_display_list_retain();
}
if (XRE_IsE10sParentProcess()) {
return StaticPrefs::LayoutRetainDisplayListChrome();
return StaticPrefs::layout_display_list_retain_chrome();
}
// Retained display lists require e10s.
@ -1292,7 +1292,7 @@ bool nsLayoutUtils::SetDisplayPortMargins(nsIContent* aContent,
GetHighResolutionDisplayPort(aContent, &newDisplayPort);
MOZ_ASSERT(hasDisplayPort);
if (StaticPrefs::LayoutUseContainersForRootFrames()) {
if (StaticPrefs::layout_scroll_root_frame_containers()) {
nsIFrame* rootScrollFrame = aPresShell->GetRootScrollFrame();
if (rootScrollFrame && aContent == rootScrollFrame->GetContent() &&
nsLayoutUtils::UsesAsyncScrolling(rootScrollFrame)) {
@ -3962,7 +3962,7 @@ nsresult nsLayoutUtils::PaintFrame(gfxContext* aRenderingContext,
// This calls BuildDisplayListForStacking context on a subset of the
// viewport.
if (shouldAttemptPartialUpdate) {
if (StaticPrefs::LayoutVerifyRetainDisplayList()) {
if (StaticPrefs::layout_display_list_retain_verify()) {
beforeMergeChecker.Set(list, "BM");
}
@ -3986,7 +3986,7 @@ nsresult nsLayoutUtils::PaintFrame(gfxContext* aRenderingContext,
bool doFullRebuild =
updateState == PartialUpdateResult::Failed || afterMergeChecker;
if (StaticPrefs::LayoutDisplayListBuildTwice()) {
if (StaticPrefs::layout_display_list_build_twice()) {
// Build display list twice to compare partial and full display list
// build times.
metrics->StartBuild();
@ -9319,14 +9319,14 @@ Maybe<ScrollMetadata> nsLayoutUtils::GetRootMetadata(
// want the root container layer to have metrics. If the parent process is
// using XUL windows, there is no root scrollframe, and without explicitly
// creating metrics there will be no guaranteed top-level APZC.
bool addMetrics = StaticPrefs::LayoutUseContainersForRootFrames() ||
bool addMetrics = StaticPrefs::layout_scroll_root_frame_containers() ||
(XRE_IsParentProcess() && !presShell->GetRootScrollFrame());
// Add metrics if there are none in the layer tree with the id (create an id
// if there isn't one already) of the root scroll frame/root content.
bool ensureMetricsForRootId =
nsLayoutUtils::AsyncPanZoomEnabled(frame) &&
!StaticPrefs::LayoutUseContainersForRootFrames() &&
!StaticPrefs::layout_scroll_root_frame_containers() &&
aBuilder->IsPaintingToWindow() && !presContext->GetParentPresContext();
nsIContent* content = nullptr;

3
layout/generic/ScrollSnap.cpp
View File

@ -333,7 +333,8 @@ Maybe<nsPoint> ScrollSnapUtils::GetSnapPointForDestination(
bool snapped = false;
nsPoint finalPos = calcSnapPoints.GetBestEdge();
nscoord proximityThreshold = StaticPrefs::ScrollSnapProximityThreshold();
nscoord proximityThreshold =
StaticPrefs::layout_css_scroll_snap_proximity_threshold();
proximityThreshold = nsPresContext::CSSPixelsToAppUnits(proximityThreshold);
if (aSnapInfo.mScrollSnapStrictnessY ==
StyleScrollSnapStrictness::Proximity &&

6
layout/generic/ScrollVelocityQueue.cpp
View File

@ -14,8 +14,10 @@ namespace mozilla {
namespace layout {
void ScrollVelocityQueue::Sample(const nsPoint& aScrollPosition) {
float flingSensitivity = StaticPrefs::ScrollSnapPredictionSensitivity();
int maxVelocity = StaticPrefs::ScrollSnapPredictionMaxVelocity();
float flingSensitivity =
StaticPrefs::layout_css_scroll_snap_prediction_sensitivity();
int maxVelocity =
StaticPrefs::layout_css_scroll_snap_prediction_max_velocity();
maxVelocity = nsPresContext::CSSPixelsToAppUnits(maxVelocity);
int maxOffset = maxVelocity * flingSensitivity;
TimeStamp currentRefreshTime =

6
layout/generic/nsFrame.cpp
View File

@ -1097,7 +1097,8 @@ void nsIFrame::MarkNeedsDisplayItemRebuild() {
RetainedDisplayListData* data = GetOrSetRetainedDisplayListData(rootFrame);
if (data->ModifiedFramesCount() > StaticPrefs::LayoutRebuildFrameLimit()) {
if (data->ModifiedFramesCount() >
StaticPrefs::layout_display_list_rebuild_frame_limit()) {
// If the modified frames count is above the rebuild limit, mark the root
// frame modified, and stop marking additional frames modified.
data->AddModifiedFrame(rootFrame);
@ -3284,7 +3285,8 @@ void nsIFrame::BuildDisplayListForStackingContext(
set.Outlines()->DeleteAll(aBuilder);
}
if (hasOverrideDirtyRect && StaticPrefs::LayoutDisplayListShowArea()) {
if (hasOverrideDirtyRect &&
StaticPrefs::layout_display_list_show_rebuild_area()) {
nsDisplaySolidColor* color = MakeDisplayItem<nsDisplaySolidColor>(
aBuilder, this,
dirtyRect + aBuilder->GetCurrentFrameOffsetToReferenceFrame(),

40
layout/generic/nsGfxScrollFrame.cpp
View File

@ -1702,12 +1702,12 @@ class ScrollFrameHelper::AsyncSmoothMSDScroll final
nsPresContext* aPresContext)
: mXAxisModel(aInitialPosition.x, aInitialDestination.x,
aInitialVelocity.width,
StaticPrefs::ScrollBehaviorSpringConstant(),
StaticPrefs::ScrollBehaviorDampingRatio()),
StaticPrefs::layout_css_scroll_behavior_spring_constant(),
StaticPrefs::layout_css_scroll_behavior_damping_ratio()),
mYAxisModel(aInitialPosition.y, aInitialDestination.y,
aInitialVelocity.height,
StaticPrefs::ScrollBehaviorSpringConstant(),
StaticPrefs::ScrollBehaviorDampingRatio()),
StaticPrefs::layout_css_scroll_behavior_spring_constant(),
StaticPrefs::layout_css_scroll_behavior_damping_ratio()),
mRange(aRange),
mLastRefreshTime(aStartTime),
mCallee(nullptr),
@ -2332,7 +2332,7 @@ void ScrollFrameHelper::ScrollToWithOrigin(
nsSize currentVelocity(0, 0);
if (StaticPrefs::ScrollBehaviorEnabled()) {
if (StaticPrefs::layout_css_scroll_behavior_enabled()) {
if (aMode == ScrollMode::SmoothMsd) {
mIgnoreMomentumScroll = true;
if (!mAsyncSmoothMSDScroll) {
@ -3181,7 +3181,7 @@ void ScrollFrameHelper::AppendScrollPartsTo(nsDisplayListBuilder* aBuilder,
scrollDirection.isSome() && overlayScrollbars;
const bool createLayer =
aCreateLayer || isOverlayScrollbar ||
StaticPrefs::AlwaysLayerizeScrollbarTrackTestOnly();
StaticPrefs::layout_scrollbars_always_layerize_track();
nsDisplayListCollection partList(aBuilder);
{
@ -3437,7 +3437,7 @@ void ScrollFrameHelper::BuildDisplayList(nsDisplayListBuilder* aBuilder,
nsDisplayListBuilder::AutoCurrentActiveScrolledRootSetter asrSetter(
aBuilder);
if (aBuilder->IsPaintingToWindow() &&
StaticPrefs::LayoutUseContainersForRootFrames() && mIsRoot) {
StaticPrefs::layout_scroll_root_frame_containers() && mIsRoot) {
asrSetter.EnterScrollFrame(sf);
if (isRcdRsf) {
aBuilder->SetActiveScrolledRootForRootScrollframe(
@ -3485,7 +3485,7 @@ void ScrollFrameHelper::BuildDisplayList(nsDisplayListBuilder* aBuilder,
// scroll frame for the display root, then we don't need a scroll
// info layer. nsDisplayList::PaintForFrame already calls
// ComputeFrameMetrics for us.
(!(StaticPrefs::LayoutUseContainersForRootFrames() && mIsRoot) ||
(!(StaticPrefs::layout_scroll_root_frame_containers() && mIsRoot) ||
(aBuilder->RootReferenceFrame()->PresContext() !=
mOuter->PresContext()));
}
@ -3575,7 +3575,7 @@ void ScrollFrameHelper::BuildDisplayList(nsDisplayListBuilder* aBuilder,
bool haveRadii = mOuter->GetPaddingBoxBorderRadii(radii);
if (mIsRoot) {
clipRect.SizeTo(nsLayoutUtils::CalculateCompositionSizeForFrame(mOuter));
if ((StaticPrefs::LayoutUseContainersForRootFrames() ||
if ((StaticPrefs::layout_scroll_root_frame_containers() ||
!aBuilder->IsPaintingToWindow()) &&
mOuter->PresContext()->IsRootContentDocument()) {
double res = mOuter->PresShell()->GetResolution();
@ -3688,7 +3688,7 @@ void ScrollFrameHelper::BuildDisplayList(nsDisplayListBuilder* aBuilder,
mOuter->BuildDisplayListForChild(aBuilder, mScrolledFrame, set);
if (dirtyRectHasBeenOverriden &&
StaticPrefs::LayoutDisplayListShowArea()) {
StaticPrefs::layout_display_list_show_rebuild_area()) {
nsDisplaySolidColor* color = MakeDisplayItem<nsDisplaySolidColor>(
aBuilder, mOuter,
dirtyRect + aBuilder->GetCurrentFrameOffsetToReferenceFrame(),
@ -3713,7 +3713,7 @@ void ScrollFrameHelper::BuildDisplayList(nsDisplayListBuilder* aBuilder,
mIsScrollParent = idSetter.ShouldForceLayerForScrollParent();
}
if (idSetter.ShouldForceLayerForScrollParent() &&
!StaticPrefs::LayoutUseContainersForRootFrames()) {
!StaticPrefs::layout_scroll_root_frame_containers()) {
// Note that forcing layerization of scroll parents follows the scroll
// handoff chain which is subject to the out-of-flow-frames caveat noted
// above (where the idSetter variable is created).
@ -4022,7 +4022,7 @@ bool ScrollFrameHelper::DecideScrollableLayer(
}
mIsScrollableLayerInRootContainer =
StaticPrefs::LayoutUseContainersForRootFrames() &&
StaticPrefs::layout_scroll_root_frame_containers() &&
mWillBuildScrollableLayer && mIsRoot;
return mWillBuildScrollableLayer;
}
@ -4069,7 +4069,7 @@ void ScrollFrameHelper::ClipLayerToDisplayPort(
if (!nsLayoutUtils::UsesAsyncScrolling(mOuter)) {
Maybe<nsRect> parentLayerClip;
// For containerful frames, the clip is on the container layer.
if (aClip && (!StaticPrefs::LayoutUseContainersForRootFrames() ||
if (aClip && (!StaticPrefs::layout_scroll_root_frame_containers() ||
mAddClipRectToLayer)) {
parentLayerClip = Some(aClip->GetClipRect());
}
@ -4395,8 +4395,10 @@ void ScrollFrameHelper::ScrollByCSSPixels(
}
void ScrollFrameHelper::ScrollSnap(ScrollMode aMode) {
float flingSensitivity = StaticPrefs::ScrollSnapPredictionSensitivity();
int maxVelocity = StaticPrefs::ScrollSnapPredictionMaxVelocity();
float flingSensitivity =
StaticPrefs::layout_css_scroll_snap_prediction_sensitivity();
int maxVelocity =
StaticPrefs::layout_css_scroll_snap_prediction_max_velocity();
maxVelocity = nsPresContext::CSSPixelsToAppUnits(maxVelocity);
int maxOffset = maxVelocity * flingSensitivity;
nsPoint velocity = mVelocityQueue.GetVelocity();
@ -6973,7 +6975,7 @@ bool ScrollFrameHelper::GetSnapPointForDestination(
}
bool ScrollFrameHelper::UsesContainerScrolling() const {
if (StaticPrefs::LayoutUseContainersForRootFrames()) {
if (StaticPrefs::layout_scroll_root_frame_containers()) {
return mIsRoot;
}
return false;
@ -7133,9 +7135,9 @@ void ScrollFrameHelper::ApzSmoothScrollTo(const nsPoint& aDestination,
bool ScrollFrameHelper::SmoothScrollVisual(
const nsPoint& aVisualViewportOffset,
FrameMetrics::ScrollOffsetUpdateType aUpdateType) {
bool canDoApzSmoothScroll = StaticPrefs::ScrollBehaviorEnabled() &&
nsLayoutUtils::AsyncPanZoomEnabled(mOuter) &&
WantAsyncScroll();
bool canDoApzSmoothScroll =
StaticPrefs::layout_css_scroll_behavior_enabled() &&
nsLayoutUtils::AsyncPanZoomEnabled(mOuter) && WantAsyncScroll();
if (!canDoApzSmoothScroll) {
return false;
}

4
layout/generic/nsSubDocumentFrame.cpp
View File

@ -433,7 +433,7 @@ void nsSubDocumentFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
aBuilder, &copyOfVisible, &copyOfDirty,
/* aSetBase = */ true);
if (!StaticPrefs::LayoutUseContainersForRootFrames() ||
if (!StaticPrefs::layout_scroll_root_frame_containers() ||
!aBuilder->IsPaintingToWindow()) {
haveDisplayPort = false;
}
@ -590,7 +590,7 @@ void nsSubDocumentFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
// unscrolled color item for overscroll. Try again now that we're
// outside the scrolled ContainerLayer.
if (!aBuilder->IsForEventDelivery() &&
StaticPrefs::LayoutUseContainersForRootFrames() &&
StaticPrefs::layout_scroll_root_frame_containers() &&
!nsLayoutUtils::NeedsPrintPreviewBackground(presContext)) {
nsRect bounds =
GetContentRectRelativeToSelf() + aBuilder->ToReferenceFrame(this);

2
layout/generic/nsTextFrame.cpp
View File

@ -6739,7 +6739,7 @@ static void DrawTextRun(const gfxTextRun* aTextRun,
return;
}
params.drawMode |= DrawMode::GLYPH_STROKE;
if (StaticPrefs::PaintOrderEnabled()) {
if (StaticPrefs::layout_css_paint_order_enabled()) {
// Check the paint-order property; if we find stroke before fill,
// then change mode to GLYPH_STROKE_UNDERNEATH.
uint32_t paintOrder = aFrame->StyleSVG()->mPaintOrder;

3
layout/painting/DisplayListChecker.cpp
View File

@ -81,7 +81,8 @@ class DisplayListBlueprint {
unsigned& aIndex);
std::vector<DisplayItemBlueprint> mItems;
const bool mVerifyOrder = StaticPrefs::LayoutVerifyRetainDisplayListOrder();
const bool mVerifyOrder =
StaticPrefs::layout_display_list_retain_verify_order();
};
// Object representing one display item, with just enough information to

12
layout/painting/FrameLayerBuilder.cpp
View File

@ -3091,7 +3091,7 @@ PaintedLayerData* PaintedLayerDataNode::FindPaintedLayerFor(
break;
}
if (StaticPrefs::LayoutSmallerPaintedLayers()) {
if (StaticPrefs::layout_smaller_painted_layers()) {
lowestUsableLayer = nullptr;
}
}
@ -5077,7 +5077,7 @@ void ContainerState::ProcessDisplayItems(nsDisplayList* aList) {
} else if ((itemType == DisplayItemType::TYPE_SUBDOCUMENT ||
itemType == DisplayItemType::TYPE_ZOOM ||
itemType == DisplayItemType::TYPE_RESOLUTION) &&
StaticPrefs::LayoutUseContainersForRootFrames()) {
StaticPrefs::layout_scroll_root_frame_containers()) {
newLayerEntry->mBaseScrollMetadata =
static_cast<nsDisplaySubDocument*>(item)->ComputeScrollMetadata(
ownLayer->Manager(), mParameters);
@ -5965,9 +5965,9 @@ void ContainerState::Finish(uint32_t* aTextContentFlags,
nsDisplayList* aChildItems) {
mPaintedLayerDataTree.Finish();
if (!StaticPrefs::LayoutUseContainersForRootFrames()) {
if (!StaticPrefs::layout_scroll_root_frame_containers()) {
// Bug 1336544 tracks re-enabling this assertion in the
// StaticPrefs::LayoutUseContainersForRootFrames() case.
// StaticPrefs::layout_scroll_root_frame_containers() case.
NS_ASSERTION(mContainerBounds.IsEqualInterior(mAccumulatedChildBounds),
"Bounds computation mismatch");
}
@ -6304,7 +6304,7 @@ already_AddRefed<ContainerLayer> FrameLayerBuilder::BuildContainerLayerFor(
aParameters.mScrollMetadataASR;
const ActiveScrolledRoot* containerCompositorASR = aParameters.mCompositorASR;
if (!aContainerItem && StaticPrefs::LayoutUseContainersForRootFrames()) {
if (!aContainerItem && StaticPrefs::layout_scroll_root_frame_containers()) {
containerASR = aBuilder->ActiveScrolledRootForRootScrollframe();
containerScrollMetadataASR = containerASR;
containerCompositorASR = containerASR;
@ -7155,7 +7155,7 @@ void FrameLayerBuilder::PaintItems(std::vector<AssignedDisplayItem>& aItems,
*/
static bool ShouldDrawRectsSeparately(DrawTarget* aDrawTarget,
DrawRegionClip aClip) {
if (!StaticPrefs::LayoutPaintRectsSeparately() ||
if (!StaticPrefs::layout_paint_rects_separately() ||
aClip == DrawRegionClip::NONE) {
return false;
}

3
layout/painting/RetainedDisplayListBuilder.cpp
View File

@ -1332,7 +1332,8 @@ bool RetainedDisplayListBuilder::ShouldBuildPartial(
return false;
}
if (aModifiedFrames.Length() > StaticPrefs::LayoutRebuildFrameLimit()) {
if (aModifiedFrames.Length() >
StaticPrefs::layout_display_list_rebuild_frame_limit()) {
// Computing a dirty rect with too many modified frames can be slow.
Metrics()->mPartialUpdateFailReason = PartialUpdateFailReason::RebuildLimit;
return false;

40
layout/painting/nsDisplayList.cpp
View File

@ -1502,8 +1502,9 @@ AnimatedGeometryRoot* nsDisplayListBuilder::FindAnimatedGeometryRootFor(
void nsDisplayListBuilder::UpdateShouldBuildAsyncZoomContainer() {
Document* document = mReferenceFrame->PresContext()->Document();
mBuildAsyncZoomContainer = nsLayoutUtils::AllowZoomingForDocument(document) &&
!StaticPrefs::LayoutUseContainersForRootFrames();
mBuildAsyncZoomContainer =
nsLayoutUtils::AllowZoomingForDocument(document) &&
!StaticPrefs::layout_scroll_root_frame_containers();
}
bool nsDisplayListBuilder::MarkOutOfFlowFrameForDisplay(nsIFrame* aDirtyFrame,
@ -2694,7 +2695,7 @@ bool nsDisplayList::ComputeVisibilityForRoot(nsDisplayListBuilder* aBuilder,
nsRegion r;
const ActiveScrolledRoot* rootASR = nullptr;
if (StaticPrefs::LayoutUseContainersForRootFrames()) {
if (StaticPrefs::layout_scroll_root_frame_containers()) {
rootASR = aBuilder->ActiveScrolledRootForRootScrollframe();
}
r.And(*aVisibleRegion, GetClippedBoundsWithRespectToASR(aBuilder, rootASR));
@ -2872,7 +2873,7 @@ FrameLayerBuilder* nsDisplayList::BuildLayers(nsDisplayListBuilder* aBuilder,
rootLayer->SetScrollMetadata(nsTArray<ScrollMetadata>());
}
float resolutionUniform = StaticPrefs::LayoutUseContainersForRootFrames()
float resolutionUniform = StaticPrefs::layout_scroll_root_frame_containers()
? presShell->GetResolution()
: 1.0f;
float resolutionX = resolutionUniform;
@ -2909,7 +2910,7 @@ FrameLayerBuilder* nsDisplayList::BuildLayers(nsDisplayListBuilder* aBuilder,
}
// Root is being scaled up by the X/Y resolution. Scale it back down.
root->SetPostScale(1.0f / resolutionX, 1.0f / resolutionY);
if (StaticPrefs::LayoutUseContainersForRootFrames()) {
if (StaticPrefs::layout_scroll_root_frame_containers()) {
root->SetScaleToResolution(resolutionUniform);
}
@ -3573,7 +3574,7 @@ Maybe<nsRect> nsDisplayItem::GetClipWithRespectToASR(
return Some(clip->GetClipRect());
}
#ifdef DEBUG
if (!StaticPrefs::LayoutUseContainersForRootFrames()) {
if (!StaticPrefs::layout_scroll_root_frame_containers()) {
MOZ_ASSERT(false, "item should have finite clip with respect to aASR");
}
#endif
@ -6379,8 +6380,8 @@ static bool IsItemTooSmallForActiveLayer(nsIFrame* aFrame) {
aFrame->GetVisualOverflowRectRelativeToSelf().ToOutsidePixels(
aFrame->PresContext()->AppUnitsPerDevPixel());
return visibleDevPixels.Size() <
nsIntSize(StaticPrefs::LayoutMinActiveLayerSize(),
StaticPrefs::LayoutMinActiveLayerSize());
nsIntSize(StaticPrefs::layout_min_active_layer_size(),
StaticPrefs::layout_min_active_layer_size());
}
/* static */
@ -7256,7 +7257,7 @@ already_AddRefed<Layer> nsDisplayResolution::BuildLayer(
nsDisplayListBuilder* aBuilder, LayerManager* aManager,
const ContainerLayerParameters& aContainerParameters) {
PresShell* presShell = mFrame->PresShell();
float rootLayerResolution = StaticPrefs::LayoutUseContainersForRootFrames()
float rootLayerResolution = StaticPrefs::layout_scroll_root_frame_containers()
? presShell->GetResolution()
: 1.0f;
ContainerLayerParameters containerParameters(
@ -7266,7 +7267,7 @@ already_AddRefed<Layer> nsDisplayResolution::BuildLayer(
RefPtr<Layer> layer =
nsDisplaySubDocument::BuildLayer(aBuilder, aManager, containerParameters);
if (StaticPrefs::LayoutUseContainersForRootFrames()) {
if (StaticPrefs::layout_scroll_root_frame_containers()) {
layer->SetPostScale(1.0f / presShell->GetResolution(),
1.0f / presShell->GetResolution());
layer->AsContainerLayer()->SetScaleToResolution(presShell->GetResolution());
@ -8008,7 +8009,8 @@ void nsDisplayTransform::Init(nsDisplayListBuilder* aBuilder,
}
bool nsDisplayTransform::ShouldFlattenAway(nsDisplayListBuilder* aBuilder) {
if (gfxVars::UseWebRender() || !StaticPrefs::LayoutFlattenTransform()) {
if (gfxVars::UseWebRender() ||
!StaticPrefs::layout_display_list_flatten_transform()) {
return false;
}
@ -8374,10 +8376,14 @@ auto nsDisplayTransform::ShouldPrerenderTransformedContent(
return FullPrerender;
}
float viewportRatioX = StaticPrefs::AnimationPrerenderViewportRatioLimitX();
float viewportRatioY = StaticPrefs::AnimationPrerenderViewportRatioLimitY();
uint32_t absoluteLimitX = StaticPrefs::AnimationPrerenderAbsoluteLimitX();
uint32_t absoluteLimitY = StaticPrefs::AnimationPrerenderAbsoluteLimitY();
float viewportRatioX =
StaticPrefs::layout_animation_prerender_viewport_ratio_limit_x();
float viewportRatioY =
StaticPrefs::layout_animation_prerender_viewport_ratio_limit_y();
uint32_t absoluteLimitX =
StaticPrefs::layout_animation_prerender_absolute_limit_x();
uint32_t absoluteLimitY =
StaticPrefs::layout_animation_prerender_absolute_limit_y();
nsSize refSize = aBuilder->RootReferenceFrame()->GetSize();
// Only prerender if the transformed frame's size is <= a multiple of the
// reference frame size (~viewport), and less than an absolute limit.
@ -8404,7 +8410,7 @@ auto nsDisplayTransform::ShouldPrerenderTransformedContent(
return FullPrerender;
}
if (StaticPrefs::PartiallyPrerenderAnimatedContent()) {
if (StaticPrefs::layout_animation_prerender_partial()) {
*aDirtyRect = nsLayoutUtils::ComputePartialPrerenderArea(*aDirtyRect,
overflow, maxSize);
return PartialPrerender;
@ -10114,7 +10120,7 @@ Maybe<nsRect> nsDisplayMasksAndClipPaths::GetClipWithRespectToASR(
return Some(childList->GetClippedBoundsWithRespectToASR(aBuilder, aASR));
}
#ifdef DEBUG
if (!StaticPrefs::LayoutUseContainersForRootFrames()) {
if (!StaticPrefs::layout_scroll_root_frame_containers()) {
MOZ_ASSERT(false, "item should have finite clip with respect to aASR");
}
#endif

58
modules/libpref/init/StaticPrefList.h
View File

@ -4664,35 +4664,35 @@ VARCACHE_PREF(
VARCACHE_PREF(
Live,
"layout.animation.prerender.partial",
PartiallyPrerenderAnimatedContent,
layout_animation_prerender_partial,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"layout.animation.prerender.viewport-ratio-limit-x",
AnimationPrerenderViewportRatioLimitX,
layout_animation_prerender_viewport_ratio_limit_x,
AtomicFloat, 1.125f
)
VARCACHE_PREF(
Live,
"layout.animation.prerender.viewport-ratio-limit-y",
AnimationPrerenderViewportRatioLimitY,
layout_animation_prerender_viewport_ratio_limit_y,
AtomicFloat, 1.125f
)
VARCACHE_PREF(
Live,
"layout.animation.prerender.absolute-limit-x",
AnimationPrerenderAbsoluteLimitX,
layout_animation_prerender_absolute_limit_x,
RelaxedAtomicUint32, 4096
)
VARCACHE_PREF(
Live,
"layout.animation.prerender.absolute-limit-y",
AnimationPrerenderAbsoluteLimitY,
layout_animation_prerender_absolute_limit_y,
RelaxedAtomicUint32, 4096
)
@ -4986,7 +4986,7 @@ VARCACHE_PREF(
VARCACHE_PREF(
Live,
"layout.css.paint-order.enabled",
PaintOrderEnabled,
layout_css_paint_order_enabled,
RelaxedAtomicBool, false
)
@ -5072,7 +5072,7 @@ VARCACHE_PREF(
VARCACHE_PREF(
Live,
"layout.css.scroll-behavior.damping-ratio",
ScrollBehaviorDampingRatio,
layout_css_scroll_behavior_damping_ratio,
AtomicFloat, 1.0f
)
@ -5108,35 +5108,35 @@ VARCACHE_PREF(
VARCACHE_PREF(
Live,
"layout.css.scroll-behavior.enabled",
ScrollBehaviorEnabled,
layout_css_scroll_behavior_enabled,
RelaxedAtomicBool, true
)
VARCACHE_PREF(
Live,
"layout.css.scroll-behavior.spring-constant",
ScrollBehaviorSpringConstant,
layout_css_scroll_behavior_spring_constant,
AtomicFloat, 250.0f
)
VARCACHE_PREF(
Live,
"layout.css.scroll-snap.prediction-max-velocity",
ScrollSnapPredictionMaxVelocity,
layout_css_scroll_snap_prediction_max_velocity,
RelaxedAtomicInt32, 2000
)
VARCACHE_PREF(
Live,
"layout.css.scroll-snap.prediction-sensitivity",
ScrollSnapPredictionSensitivity,
layout_css_scroll_snap_prediction_sensitivity,
AtomicFloat, 0.750f
)
VARCACHE_PREF(
Live,
"layout.css.scroll-snap.proximity-threshold",
ScrollSnapProximityThreshold,
layout_css_scroll_snap_proximity_threshold,
RelaxedAtomicInt32, 200
)
@ -5243,77 +5243,77 @@ VARCACHE_PREF(
VARCACHE_PREF(
Live,
"layout.display-list.build-twice",
LayoutDisplayListBuildTwice,
layout_display_list_build_twice,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"layout.display-list.retain",
LayoutRetainDisplayList,
layout_display_list_retain,
RelaxedAtomicBool, true
)
VARCACHE_PREF(
Live,
"layout.display-list.retain.chrome",
LayoutRetainDisplayListChrome,
layout_display_list_retain_chrome,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"layout.display-list.retain.verify",
LayoutVerifyRetainDisplayList,
layout_display_list_retain_verify,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"layout.display-list.retain.verify.order",
LayoutVerifyRetainDisplayListOrder,
layout_display_list_retain_verify_order,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"layout.display-list.rebuild-frame-limit",
LayoutRebuildFrameLimit,
layout_display_list_rebuild_frame_limit,
RelaxedAtomicUint32, 500
)
VARCACHE_PREF(
Live,
"layout.display-list.dump",
LayoutDumpDisplayList,
layout_display_list_dump,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"layout.display-list.dump-content",
LayoutDumpDisplayListContent,
layout_display_list_dump_content,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"layout.display-list.dump-parent",
LayoutDumpDisplayListParent,
layout_display_list_dump_parent,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"layout.display-list.show-rebuild-area",
LayoutDisplayListShowArea,
layout_display_list_show_rebuild_area,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"layout.display-list.flatten-transform",
LayoutFlattenTransform,
layout_display_list_flatten_transform,
RelaxedAtomicBool, true
)
@ -5334,21 +5334,21 @@ VARCACHE_PREF(
VARCACHE_PREF(
Live,
"layout.frame_rate",
LayoutFrameRate,
layout_frame_rate,
RelaxedAtomicInt32, -1
)
VARCACHE_PREF(
Live,
"layout.min-active-layer-size",
LayoutMinActiveLayerSize,
layout_min_active_layer_size,
int, 64
)
VARCACHE_PREF(
Once,
"layout.paint_rects_separately",
LayoutPaintRectsSeparately,
layout_paint_rects_separately,
bool, true
)
@ -5356,7 +5356,7 @@ VARCACHE_PREF(
VARCACHE_PREF(
Live,
"layout.scroll.root-frame-containers",
LayoutUseContainersForRootFrames,
layout_scroll_root_frame_containers,
RelaxedAtomicBool, false
)
@ -5364,14 +5364,14 @@ VARCACHE_PREF(
VARCACHE_PREF(
Live,
"layout.scrollbars.always-layerize-track",
AlwaysLayerizeScrollbarTrackTestOnly,
layout_scrollbars_always_layerize_track,
RelaxedAtomicBool, false
)
VARCACHE_PREF(
Live,
"layout.smaller-painted-layers",
LayoutSmallerPaintedLayers,
layout_smaller_painted_layers,
RelaxedAtomicBool, false
)