diff options
Diffstat (limited to '')
| -rw-r--r-- | layout/generic/ViewportFrame.cpp | 499 |
1 files changed, 499 insertions, 0 deletions
diff --git a/layout/generic/ViewportFrame.cpp b/layout/generic/ViewportFrame.cpp new file mode 100644 index 0000000000..a77ade73ef --- /dev/null +++ b/layout/generic/ViewportFrame.cpp @@ -0,0 +1,499 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim: set ts=8 sts=2 et sw=2 tw=80: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +/* + * rendering object that is the root of the frame tree, which contains + * the document's scrollbars and contains fixed-positioned elements + */ + +#include "mozilla/ViewportFrame.h" + +#include "mozilla/ComputedStyleInlines.h" +#include "mozilla/PresShell.h" +#include "mozilla/ProfilerLabels.h" +#include "mozilla/RestyleManager.h" +#include "nsGkAtoms.h" +#include "nsIScrollableFrame.h" +#include "nsAbsoluteContainingBlock.h" +#include "nsCanvasFrame.h" +#include "nsLayoutUtils.h" +#include "nsSubDocumentFrame.h" +#include "nsIMozBrowserFrame.h" +#include "nsPlaceholderFrame.h" +#include "MobileViewportManager.h" + +using namespace mozilla; +typedef nsAbsoluteContainingBlock::AbsPosReflowFlags AbsPosReflowFlags; + +ViewportFrame* NS_NewViewportFrame(PresShell* aPresShell, + ComputedStyle* aStyle) { + return new (aPresShell) ViewportFrame(aStyle, aPresShell->GetPresContext()); +} + +NS_IMPL_FRAMEARENA_HELPERS(ViewportFrame) +NS_QUERYFRAME_HEAD(ViewportFrame) + NS_QUERYFRAME_ENTRY(ViewportFrame) +NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame) + +void ViewportFrame::Init(nsIContent* aContent, nsContainerFrame* aParent, + nsIFrame* aPrevInFlow) { + nsContainerFrame::Init(aContent, aParent, aPrevInFlow); + // No need to call CreateView() here - the frame ctor will call SetView() + // with the ViewManager's root view, so we'll assign it in SetViewInternal(). + + nsIFrame* parent = nsLayoutUtils::GetCrossDocParentFrameInProcess(this); + if (parent) { + nsFrameState state = parent->GetStateBits(); + + AddStateBits(state & (NS_FRAME_IN_POPUP)); + } +} + +void ViewportFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder, + const nsDisplayListSet& aLists) { + AUTO_PROFILER_LABEL("ViewportFrame::BuildDisplayList", + GRAPHICS_DisplayListBuilding); + + nsIFrame* kid = mFrames.FirstChild(); + if (!kid) { + return; + } + + nsDisplayListCollection set(aBuilder); + BuildDisplayListForChild(aBuilder, kid, set); + + // If we have a scrollframe then it takes care of creating the display list + // for the top layer, but otherwise we need to do it here. + if (!kid->IsScrollFrame()) { + bool isOpaque = false; + if (auto* list = BuildDisplayListForTopLayer(aBuilder, &isOpaque)) { + if (isOpaque) { + set.DeleteAll(aBuilder); + } + set.PositionedDescendants()->AppendToTop(list); + } + } + + set.MoveTo(aLists); +} + +#ifdef DEBUG +/** + * Returns whether we are going to put an element in the top layer for + * fullscreen. This function should matches the CSS rule in ua.css. + */ +static bool ShouldInTopLayerForFullscreen(dom::Element* aElement) { + if (!aElement->GetParent()) { + return false; + } + nsCOMPtr<nsIMozBrowserFrame> browserFrame = do_QueryInterface(aElement); + if (browserFrame && browserFrame->GetReallyIsBrowser()) { + return false; + } + return true; +} +#endif // DEBUG + +static void BuildDisplayListForTopLayerFrame(nsDisplayListBuilder* aBuilder, + nsIFrame* aFrame, + nsDisplayList* aList) { + nsRect visible; + nsRect dirty; + DisplayListClipState::AutoSaveRestore clipState(aBuilder); + nsDisplayListBuilder::AutoCurrentActiveScrolledRootSetter asrSetter(aBuilder); + nsDisplayListBuilder::OutOfFlowDisplayData* savedOutOfFlowData = + nsDisplayListBuilder::GetOutOfFlowData(aFrame); + if (savedOutOfFlowData) { + visible = + savedOutOfFlowData->GetVisibleRectForFrame(aBuilder, aFrame, &dirty); + // This function is called after we've finished building display items for + // the root scroll frame. That means that the content clip from the root + // scroll frame is no longer on aBuilder. However, we need to make sure + // that the display items we build in this function have finite clipped + // bounds with respect to the root ASR, so we restore the *combined clip* + // that we saved earlier. The combined clip will include the clip from the + // root scroll frame. + clipState.SetClipChainForContainingBlockDescendants( + savedOutOfFlowData->mCombinedClipChain); + asrSetter.SetCurrentActiveScrolledRoot( + savedOutOfFlowData->mContainingBlockActiveScrolledRoot); + asrSetter.SetCurrentScrollParentId(savedOutOfFlowData->mScrollParentId); + } + nsDisplayListBuilder::AutoBuildingDisplayList buildingForChild( + aBuilder, aFrame, visible, dirty); + + nsDisplayList list(aBuilder); + aFrame->BuildDisplayListForStackingContext(aBuilder, &list); + aList->AppendToTop(&list); +} + +static bool BackdropListIsOpaque(ViewportFrame* aFrame, + nsDisplayListBuilder* aBuilder, + nsDisplayList* aList) { + // The common case for ::backdrop elements on the top layer is a single + // fixed position container, holding an opaque background color covering + // the whole viewport. + if (aList->Length() != 1 || + aList->GetTop()->GetType() != DisplayItemType::TYPE_FIXED_POSITION) { + return false; + } + + // Make sure the fixed position container isn't clipped or scrollable. + nsDisplayFixedPosition* fixed = + static_cast<nsDisplayFixedPosition*>(aList->GetTop()); + if (fixed->GetActiveScrolledRoot() || fixed->GetClipChain()) { + return false; + } + + nsDisplayList* children = fixed->GetChildren(); + if (!children->GetTop() || + children->GetTop()->GetType() != DisplayItemType::TYPE_BACKGROUND_COLOR) { + return false; + } + + nsDisplayBackgroundColor* child = + static_cast<nsDisplayBackgroundColor*>(children->GetTop()); + if (child->GetActiveScrolledRoot() || child->GetClipChain()) { + return false; + } + + // Check that the background color is both opaque, and covering the + // whole viewport. + bool dummy; + nsRegion opaque = child->GetOpaqueRegion(aBuilder, &dummy); + return opaque.Contains(aFrame->GetRect()); +} + +nsDisplayWrapList* ViewportFrame::BuildDisplayListForTopLayer( + nsDisplayListBuilder* aBuilder, bool* aIsOpaque) { + nsDisplayList topLayerList(aBuilder); + + nsTArray<dom::Element*> topLayer = PresContext()->Document()->GetTopLayer(); + for (dom::Element* elem : topLayer) { + nsIFrame* frame = elem->GetPrimaryFrame(); + if (!frame) { + continue; + } + + if (frame->IsHiddenByContentVisibilityOnAnyAncestor( + nsIFrame::IncludeContentVisibility::Hidden)) { + continue; + } + + // There are two cases where an element in fullscreen is not in + // the top layer: + // 1. When building display list for purpose other than painting, + // it is possible that there is inconsistency between the style + // info and the content tree. + // 2. This is an element which we are not going to put in the top + // layer for fullscreen. See ShouldInTopLayerForFullscreen(). + // In both cases, we want to skip the frame here and paint it in + // the normal path. + if (frame->StyleDisplay()->mTopLayer == StyleTopLayer::None) { + MOZ_ASSERT(!aBuilder->IsForPainting() || + !ShouldInTopLayerForFullscreen(elem)); + continue; + } + MOZ_ASSERT(ShouldInTopLayerForFullscreen(elem)); + // Inner SVG, MathML elements, as well as children of some XUL + // elements are not allowed to be out-of-flow. They should not + // be handled as top layer element here. + if (!frame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW)) { + MOZ_ASSERT(!elem->GetParent()->IsHTMLElement(), + "HTML element should always be out-of-flow if in the top " + "layer"); + continue; + } + if (nsIFrame* backdropPh = + frame->GetChildList(FrameChildListID::Backdrop).FirstChild()) { + MOZ_ASSERT(!backdropPh->GetNextSibling(), "more than one ::backdrop?"); + MOZ_ASSERT(backdropPh->HasAnyStateBits(NS_FRAME_FIRST_REFLOW), + "did you intend to reflow ::backdrop placeholders?"); + nsIFrame* backdropFrame = + nsPlaceholderFrame::GetRealFrameForPlaceholder(backdropPh); + BuildDisplayListForTopLayerFrame(aBuilder, backdropFrame, &topLayerList); + + if (aIsOpaque) { + *aIsOpaque = BackdropListIsOpaque(this, aBuilder, &topLayerList); + } + } + BuildDisplayListForTopLayerFrame(aBuilder, frame, &topLayerList); + } + + if (nsCanvasFrame* canvasFrame = PresShell()->GetCanvasFrame()) { + if (dom::Element* container = canvasFrame->GetCustomContentContainer()) { + if (nsIFrame* frame = container->GetPrimaryFrame()) { + MOZ_ASSERT(frame->StyleDisplay()->mTopLayer != StyleTopLayer::None, + "ua.css should ensure this"); + MOZ_ASSERT(frame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW)); + BuildDisplayListForTopLayerFrame(aBuilder, frame, &topLayerList); + } + } + } + if (topLayerList.IsEmpty()) { + return nullptr; + } + nsPoint offset = aBuilder->GetCurrentFrame()->GetOffsetTo(this); + nsDisplayListBuilder::AutoBuildingDisplayList buildingDisplayList( + aBuilder, this, aBuilder->GetVisibleRect() + offset, + aBuilder->GetDirtyRect() + offset); + // Wrap the whole top layer in a single item with maximum z-index, + // and append it at the very end, so that it stays at the topmost. + nsDisplayWrapList* wrapList = MakeDisplayItemWithIndex<nsDisplayWrapper>( + aBuilder, this, 2, &topLayerList, aBuilder->CurrentActiveScrolledRoot(), + false); + if (!wrapList) { + return nullptr; + } + wrapList->SetOverrideZIndex( + std::numeric_limits<decltype(wrapList->ZIndex())>::max()); + return wrapList; +} + +#ifdef DEBUG +void ViewportFrame::AppendFrames(ChildListID aListID, + nsFrameList&& aFrameList) { + NS_ASSERTION(aListID == FrameChildListID::Principal, "unexpected child list"); + NS_ASSERTION(GetChildList(aListID).IsEmpty(), "Shouldn't have any kids!"); + nsContainerFrame::AppendFrames(aListID, std::move(aFrameList)); +} + +void ViewportFrame::InsertFrames(ChildListID aListID, nsIFrame* aPrevFrame, + const nsLineList::iterator* aPrevFrameLine, + nsFrameList&& aFrameList) { + NS_ASSERTION(aListID == FrameChildListID::Principal, "unexpected child list"); + NS_ASSERTION(GetChildList(aListID).IsEmpty(), "Shouldn't have any kids!"); + nsContainerFrame::InsertFrames(aListID, aPrevFrame, aPrevFrameLine, + std::move(aFrameList)); +} + +void ViewportFrame::RemoveFrame(DestroyContext& aContext, ChildListID aListID, + nsIFrame* aOldFrame) { + NS_ASSERTION(aListID == FrameChildListID::Principal, "unexpected child list"); + nsContainerFrame::RemoveFrame(aContext, aListID, aOldFrame); +} +#endif + +/* virtual */ +nscoord ViewportFrame::GetMinISize(gfxContext* aRenderingContext) { + nscoord result; + DISPLAY_MIN_INLINE_SIZE(this, result); + if (mFrames.IsEmpty()) + result = 0; + else + result = mFrames.FirstChild()->GetMinISize(aRenderingContext); + + return result; +} + +/* virtual */ +nscoord ViewportFrame::GetPrefISize(gfxContext* aRenderingContext) { + nscoord result; + DISPLAY_PREF_INLINE_SIZE(this, result); + if (mFrames.IsEmpty()) + result = 0; + else + result = mFrames.FirstChild()->GetPrefISize(aRenderingContext); + + return result; +} + +nsPoint ViewportFrame::AdjustReflowInputForScrollbars( + ReflowInput* aReflowInput) const { + // Get our prinicpal child frame and see if we're scrollable + nsIFrame* kidFrame = mFrames.FirstChild(); + nsIScrollableFrame* scrollingFrame = do_QueryFrame(kidFrame); + + if (scrollingFrame) { + WritingMode wm = aReflowInput->GetWritingMode(); + LogicalMargin scrollbars(wm, scrollingFrame->GetActualScrollbarSizes()); + aReflowInput->SetComputedISize( + aReflowInput->ComputedISize() - scrollbars.IStartEnd(wm), + ReflowInput::ResetResizeFlags::No); + aReflowInput->SetAvailableISize(aReflowInput->AvailableISize() - + scrollbars.IStartEnd(wm)); + aReflowInput->SetComputedBSize( + aReflowInput->ComputedBSize() - scrollbars.BStartEnd(wm), + ReflowInput::ResetResizeFlags::No); + return nsPoint(scrollbars.Left(wm), scrollbars.Top(wm)); + } + return nsPoint(0, 0); +} + +nsRect ViewportFrame::AdjustReflowInputAsContainingBlock( + ReflowInput* aReflowInput) const { +#ifdef DEBUG + nsPoint offset = +#endif + AdjustReflowInputForScrollbars(aReflowInput); + + NS_ASSERTION(GetAbsoluteContainingBlock()->GetChildList().IsEmpty() || + (offset.x == 0 && offset.y == 0), + "We don't handle correct positioning of fixed frames with " + "scrollbars in odd positions"); + + nsRect rect(0, 0, aReflowInput->ComputedWidth(), + aReflowInput->ComputedHeight()); + + rect.SizeTo(AdjustViewportSizeForFixedPosition(rect)); + + return rect; +} + +void ViewportFrame::Reflow(nsPresContext* aPresContext, + ReflowOutput& aDesiredSize, + const ReflowInput& aReflowInput, + nsReflowStatus& aStatus) { + MarkInReflow(); + DO_GLOBAL_REFLOW_COUNT("ViewportFrame"); + DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus); + MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!"); + NS_FRAME_TRACE_REFLOW_IN("ViewportFrame::Reflow"); + + // Because |Reflow| sets ComputedBSize() on the child to our + // ComputedBSize(). + AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE); + + // Set our size up front, since some parts of reflow depend on it + // being already set. Note that the computed height may be + // unconstrained; that's ok. Consumers should watch out for that. + SetSize(nsSize(aReflowInput.ComputedWidth(), aReflowInput.ComputedHeight())); + + // Reflow the main content first so that the placeholders of the + // fixed-position frames will be in the right places on an initial + // reflow. + nscoord kidBSize = 0; + WritingMode wm = aReflowInput.GetWritingMode(); + + if (mFrames.NotEmpty()) { + // Deal with a non-incremental reflow or an incremental reflow + // targeted at our one-and-only principal child frame. + if (aReflowInput.ShouldReflowAllKids() || + mFrames.FirstChild()->IsSubtreeDirty()) { + // Reflow our one-and-only principal child frame + nsIFrame* kidFrame = mFrames.FirstChild(); + ReflowOutput kidDesiredSize(aReflowInput); + const WritingMode kidWM = kidFrame->GetWritingMode(); + LogicalSize availableSpace = aReflowInput.AvailableSize(kidWM); + ReflowInput kidReflowInput(aPresContext, aReflowInput, kidFrame, + availableSpace); + + // Reflow the frame + kidReflowInput.SetComputedBSize(aReflowInput.ComputedBSize()); + ReflowChild(kidFrame, aPresContext, kidDesiredSize, kidReflowInput, 0, 0, + ReflowChildFlags::Default, aStatus); + kidBSize = kidDesiredSize.BSize(wm); + + FinishReflowChild(kidFrame, aPresContext, kidDesiredSize, &kidReflowInput, + 0, 0, ReflowChildFlags::Default); + } else { + kidBSize = LogicalSize(wm, mFrames.FirstChild()->GetSize()).BSize(wm); + } + } + + NS_ASSERTION(aReflowInput.AvailableISize() != NS_UNCONSTRAINEDSIZE, + "shouldn't happen anymore"); + + // Return the max size as our desired size + LogicalSize maxSize(wm, aReflowInput.AvailableISize(), + // Being flowed initially at an unconstrained block size + // means we should return our child's intrinsic size. + aReflowInput.ComputedBSize() != NS_UNCONSTRAINEDSIZE + ? aReflowInput.ComputedBSize() + : kidBSize); + aDesiredSize.SetSize(wm, maxSize); + aDesiredSize.SetOverflowAreasToDesiredBounds(); + + if (HasAbsolutelyPositionedChildren()) { + // Make a copy of the reflow input and change the computed width and height + // to reflect the available space for the fixed items + ReflowInput reflowInput(aReflowInput); + + if (reflowInput.AvailableBSize() == NS_UNCONSTRAINEDSIZE) { + // We have an intrinsic-block-size document with abs-pos/fixed-pos + // children. Set the available block-size and computed block-size to our + // chosen block-size. + reflowInput.SetAvailableBSize(maxSize.BSize(wm)); + // Not having border/padding simplifies things + NS_ASSERTION(reflowInput.ComputedPhysicalBorderPadding() == nsMargin(), + "Viewports can't have border/padding"); + reflowInput.SetComputedBSize(maxSize.BSize(wm)); + } + + nsRect rect = AdjustReflowInputAsContainingBlock(&reflowInput); + AbsPosReflowFlags flags = + AbsPosReflowFlags::CBWidthAndHeightChanged; // XXX could be optimized + GetAbsoluteContainingBlock()->Reflow(this, aPresContext, reflowInput, + aStatus, rect, flags, + /* aOverflowAreas = */ nullptr); + } + + if (mFrames.NotEmpty()) { + ConsiderChildOverflow(aDesiredSize.mOverflowAreas, mFrames.FirstChild()); + } + + // If we were dirty then do a repaint + if (HasAnyStateBits(NS_FRAME_IS_DIRTY)) { + InvalidateFrame(); + } + + // Clipping is handled by the document container (e.g., nsSubDocumentFrame), + // so we don't need to change our overflow areas. + FinishAndStoreOverflow(&aDesiredSize); + + NS_FRAME_TRACE_REFLOW_OUT("ViewportFrame::Reflow", aStatus); +} + +void ViewportFrame::UpdateStyle(ServoRestyleState& aRestyleState) { + RefPtr<ComputedStyle> newStyle = + aRestyleState.StyleSet().ResolveInheritingAnonymousBoxStyle( + Style()->GetPseudoType(), nullptr); + + MOZ_ASSERT(!GetNextContinuation(), "Viewport has continuations?"); + SetComputedStyle(newStyle); + + UpdateStyleOfOwnedAnonBoxes(aRestyleState); +} + +void ViewportFrame::AppendDirectlyOwnedAnonBoxes( + nsTArray<OwnedAnonBox>& aResult) { + if (mFrames.NotEmpty()) { + aResult.AppendElement(mFrames.FirstChild()); + } +} + +nsSize ViewportFrame::AdjustViewportSizeForFixedPosition( + const nsRect& aViewportRect) const { + nsSize result = aViewportRect.Size(); + + mozilla::PresShell* presShell = PresShell(); + // Layout fixed position elements to the visual viewport size if and only if + // it has been set and it is larger than the computed size, otherwise use the + // computed size. + if (presShell->IsVisualViewportSizeSet()) { + if (presShell->GetDynamicToolbarState() == DynamicToolbarState::Collapsed && + result < presShell->GetVisualViewportSizeUpdatedByDynamicToolbar()) { + // We need to use the viewport size updated by the dynamic toolbar in the + // case where the dynamic toolbar is completely hidden. + result = presShell->GetVisualViewportSizeUpdatedByDynamicToolbar(); + } else if (result < presShell->GetVisualViewportSize()) { + result = presShell->GetVisualViewportSize(); + } + } + // Expand the size to the layout viewport size if necessary. + const nsSize layoutViewportSize = presShell->GetLayoutViewportSize(); + if (result < layoutViewportSize) { + result = layoutViewportSize; + } + + return result; +} + +#ifdef DEBUG_FRAME_DUMP +nsresult ViewportFrame::GetFrameName(nsAString& aResult) const { + return MakeFrameName(u"Viewport"_ns, aResult); +} +#endif |