diff options
Diffstat (limited to 'layout/generic/nsContainerFrame.cpp')
| -rw-r--r-- | layout/generic/nsContainerFrame.cpp | 3079 |
1 files changed, 3079 insertions, 0 deletions
diff --git a/layout/generic/nsContainerFrame.cpp b/layout/generic/nsContainerFrame.cpp new file mode 100644 index 0000000000..813f6170a9 --- /dev/null +++ b/layout/generic/nsContainerFrame.cpp @@ -0,0 +1,3079 @@ +/* -*- 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/. */ + +/* base class #1 for rendering objects that have child lists */ + +#include "nsContainerFrame.h" +#include "mozilla/widget/InitData.h" +#include "nsContainerFrameInlines.h" + +#include "mozilla/ComputedStyle.h" +#include "mozilla/PresShell.h" +#include "mozilla/dom/HTMLSummaryElement.h" +#include "mozilla/gfx/2D.h" +#include "mozilla/gfx/Types.h" +#include "nsAbsoluteContainingBlock.h" +#include "nsAttrValue.h" +#include "nsAttrValueInlines.h" +#include "nsFlexContainerFrame.h" +#include "nsFrameSelection.h" +#include "mozilla/dom/Document.h" +#include "nsPresContext.h" +#include "nsRect.h" +#include "nsPoint.h" +#include "nsStyleConsts.h" +#include "nsView.h" +#include "nsCOMPtr.h" +#include "nsGkAtoms.h" +#include "nsViewManager.h" +#include "nsIWidget.h" +#include "nsCanvasFrame.h" +#include "nsCSSRendering.h" +#include "nsError.h" +#include "nsDisplayList.h" +#include "nsIBaseWindow.h" +#include "nsCSSFrameConstructor.h" +#include "nsBlockFrame.h" +#include "nsPlaceholderFrame.h" +#include "mozilla/AutoRestore.h" +#include "nsIFrameInlines.h" +#include "nsPrintfCString.h" +#include "mozilla/webrender/WebRenderAPI.h" +#include <algorithm> + +using namespace mozilla; +using namespace mozilla::dom; +using namespace mozilla::layout; + +using mozilla::gfx::ColorPattern; +using mozilla::gfx::DeviceColor; +using mozilla::gfx::DrawTarget; +using mozilla::gfx::Rect; +using mozilla::gfx::sRGBColor; +using mozilla::gfx::ToDeviceColor; + +nsContainerFrame::~nsContainerFrame() = default; + +NS_QUERYFRAME_HEAD(nsContainerFrame) + NS_QUERYFRAME_ENTRY(nsContainerFrame) +NS_QUERYFRAME_TAIL_INHERITING(nsSplittableFrame) + +void nsContainerFrame::Init(nsIContent* aContent, nsContainerFrame* aParent, + nsIFrame* aPrevInFlow) { + nsSplittableFrame::Init(aContent, aParent, aPrevInFlow); + if (aPrevInFlow) { + // Make sure we copy bits from our prev-in-flow that will affect + // us. A continuation for a container frame needs to know if it + // has a child with a view so that we'll properly reposition it. + if (aPrevInFlow->HasAnyStateBits(NS_FRAME_HAS_CHILD_WITH_VIEW)) { + AddStateBits(NS_FRAME_HAS_CHILD_WITH_VIEW); + } + } +} + +void nsContainerFrame::SetInitialChildList(ChildListID aListID, + nsFrameList&& aChildList) { +#ifdef DEBUG + nsIFrame::VerifyDirtyBitSet(aChildList); + for (nsIFrame* f : aChildList) { + MOZ_ASSERT(f->GetParent() == this, "Unexpected parent"); + } +#endif + if (aListID == FrameChildListID::Principal) { + MOZ_ASSERT(mFrames.IsEmpty(), + "unexpected second call to SetInitialChildList"); + mFrames = std::move(aChildList); + } else if (aListID == FrameChildListID::Backdrop) { + MOZ_ASSERT(StyleDisplay()->mTopLayer != StyleTopLayer::None, + "Only top layer frames should have backdrop"); + MOZ_ASSERT(HasAnyStateBits(NS_FRAME_OUT_OF_FLOW), + "Top layer frames should be out-of-flow"); + MOZ_ASSERT(!GetProperty(BackdropProperty()), + "We shouldn't have setup backdrop frame list before"); +#ifdef DEBUG + { + nsIFrame* placeholder = aChildList.FirstChild(); + MOZ_ASSERT(aChildList.OnlyChild(), "Should have only one backdrop"); + MOZ_ASSERT(placeholder->IsPlaceholderFrame(), + "The frame to be stored should be a placeholder"); + MOZ_ASSERT(static_cast<nsPlaceholderFrame*>(placeholder) + ->GetOutOfFlowFrame() + ->IsBackdropFrame(), + "The placeholder should points to a backdrop frame"); + } +#endif + nsFrameList* list = new (PresShell()) nsFrameList(std::move(aChildList)); + SetProperty(BackdropProperty(), list); + } else { + MOZ_ASSERT_UNREACHABLE("Unexpected child list"); + } +} + +void nsContainerFrame::AppendFrames(ChildListID aListID, + nsFrameList&& aFrameList) { + MOZ_ASSERT(aListID == FrameChildListID::Principal || + aListID == FrameChildListID::NoReflowPrincipal, + "unexpected child list"); + + if (MOZ_UNLIKELY(aFrameList.IsEmpty())) { + return; + } + + DrainSelfOverflowList(); // ensure the last frame is in mFrames + mFrames.AppendFrames(this, std::move(aFrameList)); + + if (aListID != FrameChildListID::NoReflowPrincipal) { + PresShell()->FrameNeedsReflow(this, IntrinsicDirty::FrameAndAncestors, + NS_FRAME_HAS_DIRTY_CHILDREN); + } +} + +void nsContainerFrame::InsertFrames(ChildListID aListID, nsIFrame* aPrevFrame, + const nsLineList::iterator* aPrevFrameLine, + nsFrameList&& aFrameList) { + MOZ_ASSERT(aListID == FrameChildListID::Principal || + aListID == FrameChildListID::NoReflowPrincipal, + "unexpected child list"); + NS_ASSERTION(!aPrevFrame || aPrevFrame->GetParent() == this, + "inserting after sibling frame with different parent"); + + if (MOZ_UNLIKELY(aFrameList.IsEmpty())) { + return; + } + + DrainSelfOverflowList(); // ensure aPrevFrame is in mFrames + mFrames.InsertFrames(this, aPrevFrame, std::move(aFrameList)); + + if (aListID != FrameChildListID::NoReflowPrincipal) { + PresShell()->FrameNeedsReflow(this, IntrinsicDirty::FrameAndAncestors, + NS_FRAME_HAS_DIRTY_CHILDREN); + } +} + +void nsContainerFrame::RemoveFrame(DestroyContext& aContext, + ChildListID aListID, nsIFrame* aOldFrame) { + MOZ_ASSERT(aListID == FrameChildListID::Principal || + aListID == FrameChildListID::NoReflowPrincipal, + "unexpected child list"); + + AutoTArray<nsIFrame*, 10> continuations; + { + nsIFrame* continuation = aOldFrame; + while (continuation) { + continuations.AppendElement(continuation); + continuation = continuation->GetNextContinuation(); + } + } + + mozilla::PresShell* presShell = PresShell(); + nsContainerFrame* lastParent = nullptr; + + // Loop and destroy aOldFrame and all of its continuations. + // + // Request a reflow on the parent frames involved unless we were explicitly + // told not to (FrameChildListID::NoReflowPrincipal). + const bool generateReflowCommand = + aListID != FrameChildListID::NoReflowPrincipal; + for (nsIFrame* continuation : Reversed(continuations)) { + nsContainerFrame* parent = continuation->GetParent(); + + // Please note that 'parent' may not actually be where 'continuation' lives. + // We really MUST use StealFrame() and nothing else here. + // @see nsInlineFrame::StealFrame for details. + parent->StealFrame(continuation); + continuation->Destroy(aContext); + if (generateReflowCommand && parent != lastParent) { + presShell->FrameNeedsReflow(parent, IntrinsicDirty::FrameAndAncestors, + NS_FRAME_HAS_DIRTY_CHILDREN); + lastParent = parent; + } + } +} + +void nsContainerFrame::DestroyAbsoluteFrames(DestroyContext& aContext) { + if (IsAbsoluteContainer()) { + GetAbsoluteContainingBlock()->DestroyFrames(aContext); + MarkAsNotAbsoluteContainingBlock(); + } +} + +void nsContainerFrame::SafelyDestroyFrameListProp( + DestroyContext& aContext, mozilla::PresShell* aPresShell, + FrameListPropertyDescriptor aProp) { + // Note that the last frame can be removed through another route and thus + // delete the property -- that's why we fetch the property again before + // removing each frame rather than fetching it once and iterating the list. + while (nsFrameList* frameList = GetProperty(aProp)) { + nsIFrame* frame = frameList->RemoveFirstChild(); + if (MOZ_LIKELY(frame)) { + frame->Destroy(aContext); + } else { + Unused << TakeProperty(aProp); + frameList->Delete(aPresShell); + return; + } + } +} + +void nsContainerFrame::Destroy(DestroyContext& aContext) { + // Prevent event dispatch during destruction. + if (HasView()) { + GetView()->SetFrame(nullptr); + } + + DestroyAbsoluteFrames(aContext); + + // Destroy frames on the principal child list. + mFrames.DestroyFrames(aContext); + + // If we have any IB split siblings, clear their references to us. + if (HasAnyStateBits(NS_FRAME_PART_OF_IBSPLIT)) { + // Delete previous sibling's reference to me. + if (nsIFrame* prevSib = GetProperty(nsIFrame::IBSplitPrevSibling())) { + NS_WARNING_ASSERTION( + this == prevSib->GetProperty(nsIFrame::IBSplitSibling()), + "IB sibling chain is inconsistent"); + prevSib->RemoveProperty(nsIFrame::IBSplitSibling()); + } + + // Delete next sibling's reference to me. + if (nsIFrame* nextSib = GetProperty(nsIFrame::IBSplitSibling())) { + NS_WARNING_ASSERTION( + this == nextSib->GetProperty(nsIFrame::IBSplitPrevSibling()), + "IB sibling chain is inconsistent"); + nextSib->RemoveProperty(nsIFrame::IBSplitPrevSibling()); + } + +#ifdef DEBUG + // This is just so we can assert it's not set in nsIFrame::DestroyFrom. + RemoveStateBits(NS_FRAME_PART_OF_IBSPLIT); +#endif + } + + if (MOZ_UNLIKELY(!mProperties.IsEmpty())) { + using T = mozilla::FrameProperties::UntypedDescriptor; + bool hasO = false, hasOC = false, hasEOC = false, hasBackdrop = false; + mProperties.ForEach([&](const T& aProp, uint64_t) { + if (aProp == OverflowProperty()) { + hasO = true; + } else if (aProp == OverflowContainersProperty()) { + hasOC = true; + } else if (aProp == ExcessOverflowContainersProperty()) { + hasEOC = true; + } else if (aProp == BackdropProperty()) { + hasBackdrop = true; + } + return true; + }); + + // Destroy frames on the auxiliary frame lists and delete the lists. + nsPresContext* pc = PresContext(); + mozilla::PresShell* presShell = pc->PresShell(); + if (hasO) { + SafelyDestroyFrameListProp(aContext, presShell, OverflowProperty()); + } + + MOZ_ASSERT( + IsFrameOfType(eCanContainOverflowContainers) || !(hasOC || hasEOC), + "this type of frame shouldn't have overflow containers"); + if (hasOC) { + SafelyDestroyFrameListProp(aContext, presShell, + OverflowContainersProperty()); + } + if (hasEOC) { + SafelyDestroyFrameListProp(aContext, presShell, + ExcessOverflowContainersProperty()); + } + + MOZ_ASSERT(!GetProperty(BackdropProperty()) || + StyleDisplay()->mTopLayer != StyleTopLayer::None, + "only top layer frame may have backdrop"); + if (hasBackdrop) { + SafelyDestroyFrameListProp(aContext, presShell, BackdropProperty()); + } + } + + nsSplittableFrame::Destroy(aContext); +} + +///////////////////////////////////////////////////////////////////////////// +// Child frame enumeration + +const nsFrameList& nsContainerFrame::GetChildList(ChildListID aListID) const { + // We only know about the principal child list, the overflow lists, + // and the backdrop list. + switch (aListID) { + case FrameChildListID::Principal: + return mFrames; + case FrameChildListID::Overflow: { + nsFrameList* list = GetOverflowFrames(); + return list ? *list : nsFrameList::EmptyList(); + } + case FrameChildListID::OverflowContainers: { + nsFrameList* list = GetOverflowContainers(); + return list ? *list : nsFrameList::EmptyList(); + } + case FrameChildListID::ExcessOverflowContainers: { + nsFrameList* list = GetExcessOverflowContainers(); + return list ? *list : nsFrameList::EmptyList(); + } + case FrameChildListID::Backdrop: { + nsFrameList* list = GetProperty(BackdropProperty()); + return list ? *list : nsFrameList::EmptyList(); + } + default: + return nsSplittableFrame::GetChildList(aListID); + } +} + +void nsContainerFrame::GetChildLists(nsTArray<ChildList>* aLists) const { + mFrames.AppendIfNonempty(aLists, FrameChildListID::Principal); + + using T = mozilla::FrameProperties::UntypedDescriptor; + mProperties.ForEach([this, aLists](const T& aProp, uint64_t aValue) { + typedef const nsFrameList* L; + if (aProp == OverflowProperty()) { + reinterpret_cast<L>(aValue)->AppendIfNonempty(aLists, + FrameChildListID::Overflow); + } else if (aProp == OverflowContainersProperty()) { + MOZ_ASSERT(IsFrameOfType(nsIFrame::eCanContainOverflowContainers), + "found unexpected OverflowContainersProperty"); + Unused << this; // silence clang -Wunused-lambda-capture in opt builds + reinterpret_cast<L>(aValue)->AppendIfNonempty( + aLists, FrameChildListID::OverflowContainers); + } else if (aProp == ExcessOverflowContainersProperty()) { + MOZ_ASSERT(IsFrameOfType(nsIFrame::eCanContainOverflowContainers), + "found unexpected ExcessOverflowContainersProperty"); + Unused << this; // silence clang -Wunused-lambda-capture in opt builds + reinterpret_cast<L>(aValue)->AppendIfNonempty( + aLists, FrameChildListID::ExcessOverflowContainers); + } else if (aProp == BackdropProperty()) { + reinterpret_cast<L>(aValue)->AppendIfNonempty(aLists, + FrameChildListID::Backdrop); + } + return true; + }); + + nsSplittableFrame::GetChildLists(aLists); +} + +///////////////////////////////////////////////////////////////////////////// +// Painting/Events + +void nsContainerFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder, + const nsDisplayListSet& aLists) { + DisplayBorderBackgroundOutline(aBuilder, aLists); + BuildDisplayListForNonBlockChildren(aBuilder, aLists); +} + +void nsContainerFrame::BuildDisplayListForNonBlockChildren( + nsDisplayListBuilder* aBuilder, const nsDisplayListSet& aLists, + DisplayChildFlags aFlags) { + nsIFrame* kid = mFrames.FirstChild(); + // Put each child's background directly onto the content list + nsDisplayListSet set(aLists, aLists.Content()); + // The children should be in content order + while (kid) { + BuildDisplayListForChild(aBuilder, kid, set, aFlags); + kid = kid->GetNextSibling(); + } +} + +class nsDisplaySelectionOverlay : public nsPaintedDisplayItem { + public: + /** + * @param aSelectionValue nsISelectionController::getDisplaySelection. + */ + nsDisplaySelectionOverlay(nsDisplayListBuilder* aBuilder, nsIFrame* aFrame, + int16_t aSelectionValue) + : nsPaintedDisplayItem(aBuilder, aFrame), + mSelectionValue(aSelectionValue) { + MOZ_COUNT_CTOR(nsDisplaySelectionOverlay); + } + MOZ_COUNTED_DTOR_OVERRIDE(nsDisplaySelectionOverlay) + + virtual void Paint(nsDisplayListBuilder* aBuilder, gfxContext* aCtx) override; + bool CreateWebRenderCommands( + mozilla::wr::DisplayListBuilder& aBuilder, + mozilla::wr::IpcResourceUpdateQueue& aResources, + const StackingContextHelper& aSc, + mozilla::layers::RenderRootStateManager* aManager, + nsDisplayListBuilder* aDisplayListBuilder) override; + NS_DISPLAY_DECL_NAME("SelectionOverlay", TYPE_SELECTION_OVERLAY) + private: + DeviceColor ComputeColor() const; + + static DeviceColor ComputeColorFromSelectionStyle(ComputedStyle&); + static DeviceColor ApplyTransparencyIfNecessary(nscolor); + + // nsISelectionController::getDisplaySelection. + int16_t mSelectionValue; +}; + +DeviceColor nsDisplaySelectionOverlay::ApplyTransparencyIfNecessary( + nscolor aColor) { + // If it has already alpha, leave it like that. + if (NS_GET_A(aColor) != 255) { + return ToDeviceColor(aColor); + } + + // NOTE(emilio): Blink and WebKit do something slightly different here, and + // blend the color with white instead, both for overlays and text backgrounds. + auto color = sRGBColor::FromABGR(aColor); + color.a = 0.5; + return ToDeviceColor(color); +} + +DeviceColor nsDisplaySelectionOverlay::ComputeColorFromSelectionStyle( + ComputedStyle& aStyle) { + return ApplyTransparencyIfNecessary( + aStyle.GetVisitedDependentColor(&nsStyleBackground::mBackgroundColor)); +} + +DeviceColor nsDisplaySelectionOverlay::ComputeColor() const { + LookAndFeel::ColorID colorID; + if (RefPtr<ComputedStyle> style = + mFrame->ComputeSelectionStyle(mSelectionValue)) { + return ComputeColorFromSelectionStyle(*style); + } + if (mSelectionValue == nsISelectionController::SELECTION_ON) { + colorID = LookAndFeel::ColorID::Highlight; + } else if (mSelectionValue == nsISelectionController::SELECTION_ATTENTION) { + colorID = LookAndFeel::ColorID::TextSelectAttentionBackground; + } else { + colorID = LookAndFeel::ColorID::TextSelectDisabledBackground; + } + + return ApplyTransparencyIfNecessary( + LookAndFeel::Color(colorID, mFrame, NS_RGB(255, 255, 255))); +} + +void nsDisplaySelectionOverlay::Paint(nsDisplayListBuilder* aBuilder, + gfxContext* aCtx) { + DrawTarget& aDrawTarget = *aCtx->GetDrawTarget(); + ColorPattern color(ComputeColor()); + + nsIntRect pxRect = + GetPaintRect(aBuilder, aCtx) + .ToOutsidePixels(mFrame->PresContext()->AppUnitsPerDevPixel()); + Rect rect(pxRect.x, pxRect.y, pxRect.width, pxRect.height); + MaybeSnapToDevicePixels(rect, aDrawTarget, true); + + aDrawTarget.FillRect(rect, color); +} + +bool nsDisplaySelectionOverlay::CreateWebRenderCommands( + mozilla::wr::DisplayListBuilder& aBuilder, + mozilla::wr::IpcResourceUpdateQueue& aResources, + const StackingContextHelper& aSc, + mozilla::layers::RenderRootStateManager* aManager, + nsDisplayListBuilder* aDisplayListBuilder) { + wr::LayoutRect bounds = wr::ToLayoutRect(LayoutDeviceRect::FromAppUnits( + nsRect(ToReferenceFrame(), Frame()->GetSize()), + mFrame->PresContext()->AppUnitsPerDevPixel())); + aBuilder.PushRect(bounds, bounds, !BackfaceIsHidden(), false, false, + wr::ToColorF(ComputeColor())); + return true; +} + +void nsContainerFrame::DisplaySelectionOverlay(nsDisplayListBuilder* aBuilder, + nsDisplayList* aList, + uint16_t aContentType) { + if (!IsSelected() || !IsVisibleForPainting()) { + return; + } + + int16_t displaySelection = PresShell()->GetSelectionFlags(); + if (!(displaySelection & aContentType)) { + return; + } + + const nsFrameSelection* frameSelection = GetConstFrameSelection(); + int16_t selectionValue = frameSelection->GetDisplaySelection(); + + if (selectionValue <= nsISelectionController::SELECTION_HIDDEN) { + return; // selection is hidden or off + } + + nsIContent* newContent = mContent->GetParent(); + + // check to see if we are anonymous content + // XXXbz there has GOT to be a better way of determining this! + int32_t offset = + newContent ? newContent->ComputeIndexOf_Deprecated(mContent) : 0; + + // look up to see what selection(s) are on this frame + UniquePtr<SelectionDetails> details = + frameSelection->LookUpSelection(newContent, offset, 1, false); + if (!details) { + return; + } + + bool normal = false; + for (SelectionDetails* sd = details.get(); sd; sd = sd->mNext.get()) { + if (sd->mSelectionType == SelectionType::eNormal) { + normal = true; + } + } + + if (!normal && aContentType == nsISelectionDisplay::DISPLAY_IMAGES) { + // Don't overlay an image if it's not in the primary selection. + return; + } + + aList->AppendNewToTop<nsDisplaySelectionOverlay>(aBuilder, this, + selectionValue); +} + +/* virtual */ +void nsContainerFrame::ChildIsDirty(nsIFrame* aChild) { + NS_ASSERTION(aChild->IsSubtreeDirty(), "child isn't actually dirty"); + + AddStateBits(NS_FRAME_HAS_DIRTY_CHILDREN); +} + +nsIFrame::FrameSearchResult nsContainerFrame::PeekOffsetNoAmount( + bool aForward, int32_t* aOffset) { + NS_ASSERTION(aOffset && *aOffset <= 1, "aOffset out of range"); + // Don't allow the caret to stay in an empty (leaf) container frame. + return CONTINUE_EMPTY; +} + +nsIFrame::FrameSearchResult nsContainerFrame::PeekOffsetCharacter( + bool aForward, int32_t* aOffset, PeekOffsetCharacterOptions aOptions) { + NS_ASSERTION(aOffset && *aOffset <= 1, "aOffset out of range"); + // Don't allow the caret to stay in an empty (leaf) container frame. + return CONTINUE_EMPTY; +} + +///////////////////////////////////////////////////////////////////////////// +// Helper member functions + +/** + * Position the view associated with |aKidFrame|, if there is one. A + * container frame should call this method after positioning a frame, + * but before |Reflow|. + */ +void nsContainerFrame::PositionFrameView(nsIFrame* aKidFrame) { + nsIFrame* parentFrame = aKidFrame->GetParent(); + if (!aKidFrame->HasView() || !parentFrame) return; + + nsView* view = aKidFrame->GetView(); + nsViewManager* vm = view->GetViewManager(); + nsPoint pt; + nsView* ancestorView = parentFrame->GetClosestView(&pt); + + if (ancestorView != view->GetParent()) { + NS_ASSERTION(ancestorView == view->GetParent()->GetParent(), + "Allowed only one anonymous view between frames"); + // parentFrame is responsible for positioning aKidFrame's view + // explicitly + return; + } + + pt += aKidFrame->GetPosition(); + vm->MoveViewTo(view, pt.x, pt.y); +} + +void nsContainerFrame::ReparentFrameView(nsIFrame* aChildFrame, + nsIFrame* aOldParentFrame, + nsIFrame* aNewParentFrame) { +#ifdef DEBUG + MOZ_ASSERT(aChildFrame, "null child frame pointer"); + MOZ_ASSERT(aOldParentFrame, "null old parent frame pointer"); + MOZ_ASSERT(aNewParentFrame, "null new parent frame pointer"); + MOZ_ASSERT(aOldParentFrame != aNewParentFrame, + "same old and new parent frame"); + + // See if either the old parent frame or the new parent frame have a view + while (!aOldParentFrame->HasView() && !aNewParentFrame->HasView()) { + // Walk up both the old parent frame and the new parent frame nodes + // stopping when we either find a common parent or views for one + // or both of the frames. + // + // This works well in the common case where we push/pull and the old parent + // frame and the new parent frame are part of the same flow. They will + // typically be the same distance (height wise) from the + aOldParentFrame = aOldParentFrame->GetParent(); + aNewParentFrame = aNewParentFrame->GetParent(); + + // We should never walk all the way to the root frame without finding + // a view + NS_ASSERTION(aOldParentFrame && aNewParentFrame, "didn't find view"); + + // See if we reached a common ancestor + if (aOldParentFrame == aNewParentFrame) { + break; + } + } + + // See if we found a common parent frame + if (aOldParentFrame == aNewParentFrame) { + // We found a common parent and there are no views between the old parent + // and the common parent or the new parent frame and the common parent. + // Because neither the old parent frame nor the new parent frame have views, + // then any child views don't need reparenting + return; + } + + // We found views for one or both of the ancestor frames before we + // found a common ancestor. + nsView* oldParentView = aOldParentFrame->GetClosestView(); + nsView* newParentView = aNewParentFrame->GetClosestView(); + + // See if the old parent frame and the new parent frame are in the + // same view sub-hierarchy. If they are then we don't have to do + // anything + if (oldParentView != newParentView) { + MOZ_ASSERT_UNREACHABLE("can't move frames between views"); + // They're not so we need to reparent any child views + aChildFrame->ReparentFrameViewTo(oldParentView->GetViewManager(), + newParentView); + } +#endif +} + +void nsContainerFrame::ReparentFrameViewList(const nsFrameList& aChildFrameList, + nsIFrame* aOldParentFrame, + nsIFrame* aNewParentFrame) { +#ifdef DEBUG + MOZ_ASSERT(aChildFrameList.NotEmpty(), "empty child frame list"); + MOZ_ASSERT(aOldParentFrame, "null old parent frame pointer"); + MOZ_ASSERT(aNewParentFrame, "null new parent frame pointer"); + MOZ_ASSERT(aOldParentFrame != aNewParentFrame, + "same old and new parent frame"); + + // See if either the old parent frame or the new parent frame have a view + while (!aOldParentFrame->HasView() && !aNewParentFrame->HasView()) { + // Walk up both the old parent frame and the new parent frame nodes + // stopping when we either find a common parent or views for one + // or both of the frames. + // + // This works well in the common case where we push/pull and the old parent + // frame and the new parent frame are part of the same flow. They will + // typically be the same distance (height wise) from the + aOldParentFrame = aOldParentFrame->GetParent(); + aNewParentFrame = aNewParentFrame->GetParent(); + + // We should never walk all the way to the root frame without finding + // a view + NS_ASSERTION(aOldParentFrame && aNewParentFrame, "didn't find view"); + + // See if we reached a common ancestor + if (aOldParentFrame == aNewParentFrame) { + break; + } + } + + // See if we found a common parent frame + if (aOldParentFrame == aNewParentFrame) { + // We found a common parent and there are no views between the old parent + // and the common parent or the new parent frame and the common parent. + // Because neither the old parent frame nor the new parent frame have views, + // then any child views don't need reparenting + return; + } + + // We found views for one or both of the ancestor frames before we + // found a common ancestor. + nsView* oldParentView = aOldParentFrame->GetClosestView(); + nsView* newParentView = aNewParentFrame->GetClosestView(); + + // See if the old parent frame and the new parent frame are in the + // same view sub-hierarchy. If they are then we don't have to do + // anything + if (oldParentView != newParentView) { + MOZ_ASSERT_UNREACHABLE("can't move frames between views"); + nsViewManager* viewManager = oldParentView->GetViewManager(); + + // They're not so we need to reparent any child views + for (nsIFrame* f : aChildFrameList) { + f->ReparentFrameViewTo(viewManager, newParentView); + } + } +#endif +} + +void nsContainerFrame::ReparentFrame(nsIFrame* aFrame, + nsContainerFrame* aOldParent, + nsContainerFrame* aNewParent) { + NS_ASSERTION(aOldParent == aFrame->GetParent(), + "Parent not consistent with expectations"); + + aFrame->SetParent(aNewParent); + + // When pushing and pulling frames we need to check for whether any + // views need to be reparented + ReparentFrameView(aFrame, aOldParent, aNewParent); +} + +void nsContainerFrame::ReparentFrames(nsFrameList& aFrameList, + nsContainerFrame* aOldParent, + nsContainerFrame* aNewParent) { + for (auto* f : aFrameList) { + ReparentFrame(f, aOldParent, aNewParent); + } +} + +void nsContainerFrame::SetSizeConstraints(nsPresContext* aPresContext, + nsIWidget* aWidget, + const nsSize& aMinSize, + const nsSize& aMaxSize) { + LayoutDeviceIntSize devMinSize( + aPresContext->AppUnitsToDevPixels(aMinSize.width), + aPresContext->AppUnitsToDevPixels(aMinSize.height)); + LayoutDeviceIntSize devMaxSize( + aMaxSize.width == NS_UNCONSTRAINEDSIZE + ? NS_MAXSIZE + : aPresContext->AppUnitsToDevPixels(aMaxSize.width), + aMaxSize.height == NS_UNCONSTRAINEDSIZE + ? NS_MAXSIZE + : aPresContext->AppUnitsToDevPixels(aMaxSize.height)); + + // MinSize has a priority over MaxSize + if (devMinSize.width > devMaxSize.width) devMaxSize.width = devMinSize.width; + if (devMinSize.height > devMaxSize.height) + devMaxSize.height = devMinSize.height; + + nsIWidget* rootWidget = aPresContext->GetNearestWidget(); + DesktopToLayoutDeviceScale constraintsScale(MOZ_WIDGET_INVALID_SCALE); + if (rootWidget) { + constraintsScale = rootWidget->GetDesktopToDeviceScale(); + } + + widget::SizeConstraints constraints(devMinSize, devMaxSize, constraintsScale); + + // The sizes are in inner window sizes, so convert them into outer window + // sizes. Use a size of (200, 200) as only the difference between the inner + // and outer size is needed. + const LayoutDeviceIntSize sizeDiff = aWidget->ClientToWindowSizeDifference(); + if (constraints.mMinSize.width) { + constraints.mMinSize.width += sizeDiff.width; + } + if (constraints.mMinSize.height) { + constraints.mMinSize.height += sizeDiff.height; + } + if (constraints.mMaxSize.width != NS_MAXSIZE) { + constraints.mMaxSize.width += sizeDiff.width; + } + if (constraints.mMaxSize.height != NS_MAXSIZE) { + constraints.mMaxSize.height += sizeDiff.height; + } + + aWidget->SetSizeConstraints(constraints); +} + +void nsContainerFrame::SyncFrameViewAfterReflow(nsPresContext* aPresContext, + nsIFrame* aFrame, nsView* aView, + const nsRect& aInkOverflowArea, + ReflowChildFlags aFlags) { + if (!aView) { + return; + } + + // Make sure the view is sized and positioned correctly + if (!(aFlags & ReflowChildFlags::NoMoveView)) { + PositionFrameView(aFrame); + } + + if (!(aFlags & ReflowChildFlags::NoSizeView)) { + nsViewManager* vm = aView->GetViewManager(); + + vm->ResizeView(aView, aInkOverflowArea, true); + } +} + +void nsContainerFrame::DoInlineMinISize(gfxContext* aRenderingContext, + InlineMinISizeData* aData) { + auto handleChildren = [aRenderingContext](auto frame, auto data) { + for (nsIFrame* kid : frame->mFrames) { + kid->AddInlineMinISize(aRenderingContext, data); + } + }; + DoInlineIntrinsicISize(aData, handleChildren); +} + +void nsContainerFrame::DoInlinePrefISize(gfxContext* aRenderingContext, + InlinePrefISizeData* aData) { + auto handleChildren = [aRenderingContext](auto frame, auto data) { + for (nsIFrame* kid : frame->mFrames) { + kid->AddInlinePrefISize(aRenderingContext, data); + } + }; + DoInlineIntrinsicISize(aData, handleChildren); + aData->mLineIsEmpty = false; +} + +/* virtual */ +LogicalSize nsContainerFrame::ComputeAutoSize( + gfxContext* aRenderingContext, WritingMode aWM, const LogicalSize& aCBSize, + nscoord aAvailableISize, const LogicalSize& aMargin, + const mozilla::LogicalSize& aBorderPadding, + const StyleSizeOverrides& aSizeOverrides, ComputeSizeFlags aFlags) { + LogicalSize result(aWM, 0xdeadbeef, NS_UNCONSTRAINEDSIZE); + nscoord availBased = + aAvailableISize - aMargin.ISize(aWM) - aBorderPadding.ISize(aWM); + // replaced elements always shrink-wrap + if (aFlags.contains(ComputeSizeFlag::ShrinkWrap) || + IsFrameOfType(eReplaced)) { + // Only bother computing our 'auto' ISize if the result will be used. + const auto& styleISize = aSizeOverrides.mStyleISize + ? *aSizeOverrides.mStyleISize + : StylePosition()->ISize(aWM); + if (styleISize.IsAuto()) { + result.ISize(aWM) = + ShrinkISizeToFit(aRenderingContext, availBased, aFlags); + } + } else { + result.ISize(aWM) = availBased; + } + + if (IsTableCaption()) { + // If we're a container for font size inflation, then shrink + // wrapping inside of us should not apply font size inflation. + AutoMaybeDisableFontInflation an(this); + + WritingMode tableWM = GetParent()->GetWritingMode(); + if (aWM.IsOrthogonalTo(tableWM)) { + // For an orthogonal caption on a block-dir side of the table, shrink-wrap + // to min-isize. + result.ISize(aWM) = GetMinISize(aRenderingContext); + } else { + // The outer frame constrains our available isize to the isize of + // the table. Grow if our min-isize is bigger than that, but not + // larger than the containing block isize. (It would really be nice + // to transmit that information another way, so we could grow up to + // the table's available isize, but that's harder.) + nscoord min = GetMinISize(aRenderingContext); + if (min > aCBSize.ISize(aWM)) { + min = aCBSize.ISize(aWM); + } + if (min > result.ISize(aWM)) { + result.ISize(aWM) = min; + } + } + } + return result; +} + +void nsContainerFrame::ReflowChild( + nsIFrame* aKidFrame, nsPresContext* aPresContext, + ReflowOutput& aDesiredSize, const ReflowInput& aReflowInput, + const WritingMode& aWM, const LogicalPoint& aPos, + const nsSize& aContainerSize, ReflowChildFlags aFlags, + nsReflowStatus& aStatus, nsOverflowContinuationTracker* aTracker) { + MOZ_ASSERT(aReflowInput.mFrame == aKidFrame, "bad reflow input"); + if (aWM.IsPhysicalRTL()) { + NS_ASSERTION(aContainerSize.width != NS_UNCONSTRAINEDSIZE, + "ReflowChild with unconstrained container width!"); + } + MOZ_ASSERT(aDesiredSize.InkOverflow() == nsRect(0, 0, 0, 0) && + aDesiredSize.ScrollableOverflow() == nsRect(0, 0, 0, 0), + "please reset the overflow areas before calling ReflowChild"); + + // Position the child frame and its view if requested. + if (ReflowChildFlags::NoMoveFrame != + (aFlags & ReflowChildFlags::NoMoveFrame)) { + aKidFrame->SetPosition(aWM, aPos, aContainerSize); + } + + if (!(aFlags & ReflowChildFlags::NoMoveView)) { + PositionFrameView(aKidFrame); + PositionChildViews(aKidFrame); + } + + // Reflow the child frame + aKidFrame->Reflow(aPresContext, aDesiredSize, aReflowInput, aStatus); + + // If the child frame is complete, delete any next-in-flows, + // but only if the NoDeleteNextInFlowChild flag isn't set. + if (!aStatus.IsInlineBreakBefore() && aStatus.IsFullyComplete() && + !(aFlags & ReflowChildFlags::NoDeleteNextInFlowChild)) { + if (nsIFrame* kidNextInFlow = aKidFrame->GetNextInFlow()) { + // Remove all of the childs next-in-flows. Make sure that we ask + // the right parent to do the removal (it's possible that the + // parent is not this because we are executing pullup code) + nsOverflowContinuationTracker::AutoFinish fini(aTracker, aKidFrame); + DestroyContext context(PresShell()); + kidNextInFlow->GetParent()->DeleteNextInFlowChild(context, kidNextInFlow, + true); + } + } +} + +// XXX temporary: hold on to a copy of the old physical version of +// ReflowChild so that we can convert callers incrementally. +void nsContainerFrame::ReflowChild(nsIFrame* aKidFrame, + nsPresContext* aPresContext, + ReflowOutput& aDesiredSize, + const ReflowInput& aReflowInput, nscoord aX, + nscoord aY, ReflowChildFlags aFlags, + nsReflowStatus& aStatus, + nsOverflowContinuationTracker* aTracker) { + MOZ_ASSERT(aReflowInput.mFrame == aKidFrame, "bad reflow input"); + + // Position the child frame and its view if requested. + if (ReflowChildFlags::NoMoveFrame != + (aFlags & ReflowChildFlags::NoMoveFrame)) { + aKidFrame->SetPosition(nsPoint(aX, aY)); + } + + if (!(aFlags & ReflowChildFlags::NoMoveView)) { + PositionFrameView(aKidFrame); + PositionChildViews(aKidFrame); + } + + // Reflow the child frame + aKidFrame->Reflow(aPresContext, aDesiredSize, aReflowInput, aStatus); + + // If the child frame is complete, delete any next-in-flows, + // but only if the NoDeleteNextInFlowChild flag isn't set. + if (aStatus.IsFullyComplete() && + !(aFlags & ReflowChildFlags::NoDeleteNextInFlowChild)) { + if (nsIFrame* kidNextInFlow = aKidFrame->GetNextInFlow()) { + // Remove all of the childs next-in-flows. Make sure that we ask + // the right parent to do the removal (it's possible that the + // parent is not this because we are executing pullup code) + nsOverflowContinuationTracker::AutoFinish fini(aTracker, aKidFrame); + DestroyContext context(PresShell()); + kidNextInFlow->GetParent()->DeleteNextInFlowChild(context, kidNextInFlow, + true); + } + } +} + +/** + * Position the views of |aFrame|'s descendants. A container frame + * should call this method if it moves a frame after |Reflow|. + */ +void nsContainerFrame::PositionChildViews(nsIFrame* aFrame) { + if (!aFrame->HasAnyStateBits(NS_FRAME_HAS_CHILD_WITH_VIEW)) { + return; + } + + // Recursively walk aFrame's child frames. + // Process the additional child lists, but skip the popup list as the view for + // popups is managed by the parent. + // Currently only nsMenuFrame has a popupList and during layout will adjust + // the view manually to position the popup. + for (const auto& [list, listID] : aFrame->ChildLists()) { + if (listID == FrameChildListID::Popup) { + continue; + } + for (nsIFrame* childFrame : list) { + // Position the frame's view (if it has one) otherwise recursively + // process its children + if (childFrame->HasView()) { + PositionFrameView(childFrame); + } else { + PositionChildViews(childFrame); + } + } + } +} + +/** + * De-optimize function to work around a VC2017 15.5+ compiler bug: + * https://bugzil.la/1424281#c12 + */ +#if defined(_MSC_VER) && !defined(__clang__) && defined(_M_AMD64) +# pragma optimize("g", off) +#endif +void nsContainerFrame::FinishReflowChild( + nsIFrame* aKidFrame, nsPresContext* aPresContext, + const ReflowOutput& aDesiredSize, const ReflowInput* aReflowInput, + const WritingMode& aWM, const LogicalPoint& aPos, + const nsSize& aContainerSize, nsIFrame::ReflowChildFlags aFlags) { + MOZ_ASSERT(!aReflowInput || aReflowInput->mFrame == aKidFrame); + MOZ_ASSERT(aReflowInput || aKidFrame->IsFrameOfType(eMathML) || + aKidFrame->IsTableCellFrame(), + "aReflowInput should be passed in almost all cases"); + + if (aWM.IsPhysicalRTL()) { + NS_ASSERTION(aContainerSize.width != NS_UNCONSTRAINEDSIZE, + "FinishReflowChild with unconstrained container width!"); + } + + nsPoint curOrigin = aKidFrame->GetPosition(); + const LogicalSize convertedSize = aDesiredSize.Size(aWM); + LogicalPoint pos(aPos); + + if (aFlags & ReflowChildFlags::ApplyRelativePositioning) { + MOZ_ASSERT(aReflowInput, "caller must have passed reflow input"); + // ApplyRelativePositioning in right-to-left writing modes needs to know + // the updated frame width to set the normal position correctly. + aKidFrame->SetSize(aWM, convertedSize); + + const LogicalMargin offsets = aReflowInput->ComputedLogicalOffsets(aWM); + ReflowInput::ApplyRelativePositioning(aKidFrame, aWM, offsets, &pos, + aContainerSize); + } + + if (ReflowChildFlags::NoMoveFrame != + (aFlags & ReflowChildFlags::NoMoveFrame)) { + aKidFrame->SetRect(aWM, LogicalRect(aWM, pos, convertedSize), + aContainerSize); + } else { + aKidFrame->SetSize(aWM, convertedSize); + } + + if (aKidFrame->HasView()) { + nsView* view = aKidFrame->GetView(); + // Make sure the frame's view is properly sized and positioned and has + // things like opacity correct + SyncFrameViewAfterReflow(aPresContext, aKidFrame, view, + aDesiredSize.InkOverflow(), aFlags); + } + + nsPoint newOrigin = aKidFrame->GetPosition(); + if (!(aFlags & ReflowChildFlags::NoMoveView) && curOrigin != newOrigin) { + if (!aKidFrame->HasView()) { + // If the frame has moved, then we need to make sure any child views are + // correctly positioned + PositionChildViews(aKidFrame); + } + } + + aKidFrame->DidReflow(aPresContext, aReflowInput); +} +#if defined(_MSC_VER) && !defined(__clang__) && defined(_M_AMD64) +# pragma optimize("", on) +#endif + +// XXX temporary: hold on to a copy of the old physical version of +// FinishReflowChild so that we can convert callers incrementally. +void nsContainerFrame::FinishReflowChild(nsIFrame* aKidFrame, + nsPresContext* aPresContext, + const ReflowOutput& aDesiredSize, + const ReflowInput* aReflowInput, + nscoord aX, nscoord aY, + ReflowChildFlags aFlags) { + MOZ_ASSERT(!(aFlags & ReflowChildFlags::ApplyRelativePositioning), + "only the logical version supports ApplyRelativePositioning " + "since ApplyRelativePositioning requires the container size"); + + nsPoint curOrigin = aKidFrame->GetPosition(); + nsPoint pos(aX, aY); + nsSize size(aDesiredSize.PhysicalSize()); + + if (ReflowChildFlags::NoMoveFrame != + (aFlags & ReflowChildFlags::NoMoveFrame)) { + aKidFrame->SetRect(nsRect(pos, size)); + } else { + aKidFrame->SetSize(size); + } + + if (aKidFrame->HasView()) { + nsView* view = aKidFrame->GetView(); + // Make sure the frame's view is properly sized and positioned and has + // things like opacity correct + SyncFrameViewAfterReflow(aPresContext, aKidFrame, view, + aDesiredSize.InkOverflow(), aFlags); + } + + if (!(aFlags & ReflowChildFlags::NoMoveView) && curOrigin != pos) { + if (!aKidFrame->HasView()) { + // If the frame has moved, then we need to make sure any child views are + // correctly positioned + PositionChildViews(aKidFrame); + } + } + + aKidFrame->DidReflow(aPresContext, aReflowInput); +} + +void nsContainerFrame::ReflowOverflowContainerChildren( + nsPresContext* aPresContext, const ReflowInput& aReflowInput, + OverflowAreas& aOverflowRects, ReflowChildFlags aFlags, + nsReflowStatus& aStatus, ChildFrameMerger aMergeFunc, + Maybe<nsSize> aContainerSize) { + MOZ_ASSERT(aPresContext, "null pointer"); + + nsFrameList* overflowContainers = + DrainExcessOverflowContainersList(aMergeFunc); + if (!overflowContainers) { + return; // nothing to reflow + } + + nsOverflowContinuationTracker tracker(this, false, false); + bool shouldReflowAllKids = aReflowInput.ShouldReflowAllKids(); + + for (nsIFrame* frame : *overflowContainers) { + if (frame->GetPrevInFlow()->GetParent() != GetPrevInFlow()) { + // frame's prevInFlow has moved, skip reflowing this frame; + // it will get reflowed once it's been placed + if (GetNextInFlow()) { + // We report OverflowIncomplete status in this case to avoid our parent + // deleting our next-in-flows which might destroy non-empty frames. + nsReflowStatus status; + status.SetOverflowIncomplete(); + aStatus.MergeCompletionStatusFrom(status); + } + continue; + } + + auto ScrollableOverflowExceedsAvailableBSize = + [this, &aReflowInput](nsIFrame* aFrame) { + if (aReflowInput.AvailableBSize() == NS_UNCONSTRAINEDSIZE) { + return false; + } + const auto parentWM = GetWritingMode(); + const nscoord scrollableOverflowRectBEnd = + LogicalRect(parentWM, + aFrame->ScrollableOverflowRectRelativeToParent(), + GetSize()) + .BEnd(parentWM); + return scrollableOverflowRectBEnd > aReflowInput.AvailableBSize(); + }; + + // If the available block-size has changed, or the existing scrollable + // overflow's block-end exceeds it, we need to reflow even if the frame + // isn't dirty. + if (shouldReflowAllKids || frame->IsSubtreeDirty() || + ScrollableOverflowExceedsAvailableBSize(frame)) { + // Get prev-in-flow + nsIFrame* prevInFlow = frame->GetPrevInFlow(); + NS_ASSERTION(prevInFlow, + "overflow container frame must have a prev-in-flow"); + NS_ASSERTION( + frame->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER), + "overflow container frame must have overflow container bit set"); + WritingMode wm = frame->GetWritingMode(); + nsSize containerSize = + aContainerSize ? *aContainerSize + : aReflowInput.AvailableSize(wm).GetPhysicalSize(wm); + LogicalRect prevRect = prevInFlow->GetLogicalRect(wm, containerSize); + + // Initialize reflow params + LogicalSize availSpace(wm, prevRect.ISize(wm), + aReflowInput.AvailableSize(wm).BSize(wm)); + ReflowOutput desiredSize(aReflowInput); + + StyleSizeOverrides sizeOverride; + if (frame->IsFlexItem()) { + // A flex item's size is determined by the flex algorithm, not solely by + // its style. Thus, the following overrides are necessary. + // + // Use the overflow container flex item's prev-in-flow inline-size since + // this continuation's inline-size is the same. + sizeOverride.mStyleISize.emplace( + StyleSize::LengthPercentage(LengthPercentage::FromAppUnits( + frame->StylePosition()->mBoxSizing == StyleBoxSizing::Border + ? prevRect.ISize(wm) + : prevInFlow->ContentSize(wm).ISize(wm)))); + + // An overflow container's block-size must be 0. + sizeOverride.mStyleBSize.emplace( + StyleSize::LengthPercentage(LengthPercentage::FromAppUnits(0))); + } + ReflowInput reflowInput(aPresContext, aReflowInput, frame, availSpace, + Nothing(), {}, sizeOverride); + + LogicalPoint pos(wm, prevRect.IStart(wm), 0); + nsReflowStatus frameStatus; + ReflowChild(frame, aPresContext, desiredSize, reflowInput, wm, pos, + containerSize, aFlags, frameStatus, &tracker); + FinishReflowChild(frame, aPresContext, desiredSize, &reflowInput, wm, pos, + containerSize, aFlags); + + // Handle continuations + if (!frameStatus.IsFullyComplete()) { + if (frame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW)) { + // Abspos frames can't cause their parent to be incomplete, + // only overflow incomplete. + frameStatus.SetOverflowIncomplete(); + } else { + NS_ASSERTION(frameStatus.IsComplete(), + "overflow container frames can't be incomplete, only " + "overflow-incomplete"); + } + + // Acquire a next-in-flow, creating it if necessary + nsIFrame* nif = frame->GetNextInFlow(); + if (!nif) { + NS_ASSERTION(frameStatus.NextInFlowNeedsReflow(), + "Someone forgot a NextInFlowNeedsReflow flag"); + nif = PresShell()->FrameConstructor()->CreateContinuingFrame(frame, + this); + } else if (!nif->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER)) { + // used to be a normal next-in-flow; steal it from the child list + nif->GetParent()->StealFrame(nif); + } + + tracker.Insert(nif, frameStatus); + } + aStatus.MergeCompletionStatusFrom(frameStatus); + // At this point it would be nice to assert + // !frame->GetOverflowRect().IsEmpty(), but we have some unsplittable + // frames that, when taller than availableHeight will push zero-height + // content into a next-in-flow. + } else { + tracker.Skip(frame, aStatus); + if (aReflowInput.mFloatManager) { + nsBlockFrame::RecoverFloatsFor(frame, *aReflowInput.mFloatManager, + aReflowInput.GetWritingMode(), + aReflowInput.ComputedPhysicalSize()); + } + } + ConsiderChildOverflow(aOverflowRects, frame); + } +} + +void nsContainerFrame::DisplayOverflowContainers( + nsDisplayListBuilder* aBuilder, const nsDisplayListSet& aLists) { + nsFrameList* overflowconts = GetOverflowContainers(); + if (overflowconts) { + for (nsIFrame* frame : *overflowconts) { + BuildDisplayListForChild(aBuilder, frame, aLists); + } + } +} + +bool nsContainerFrame::TryRemoveFrame(FrameListPropertyDescriptor aProp, + nsIFrame* aChildToRemove) { + nsFrameList* list = GetProperty(aProp); + if (list && list->StartRemoveFrame(aChildToRemove)) { + // aChildToRemove *may* have been removed from this list. + if (list->IsEmpty()) { + Unused << TakeProperty(aProp); + list->Delete(PresShell()); + } + return true; + } + return false; +} + +bool nsContainerFrame::MaybeStealOverflowContainerFrame(nsIFrame* aChild) { + bool removed = false; + if (MOZ_UNLIKELY(aChild->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER))) { + // Try removing from the overflow container list. + removed = TryRemoveFrame(OverflowContainersProperty(), aChild); + if (!removed) { + // It might be in the excess overflow container list. + removed = TryRemoveFrame(ExcessOverflowContainersProperty(), aChild); + } + } + return removed; +} + +void nsContainerFrame::StealFrame(nsIFrame* aChild) { +#ifdef DEBUG + if (!mFrames.ContainsFrame(aChild)) { + nsFrameList* list = GetOverflowFrames(); + if (!list || !list->ContainsFrame(aChild)) { + list = GetOverflowContainers(); + if (!list || !list->ContainsFrame(aChild)) { + list = GetExcessOverflowContainers(); + MOZ_ASSERT(list && list->ContainsFrame(aChild), + "aChild isn't our child" + " or on a frame list not supported by StealFrame"); + } + } + } +#endif + + if (MaybeStealOverflowContainerFrame(aChild)) { + return; + } + + // NOTE nsColumnSetFrame and nsCanvasFrame have their overflow containers + // on the normal lists so we might get here also if the frame bit + // NS_FRAME_IS_OVERFLOW_CONTAINER is set. + if (mFrames.StartRemoveFrame(aChild)) { + return; + } + + // We didn't find the child in our principal child list. + // Maybe it's on the overflow list? + nsFrameList* frameList = GetOverflowFrames(); + if (frameList && frameList->ContinueRemoveFrame(aChild)) { + if (frameList->IsEmpty()) { + DestroyOverflowList(); + } + return; + } + + MOZ_ASSERT_UNREACHABLE("StealFrame: can't find aChild"); +} + +nsFrameList nsContainerFrame::StealFramesAfter(nsIFrame* aChild) { + NS_ASSERTION( + !aChild || !aChild->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER), + "StealFramesAfter doesn't handle overflow containers"); + NS_ASSERTION(!IsBlockFrame(), "unexpected call"); + + if (!aChild) { + return std::move(mFrames); + } + + for (nsIFrame* f : mFrames) { + if (f == aChild) { + return mFrames.TakeFramesAfter(f); + } + } + + // We didn't find the child in the principal child list. + // Maybe it's on the overflow list? + if (nsFrameList* overflowFrames = GetOverflowFrames()) { + for (nsIFrame* f : *overflowFrames) { + if (f == aChild) { + return mFrames.TakeFramesAfter(f); + } + } + } + + NS_ERROR("StealFramesAfter: can't find aChild"); + return nsFrameList(); +} + +/* + * Create a next-in-flow for aFrame. Will return the newly created + * frame <b>if and only if</b> a new frame is created; otherwise + * nullptr is returned. + */ +nsIFrame* nsContainerFrame::CreateNextInFlow(nsIFrame* aFrame) { + MOZ_ASSERT( + !IsBlockFrame(), + "you should have called nsBlockFrame::CreateContinuationFor instead"); + MOZ_ASSERT(mFrames.ContainsFrame(aFrame), "expected an in-flow child frame"); + + nsIFrame* nextInFlow = aFrame->GetNextInFlow(); + if (nullptr == nextInFlow) { + // Create a continuation frame for the child frame and insert it + // into our child list. + nextInFlow = + PresShell()->FrameConstructor()->CreateContinuingFrame(aFrame, this); + mFrames.InsertFrame(nullptr, aFrame, nextInFlow); + + NS_FRAME_LOG(NS_FRAME_TRACE_NEW_FRAMES, + ("nsContainerFrame::CreateNextInFlow: frame=%p nextInFlow=%p", + aFrame, nextInFlow)); + + return nextInFlow; + } + return nullptr; +} + +/** + * Remove and delete aNextInFlow and its next-in-flows. Updates the sibling and + * flow pointers + */ +void nsContainerFrame::DeleteNextInFlowChild(DestroyContext& aContext, + nsIFrame* aNextInFlow, + bool aDeletingEmptyFrames) { +#ifdef DEBUG + nsIFrame* prevInFlow = aNextInFlow->GetPrevInFlow(); +#endif + MOZ_ASSERT(prevInFlow, "bad prev-in-flow"); + + // If the next-in-flow has a next-in-flow then delete it, too (and + // delete it first). + // Do this in a loop so we don't overflow the stack for frames + // with very many next-in-flows + nsIFrame* nextNextInFlow = aNextInFlow->GetNextInFlow(); + if (nextNextInFlow) { + AutoTArray<nsIFrame*, 8> frames; + for (nsIFrame* f = nextNextInFlow; f; f = f->GetNextInFlow()) { + frames.AppendElement(f); + } + for (nsIFrame* delFrame : Reversed(frames)) { + nsContainerFrame* parent = delFrame->GetParent(); + parent->DeleteNextInFlowChild(aContext, delFrame, aDeletingEmptyFrames); + } + } + + // Take the next-in-flow out of the parent's child list + StealFrame(aNextInFlow); + +#ifdef DEBUG + if (aDeletingEmptyFrames) { + nsLayoutUtils::AssertTreeOnlyEmptyNextInFlows(aNextInFlow); + } +#endif + + // Delete the next-in-flow frame and its descendants. This will also + // remove it from its next-in-flow/prev-in-flow chain. + aNextInFlow->Destroy(aContext); + + MOZ_ASSERT(!prevInFlow->GetNextInFlow(), "non null next-in-flow"); +} + +void nsContainerFrame::PushChildrenToOverflow(nsIFrame* aFromChild, + nsIFrame* aPrevSibling) { + MOZ_ASSERT(aFromChild, "null pointer"); + MOZ_ASSERT(aPrevSibling, "pushing first child"); + MOZ_ASSERT(aPrevSibling->GetNextSibling() == aFromChild, "bad prev sibling"); + + // Add the frames to our overflow list (let our next in flow drain + // our overflow list when it is ready) + SetOverflowFrames(mFrames.TakeFramesAfter(aPrevSibling)); +} + +void nsContainerFrame::PushChildren(nsIFrame* aFromChild, + nsIFrame* aPrevSibling) { + MOZ_ASSERT(aFromChild, "null pointer"); + MOZ_ASSERT(aPrevSibling, "pushing first child"); + MOZ_ASSERT(aPrevSibling->GetNextSibling() == aFromChild, "bad prev sibling"); + + // Disconnect aFromChild from its previous sibling + nsFrameList tail = mFrames.TakeFramesAfter(aPrevSibling); + + nsContainerFrame* nextInFlow = + static_cast<nsContainerFrame*>(GetNextInFlow()); + if (nextInFlow) { + // XXX This is not a very good thing to do. If it gets removed + // then remove the copy of this routine that doesn't do this from + // nsInlineFrame. + // When pushing and pulling frames we need to check for whether any + // views need to be reparented. + for (nsIFrame* f = aFromChild; f; f = f->GetNextSibling()) { + nsContainerFrame::ReparentFrameView(f, this, nextInFlow); + } + nextInFlow->mFrames.InsertFrames(nextInFlow, nullptr, std::move(tail)); + } else { + // Add the frames to our overflow list + SetOverflowFrames(std::move(tail)); + } +} + +bool nsContainerFrame::PushIncompleteChildren( + const FrameHashtable& aPushedItems, const FrameHashtable& aIncompleteItems, + const FrameHashtable& aOverflowIncompleteItems) { + MOZ_ASSERT(IsFlexOrGridContainer(), + "Only Grid / Flex containers can call this!"); + + if (aPushedItems.IsEmpty() && aIncompleteItems.IsEmpty() && + aOverflowIncompleteItems.IsEmpty()) { + return false; + } + + // Iterate the children in normal document order and append them (or a NIF) + // to one of the following frame lists according to their status. + nsFrameList pushedList; + nsFrameList incompleteList; + nsFrameList overflowIncompleteList; + auto* fc = PresShell()->FrameConstructor(); + for (nsIFrame* child = PrincipalChildList().FirstChild(); child;) { + MOZ_ASSERT((aPushedItems.Contains(child) ? 1 : 0) + + (aIncompleteItems.Contains(child) ? 1 : 0) + + (aOverflowIncompleteItems.Contains(child) ? 1 : 0) <= + 1, + "child should only be in one of these sets"); + // Save the next-sibling so we can continue the loop if |child| is moved. + nsIFrame* next = child->GetNextSibling(); + if (aPushedItems.Contains(child)) { + MOZ_ASSERT(child->GetParent() == this); + StealFrame(child); + pushedList.AppendFrame(nullptr, child); + } else if (aIncompleteItems.Contains(child)) { + nsIFrame* childNIF = child->GetNextInFlow(); + if (!childNIF) { + childNIF = fc->CreateContinuingFrame(child, this); + incompleteList.AppendFrame(nullptr, childNIF); + } else { + auto* parent = childNIF->GetParent(); + MOZ_ASSERT(parent != this || !mFrames.ContainsFrame(childNIF), + "child's NIF shouldn't be in the same principal list"); + // If child's existing NIF is an overflow container, convert it to an + // actual NIF, since now |child| has non-overflow stuff to give it. + // Or, if it's further away then our next-in-flow, then pull it up. + if (childNIF->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER) || + (parent != this && parent != GetNextInFlow())) { + parent->StealFrame(childNIF); + childNIF->RemoveStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER); + if (parent == this) { + incompleteList.AppendFrame(nullptr, childNIF); + } else { + // If childNIF already lives on the next fragment, then we + // don't need to reparent it, since we know it's destined to end + // up there anyway. Just move it to its parent's overflow list. + if (parent == GetNextInFlow()) { + nsFrameList toMove(childNIF, childNIF); + parent->MergeSortedOverflow(toMove); + } else { + ReparentFrame(childNIF, parent, this); + incompleteList.AppendFrame(nullptr, childNIF); + } + } + } + } + } else if (aOverflowIncompleteItems.Contains(child)) { + nsIFrame* childNIF = child->GetNextInFlow(); + if (!childNIF) { + childNIF = fc->CreateContinuingFrame(child, this); + childNIF->AddStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER); + overflowIncompleteList.AppendFrame(nullptr, childNIF); + } else { + DebugOnly<nsContainerFrame*> lastParent = this; + auto* nif = static_cast<nsContainerFrame*>(GetNextInFlow()); + // If child has any non-overflow-container NIFs, convert them to + // overflow containers, since that's all |child| needs now. + while (childNIF && + !childNIF->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER)) { + auto* parent = childNIF->GetParent(); + parent->StealFrame(childNIF); + childNIF->AddStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER); + if (parent == this) { + overflowIncompleteList.AppendFrame(nullptr, childNIF); + } else { + if (!nif || parent == nif) { + nsFrameList toMove(childNIF, childNIF); + parent->MergeSortedExcessOverflowContainers(toMove); + } else { + ReparentFrame(childNIF, parent, nif); + nsFrameList toMove(childNIF, childNIF); + nif->MergeSortedExcessOverflowContainers(toMove); + } + // We only need to reparent the first childNIF (or not at all if + // its parent is our NIF). + nif = nullptr; + } + lastParent = parent; + childNIF = childNIF->GetNextInFlow(); + } + } + } + child = next; + } + + // Merge the results into our respective overflow child lists. + if (!pushedList.IsEmpty()) { + MergeSortedOverflow(pushedList); + } + if (!incompleteList.IsEmpty()) { + MergeSortedOverflow(incompleteList); + } + if (!overflowIncompleteList.IsEmpty()) { + // If our next-in-flow already has overflow containers list, merge the + // overflowIncompleteList into that list. Otherwise, merge it into our + // excess overflow containers list, to be drained by our next-in-flow. + auto* nif = static_cast<nsContainerFrame*>(GetNextInFlow()); + nsFrameList* oc = nif ? nif->GetOverflowContainers() : nullptr; + if (oc) { + ReparentFrames(overflowIncompleteList, this, nif); + MergeSortedFrameLists(*oc, overflowIncompleteList, GetContent()); + } else { + MergeSortedExcessOverflowContainers(overflowIncompleteList); + } + } + return true; +} + +void nsContainerFrame::NormalizeChildLists() { + MOZ_ASSERT(IsFlexOrGridContainer(), + "Only Flex / Grid containers can call this!"); + + // Note: the following description uses grid container as an example. Flex + // container is similar. + // + // First we gather child frames we should include in our reflow/placement, + // i.e. overflowed children from our prev-in-flow, and pushed first-in-flow + // children (that might now fit). It's important to note that these children + // can be in arbitrary order vis-a-vis the current children in our lists. + // E.g. grid items in the document order: A, B, C may be placed in the rows + // 3, 2, 1. Assume each row goes in a separate grid container fragment, + // and we reflow the second fragment. Now if C (in fragment 1) overflows, + // we can't just prepend it to our mFrames like we usually do because that + // would violate the document order invariant that other code depends on. + // Similarly if we pull up child A (from fragment 3) we can't just append + // that for the same reason. Instead, we must sort these children into + // our child lists. (The sorting is trivial given that both lists are + // already fully sorted individually - it's just a merge.) + // + // The invariants that we maintain are that each grid container child list + // is sorted in the normal document order at all times, but that children + // in different grid container continuations may be in arbitrary order. + + const auto didPushItemsBit = IsFlexContainerFrame() + ? NS_STATE_FLEX_DID_PUSH_ITEMS + : NS_STATE_GRID_DID_PUSH_ITEMS; + const auto hasChildNifBit = IsFlexContainerFrame() + ? NS_STATE_FLEX_HAS_CHILD_NIFS + : NS_STATE_GRID_HAS_CHILD_NIFS; + + auto* prevInFlow = static_cast<nsContainerFrame*>(GetPrevInFlow()); + // Merge overflow frames from our prev-in-flow into our principal child list. + if (prevInFlow) { + AutoFrameListPtr overflow(PresContext(), prevInFlow->StealOverflowFrames()); + if (overflow) { + ReparentFrames(*overflow, prevInFlow, this); + MergeSortedFrameLists(mFrames, *overflow, GetContent()); + + // Move trailing next-in-flows into our overflow list. + nsFrameList continuations; + for (nsIFrame* f = mFrames.FirstChild(); f;) { + nsIFrame* next = f->GetNextSibling(); + nsIFrame* pif = f->GetPrevInFlow(); + if (pif && pif->GetParent() == this) { + mFrames.RemoveFrame(f); + continuations.AppendFrame(nullptr, f); + } + f = next; + } + MergeSortedOverflow(continuations); + + // Move prev-in-flow's excess overflow containers list into our own + // overflow containers list. If we already have an excess overflow + // containers list, any child in that list which doesn't have a + // prev-in-flow in this frame is also merged into our overflow container + // list. + nsFrameList* overflowContainers = + DrainExcessOverflowContainersList(MergeSortedFrameListsFor); + + // Move trailing OC next-in-flows into our excess overflow containers + // list. + if (overflowContainers) { + nsFrameList moveToEOC; + for (nsIFrame* f = overflowContainers->FirstChild(); f;) { + nsIFrame* next = f->GetNextSibling(); + nsIFrame* pif = f->GetPrevInFlow(); + if (pif && pif->GetParent() == this) { + overflowContainers->RemoveFrame(f); + moveToEOC.AppendFrame(nullptr, f); + } + f = next; + } + if (overflowContainers->IsEmpty()) { + DestroyOverflowContainers(); + } + MergeSortedExcessOverflowContainers(moveToEOC); + } + } + } + + // For each item in aItems, pull up its next-in-flow (if any), and reparent it + // to our next-in-flow, unless its parent is already ourselves or our + // next-in-flow (to avoid leaving a hole there). + auto PullItemsNextInFlow = [this](const nsFrameList& aItems) { + auto* firstNIF = static_cast<nsContainerFrame*>(GetNextInFlow()); + if (!firstNIF) { + return; + } + nsFrameList childNIFs; + nsFrameList childOCNIFs; + for (auto* child : aItems) { + if (auto* childNIF = child->GetNextInFlow()) { + if (auto* parent = childNIF->GetParent(); + parent != this && parent != firstNIF) { + parent->StealFrame(childNIF); + ReparentFrame(childNIF, parent, firstNIF); + if (childNIF->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER)) { + childOCNIFs.AppendFrame(nullptr, childNIF); + } else { + childNIFs.AppendFrame(nullptr, childNIF); + } + } + } + } + // Merge aItems' NIFs into our NIF's respective overflow child lists. + firstNIF->MergeSortedOverflow(childNIFs); + firstNIF->MergeSortedExcessOverflowContainers(childOCNIFs); + }; + + // Merge our own overflow frames into our principal child list, + // except those that are a next-in-flow for one of our items. + DebugOnly<bool> foundOwnPushedChild = false; + { + nsFrameList* ourOverflow = GetOverflowFrames(); + if (ourOverflow) { + nsFrameList items; + for (nsIFrame* f = ourOverflow->FirstChild(); f;) { + nsIFrame* next = f->GetNextSibling(); + nsIFrame* pif = f->GetPrevInFlow(); + if (!pif || pif->GetParent() != this) { + MOZ_ASSERT(f->GetParent() == this); + ourOverflow->RemoveFrame(f); + items.AppendFrame(nullptr, f); + if (!pif) { + foundOwnPushedChild = true; + } + } + f = next; + } + + if (ourOverflow->IsEmpty()) { + DestroyOverflowList(); + ourOverflow = nullptr; + } + if (items.NotEmpty()) { + PullItemsNextInFlow(items); + } + MergeSortedFrameLists(mFrames, items, GetContent()); + } + } + + // Push any child next-in-flows in our principal list to OverflowList. + if (HasAnyStateBits(hasChildNifBit)) { + nsFrameList framesToPush; + nsIFrame* firstChild = mFrames.FirstChild(); + // Note that we potentially modify our mFrames list as we go. + for (auto* child = firstChild; child; child = child->GetNextSibling()) { + if (auto* childNIF = child->GetNextInFlow()) { + if (childNIF->GetParent() == this) { + for (auto* c = child->GetNextSibling(); c; c = c->GetNextSibling()) { + if (c == childNIF) { + // child's next-in-flow is in our principal child list, push it. + mFrames.RemoveFrame(childNIF); + framesToPush.AppendFrame(nullptr, childNIF); + break; + } + } + } + } + } + if (!framesToPush.IsEmpty()) { + MergeSortedOverflow(framesToPush); + } + RemoveStateBits(hasChildNifBit); + } + + // Pull up any first-in-flow children we might have pushed. + if (HasAnyStateBits(didPushItemsBit)) { + RemoveStateBits(didPushItemsBit); + nsFrameList items; + auto* nif = static_cast<nsContainerFrame*>(GetNextInFlow()); + DebugOnly<bool> nifNeedPushedItem = false; + while (nif) { + nsFrameList nifItems; + for (nsIFrame* nifChild = nif->PrincipalChildList().FirstChild(); + nifChild;) { + nsIFrame* next = nifChild->GetNextSibling(); + if (!nifChild->GetPrevInFlow()) { + nif->StealFrame(nifChild); + ReparentFrame(nifChild, nif, this); + nifItems.AppendFrame(nullptr, nifChild); + nifNeedPushedItem = false; + } + nifChild = next; + } + MergeSortedFrameLists(items, nifItems, GetContent()); + + if (!nif->HasAnyStateBits(didPushItemsBit)) { + MOZ_ASSERT(!nifNeedPushedItem || mDidPushItemsBitMayLie, + "The state bit stored in didPushItemsBit lied!"); + break; + } + nifNeedPushedItem = true; + + for (nsIFrame* nifChild = + nif->GetChildList(FrameChildListID::Overflow).FirstChild(); + nifChild;) { + nsIFrame* next = nifChild->GetNextSibling(); + if (!nifChild->GetPrevInFlow()) { + nif->StealFrame(nifChild); + ReparentFrame(nifChild, nif, this); + nifItems.AppendFrame(nullptr, nifChild); + nifNeedPushedItem = false; + } + nifChild = next; + } + MergeSortedFrameLists(items, nifItems, GetContent()); + + nif->RemoveStateBits(didPushItemsBit); + nif = static_cast<nsContainerFrame*>(nif->GetNextInFlow()); + MOZ_ASSERT(nif || !nifNeedPushedItem || mDidPushItemsBitMayLie, + "The state bit stored in didPushItemsBit lied!"); + } + + if (!items.IsEmpty()) { + PullItemsNextInFlow(items); + } + + MOZ_ASSERT( + foundOwnPushedChild || !items.IsEmpty() || mDidPushItemsBitMayLie, + "The state bit stored in didPushItemsBit lied!"); + MergeSortedFrameLists(mFrames, items, GetContent()); + } +} + +void nsContainerFrame::NoteNewChildren(ChildListID aListID, + const nsFrameList& aFrameList) { + MOZ_ASSERT(aListID == FrameChildListID::Principal, "unexpected child list"); + MOZ_ASSERT(IsFlexOrGridContainer(), + "Only Flex / Grid containers can call this!"); + + mozilla::PresShell* presShell = PresShell(); + const auto didPushItemsBit = IsFlexContainerFrame() + ? NS_STATE_FLEX_DID_PUSH_ITEMS + : NS_STATE_GRID_DID_PUSH_ITEMS; + for (auto* pif = GetPrevInFlow(); pif; pif = pif->GetPrevInFlow()) { + pif->AddStateBits(didPushItemsBit); + presShell->FrameNeedsReflow(pif, IntrinsicDirty::FrameAndAncestors, + NS_FRAME_IS_DIRTY); + } +} + +bool nsContainerFrame::MoveOverflowToChildList() { + bool result = false; + + // Check for an overflow list with our prev-in-flow + nsContainerFrame* prevInFlow = (nsContainerFrame*)GetPrevInFlow(); + if (nullptr != prevInFlow) { + AutoFrameListPtr prevOverflowFrames(PresContext(), + prevInFlow->StealOverflowFrames()); + if (prevOverflowFrames) { + // Tables are special; they can have repeated header/footer + // frames on mFrames at this point. + NS_ASSERTION(mFrames.IsEmpty() || IsTableFrame(), "bad overflow list"); + // When pushing and pulling frames we need to check for whether any + // views need to be reparented. + nsContainerFrame::ReparentFrameViewList(*prevOverflowFrames, prevInFlow, + this); + mFrames.AppendFrames(this, std::move(*prevOverflowFrames)); + result = true; + } + } + + // It's also possible that we have an overflow list for ourselves. + return DrainSelfOverflowList() || result; +} + +void nsContainerFrame::MergeSortedOverflow(nsFrameList& aList) { + if (aList.IsEmpty()) { + return; + } + MOZ_ASSERT( + !aList.FirstChild()->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER), + "this is the wrong list to put this child frame"); + MOZ_ASSERT(aList.FirstChild()->GetParent() == this); + nsFrameList* overflow = GetOverflowFrames(); + if (overflow) { + MergeSortedFrameLists(*overflow, aList, GetContent()); + } else { + SetOverflowFrames(std::move(aList)); + } +} + +void nsContainerFrame::MergeSortedExcessOverflowContainers(nsFrameList& aList) { + if (aList.IsEmpty()) { + return; + } + MOZ_ASSERT( + aList.FirstChild()->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER), + "this is the wrong list to put this child frame"); + MOZ_ASSERT(aList.FirstChild()->GetParent() == this); + if (nsFrameList* eoc = GetExcessOverflowContainers()) { + MergeSortedFrameLists(*eoc, aList, GetContent()); + } else { + SetExcessOverflowContainers(std::move(aList)); + } +} + +nsIFrame* nsContainerFrame::GetFirstNonAnonBoxInSubtree(nsIFrame* aFrame) { + while (aFrame) { + // If aFrame isn't an anonymous container, or it's text or such, then it'll + // do. + if (!aFrame->Style()->IsAnonBox() || + nsCSSAnonBoxes::IsNonElement(aFrame->Style()->GetPseudoType())) { + break; + } + + // Otherwise, descend to its first child and repeat. + + // SPECIAL CASE: if we're dealing with an anonymous table, then it might + // be wrapping something non-anonymous in its caption or col-group lists + // (instead of its principal child list), so we have to look there. + // (Note: For anonymous tables that have a non-anon cell *and* a non-anon + // column, we'll always return the column. This is fine; we're really just + // looking for a handle to *anything* with a meaningful content node inside + // the table, for use in DOM comparisons to things outside of the table.) + if (MOZ_UNLIKELY(aFrame->IsTableWrapperFrame())) { + nsIFrame* captionDescendant = GetFirstNonAnonBoxInSubtree( + aFrame->GetChildList(FrameChildListID::Caption).FirstChild()); + if (captionDescendant) { + return captionDescendant; + } + } else if (MOZ_UNLIKELY(aFrame->IsTableFrame())) { + nsIFrame* colgroupDescendant = GetFirstNonAnonBoxInSubtree( + aFrame->GetChildList(FrameChildListID::ColGroup).FirstChild()); + if (colgroupDescendant) { + return colgroupDescendant; + } + } + + // USUAL CASE: Descend to the first child in principal list. + aFrame = aFrame->PrincipalChildList().FirstChild(); + } + return aFrame; +} + +/** + * Is aFrame1 a prev-continuation of aFrame2? + */ +static bool IsPrevContinuationOf(nsIFrame* aFrame1, nsIFrame* aFrame2) { + nsIFrame* prev = aFrame2; + while ((prev = prev->GetPrevContinuation())) { + if (prev == aFrame1) { + return true; + } + } + return false; +} + +void nsContainerFrame::MergeSortedFrameLists(nsFrameList& aDest, + nsFrameList& aSrc, + nsIContent* aCommonAncestor) { + // Returns a frame whose DOM node can be used for the purpose of ordering + // aFrame among its sibling frames by DOM position. If aFrame is + // non-anonymous, this just returns aFrame itself. Otherwise, this returns the + // first non-anonymous descendant in aFrame's continuation chain. + auto FrameForDOMPositionComparison = [](nsIFrame* aFrame) { + if (!aFrame->Style()->IsAnonBox()) { + // The usual case. + return aFrame; + } + + // Walk the continuation chain from the start, and return the first + // non-anonymous descendant that we find. + for (nsIFrame* f = aFrame->FirstContinuation(); f; + f = f->GetNextContinuation()) { + if (nsIFrame* nonAnonBox = GetFirstNonAnonBoxInSubtree(f)) { + return nonAnonBox; + } + } + + MOZ_ASSERT_UNREACHABLE( + "Why is there no non-anonymous descendants in the continuation chain?"); + return aFrame; + }; + + nsIFrame* dest = aDest.FirstChild(); + for (nsIFrame* src = aSrc.FirstChild(); src;) { + if (!dest) { + aDest.AppendFrames(nullptr, std::move(aSrc)); + break; + } + nsIContent* srcContent = FrameForDOMPositionComparison(src)->GetContent(); + nsIContent* destContent = FrameForDOMPositionComparison(dest)->GetContent(); + int32_t result = nsLayoutUtils::CompareTreePosition(srcContent, destContent, + aCommonAncestor); + if (MOZ_UNLIKELY(result == 0)) { + // NOTE: we get here when comparing ::before/::after for the same element. + if (MOZ_UNLIKELY(srcContent->IsGeneratedContentContainerForBefore())) { + if (MOZ_LIKELY(!destContent->IsGeneratedContentContainerForBefore()) || + ::IsPrevContinuationOf(src, dest)) { + result = -1; + } + } else if (MOZ_UNLIKELY( + srcContent->IsGeneratedContentContainerForAfter())) { + if (MOZ_UNLIKELY(destContent->IsGeneratedContentContainerForAfter()) && + ::IsPrevContinuationOf(src, dest)) { + result = -1; + } + } else if (::IsPrevContinuationOf(src, dest)) { + result = -1; + } + } + if (result < 0) { + // src should come before dest + nsIFrame* next = src->GetNextSibling(); + aSrc.RemoveFrame(src); + aDest.InsertFrame(nullptr, dest->GetPrevSibling(), src); + src = next; + } else { + dest = dest->GetNextSibling(); + } + } + MOZ_ASSERT(aSrc.IsEmpty()); +} + +bool nsContainerFrame::MoveInlineOverflowToChildList(nsIFrame* aLineContainer) { + MOZ_ASSERT(aLineContainer, + "Must have line container for moving inline overflows"); + + bool result = false; + + // Check for an overflow list with our prev-in-flow + if (auto prevInFlow = static_cast<nsContainerFrame*>(GetPrevInFlow())) { + AutoFrameListPtr prevOverflowFrames(PresContext(), + prevInFlow->StealOverflowFrames()); + if (prevOverflowFrames) { + // We may need to reparent floats from prev-in-flow to our line + // container if the container has prev continuation. + if (aLineContainer->GetPrevContinuation()) { + ReparentFloatsForInlineChild(aLineContainer, + prevOverflowFrames->FirstChild(), true); + } + // When pushing and pulling frames we need to check for whether + // any views need to be reparented. + nsContainerFrame::ReparentFrameViewList(*prevOverflowFrames, prevInFlow, + this); + // Prepend overflow frames to the list. + mFrames.InsertFrames(this, nullptr, std::move(*prevOverflowFrames)); + result = true; + } + } + + // It's also possible that we have overflow list for ourselves. + return DrainSelfOverflowList() || result; +} + +bool nsContainerFrame::DrainSelfOverflowList() { + AutoFrameListPtr overflowFrames(PresContext(), StealOverflowFrames()); + if (overflowFrames) { + mFrames.AppendFrames(nullptr, std::move(*overflowFrames)); + return true; + } + return false; +} + +bool nsContainerFrame::DrainAndMergeSelfOverflowList() { + MOZ_ASSERT(IsFlexOrGridContainer(), + "Only Flex / Grid containers can call this!"); + + // Unlike nsContainerFrame::DrainSelfOverflowList, flex or grid containers + // need to merge these lists so that the resulting mFrames is in document + // content order. + // NOTE: nsContainerFrame::AppendFrames/InsertFrames calls this method and + // there are also direct calls from the fctor (FindAppendPrevSibling). + AutoFrameListPtr overflowFrames(PresContext(), StealOverflowFrames()); + if (overflowFrames) { + MergeSortedFrameLists(mFrames, *overflowFrames, GetContent()); + // We set a frame bit to push them again in Reflow() to avoid creating + // multiple flex / grid items per flex / grid container fragment for the + // same content. + AddStateBits(IsFlexContainerFrame() ? NS_STATE_FLEX_HAS_CHILD_NIFS + : NS_STATE_GRID_HAS_CHILD_NIFS); + return true; + } + return false; +} + +nsFrameList* nsContainerFrame::DrainExcessOverflowContainersList( + ChildFrameMerger aMergeFunc) { + nsFrameList* overflowContainers = GetOverflowContainers(); + + // Drain excess overflow containers from our prev-in-flow. + if (auto* prev = static_cast<nsContainerFrame*>(GetPrevInFlow())) { + AutoFrameListPtr excessFrames(PresContext(), + prev->StealExcessOverflowContainers()); + if (excessFrames) { + excessFrames->ApplySetParent(this); + nsContainerFrame::ReparentFrameViewList(*excessFrames, prev, this); + if (overflowContainers) { + // The default merge function is AppendFrames, so we use excessFrames as + // the destination and then assign the result to overflowContainers. + aMergeFunc(*excessFrames, *overflowContainers, this); + *overflowContainers = std::move(*excessFrames); + } else { + overflowContainers = SetOverflowContainers(std::move(*excessFrames)); + } + } + } + + // Our own excess overflow containers from a previous reflow can still be + // present if our next-in-flow hasn't been reflown yet. Move any children + // from it that don't have a continuation in this frame to the + // OverflowContainers list. + AutoFrameListPtr selfExcessOCFrames(PresContext(), + StealExcessOverflowContainers()); + if (selfExcessOCFrames) { + nsFrameList toMove; + auto child = selfExcessOCFrames->FirstChild(); + while (child) { + auto next = child->GetNextSibling(); + MOZ_ASSERT(child->GetPrevInFlow(), + "ExcessOverflowContainers frames must be continuations"); + if (child->GetPrevInFlow()->GetParent() != this) { + selfExcessOCFrames->RemoveFrame(child); + toMove.AppendFrame(nullptr, child); + } + child = next; + } + + // If there's any remaining excess overflow containers, put them back. + if (selfExcessOCFrames->NotEmpty()) { + SetExcessOverflowContainers(std::move(*selfExcessOCFrames)); + } + + if (toMove.NotEmpty()) { + if (overflowContainers) { + aMergeFunc(*overflowContainers, toMove, this); + } else { + overflowContainers = SetOverflowContainers(std::move(toMove)); + } + } + } + + return overflowContainers; +} + +nsIFrame* nsContainerFrame::GetNextInFlowChild( + ContinuationTraversingState& aState, bool* aIsInOverflow) { + nsContainerFrame*& nextInFlow = aState.mNextInFlow; + while (nextInFlow) { + // See if there is any frame in the container + nsIFrame* frame = nextInFlow->mFrames.FirstChild(); + if (frame) { + if (aIsInOverflow) { + *aIsInOverflow = false; + } + return frame; + } + // No frames in the principal list, try its overflow list + nsFrameList* overflowFrames = nextInFlow->GetOverflowFrames(); + if (overflowFrames) { + if (aIsInOverflow) { + *aIsInOverflow = true; + } + return overflowFrames->FirstChild(); + } + nextInFlow = static_cast<nsContainerFrame*>(nextInFlow->GetNextInFlow()); + } + return nullptr; +} + +nsIFrame* nsContainerFrame::PullNextInFlowChild( + ContinuationTraversingState& aState) { + bool isInOverflow; + nsIFrame* frame = GetNextInFlowChild(aState, &isInOverflow); + if (frame) { + nsContainerFrame* nextInFlow = aState.mNextInFlow; + if (isInOverflow) { + nsFrameList* overflowFrames = nextInFlow->GetOverflowFrames(); + overflowFrames->RemoveFirstChild(); + if (overflowFrames->IsEmpty()) { + nextInFlow->DestroyOverflowList(); + } + } else { + nextInFlow->mFrames.RemoveFirstChild(); + } + + // Move the frame to the principal frame list of this container + mFrames.AppendFrame(this, frame); + // AppendFrame has reparented the frame, we need + // to reparent the frame view then. + nsContainerFrame::ReparentFrameView(frame, nextInFlow, this); + } + return frame; +} + +/* static */ +void nsContainerFrame::ReparentFloatsForInlineChild(nsIFrame* aOurLineContainer, + nsIFrame* aFrame, + bool aReparentSiblings) { + // XXXbz this would be better if it took a nsFrameList or a frame + // list slice.... + NS_ASSERTION(aOurLineContainer->GetNextContinuation() || + aOurLineContainer->GetPrevContinuation(), + "Don't call this when we have no continuation, it's a waste"); + if (!aFrame) { + NS_ASSERTION(aReparentSiblings, "Why did we get called?"); + return; + } + + nsBlockFrame* frameBlock = nsLayoutUtils::GetFloatContainingBlock(aFrame); + if (!frameBlock || frameBlock == aOurLineContainer) { + return; + } + + nsBlockFrame* ourBlock = do_QueryFrame(aOurLineContainer); + NS_ASSERTION(ourBlock, "Not a block, but broke vertically?"); + + while (true) { + ourBlock->ReparentFloats(aFrame, frameBlock, false); + + if (!aReparentSiblings) return; + nsIFrame* next = aFrame->GetNextSibling(); + if (!next) return; + if (next->GetParent() == aFrame->GetParent()) { + aFrame = next; + continue; + } + // This is paranoid and will hardly ever get hit ... but we can't actually + // trust that the frames in the sibling chain all have the same parent, + // because lazy reparenting may be going on. If we find a different + // parent we need to redo our analysis. + ReparentFloatsForInlineChild(aOurLineContainer, next, aReparentSiblings); + return; + } +} + +bool nsContainerFrame::ResolvedOrientationIsVertical() { + StyleOrient orient = StyleDisplay()->mOrient; + switch (orient) { + case StyleOrient::Horizontal: + return false; + case StyleOrient::Vertical: + return true; + case StyleOrient::Inline: + return GetWritingMode().IsVertical(); + case StyleOrient::Block: + return !GetWritingMode().IsVertical(); + } + MOZ_ASSERT_UNREACHABLE("unexpected -moz-orient value"); + return false; +} + +LogicalSize nsContainerFrame::ComputeSizeWithIntrinsicDimensions( + gfxContext* aRenderingContext, WritingMode aWM, + const IntrinsicSize& aIntrinsicSize, const AspectRatio& aAspectRatio, + const LogicalSize& aCBSize, const LogicalSize& aMargin, + const LogicalSize& aBorderPadding, const StyleSizeOverrides& aSizeOverrides, + ComputeSizeFlags aFlags) { + const nsStylePosition* stylePos = StylePosition(); + const auto& styleISize = aSizeOverrides.mStyleISize + ? *aSizeOverrides.mStyleISize + : stylePos->ISize(aWM); + const auto& styleBSize = aSizeOverrides.mStyleBSize + ? *aSizeOverrides.mStyleBSize + : stylePos->BSize(aWM); + const auto& aspectRatio = + aSizeOverrides.mAspectRatio ? *aSizeOverrides.mAspectRatio : aAspectRatio; + + auto* parentFrame = GetParent(); + const bool isGridItem = IsGridItem(); + const bool isFlexItem = + IsFlexItem() && !parentFrame->HasAnyStateBits( + NS_STATE_FLEX_IS_EMULATING_LEGACY_WEBKIT_BOX); + // This variable only gets meaningfully set if isFlexItem is true. It + // indicates which axis (in this frame's own WM) corresponds to its + // flex container's main axis. + LogicalAxis flexMainAxis = eLogicalAxisBlock; + if (isFlexItem && nsFlexContainerFrame::IsItemInlineAxisMainAxis(this)) { + flexMainAxis = eLogicalAxisInline; + } + + // Handle intrinsic sizes and their interaction with + // {min-,max-,}{width,height} according to the rules in + // https://www.w3.org/TR/CSS22/visudet.html#min-max-widths and + // https://drafts.csswg.org/css-sizing-3/#intrinsic-sizes + + // Note: throughout the following section of the function, I avoid + // a * (b / c) because of its reduced accuracy relative to a * b / c + // or (a * b) / c (which are equivalent). + + const bool isAutoOrMaxContentISize = + styleISize.IsAuto() || styleISize.IsMaxContent(); + const bool isAutoBSize = + nsLayoutUtils::IsAutoBSize(styleBSize, aCBSize.BSize(aWM)); + + const auto boxSizingAdjust = stylePos->mBoxSizing == StyleBoxSizing::Border + ? aBorderPadding + : LogicalSize(aWM); + const nscoord boxSizingToMarginEdgeISize = aMargin.ISize(aWM) + + aBorderPadding.ISize(aWM) - + boxSizingAdjust.ISize(aWM); + + nscoord iSize, minISize, maxISize, bSize, minBSize, maxBSize; + enum class Stretch { + // stretch to fill the CB (preserving intrinsic ratio) in the relevant axis + StretchPreservingRatio, + // stretch to fill the CB in the relevant axis + Stretch, + // no stretching in the relevant axis + NoStretch, + }; + // just to avoid having to type these out everywhere: + const auto eStretchPreservingRatio = Stretch::StretchPreservingRatio; + const auto eStretch = Stretch::Stretch; + const auto eNoStretch = Stretch::NoStretch; + + Stretch stretchI = eNoStretch; // stretch behavior in the inline axis + Stretch stretchB = eNoStretch; // stretch behavior in the block axis + + const bool isOrthogonal = aWM.IsOrthogonalTo(parentFrame->GetWritingMode()); + const bool isVertical = aWM.IsVertical(); + const LogicalSize fallbackIntrinsicSize(aWM, kFallbackIntrinsicSize); + const auto& isizeCoord = + isVertical ? aIntrinsicSize.height : aIntrinsicSize.width; + const bool hasIntrinsicISize = isizeCoord.isSome(); + nscoord intrinsicISize = std::max(0, isizeCoord.valueOr(0)); + + const auto& bsizeCoord = + isVertical ? aIntrinsicSize.width : aIntrinsicSize.height; + const bool hasIntrinsicBSize = bsizeCoord.isSome(); + nscoord intrinsicBSize = std::max(0, bsizeCoord.valueOr(0)); + + if (!isAutoOrMaxContentISize) { + iSize = ComputeISizeValue(aRenderingContext, aWM, aCBSize, boxSizingAdjust, + boxSizingToMarginEdgeISize, styleISize, + aSizeOverrides, aFlags) + .mISize; + } else if (MOZ_UNLIKELY(isGridItem) && + !parentFrame->IsMasonry(isOrthogonal ? eLogicalAxisBlock + : eLogicalAxisInline)) { + MOZ_ASSERT(!IsTrueOverflowContainer()); + // 'auto' inline-size for grid-level box - apply 'stretch' as needed: + auto cbSize = aCBSize.ISize(aWM); + if (cbSize != NS_UNCONSTRAINEDSIZE) { + if (!StyleMargin()->HasInlineAxisAuto(aWM)) { + auto inlineAxisAlignment = + isOrthogonal ? stylePos->UsedAlignSelf(GetParent()->Style())._0 + : stylePos->UsedJustifySelf(GetParent()->Style())._0; + if (inlineAxisAlignment == StyleAlignFlags::STRETCH) { + stretchI = eStretch; + } + } + if (stretchI != eNoStretch || + aFlags.contains(ComputeSizeFlag::IClampMarginBoxMinSize)) { + iSize = std::max(nscoord(0), cbSize - aBorderPadding.ISize(aWM) - + aMargin.ISize(aWM)); + } + } else { + // Reset this flag to avoid applying the clamping below. + aFlags -= ComputeSizeFlag::IClampMarginBoxMinSize; + } + } + + const auto& maxISizeCoord = stylePos->MaxISize(aWM); + + if (!maxISizeCoord.IsNone() && + !(isFlexItem && flexMainAxis == eLogicalAxisInline)) { + maxISize = ComputeISizeValue(aRenderingContext, aWM, aCBSize, + boxSizingAdjust, boxSizingToMarginEdgeISize, + maxISizeCoord, aSizeOverrides, aFlags) + .mISize; + } else { + maxISize = nscoord_MAX; + } + + // NOTE: Flex items ignore their min & max sizing properties in their + // flex container's main-axis. (Those properties get applied later in + // the flexbox algorithm.) + + const auto& minISizeCoord = stylePos->MinISize(aWM); + + if (!minISizeCoord.IsAuto() && + !(isFlexItem && flexMainAxis == eLogicalAxisInline)) { + minISize = ComputeISizeValue(aRenderingContext, aWM, aCBSize, + boxSizingAdjust, boxSizingToMarginEdgeISize, + minISizeCoord, aSizeOverrides, aFlags) + .mISize; + } else { + // Treat "min-width: auto" as 0. + // NOTE: Technically, "auto" is supposed to behave like "min-content" on + // flex items. However, we don't need to worry about that here, because + // flex items' min-sizes are intentionally ignored until the flex + // container explicitly considers them during space distribution. + minISize = 0; + } + + if (!isAutoBSize) { + bSize = nsLayoutUtils::ComputeBSizeValue(aCBSize.BSize(aWM), + boxSizingAdjust.BSize(aWM), + styleBSize.AsLengthPercentage()); + } else if (MOZ_UNLIKELY(isGridItem) && + !parentFrame->IsMasonry(isOrthogonal ? eLogicalAxisInline + : eLogicalAxisBlock)) { + MOZ_ASSERT(!IsTrueOverflowContainer()); + // 'auto' block-size for grid-level box - apply 'stretch' as needed: + auto cbSize = aCBSize.BSize(aWM); + if (cbSize != NS_UNCONSTRAINEDSIZE) { + if (!StyleMargin()->HasBlockAxisAuto(aWM)) { + auto blockAxisAlignment = + !isOrthogonal ? stylePos->UsedAlignSelf(GetParent()->Style())._0 + : stylePos->UsedJustifySelf(GetParent()->Style())._0; + if (blockAxisAlignment == StyleAlignFlags::STRETCH) { + stretchB = eStretch; + } + } + if (stretchB != eNoStretch || + aFlags.contains(ComputeSizeFlag::BClampMarginBoxMinSize)) { + bSize = std::max(nscoord(0), cbSize - aBorderPadding.BSize(aWM) - + aMargin.BSize(aWM)); + } + } else { + // Reset this flag to avoid applying the clamping below. + aFlags -= ComputeSizeFlag::BClampMarginBoxMinSize; + } + } + + const auto& maxBSizeCoord = stylePos->MaxBSize(aWM); + + if (!nsLayoutUtils::IsAutoBSize(maxBSizeCoord, aCBSize.BSize(aWM)) && + !(isFlexItem && flexMainAxis == eLogicalAxisBlock)) { + maxBSize = nsLayoutUtils::ComputeBSizeValue( + aCBSize.BSize(aWM), boxSizingAdjust.BSize(aWM), + maxBSizeCoord.AsLengthPercentage()); + } else { + maxBSize = nscoord_MAX; + } + + const auto& minBSizeCoord = stylePos->MinBSize(aWM); + + if (!nsLayoutUtils::IsAutoBSize(minBSizeCoord, aCBSize.BSize(aWM)) && + !(isFlexItem && flexMainAxis == eLogicalAxisBlock)) { + minBSize = nsLayoutUtils::ComputeBSizeValue( + aCBSize.BSize(aWM), boxSizingAdjust.BSize(aWM), + minBSizeCoord.AsLengthPercentage()); + } else { + minBSize = 0; + } + + NS_ASSERTION(aCBSize.ISize(aWM) != NS_UNCONSTRAINEDSIZE, + "Our containing block must not have unconstrained inline-size!"); + + // Now calculate the used values for iSize and bSize: + if (isAutoOrMaxContentISize) { + if (isAutoBSize) { + // 'auto' iSize, 'auto' bSize + + // Get tentative values - CSS 2.1 sections 10.3.2 and 10.6.2: + + nscoord tentISize, tentBSize; + + if (hasIntrinsicISize) { + tentISize = intrinsicISize; + } else if (hasIntrinsicBSize && aspectRatio) { + tentISize = aspectRatio.ComputeRatioDependentSize( + LogicalAxis::eLogicalAxisInline, aWM, intrinsicBSize, + boxSizingAdjust); + } else if (aspectRatio) { + tentISize = + aCBSize.ISize(aWM) - boxSizingToMarginEdgeISize; // XXX scrollbar? + if (tentISize < 0) { + tentISize = 0; + } + } else { + tentISize = fallbackIntrinsicSize.ISize(aWM); + } + + // If we need to clamp the inline size to fit the CB, we use the 'stretch' + // or 'normal' codepath. We use the ratio-preserving 'normal' codepath + // unless we have 'stretch' in the other axis. + if (aFlags.contains(ComputeSizeFlag::IClampMarginBoxMinSize) && + stretchI != eStretch && tentISize > iSize) { + stretchI = (stretchB == eStretch ? eStretch : eStretchPreservingRatio); + } + + if (hasIntrinsicBSize) { + tentBSize = intrinsicBSize; + } else if (aspectRatio) { + tentBSize = aspectRatio.ComputeRatioDependentSize( + LogicalAxis::eLogicalAxisBlock, aWM, tentISize, boxSizingAdjust); + } else { + tentBSize = fallbackIntrinsicSize.BSize(aWM); + } + + // (ditto the comment about clamping the inline size above) + if (aFlags.contains(ComputeSizeFlag::BClampMarginBoxMinSize) && + stretchB != eStretch && tentBSize > bSize) { + stretchB = (stretchI == eStretch ? eStretch : eStretchPreservingRatio); + } + + if (stretchI == eStretch) { + tentISize = iSize; // * / 'stretch' + if (stretchB == eStretch) { + tentBSize = bSize; // 'stretch' / 'stretch' + } else if (stretchB == eStretchPreservingRatio && aspectRatio) { + // 'normal' / 'stretch' + tentBSize = aspectRatio.ComputeRatioDependentSize( + LogicalAxis::eLogicalAxisBlock, aWM, iSize, boxSizingAdjust); + } + } else if (stretchB == eStretch) { + tentBSize = bSize; // 'stretch' / * (except 'stretch') + if (stretchI == eStretchPreservingRatio && aspectRatio) { + // 'stretch' / 'normal' + tentISize = aspectRatio.ComputeRatioDependentSize( + LogicalAxis::eLogicalAxisInline, aWM, bSize, boxSizingAdjust); + } + } else if (stretchI == eStretchPreservingRatio && aspectRatio) { + tentISize = iSize; // * (except 'stretch') / 'normal' + tentBSize = aspectRatio.ComputeRatioDependentSize( + LogicalAxis::eLogicalAxisBlock, aWM, iSize, boxSizingAdjust); + if (stretchB == eStretchPreservingRatio && tentBSize > bSize) { + // Stretch within the CB size with preserved intrinsic ratio. + tentBSize = bSize; // 'normal' / 'normal' + tentISize = aspectRatio.ComputeRatioDependentSize( + LogicalAxis::eLogicalAxisInline, aWM, bSize, boxSizingAdjust); + } + } else if (stretchB == eStretchPreservingRatio && aspectRatio) { + tentBSize = bSize; // 'normal' / * (except 'normal' and 'stretch') + tentISize = aspectRatio.ComputeRatioDependentSize( + LogicalAxis::eLogicalAxisInline, aWM, bSize, boxSizingAdjust); + } + + // ComputeAutoSizeWithIntrinsicDimensions preserves the ratio when + // applying the min/max-size. We don't want that when we have 'stretch' + // in either axis because tentISize/tentBSize is likely not according to + // ratio now. + if (aspectRatio && stretchI != eStretch && stretchB != eStretch) { + nsSize autoSize = nsLayoutUtils::ComputeAutoSizeWithIntrinsicDimensions( + minISize, minBSize, maxISize, maxBSize, tentISize, tentBSize); + // The nsSize that ComputeAutoSizeWithIntrinsicDimensions returns will + // actually contain logical values if the parameters passed to it were + // logical coordinates, so we do NOT perform a physical-to-logical + // conversion here, but just assign the fields directly to our result. + iSize = autoSize.width; + bSize = autoSize.height; + } else { + // Not honoring an intrinsic ratio: clamp the dimensions independently. + iSize = NS_CSS_MINMAX(tentISize, minISize, maxISize); + bSize = NS_CSS_MINMAX(tentBSize, minBSize, maxBSize); + } + } else { + // 'auto' iSize, non-'auto' bSize + bSize = NS_CSS_MINMAX(bSize, minBSize, maxBSize); + if (stretchI != eStretch) { + if (aspectRatio) { + iSize = aspectRatio.ComputeRatioDependentSize( + LogicalAxis::eLogicalAxisInline, aWM, bSize, boxSizingAdjust); + } else if (hasIntrinsicISize) { + if (!(aFlags.contains(ComputeSizeFlag::IClampMarginBoxMinSize) && + intrinsicISize > iSize)) { + iSize = intrinsicISize; + } // else - leave iSize as is to fill the CB + } else { + iSize = fallbackIntrinsicSize.ISize(aWM); + } + } // else - leave iSize as is to fill the CB + iSize = NS_CSS_MINMAX(iSize, minISize, maxISize); + } + } else { + if (isAutoBSize) { + // non-'auto' iSize, 'auto' bSize + iSize = NS_CSS_MINMAX(iSize, minISize, maxISize); + if (stretchB != eStretch) { + if (aspectRatio) { + bSize = aspectRatio.ComputeRatioDependentSize( + LogicalAxis::eLogicalAxisBlock, aWM, iSize, boxSizingAdjust); + } else if (hasIntrinsicBSize) { + if (!(aFlags.contains(ComputeSizeFlag::BClampMarginBoxMinSize) && + intrinsicBSize > bSize)) { + bSize = intrinsicBSize; + } // else - leave bSize as is to fill the CB + } else { + bSize = fallbackIntrinsicSize.BSize(aWM); + } + } // else - leave bSize as is to fill the CB + bSize = NS_CSS_MINMAX(bSize, minBSize, maxBSize); + + } else { + // non-'auto' iSize, non-'auto' bSize + iSize = NS_CSS_MINMAX(iSize, minISize, maxISize); + bSize = NS_CSS_MINMAX(bSize, minBSize, maxBSize); + } + } + + return LogicalSize(aWM, iSize, bSize); +} + +nsRect nsContainerFrame::ComputeSimpleTightBounds( + DrawTarget* aDrawTarget) const { + if (StyleOutline()->ShouldPaintOutline() || StyleBorder()->HasBorder() || + !StyleBackground()->IsTransparent(this) || + StyleDisplay()->HasAppearance()) { + // Not necessarily tight, due to clipping, negative + // outline-offset, and lots of other issues, but that's OK + return InkOverflowRect(); + } + + nsRect r(0, 0, 0, 0); + for (const auto& childLists : ChildLists()) { + for (nsIFrame* child : childLists.mList) { + r.UnionRect( + r, child->ComputeTightBounds(aDrawTarget) + child->GetPosition()); + } + } + return r; +} + +void nsContainerFrame::PushDirtyBitToAbsoluteFrames() { + if (!HasAnyStateBits(NS_FRAME_IS_DIRTY)) { + return; // No dirty bit to push. + } + if (!HasAbsolutelyPositionedChildren()) { + return; // No absolute children to push to. + } + GetAbsoluteContainingBlock()->MarkAllFramesDirty(); +} + +// Define the MAX_FRAME_DEPTH to be the ContentSink's MAX_REFLOW_DEPTH plus +// 4 for the frames above the document's frames: +// the Viewport, GFXScroll, ScrollPort, and Canvas +#define MAX_FRAME_DEPTH (MAX_REFLOW_DEPTH + 4) + +bool nsContainerFrame::IsFrameTreeTooDeep(const ReflowInput& aReflowInput, + ReflowOutput& aMetrics, + nsReflowStatus& aStatus) { + if (aReflowInput.mReflowDepth > MAX_FRAME_DEPTH) { + NS_WARNING("frame tree too deep; setting zero size and returning"); + AddStateBits(NS_FRAME_TOO_DEEP_IN_FRAME_TREE); + ClearOverflowRects(); + aMetrics.ClearSize(); + aMetrics.SetBlockStartAscent(0); + aMetrics.mCarriedOutBEndMargin.Zero(); + aMetrics.mOverflowAreas.Clear(); + + aStatus.Reset(); + if (GetNextInFlow()) { + // Reflow depth might vary between reflows, so we might have + // successfully reflowed and split this frame before. If so, we + // shouldn't delete its continuations. + aStatus.SetIncomplete(); + } + + return true; + } + RemoveStateBits(NS_FRAME_TOO_DEEP_IN_FRAME_TREE); + return false; +} + +bool nsContainerFrame::ShouldAvoidBreakInside( + const ReflowInput& aReflowInput) const { + MOZ_ASSERT(this == aReflowInput.mFrame, + "Caller should pass a ReflowInput for this frame!"); + + const auto* disp = StyleDisplay(); + const bool mayAvoidBreak = [&] { + switch (disp->mBreakInside) { + case StyleBreakWithin::Auto: + return false; + case StyleBreakWithin::Avoid: + return true; + case StyleBreakWithin::AvoidPage: + return aReflowInput.mBreakType == ReflowInput::BreakType::Page; + case StyleBreakWithin::AvoidColumn: + return aReflowInput.mBreakType == ReflowInput::BreakType::Column; + } + MOZ_ASSERT_UNREACHABLE("Unknown break-inside value"); + return false; + }(); + + if (!mayAvoidBreak) { + return false; + } + if (aReflowInput.mFlags.mIsTopOfPage) { + return false; + } + if (IsAbsolutelyPositioned(disp)) { + return false; + } + if (GetPrevInFlow()) { + return false; + } + return true; +} + +void nsContainerFrame::ConsiderChildOverflow(OverflowAreas& aOverflowAreas, + nsIFrame* aChildFrame) { + if (StyleDisplay()->IsContainLayout() && + IsFrameOfType(eSupportsContainLayoutAndPaint)) { + // If we have layout containment and are not a non-atomic, inline-level + // principal box, we should only consider our child's ink overflow, + // leaving the scrollable regions of the parent unaffected. + // Note: scrollable overflow is a subset of ink overflow, + // so this has the same affect as unioning the child's ink and + // scrollable overflow with the parent's ink overflow. + const OverflowAreas childOverflows(aChildFrame->InkOverflowRect(), + nsRect()); + aOverflowAreas.UnionWith(childOverflows + aChildFrame->GetPosition()); + } else { + aOverflowAreas.UnionWith( + aChildFrame->GetActualAndNormalOverflowAreasRelativeToParent()); + } +} + +StyleAlignFlags nsContainerFrame::CSSAlignmentForAbsPosChild( + const ReflowInput& aChildRI, LogicalAxis aLogicalAxis) const { + MOZ_ASSERT(aChildRI.mFrame->IsAbsolutelyPositioned(), + "This method should only be called for abspos children"); + NS_ERROR( + "Child classes that use css box alignment for abspos children " + "should provide their own implementation of this method!"); + + // In the unexpected/unlikely event that this implementation gets invoked, + // just use "start" alignment. + return StyleAlignFlags::START; +} + +nsOverflowContinuationTracker::nsOverflowContinuationTracker( + nsContainerFrame* aFrame, bool aWalkOOFFrames, + bool aSkipOverflowContainerChildren) + : mOverflowContList(nullptr), + mPrevOverflowCont(nullptr), + mSentry(nullptr), + mParent(aFrame), + mSkipOverflowContainerChildren(aSkipOverflowContainerChildren), + mWalkOOFFrames(aWalkOOFFrames) { + MOZ_ASSERT(aFrame, "null frame pointer"); + SetupOverflowContList(); +} + +void nsOverflowContinuationTracker::SetupOverflowContList() { + MOZ_ASSERT(mParent, "null frame pointer"); + MOZ_ASSERT(!mOverflowContList, "already have list"); + nsContainerFrame* nif = + static_cast<nsContainerFrame*>(mParent->GetNextInFlow()); + if (nif) { + mOverflowContList = nif->GetOverflowContainers(); + if (mOverflowContList) { + mParent = nif; + SetUpListWalker(); + } + } + if (!mOverflowContList) { + mOverflowContList = mParent->GetExcessOverflowContainers(); + if (mOverflowContList) { + SetUpListWalker(); + } + } +} + +/** + * Helper function to walk past overflow continuations whose prev-in-flow + * isn't a normal child and to set mSentry and mPrevOverflowCont correctly. + */ +void nsOverflowContinuationTracker::SetUpListWalker() { + NS_ASSERTION(!mSentry && !mPrevOverflowCont, + "forgot to reset mSentry or mPrevOverflowCont"); + if (mOverflowContList) { + nsIFrame* cur = mOverflowContList->FirstChild(); + if (mSkipOverflowContainerChildren) { + while (cur && cur->GetPrevInFlow()->HasAnyStateBits( + NS_FRAME_IS_OVERFLOW_CONTAINER)) { + mPrevOverflowCont = cur; + cur = cur->GetNextSibling(); + } + while (cur && + (cur->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW) != mWalkOOFFrames)) { + mPrevOverflowCont = cur; + cur = cur->GetNextSibling(); + } + } + if (cur) { + mSentry = cur->GetPrevInFlow(); + } + } +} + +/** + * Helper function to step forward through the overflow continuations list. + * Sets mSentry and mPrevOverflowCont, skipping over OOF or non-OOF frames + * as appropriate. May only be called when we have already set up an + * mOverflowContList; mOverflowContList cannot be null. + */ +void nsOverflowContinuationTracker::StepForward() { + MOZ_ASSERT(mOverflowContList, "null list"); + + // Step forward + if (mPrevOverflowCont) { + mPrevOverflowCont = mPrevOverflowCont->GetNextSibling(); + } else { + mPrevOverflowCont = mOverflowContList->FirstChild(); + } + + // Skip over oof or non-oof frames as appropriate + if (mSkipOverflowContainerChildren) { + nsIFrame* cur = mPrevOverflowCont->GetNextSibling(); + while (cur && + (cur->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW) != mWalkOOFFrames)) { + mPrevOverflowCont = cur; + cur = cur->GetNextSibling(); + } + } + + // Set up the sentry + mSentry = (mPrevOverflowCont->GetNextSibling()) + ? mPrevOverflowCont->GetNextSibling()->GetPrevInFlow() + : nullptr; +} + +nsresult nsOverflowContinuationTracker::Insert(nsIFrame* aOverflowCont, + nsReflowStatus& aReflowStatus) { + MOZ_ASSERT(aOverflowCont, "null frame pointer"); + MOZ_ASSERT(!mSkipOverflowContainerChildren || + mWalkOOFFrames == + aOverflowCont->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW), + "shouldn't insert frame that doesn't match walker type"); + MOZ_ASSERT(aOverflowCont->GetPrevInFlow(), + "overflow containers must have a prev-in-flow"); + + nsresult rv = NS_OK; + bool reparented = false; + nsPresContext* presContext = aOverflowCont->PresContext(); + bool addToList = !mSentry || aOverflowCont != mSentry->GetNextInFlow(); + + // If we have a list and aOverflowCont is already in it then don't try to + // add it again. + if (addToList && aOverflowCont->GetParent() == mParent && + aOverflowCont->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER) && + mOverflowContList && mOverflowContList->ContainsFrame(aOverflowCont)) { + addToList = false; + mPrevOverflowCont = aOverflowCont->GetPrevSibling(); + } + + if (addToList) { + if (aOverflowCont->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER)) { + // aOverflowCont is in some other overflow container list, + // steal it first + NS_ASSERTION(!(mOverflowContList && + mOverflowContList->ContainsFrame(aOverflowCont)), + "overflow containers out of order"); + aOverflowCont->GetParent()->StealFrame(aOverflowCont); + } else { + aOverflowCont->AddStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER); + } + if (!mOverflowContList) { + // Note: We don't use SetExcessOverflowContainers() since it requires + // setting a non-empty list. It's OK to manually set an empty list to + // ExcessOverflowContainersProperty() because we are going to insert + // aOverflowCont to mOverflowContList below, which guarantees an nonempty + // list in ExcessOverflowContainersProperty(). + mOverflowContList = new (presContext->PresShell()) nsFrameList(); + mParent->SetProperty(nsContainerFrame::ExcessOverflowContainersProperty(), + mOverflowContList); + SetUpListWalker(); + } + if (aOverflowCont->GetParent() != mParent) { + nsContainerFrame::ReparentFrameView(aOverflowCont, + aOverflowCont->GetParent(), mParent); + reparented = true; + } + + // If aOverflowCont has a prev/next-in-flow that might be in + // mOverflowContList we need to find it and insert after/before it to + // maintain the order amongst next-in-flows in this list. + nsIFrame* pif = aOverflowCont->GetPrevInFlow(); + nsIFrame* nif = aOverflowCont->GetNextInFlow(); + if ((pif && pif->GetParent() == mParent && pif != mPrevOverflowCont) || + (nif && nif->GetParent() == mParent && mPrevOverflowCont)) { + for (nsIFrame* f : *mOverflowContList) { + if (f == pif) { + mPrevOverflowCont = pif; + break; + } + if (f == nif) { + mPrevOverflowCont = f->GetPrevSibling(); + break; + } + } + } + + mOverflowContList->InsertFrame(mParent, mPrevOverflowCont, aOverflowCont); + aReflowStatus.SetNextInFlowNeedsReflow(); + } + + // If we need to reflow it, mark it dirty + if (aReflowStatus.NextInFlowNeedsReflow()) { + aOverflowCont->MarkSubtreeDirty(); + } + + // It's in our list, just step forward + StepForward(); + NS_ASSERTION(mPrevOverflowCont == aOverflowCont || + (mSkipOverflowContainerChildren && + mPrevOverflowCont->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW) != + aOverflowCont->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW)), + "OverflowContTracker in unexpected state"); + + if (addToList) { + // Convert all non-overflow-container next-in-flows of aOverflowCont + // into overflow containers and move them to our overflow + // tracker. This preserves the invariant that the next-in-flows + // of an overflow container are also overflow containers. + nsIFrame* f = aOverflowCont->GetNextInFlow(); + if (f && (!f->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER) || + (!reparented && f->GetParent() == mParent) || + (reparented && f->GetParent() != mParent))) { + if (!f->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER)) { + f->GetParent()->StealFrame(f); + } + Insert(f, aReflowStatus); + } + } + return rv; +} + +void nsOverflowContinuationTracker::BeginFinish(nsIFrame* aChild) { + MOZ_ASSERT(aChild, "null ptr"); + MOZ_ASSERT(aChild->GetNextInFlow(), + "supposed to call Finish *before* deleting next-in-flow!"); + + for (nsIFrame* f = aChild; f; f = f->GetNextInFlow()) { + // We'll update these in EndFinish after the next-in-flows are gone. + if (f == mPrevOverflowCont) { + mSentry = nullptr; + mPrevOverflowCont = nullptr; + break; + } + if (f == mSentry) { + mSentry = nullptr; + break; + } + } +} + +void nsOverflowContinuationTracker::EndFinish(nsIFrame* aChild) { + if (!mOverflowContList) { + return; + } + // Forget mOverflowContList if it was deleted. + nsFrameList* eoc = mParent->GetExcessOverflowContainers(); + if (eoc != mOverflowContList) { + nsFrameList* oc = mParent->GetOverflowContainers(); + if (oc != mOverflowContList) { + // mOverflowContList was deleted + mPrevOverflowCont = nullptr; + mSentry = nullptr; + mParent = aChild->GetParent(); + mOverflowContList = nullptr; + SetupOverflowContList(); + return; + } + } + // The list survived, update mSentry if needed. + if (!mSentry) { + if (!mPrevOverflowCont) { + SetUpListWalker(); + } else { + mozilla::AutoRestore<nsIFrame*> saved(mPrevOverflowCont); + // step backward to make StepForward() use our current mPrevOverflowCont + mPrevOverflowCont = mPrevOverflowCont->GetPrevSibling(); + StepForward(); + } + } +} + +///////////////////////////////////////////////////////////////////////////// +// Debugging + +#ifdef DEBUG +void nsContainerFrame::SanityCheckChildListsBeforeReflow() const { + MOZ_ASSERT(IsFlexOrGridContainer(), + "Only Flex / Grid containers can call this!"); + + const auto didPushItemsBit = IsFlexContainerFrame() + ? NS_STATE_FLEX_DID_PUSH_ITEMS + : NS_STATE_GRID_DID_PUSH_ITEMS; + ChildListIDs absLists = {FrameChildListID::Absolute, FrameChildListID::Fixed, + FrameChildListID::OverflowContainers, + FrameChildListID::ExcessOverflowContainers}; + ChildListIDs itemLists = {FrameChildListID::Principal, + FrameChildListID::Overflow}; + for (const nsIFrame* f = this; f; f = f->GetNextInFlow()) { + MOZ_ASSERT(!f->HasAnyStateBits(didPushItemsBit), + "At start of reflow, we should've pulled items back from all " + "NIFs and cleared the state bit stored in didPushItemsBit in " + "the process."); + for (const auto& [list, listID] : f->ChildLists()) { + if (!itemLists.contains(listID)) { + MOZ_ASSERT( + absLists.contains(listID) || listID == FrameChildListID::Backdrop, + "unexpected non-empty child list"); + continue; + } + for (const auto* child : list) { + MOZ_ASSERT(f == this || child->GetPrevInFlow(), + "all pushed items must be pulled up before reflow"); + } + } + } + // If we have a prev-in-flow, each of its children's next-in-flow + // should be one of our children or be null. + const auto* pif = static_cast<nsContainerFrame*>(GetPrevInFlow()); + if (pif) { + const nsFrameList* oc = GetOverflowContainers(); + const nsFrameList* eoc = GetExcessOverflowContainers(); + const nsFrameList* pifEOC = pif->GetExcessOverflowContainers(); + for (const nsIFrame* child : pif->PrincipalChildList()) { + const nsIFrame* childNIF = child->GetNextInFlow(); + MOZ_ASSERT(!childNIF || mFrames.ContainsFrame(childNIF) || + (pifEOC && pifEOC->ContainsFrame(childNIF)) || + (oc && oc->ContainsFrame(childNIF)) || + (eoc && eoc->ContainsFrame(childNIF))); + } + } +} + +void nsContainerFrame::SetDidPushItemsBitIfNeeded(ChildListID aListID, + nsIFrame* aOldFrame) { + MOZ_ASSERT(IsFlexOrGridContainer(), + "Only Flex / Grid containers can call this!"); + + // Note that FrameChildListID::Principal doesn't mean aOldFrame must be on + // that list. It can also be on FrameChildListID::Overflow, in which case it + // might be a pushed item, and if it's the only pushed item our DID_PUSH_ITEMS + // bit will lie. + if (aListID == FrameChildListID::Principal && !aOldFrame->GetPrevInFlow()) { + // Since the bit may lie, set the mDidPushItemsBitMayLie value to true for + // ourself and for all our prev-in-flows. + nsContainerFrame* frameThatMayLie = this; + do { + frameThatMayLie->mDidPushItemsBitMayLie = true; + frameThatMayLie = + static_cast<nsContainerFrame*>(frameThatMayLie->GetPrevInFlow()); + } while (frameThatMayLie); + } +} +#endif + +#ifdef DEBUG_FRAME_DUMP +void nsContainerFrame::List(FILE* out, const char* aPrefix, + ListFlags aFlags) const { + nsCString str; + ListGeneric(str, aPrefix, aFlags); + ExtraContainerFrameInfo(str); + + // Output the frame name and various fields. + fprintf_stderr(out, "%s <\n", str.get()); + + const nsCString pfx = nsCString(aPrefix) + " "_ns; + + // Output principal child list separately since we want to omit its + // name and address. + for (nsIFrame* kid : PrincipalChildList()) { + kid->List(out, pfx.get(), aFlags); + } + + // Output rest of the child lists. + const ChildListIDs skippedListIDs = {FrameChildListID::Principal}; + ListChildLists(out, pfx.get(), aFlags, skippedListIDs); + + fprintf_stderr(out, "%s>\n", aPrefix); +} + +void nsContainerFrame::ListWithMatchedRules(FILE* out, + const char* aPrefix) const { + fprintf_stderr(out, "%s%s\n", aPrefix, ListTag().get()); + + nsCString rulePrefix; + rulePrefix += aPrefix; + rulePrefix += " "; + ListMatchedRules(out, rulePrefix.get()); + + nsCString childPrefix; + childPrefix += aPrefix; + childPrefix += " "; + + for (const auto& childList : ChildLists()) { + for (const nsIFrame* kid : childList.mList) { + kid->ListWithMatchedRules(out, childPrefix.get()); + } + } +} + +void nsContainerFrame::ListChildLists(FILE* aOut, const char* aPrefix, + ListFlags aFlags, + ChildListIDs aSkippedListIDs) const { + const nsCString nestedPfx = nsCString(aPrefix) + " "_ns; + + for (const auto& [list, listID] : ChildLists()) { + if (aSkippedListIDs.contains(listID)) { + continue; + } + + // Use nsPrintfCString so that %p don't output prefix "0x". This is + // consistent with nsIFrame::ListTag(). + const nsPrintfCString str("%s%s@%p <\n", aPrefix, ChildListName(listID), + &GetChildList(listID)); + fprintf_stderr(aOut, "%s", str.get()); + + for (nsIFrame* kid : list) { + // Verify the child frame's parent frame pointer is correct. + NS_ASSERTION(kid->GetParent() == this, "Bad parent frame pointer!"); + kid->List(aOut, nestedPfx.get(), aFlags); + } + fprintf_stderr(aOut, "%s>\n", aPrefix); + } +} + +void nsContainerFrame::ExtraContainerFrameInfo(nsACString& aTo) const { + (void)aTo; +} + +#endif |