summaryrefslogtreecommitdiffstats
path: root/layout/generic/nsBlockFrame.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'layout/generic/nsBlockFrame.cpp')
-rw-r--r--layout/generic/nsBlockFrame.cpp8626
1 files changed, 8626 insertions, 0 deletions
diff --git a/layout/generic/nsBlockFrame.cpp b/layout/generic/nsBlockFrame.cpp
new file mode 100644
index 0000000000..54976ecc47
--- /dev/null
+++ b/layout/generic/nsBlockFrame.cpp
@@ -0,0 +1,8626 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=8 sts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/*
+ * rendering object for CSS display:block, inline-block, and list-item
+ * boxes, also used for various anonymous boxes
+ */
+
+#include "nsBlockFrame.h"
+
+#include "gfxContext.h"
+
+#include "mozilla/AppUnits.h"
+#include "mozilla/Baseline.h"
+#include "mozilla/ComputedStyle.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/StaticPrefs_browser.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "mozilla/ToString.h"
+#include "mozilla/UniquePtr.h"
+
+#include "nsCRT.h"
+#include "nsCOMPtr.h"
+#include "nsCSSRendering.h"
+#include "nsAbsoluteContainingBlock.h"
+#include "nsBlockReflowContext.h"
+#include "BlockReflowState.h"
+#include "nsFontMetrics.h"
+#include "nsGenericHTMLElement.h"
+#include "nsLineBox.h"
+#include "nsLineLayout.h"
+#include "nsPlaceholderFrame.h"
+#include "nsStyleConsts.h"
+#include "nsFrameManager.h"
+#include "nsPresContext.h"
+#include "nsPresContextInlines.h"
+#include "nsHTMLParts.h"
+#include "nsGkAtoms.h"
+#include "nsAttrValueInlines.h"
+#include "mozilla/Sprintf.h"
+#include "nsFloatManager.h"
+#include "prenv.h"
+#include "nsError.h"
+#include "nsIScrollableFrame.h"
+#include <algorithm>
+#include "nsLayoutUtils.h"
+#include "nsDisplayList.h"
+#include "nsCSSAnonBoxes.h"
+#include "nsCSSFrameConstructor.h"
+#include "TextOverflow.h"
+#include "nsIFrameInlines.h"
+#include "CounterStyleManager.h"
+#include "mozilla/dom/HTMLDetailsElement.h"
+#include "mozilla/dom/HTMLSummaryElement.h"
+#include "mozilla/dom/Selection.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/RestyleManager.h"
+#include "mozilla/ServoStyleSet.h"
+#include "mozilla/Telemetry.h"
+#include "nsFlexContainerFrame.h"
+#include "nsFileControlFrame.h"
+#include "nsMathMLContainerFrame.h"
+#include "nsSelectsAreaFrame.h"
+
+#include "nsBidiPresUtils.h"
+
+#include <inttypes.h>
+
+static const int MIN_LINES_NEEDING_CURSOR = 20;
+
+using namespace mozilla;
+using namespace mozilla::css;
+using namespace mozilla::dom;
+using namespace mozilla::layout;
+using AbsPosReflowFlags = nsAbsoluteContainingBlock::AbsPosReflowFlags;
+using ClearFloatsResult = BlockReflowState::ClearFloatsResult;
+using ShapeType = nsFloatManager::ShapeType;
+
+static void MarkAllDescendantLinesDirty(nsBlockFrame* aBlock) {
+ for (auto& line : aBlock->Lines()) {
+ if (line.IsBlock()) {
+ nsBlockFrame* bf = do_QueryFrame(line.mFirstChild);
+ if (bf) {
+ MarkAllDescendantLinesDirty(bf);
+ }
+ }
+ line.MarkDirty();
+ }
+}
+
+static void MarkSameFloatManagerLinesDirty(nsBlockFrame* aBlock) {
+ nsBlockFrame* blockWithFloatMgr = aBlock;
+ while (!blockWithFloatMgr->HasAnyStateBits(NS_BLOCK_BFC_STATE_BITS)) {
+ nsBlockFrame* bf = do_QueryFrame(blockWithFloatMgr->GetParent());
+ if (!bf) {
+ break;
+ }
+ blockWithFloatMgr = bf;
+ }
+
+ // Mark every line at and below the line where the float was
+ // dirty, and mark their lines dirty too. We could probably do
+ // something more efficient --- e.g., just dirty the lines that intersect
+ // the float vertically.
+ MarkAllDescendantLinesDirty(blockWithFloatMgr);
+}
+
+/**
+ * Returns true if aFrame is a block that has one or more float children.
+ */
+static bool BlockHasAnyFloats(nsIFrame* aFrame) {
+ nsBlockFrame* block = do_QueryFrame(aFrame);
+ if (!block) {
+ return false;
+ }
+ if (block->GetChildList(FrameChildListID::Float).FirstChild()) {
+ return true;
+ }
+
+ for (const auto& line : block->Lines()) {
+ if (line.IsBlock() && BlockHasAnyFloats(line.mFirstChild)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+/**
+ * Determines whether the given frame is visible or has
+ * visible children that participate in the same line. Frames
+ * that are not line participants do not have their
+ * children checked.
+ */
+static bool FrameHasVisibleInlineContent(nsIFrame* aFrame) {
+ MOZ_ASSERT(aFrame, "Frame argument cannot be null");
+
+ if (aFrame->StyleVisibility()->IsVisible()) {
+ return true;
+ }
+
+ if (aFrame->IsLineParticipant()) {
+ for (nsIFrame* kid : aFrame->PrincipalChildList()) {
+ if (kid->StyleVisibility()->IsVisible() ||
+ FrameHasVisibleInlineContent(kid)) {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+/**
+ * Determines whether any of the frames descended from the
+ * given line have inline content with 'visibility: visible'.
+ * This function calls FrameHasVisibleInlineContent to process
+ * each frame in the line's child list.
+ */
+static bool LineHasVisibleInlineContent(nsLineBox* aLine) {
+ nsIFrame* kid = aLine->mFirstChild;
+ int32_t n = aLine->GetChildCount();
+ while (n-- > 0) {
+ if (FrameHasVisibleInlineContent(kid)) {
+ return true;
+ }
+
+ kid = kid->GetNextSibling();
+ }
+
+ return false;
+}
+
+/**
+ * Iterates through the frame's in-flow children and
+ * unions the ink overflow of all text frames which
+ * participate in the line aFrame belongs to.
+ * If a child of aFrame is not a text frame,
+ * we recurse with the child as the aFrame argument.
+ * If aFrame isn't a line participant, we skip it entirely
+ * and return an empty rect.
+ * The resulting nsRect is offset relative to the parent of aFrame.
+ */
+static nsRect GetFrameTextArea(nsIFrame* aFrame,
+ nsDisplayListBuilder* aBuilder) {
+ nsRect textArea;
+ if (const nsTextFrame* textFrame = do_QueryFrame(aFrame)) {
+ if (!textFrame->IsEntirelyWhitespace()) {
+ textArea = aFrame->InkOverflowRect();
+ }
+ } else if (aFrame->IsLineParticipant()) {
+ for (nsIFrame* kid : aFrame->PrincipalChildList()) {
+ nsRect kidTextArea = GetFrameTextArea(kid, aBuilder);
+ textArea.OrWith(kidTextArea);
+ }
+ }
+ // add aFrame's position to keep textArea relative to aFrame's parent
+ return textArea + aFrame->GetPosition();
+}
+
+/**
+ * Iterates through the line's children and
+ * unions the ink overflow of all text frames.
+ * GetFrameTextArea unions and returns the ink overflow
+ * from all line-participating text frames within the given child.
+ * The nsRect returned from GetLineTextArea is offset
+ * relative to the given line.
+ */
+static nsRect GetLineTextArea(nsLineBox* aLine,
+ nsDisplayListBuilder* aBuilder) {
+ nsRect textArea;
+ nsIFrame* kid = aLine->mFirstChild;
+ int32_t n = aLine->GetChildCount();
+ while (n-- > 0) {
+ nsRect kidTextArea = GetFrameTextArea(kid, aBuilder);
+ textArea.OrWith(kidTextArea);
+ kid = kid->GetNextSibling();
+ }
+
+ return textArea;
+}
+
+/**
+ * Starting with aFrame, iterates upward through parent frames and checks for
+ * non-transparent background colors. If one is found, we use that as our
+ * backplate color. Otheriwse, we use the default background color from
+ * our high contrast theme.
+ */
+static nscolor GetBackplateColor(nsIFrame* aFrame) {
+ nsPresContext* pc = aFrame->PresContext();
+ nscolor currentBackgroundColor = NS_TRANSPARENT;
+ for (nsIFrame* frame = aFrame; frame; frame = frame->GetParent()) {
+ // NOTE(emilio): We assume themed frames (frame->IsThemed()) have correct
+ // background-color information so as to compute the right backplate color.
+ //
+ // This holds because HTML widgets with author-specified backgrounds or
+ // borders disable theming. So as long as the UA-specified background colors
+ // match the actual theme (which they should because we always use system
+ // colors with the non-native theme, and native system colors should also
+ // match the native theme), then we're alright and we should compute an
+ // appropriate backplate color.
+ const auto* style = frame->Style();
+ if (style->StyleBackground()->IsTransparent(style)) {
+ continue;
+ }
+ bool drawImage = false, drawColor = false;
+ nscolor backgroundColor = nsCSSRendering::DetermineBackgroundColor(
+ pc, style, frame, drawImage, drawColor);
+ if (!drawColor && !drawImage) {
+ continue;
+ }
+ if (NS_GET_A(backgroundColor) == 0) {
+ // Even if there's a background image, if there's no background color we
+ // keep going up the frame tree, see bug 1723938.
+ continue;
+ }
+ if (NS_GET_A(currentBackgroundColor) == 0) {
+ // Try to avoid somewhat expensive math in the common case.
+ currentBackgroundColor = backgroundColor;
+ } else {
+ currentBackgroundColor =
+ NS_ComposeColors(backgroundColor, currentBackgroundColor);
+ }
+ if (NS_GET_A(currentBackgroundColor) == 0xff) {
+ // If fully opaque, we're done, otherwise keep going up blending with our
+ // background.
+ return currentBackgroundColor;
+ }
+ }
+ nscolor backgroundColor = aFrame->PresContext()->DefaultBackgroundColor();
+ if (NS_GET_A(currentBackgroundColor) == 0) {
+ return backgroundColor;
+ }
+ return NS_ComposeColors(backgroundColor, currentBackgroundColor);
+}
+
+#ifdef DEBUG
+# include "nsBlockDebugFlags.h"
+
+bool nsBlockFrame::gLamePaintMetrics;
+bool nsBlockFrame::gLameReflowMetrics;
+bool nsBlockFrame::gNoisy;
+bool nsBlockFrame::gNoisyDamageRepair;
+bool nsBlockFrame::gNoisyIntrinsic;
+bool nsBlockFrame::gNoisyReflow;
+bool nsBlockFrame::gReallyNoisyReflow;
+bool nsBlockFrame::gNoisyFloatManager;
+bool nsBlockFrame::gVerifyLines;
+bool nsBlockFrame::gDisableResizeOpt;
+
+int32_t nsBlockFrame::gNoiseIndent;
+
+struct BlockDebugFlags {
+ const char* name;
+ bool* on;
+};
+
+static const BlockDebugFlags gFlags[] = {
+ {"reflow", &nsBlockFrame::gNoisyReflow},
+ {"really-noisy-reflow", &nsBlockFrame::gReallyNoisyReflow},
+ {"intrinsic", &nsBlockFrame::gNoisyIntrinsic},
+ {"float-manager", &nsBlockFrame::gNoisyFloatManager},
+ {"verify-lines", &nsBlockFrame::gVerifyLines},
+ {"damage-repair", &nsBlockFrame::gNoisyDamageRepair},
+ {"lame-paint-metrics", &nsBlockFrame::gLamePaintMetrics},
+ {"lame-reflow-metrics", &nsBlockFrame::gLameReflowMetrics},
+ {"disable-resize-opt", &nsBlockFrame::gDisableResizeOpt},
+};
+# define NUM_DEBUG_FLAGS (sizeof(gFlags) / sizeof(gFlags[0]))
+
+static void ShowDebugFlags() {
+ printf("Here are the available GECKO_BLOCK_DEBUG_FLAGS:\n");
+ const BlockDebugFlags* bdf = gFlags;
+ const BlockDebugFlags* end = gFlags + NUM_DEBUG_FLAGS;
+ for (; bdf < end; bdf++) {
+ printf(" %s\n", bdf->name);
+ }
+ printf("Note: GECKO_BLOCK_DEBUG_FLAGS is a comma separated list of flag\n");
+ printf("names (no whitespace)\n");
+}
+
+void nsBlockFrame::InitDebugFlags() {
+ static bool firstTime = true;
+ if (firstTime) {
+ firstTime = false;
+ char* flags = PR_GetEnv("GECKO_BLOCK_DEBUG_FLAGS");
+ if (flags) {
+ bool error = false;
+ for (;;) {
+ char* cm = strchr(flags, ',');
+ if (cm) {
+ *cm = '\0';
+ }
+
+ bool found = false;
+ const BlockDebugFlags* bdf = gFlags;
+ const BlockDebugFlags* end = gFlags + NUM_DEBUG_FLAGS;
+ for (; bdf < end; bdf++) {
+ if (nsCRT::strcasecmp(bdf->name, flags) == 0) {
+ *(bdf->on) = true;
+ printf("nsBlockFrame: setting %s debug flag on\n", bdf->name);
+ gNoisy = true;
+ found = true;
+ break;
+ }
+ }
+ if (!found) {
+ error = true;
+ }
+
+ if (!cm) {
+ break;
+ }
+ *cm = ',';
+ flags = cm + 1;
+ }
+ if (error) {
+ ShowDebugFlags();
+ }
+ }
+ }
+}
+
+#endif
+
+//----------------------------------------------------------------------
+
+// Debugging support code
+
+#ifdef DEBUG
+const char* nsBlockFrame::kReflowCommandType[] = {
+ "ContentChanged", "StyleChanged", "ReflowDirty", "Timeout", "UserDefined",
+};
+
+const char* nsBlockFrame::LineReflowStatusToString(
+ LineReflowStatus aLineReflowStatus) const {
+ switch (aLineReflowStatus) {
+ case LineReflowStatus::OK:
+ return "LINE_REFLOW_OK";
+ case LineReflowStatus::Stop:
+ return "LINE_REFLOW_STOP";
+ case LineReflowStatus::RedoNoPull:
+ return "LINE_REFLOW_REDO_NO_PULL";
+ case LineReflowStatus::RedoMoreFloats:
+ return "LINE_REFLOW_REDO_MORE_FLOATS";
+ case LineReflowStatus::RedoNextBand:
+ return "LINE_REFLOW_REDO_NEXT_BAND";
+ case LineReflowStatus::Truncated:
+ return "LINE_REFLOW_TRUNCATED";
+ }
+ return "unknown";
+}
+
+#endif
+
+#ifdef REFLOW_STATUS_COVERAGE
+static void RecordReflowStatus(bool aChildIsBlock,
+ const nsReflowStatus& aFrameReflowStatus) {
+ static uint32_t record[2];
+
+ // 0: child-is-block
+ // 1: child-is-inline
+ int index = 0;
+ if (!aChildIsBlock) {
+ index |= 1;
+ }
+
+ // Compute new status
+ uint32_t newS = record[index];
+ if (aFrameReflowStatus.IsInlineBreak()) {
+ if (aFrameReflowStatus.IsInlineBreakBefore()) {
+ newS |= 1;
+ } else if (aFrameReflowStatus.IsIncomplete()) {
+ newS |= 2;
+ } else {
+ newS |= 4;
+ }
+ } else if (aFrameReflowStatus.IsIncomplete()) {
+ newS |= 8;
+ } else {
+ newS |= 16;
+ }
+
+ // Log updates to the status that yield different values
+ if (record[index] != newS) {
+ record[index] = newS;
+ printf("record(%d): %02x %02x\n", index, record[0], record[1]);
+ }
+}
+#endif
+
+NS_DECLARE_FRAME_PROPERTY_WITH_DTOR_NEVER_CALLED(OverflowLinesProperty,
+ nsBlockFrame::FrameLines)
+NS_DECLARE_FRAME_PROPERTY_FRAMELIST(OverflowOutOfFlowsProperty)
+NS_DECLARE_FRAME_PROPERTY_FRAMELIST(PushedFloatProperty)
+NS_DECLARE_FRAME_PROPERTY_FRAMELIST(OutsideMarkerProperty)
+NS_DECLARE_FRAME_PROPERTY_WITHOUT_DTOR(InsideMarkerProperty, nsIFrame)
+NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(BlockEndEdgeOfChildrenProperty, nscoord)
+
+//----------------------------------------------------------------------
+
+nsBlockFrame* NS_NewBlockFrame(PresShell* aPresShell, ComputedStyle* aStyle) {
+ return new (aPresShell) nsBlockFrame(aStyle, aPresShell->GetPresContext());
+}
+
+nsBlockFrame* NS_NewBlockFormattingContext(PresShell* aPresShell,
+ ComputedStyle* aComputedStyle) {
+ nsBlockFrame* blockFrame = NS_NewBlockFrame(aPresShell, aComputedStyle);
+ blockFrame->AddStateBits(NS_BLOCK_STATIC_BFC);
+ return blockFrame;
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsBlockFrame)
+
+nsBlockFrame::~nsBlockFrame() = default;
+
+void nsBlockFrame::AddSizeOfExcludingThisForTree(
+ nsWindowSizes& aWindowSizes) const {
+ nsContainerFrame::AddSizeOfExcludingThisForTree(aWindowSizes);
+
+ // Add the size of any nsLineBox::mFrames hashtables we might have:
+ for (const auto& line : Lines()) {
+ line.AddSizeOfExcludingThis(aWindowSizes);
+ }
+ const FrameLines* overflowLines = GetOverflowLines();
+ if (overflowLines) {
+ ConstLineIterator line = overflowLines->mLines.begin(),
+ line_end = overflowLines->mLines.end();
+ for (; line != line_end; ++line) {
+ line->AddSizeOfExcludingThis(aWindowSizes);
+ }
+ }
+}
+
+void nsBlockFrame::Destroy(DestroyContext& aContext) {
+ ClearLineCursors();
+ DestroyAbsoluteFrames(aContext);
+ mFloats.DestroyFrames(aContext);
+ nsPresContext* presContext = PresContext();
+ mozilla::PresShell* presShell = presContext->PresShell();
+ nsLineBox::DeleteLineList(presContext, mLines, &mFrames, aContext);
+
+ if (HasPushedFloats()) {
+ SafelyDestroyFrameListProp(aContext, presShell, PushedFloatProperty());
+ RemoveStateBits(NS_BLOCK_HAS_PUSHED_FLOATS);
+ }
+
+ // destroy overflow lines now
+ FrameLines* overflowLines = RemoveOverflowLines();
+ if (overflowLines) {
+ nsLineBox::DeleteLineList(presContext, overflowLines->mLines,
+ &overflowLines->mFrames, aContext);
+ delete overflowLines;
+ }
+
+ if (HasAnyStateBits(NS_BLOCK_HAS_OVERFLOW_OUT_OF_FLOWS)) {
+ SafelyDestroyFrameListProp(aContext, presShell,
+ OverflowOutOfFlowsProperty());
+ RemoveStateBits(NS_BLOCK_HAS_OVERFLOW_OUT_OF_FLOWS);
+ }
+
+ if (HasOutsideMarker()) {
+ SafelyDestroyFrameListProp(aContext, presShell, OutsideMarkerProperty());
+ RemoveStateBits(NS_BLOCK_FRAME_HAS_OUTSIDE_MARKER);
+ }
+
+ nsContainerFrame::Destroy(aContext);
+}
+
+/* virtual */
+nsILineIterator* nsBlockFrame::GetLineIterator() {
+ nsLineIterator* iter = GetProperty(LineIteratorProperty());
+ if (!iter) {
+ const nsStyleVisibility* visibility = StyleVisibility();
+ iter = new nsLineIterator(mLines,
+ visibility->mDirection == StyleDirection::Rtl);
+ SetProperty(LineIteratorProperty(), iter);
+ }
+ return iter;
+}
+
+NS_QUERYFRAME_HEAD(nsBlockFrame)
+ NS_QUERYFRAME_ENTRY(nsBlockFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
+
+#ifdef DEBUG_FRAME_DUMP
+void nsBlockFrame::List(FILE* out, const char* aPrefix,
+ ListFlags aFlags) const {
+ nsCString str;
+ ListGeneric(str, aPrefix, aFlags);
+
+ fprintf_stderr(out, "%s <\n", str.get());
+
+ nsCString pfx(aPrefix);
+ pfx += " ";
+
+ // Output the lines
+ if (!mLines.empty()) {
+ ConstLineIterator line = LinesBegin(), line_end = LinesEnd();
+ for (; line != line_end; ++line) {
+ line->List(out, pfx.get(), aFlags);
+ }
+ }
+
+ // Output the overflow lines.
+ const FrameLines* overflowLines = GetOverflowLines();
+ if (overflowLines && !overflowLines->mLines.empty()) {
+ fprintf_stderr(out, "%sOverflow-lines %p/%p <\n", pfx.get(), overflowLines,
+ &overflowLines->mFrames);
+ nsCString nestedPfx(pfx);
+ nestedPfx += " ";
+ ConstLineIterator line = overflowLines->mLines.begin(),
+ line_end = overflowLines->mLines.end();
+ for (; line != line_end; ++line) {
+ line->List(out, nestedPfx.get(), aFlags);
+ }
+ fprintf_stderr(out, "%s>\n", pfx.get());
+ }
+
+ // skip the principal list - we printed the lines above
+ // skip the overflow list - we printed the overflow lines above
+ ChildListIDs skip = {FrameChildListID::Principal, FrameChildListID::Overflow};
+ ListChildLists(out, pfx.get(), aFlags, skip);
+
+ fprintf_stderr(out, "%s>\n", aPrefix);
+}
+
+nsresult nsBlockFrame::GetFrameName(nsAString& aResult) const {
+ return MakeFrameName(u"Block"_ns, aResult);
+}
+#endif
+
+void nsBlockFrame::InvalidateFrame(uint32_t aDisplayItemKey,
+ bool aRebuildDisplayItems) {
+ if (IsInSVGTextSubtree()) {
+ NS_ASSERTION(GetParent()->IsSVGTextFrame(),
+ "unexpected block frame in SVG text");
+ GetParent()->InvalidateFrame();
+ return;
+ }
+ nsContainerFrame::InvalidateFrame(aDisplayItemKey, aRebuildDisplayItems);
+}
+
+void nsBlockFrame::InvalidateFrameWithRect(const nsRect& aRect,
+ uint32_t aDisplayItemKey,
+ bool aRebuildDisplayItems) {
+ if (IsInSVGTextSubtree()) {
+ NS_ASSERTION(GetParent()->IsSVGTextFrame(),
+ "unexpected block frame in SVG text");
+ GetParent()->InvalidateFrame();
+ return;
+ }
+ nsContainerFrame::InvalidateFrameWithRect(aRect, aDisplayItemKey,
+ aRebuildDisplayItems);
+}
+
+nscoord nsBlockFrame::SynthesizeFallbackBaseline(
+ WritingMode aWM, BaselineSharingGroup aBaselineGroup) const {
+ return Baseline::SynthesizeBOffsetFromMarginBox(this, aWM, aBaselineGroup);
+}
+
+template <typename LineIteratorType>
+Maybe<nscoord> nsBlockFrame::GetBaselineBOffset(
+ LineIteratorType aStart, LineIteratorType aEnd, WritingMode aWM,
+ BaselineSharingGroup aBaselineGroup,
+ BaselineExportContext aExportContext) const {
+ MOZ_ASSERT((std::is_same_v<LineIteratorType, ConstLineIterator> &&
+ aBaselineGroup == BaselineSharingGroup::First) ||
+ (std::is_same_v<LineIteratorType, ConstReverseLineIterator> &&
+ aBaselineGroup == BaselineSharingGroup::Last),
+ "Iterator direction must match baseline sharing group.");
+ for (auto line = aStart; line != aEnd; ++line) {
+ if (!line->IsBlock()) {
+ // XXX Is this the right test? We have some bogus empty lines
+ // floating around, but IsEmpty is perhaps too weak.
+ if (line->BSize() != 0 || !line->IsEmpty()) {
+ const auto ascent = line->BStart() + line->GetLogicalAscent();
+ if (aBaselineGroup == BaselineSharingGroup::Last) {
+ return Some(BSize(aWM) - ascent);
+ }
+ return Some(ascent);
+ }
+ continue;
+ }
+ nsIFrame* kid = line->mFirstChild;
+ if (aWM.IsOrthogonalTo(kid->GetWritingMode())) {
+ continue;
+ }
+ if (aExportContext == BaselineExportContext::LineLayout &&
+ kid->IsTableWrapperFrame()) {
+ // `<table>` in inline-block context does not export any baseline.
+ continue;
+ }
+ const auto kidBaselineGroup =
+ aExportContext == BaselineExportContext::LineLayout
+ ? kid->GetDefaultBaselineSharingGroup()
+ : aBaselineGroup;
+ const auto kidBaseline =
+ kid->GetNaturalBaselineBOffset(aWM, kidBaselineGroup, aExportContext);
+ if (!kidBaseline) {
+ continue;
+ }
+ auto result = *kidBaseline;
+ if (kidBaselineGroup == BaselineSharingGroup::Last) {
+ result = kid->BSize(aWM) - result;
+ }
+ // Ignore relative positioning for baseline calculations.
+ const nsSize& sz = line->mContainerSize;
+ result += kid->GetLogicalNormalPosition(aWM, sz).B(aWM);
+ if (aBaselineGroup == BaselineSharingGroup::Last) {
+ return Some(BSize(aWM) - result);
+ }
+ return Some(result);
+ }
+ return Nothing{};
+}
+
+Maybe<nscoord> nsBlockFrame::GetNaturalBaselineBOffset(
+ WritingMode aWM, BaselineSharingGroup aBaselineGroup,
+ BaselineExportContext aExportContext) const {
+ if (StyleDisplay()->IsContainLayout()) {
+ return Nothing{};
+ }
+
+ if (aBaselineGroup == BaselineSharingGroup::First) {
+ return GetBaselineBOffset(LinesBegin(), LinesEnd(), aWM, aBaselineGroup,
+ aExportContext);
+ }
+
+ return GetBaselineBOffset(LinesRBegin(), LinesREnd(), aWM, aBaselineGroup,
+ aExportContext);
+}
+
+nscoord nsBlockFrame::GetCaretBaseline() const {
+ nsRect contentRect = GetContentRect();
+ nsMargin bp = GetUsedBorderAndPadding();
+
+ if (!mLines.empty()) {
+ ConstLineIterator line = LinesBegin();
+ if (!line->IsEmpty()) {
+ if (line->IsBlock()) {
+ return bp.top + line->mFirstChild->GetCaretBaseline();
+ }
+ return line->BStart() + line->GetLogicalAscent();
+ }
+ }
+
+ float inflation = nsLayoutUtils::FontSizeInflationFor(this);
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetFontMetricsForFrame(this, inflation);
+ nscoord lineHeight = ReflowInput::CalcLineHeight(
+ *Style(), PresContext(), GetContent(), contentRect.height, inflation);
+ const WritingMode wm = GetWritingMode();
+ return nsLayoutUtils::GetCenteredFontBaseline(fm, lineHeight,
+ wm.IsLineInverted()) +
+ bp.top;
+}
+
+/////////////////////////////////////////////////////////////////////////////
+// Child frame enumeration
+
+const nsFrameList& nsBlockFrame::GetChildList(ChildListID aListID) const {
+ switch (aListID) {
+ case FrameChildListID::Principal:
+ return mFrames;
+ case FrameChildListID::Overflow: {
+ FrameLines* overflowLines = GetOverflowLines();
+ return overflowLines ? overflowLines->mFrames : nsFrameList::EmptyList();
+ }
+ case FrameChildListID::Float:
+ return mFloats;
+ case FrameChildListID::OverflowOutOfFlow: {
+ const nsFrameList* list = GetOverflowOutOfFlows();
+ return list ? *list : nsFrameList::EmptyList();
+ }
+ case FrameChildListID::PushedFloats: {
+ const nsFrameList* list = GetPushedFloats();
+ return list ? *list : nsFrameList::EmptyList();
+ }
+ case FrameChildListID::Bullet: {
+ const nsFrameList* list = GetOutsideMarkerList();
+ return list ? *list : nsFrameList::EmptyList();
+ }
+ default:
+ return nsContainerFrame::GetChildList(aListID);
+ }
+}
+
+void nsBlockFrame::GetChildLists(nsTArray<ChildList>* aLists) const {
+ nsContainerFrame::GetChildLists(aLists);
+ FrameLines* overflowLines = GetOverflowLines();
+ if (overflowLines) {
+ overflowLines->mFrames.AppendIfNonempty(aLists, FrameChildListID::Overflow);
+ }
+ const nsFrameList* list = GetOverflowOutOfFlows();
+ if (list) {
+ list->AppendIfNonempty(aLists, FrameChildListID::OverflowOutOfFlow);
+ }
+ mFloats.AppendIfNonempty(aLists, FrameChildListID::Float);
+ list = GetOutsideMarkerList();
+ if (list) {
+ list->AppendIfNonempty(aLists, FrameChildListID::Bullet);
+ }
+ list = GetPushedFloats();
+ if (list) {
+ list->AppendIfNonempty(aLists, FrameChildListID::PushedFloats);
+ }
+}
+
+/* virtual */
+bool nsBlockFrame::IsFloatContainingBlock() const { return true; }
+
+/**
+ * Remove the first line from aFromLines and adjust the associated frame list
+ * aFromFrames accordingly. The removed line is assigned to *aOutLine and
+ * a frame list with its frames is assigned to *aOutFrames, i.e. the frames
+ * that were extracted from the head of aFromFrames.
+ * aFromLines must contain at least one line, the line may be empty.
+ * @return true if aFromLines becomes empty
+ */
+static bool RemoveFirstLine(nsLineList& aFromLines, nsFrameList& aFromFrames,
+ nsLineBox** aOutLine, nsFrameList* aOutFrames) {
+ nsLineList_iterator removedLine = aFromLines.begin();
+ *aOutLine = removedLine;
+ nsLineList_iterator next = aFromLines.erase(removedLine);
+ bool isLastLine = next == aFromLines.end();
+ nsIFrame* firstFrameInNextLine = isLastLine ? nullptr : next->mFirstChild;
+ *aOutFrames = aFromFrames.TakeFramesBefore(firstFrameInNextLine);
+ return isLastLine;
+}
+
+//////////////////////////////////////////////////////////////////////
+// Reflow methods
+
+/* virtual */
+void nsBlockFrame::MarkIntrinsicISizesDirty() {
+ nsBlockFrame* dirtyBlock = static_cast<nsBlockFrame*>(FirstContinuation());
+ dirtyBlock->mCachedMinISize = NS_INTRINSIC_ISIZE_UNKNOWN;
+ dirtyBlock->mCachedPrefISize = NS_INTRINSIC_ISIZE_UNKNOWN;
+ if (!HasAnyStateBits(NS_BLOCK_NEEDS_BIDI_RESOLUTION)) {
+ for (nsIFrame* frame = dirtyBlock; frame;
+ frame = frame->GetNextContinuation()) {
+ frame->AddStateBits(NS_BLOCK_NEEDS_BIDI_RESOLUTION);
+ }
+ }
+
+ nsContainerFrame::MarkIntrinsicISizesDirty();
+}
+
+void nsBlockFrame::CheckIntrinsicCacheAgainstShrinkWrapState() {
+ nsPresContext* presContext = PresContext();
+ if (!nsLayoutUtils::FontSizeInflationEnabled(presContext)) {
+ return;
+ }
+ bool inflationEnabled = !presContext->mInflationDisabledForShrinkWrap;
+ if (inflationEnabled != HasAnyStateBits(NS_BLOCK_FRAME_INTRINSICS_INFLATED)) {
+ mCachedMinISize = NS_INTRINSIC_ISIZE_UNKNOWN;
+ mCachedPrefISize = NS_INTRINSIC_ISIZE_UNKNOWN;
+ if (inflationEnabled) {
+ AddStateBits(NS_BLOCK_FRAME_INTRINSICS_INFLATED);
+ } else {
+ RemoveStateBits(NS_BLOCK_FRAME_INTRINSICS_INFLATED);
+ }
+ }
+}
+
+// Whether this line is indented by the text-indent amount.
+bool nsBlockFrame::TextIndentAppliesTo(const LineIterator& aLine) const {
+ const auto& textIndent = StyleText()->mTextIndent;
+
+ bool isFirstLineOrAfterHardBreak = [&] {
+ if (aLine != LinesBegin()) {
+ // If not the first line of the block, but 'each-line' is in effect,
+ // check if the previous line was not wrapped.
+ return textIndent.each_line && !aLine.prev()->IsLineWrapped();
+ }
+ if (nsBlockFrame* prevBlock = do_QueryFrame(GetPrevInFlow())) {
+ // There's a prev-in-flow, so this only counts as a first-line if
+ // 'each-line' and the prev-in-flow's last line was not wrapped.
+ return textIndent.each_line &&
+ (prevBlock->Lines().empty() ||
+ !prevBlock->LinesEnd().prev()->IsLineWrapped());
+ }
+ return true;
+ }();
+
+ // The 'hanging' option inverts which lines are/aren't indented.
+ return isFirstLineOrAfterHardBreak != textIndent.hanging;
+}
+
+/* virtual */
+nscoord nsBlockFrame::GetMinISize(gfxContext* aRenderingContext) {
+ nsIFrame* firstInFlow = FirstContinuation();
+ if (firstInFlow != this) {
+ return firstInFlow->GetMinISize(aRenderingContext);
+ }
+
+ DISPLAY_MIN_INLINE_SIZE(this, mCachedMinISize);
+
+ CheckIntrinsicCacheAgainstShrinkWrapState();
+
+ if (mCachedMinISize != NS_INTRINSIC_ISIZE_UNKNOWN) {
+ return mCachedMinISize;
+ }
+
+ if (Maybe<nscoord> containISize = ContainIntrinsicISize()) {
+ mCachedMinISize = *containISize;
+ return mCachedMinISize;
+ }
+
+#ifdef DEBUG
+ if (gNoisyIntrinsic) {
+ IndentBy(stdout, gNoiseIndent);
+ ListTag(stdout);
+ printf(": GetMinISize\n");
+ }
+ AutoNoisyIndenter indenter(gNoisyIntrinsic);
+#endif
+
+ for (nsBlockFrame* curFrame = this; curFrame;
+ curFrame = static_cast<nsBlockFrame*>(curFrame->GetNextContinuation())) {
+ curFrame->LazyMarkLinesDirty();
+ }
+
+ if (HasAnyStateBits(NS_BLOCK_NEEDS_BIDI_RESOLUTION) &&
+ PresContext()->BidiEnabled()) {
+ ResolveBidi();
+ }
+
+ const bool whiteSpaceCanWrap = StyleText()->WhiteSpaceCanWrapStyle();
+ InlineMinISizeData data;
+ for (nsBlockFrame* curFrame = this; curFrame;
+ curFrame = static_cast<nsBlockFrame*>(curFrame->GetNextContinuation())) {
+ for (LineIterator line = curFrame->LinesBegin(),
+ line_end = curFrame->LinesEnd();
+ line != line_end; ++line) {
+#ifdef DEBUG
+ if (gNoisyIntrinsic) {
+ IndentBy(stdout, gNoiseIndent);
+ printf("line (%s%s)\n", line->IsBlock() ? "block" : "inline",
+ line->IsEmpty() ? ", empty" : "");
+ }
+ AutoNoisyIndenter lineindent(gNoisyIntrinsic);
+#endif
+ if (line->IsBlock()) {
+ data.ForceBreak();
+ data.mCurrentLine = nsLayoutUtils::IntrinsicForContainer(
+ aRenderingContext, line->mFirstChild, IntrinsicISizeType::MinISize);
+ data.ForceBreak();
+ } else {
+ if (!curFrame->GetPrevContinuation() && TextIndentAppliesTo(line)) {
+ data.mCurrentLine += StyleText()->mTextIndent.length.Resolve(0);
+ }
+ data.mLine = &line;
+ data.SetLineContainer(curFrame);
+ nsIFrame* kid = line->mFirstChild;
+ for (int32_t i = 0, i_end = line->GetChildCount(); i != i_end;
+ ++i, kid = kid->GetNextSibling()) {
+ kid->AddInlineMinISize(aRenderingContext, &data);
+ if (whiteSpaceCanWrap && data.mTrailingWhitespace) {
+ data.OptionallyBreak();
+ }
+ }
+ }
+#ifdef DEBUG
+ if (gNoisyIntrinsic) {
+ IndentBy(stdout, gNoiseIndent);
+ printf("min: [prevLines=%d currentLine=%d]\n", data.mPrevLines,
+ data.mCurrentLine);
+ }
+#endif
+ }
+ }
+ data.ForceBreak();
+
+ mCachedMinISize = data.mPrevLines;
+ return mCachedMinISize;
+}
+
+/* virtual */
+nscoord nsBlockFrame::GetPrefISize(gfxContext* aRenderingContext) {
+ nsIFrame* firstInFlow = FirstContinuation();
+ if (firstInFlow != this) {
+ return firstInFlow->GetPrefISize(aRenderingContext);
+ }
+
+ DISPLAY_PREF_INLINE_SIZE(this, mCachedPrefISize);
+
+ CheckIntrinsicCacheAgainstShrinkWrapState();
+
+ if (mCachedPrefISize != NS_INTRINSIC_ISIZE_UNKNOWN) {
+ return mCachedPrefISize;
+ }
+
+ if (Maybe<nscoord> containISize = ContainIntrinsicISize()) {
+ mCachedPrefISize = *containISize;
+ return mCachedPrefISize;
+ }
+
+#ifdef DEBUG
+ if (gNoisyIntrinsic) {
+ IndentBy(stdout, gNoiseIndent);
+ ListTag(stdout);
+ printf(": GetPrefISize\n");
+ }
+ AutoNoisyIndenter indenter(gNoisyIntrinsic);
+#endif
+
+ for (nsBlockFrame* curFrame = this; curFrame;
+ curFrame = static_cast<nsBlockFrame*>(curFrame->GetNextContinuation())) {
+ curFrame->LazyMarkLinesDirty();
+ }
+
+ if (HasAnyStateBits(NS_BLOCK_NEEDS_BIDI_RESOLUTION) &&
+ PresContext()->BidiEnabled()) {
+ ResolveBidi();
+ }
+ InlinePrefISizeData data;
+ for (nsBlockFrame* curFrame = this; curFrame;
+ curFrame = static_cast<nsBlockFrame*>(curFrame->GetNextContinuation())) {
+ for (LineIterator line = curFrame->LinesBegin(),
+ line_end = curFrame->LinesEnd();
+ line != line_end; ++line) {
+#ifdef DEBUG
+ if (gNoisyIntrinsic) {
+ IndentBy(stdout, gNoiseIndent);
+ printf("line (%s%s)\n", line->IsBlock() ? "block" : "inline",
+ line->IsEmpty() ? ", empty" : "");
+ }
+ AutoNoisyIndenter lineindent(gNoisyIntrinsic);
+#endif
+ if (line->IsBlock()) {
+ StyleClear clearType;
+ if (!data.mLineIsEmpty || BlockCanIntersectFloats(line->mFirstChild)) {
+ clearType = StyleClear::Both;
+ } else {
+ clearType = line->mFirstChild->StyleDisplay()->mClear;
+ }
+ data.ForceBreak(clearType);
+ data.mCurrentLine = nsLayoutUtils::IntrinsicForContainer(
+ aRenderingContext, line->mFirstChild,
+ IntrinsicISizeType::PrefISize);
+ data.ForceBreak();
+ } else {
+ if (!curFrame->GetPrevContinuation() && TextIndentAppliesTo(line)) {
+ nscoord indent = StyleText()->mTextIndent.length.Resolve(0);
+ data.mCurrentLine += indent;
+ // XXXmats should the test below be indent > 0?
+ if (indent != nscoord(0)) {
+ data.mLineIsEmpty = false;
+ }
+ }
+ data.mLine = &line;
+ data.SetLineContainer(curFrame);
+ nsIFrame* kid = line->mFirstChild;
+ for (int32_t i = 0, i_end = line->GetChildCount(); i != i_end;
+ ++i, kid = kid->GetNextSibling()) {
+ kid->AddInlinePrefISize(aRenderingContext, &data);
+ }
+ }
+#ifdef DEBUG
+ if (gNoisyIntrinsic) {
+ IndentBy(stdout, gNoiseIndent);
+ printf("pref: [prevLines=%d currentLine=%d]\n", data.mPrevLines,
+ data.mCurrentLine);
+ }
+#endif
+ }
+ }
+ data.ForceBreak();
+
+ mCachedPrefISize = data.mPrevLines;
+ return mCachedPrefISize;
+}
+
+nsRect nsBlockFrame::ComputeTightBounds(DrawTarget* aDrawTarget) const {
+ // be conservative
+ if (Style()->HasTextDecorationLines()) {
+ return InkOverflowRect();
+ }
+ return ComputeSimpleTightBounds(aDrawTarget);
+}
+
+/* virtual */
+nsresult nsBlockFrame::GetPrefWidthTightBounds(gfxContext* aRenderingContext,
+ nscoord* aX, nscoord* aXMost) {
+ nsIFrame* firstInFlow = FirstContinuation();
+ if (firstInFlow != this) {
+ return firstInFlow->GetPrefWidthTightBounds(aRenderingContext, aX, aXMost);
+ }
+
+ *aX = 0;
+ *aXMost = 0;
+
+ nsresult rv;
+ InlinePrefISizeData data;
+ for (nsBlockFrame* curFrame = this; curFrame;
+ curFrame = static_cast<nsBlockFrame*>(curFrame->GetNextContinuation())) {
+ for (LineIterator line = curFrame->LinesBegin(),
+ line_end = curFrame->LinesEnd();
+ line != line_end; ++line) {
+ nscoord childX, childXMost;
+ if (line->IsBlock()) {
+ data.ForceBreak();
+ rv = line->mFirstChild->GetPrefWidthTightBounds(aRenderingContext,
+ &childX, &childXMost);
+ NS_ENSURE_SUCCESS(rv, rv);
+ *aX = std::min(*aX, childX);
+ *aXMost = std::max(*aXMost, childXMost);
+ } else {
+ if (!curFrame->GetPrevContinuation() && TextIndentAppliesTo(line)) {
+ data.mCurrentLine += StyleText()->mTextIndent.length.Resolve(0);
+ }
+ data.mLine = &line;
+ data.SetLineContainer(curFrame);
+ nsIFrame* kid = line->mFirstChild;
+ for (int32_t i = 0, i_end = line->GetChildCount(); i != i_end;
+ ++i, kid = kid->GetNextSibling()) {
+ rv = kid->GetPrefWidthTightBounds(aRenderingContext, &childX,
+ &childXMost);
+ NS_ENSURE_SUCCESS(rv, rv);
+ *aX = std::min(*aX, data.mCurrentLine + childX);
+ *aXMost = std::max(*aXMost, data.mCurrentLine + childXMost);
+ kid->AddInlinePrefISize(aRenderingContext, &data);
+ }
+ }
+ }
+ }
+ data.ForceBreak();
+
+ return NS_OK;
+}
+
+/**
+ * Return whether aNewAvailableSpace is smaller *on either side*
+ * (inline-start or inline-end) than aOldAvailableSpace, so that we know
+ * if we need to redo layout on an line, replaced block, or block
+ * formatting context, because its height (which we used to compute
+ * aNewAvailableSpace) caused it to intersect additional floats.
+ */
+static bool AvailableSpaceShrunk(WritingMode aWM,
+ const LogicalRect& aOldAvailableSpace,
+ const LogicalRect& aNewAvailableSpace,
+ bool aCanGrow /* debug-only */) {
+ if (aNewAvailableSpace.ISize(aWM) == 0) {
+ // Positions are not significant if the inline size is zero.
+ return aOldAvailableSpace.ISize(aWM) != 0;
+ }
+ if (aCanGrow) {
+ NS_ASSERTION(
+ aNewAvailableSpace.IStart(aWM) <= aOldAvailableSpace.IStart(aWM) ||
+ aNewAvailableSpace.IEnd(aWM) <= aOldAvailableSpace.IEnd(aWM),
+ "available space should not shrink on the start side and "
+ "grow on the end side");
+ NS_ASSERTION(
+ aNewAvailableSpace.IStart(aWM) >= aOldAvailableSpace.IStart(aWM) ||
+ aNewAvailableSpace.IEnd(aWM) >= aOldAvailableSpace.IEnd(aWM),
+ "available space should not grow on the start side and "
+ "shrink on the end side");
+ } else {
+ NS_ASSERTION(
+ aOldAvailableSpace.IStart(aWM) <= aNewAvailableSpace.IStart(aWM) &&
+ aOldAvailableSpace.IEnd(aWM) >= aNewAvailableSpace.IEnd(aWM),
+ "available space should never grow");
+ }
+ // Have we shrunk on either side?
+ return aNewAvailableSpace.IStart(aWM) > aOldAvailableSpace.IStart(aWM) ||
+ aNewAvailableSpace.IEnd(aWM) < aOldAvailableSpace.IEnd(aWM);
+}
+
+static LogicalSize CalculateContainingBlockSizeForAbsolutes(
+ WritingMode aWM, const ReflowInput& aReflowInput, LogicalSize aFrameSize) {
+ // The issue here is that for a 'height' of 'auto' the reflow input
+ // code won't know how to calculate the containing block height
+ // because it's calculated bottom up. So we use our own computed
+ // size as the dimensions.
+ nsIFrame* frame = aReflowInput.mFrame;
+
+ LogicalSize cbSize(aFrameSize);
+ // Containing block is relative to the padding edge
+ const LogicalMargin border = aReflowInput.ComputedLogicalBorder(aWM);
+ cbSize.ISize(aWM) -= border.IStartEnd(aWM);
+ cbSize.BSize(aWM) -= border.BStartEnd(aWM);
+
+ if (frame->GetParent()->GetContent() != frame->GetContent() ||
+ frame->GetParent()->IsCanvasFrame()) {
+ return cbSize;
+ }
+
+ // We are a wrapped frame for the content (and the wrapper is not the
+ // canvas frame, whose size is not meaningful here).
+ // Use the container's dimensions, if they have been precomputed.
+ // XXX This is a hack! We really should be waiting until the outermost
+ // frame is fully reflowed and using the resulting dimensions, even
+ // if they're intrinsic.
+ // In fact we should be attaching absolute children to the outermost
+ // frame and not always sticking them in block frames.
+
+ // First, find the reflow input for the outermost frame for this content.
+ const ReflowInput* lastRI = &aReflowInput;
+ DebugOnly<const ReflowInput*> lastButOneRI = &aReflowInput;
+ while (lastRI->mParentReflowInput &&
+ lastRI->mParentReflowInput->mFrame->GetContent() ==
+ frame->GetContent()) {
+ lastButOneRI = lastRI;
+ lastRI = lastRI->mParentReflowInput;
+ }
+
+ if (lastRI == &aReflowInput) {
+ return cbSize;
+ }
+
+ // For scroll containers, we can just use cbSize (which is the padding-box
+ // size of the scrolled-content frame).
+ if (nsIScrollableFrame* scrollFrame = do_QueryFrame(lastRI->mFrame)) {
+ // Assert that we're not missing any frames between the abspos containing
+ // block and the scroll container.
+ // the parent.
+ Unused << scrollFrame;
+ MOZ_ASSERT(lastButOneRI == &aReflowInput);
+ return cbSize;
+ }
+
+ // Same for fieldsets, where the inner anonymous frame has the correct padding
+ // area with the legend taken into account.
+ if (lastRI->mFrame->IsFieldSetFrame()) {
+ return cbSize;
+ }
+
+ // We found a reflow input for the outermost wrapping frame, so use
+ // its computed metrics if available, converted to our writing mode
+ const LogicalSize lastRISize = lastRI->ComputedSize(aWM);
+ const LogicalMargin lastRIPadding = lastRI->ComputedLogicalPadding(aWM);
+ if (lastRISize.ISize(aWM) != NS_UNCONSTRAINEDSIZE) {
+ cbSize.ISize(aWM) =
+ std::max(0, lastRISize.ISize(aWM) + lastRIPadding.IStartEnd(aWM));
+ }
+ if (lastRISize.BSize(aWM) != NS_UNCONSTRAINEDSIZE) {
+ cbSize.BSize(aWM) =
+ std::max(0, lastRISize.BSize(aWM) + lastRIPadding.BStartEnd(aWM));
+ }
+
+ return cbSize;
+}
+
+/**
+ * Returns aFrame if it is a non-BFC block frame, and null otherwise.
+ *
+ * This is used to determine whether to recurse into aFrame when applying
+ * -webkit-line-clamp.
+ */
+static const nsBlockFrame* GetAsLineClampDescendant(const nsIFrame* aFrame) {
+ if (const nsBlockFrame* block = do_QueryFrame(aFrame)) {
+ if (!block->HasAnyStateBits(NS_BLOCK_BFC_STATE_BITS)) {
+ return block;
+ }
+ }
+ return nullptr;
+}
+
+static nsBlockFrame* GetAsLineClampDescendant(nsIFrame* aFrame) {
+ return const_cast<nsBlockFrame*>(
+ GetAsLineClampDescendant(const_cast<const nsIFrame*>(aFrame)));
+}
+
+static bool IsLineClampRoot(const nsBlockFrame* aFrame) {
+ if (!aFrame->StyleDisplay()->mWebkitLineClamp) {
+ return false;
+ }
+
+ if (!aFrame->HasAnyStateBits(NS_BLOCK_BFC_STATE_BITS)) {
+ return false;
+ }
+
+ if (StaticPrefs::layout_css_webkit_line_clamp_block_enabled()) {
+ return true;
+ }
+
+ // For now, -webkit-box is the only thing allowed to be a line-clamp root.
+ // Ideally we'd just make this work everywhere, but for now we're carrying
+ // this forward as a limitation on the legacy -webkit-line-clamp feature,
+ // since relaxing this limitation might create webcompat trouble.
+ auto origDisplay = [&] {
+ if (aFrame->Style()->GetPseudoType() == PseudoStyleType::scrolledContent) {
+ // If we're the anonymous block inside the scroll frame, we need to look
+ // at the original display of our parent frame.
+ MOZ_ASSERT(aFrame->GetParent());
+ const auto& parentDisp = *aFrame->GetParent()->StyleDisplay();
+ MOZ_ASSERT(parentDisp.mWebkitLineClamp ==
+ aFrame->StyleDisplay()->mWebkitLineClamp,
+ ":-moz-scrolled-content should inherit -webkit-line-clamp, "
+ "via rule in UA stylesheet");
+ return parentDisp.mOriginalDisplay;
+ }
+ return aFrame->StyleDisplay()->mOriginalDisplay;
+ }();
+ return origDisplay.Inside() == StyleDisplayInside::WebkitBox;
+}
+
+bool nsBlockFrame::IsInLineClampContext() const {
+ if (IsLineClampRoot(this)) {
+ return true;
+ }
+ const nsBlockFrame* cur = this;
+ while (GetAsLineClampDescendant(cur)) {
+ cur = do_QueryFrame(cur->GetParent());
+ if (!cur) {
+ return false;
+ }
+ if (IsLineClampRoot(cur)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+/**
+ * Iterator over all descendant inline line boxes, except for those that are
+ * under an independent formatting context.
+ */
+class MOZ_RAII LineClampLineIterator {
+ public:
+ explicit LineClampLineIterator(nsBlockFrame* aFrame)
+ : mCur(aFrame->LinesBegin()),
+ mEnd(aFrame->LinesEnd()),
+ mCurrentFrame(mCur == mEnd ? nullptr : aFrame) {
+ if (mCur != mEnd && !mCur->IsInline()) {
+ Advance();
+ }
+ }
+
+ nsLineBox* GetCurrentLine() { return mCurrentFrame ? mCur.get() : nullptr; }
+ nsBlockFrame* GetCurrentFrame() { return mCurrentFrame; }
+
+ // Advances the iterator to the next line line.
+ //
+ // Next() shouldn't be called once the iterator is at the end, which can be
+ // checked for by GetCurrentLine() or GetCurrentFrame() returning null.
+ void Next() {
+ MOZ_ASSERT(mCur != mEnd && mCurrentFrame,
+ "Don't call Next() when the iterator is at the end");
+ ++mCur;
+ Advance();
+ }
+
+ private:
+ void Advance() {
+ for (;;) {
+ if (mCur == mEnd) {
+ // Reached the end of the current block. Pop the parent off the
+ // stack; if there isn't one, then we've reached the end.
+ if (mStack.IsEmpty()) {
+ mCurrentFrame = nullptr;
+ break;
+ }
+ auto entry = mStack.PopLastElement();
+ mCurrentFrame = entry.first;
+ mCur = entry.second;
+ mEnd = mCurrentFrame->LinesEnd();
+ } else if (mCur->IsBlock()) {
+ if (nsBlockFrame* child = GetAsLineClampDescendant(mCur->mFirstChild)) {
+ nsBlockFrame::LineIterator next = mCur;
+ ++next;
+ mStack.AppendElement(std::make_pair(mCurrentFrame, next));
+ mCur = child->LinesBegin();
+ mEnd = child->LinesEnd();
+ mCurrentFrame = child;
+ } else {
+ // Some kind of frame we shouldn't descend into.
+ ++mCur;
+ }
+ } else {
+ MOZ_ASSERT(mCur->IsInline());
+ break;
+ }
+ }
+ }
+
+ // The current line within the current block.
+ //
+ // When this is equal to mEnd, the iterator is at its end, and mCurrentFrame
+ // is set to null.
+ nsBlockFrame::LineIterator mCur;
+
+ // The iterator end for the current block.
+ nsBlockFrame::LineIterator mEnd;
+
+ // The current block.
+ nsBlockFrame* mCurrentFrame;
+
+ // Stack of mCurrentFrame and mEnd values that we push and pop as we enter and
+ // exist blocks.
+ AutoTArray<std::pair<nsBlockFrame*, nsBlockFrame::LineIterator>, 8> mStack;
+};
+
+static bool ClearLineClampEllipsis(nsBlockFrame* aFrame) {
+ if (!aFrame->HasAnyStateBits(NS_BLOCK_HAS_LINE_CLAMP_ELLIPSIS)) {
+ for (nsIFrame* f : aFrame->PrincipalChildList()) {
+ if (nsBlockFrame* child = GetAsLineClampDescendant(f)) {
+ if (ClearLineClampEllipsis(child)) {
+ return true;
+ }
+ }
+ }
+ return false;
+ }
+
+ aFrame->RemoveStateBits(NS_BLOCK_HAS_LINE_CLAMP_ELLIPSIS);
+
+ for (auto& line : aFrame->Lines()) {
+ if (line.HasLineClampEllipsis()) {
+ line.ClearHasLineClampEllipsis();
+ return true;
+ }
+ }
+
+ // We didn't find a line with the ellipsis; it must have been deleted already.
+ return true;
+}
+
+void nsBlockFrame::ClearLineClampEllipsis() { ::ClearLineClampEllipsis(this); }
+
+void nsBlockFrame::Reflow(nsPresContext* aPresContext, ReflowOutput& aMetrics,
+ const ReflowInput& aReflowInput,
+ nsReflowStatus& aStatus) {
+ if (IsHiddenByContentVisibilityOfInFlowParentForLayout()) {
+ FinishAndStoreOverflow(&aMetrics, aReflowInput.mStyleDisplay);
+ return;
+ }
+
+ MarkInReflow();
+ DO_GLOBAL_REFLOW_COUNT("nsBlockFrame");
+ DISPLAY_REFLOW(aPresContext, this, aReflowInput, aMetrics, aStatus);
+ MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
+
+#ifdef DEBUG
+ if (gNoisyReflow) {
+ IndentBy(stdout, gNoiseIndent);
+ ListTag(stdout);
+ printf(": begin reflow availSize=%d,%d computedSize=%d,%d\n",
+ aReflowInput.AvailableISize(), aReflowInput.AvailableBSize(),
+ aReflowInput.ComputedISize(), aReflowInput.ComputedBSize());
+ }
+ AutoNoisyIndenter indent(gNoisy);
+ PRTime start = 0; // Initialize these variablies to silence the compiler.
+ int32_t ctc = 0; // We only use these if they are set (gLameReflowMetrics).
+ if (gLameReflowMetrics) {
+ start = PR_Now();
+ ctc = nsLineBox::GetCtorCount();
+ }
+#endif
+
+ // ColumnSetWrapper's children depend on ColumnSetWrapper's block-size or
+ // max-block-size because both affect the children's available block-size.
+ if (IsColumnSetWrapperFrame()) {
+ AddStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE);
+ }
+
+ Maybe<nscoord> restoreReflowInputAvailBSize;
+ auto MaybeRestore = MakeScopeExit([&] {
+ if (MOZ_UNLIKELY(restoreReflowInputAvailBSize)) {
+ const_cast<ReflowInput&>(aReflowInput)
+ .SetAvailableBSize(*restoreReflowInputAvailBSize);
+ }
+ });
+
+ WritingMode wm = aReflowInput.GetWritingMode();
+ const nscoord consumedBSize = CalcAndCacheConsumedBSize();
+ const nscoord effectiveContentBoxBSize =
+ GetEffectiveComputedBSize(aReflowInput, consumedBSize);
+ // If we have non-auto block size, we're clipping our kids and we fit,
+ // make sure our kids fit too.
+ const PhysicalAxes physicalBlockAxis =
+ wm.IsVertical() ? PhysicalAxes::Horizontal : PhysicalAxes::Vertical;
+ if (aReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE &&
+ aReflowInput.ComputedBSize() != NS_UNCONSTRAINEDSIZE &&
+ (ShouldApplyOverflowClipping(aReflowInput.mStyleDisplay) &
+ physicalBlockAxis)) {
+ LogicalMargin blockDirExtras =
+ aReflowInput.ComputedLogicalBorderPadding(wm);
+ if (GetLogicalSkipSides().BStart()) {
+ blockDirExtras.BStart(wm) = 0;
+ } else {
+ // Block-end margin never causes us to create continuations, so we
+ // don't need to worry about whether it fits in its entirety.
+ blockDirExtras.BStart(wm) +=
+ aReflowInput.ComputedLogicalMargin(wm).BStart(wm);
+ }
+
+ if (effectiveContentBoxBSize + blockDirExtras.BStartEnd(wm) <=
+ aReflowInput.AvailableBSize()) {
+ restoreReflowInputAvailBSize.emplace(aReflowInput.AvailableBSize());
+ const_cast<ReflowInput&>(aReflowInput)
+ .SetAvailableBSize(NS_UNCONSTRAINEDSIZE);
+ }
+ }
+
+ if (IsFrameTreeTooDeep(aReflowInput, aMetrics, aStatus)) {
+ return;
+ }
+
+ // OK, some lines may be reflowed. Blow away any saved line cursor
+ // because we may invalidate the nondecreasing
+ // overflowArea.InkOverflow().y/yMost invariant, and we may even
+ // delete the line with the line cursor.
+ ClearLineCursors();
+
+ // See comment below about oldSize. Use *only* for the
+ // abs-pos-containing-block-size-change optimization!
+ nsSize oldSize = GetSize();
+
+ // Should we create a float manager?
+ nsAutoFloatManager autoFloatManager(const_cast<ReflowInput&>(aReflowInput));
+
+ // XXXldb If we start storing the float manager in the frame rather
+ // than keeping it around only during reflow then we should create it
+ // only when there are actually floats to manage. Otherwise things
+ // like tables will gain significant bloat.
+ bool needFloatManager = nsBlockFrame::BlockNeedsFloatManager(this);
+ if (needFloatManager) {
+ autoFloatManager.CreateFloatManager(aPresContext);
+ }
+
+ if (HasAnyStateBits(NS_BLOCK_NEEDS_BIDI_RESOLUTION) &&
+ PresContext()->BidiEnabled()) {
+ static_cast<nsBlockFrame*>(FirstContinuation())->ResolveBidi();
+ }
+
+ // Whether to apply text-wrap: balance behavior.
+ bool tryBalance =
+ StyleText()->mTextWrapStyle == StyleTextWrapStyle::Balance &&
+ !GetPrevContinuation();
+
+ // Struct used to hold the "target" number of lines or clamp position to
+ // maintain when doing text-wrap: balance.
+ struct BalanceTarget {
+ // If line-clamp is in effect, mContent and mOffset indicate the starting
+ // position of the first line after the clamp limit. If line-clamp is not
+ // in use, mContent is null and mOffset is the total number of lines that
+ // the block must contain.
+ nsIContent* mContent = nullptr;
+ int32_t mOffset = -1;
+
+ bool operator==(const BalanceTarget& aOther) const {
+ return mContent == aOther.mContent && mOffset == aOther.mOffset;
+ }
+ bool operator!=(const BalanceTarget& aOther) const {
+ return !(*this == aOther);
+ }
+ };
+
+ BalanceTarget balanceTarget;
+
+ // Helpers for text-wrap: balance implementation:
+
+ // Count the number of lines in the mLines list, but return -1 (to suppress
+ // balancing) instead if the count is going to exceed aLimit, or if we
+ // encounter a block.
+ auto countLinesUpTo = [&](int32_t aLimit) -> int32_t {
+ int32_t n = 0;
+ for (auto iter = mLines.begin(); iter != mLines.end(); ++iter) {
+ if (++n > aLimit || iter->IsBlock()) {
+ return -1;
+ }
+ }
+ return n;
+ };
+
+ // Return a BalanceTarget record representing the position at which line-clamp
+ // will take effect for the current line list. Only to be used when there are
+ // enough lines that the clamp will apply.
+ auto getClampPosition = [&](uint32_t aClampCount) -> BalanceTarget {
+ MOZ_ASSERT(aClampCount < mLines.size());
+ auto iter = mLines.begin();
+ for (uint32_t i = 0; i < aClampCount; i++) {
+ ++iter;
+ }
+ nsIFrame* firstChild = iter->mFirstChild;
+ if (!firstChild) {
+ return BalanceTarget{};
+ }
+ nsIContent* content = firstChild->GetContent();
+ if (!content) {
+ return BalanceTarget{};
+ }
+ int32_t offset = 0;
+ if (firstChild->IsTextFrame()) {
+ auto* textFrame = static_cast<nsTextFrame*>(firstChild);
+ offset = textFrame->GetContentOffset();
+ }
+ return BalanceTarget{content, offset};
+ };
+
+ // "balancing" is implemented by shortening the effective inline-size of the
+ // lines, so that content will tend to be pushed down to fill later lines of
+ // the block. `balanceInset` is the current amount of "inset" to apply, and
+ // `balanceStep` is the increment to adjust it by for the next iteration.
+ nscoord balanceStep = 0;
+
+ // text-wrap: balance loop, executed only once if balancing is not required.
+ nsReflowStatus reflowStatus;
+ TrialReflowState trialState(consumedBSize, effectiveContentBoxBSize,
+ needFloatManager);
+ while (true) {
+ // Save the initial floatManager state for repeated trial reflows.
+ // We'll restore (and re-save) the initial state each time we repeat the
+ // reflow.
+ nsFloatManager::SavedState floatManagerState;
+ aReflowInput.mFloatManager->PushState(&floatManagerState);
+
+ aMetrics = ReflowOutput(aMetrics.GetWritingMode());
+ reflowStatus =
+ TrialReflow(aPresContext, aMetrics, aReflowInput, trialState);
+
+ // Do we need to start a `text-wrap: balance` iteration?
+ if (tryBalance) {
+ tryBalance = false;
+ // Don't try to balance an incomplete block, or if we had to use an
+ // overflow-wrap break position in the initial reflow.
+ if (!reflowStatus.IsFullyComplete() || trialState.mUsedOverflowWrap) {
+ break;
+ }
+ balanceTarget.mOffset =
+ countLinesUpTo(StaticPrefs::layout_css_text_wrap_balance_limit());
+ if (balanceTarget.mOffset < 2) {
+ // If there are less than 2 lines, or the number exceeds the limit,
+ // no balancing is needed; just break from the balance loop.
+ break;
+ }
+ // Initialize the amount of inset to try, and the iteration step size.
+ balanceStep = aReflowInput.ComputedISize() / balanceTarget.mOffset;
+ trialState.ResetForBalance(balanceStep);
+ balanceStep /= 2;
+
+ // If -webkit-line-clamp is in effect, then we need to maintain the
+ // content location at which clamping occurs, rather than the total
+ // number of lines in the block.
+ if (StaticPrefs::layout_css_text_wrap_balance_after_clamp_enabled() &&
+ IsLineClampRoot(this)) {
+ uint32_t lineClampCount = aReflowInput.mStyleDisplay->mWebkitLineClamp;
+ if (uint32_t(balanceTarget.mOffset) > lineClampCount) {
+ auto t = getClampPosition(lineClampCount);
+ if (t.mContent) {
+ balanceTarget = t;
+ }
+ }
+ }
+
+ // Restore initial floatManager state for a new trial with updated inset.
+ aReflowInput.mFloatManager->PopState(&floatManagerState);
+ continue;
+ }
+
+ // Helper to determine whether the current trial succeeded (i.e. was able
+ // to fit the content into the expected number of lines).
+ auto trialSucceeded = [&]() -> bool {
+ if (!reflowStatus.IsFullyComplete() || trialState.mUsedOverflowWrap) {
+ return false;
+ }
+ if (balanceTarget.mContent) {
+ auto t = getClampPosition(aReflowInput.mStyleDisplay->mWebkitLineClamp);
+ return t == balanceTarget;
+ }
+ int32_t numLines =
+ countLinesUpTo(StaticPrefs::layout_css_text_wrap_balance_limit());
+ return numLines == balanceTarget.mOffset;
+ };
+
+ // If we're in the process of a balance operation, check whether we've
+ // inset by too much and either increase or reduce the inset for the next
+ // iteration.
+ if (balanceStep > 0) {
+ if (trialSucceeded()) {
+ trialState.ResetForBalance(balanceStep);
+ } else {
+ trialState.ResetForBalance(-balanceStep);
+ }
+ balanceStep /= 2;
+
+ aReflowInput.mFloatManager->PopState(&floatManagerState);
+ continue;
+ }
+
+ // If we were attempting to balance, check whether the final iteration was
+ // successful, and if not, back up by one step.
+ if (balanceTarget.mOffset >= 0) {
+ if (!trialState.mInset || trialSucceeded()) {
+ break;
+ }
+ trialState.ResetForBalance(-1);
+
+ aReflowInput.mFloatManager->PopState(&floatManagerState);
+ continue;
+ }
+
+ // If we reach here, no balancing was required, so just exit; we don't
+ // reset (pop) the floatManager state because this is the reflow we're
+ // going to keep. So the saved state is just dropped.
+ break;
+ } // End of text-wrap: balance retry loop
+
+ // If the block direction is right-to-left, we need to update the bounds of
+ // lines that were placed relative to mContainerSize during reflow, as
+ // we typically do not know the true container size until we've reflowed all
+ // its children. So we use a dummy mContainerSize during reflow (see
+ // BlockReflowState's constructor) and then fix up the positions of the
+ // lines here, once the final block size is known.
+ //
+ // Note that writing-mode:vertical-rl is the only case where the block
+ // logical direction progresses in a negative physical direction, and
+ // therefore block-dir coordinate conversion depends on knowing the width
+ // of the coordinate space in order to translate between the logical and
+ // physical origins.
+ if (aReflowInput.GetWritingMode().IsVerticalRL()) {
+ nsSize containerSize = aMetrics.PhysicalSize();
+ nscoord deltaX = containerSize.width - trialState.mContainerWidth;
+ if (deltaX != 0) {
+ // We compute our lines and markers' overflow areas later in
+ // ComputeOverflowAreas(), so we don't need to adjust their overflow areas
+ // here.
+ const nsPoint physicalDelta(deltaX, 0);
+ for (auto& line : Lines()) {
+ UpdateLineContainerSize(&line, containerSize);
+ }
+ trialState.mFcBounds.Clear();
+ for (nsIFrame* f : mFloats) {
+ f->MovePositionBy(physicalDelta);
+ ConsiderChildOverflow(trialState.mFcBounds, f);
+ }
+ nsFrameList* markerList = GetOutsideMarkerList();
+ if (markerList) {
+ for (nsIFrame* f : *markerList) {
+ f->MovePositionBy(physicalDelta);
+ }
+ }
+ if (nsFrameList* overflowContainers = GetOverflowContainers()) {
+ trialState.mOcBounds.Clear();
+ for (nsIFrame* f : *overflowContainers) {
+ f->MovePositionBy(physicalDelta);
+ ConsiderChildOverflow(trialState.mOcBounds, f);
+ }
+ }
+ }
+ }
+
+ aMetrics.SetOverflowAreasToDesiredBounds();
+ ComputeOverflowAreas(aMetrics.mOverflowAreas,
+ trialState.mBlockEndEdgeOfChildren,
+ aReflowInput.mStyleDisplay);
+ // Factor overflow container child bounds into the overflow area
+ aMetrics.mOverflowAreas.UnionWith(trialState.mOcBounds);
+ // Factor pushed float child bounds into the overflow area
+ aMetrics.mOverflowAreas.UnionWith(trialState.mFcBounds);
+
+ // Let the absolutely positioned container reflow any absolutely positioned
+ // child frames that need to be reflowed, e.g., elements with a percentage
+ // based width/height
+ // We want to do this under either of two conditions:
+ // 1. If we didn't do the incremental reflow above.
+ // 2. If our size changed.
+ // Even though it's the padding edge that's the containing block, we
+ // can use our rect (the border edge) since if the border style
+ // changed, the reflow would have been targeted at us so we'd satisfy
+ // condition 1.
+ // XXX checking oldSize is bogus, there are various reasons we might have
+ // reflowed but our size might not have been changed to what we
+ // asked for (e.g., we ended up being pushed to a new page)
+ // When WillReflowAgainForClearance is true, we will reflow again without
+ // resetting the size. Because of this, we must not reflow our abs-pos
+ // children in that situation --- what we think is our "new size" will not be
+ // our real new size. This also happens to be more efficient.
+ WritingMode parentWM = aMetrics.GetWritingMode();
+ if (HasAbsolutelyPositionedChildren()) {
+ nsAbsoluteContainingBlock* absoluteContainer = GetAbsoluteContainingBlock();
+ bool haveInterrupt = aPresContext->HasPendingInterrupt();
+ if (aReflowInput.WillReflowAgainForClearance() || haveInterrupt) {
+ // Make sure that when we reflow again we'll actually reflow all the abs
+ // pos frames that might conceivably depend on our size (or all of them,
+ // if we're dirty right now and interrupted; in that case we also need
+ // to mark them all with NS_FRAME_IS_DIRTY). Sadly, we can't do much
+ // better than that, because we don't really know what our size will be,
+ // and it might in fact not change on the followup reflow!
+ if (haveInterrupt && HasAnyStateBits(NS_FRAME_IS_DIRTY)) {
+ absoluteContainer->MarkAllFramesDirty();
+ } else {
+ absoluteContainer->MarkSizeDependentFramesDirty();
+ }
+ if (haveInterrupt) {
+ // We're not going to reflow absolute frames; make sure to account for
+ // their existing overflow areas, which is usually a side effect of this
+ // reflow.
+ //
+ // TODO(emilio): nsAbsoluteContainingBlock::Reflow already checks for
+ // interrupt, can we just rely on it and unconditionally take the else
+ // branch below? That's a bit more subtle / risky, since I don't see
+ // what would reflow them in that case if they depended on our size.
+ for (nsIFrame* kid = absoluteContainer->GetChildList().FirstChild();
+ kid; kid = kid->GetNextSibling()) {
+ ConsiderChildOverflow(aMetrics.mOverflowAreas, kid);
+ }
+ }
+ } else {
+ LogicalSize containingBlockSize =
+ CalculateContainingBlockSizeForAbsolutes(parentWM, aReflowInput,
+ aMetrics.Size(parentWM));
+
+ // Mark frames that depend on changes we just made to this frame as dirty:
+ // Now we can assume that the padding edge hasn't moved.
+ // We need to reflow the absolutes if one of them depends on
+ // its placeholder position, or the containing block size in a
+ // direction in which the containing block size might have
+ // changed.
+
+ // XXX "width" and "height" in this block will become ISize and BSize
+ // when nsAbsoluteContainingBlock is logicalized
+ bool cbWidthChanged = aMetrics.Width() != oldSize.width;
+ bool isRoot = !GetContent()->GetParent();
+ // If isRoot and we have auto height, then we are the initial
+ // containing block and the containing block height is the
+ // viewport height, which can't change during incremental
+ // reflow.
+ bool cbHeightChanged =
+ !(isRoot && NS_UNCONSTRAINEDSIZE == aReflowInput.ComputedHeight()) &&
+ aMetrics.Height() != oldSize.height;
+
+ nsRect containingBlock(nsPoint(0, 0),
+ containingBlockSize.GetPhysicalSize(parentWM));
+ AbsPosReflowFlags flags = AbsPosReflowFlags::ConstrainHeight;
+ if (cbWidthChanged) {
+ flags |= AbsPosReflowFlags::CBWidthChanged;
+ }
+ if (cbHeightChanged) {
+ flags |= AbsPosReflowFlags::CBHeightChanged;
+ }
+ // Setup the line cursor here to optimize line searching for
+ // calculating hypothetical position of absolutely-positioned
+ // frames.
+ SetupLineCursorForQuery();
+ absoluteContainer->Reflow(this, aPresContext, aReflowInput, reflowStatus,
+ containingBlock, flags,
+ &aMetrics.mOverflowAreas);
+ }
+ }
+
+ FinishAndStoreOverflow(&aMetrics, aReflowInput.mStyleDisplay);
+
+ aStatus = reflowStatus;
+
+#ifdef DEBUG
+ // Between when we drain pushed floats and when we complete reflow,
+ // we're allowed to have multiple continuations of the same float on
+ // our floats list, since a first-in-flow might get pushed to a later
+ // continuation of its containing block. But it's not permitted
+ // outside that time.
+ nsLayoutUtils::AssertNoDuplicateContinuations(this, mFloats);
+
+ if (gNoisyReflow) {
+ IndentBy(stdout, gNoiseIndent);
+ ListTag(stdout);
+ printf(": status=%s metrics=%d,%d carriedMargin=%d",
+ ToString(aStatus).c_str(), aMetrics.ISize(parentWM),
+ aMetrics.BSize(parentWM), aMetrics.mCarriedOutBEndMargin.get());
+ if (HasOverflowAreas()) {
+ printf(" overflow-vis={%d,%d,%d,%d}", aMetrics.InkOverflow().x,
+ aMetrics.InkOverflow().y, aMetrics.InkOverflow().width,
+ aMetrics.InkOverflow().height);
+ printf(" overflow-scr={%d,%d,%d,%d}", aMetrics.ScrollableOverflow().x,
+ aMetrics.ScrollableOverflow().y,
+ aMetrics.ScrollableOverflow().width,
+ aMetrics.ScrollableOverflow().height);
+ }
+ printf("\n");
+ }
+
+ if (gLameReflowMetrics) {
+ PRTime end = PR_Now();
+
+ int32_t ectc = nsLineBox::GetCtorCount();
+ int32_t numLines = mLines.size();
+ if (!numLines) {
+ numLines = 1;
+ }
+ PRTime delta, perLineDelta, lines;
+ lines = int64_t(numLines);
+ delta = end - start;
+ perLineDelta = delta / lines;
+
+ ListTag(stdout);
+ char buf[400];
+ SprintfLiteral(buf,
+ ": %" PRId64 " elapsed (%" PRId64
+ " per line) (%d lines; %d new lines)",
+ delta, perLineDelta, numLines, ectc - ctc);
+ printf("%s\n", buf);
+ }
+#endif
+}
+
+nsReflowStatus nsBlockFrame::TrialReflow(nsPresContext* aPresContext,
+ ReflowOutput& aMetrics,
+ const ReflowInput& aReflowInput,
+ TrialReflowState& aTrialState) {
+#ifdef DEBUG
+ // Between when we drain pushed floats and when we complete reflow,
+ // we're allowed to have multiple continuations of the same float on
+ // our floats list, since a first-in-flow might get pushed to a later
+ // continuation of its containing block. But it's not permitted
+ // outside that time.
+ nsLayoutUtils::AssertNoDuplicateContinuations(this, mFloats);
+#endif
+
+ // ALWAYS drain overflow. We never want to leave the previnflow's
+ // overflow lines hanging around; block reflow depends on the
+ // overflow line lists being cleared out between reflow passes.
+ DrainOverflowLines();
+
+ bool blockStartMarginRoot, blockEndMarginRoot;
+ IsMarginRoot(&blockStartMarginRoot, &blockEndMarginRoot);
+
+ BlockReflowState state(aReflowInput, aPresContext, this, blockStartMarginRoot,
+ blockEndMarginRoot, aTrialState.mNeedFloatManager,
+ aTrialState.mConsumedBSize,
+ aTrialState.mEffectiveContentBoxBSize,
+ aTrialState.mInset);
+
+ // Handle paginated overflow (see nsContainerFrame.h)
+ nsReflowStatus ocStatus;
+ if (GetPrevInFlow()) {
+ ReflowOverflowContainerChildren(
+ aPresContext, aReflowInput, aTrialState.mOcBounds,
+ ReflowChildFlags::Default, ocStatus, DefaultChildFrameMerge,
+ Some(state.ContainerSize()));
+ }
+
+ // Now that we're done cleaning up our overflow container lists, we can
+ // give |state| its nsOverflowContinuationTracker.
+ nsOverflowContinuationTracker tracker(this, false);
+ state.mOverflowTracker = &tracker;
+
+ // Drain & handle pushed floats
+ DrainPushedFloats();
+ ReflowPushedFloats(state, aTrialState.mFcBounds);
+
+ // If we're not dirty (which means we'll mark everything dirty later)
+ // and our inline-size has changed, mark the lines dirty that we need to
+ // mark dirty for a resize reflow.
+ if (!HasAnyStateBits(NS_FRAME_IS_DIRTY) && aReflowInput.IsIResize()) {
+ PrepareResizeReflow(state);
+ }
+
+ // The same for percentage text-indent, except conditioned on the
+ // parent resizing.
+ if (!HasAnyStateBits(NS_FRAME_IS_DIRTY) && aReflowInput.mCBReflowInput &&
+ aReflowInput.mCBReflowInput->IsIResize() &&
+ StyleText()->mTextIndent.length.HasPercent() && !mLines.empty()) {
+ mLines.front()->MarkDirty();
+ }
+
+ // For text-wrap:balance trials, we need to reflow all the lines even if
+ // they're not all "dirty".
+ if (aTrialState.mBalancing) {
+ MarkAllDescendantLinesDirty(this);
+ } else {
+ LazyMarkLinesDirty();
+ }
+
+ // Now reflow...
+ aTrialState.mUsedOverflowWrap = ReflowDirtyLines(state);
+
+ // If we have a next-in-flow, and that next-in-flow has pushed floats from
+ // this frame from a previous iteration of reflow, then we should not return
+ // a status with IsFullyComplete() equals to true, since we actually have
+ // overflow, it's just already been handled.
+
+ // NOTE: This really shouldn't happen, since we _should_ pull back our floats
+ // and reflow them, but just in case it does, this is a safety precaution so
+ // we don't end up with a placeholder pointing to frames that have already
+ // been deleted as part of removing our next-in-flow.
+ if (state.mReflowStatus.IsFullyComplete()) {
+ nsBlockFrame* nif = static_cast<nsBlockFrame*>(GetNextInFlow());
+ while (nif) {
+ if (nif->HasPushedFloatsFromPrevContinuation()) {
+ if (nif->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER)) {
+ state.mReflowStatus.SetOverflowIncomplete();
+ } else {
+ state.mReflowStatus.SetIncomplete();
+ }
+ break;
+ }
+
+ nif = static_cast<nsBlockFrame*>(nif->GetNextInFlow());
+ }
+ }
+
+ state.mReflowStatus.MergeCompletionStatusFrom(ocStatus);
+
+ // If we end in a BR with clear and affected floats continue,
+ // we need to continue, too.
+ if (NS_UNCONSTRAINEDSIZE != aReflowInput.AvailableBSize() &&
+ state.mReflowStatus.IsComplete() &&
+ state.FloatManager()->ClearContinues(FindTrailingClear())) {
+ state.mReflowStatus.SetIncomplete();
+ }
+
+ if (!state.mReflowStatus.IsFullyComplete()) {
+ if (HasOverflowLines() || HasPushedFloats()) {
+ state.mReflowStatus.SetNextInFlowNeedsReflow();
+ }
+
+#ifdef DEBUG_kipp
+ ListTag(stdout);
+ printf(": block is not fully complete\n");
+#endif
+ }
+
+ // Place the ::marker's frame if it is placed next to a block child.
+ //
+ // According to the CSS2 spec, section 12.6.1, the ::marker's box
+ // participates in the height calculation of the list-item box's
+ // first line box.
+ //
+ // There are exactly two places a ::marker can be placed: near the
+ // first or second line. It's only placed on the second line in a
+ // rare case: an empty first line followed by a second line that
+ // contains a block (example: <LI>\n<P>... ). This is where
+ // the second case can happen.
+ if (HasOutsideMarker() && !mLines.empty() &&
+ (mLines.front()->IsBlock() ||
+ (0 == mLines.front()->BSize() && mLines.front() != mLines.back() &&
+ mLines.begin().next()->IsBlock()))) {
+ // Reflow the ::marker's frame.
+ ReflowOutput reflowOutput(aReflowInput);
+ // XXX Use the entire line when we fix bug 25888.
+ nsLayoutUtils::LinePosition position;
+ WritingMode wm = aReflowInput.GetWritingMode();
+ bool havePosition =
+ nsLayoutUtils::GetFirstLinePosition(wm, this, &position);
+ nscoord lineBStart =
+ havePosition ? position.mBStart
+ : aReflowInput.ComputedLogicalBorderPadding(wm).BStart(wm);
+ nsIFrame* marker = GetOutsideMarker();
+ ReflowOutsideMarker(marker, state, reflowOutput, lineBStart);
+ NS_ASSERTION(!MarkerIsEmpty() || reflowOutput.BSize(wm) == 0,
+ "empty ::marker frame took up space");
+
+ if (havePosition && !MarkerIsEmpty()) {
+ // We have some lines to align the ::marker with.
+
+ // Doing the alignment using the baseline will also cater for
+ // ::markers that are placed next to a child block (bug 92896)
+
+ // Tall ::markers won't look particularly nice here...
+ LogicalRect bbox =
+ marker->GetLogicalRect(wm, reflowOutput.PhysicalSize());
+ const auto baselineGroup = BaselineSharingGroup::First;
+ Maybe<nscoord> result;
+ if (MOZ_LIKELY(!wm.IsOrthogonalTo(marker->GetWritingMode()))) {
+ result = marker->GetNaturalBaselineBOffset(
+ wm, baselineGroup, BaselineExportContext::LineLayout);
+ }
+ const auto markerBaseline = result.valueOrFrom([bbox, wm, marker]() {
+ return bbox.BSize(wm) + marker->GetLogicalUsedMargin(wm).BEnd(wm);
+ });
+ bbox.BStart(wm) = position.mBaseline - markerBaseline;
+ marker->SetRect(wm, bbox, reflowOutput.PhysicalSize());
+ }
+ // Otherwise just leave the ::marker where it is, up against our
+ // block-start padding.
+ }
+
+ // Clear any existing -webkit-line-clamp ellipsis.
+ if (aReflowInput.mStyleDisplay->mWebkitLineClamp) {
+ ClearLineClampEllipsis();
+ }
+
+ CheckFloats(state);
+
+ // Compute our final size (for this trial layout)
+ aTrialState.mBlockEndEdgeOfChildren =
+ ComputeFinalSize(aReflowInput, state, aMetrics);
+ aTrialState.mContainerWidth = state.ContainerSize().width;
+
+ return state.mReflowStatus;
+}
+
+bool nsBlockFrame::CheckForCollapsedBEndMarginFromClearanceLine() {
+ for (auto& line : Reversed(Lines())) {
+ if (0 != line.BSize() || !line.CachedIsEmpty()) {
+ return false;
+ }
+ if (line.HasClearance()) {
+ return true;
+ }
+ }
+ return false;
+}
+
+static nsLineBox* FindLineClampTarget(nsBlockFrame*& aFrame,
+ StyleLineClamp aLineNumber) {
+ MOZ_ASSERT(aLineNumber > 0);
+ MOZ_ASSERT(!aFrame->HasAnyStateBits(NS_BLOCK_HAS_LINE_CLAMP_ELLIPSIS),
+ "Should have been removed earlier in nsBlockReflow::Reflow");
+
+ nsLineBox* target = nullptr;
+ nsBlockFrame* targetFrame = nullptr;
+ bool foundFollowingLine = false;
+
+ LineClampLineIterator iter(aFrame);
+
+ while (nsLineBox* line = iter.GetCurrentLine()) {
+ MOZ_ASSERT(!line->HasLineClampEllipsis(),
+ "Should have been removed earlier in nsBlockFrame::Reflow");
+ MOZ_ASSERT(!iter.GetCurrentFrame()->HasAnyStateBits(
+ NS_BLOCK_HAS_LINE_CLAMP_ELLIPSIS),
+ "Should have been removed earlier in nsBlockReflow::Reflow");
+
+ // Don't count a line that only has collapsible white space (as might exist
+ // after calling e.g. getBoxQuads).
+ if (line->IsEmpty()) {
+ iter.Next();
+ continue;
+ }
+
+ if (aLineNumber == 0) {
+ // We already previously found our target line, and now we have
+ // confirmed that there is another line after it.
+ foundFollowingLine = true;
+ break;
+ }
+
+ if (--aLineNumber == 0) {
+ // This is our target line. Continue looping to confirm that we
+ // have another line after us.
+ target = line;
+ targetFrame = iter.GetCurrentFrame();
+ }
+
+ iter.Next();
+ }
+
+ if (!foundFollowingLine) {
+ aFrame = nullptr;
+ return nullptr;
+ }
+
+ MOZ_ASSERT(target);
+ MOZ_ASSERT(targetFrame);
+
+ aFrame = targetFrame;
+ return target;
+}
+
+static nscoord ApplyLineClamp(const ReflowInput& aReflowInput,
+ nsBlockFrame* aFrame,
+ nscoord aContentBlockEndEdge) {
+ if (!IsLineClampRoot(aFrame)) {
+ return aContentBlockEndEdge;
+ }
+ auto lineClamp = aReflowInput.mStyleDisplay->mWebkitLineClamp;
+ nsBlockFrame* frame = aFrame;
+ nsLineBox* line = FindLineClampTarget(frame, lineClamp);
+ if (!line) {
+ // The number of lines did not exceed the -webkit-line-clamp value.
+ return aContentBlockEndEdge;
+ }
+
+ // Mark the line as having an ellipsis so that TextOverflow will render it.
+ line->SetHasLineClampEllipsis();
+ frame->AddStateBits(NS_BLOCK_HAS_LINE_CLAMP_ELLIPSIS);
+
+ // Translate the b-end edge of the line up to aFrame's space.
+ nscoord edge = line->BEnd();
+ for (nsIFrame* f = frame; f != aFrame; f = f->GetParent()) {
+ edge +=
+ f->GetLogicalPosition(f->GetParent()->GetSize()).B(f->GetWritingMode());
+ }
+
+ return edge;
+}
+
+nscoord nsBlockFrame::ComputeFinalSize(const ReflowInput& aReflowInput,
+ BlockReflowState& aState,
+ ReflowOutput& aMetrics) {
+ WritingMode wm = aState.mReflowInput.GetWritingMode();
+ const LogicalMargin& borderPadding = aState.BorderPadding();
+#ifdef NOISY_FINAL_SIZE
+ ListTag(stdout);
+ printf(": mBCoord=%d mIsBEndMarginRoot=%s mPrevBEndMargin=%d bp=%d,%d\n",
+ aState.mBCoord, aState.mFlags.mIsBEndMarginRoot ? "yes" : "no",
+ aState.mPrevBEndMargin.get(), borderPadding.BStart(wm),
+ borderPadding.BEnd(wm));
+#endif
+
+ // Compute final inline size
+ LogicalSize finalSize(wm);
+ finalSize.ISize(wm) =
+ NSCoordSaturatingAdd(NSCoordSaturatingAdd(borderPadding.IStart(wm),
+ aReflowInput.ComputedISize()),
+ borderPadding.IEnd(wm));
+
+ // Return block-end margin information
+ // rbs says he hit this assertion occasionally (see bug 86947), so
+ // just set the margin to zero and we'll figure out why later
+ // NS_ASSERTION(aMetrics.mCarriedOutBEndMargin.IsZero(),
+ // "someone else set the margin");
+ nscoord nonCarriedOutBDirMargin = 0;
+ if (!aState.mFlags.mIsBEndMarginRoot) {
+ // Apply rule from CSS 2.1 section 8.3.1. If we have some empty
+ // line with clearance and a non-zero block-start margin and all
+ // subsequent lines are empty, then we do not allow our children's
+ // carried out block-end margin to be carried out of us and collapse
+ // with our own block-end margin.
+ if (CheckForCollapsedBEndMarginFromClearanceLine()) {
+ // Convert the children's carried out margin to something that
+ // we will include in our height
+ nonCarriedOutBDirMargin = aState.mPrevBEndMargin.get();
+ aState.mPrevBEndMargin.Zero();
+ }
+ aMetrics.mCarriedOutBEndMargin = aState.mPrevBEndMargin;
+ } else {
+ aMetrics.mCarriedOutBEndMargin.Zero();
+ }
+
+ nscoord blockEndEdgeOfChildren = aState.mBCoord + nonCarriedOutBDirMargin;
+ // Shrink wrap our height around our contents.
+ if (aState.mFlags.mIsBEndMarginRoot ||
+ NS_UNCONSTRAINEDSIZE != aReflowInput.ComputedBSize()) {
+ // When we are a block-end-margin root make sure that our last
+ // child's block-end margin is fully applied. We also do this when
+ // we have a computed height, since in that case the carried out
+ // margin is not going to be applied anywhere, so we should note it
+ // here to be included in the overflow area.
+ // Apply the margin only if there's space for it.
+ if (blockEndEdgeOfChildren < aState.mReflowInput.AvailableBSize()) {
+ // Truncate block-end margin if it doesn't fit to our available BSize.
+ blockEndEdgeOfChildren =
+ std::min(blockEndEdgeOfChildren + aState.mPrevBEndMargin.get(),
+ aState.mReflowInput.AvailableBSize());
+ }
+ }
+ if (aState.mFlags.mBlockNeedsFloatManager) {
+ // Include the float manager's state to properly account for the
+ // block-end margin of any floated elements; e.g., inside a table cell.
+ //
+ // Note: The block coordinate returned by ClearFloats is always greater than
+ // or equal to blockEndEdgeOfChildren.
+ std::tie(blockEndEdgeOfChildren, std::ignore) =
+ aState.ClearFloats(blockEndEdgeOfChildren, StyleClear::Both);
+ }
+
+ if (NS_UNCONSTRAINEDSIZE != aReflowInput.ComputedBSize()) {
+ // Note: We don't use blockEndEdgeOfChildren because it includes the
+ // previous margin.
+ const nscoord contentBSizeWithBStartBP =
+ aState.mBCoord + nonCarriedOutBDirMargin;
+
+ // We don't care about ApplyLineClamp's return value (the line-clamped
+ // content BSize) in this explicit-BSize codepath, but we do still need to
+ // call ApplyLineClamp for ellipsis markers to be placed as-needed.
+ ApplyLineClamp(aState.mReflowInput, this, contentBSizeWithBStartBP);
+
+ finalSize.BSize(wm) = ComputeFinalBSize(aState, contentBSizeWithBStartBP);
+
+ // If the content block-size is larger than the effective computed
+ // block-size, we extend the block-size to contain all the content.
+ // https://drafts.csswg.org/css-sizing-4/#aspect-ratio-minimum
+ if (aReflowInput.ShouldApplyAutomaticMinimumOnBlockAxis()) {
+ // Note: finalSize.BSize(wm) is the border-box size, so we compare it with
+ // the content's block-size plus our border and padding..
+ finalSize.BSize(wm) =
+ std::max(finalSize.BSize(wm),
+ contentBSizeWithBStartBP + borderPadding.BEnd(wm));
+ }
+
+ // Don't carry out a block-end margin when our BSize is fixed.
+ //
+ // Note: this also includes the case that aReflowInput.ComputedBSize() is
+ // calculated from aspect-ratio. i.e. Don't carry out block margin-end if it
+ // is replaced by the block size from aspect-ratio and inline size.
+ aMetrics.mCarriedOutBEndMargin.Zero();
+ } else {
+ Maybe<nscoord> containBSize = ContainIntrinsicBSize(
+ IsComboboxControlFrame() ? NS_UNCONSTRAINEDSIZE : 0);
+ if (containBSize && *containBSize != NS_UNCONSTRAINEDSIZE) {
+ // If we're size-containing in block axis and we don't have a specified
+ // block size, then our final size should actually be computed from only
+ // our border, padding and contain-intrinsic-block-size, ignoring the
+ // actual contents. Hence this case is a simplified version of the case
+ // below.
+ //
+ // NOTE: We exempt the nsComboboxControlFrame subclass from taking this
+ // special case when it has 'contain-intrinsic-block-size: none', because
+ // comboboxes implicitly honors the size-containment behavior on its
+ // nsComboboxDisplayFrame child (which it shrinkwraps) rather than on the
+ // nsComboboxControlFrame. (Moreover, the DisplayFrame child doesn't even
+ // need any special content-size-ignoring behavior in its reflow method,
+ // because that method just resolves "auto" BSize values to one
+ // line-height rather than by measuring its contents' BSize.)
+ nscoord contentBSize = *containBSize;
+ nscoord autoBSize =
+ aReflowInput.ApplyMinMaxBSize(contentBSize, aState.mConsumedBSize);
+ aMetrics.mCarriedOutBEndMargin.Zero();
+ autoBSize += borderPadding.BStartEnd(wm);
+ finalSize.BSize(wm) = autoBSize;
+ } else if (aState.mReflowStatus.IsInlineBreakBefore()) {
+ // Our parent is expected to push this frame to the next page/column so
+ // what size we set here doesn't really matter.
+ finalSize.BSize(wm) = aReflowInput.AvailableBSize();
+ } else if (aState.mReflowStatus.IsComplete()) {
+ const nscoord lineClampedContentBlockEndEdge =
+ ApplyLineClamp(aReflowInput, this, blockEndEdgeOfChildren);
+
+ const nscoord bpBStart = borderPadding.BStart(wm);
+ const nscoord contentBSize = blockEndEdgeOfChildren - bpBStart;
+ const nscoord lineClampedContentBSize =
+ lineClampedContentBlockEndEdge - bpBStart;
+
+ const nscoord autoBSize = aReflowInput.ApplyMinMaxBSize(
+ lineClampedContentBSize, aState.mConsumedBSize);
+ if (autoBSize != contentBSize) {
+ // Our min-block-size, max-block-size, or -webkit-line-clamp value made
+ // our bsize change. Don't carry out our kids' block-end margins.
+ aMetrics.mCarriedOutBEndMargin.Zero();
+ }
+ nscoord bSize = autoBSize + borderPadding.BStartEnd(wm);
+ if (MOZ_UNLIKELY(autoBSize > contentBSize &&
+ bSize > aReflowInput.AvailableBSize() &&
+ aReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE)) {
+ // Applying `min-size` made us overflow our available size.
+ // Clamp it and report that we're Incomplete, or BreakBefore if we have
+ // 'break-inside: avoid' that is applicable.
+ bSize = aReflowInput.AvailableBSize();
+ if (ShouldAvoidBreakInside(aReflowInput)) {
+ aState.mReflowStatus.SetInlineLineBreakBeforeAndReset();
+ } else {
+ aState.mReflowStatus.SetIncomplete();
+ }
+ }
+ finalSize.BSize(wm) = bSize;
+ } else {
+ NS_ASSERTION(
+ aReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE,
+ "Shouldn't be incomplete if availableBSize is UNCONSTRAINED.");
+ nscoord bSize = std::max(aState.mBCoord, aReflowInput.AvailableBSize());
+ if (aReflowInput.AvailableBSize() == NS_UNCONSTRAINEDSIZE) {
+ // This should never happen, but it does. See bug 414255
+ bSize = aState.mBCoord;
+ }
+ const nscoord maxBSize = aReflowInput.ComputedMaxBSize();
+ if (maxBSize != NS_UNCONSTRAINEDSIZE &&
+ aState.mConsumedBSize + bSize - borderPadding.BStart(wm) > maxBSize) {
+ // Compute this fragment's block-size, with the max-block-size
+ // constraint taken into consideration.
+ const nscoord clampedBSizeWithoutEndBP =
+ std::max(0, maxBSize - aState.mConsumedBSize) +
+ borderPadding.BStart(wm);
+ const nscoord clampedBSize =
+ clampedBSizeWithoutEndBP + borderPadding.BEnd(wm);
+ if (clampedBSize <= aReflowInput.AvailableBSize()) {
+ // We actually fit after applying `max-size` so we should be
+ // Overflow-Incomplete instead.
+ bSize = clampedBSize;
+ aState.mReflowStatus.SetOverflowIncomplete();
+ } else {
+ // We cannot fit after applying `max-size` with our block-end BP, so
+ // we should draw it in our next continuation.
+ bSize = clampedBSizeWithoutEndBP;
+ }
+ }
+ finalSize.BSize(wm) = bSize;
+ }
+ }
+
+ if (IsTrueOverflowContainer()) {
+ if (aState.mReflowStatus.IsIncomplete()) {
+ // Overflow containers can only be overflow complete.
+ // Note that auto height overflow containers have no normal children
+ NS_ASSERTION(finalSize.BSize(wm) == 0,
+ "overflow containers must be zero-block-size");
+ aState.mReflowStatus.SetOverflowIncomplete();
+ }
+ } else if (aReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE &&
+ !aState.mReflowStatus.IsInlineBreakBefore() &&
+ aState.mReflowStatus.IsComplete()) {
+ // Currently only used for grid items, but could be used in other contexts.
+ // The FragStretchBSizeProperty is our expected non-fragmented block-size
+ // we should stretch to (for align-self:stretch etc). In some fragmentation
+ // cases though, the last fragment (this frame since we're complete), needs
+ // to have extra size applied because earlier fragments consumed too much of
+ // our computed size due to overflowing their containing block. (E.g. this
+ // ensures we fill the last row when a multi-row grid item is fragmented).
+ bool found;
+ nscoord bSize = GetProperty(FragStretchBSizeProperty(), &found);
+ if (found) {
+ finalSize.BSize(wm) = std::max(bSize, finalSize.BSize(wm));
+ }
+ }
+
+ // Clamp the content size to fit within the margin-box clamp size, if any.
+ if (MOZ_UNLIKELY(aReflowInput.mComputeSizeFlags.contains(
+ ComputeSizeFlag::BClampMarginBoxMinSize)) &&
+ aState.mReflowStatus.IsComplete()) {
+ bool found;
+ nscoord cbSize = GetProperty(BClampMarginBoxMinSizeProperty(), &found);
+ if (found) {
+ auto marginBoxBSize =
+ finalSize.BSize(wm) +
+ aReflowInput.ComputedLogicalMargin(wm).BStartEnd(wm);
+ auto overflow = marginBoxBSize - cbSize;
+ if (overflow > 0) {
+ auto contentBSize = finalSize.BSize(wm) - borderPadding.BStartEnd(wm);
+ auto newContentBSize = std::max(nscoord(0), contentBSize - overflow);
+ // XXXmats deal with percentages better somehow?
+ finalSize.BSize(wm) -= contentBSize - newContentBSize;
+ }
+ }
+ }
+
+ // Screen out negative block sizes --- can happen due to integer overflows :-(
+ finalSize.BSize(wm) = std::max(0, finalSize.BSize(wm));
+
+ if (blockEndEdgeOfChildren != finalSize.BSize(wm) - borderPadding.BEnd(wm)) {
+ SetProperty(BlockEndEdgeOfChildrenProperty(), blockEndEdgeOfChildren);
+ } else {
+ RemoveProperty(BlockEndEdgeOfChildrenProperty());
+ }
+
+ aMetrics.SetSize(wm, finalSize);
+
+#ifdef DEBUG_blocks
+ if ((ABSURD_SIZE(aMetrics.Width()) || ABSURD_SIZE(aMetrics.Height())) &&
+ !GetParent()->IsAbsurdSizeAssertSuppressed()) {
+ ListTag(stdout);
+ printf(": WARNING: desired:%d,%d\n", aMetrics.Width(), aMetrics.Height());
+ }
+#endif
+
+ return blockEndEdgeOfChildren;
+}
+
+void nsBlockFrame::ConsiderBlockEndEdgeOfChildren(
+ OverflowAreas& aOverflowAreas, nscoord aBEndEdgeOfChildren,
+ const nsStyleDisplay* aDisplay) const {
+ const auto wm = GetWritingMode();
+
+ // Factor in the block-end edge of the children. Child frames will be added
+ // to the overflow area as we iterate through the lines, but their margins
+ // won't, so we need to account for block-end margins here.
+ // REVIEW: For now, we do this for both visual and scrollable area,
+ // although when we make scrollable overflow area not be a subset of
+ // visual, we can change this.
+
+ if (Style()->GetPseudoType() == PseudoStyleType::scrolledContent) {
+ // If we are a scrolled inner frame, add our block-end padding to our
+ // children's block-end edge.
+ //
+ // Note: aBEndEdgeOfChildren already includes our own block-start padding
+ // because it is relative to our block-start edge of our border-box, which
+ // is the same as our padding-box here.
+ MOZ_ASSERT(GetLogicalUsedBorderAndPadding(wm) == GetLogicalUsedPadding(wm),
+ "A scrolled inner frame shouldn't have any border!");
+ aBEndEdgeOfChildren += GetLogicalUsedPadding(wm).BEnd(wm);
+ }
+
+ // XXX Currently, overflow areas are stored as physical rects, so we have
+ // to handle writing modes explicitly here. If we change overflow rects
+ // to be stored logically, this can be simplified again.
+ if (wm.IsVertical()) {
+ if (wm.IsVerticalLR()) {
+ for (const auto otype : AllOverflowTypes()) {
+ if (!(aDisplay->IsContainLayout() &&
+ otype == OverflowType::Scrollable)) {
+ // Layout containment should force all overflow to be ink (visual)
+ // overflow, so if we're layout-contained, we only add our children's
+ // block-end edge to the ink (visual) overflow -- not to the
+ // scrollable overflow.
+ nsRect& o = aOverflowAreas.Overflow(otype);
+ o.width = std::max(o.XMost(), aBEndEdgeOfChildren) - o.x;
+ }
+ }
+ } else {
+ for (const auto otype : AllOverflowTypes()) {
+ if (!(aDisplay->IsContainLayout() &&
+ otype == OverflowType::Scrollable)) {
+ nsRect& o = aOverflowAreas.Overflow(otype);
+ nscoord xmost = o.XMost();
+ o.x = std::min(o.x, xmost - aBEndEdgeOfChildren);
+ o.width = xmost - o.x;
+ }
+ }
+ }
+ } else {
+ for (const auto otype : AllOverflowTypes()) {
+ if (!(aDisplay->IsContainLayout() && otype == OverflowType::Scrollable)) {
+ nsRect& o = aOverflowAreas.Overflow(otype);
+ o.height = std::max(o.YMost(), aBEndEdgeOfChildren) - o.y;
+ }
+ }
+ }
+}
+
+void nsBlockFrame::ComputeOverflowAreas(OverflowAreas& aOverflowAreas,
+ nscoord aBEndEdgeOfChildren,
+ const nsStyleDisplay* aDisplay) const {
+ // XXX_perf: This can be done incrementally. It is currently one of
+ // the things that makes incremental reflow O(N^2).
+ auto overflowClipAxes = ShouldApplyOverflowClipping(aDisplay);
+ auto overflowClipMargin = OverflowClipMargin(overflowClipAxes);
+ if (overflowClipAxes == PhysicalAxes::Both &&
+ overflowClipMargin == nsSize()) {
+ return;
+ }
+
+ // We rely here on our caller having called SetOverflowAreasToDesiredBounds().
+ nsRect frameBounds = aOverflowAreas.ScrollableOverflow();
+
+ for (const auto& line : Lines()) {
+ if (aDisplay->IsContainLayout()) {
+ // If we have layout containment, 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 visual and
+ // scrollable overflow with its parent's ink overflow.
+ nsRect childVisualRect = line.InkOverflowRect();
+ OverflowAreas childVisualArea = OverflowAreas(childVisualRect, nsRect());
+ aOverflowAreas.UnionWith(childVisualArea);
+ } else {
+ aOverflowAreas.UnionWith(line.GetOverflowAreas());
+ }
+ }
+
+ // Factor an outside ::marker in; normally the ::marker will be factored
+ // into the line-box's overflow areas. However, if the line is a block
+ // line then it won't; if there are no lines, it won't. So just
+ // factor it in anyway (it can't hurt if it was already done).
+ // XXXldb Can we just fix GetOverflowArea instead?
+ if (nsIFrame* outsideMarker = GetOutsideMarker()) {
+ aOverflowAreas.UnionAllWith(outsideMarker->GetRect());
+ }
+
+ ConsiderBlockEndEdgeOfChildren(aOverflowAreas, aBEndEdgeOfChildren, aDisplay);
+
+ if (overflowClipAxes != PhysicalAxes::None) {
+ aOverflowAreas.ApplyClipping(frameBounds, overflowClipAxes,
+ overflowClipMargin);
+ }
+
+#ifdef NOISY_OVERFLOW_AREAS
+ printf("%s: InkOverflowArea=%s, ScrollableOverflowArea=%s\n", ListTag().get(),
+ ToString(aOverflowAreas.InkOverflow()).c_str(),
+ ToString(aOverflowAreas.ScrollableOverflow()).c_str());
+#endif
+}
+
+void nsBlockFrame::UnionChildOverflow(OverflowAreas& aOverflowAreas) {
+ // We need to update the overflow areas of lines manually, as they
+ // get cached and re-used otherwise. Lines aren't exposed as normal
+ // frame children, so calling UnionChildOverflow alone will end up
+ // using the old cached values.
+ for (auto& line : Lines()) {
+ nsRect bounds = line.GetPhysicalBounds();
+ OverflowAreas lineAreas(bounds, bounds);
+
+ int32_t n = line.GetChildCount();
+ for (nsIFrame* lineFrame = line.mFirstChild; n > 0;
+ lineFrame = lineFrame->GetNextSibling(), --n) {
+ ConsiderChildOverflow(lineAreas, lineFrame);
+ }
+
+ // Consider the overflow areas of the floats attached to the line as well
+ if (line.HasFloats()) {
+ for (nsIFrame* f : line.Floats()) {
+ ConsiderChildOverflow(lineAreas, f);
+ }
+ }
+
+ line.SetOverflowAreas(lineAreas);
+ aOverflowAreas.UnionWith(lineAreas);
+ }
+
+ // Union with child frames, skipping the principal and float lists
+ // since we already handled those using the line boxes.
+ nsLayoutUtils::UnionChildOverflow(
+ this, aOverflowAreas,
+ {FrameChildListID::Principal, FrameChildListID::Float});
+}
+
+bool nsBlockFrame::ComputeCustomOverflow(OverflowAreas& aOverflowAreas) {
+ bool found;
+ nscoord blockEndEdgeOfChildren =
+ GetProperty(BlockEndEdgeOfChildrenProperty(), &found);
+ if (found) {
+ ConsiderBlockEndEdgeOfChildren(aOverflowAreas, blockEndEdgeOfChildren,
+ StyleDisplay());
+ }
+
+ // Line cursor invariants depend on the overflow areas of the lines, so
+ // we must clear the line cursor since those areas may have changed.
+ ClearLineCursors();
+ return nsContainerFrame::ComputeCustomOverflow(aOverflowAreas);
+}
+
+void nsBlockFrame::LazyMarkLinesDirty() {
+ if (HasAnyStateBits(NS_BLOCK_LOOK_FOR_DIRTY_FRAMES)) {
+ for (LineIterator line = LinesBegin(), line_end = LinesEnd();
+ line != line_end; ++line) {
+ int32_t n = line->GetChildCount();
+ for (nsIFrame* lineFrame = line->mFirstChild; n > 0;
+ lineFrame = lineFrame->GetNextSibling(), --n) {
+ if (lineFrame->IsSubtreeDirty()) {
+ // NOTE: MarkLineDirty does more than just marking the line dirty.
+ MarkLineDirty(line, &mLines);
+ break;
+ }
+ }
+ }
+ RemoveStateBits(NS_BLOCK_LOOK_FOR_DIRTY_FRAMES);
+ }
+}
+
+void nsBlockFrame::MarkLineDirty(LineIterator aLine,
+ const nsLineList* aLineList) {
+ // Mark aLine dirty
+ aLine->MarkDirty();
+ aLine->SetInvalidateTextRuns(true);
+#ifdef DEBUG
+ if (gNoisyReflow) {
+ IndentBy(stdout, gNoiseIndent);
+ ListTag(stdout);
+ printf(": mark line %p dirty\n", static_cast<void*>(aLine.get()));
+ }
+#endif
+
+ // Mark previous line dirty if it's an inline line so that it can
+ // maybe pullup something from the line just affected.
+ // XXX We don't need to do this if aPrevLine ends in a break-after...
+ if (aLine != aLineList->front() && aLine->IsInline() &&
+ aLine.prev()->IsInline()) {
+ aLine.prev()->MarkDirty();
+ aLine.prev()->SetInvalidateTextRuns(true);
+#ifdef DEBUG
+ if (gNoisyReflow) {
+ IndentBy(stdout, gNoiseIndent);
+ ListTag(stdout);
+ printf(": mark prev-line %p dirty\n",
+ static_cast<void*>(aLine.prev().get()));
+ }
+#endif
+ }
+}
+
+/**
+ * Test whether lines are certain to be aligned left so that we can make
+ * resizing optimizations
+ */
+static inline bool IsAlignedLeft(StyleTextAlign aAlignment,
+ StyleDirection aDirection,
+ StyleUnicodeBidi aUnicodeBidi,
+ nsIFrame* aFrame) {
+ return aFrame->IsInSVGTextSubtree() || StyleTextAlign::Left == aAlignment ||
+ (((StyleTextAlign::Start == aAlignment &&
+ StyleDirection::Ltr == aDirection) ||
+ (StyleTextAlign::End == aAlignment &&
+ StyleDirection::Rtl == aDirection)) &&
+ aUnicodeBidi != StyleUnicodeBidi::Plaintext);
+}
+
+void nsBlockFrame::PrepareResizeReflow(BlockReflowState& aState) {
+ // See if we can try and avoid marking all the lines as dirty
+ // FIXME(emilio): This should be writing-mode aware, I guess.
+ bool tryAndSkipLines =
+ // The left content-edge must be a constant distance from the left
+ // border-edge.
+ !StylePadding()->mPadding.Get(eSideLeft).HasPercent();
+
+#ifdef DEBUG
+ if (gDisableResizeOpt) {
+ tryAndSkipLines = false;
+ }
+ if (gNoisyReflow) {
+ if (!tryAndSkipLines) {
+ IndentBy(stdout, gNoiseIndent);
+ ListTag(stdout);
+ printf(": marking all lines dirty: availISize=%d\n",
+ aState.mReflowInput.AvailableISize());
+ }
+ }
+#endif
+
+ if (tryAndSkipLines) {
+ WritingMode wm = aState.mReflowInput.GetWritingMode();
+ nscoord newAvailISize =
+ aState.mReflowInput.ComputedLogicalBorderPadding(wm).IStart(wm) +
+ aState.mReflowInput.ComputedISize();
+
+#ifdef DEBUG
+ if (gNoisyReflow) {
+ IndentBy(stdout, gNoiseIndent);
+ ListTag(stdout);
+ printf(": trying to avoid marking all lines dirty\n");
+ }
+#endif
+
+ for (LineIterator line = LinesBegin(), line_end = LinesEnd();
+ line != line_end; ++line) {
+ // We let child blocks make their own decisions the same
+ // way we are here.
+ bool isLastLine = line == mLines.back() && !GetNextInFlow();
+ if (line->IsBlock() || line->HasFloats() ||
+ (!isLastLine && !line->HasForcedLineBreakAfter()) ||
+ ((isLastLine || !line->IsLineWrapped())) ||
+ line->ResizeReflowOptimizationDisabled() ||
+ line->IsImpactedByFloat() || (line->IEnd() > newAvailISize)) {
+ line->MarkDirty();
+ }
+
+#ifdef REALLY_NOISY_REFLOW
+ if (!line->IsBlock()) {
+ printf("PrepareResizeReflow thinks line %p is %simpacted by floats\n",
+ line.get(), line->IsImpactedByFloat() ? "" : "not ");
+ }
+#endif
+#ifdef DEBUG
+ if (gNoisyReflow && !line->IsDirty()) {
+ IndentBy(stdout, gNoiseIndent + 1);
+ printf(
+ "skipped: line=%p next=%p %s %s%s%s clearTypeBefore/After=%s/%s "
+ "xmost=%d\n",
+ static_cast<void*>(line.get()),
+ static_cast<void*>(
+ (line.next() != LinesEnd() ? line.next().get() : nullptr)),
+ line->IsBlock() ? "block" : "inline",
+ line->HasForcedLineBreakAfter() ? "has-break-after " : "",
+ line->HasFloats() ? "has-floats " : "",
+ line->IsImpactedByFloat() ? "impacted " : "",
+ line->StyleClearToString(line->FloatClearTypeBefore()),
+ line->StyleClearToString(line->FloatClearTypeAfter()),
+ line->IEnd());
+ }
+#endif
+ }
+ } else {
+ // Mark everything dirty
+ for (auto& line : Lines()) {
+ line.MarkDirty();
+ }
+ }
+}
+
+//----------------------------------------
+
+/**
+ * Propagate reflow "damage" from from earlier lines to the current
+ * line. The reflow damage comes from the following sources:
+ * 1. The regions of float damage remembered during reflow.
+ * 2. The combination of nonzero |aDeltaBCoord| and any impact by a
+ * float, either the previous reflow or now.
+ *
+ * When entering this function, |aLine| is still at its old position and
+ * |aDeltaBCoord| indicates how much it will later be slid (assuming it
+ * doesn't get marked dirty and reflowed entirely).
+ */
+void nsBlockFrame::PropagateFloatDamage(BlockReflowState& aState,
+ nsLineBox* aLine,
+ nscoord aDeltaBCoord) {
+ nsFloatManager* floatManager = aState.FloatManager();
+ NS_ASSERTION(
+ (aState.mReflowInput.mParentReflowInput &&
+ aState.mReflowInput.mParentReflowInput->mFloatManager == floatManager) ||
+ aState.mReflowInput.mBlockDelta == 0,
+ "Bad block delta passed in");
+
+ // Check to see if there are any floats; if there aren't, there can't
+ // be any float damage
+ if (!floatManager->HasAnyFloats()) {
+ return;
+ }
+
+ // Check the damage region recorded in the float damage.
+ if (floatManager->HasFloatDamage()) {
+ // Need to check mBounds *and* mCombinedArea to find intersections
+ // with aLine's floats
+ nscoord lineBCoordBefore = aLine->BStart() + aDeltaBCoord;
+ nscoord lineBCoordAfter = lineBCoordBefore + aLine->BSize();
+ // Scrollable overflow should be sufficient for things that affect
+ // layout.
+ WritingMode wm = aState.mReflowInput.GetWritingMode();
+ nsSize containerSize = aState.ContainerSize();
+ LogicalRect overflow =
+ aLine->GetOverflowArea(OverflowType::Scrollable, wm, containerSize);
+ nscoord lineBCoordCombinedBefore = overflow.BStart(wm) + aDeltaBCoord;
+ nscoord lineBCoordCombinedAfter =
+ lineBCoordCombinedBefore + overflow.BSize(wm);
+
+ bool isDirty =
+ floatManager->IntersectsDamage(lineBCoordBefore, lineBCoordAfter) ||
+ floatManager->IntersectsDamage(lineBCoordCombinedBefore,
+ lineBCoordCombinedAfter);
+ if (isDirty) {
+ aLine->MarkDirty();
+ return;
+ }
+ }
+
+ // Check if the line is moving relative to the float manager
+ if (aDeltaBCoord + aState.mReflowInput.mBlockDelta != 0) {
+ if (aLine->IsBlock()) {
+ // Unconditionally reflow sliding blocks; we only really need to reflow
+ // if there's a float impacting this block, but the current float manager
+ // makes it difficult to check that. Therefore, we let the child block
+ // decide what it needs to reflow.
+ aLine->MarkDirty();
+ } else {
+ bool wasImpactedByFloat = aLine->IsImpactedByFloat();
+ nsFlowAreaRect floatAvailableSpace =
+ aState.GetFloatAvailableSpaceForBSize(aLine->BStart() + aDeltaBCoord,
+ aLine->BSize(), nullptr);
+
+#ifdef REALLY_NOISY_REFLOW
+ printf("nsBlockFrame::PropagateFloatDamage %p was = %d, is=%d\n", this,
+ wasImpactedByFloat, floatAvailableSpace.HasFloats());
+#endif
+
+ // Mark the line dirty if it was or is affected by a float
+ // We actually only really need to reflow if the amount of impact
+ // changes, but that's not straightforward to check
+ if (wasImpactedByFloat || floatAvailableSpace.HasFloats()) {
+ aLine->MarkDirty();
+ }
+ }
+ }
+}
+
+static bool LineHasClear(nsLineBox* aLine) {
+ return aLine->IsBlock()
+ ? (aLine->HasForcedLineBreakBefore() ||
+ aLine->mFirstChild->HasAnyStateBits(
+ NS_BLOCK_HAS_CLEAR_CHILDREN) ||
+ !nsBlockFrame::BlockCanIntersectFloats(aLine->mFirstChild))
+ : aLine->HasFloatClearTypeAfter();
+}
+
+/**
+ * Reparent a whole list of floats from aOldParent to this block. The
+ * floats might be taken from aOldParent's overflow list. They will be
+ * removed from the list. They end up appended to our mFloats list.
+ */
+void nsBlockFrame::ReparentFloats(nsIFrame* aFirstFrame,
+ nsBlockFrame* aOldParent,
+ bool aReparentSiblings) {
+ nsFrameList list;
+ aOldParent->CollectFloats(aFirstFrame, list, aReparentSiblings);
+ if (list.NotEmpty()) {
+ for (nsIFrame* f : list) {
+ MOZ_ASSERT(!f->HasAnyStateBits(NS_FRAME_IS_PUSHED_FLOAT),
+ "CollectFloats should've removed that bit");
+ ReparentFrame(f, aOldParent, this);
+ }
+ mFloats.AppendFrames(nullptr, std::move(list));
+ }
+}
+
+static void DumpLine(const BlockReflowState& aState, nsLineBox* aLine,
+ nscoord aDeltaBCoord, int32_t aDeltaIndent) {
+#ifdef DEBUG
+ if (nsBlockFrame::gNoisyReflow) {
+ nsRect ovis(aLine->InkOverflowRect());
+ nsRect oscr(aLine->ScrollableOverflowRect());
+ nsBlockFrame::IndentBy(stdout, nsBlockFrame::gNoiseIndent + aDeltaIndent);
+ printf(
+ "line=%p mBCoord=%d dirty=%s oldBounds={%d,%d,%d,%d} "
+ "oldoverflow-vis={%d,%d,%d,%d} oldoverflow-scr={%d,%d,%d,%d} "
+ "deltaBCoord=%d mPrevBEndMargin=%d childCount=%d\n",
+ static_cast<void*>(aLine), aState.mBCoord,
+ aLine->IsDirty() ? "yes" : "no", aLine->IStart(), aLine->BStart(),
+ aLine->ISize(), aLine->BSize(), ovis.x, ovis.y, ovis.width, ovis.height,
+ oscr.x, oscr.y, oscr.width, oscr.height, aDeltaBCoord,
+ aState.mPrevBEndMargin.get(), aLine->GetChildCount());
+ }
+#endif
+}
+
+static bool LinesAreEmpty(const nsLineList& aList) {
+ for (const auto& line : aList) {
+ if (!line.IsEmpty()) {
+ return false;
+ }
+ }
+ return true;
+}
+
+bool nsBlockFrame::ReflowDirtyLines(BlockReflowState& aState) {
+ bool keepGoing = true;
+ bool repositionViews = false; // should we really need this?
+ bool foundAnyClears = aState.mTrailingClearFromPIF != StyleClear::None;
+ bool willReflowAgain = false;
+ bool usedOverflowWrap = false;
+
+#ifdef DEBUG
+ if (gNoisyReflow) {
+ IndentBy(stdout, gNoiseIndent);
+ ListTag(stdout);
+ printf(": reflowing dirty lines");
+ printf(" computedISize=%d\n", aState.mReflowInput.ComputedISize());
+ }
+ AutoNoisyIndenter indent(gNoisyReflow);
+#endif
+
+ bool selfDirty = HasAnyStateBits(NS_FRAME_IS_DIRTY) ||
+ (aState.mReflowInput.IsBResize() &&
+ HasAnyStateBits(NS_FRAME_CONTAINS_RELATIVE_BSIZE));
+
+ // Reflow our last line if our availableBSize has increased
+ // so that we (and our last child) pull up content as necessary
+ if (aState.mReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE &&
+ GetNextInFlow() &&
+ aState.mReflowInput.AvailableBSize() >
+ GetLogicalSize().BSize(aState.mReflowInput.GetWritingMode())) {
+ LineIterator lastLine = LinesEnd();
+ if (lastLine != LinesBegin()) {
+ --lastLine;
+ lastLine->MarkDirty();
+ }
+ }
+ // the amount by which we will slide the current line if it is not
+ // dirty
+ nscoord deltaBCoord = 0;
+
+ // whether we did NOT reflow the previous line and thus we need to
+ // recompute the carried out margin before the line if we want to
+ // reflow it or if its previous margin is dirty
+ bool needToRecoverState = false;
+ // Float continuations were reflowed in ReflowPushedFloats
+ bool reflowedFloat =
+ mFloats.NotEmpty() &&
+ mFloats.FirstChild()->HasAnyStateBits(NS_FRAME_IS_PUSHED_FLOAT);
+ bool lastLineMovedUp = false;
+ // We save up information about BR-clearance here
+ StyleClear inlineFloatClearType = aState.mTrailingClearFromPIF;
+
+ LineIterator line = LinesBegin(), line_end = LinesEnd();
+
+ // Determine if children of this frame could have breaks between them for
+ // page names.
+ //
+ // We need to check for paginated layout, the named-page pref, and if the
+ // available block-size is constrained.
+ //
+ // Note that we need to check for paginated layout as named-pages are only
+ // used during paginated reflow. We need to additionally check for
+ // unconstrained block-size to avoid introducing fragmentation breaks during
+ // "measuring" reflows within an overall paginated reflow, and to avoid
+ // fragmentation in monolithic containers like 'inline-block'.
+ //
+ // Because we can only break for named pages using Class A breakpoints, we
+ // also need to check that the block flow direction of the containing frame
+ // of these items (which is this block) is parallel to that of this page.
+ // See: https://www.w3.org/TR/css-break-3/#btw-blocks
+ const nsPresContext* const presCtx = aState.mPresContext;
+ const bool canBreakForPageNames =
+ aState.mReflowInput.mFlags.mCanHaveClassABreakpoints &&
+ aState.mReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE &&
+ presCtx->GetPresShell()->GetRootFrame()->GetWritingMode().IsVertical() ==
+ GetWritingMode().IsVertical();
+
+ // ReflowInput.mFlags.mCanHaveClassABreakpoints should respect the named
+ // pages pref and presCtx->IsPaginated, so we did not explicitly check these
+ // above when setting canBreakForPageNames.
+ if (canBreakForPageNames) {
+ MOZ_ASSERT(presCtx->IsPaginated(),
+ "canBreakForPageNames should not be set during non-paginated "
+ "reflow");
+ }
+
+ // Reflow the lines that are already ours
+ for (; line != line_end; ++line, aState.AdvanceToNextLine()) {
+ DumpLine(aState, line, deltaBCoord, 0);
+#ifdef DEBUG
+ AutoNoisyIndenter indent2(gNoisyReflow);
+#endif
+
+ if (selfDirty) {
+ line->MarkDirty();
+ }
+
+ // This really sucks, but we have to look inside any blocks that have clear
+ // elements inside them.
+ // XXX what can we do smarter here?
+ if (!line->IsDirty() && line->IsBlock() &&
+ line->mFirstChild->HasAnyStateBits(NS_BLOCK_HAS_CLEAR_CHILDREN)) {
+ line->MarkDirty();
+ }
+
+ nsIFrame* floatAvoidingBlock = nullptr;
+ if (line->IsBlock() &&
+ !nsBlockFrame::BlockCanIntersectFloats(line->mFirstChild)) {
+ floatAvoidingBlock = line->mFirstChild;
+ }
+
+ // We have to reflow the line if it's a block whose clearance
+ // might have changed, so detect that.
+ if (!line->IsDirty() &&
+ (line->HasForcedLineBreakBefore() || floatAvoidingBlock)) {
+ nscoord curBCoord = aState.mBCoord;
+ // See where we would be after applying any clearance due to
+ // BRs.
+ if (inlineFloatClearType != StyleClear::None) {
+ std::tie(curBCoord, std::ignore) =
+ aState.ClearFloats(curBCoord, inlineFloatClearType);
+ }
+
+ auto [newBCoord, result] = aState.ClearFloats(
+ curBCoord, line->FloatClearTypeBefore(), floatAvoidingBlock);
+
+ if (line->HasClearance()) {
+ // Reflow the line if it might not have clearance anymore.
+ if (result == ClearFloatsResult::BCoordNoChange
+ // aState.mBCoord is the clearance point which should be the
+ // block-start border-edge of the block frame. If sliding the
+ // block by deltaBCoord isn't going to put it in the predicted
+ // position, then we'd better reflow the line.
+ || newBCoord != line->BStart() + deltaBCoord) {
+ line->MarkDirty();
+ }
+ } else {
+ // Reflow the line if the line might have clearance now.
+ if (result != ClearFloatsResult::BCoordNoChange) {
+ line->MarkDirty();
+ }
+ }
+ }
+
+ // We might have to reflow a line that is after a clearing BR.
+ if (inlineFloatClearType != StyleClear::None) {
+ std::tie(aState.mBCoord, std::ignore) =
+ aState.ClearFloats(aState.mBCoord, inlineFloatClearType);
+ if (aState.mBCoord != line->BStart() + deltaBCoord) {
+ // SlideLine is not going to put the line where the clearance
+ // put it. Reflow the line to be sure.
+ line->MarkDirty();
+ }
+ inlineFloatClearType = StyleClear::None;
+ }
+
+ bool previousMarginWasDirty = line->IsPreviousMarginDirty();
+ if (previousMarginWasDirty) {
+ // If the previous margin is dirty, reflow the current line
+ line->MarkDirty();
+ line->ClearPreviousMarginDirty();
+ } else if (aState.ContentBSize() != NS_UNCONSTRAINEDSIZE) {
+ const nscoord scrollableOverflowBEnd =
+ LogicalRect(line->mWritingMode, line->ScrollableOverflowRect(),
+ line->mContainerSize)
+ .BEnd(line->mWritingMode);
+ if (scrollableOverflowBEnd + deltaBCoord > aState.ContentBEnd()) {
+ // Lines that aren't dirty but get slid past our available block-size
+ // constraint must be reflowed.
+ line->MarkDirty();
+ }
+ }
+
+ if (!line->IsDirty()) {
+ const bool isPaginated =
+ // Last column can be reflowed unconstrained during column balancing.
+ // Hence the additional NS_FRAME_HAS_MULTI_COLUMN_ANCESTOR bit check
+ // as a fail-safe fallback.
+ aState.mReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE ||
+ HasAnyStateBits(NS_FRAME_HAS_MULTI_COLUMN_ANCESTOR) ||
+ // Table can also be reflowed unconstrained during printing.
+ aState.mPresContext->IsPaginated();
+ if (isPaginated) {
+ // We are in a paginated context, i.e. in columns or pages.
+ const bool mayContainFloats =
+ line->IsBlock() || line->HasFloats() || line->HadFloatPushed();
+ if (mayContainFloats) {
+ // The following if-else conditions check whether this line -- which
+ // might have floats in its subtree, or has floats as direct children,
+ // or had floats pushed -- needs to be reflowed.
+ if (deltaBCoord != 0 || aState.mReflowInput.IsBResize()) {
+ // The distance to the block-end edge might have changed. Reflow the
+ // line both because the breakpoints within its floats may have
+ // changed and because we might have to push/pull the floats in
+ // their entirety.
+ line->MarkDirty();
+ } else if (HasPushedFloats()) {
+ // We had pushed floats which haven't been drained by our
+ // next-in-flow, which means our parent is currently reflowing us
+ // again due to clearance without creating a next-in-flow for us.
+ // Reflow the line to redo the floats split logic to correctly set
+ // our reflow status.
+ line->MarkDirty();
+ } else if (aState.mReflowInput.mFlags.mMustReflowPlaceholders) {
+ // Reflow the line (that may containing a float's placeholder frame)
+ // if our parent tells us to do so.
+ line->MarkDirty();
+ } else if (aState.mReflowInput.mFlags.mMovedBlockFragments) {
+ // Our parent's line containing us moved to a different fragment.
+ // Reflow the line because the decision about whether the float fits
+ // may be different in a different fragment.
+ line->MarkDirty();
+ }
+ }
+ }
+ }
+
+ if (!line->IsDirty()) {
+ // See if there's any reflow damage that requires that we mark the
+ // line dirty.
+ PropagateFloatDamage(aState, line, deltaBCoord);
+ }
+
+ // If the container size has changed, reset mContainerSize. If the
+ // line's writing mode is not ltr, or if the line is not left-aligned, also
+ // mark the line dirty.
+ if (aState.ContainerSize() != line->mContainerSize) {
+ line->mContainerSize = aState.ContainerSize();
+
+ const bool isLastLine = line == mLines.back() && !GetNextInFlow();
+ const auto align = isLastLine ? StyleText()->TextAlignForLastLine()
+ : StyleText()->mTextAlign;
+ if (line->mWritingMode.IsVertical() || line->mWritingMode.IsBidiRTL() ||
+ !IsAlignedLeft(align, StyleVisibility()->mDirection,
+ StyleTextReset()->mUnicodeBidi, this)) {
+ line->MarkDirty();
+ }
+ }
+
+ // Check for a page break caused by CSS named pages.
+ //
+ // We should break for named pages when two frames meet at a class A
+ // breakpoint, where the first frame has a different end page value to the
+ // second frame's start page value. canBreakForPageNames is true iff
+ // children of this frame can form class A breakpoints, and that we are not
+ // in a measurement reflow or in a monolithic container such as
+ // 'inline-block'.
+ //
+ // We specifically do not want to cause a page-break for named pages when
+ // we are at the top of a page. This would otherwise happen when the
+ // previous sibling is an nsPageBreakFrame, or all previous siblings on the
+ // current page are zero-height. The latter may not be per-spec, but is
+ // compatible with Chrome's implementation of named pages.
+ const nsAtom* nextPageName = nullptr;
+ bool shouldBreakForPageName = false;
+ if (canBreakForPageNames && (!aState.mReflowInput.mFlags.mIsTopOfPage ||
+ !aState.IsAdjacentWithBStart())) {
+ const nsIFrame* const frame = line->mFirstChild;
+ if (!frame->IsPlaceholderFrame() && !frame->IsPageBreakFrame()) {
+ nextPageName = frame->GetStartPageValue();
+ // Walk back to the last frame that isn't a placeholder.
+ const nsIFrame* prevFrame = frame->GetPrevSibling();
+ while (prevFrame && prevFrame->IsPlaceholderFrame()) {
+ prevFrame = prevFrame->GetPrevSibling();
+ }
+ if (prevFrame && prevFrame->GetEndPageValue() != nextPageName) {
+ shouldBreakForPageName = true;
+ line->MarkDirty();
+ }
+ }
+ }
+
+ if (needToRecoverState && line->IsDirty()) {
+ // We need to reconstruct the block-end margin only if we didn't
+ // reflow the previous line and we do need to reflow (or repair
+ // the block-start position of) the next line.
+ aState.ReconstructMarginBefore(line);
+ }
+
+ bool reflowedPrevLine = !needToRecoverState;
+ if (needToRecoverState) {
+ needToRecoverState = false;
+
+ // Update aState.mPrevChild as if we had reflowed all of the frames in
+ // this line.
+ if (line->IsDirty()) {
+ NS_ASSERTION(
+ line->mFirstChild->GetPrevSibling() == line.prev()->LastChild(),
+ "unexpected line frames");
+ aState.mPrevChild = line->mFirstChild->GetPrevSibling();
+ }
+ }
+
+ // Now repair the line and update |aState.mBCoord| by calling
+ // |ReflowLine| or |SlideLine|.
+ // If we're going to reflow everything again, then no need to reflow
+ // the dirty line ... unless the line has floats, in which case we'd
+ // better reflow it now to refresh its float cache, which may contain
+ // dangling frame pointers! Ugh! This reflow of the line may be
+ // incorrect because we skipped reflowing previous lines (e.g., floats
+ // may be placed incorrectly), but that's OK because we'll mark the
+ // line dirty below under "if (aState.mReflowInput.mDiscoveredClearance..."
+ if (line->IsDirty() && (line->HasFloats() || !willReflowAgain)) {
+ lastLineMovedUp = true;
+
+ bool maybeReflowingForFirstTime =
+ line->IStart() == 0 && line->BStart() == 0 && line->ISize() == 0 &&
+ line->BSize() == 0;
+
+ // Compute the dirty lines "before" BEnd, after factoring in
+ // the running deltaBCoord value - the running value is implicit in
+ // aState.mBCoord.
+ nscoord oldB = line->BStart();
+ nscoord oldBMost = line->BEnd();
+
+ NS_ASSERTION(!willReflowAgain || !line->IsBlock(),
+ "Don't reflow blocks while willReflowAgain is true, reflow "
+ "of block abs-pos children depends on this");
+
+ if (shouldBreakForPageName) {
+ // Immediately fragment for page-name. It is possible we could break
+ // out of the loop right here, but this should make it more similar to
+ // what happens when reflow causes fragmentation.
+ PushTruncatedLine(aState, line, &keepGoing);
+ PresShell()->FrameConstructor()->SetNextPageContentFramePageName(
+ nextPageName ? nextPageName : GetAutoPageValue());
+ } else {
+ // Reflow the dirty line. If it's an incremental reflow, then force
+ // it to invalidate the dirty area if necessary
+ usedOverflowWrap |= ReflowLine(aState, line, &keepGoing);
+ }
+
+ if (aState.mReflowInput.WillReflowAgainForClearance()) {
+ line->MarkDirty();
+ willReflowAgain = true;
+ // Note that once we've entered this state, every line that gets here
+ // (e.g. because it has floats) gets marked dirty and reflowed again.
+ // in the next pass. This is important, see above.
+ }
+
+ if (line->HasFloats()) {
+ reflowedFloat = true;
+ }
+
+ if (!keepGoing) {
+ DumpLine(aState, line, deltaBCoord, -1);
+ if (0 == line->GetChildCount()) {
+ DeleteLine(aState, line, line_end);
+ }
+ break;
+ }
+
+ // Test to see whether the margin that should be carried out
+ // to the next line (NL) might have changed. In ReflowBlockFrame
+ // we call nextLine->MarkPreviousMarginDirty if the block's
+ // actual carried-out block-end margin changed. So here we only
+ // need to worry about the following effects:
+ // 1) the line was just created, and it might now be blocking
+ // a carried-out block-end margin from previous lines that
+ // used to reach NL from reaching NL
+ // 2) the line used to be empty, and is now not empty,
+ // thus blocking a carried-out block-end margin from previous lines
+ // that used to reach NL from reaching NL
+ // 3) the line wasn't empty, but now is, so a carried-out
+ // block-end margin from previous lines that didn't used to reach NL
+ // now does
+ // 4) the line might have changed in a way that affects NL's
+ // ShouldApplyBStartMargin decision. The three things that matter
+ // are the line's emptiness, its adjacency to the block-start edge of the
+ // block, and whether it has clearance (the latter only matters if the
+ // block was and is adjacent to the block-start and empty).
+ //
+ // If the line is empty now, we can't reliably tell if the line was empty
+ // before, so we just assume it was and do
+ // nextLine->MarkPreviousMarginDirty. This means the checks in 4) are
+ // redundant; if the line is empty now we don't need to check 4), but if
+ // the line is not empty now and we're sure it wasn't empty before, any
+ // adjacency and clearance changes are irrelevant to the result of
+ // nextLine->ShouldApplyBStartMargin.
+ if (line.next() != LinesEnd()) {
+ bool maybeWasEmpty = oldB == line.next()->BStart();
+ bool isEmpty = line->CachedIsEmpty();
+ if (maybeReflowingForFirstTime /*1*/ ||
+ (isEmpty || maybeWasEmpty) /*2/3/4*/) {
+ line.next()->MarkPreviousMarginDirty();
+ // since it's marked dirty, nobody will care about |deltaBCoord|
+ }
+ }
+
+ // If the line was just reflowed for the first time, then its
+ // old mBounds cannot be trusted so this deltaBCoord computation is
+ // bogus. But that's OK because we just did
+ // MarkPreviousMarginDirty on the next line which will force it
+ // to be reflowed, so this computation of deltaBCoord will not be
+ // used.
+ deltaBCoord = line->BEnd() - oldBMost;
+
+ // Now do an interrupt check. We want to do this only in the case when we
+ // actually reflow the line, so that if we get back in here we'll get
+ // further on the reflow before interrupting.
+ aState.mPresContext->CheckForInterrupt(this);
+ } else {
+ aState.mOverflowTracker->Skip(line->mFirstChild, aState.mReflowStatus);
+ // Nop except for blocks (we don't create overflow container
+ // continuations for any inlines atm), so only checking mFirstChild
+ // is enough
+
+ lastLineMovedUp = deltaBCoord < 0;
+
+ if (deltaBCoord != 0) {
+ SlideLine(aState, line, deltaBCoord);
+ } else {
+ repositionViews = true;
+ }
+
+ NS_ASSERTION(!line->IsDirty() || !line->HasFloats(),
+ "Possibly stale float cache here!");
+ if (willReflowAgain && line->IsBlock()) {
+ // If we're going to reflow everything again, and this line is a block,
+ // then there is no need to recover float state. The line may contain
+ // other lines with floats, but in that case RecoverStateFrom would only
+ // add floats to the float manager. We don't need to do that because
+ // everything's going to get reflowed again "for real". Calling
+ // RecoverStateFrom in this situation could be lethal because the
+ // block's descendant lines may have float caches containing dangling
+ // frame pointers. Ugh!
+ // If this line is inline, then we need to recover its state now
+ // to make sure that we don't forget to move its floats by deltaBCoord.
+ } else {
+ // XXX EVIL O(N^2) EVIL
+ aState.RecoverStateFrom(line, deltaBCoord);
+ }
+
+ // Keep mBCoord up to date in case we're propagating reflow damage
+ // and also because our final height may depend on it. If the
+ // line is inlines, then only update mBCoord if the line is not
+ // empty, because that's what PlaceLine does. (Empty blocks may
+ // want to update mBCoord, e.g. if they have clearance.)
+ if (line->IsBlock() || !line->CachedIsEmpty()) {
+ aState.mBCoord = line->BEnd();
+ }
+
+ needToRecoverState = true;
+
+ if (reflowedPrevLine && !line->IsBlock() &&
+ aState.mPresContext->HasPendingInterrupt()) {
+ // Need to make sure to pull overflows from any prev-in-flows
+ for (nsIFrame* inlineKid = line->mFirstChild; inlineKid;
+ inlineKid = inlineKid->PrincipalChildList().FirstChild()) {
+ inlineKid->PullOverflowsFromPrevInFlow();
+ }
+ }
+ }
+
+ // Record if we need to clear floats before reflowing the next
+ // line. Note that inlineFloatClearType will be handled and
+ // cleared before the next line is processed, so there is no
+ // need to combine break types here.
+ if (line->HasFloatClearTypeAfter()) {
+ inlineFloatClearType = line->FloatClearTypeAfter();
+ }
+
+ if (LineHasClear(line.get())) {
+ foundAnyClears = true;
+ }
+
+ DumpLine(aState, line, deltaBCoord, -1);
+
+ if (aState.mPresContext->HasPendingInterrupt()) {
+ willReflowAgain = true;
+ // Another option here might be to leave |line| clean if
+ // !HasPendingInterrupt() before the CheckForInterrupt() call, since in
+ // that case the line really did reflow as it should have. Not sure
+ // whether that would be safe, so doing this for now instead. Also not
+ // sure whether we really want to mark all lines dirty after an
+ // interrupt, but until we get better at propagating float damage we
+ // really do need to do it this way; see comments inside MarkLineDirty.
+ MarkLineDirtyForInterrupt(line);
+ }
+ }
+
+ // Handle BR-clearance from the last line of the block
+ if (inlineFloatClearType != StyleClear::None) {
+ std::tie(aState.mBCoord, std::ignore) =
+ aState.ClearFloats(aState.mBCoord, inlineFloatClearType);
+ }
+
+ if (needToRecoverState) {
+ // Is this expensive?
+ aState.ReconstructMarginBefore(line);
+
+ // Update aState.mPrevChild as if we had reflowed all of the frames in
+ // the last line.
+ NS_ASSERTION(line == line_end || line->mFirstChild->GetPrevSibling() ==
+ line.prev()->LastChild(),
+ "unexpected line frames");
+ aState.mPrevChild = line == line_end ? mFrames.LastChild()
+ : line->mFirstChild->GetPrevSibling();
+ }
+
+ // Should we really have to do this?
+ if (repositionViews) {
+ nsContainerFrame::PlaceFrameView(this);
+ }
+
+ // We can skip trying to pull up the next line if our height is constrained
+ // (so we can report being incomplete) and there is no next in flow or we
+ // were told not to or we know it will be futile, i.e.,
+ // -- the next in flow is not changing
+ // -- and we cannot have added more space for its first line to be
+ // pulled up into,
+ // -- it's an incremental reflow of a descendant
+ // -- and we didn't reflow any floats (so the available space
+ // didn't change)
+ // -- my chain of next-in-flows either has no first line, or its first
+ // line isn't dirty.
+ bool heightConstrained =
+ aState.mReflowInput.AvailableBSize() != NS_UNCONSTRAINEDSIZE;
+ bool skipPull = willReflowAgain && heightConstrained;
+ if (!skipPull && heightConstrained && aState.mNextInFlow &&
+ (aState.mReflowInput.mFlags.mNextInFlowUntouched && !lastLineMovedUp &&
+ !HasAnyStateBits(NS_FRAME_IS_DIRTY) && !reflowedFloat)) {
+ // We'll place lineIter at the last line of this block, so that
+ // nsBlockInFlowLineIterator::Next() will take us to the first
+ // line of my next-in-flow-chain. (But first, check that I
+ // have any lines -- if I don't, just bail out of this
+ // optimization.)
+ LineIterator lineIter = this->LinesEnd();
+ if (lineIter != this->LinesBegin()) {
+ lineIter--; // I have lines; step back from dummy iterator to last line.
+ nsBlockInFlowLineIterator bifLineIter(this, lineIter);
+
+ // Check for next-in-flow-chain's first line.
+ // (First, see if there is such a line, and second, see if it's clean)
+ if (!bifLineIter.Next() || !bifLineIter.GetLine()->IsDirty()) {
+ skipPull = true;
+ }
+ }
+ }
+
+ if (skipPull && aState.mNextInFlow) {
+ NS_ASSERTION(heightConstrained, "Height should be constrained here\n");
+ if (aState.mNextInFlow->IsTrueOverflowContainer()) {
+ aState.mReflowStatus.SetOverflowIncomplete();
+ } else {
+ aState.mReflowStatus.SetIncomplete();
+ }
+ }
+
+ if (!skipPull && aState.mNextInFlow) {
+ // Pull data from a next-in-flow if there's still room for more
+ // content here.
+ while (keepGoing && aState.mNextInFlow) {
+ // Grab first line from our next-in-flow
+ nsBlockFrame* nextInFlow = aState.mNextInFlow;
+ nsLineBox* pulledLine;
+ nsFrameList pulledFrames;
+ if (!nextInFlow->mLines.empty()) {
+ RemoveFirstLine(nextInFlow->mLines, nextInFlow->mFrames, &pulledLine,
+ &pulledFrames);
+ } else {
+ // Grab an overflow line if there are any
+ FrameLines* overflowLines = nextInFlow->GetOverflowLines();
+ if (!overflowLines) {
+ aState.mNextInFlow =
+ static_cast<nsBlockFrame*>(nextInFlow->GetNextInFlow());
+ continue;
+ }
+ bool last =
+ RemoveFirstLine(overflowLines->mLines, overflowLines->mFrames,
+ &pulledLine, &pulledFrames);
+ if (last) {
+ nextInFlow->DestroyOverflowLines();
+ }
+ }
+
+ if (pulledFrames.IsEmpty()) {
+ // The line is empty. Try the next one.
+ NS_ASSERTION(
+ pulledLine->GetChildCount() == 0 && !pulledLine->mFirstChild,
+ "bad empty line");
+ nextInFlow->FreeLineBox(pulledLine);
+ continue;
+ }
+
+ if (nextInFlow->MaybeHasLineCursor()) {
+ if (pulledLine == nextInFlow->GetLineCursorForDisplay()) {
+ nextInFlow->ClearLineCursorForDisplay();
+ }
+ if (pulledLine == nextInFlow->GetLineCursorForQuery()) {
+ nextInFlow->ClearLineCursorForQuery();
+ }
+ }
+ ReparentFrames(pulledFrames, nextInFlow, this);
+ pulledLine->SetMovedFragments();
+
+ NS_ASSERTION(pulledFrames.LastChild() == pulledLine->LastChild(),
+ "Unexpected last frame");
+ NS_ASSERTION(aState.mPrevChild || mLines.empty(),
+ "should have a prevchild here");
+ NS_ASSERTION(aState.mPrevChild == mFrames.LastChild(),
+ "Incorrect aState.mPrevChild before inserting line at end");
+
+ // Shift pulledLine's frames into our mFrames list.
+ mFrames.AppendFrames(nullptr, std::move(pulledFrames));
+
+ // Add line to our line list, and set its last child as our new prev-child
+ line = mLines.before_insert(LinesEnd(), pulledLine);
+ aState.mPrevChild = mFrames.LastChild();
+
+ // Reparent floats whose placeholders are in the line.
+ ReparentFloats(pulledLine->mFirstChild, nextInFlow, true);
+
+ DumpLine(aState, pulledLine, deltaBCoord, 0);
+#ifdef DEBUG
+ AutoNoisyIndenter indent2(gNoisyReflow);
+#endif
+
+ if (aState.mPresContext->HasPendingInterrupt()) {
+ MarkLineDirtyForInterrupt(line);
+ } else {
+ // Now reflow it and any lines that it makes during it's reflow
+ // (we have to loop here because reflowing the line may cause a new
+ // line to be created; see SplitLine's callers for examples of
+ // when this happens).
+ while (line != LinesEnd()) {
+ usedOverflowWrap |= ReflowLine(aState, line, &keepGoing);
+
+ if (aState.mReflowInput.WillReflowAgainForClearance()) {
+ line->MarkDirty();
+ keepGoing = false;
+ aState.mReflowStatus.SetIncomplete();
+ break;
+ }
+
+ DumpLine(aState, line, deltaBCoord, -1);
+ if (!keepGoing) {
+ if (0 == line->GetChildCount()) {
+ DeleteLine(aState, line, line_end);
+ }
+ break;
+ }
+
+ if (LineHasClear(line.get())) {
+ foundAnyClears = true;
+ }
+
+ if (aState.mPresContext->CheckForInterrupt(this)) {
+ MarkLineDirtyForInterrupt(line);
+ break;
+ }
+
+ // If this is an inline frame then its time to stop
+ ++line;
+ aState.AdvanceToNextLine();
+ }
+ }
+ }
+
+ if (aState.mReflowStatus.IsIncomplete()) {
+ aState.mReflowStatus.SetNextInFlowNeedsReflow();
+ } // XXXfr shouldn't set this flag when nextinflow has no lines
+ }
+
+ // Handle an odd-ball case: a list-item with no lines
+ if (mLines.empty() && HasOutsideMarker()) {
+ ReflowOutput metrics(aState.mReflowInput);
+ nsIFrame* marker = GetOutsideMarker();
+ WritingMode wm = aState.mReflowInput.GetWritingMode();
+ ReflowOutsideMarker(
+ marker, aState, metrics,
+ aState.mReflowInput.ComputedPhysicalBorderPadding().top);
+ NS_ASSERTION(!MarkerIsEmpty() || metrics.BSize(wm) == 0,
+ "empty ::marker frame took up space");
+
+ if (!MarkerIsEmpty()) {
+ // There are no lines so we have to fake up some y motion so that
+ // we end up with *some* height.
+ // (Note: if we're layout-contained, we have to be sure to leave our
+ // ReflowOutput's BlockStartAscent() (i.e. the baseline) untouched,
+ // because layout-contained frames have no baseline.)
+ if (!aState.mReflowInput.mStyleDisplay->IsContainLayout() &&
+ metrics.BlockStartAscent() == ReflowOutput::ASK_FOR_BASELINE) {
+ nscoord ascent;
+ WritingMode wm = aState.mReflowInput.GetWritingMode();
+ if (nsLayoutUtils::GetFirstLineBaseline(wm, marker, &ascent)) {
+ metrics.SetBlockStartAscent(ascent);
+ } else {
+ metrics.SetBlockStartAscent(metrics.BSize(wm));
+ }
+ }
+
+ RefPtr<nsFontMetrics> fm =
+ nsLayoutUtils::GetInflatedFontMetricsForFrame(this);
+
+ nscoord minAscent = nsLayoutUtils::GetCenteredFontBaseline(
+ fm, aState.mMinLineHeight, wm.IsLineInverted());
+ nscoord minDescent = aState.mMinLineHeight - minAscent;
+
+ aState.mBCoord +=
+ std::max(minAscent, metrics.BlockStartAscent()) +
+ std::max(minDescent, metrics.BSize(wm) - metrics.BlockStartAscent());
+
+ nscoord offset = minAscent - metrics.BlockStartAscent();
+ if (offset > 0) {
+ marker->SetRect(marker->GetRect() + nsPoint(0, offset));
+ }
+ }
+ }
+
+ if (LinesAreEmpty(mLines) && ShouldHaveLineIfEmpty()) {
+ aState.mBCoord += aState.mMinLineHeight;
+ }
+
+ if (foundAnyClears) {
+ AddStateBits(NS_BLOCK_HAS_CLEAR_CHILDREN);
+ } else {
+ RemoveStateBits(NS_BLOCK_HAS_CLEAR_CHILDREN);
+ }
+
+#ifdef DEBUG
+ VerifyLines(true);
+ VerifyOverflowSituation();
+ if (gNoisyReflow) {
+ IndentBy(stdout, gNoiseIndent - 1);
+ ListTag(stdout);
+ printf(": done reflowing dirty lines (status=%s)\n",
+ ToString(aState.mReflowStatus).c_str());
+ }
+#endif
+
+ return usedOverflowWrap;
+}
+
+void nsBlockFrame::MarkLineDirtyForInterrupt(nsLineBox* aLine) {
+ aLine->MarkDirty();
+
+ // Just checking NS_FRAME_IS_DIRTY is ok, because we've already
+ // marked the lines that need to be marked dirty based on our
+ // vertical resize stuff. So we'll definitely reflow all those kids;
+ // the only question is how they should behave.
+ if (HasAnyStateBits(NS_FRAME_IS_DIRTY)) {
+ // Mark all our child frames dirty so we make sure to reflow them
+ // later.
+ int32_t n = aLine->GetChildCount();
+ for (nsIFrame* f = aLine->mFirstChild; n > 0;
+ f = f->GetNextSibling(), --n) {
+ f->MarkSubtreeDirty();
+ }
+ // And mark all the floats whose reflows we might be skipping dirty too.
+ if (aLine->HasFloats()) {
+ for (nsIFrame* f : aLine->Floats()) {
+ f->MarkSubtreeDirty();
+ }
+ }
+ } else {
+ // Dirty all the descendant lines of block kids to handle float damage,
+ // since our nsFloatManager will go away by the next time we're reflowing.
+ // XXXbz Can we do something more like what PropagateFloatDamage does?
+ // Would need to sort out the exact business with mBlockDelta for that....
+ // This marks way too much dirty. If we ever make this better, revisit
+ // which lines we mark dirty in the interrupt case in ReflowDirtyLines.
+ nsBlockFrame* bf = do_QueryFrame(aLine->mFirstChild);
+ if (bf) {
+ MarkAllDescendantLinesDirty(bf);
+ }
+ }
+}
+
+void nsBlockFrame::DeleteLine(BlockReflowState& aState,
+ nsLineList::iterator aLine,
+ nsLineList::iterator aLineEnd) {
+ MOZ_ASSERT(0 == aLine->GetChildCount(), "can't delete !empty line");
+ if (0 == aLine->GetChildCount()) {
+ NS_ASSERTION(aState.mCurrentLine == aLine,
+ "using function more generally than designed, "
+ "but perhaps OK now");
+ nsLineBox* line = aLine;
+ aLine = mLines.erase(aLine);
+ FreeLineBox(line);
+ // Mark the previous margin of the next line dirty since we need to
+ // recompute its top position.
+ if (aLine != aLineEnd) {
+ aLine->MarkPreviousMarginDirty();
+ }
+ }
+}
+
+/**
+ * Reflow a line. The line will either contain a single block frame
+ * or contain 1 or more inline frames. aKeepReflowGoing indicates
+ * whether or not the caller should continue to reflow more lines.
+ * Returns true if the reflow used an overflow-wrap breakpoint.
+ */
+bool nsBlockFrame::ReflowLine(BlockReflowState& aState, LineIterator aLine,
+ bool* aKeepReflowGoing) {
+ MOZ_ASSERT(aLine->GetChildCount(), "reflowing empty line");
+
+ // Setup the line-layout for the new line
+ aState.mCurrentLine = aLine;
+ aLine->ClearDirty();
+ aLine->InvalidateCachedIsEmpty();
+ aLine->ClearHadFloatPushed();
+
+ // If this line contains a single block that is hidden by `content-visibility`
+ // don't reflow the line. If this line contains inlines and the first one is
+ // hidden by `content-visibility`, all of them are, so avoid reflow in that
+ // case as well.
+ // For frames that own anonymous children, even the first child is hidden by
+ // `content-visibility`, there could be some anonymous children need reflow,
+ // so we don't skip reflow this line.
+ nsIFrame* firstChild = aLine->mFirstChild;
+ if (firstChild->IsHiddenByContentVisibilityOfInFlowParentForLayout() &&
+ !HasAnyStateBits(NS_FRAME_OWNS_ANON_BOXES)) {
+ return false;
+ }
+
+ // Now that we know what kind of line we have, reflow it
+ bool usedOverflowWrap = false;
+ if (aLine->IsBlock()) {
+ ReflowBlockFrame(aState, aLine, aKeepReflowGoing);
+ } else {
+ aLine->SetLineWrapped(false);
+ usedOverflowWrap = ReflowInlineFrames(aState, aLine, aKeepReflowGoing);
+
+ // Store the line's float edges for overflow marker analysis if needed.
+ aLine->ClearFloatEdges();
+ if (aState.mFlags.mCanHaveOverflowMarkers) {
+ WritingMode wm = aLine->mWritingMode;
+ nsFlowAreaRect r = aState.GetFloatAvailableSpaceForBSize(
+ aLine->BStart(), aLine->BSize(), nullptr);
+ if (r.HasFloats()) {
+ LogicalRect so = aLine->GetOverflowArea(OverflowType::Scrollable, wm,
+ aLine->mContainerSize);
+ nscoord s = r.mRect.IStart(wm);
+ nscoord e = r.mRect.IEnd(wm);
+ if (so.IEnd(wm) > e || so.IStart(wm) < s) {
+ // This line is overlapping a float - store the edges marking the area
+ // between the floats for text-overflow analysis.
+ aLine->SetFloatEdges(s, e);
+ }
+ }
+ }
+ }
+
+ aLine->ClearMovedFragments();
+
+ return usedOverflowWrap;
+}
+
+nsIFrame* nsBlockFrame::PullFrame(BlockReflowState& aState,
+ LineIterator aLine) {
+ // First check our remaining lines.
+ if (LinesEnd() != aLine.next()) {
+ return PullFrameFrom(aLine, this, aLine.next());
+ }
+
+ NS_ASSERTION(
+ !GetOverflowLines(),
+ "Our overflow lines should have been removed at the start of reflow");
+
+ // Try each next-in-flow.
+ nsBlockFrame* nextInFlow = aState.mNextInFlow;
+ while (nextInFlow) {
+ if (nextInFlow->mLines.empty()) {
+ nextInFlow->DrainSelfOverflowList();
+ }
+ if (!nextInFlow->mLines.empty()) {
+ return PullFrameFrom(aLine, nextInFlow, nextInFlow->mLines.begin());
+ }
+ nextInFlow = static_cast<nsBlockFrame*>(nextInFlow->GetNextInFlow());
+ aState.mNextInFlow = nextInFlow;
+ }
+
+ return nullptr;
+}
+
+nsIFrame* nsBlockFrame::PullFrameFrom(nsLineBox* aLine,
+ nsBlockFrame* aFromContainer,
+ nsLineList::iterator aFromLine) {
+ nsLineBox* fromLine = aFromLine;
+ MOZ_ASSERT(fromLine, "bad line to pull from");
+ MOZ_ASSERT(fromLine->GetChildCount(), "empty line");
+ MOZ_ASSERT(aLine->GetChildCount(), "empty line");
+ MOZ_ASSERT(!HasProperty(LineIteratorProperty()),
+ "Shouldn't have line iterators mid-reflow");
+
+ NS_ASSERTION(fromLine->IsBlock() == fromLine->mFirstChild->IsBlockOutside(),
+ "Disagreement about whether it's a block or not");
+
+ if (fromLine->IsBlock()) {
+ // If our line is not empty and the child in aFromLine is a block
+ // then we cannot pull up the frame into this line. In this case
+ // we stop pulling.
+ return nullptr;
+ }
+ // Take frame from fromLine
+ nsIFrame* frame = fromLine->mFirstChild;
+ nsIFrame* newFirstChild = frame->GetNextSibling();
+
+ if (aFromContainer != this) {
+ // The frame is being pulled from a next-in-flow; therefore we need to add
+ // it to our sibling list.
+ MOZ_ASSERT(aLine == mLines.back());
+ MOZ_ASSERT(aFromLine == aFromContainer->mLines.begin(),
+ "should only pull from first line");
+ aFromContainer->mFrames.RemoveFrame(frame);
+
+ // When pushing and pulling frames we need to check for whether any
+ // views need to be reparented.
+ ReparentFrame(frame, aFromContainer, this);
+ mFrames.AppendFrame(nullptr, frame);
+
+ // The frame might have (or contain) floats that need to be brought
+ // over too. (pass 'false' since there are no siblings to check)
+ ReparentFloats(frame, aFromContainer, false);
+ } else {
+ MOZ_ASSERT(aLine == aFromLine.prev());
+ }
+
+ aLine->NoteFrameAdded(frame);
+ fromLine->NoteFrameRemoved(frame);
+
+ if (fromLine->GetChildCount() > 0) {
+ // Mark line dirty now that we pulled a child
+ fromLine->MarkDirty();
+ fromLine->mFirstChild = newFirstChild;
+ } else {
+ // Free up the fromLine now that it's empty.
+ // Its bounds might need to be redrawn, though.
+ if (aFromLine.next() != aFromContainer->mLines.end()) {
+ aFromLine.next()->MarkPreviousMarginDirty();
+ }
+ aFromContainer->mLines.erase(aFromLine);
+ // aFromLine is now invalid
+ aFromContainer->FreeLineBox(fromLine);
+ }
+
+#ifdef DEBUG
+ VerifyLines(true);
+ VerifyOverflowSituation();
+#endif
+
+ return frame;
+}
+
+void nsBlockFrame::SlideLine(BlockReflowState& aState, nsLineBox* aLine,
+ nscoord aDeltaBCoord) {
+ MOZ_ASSERT(aDeltaBCoord != 0, "why slide a line nowhere?");
+
+ // Adjust line state
+ aLine->SlideBy(aDeltaBCoord, aState.ContainerSize());
+
+ // Adjust the frames in the line
+ MoveChildFramesOfLine(aLine, aDeltaBCoord);
+}
+
+void nsBlockFrame::UpdateLineContainerSize(nsLineBox* aLine,
+ const nsSize& aNewContainerSize) {
+ if (aNewContainerSize == aLine->mContainerSize) {
+ return;
+ }
+
+ // Adjust line state
+ nsSize sizeDelta = aLine->UpdateContainerSize(aNewContainerSize);
+
+ // Changing container width only matters if writing mode is vertical-rl
+ if (GetWritingMode().IsVerticalRL()) {
+ MoveChildFramesOfLine(aLine, sizeDelta.width);
+ }
+}
+
+void nsBlockFrame::MoveChildFramesOfLine(nsLineBox* aLine,
+ nscoord aDeltaBCoord) {
+ // Adjust the frames in the line
+ nsIFrame* kid = aLine->mFirstChild;
+ if (!kid) {
+ return;
+ }
+
+ WritingMode wm = GetWritingMode();
+ LogicalPoint translation(wm, 0, aDeltaBCoord);
+
+ if (aLine->IsBlock()) {
+ if (aDeltaBCoord) {
+ kid->MovePositionBy(wm, translation);
+ }
+
+ // Make sure the frame's view and any child views are updated
+ nsContainerFrame::PlaceFrameView(kid);
+ } else {
+ // Adjust the block-dir coordinate of the frames in the line.
+ // Note: we need to re-position views even if aDeltaBCoord is 0, because
+ // one of our parent frames may have moved and so the view's position
+ // relative to its parent may have changed.
+ int32_t n = aLine->GetChildCount();
+ while (--n >= 0) {
+ if (aDeltaBCoord) {
+ kid->MovePositionBy(wm, translation);
+ }
+ // Make sure the frame's view and any child views are updated
+ nsContainerFrame::PlaceFrameView(kid);
+ kid = kid->GetNextSibling();
+ }
+ }
+}
+
+static inline bool IsNonAutoNonZeroBSize(const StyleSize& aCoord) {
+ // The "extremum length" values (see ExtremumLength) were originally aimed at
+ // inline-size (or width, as it was before logicalization). For now, let them
+ // return false here, so we treat them like 'auto' pending a real
+ // implementation. (See bug 1126420.)
+ //
+ // FIXME (bug 567039, bug 527285) This isn't correct for the 'fill' value,
+ // which should more likely (but not necessarily, depending on the available
+ // space) be returning true.
+ if (aCoord.BehavesLikeInitialValueOnBlockAxis()) {
+ return false;
+ }
+ MOZ_ASSERT(aCoord.IsLengthPercentage());
+ // If we evaluate the length/percent/calc at a percentage basis of
+ // both nscoord_MAX and 0, and it's zero both ways, then it's a zero
+ // length, percent, or combination thereof. Test > 0 so we clamp
+ // negative calc() results to 0.
+ return aCoord.AsLengthPercentage().Resolve(nscoord_MAX) > 0 ||
+ aCoord.AsLengthPercentage().Resolve(0) > 0;
+}
+
+/* virtual */
+bool nsBlockFrame::IsSelfEmpty() {
+ if (IsHiddenByContentVisibilityOfInFlowParentForLayout()) {
+ return true;
+ }
+
+ // Blocks which are margin-roots (including inline-blocks) cannot be treated
+ // as empty for margin-collapsing and other purposes. They're more like
+ // replaced elements.
+ if (HasAnyStateBits(NS_BLOCK_BFC_STATE_BITS)) {
+ return false;
+ }
+
+ WritingMode wm = GetWritingMode();
+ const nsStylePosition* position = StylePosition();
+
+ if (IsNonAutoNonZeroBSize(position->MinBSize(wm)) ||
+ IsNonAutoNonZeroBSize(position->BSize(wm))) {
+ return false;
+ }
+
+ // FIXME: Bug 1646100 - Take intrinsic size into account.
+ // FIXME: Handle the case that both inline and block sizes are auto.
+ // https://github.com/w3c/csswg-drafts/issues/5060.
+ // Note: block-size could be zero or auto/intrinsic keywords here.
+ if (position->BSize(wm).BehavesLikeInitialValueOnBlockAxis() &&
+ position->mAspectRatio.HasFiniteRatio()) {
+ return false;
+ }
+
+ const nsStyleBorder* border = StyleBorder();
+ const nsStylePadding* padding = StylePadding();
+
+ if (border->GetComputedBorderWidth(wm.PhysicalSide(eLogicalSideBStart)) !=
+ 0 ||
+ border->GetComputedBorderWidth(wm.PhysicalSide(eLogicalSideBEnd)) != 0 ||
+ !nsLayoutUtils::IsPaddingZero(padding->mPadding.GetBStart(wm)) ||
+ !nsLayoutUtils::IsPaddingZero(padding->mPadding.GetBEnd(wm))) {
+ return false;
+ }
+
+ if (HasOutsideMarker() && !MarkerIsEmpty()) {
+ return false;
+ }
+
+ return true;
+}
+
+bool nsBlockFrame::CachedIsEmpty() {
+ if (!IsSelfEmpty()) {
+ return false;
+ }
+ for (auto& line : mLines) {
+ if (!line.CachedIsEmpty()) {
+ return false;
+ }
+ }
+ return true;
+}
+
+bool nsBlockFrame::IsEmpty() {
+ if (!IsSelfEmpty()) {
+ return false;
+ }
+
+ return LinesAreEmpty(mLines);
+}
+
+bool nsBlockFrame::ShouldApplyBStartMargin(BlockReflowState& aState,
+ nsLineBox* aLine) {
+ if (aLine->mFirstChild->IsPageBreakFrame()) {
+ // A page break frame consumes margins adjacent to it.
+ // https://drafts.csswg.org/css-break/#break-margins
+ return false;
+ }
+
+ if (aState.mFlags.mShouldApplyBStartMargin) {
+ // Apply short-circuit check to avoid searching the line list
+ return true;
+ }
+
+ if (!aState.IsAdjacentWithBStart()) {
+ // If we aren't at the start block-coordinate then something of non-zero
+ // height must have been placed. Therefore the childs block-start margin
+ // applies.
+ aState.mFlags.mShouldApplyBStartMargin = true;
+ return true;
+ }
+
+ // Determine if this line is "essentially" the first line
+ LineIterator line = LinesBegin();
+ if (aState.mFlags.mHasLineAdjacentToTop) {
+ line = aState.mLineAdjacentToTop;
+ }
+ while (line != aLine) {
+ if (!line->CachedIsEmpty() || line->HasClearance()) {
+ // A line which precedes aLine is non-empty, or has clearance,
+ // so therefore the block-start margin applies.
+ aState.mFlags.mShouldApplyBStartMargin = true;
+ return true;
+ }
+ // No need to apply the block-start margin if the line has floats. We
+ // should collapse anyway (bug 44419)
+ ++line;
+ aState.mFlags.mHasLineAdjacentToTop = true;
+ aState.mLineAdjacentToTop = line;
+ }
+
+ // The line being reflowed is "essentially" the first line in the
+ // block. Therefore its block-start margin will be collapsed by the
+ // generational collapsing logic with its parent (us).
+ return false;
+}
+
+void nsBlockFrame::ReflowBlockFrame(BlockReflowState& aState,
+ LineIterator aLine,
+ bool* aKeepReflowGoing) {
+ MOZ_ASSERT(*aKeepReflowGoing, "bad caller");
+
+ nsIFrame* frame = aLine->mFirstChild;
+ if (!frame) {
+ NS_ASSERTION(false, "program error - unexpected empty line");
+ return;
+ }
+
+ // If the previous frame was a page-break-frame, then preemptively push this
+ // frame to the next page.
+ // This is primarily important for the placeholders for abspos frames, which
+ // measure as zero height and then would be placed on this page.
+ if (aState.ContentBSize() != NS_UNCONSTRAINEDSIZE) {
+ const nsIFrame* const prev = frame->GetPrevSibling();
+ if (prev && prev->IsPageBreakFrame()) {
+ PushTruncatedLine(aState, aLine, aKeepReflowGoing);
+ return;
+ }
+ }
+
+ // Prepare the block reflow engine
+ nsBlockReflowContext brc(aState.mPresContext, aState.mReflowInput);
+
+ StyleClear clearType = frame->StyleDisplay()->mClear;
+ if (aState.mTrailingClearFromPIF != StyleClear::None) {
+ clearType = nsLayoutUtils::CombineClearType(clearType,
+ aState.mTrailingClearFromPIF);
+ aState.mTrailingClearFromPIF = StyleClear::None;
+ }
+
+ // Clear past floats before the block if the clear style is not none
+ aLine->ClearForcedLineBreak();
+ if (clearType != StyleClear::None) {
+ aLine->SetForcedLineBreakBefore(clearType);
+ }
+
+ // See if we should apply the block-start margin. If the block frame being
+ // reflowed is a continuation, then we don't apply its block-start margin
+ // because it's not significant. Otherwise, dig deeper.
+ bool applyBStartMargin =
+ !frame->GetPrevContinuation() && ShouldApplyBStartMargin(aState, aLine);
+ if (applyBStartMargin) {
+ // The HasClearance setting is only valid if ShouldApplyBStartMargin
+ // returned false (in which case the block-start margin-root set our
+ // clearance flag). Otherwise clear it now. We'll set it later on
+ // ourselves if necessary.
+ aLine->ClearHasClearance();
+ }
+ bool treatWithClearance = aLine->HasClearance();
+
+ bool mightClearFloats = clearType != StyleClear::None;
+ nsIFrame* floatAvoidingBlock = nullptr;
+ if (!nsBlockFrame::BlockCanIntersectFloats(frame)) {
+ mightClearFloats = true;
+ floatAvoidingBlock = frame;
+ }
+
+ // If our block-start margin was counted as part of some parent's block-start
+ // margin collapse, and we are being speculatively reflowed assuming this
+ // frame DID NOT need clearance, then we need to check that
+ // assumption.
+ if (!treatWithClearance && !applyBStartMargin && mightClearFloats &&
+ aState.mReflowInput.mDiscoveredClearance) {
+ nscoord curBCoord = aState.mBCoord + aState.mPrevBEndMargin.get();
+ if (auto [clearBCoord, result] =
+ aState.ClearFloats(curBCoord, clearType, floatAvoidingBlock);
+ result != ClearFloatsResult::BCoordNoChange) {
+ Unused << clearBCoord;
+
+ // Only record the first frame that requires clearance
+ if (!*aState.mReflowInput.mDiscoveredClearance) {
+ *aState.mReflowInput.mDiscoveredClearance = frame;
+ }
+ aState.mPrevChild = frame;
+ // Exactly what we do now is flexible since we'll definitely be
+ // reflowed.
+ return;
+ }
+ }
+ if (treatWithClearance) {
+ applyBStartMargin = true;
+ }
+
+ nsIFrame* clearanceFrame = nullptr;
+ const nscoord startingBCoord = aState.mBCoord;
+ const nsCollapsingMargin incomingMargin = aState.mPrevBEndMargin;
+ nscoord clearance;
+ // Save the original position of the frame so that we can reposition
+ // its view as needed.
+ nsPoint originalPosition = frame->GetPosition();
+ while (true) {
+ clearance = 0;
+ nscoord bStartMargin = 0;
+ bool mayNeedRetry = false;
+ bool clearedFloats = false;
+ bool clearedPushedOrSplitFloat = false;
+ if (applyBStartMargin) {
+ // Precompute the blocks block-start margin value so that we can get the
+ // correct available space (there might be a float that's
+ // already been placed below the aState.mPrevBEndMargin
+
+ // Setup a reflowInput to get the style computed block-start margin
+ // value. We'll use a reason of `resize' so that we don't fudge
+ // any incremental reflow input.
+
+ // The availSpace here is irrelevant to our needs - all we want
+ // out if this setup is the block-start margin value which doesn't depend
+ // on the childs available space.
+ // XXX building a complete ReflowInput just to get the block-start
+ // margin seems like a waste. And we do this for almost every block!
+ WritingMode wm = frame->GetWritingMode();
+ LogicalSize availSpace = aState.ContentSize(wm);
+ ReflowInput reflowInput(aState.mPresContext, aState.mReflowInput, frame,
+ availSpace);
+
+ if (treatWithClearance) {
+ aState.mBCoord += aState.mPrevBEndMargin.get();
+ aState.mPrevBEndMargin.Zero();
+ }
+
+ // Now compute the collapsed margin-block-start value into
+ // aState.mPrevBEndMargin, assuming that all child margins
+ // collapse down to clearanceFrame.
+ brc.ComputeCollapsedBStartMargin(reflowInput, &aState.mPrevBEndMargin,
+ clearanceFrame, &mayNeedRetry);
+
+ // XXX optimization; we could check the collapsing children to see if they
+ // are sure to require clearance, and so avoid retrying them
+
+ if (clearanceFrame) {
+ // Don't allow retries on the second pass. The clearance decisions for
+ // the blocks whose block-start margins collapse with ours are now
+ // fixed.
+ mayNeedRetry = false;
+ }
+
+ if (!treatWithClearance && !clearanceFrame && mightClearFloats) {
+ // We don't know if we need clearance and this is the first,
+ // optimistic pass. So determine whether *this block* needs
+ // clearance. Note that we do not allow the decision for whether
+ // this block has clearance to change on the second pass; that
+ // decision is only allowed to be made under the optimistic
+ // first pass.
+ nscoord curBCoord = aState.mBCoord + aState.mPrevBEndMargin.get();
+ if (auto [clearBCoord, result] =
+ aState.ClearFloats(curBCoord, clearType, floatAvoidingBlock);
+ result != ClearFloatsResult::BCoordNoChange) {
+ Unused << clearBCoord;
+
+ // Looks like we need clearance and we didn't know about it already.
+ // So recompute collapsed margin
+ treatWithClearance = true;
+ // Remember this decision, needed for incremental reflow
+ aLine->SetHasClearance();
+
+ // Apply incoming margins
+ aState.mBCoord += aState.mPrevBEndMargin.get();
+ aState.mPrevBEndMargin.Zero();
+
+ // Compute the collapsed margin again, ignoring the incoming margin
+ // this time
+ mayNeedRetry = false;
+ brc.ComputeCollapsedBStartMargin(reflowInput, &aState.mPrevBEndMargin,
+ clearanceFrame, &mayNeedRetry);
+ }
+ }
+
+ // Temporarily advance the running block-direction value so that the
+ // GetFloatAvailableSpace method will return the right available space.
+ // This undone as soon as the horizontal margins are computed.
+ bStartMargin = aState.mPrevBEndMargin.get();
+
+ if (treatWithClearance) {
+ nscoord currentBCoord = aState.mBCoord;
+ // advance mBCoord to the clear position.
+ auto [clearBCoord, result] =
+ aState.ClearFloats(aState.mBCoord, clearType, floatAvoidingBlock);
+ aState.mBCoord = clearBCoord;
+
+ clearedFloats = result != ClearFloatsResult::BCoordNoChange;
+ clearedPushedOrSplitFloat =
+ result == ClearFloatsResult::FloatsPushedOrSplit;
+
+ // Compute clearance. It's the amount we need to add to the block-start
+ // border-edge of the frame, after applying collapsed margins
+ // from the frame and its children, to get it to line up with
+ // the block-end of the floats. The former is
+ // currentBCoord + bStartMargin, the latter is the current
+ // aState.mBCoord.
+ // Note that negative clearance is possible
+ clearance = aState.mBCoord - (currentBCoord + bStartMargin);
+
+ // Add clearance to our block-start margin while we compute available
+ // space for the frame
+ bStartMargin += clearance;
+
+ // Note that aState.mBCoord should stay where it is: at the block-start
+ // border-edge of the frame
+ } else {
+ // Advance aState.mBCoord to the block-start border-edge of the frame.
+ aState.mBCoord += bStartMargin;
+ }
+ }
+
+ aLine->SetLineIsImpactedByFloat(false);
+
+ // Here aState.mBCoord is the block-start border-edge of the block.
+ // Compute the available space for the block
+ nsFlowAreaRect floatAvailableSpace = aState.GetFloatAvailableSpace();
+ WritingMode wm = aState.mReflowInput.GetWritingMode();
+ LogicalRect availSpace = aState.ComputeBlockAvailSpace(
+ frame, floatAvailableSpace, (floatAvoidingBlock));
+
+ // The check for
+ // (!aState.mReflowInput.mFlags.mIsTopOfPage || clearedFloats)
+ // is to some degree out of paranoia: if we reliably eat up block-start
+ // margins at the top of the page as we ought to, it wouldn't be
+ // needed.
+ if ((!aState.mReflowInput.mFlags.mIsTopOfPage || clearedFloats) &&
+ (availSpace.BSize(wm) < 0 || clearedPushedOrSplitFloat)) {
+ // We know already that this child block won't fit on this
+ // page/column due to the block-start margin or the clearance. So we
+ // need to get out of here now. (If we don't, most blocks will handle
+ // things fine, and report break-before, but zero-height blocks
+ // won't, and will thus make their parent overly-large and force
+ // *it* to be pushed in its entirety.)
+ aState.mBCoord = startingBCoord;
+ aState.mPrevBEndMargin = incomingMargin;
+ if (ShouldAvoidBreakInside(aState.mReflowInput)) {
+ SetBreakBeforeStatusBeforeLine(aState, aLine, aKeepReflowGoing);
+ } else {
+ PushTruncatedLine(aState, aLine, aKeepReflowGoing);
+ }
+ return;
+ }
+
+ // Now put the block-dir coordinate back to the start of the
+ // block-start-margin + clearance.
+ aState.mBCoord -= bStartMargin;
+ availSpace.BStart(wm) -= bStartMargin;
+ if (NS_UNCONSTRAINEDSIZE != availSpace.BSize(wm)) {
+ availSpace.BSize(wm) += bStartMargin;
+ }
+
+ // Construct the reflow input for the block.
+ Maybe<ReflowInput> childReflowInput;
+ Maybe<LogicalSize> cbSize;
+ LogicalSize availSize = availSpace.Size(wm);
+ bool columnSetWrapperHasNoBSizeLeft = false;
+ if (Style()->GetPseudoType() == PseudoStyleType::columnContent) {
+ // Calculate the multicol containing block's block size so that the
+ // children with percentage block size get correct percentage basis.
+ const ReflowInput* cbReflowInput =
+ aState.mReflowInput.mParentReflowInput->mCBReflowInput;
+ MOZ_ASSERT(cbReflowInput->mFrame->StyleColumn()->IsColumnContainerStyle(),
+ "Get unexpected reflow input of multicol containing block!");
+
+ // Use column-width as the containing block's inline-size, i.e. the column
+ // content's computed inline-size.
+ cbSize.emplace(LogicalSize(wm, aState.mReflowInput.ComputedISize(),
+ cbReflowInput->ComputedBSize())
+ .ConvertTo(frame->GetWritingMode(), wm));
+
+ // If a ColumnSetWrapper is in a balancing column content, it may be
+ // pushed or pulled back and forth between column contents. Always add
+ // NS_FRAME_HAS_DIRTY_CHILDREN bit to it so that its ColumnSet children
+ // can have a chance to reflow under current block size constraint.
+ if (aState.mReflowInput.mFlags.mIsColumnBalancing &&
+ frame->IsColumnSetWrapperFrame()) {
+ frame->AddStateBits(NS_FRAME_HAS_DIRTY_CHILDREN);
+ }
+ } else if (IsColumnSetWrapperFrame()) {
+ // If we are reflowing our ColumnSet children, we want to apply our block
+ // size constraint to the available block size when constructing reflow
+ // input for ColumnSet so that ColumnSet can use it to compute its max
+ // column block size.
+ if (frame->IsColumnSetFrame()) {
+ nscoord contentBSize = aState.mReflowInput.ComputedBSize();
+ if (aState.mReflowInput.ComputedMaxBSize() != NS_UNCONSTRAINEDSIZE) {
+ contentBSize =
+ std::min(contentBSize, aState.mReflowInput.ComputedMaxBSize());
+ }
+ if (contentBSize != NS_UNCONSTRAINEDSIZE) {
+ // To get the remaining content block-size, subtract the content
+ // block-size consumed by our previous continuations.
+ contentBSize -= aState.mConsumedBSize;
+
+ // ColumnSet is not the outermost frame in the column container, so it
+ // cannot have any margin. We don't need to consider any margin that
+ // can be generated by "box-decoration-break: clone" as we do in
+ // BlockReflowState::ComputeBlockAvailSpace().
+ const nscoord availContentBSize = std::max(
+ 0, contentBSize - (aState.mBCoord - aState.ContentBStart()));
+ if (availSize.BSize(wm) >= availContentBSize) {
+ availSize.BSize(wm) = availContentBSize;
+ columnSetWrapperHasNoBSizeLeft = true;
+ }
+ }
+ }
+ }
+
+ childReflowInput.emplace(aState.mPresContext, aState.mReflowInput, frame,
+ availSize.ConvertTo(frame->GetWritingMode(), wm),
+ cbSize);
+
+ childReflowInput->mFlags.mColumnSetWrapperHasNoBSizeLeft =
+ columnSetWrapperHasNoBSizeLeft;
+
+ if (aLine->MovedFragments()) {
+ // We only need to set this the first reflow, since if we reflow
+ // again (and replace childReflowInput) we'll be reflowing it
+ // again in the same fragment as the previous time.
+ childReflowInput->mFlags.mMovedBlockFragments = true;
+ }
+
+ nsFloatManager::SavedState floatManagerState;
+ nsReflowStatus frameReflowStatus;
+ do {
+ if (floatAvailableSpace.HasFloats()) {
+ // Set if floatAvailableSpace.HasFloats() is true for any
+ // iteration of the loop.
+ aLine->SetLineIsImpactedByFloat(true);
+ }
+
+ // We might need to store into mDiscoveredClearance later if it's
+ // currently null; we want to overwrite any writes that
+ // brc.ReflowBlock() below does, so we need to remember now
+ // whether it's empty.
+ const bool shouldStoreClearance =
+ aState.mReflowInput.mDiscoveredClearance &&
+ !*aState.mReflowInput.mDiscoveredClearance;
+
+ // Reflow the block into the available space
+ if (mayNeedRetry || floatAvoidingBlock) {
+ aState.FloatManager()->PushState(&floatManagerState);
+ }
+
+ if (mayNeedRetry) {
+ childReflowInput->mDiscoveredClearance = &clearanceFrame;
+ } else if (!applyBStartMargin) {
+ childReflowInput->mDiscoveredClearance =
+ aState.mReflowInput.mDiscoveredClearance;
+ }
+
+ frameReflowStatus.Reset();
+ brc.ReflowBlock(availSpace, applyBStartMargin, aState.mPrevBEndMargin,
+ clearance, aLine.get(), *childReflowInput,
+ frameReflowStatus, aState);
+
+ if (frameReflowStatus.IsInlineBreakBefore()) {
+ // No need to retry this loop if there is a break opportunity before the
+ // child block.
+ break;
+ }
+
+ // Now the block has a height. Using that height, get the
+ // available space again and call ComputeBlockAvailSpace again.
+ // If ComputeBlockAvailSpace gives a different result, we need to
+ // reflow again.
+ if (!floatAvoidingBlock) {
+ break;
+ }
+
+ LogicalRect oldFloatAvailableSpaceRect(floatAvailableSpace.mRect);
+ floatAvailableSpace = aState.GetFloatAvailableSpaceForBSize(
+ aState.mBCoord + bStartMargin, brc.GetMetrics().BSize(wm),
+ &floatManagerState);
+ NS_ASSERTION(floatAvailableSpace.mRect.BStart(wm) ==
+ oldFloatAvailableSpaceRect.BStart(wm),
+ "yikes");
+ // Restore the height to the position of the next band.
+ floatAvailableSpace.mRect.BSize(wm) =
+ oldFloatAvailableSpaceRect.BSize(wm);
+ // Determine whether the available space shrunk on either side,
+ // because (the first time round) we now know the block's height,
+ // and it may intersect additional floats, or (on later
+ // iterations) because narrowing the width relative to the
+ // previous time may cause the block to become taller. Note that
+ // since we're reflowing the block, narrowing the width might also
+ // make it shorter, so we must pass aCanGrow as true.
+ if (!AvailableSpaceShrunk(wm, oldFloatAvailableSpaceRect,
+ floatAvailableSpace.mRect, true)) {
+ // The size and position we chose before are fine (i.e., they
+ // don't cause intersecting with floats that requires a change
+ // in size or position), so we're done.
+ break;
+ }
+
+ bool advanced = false;
+ if (!aState.FloatAvoidingBlockFitsInAvailSpace(floatAvoidingBlock,
+ floatAvailableSpace)) {
+ // Advance to the next band.
+ nscoord newBCoord = aState.mBCoord;
+ if (aState.AdvanceToNextBand(floatAvailableSpace.mRect, &newBCoord)) {
+ advanced = true;
+ }
+ // ClearFloats might be able to advance us further once we're there.
+ std::tie(aState.mBCoord, std::ignore) =
+ aState.ClearFloats(newBCoord, StyleClear::None, floatAvoidingBlock);
+
+ // Start over with a new available space rect at the new height.
+ floatAvailableSpace = aState.GetFloatAvailableSpaceWithState(
+ aState.mBCoord, ShapeType::ShapeOutside, &floatManagerState);
+ }
+
+ const LogicalRect oldAvailSpace = availSpace;
+ availSpace = aState.ComputeBlockAvailSpace(frame, floatAvailableSpace,
+ (floatAvoidingBlock));
+
+ if (!advanced && availSpace.IsEqualEdges(oldAvailSpace)) {
+ break;
+ }
+
+ // We need another reflow.
+ aState.FloatManager()->PopState(&floatManagerState);
+
+ if (!treatWithClearance && !applyBStartMargin &&
+ aState.mReflowInput.mDiscoveredClearance) {
+ // We set shouldStoreClearance above to record only the first
+ // frame that requires clearance.
+ if (shouldStoreClearance) {
+ *aState.mReflowInput.mDiscoveredClearance = frame;
+ }
+ aState.mPrevChild = frame;
+ // Exactly what we do now is flexible since we'll definitely be
+ // reflowed.
+ return;
+ }
+
+ if (advanced) {
+ // We're pushing down the border-box, so we don't apply margin anymore.
+ // This should never cause us to move up since the call to
+ // GetFloatAvailableSpaceForBSize above included the margin.
+ applyBStartMargin = false;
+ bStartMargin = 0;
+ treatWithClearance = true; // avoid hitting test above
+ clearance = 0;
+ }
+
+ childReflowInput.reset();
+ childReflowInput.emplace(
+ aState.mPresContext, aState.mReflowInput, frame,
+ availSpace.Size(wm).ConvertTo(frame->GetWritingMode(), wm));
+ } while (true);
+
+ if (mayNeedRetry && clearanceFrame) {
+ // Found a clearance frame, so we need to reflow |frame| a second time.
+ // Restore the states and start over again.
+ aState.FloatManager()->PopState(&floatManagerState);
+ aState.mBCoord = startingBCoord;
+ aState.mPrevBEndMargin = incomingMargin;
+ continue;
+ }
+
+ aState.mPrevChild = frame;
+
+ if (childReflowInput->WillReflowAgainForClearance()) {
+ // If an ancestor of ours is going to reflow for clearance, we
+ // need to avoid calling PlaceBlock, because it unsets dirty bits
+ // on the child block (both itself, and through its call to
+ // nsIFrame::DidReflow), and those dirty bits imply dirtiness for
+ // all of the child block, including the lines it didn't reflow.
+ NS_ASSERTION(originalPosition == frame->GetPosition(),
+ "we need to call PositionChildViews");
+ return;
+ }
+
+#if defined(REFLOW_STATUS_COVERAGE)
+ RecordReflowStatus(true, frameReflowStatus);
+#endif
+
+ if (frameReflowStatus.IsInlineBreakBefore()) {
+ // None of the child block fits.
+ if (ShouldAvoidBreakInside(aState.mReflowInput)) {
+ SetBreakBeforeStatusBeforeLine(aState, aLine, aKeepReflowGoing);
+ } else {
+ PushTruncatedLine(aState, aLine, aKeepReflowGoing);
+ }
+ } else {
+ // Note: line-break-after a block is a nop
+
+ // Try to place the child block.
+ // Don't force the block to fit if we have positive clearance, because
+ // pushing it to the next page would give it more room.
+ // Don't force the block to fit if it's impacted by a float. If it is,
+ // then pushing it to the next page would give it more room. Note that
+ // isImpacted doesn't include impact from the block's own floats.
+ bool forceFit = aState.IsAdjacentWithBStart() && clearance <= 0 &&
+ !floatAvailableSpace.HasFloats();
+ nsCollapsingMargin collapsedBEndMargin;
+ OverflowAreas overflowAreas;
+ *aKeepReflowGoing =
+ brc.PlaceBlock(*childReflowInput, forceFit, aLine.get(),
+ collapsedBEndMargin, overflowAreas, frameReflowStatus);
+ if (!frameReflowStatus.IsFullyComplete() &&
+ ShouldAvoidBreakInside(aState.mReflowInput)) {
+ *aKeepReflowGoing = false;
+ aLine->MarkDirty();
+ }
+
+ if (aLine->SetCarriedOutBEndMargin(collapsedBEndMargin)) {
+ LineIterator nextLine = aLine;
+ ++nextLine;
+ if (nextLine != LinesEnd()) {
+ nextLine->MarkPreviousMarginDirty();
+ }
+ }
+
+ aLine->SetOverflowAreas(overflowAreas);
+ if (*aKeepReflowGoing) {
+ // Some of the child block fit
+
+ // Advance to new Y position
+ nscoord newBCoord = aLine->BEnd();
+ aState.mBCoord = newBCoord;
+
+ // Continue the block frame now if it didn't completely fit in
+ // the available space.
+ if (!frameReflowStatus.IsFullyComplete()) {
+ bool madeContinuation = CreateContinuationFor(aState, nullptr, frame);
+
+ nsIFrame* nextFrame = frame->GetNextInFlow();
+ NS_ASSERTION(nextFrame,
+ "We're supposed to have a next-in-flow by now");
+
+ if (frameReflowStatus.IsIncomplete()) {
+ // If nextFrame used to be an overflow container, make it a normal
+ // block
+ if (!madeContinuation &&
+ nextFrame->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER)) {
+ nsOverflowContinuationTracker::AutoFinish fini(
+ aState.mOverflowTracker, frame);
+ nsContainerFrame* parent = nextFrame->GetParent();
+ parent->StealFrame(nextFrame);
+ if (parent != this) {
+ ReparentFrame(nextFrame, parent, this);
+ }
+ mFrames.InsertFrame(nullptr, frame, nextFrame);
+ madeContinuation = true; // needs to be added to mLines
+ nextFrame->RemoveStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER);
+ frameReflowStatus.SetNextInFlowNeedsReflow();
+ }
+
+ // Push continuation to a new line, but only if we actually made
+ // one.
+ if (madeContinuation) {
+ nsLineBox* line = NewLineBox(nextFrame, true);
+ mLines.after_insert(aLine, line);
+ }
+
+ PushTruncatedLine(aState, aLine.next(), aKeepReflowGoing);
+
+ // If we need to reflow the continuation of the block child,
+ // then we'd better reflow our continuation
+ if (frameReflowStatus.NextInFlowNeedsReflow()) {
+ aState.mReflowStatus.SetNextInFlowNeedsReflow();
+ // We also need to make that continuation's line dirty so
+ // it gets reflowed when we reflow our next in flow. The
+ // nif's line must always be either a line of the nif's
+ // parent block (only if we didn't make a continuation) or
+ // else one of our own overflow lines. In the latter case
+ // the line is already marked dirty, so just handle the
+ // first case.
+ if (!madeContinuation) {
+ nsBlockFrame* nifBlock = do_QueryFrame(nextFrame->GetParent());
+ NS_ASSERTION(
+ nifBlock,
+ "A block's child's next in flow's parent must be a block!");
+ for (auto& line : nifBlock->Lines()) {
+ if (line.Contains(nextFrame)) {
+ line.MarkDirty();
+ break;
+ }
+ }
+ }
+ }
+
+ // The block-end margin for a block is only applied on the last
+ // flow block. Since we just continued the child block frame,
+ // we know that line->mFirstChild is not the last flow block
+ // therefore zero out the running margin value.
+#ifdef NOISY_BLOCK_DIR_MARGINS
+ ListTag(stdout);
+ printf(": reflow incomplete, frame=");
+ frame->ListTag(stdout);
+ printf(" prevBEndMargin=%d, setting to zero\n",
+ aState.mPrevBEndMargin.get());
+#endif
+ aState.mPrevBEndMargin.Zero();
+ } else { // frame is complete but its overflow is not complete
+ // Disconnect the next-in-flow and put it in our overflow tracker
+ if (!madeContinuation &&
+ !nextFrame->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER)) {
+ // It already exists, but as a normal next-in-flow, so we need
+ // to dig it out of the child lists.
+ nextFrame->GetParent()->StealFrame(nextFrame);
+ } else if (madeContinuation) {
+ mFrames.RemoveFrame(nextFrame);
+ }
+
+ // Put it in our overflow list
+ aState.mOverflowTracker->Insert(nextFrame, frameReflowStatus);
+ aState.mReflowStatus.MergeCompletionStatusFrom(frameReflowStatus);
+
+#ifdef NOISY_BLOCK_DIR_MARGINS
+ ListTag(stdout);
+ printf(": reflow complete but overflow incomplete for ");
+ frame->ListTag(stdout);
+ printf(" prevBEndMargin=%d collapsedBEndMargin=%d\n",
+ aState.mPrevBEndMargin.get(), collapsedBEndMargin.get());
+#endif
+ aState.mPrevBEndMargin = collapsedBEndMargin;
+ }
+ } else { // frame is fully complete
+#ifdef NOISY_BLOCK_DIR_MARGINS
+ ListTag(stdout);
+ printf(": reflow complete for ");
+ frame->ListTag(stdout);
+ printf(" prevBEndMargin=%d collapsedBEndMargin=%d\n",
+ aState.mPrevBEndMargin.get(), collapsedBEndMargin.get());
+#endif
+ aState.mPrevBEndMargin = collapsedBEndMargin;
+ }
+#ifdef NOISY_BLOCK_DIR_MARGINS
+ ListTag(stdout);
+ printf(": frame=");
+ frame->ListTag(stdout);
+ printf(" carriedOutBEndMargin=%d collapsedBEndMargin=%d => %d\n",
+ brc.GetCarriedOutBEndMargin().get(), collapsedBEndMargin.get(),
+ aState.mPrevBEndMargin.get());
+#endif
+ } else {
+ if (!frameReflowStatus.IsFullyComplete()) {
+ // The frame reported an incomplete status, but then it also didn't
+ // fit. This means we need to reflow it again so that it can
+ // (again) report the incomplete status.
+ frame->AddStateBits(NS_FRAME_HAS_DIRTY_CHILDREN);
+ }
+
+ if ((aLine == mLines.front() && !GetPrevInFlow()) ||
+ ShouldAvoidBreakInside(aState.mReflowInput)) {
+ // If it's our very first line *or* we're not at the top of the page
+ // and we have page-break-inside:avoid, then we need to be pushed to
+ // our parent's next-in-flow.
+ SetBreakBeforeStatusBeforeLine(aState, aLine, aKeepReflowGoing);
+ } else {
+ // Push the line that didn't fit and any lines that follow it
+ // to our next-in-flow.
+ PushTruncatedLine(aState, aLine, aKeepReflowGoing);
+ }
+ }
+ }
+ break; // out of the reflow retry loop
+ }
+
+ // Now that we've got its final position all figured out, position any child
+ // views it may have. Note that the case when frame has a view got handled
+ // by FinishReflowChild, but that function didn't have the coordinates needed
+ // to correctly decide whether to reposition child views.
+ if (originalPosition != frame->GetPosition() && !frame->HasView()) {
+ nsContainerFrame::PositionChildViews(frame);
+ }
+
+#ifdef DEBUG
+ VerifyLines(true);
+#endif
+}
+
+// Returns true if an overflow-wrap break was used.
+bool nsBlockFrame::ReflowInlineFrames(BlockReflowState& aState,
+ LineIterator aLine,
+ bool* aKeepReflowGoing) {
+ *aKeepReflowGoing = true;
+ bool usedOverflowWrap = false;
+
+ aLine->SetLineIsImpactedByFloat(false);
+
+ // Setup initial coordinate system for reflowing the inline frames
+ // into. Apply a previous block frame's block-end margin first.
+ if (ShouldApplyBStartMargin(aState, aLine)) {
+ aState.mBCoord += aState.mPrevBEndMargin.get();
+ }
+ nsFlowAreaRect floatAvailableSpace = aState.GetFloatAvailableSpace();
+
+ LineReflowStatus lineReflowStatus;
+ do {
+ nscoord availableSpaceBSize = 0;
+ aState.mLineBSize.reset();
+ do {
+ bool allowPullUp = true;
+ nsIFrame* forceBreakInFrame = nullptr;
+ int32_t forceBreakOffset = -1;
+ gfxBreakPriority forceBreakPriority = gfxBreakPriority::eNoBreak;
+ do {
+ nsFloatManager::SavedState floatManagerState;
+ aState.FloatManager()->PushState(&floatManagerState);
+
+ // Once upon a time we allocated the first 30 nsLineLayout objects
+ // on the stack, and then we switched to the heap. At that time
+ // these objects were large (1100 bytes on a 32 bit system).
+ // Then the nsLineLayout object was shrunk to 156 bytes by
+ // removing some internal buffers. Given that it is so much
+ // smaller, the complexity of 2 different ways of allocating
+ // no longer makes sense. Now we always allocate on the stack.
+ nsLineLayout lineLayout(aState.mPresContext, aState.FloatManager(),
+ aState.mReflowInput, &aLine, nullptr);
+ lineLayout.Init(&aState, aState.mMinLineHeight, aState.mLineNumber);
+ if (forceBreakInFrame) {
+ lineLayout.ForceBreakAtPosition(forceBreakInFrame, forceBreakOffset);
+ }
+ DoReflowInlineFrames(aState, lineLayout, aLine, floatAvailableSpace,
+ availableSpaceBSize, &floatManagerState,
+ aKeepReflowGoing, &lineReflowStatus, allowPullUp);
+ usedOverflowWrap = lineLayout.EndLineReflow();
+
+ if (LineReflowStatus::RedoNoPull == lineReflowStatus ||
+ LineReflowStatus::RedoMoreFloats == lineReflowStatus ||
+ LineReflowStatus::RedoNextBand == lineReflowStatus) {
+ if (lineLayout.NeedsBackup()) {
+ NS_ASSERTION(!forceBreakInFrame,
+ "Backing up twice; this should never be necessary");
+ // If there is no saved break position, then this will set
+ // set forceBreakInFrame to null and we won't back up, which is
+ // correct.
+ forceBreakInFrame = lineLayout.GetLastOptionalBreakPosition(
+ &forceBreakOffset, &forceBreakPriority);
+ } else {
+ forceBreakInFrame = nullptr;
+ }
+ // restore the float manager state
+ aState.FloatManager()->PopState(&floatManagerState);
+ // Clear out float lists
+ aState.mCurrentLineFloats.Clear();
+ aState.mBelowCurrentLineFloats.Clear();
+ aState.mNoWrapFloats.Clear();
+ }
+
+ // Don't allow pullup on a subsequent LineReflowStatus::RedoNoPull pass
+ allowPullUp = false;
+ } while (LineReflowStatus::RedoNoPull == lineReflowStatus);
+ } while (LineReflowStatus::RedoMoreFloats == lineReflowStatus);
+ } while (LineReflowStatus::RedoNextBand == lineReflowStatus);
+
+ return usedOverflowWrap;
+}
+
+void nsBlockFrame::SetBreakBeforeStatusBeforeLine(BlockReflowState& aState,
+ LineIterator aLine,
+ bool* aKeepReflowGoing) {
+ aState.mReflowStatus.SetInlineLineBreakBeforeAndReset();
+ // Reflow the line again when we reflow at our new position.
+ aLine->MarkDirty();
+ *aKeepReflowGoing = false;
+}
+
+void nsBlockFrame::PushTruncatedLine(BlockReflowState& aState,
+ LineIterator aLine,
+ bool* aKeepReflowGoing) {
+ PushLines(aState, aLine.prev());
+ *aKeepReflowGoing = false;
+ aState.mReflowStatus.SetIncomplete();
+}
+
+void nsBlockFrame::DoReflowInlineFrames(
+ BlockReflowState& aState, nsLineLayout& aLineLayout, LineIterator aLine,
+ nsFlowAreaRect& aFloatAvailableSpace, nscoord& aAvailableSpaceBSize,
+ nsFloatManager::SavedState* aFloatStateBeforeLine, bool* aKeepReflowGoing,
+ LineReflowStatus* aLineReflowStatus, bool aAllowPullUp) {
+ // Forget all of the floats on the line
+ aLine->ClearFloats();
+ aState.mFloatOverflowAreas.Clear();
+
+ // We need to set this flag on the line if any of our reflow passes
+ // are impacted by floats.
+ if (aFloatAvailableSpace.HasFloats()) {
+ aLine->SetLineIsImpactedByFloat(true);
+ }
+#ifdef REALLY_NOISY_REFLOW
+ printf("nsBlockFrame::DoReflowInlineFrames %p impacted = %d\n", this,
+ aFloatAvailableSpace.HasFloats());
+#endif
+
+ WritingMode outerWM = aState.mReflowInput.GetWritingMode();
+ WritingMode lineWM = WritingModeForLine(outerWM, aLine->mFirstChild);
+ LogicalRect lineRect = aFloatAvailableSpace.mRect.ConvertTo(
+ lineWM, outerWM, aState.ContainerSize());
+
+ nscoord iStart = lineRect.IStart(lineWM);
+ nscoord availISize = lineRect.ISize(lineWM);
+ nscoord availBSize;
+ if (aState.mReflowInput.AvailableBSize() == NS_UNCONSTRAINEDSIZE) {
+ availBSize = NS_UNCONSTRAINEDSIZE;
+ } else {
+ /* XXX get the height right! */
+ availBSize = lineRect.BSize(lineWM);
+ }
+
+ // Make sure to enable resize optimization before we call BeginLineReflow
+ // because it might get disabled there
+ aLine->EnableResizeReflowOptimization();
+
+ aLineLayout.BeginLineReflow(
+ iStart, aState.mBCoord, availISize, availBSize,
+ aFloatAvailableSpace.HasFloats(), false, /*XXX isTopOfPage*/
+ lineWM, aState.mContainerSize, aState.mInsetForBalance);
+
+ aState.mFlags.mIsLineLayoutEmpty = false;
+
+ // XXX Unfortunately we need to know this before reflowing the first
+ // inline frame in the line. FIX ME.
+ if (0 == aLineLayout.GetLineNumber() &&
+ HasAllStateBits(NS_BLOCK_HAS_FIRST_LETTER_CHILD |
+ NS_BLOCK_HAS_FIRST_LETTER_STYLE)) {
+ aLineLayout.SetFirstLetterStyleOK(true);
+ }
+ NS_ASSERTION(!(HasAnyStateBits(NS_BLOCK_HAS_FIRST_LETTER_CHILD) &&
+ GetPrevContinuation()),
+ "first letter child bit should only be on first continuation");
+
+ // Reflow the frames that are already on the line first
+ LineReflowStatus lineReflowStatus = LineReflowStatus::OK;
+ int32_t i;
+ nsIFrame* frame = aLine->mFirstChild;
+
+ if (aFloatAvailableSpace.HasFloats()) {
+ // There is a soft break opportunity at the start of the line, because
+ // we can always move this line down below float(s).
+ if (aLineLayout.NotifyOptionalBreakPosition(
+ frame, 0, true, gfxBreakPriority::eNormalBreak)) {
+ lineReflowStatus = LineReflowStatus::RedoNextBand;
+ }
+ }
+
+ // need to repeatedly call GetChildCount here, because the child
+ // count can change during the loop!
+ for (i = 0;
+ LineReflowStatus::OK == lineReflowStatus && i < aLine->GetChildCount();
+ i++, frame = frame->GetNextSibling()) {
+ ReflowInlineFrame(aState, aLineLayout, aLine, frame, &lineReflowStatus);
+ if (LineReflowStatus::OK != lineReflowStatus) {
+ // It is possible that one or more of next lines are empty
+ // (because of DeleteNextInFlowChild). If so, delete them now
+ // in case we are finished.
+ ++aLine;
+ while ((aLine != LinesEnd()) && (0 == aLine->GetChildCount())) {
+ // XXX Is this still necessary now that DeleteNextInFlowChild
+ // uses DoRemoveFrame?
+ nsLineBox* toremove = aLine;
+ aLine = mLines.erase(aLine);
+ NS_ASSERTION(nullptr == toremove->mFirstChild, "bad empty line");
+ FreeLineBox(toremove);
+ }
+ --aLine;
+
+ NS_ASSERTION(lineReflowStatus != LineReflowStatus::Truncated,
+ "ReflowInlineFrame should never determine that a line "
+ "needs to go to the next page/column");
+ }
+ }
+
+ // Don't pull up new frames into lines with continuation placeholders
+ if (aAllowPullUp) {
+ // Pull frames and reflow them until we can't
+ while (LineReflowStatus::OK == lineReflowStatus) {
+ frame = PullFrame(aState, aLine);
+ if (!frame) {
+ break;
+ }
+
+ while (LineReflowStatus::OK == lineReflowStatus) {
+ int32_t oldCount = aLine->GetChildCount();
+ ReflowInlineFrame(aState, aLineLayout, aLine, frame, &lineReflowStatus);
+ if (aLine->GetChildCount() != oldCount) {
+ // We just created a continuation for aFrame AND its going
+ // to end up on this line (e.g. :first-letter
+ // situation). Therefore we have to loop here before trying
+ // to pull another frame.
+ frame = frame->GetNextSibling();
+ } else {
+ break;
+ }
+ }
+ }
+ }
+
+ aState.mFlags.mIsLineLayoutEmpty = aLineLayout.LineIsEmpty();
+
+ // We only need to backup if the line isn't going to be reflowed again anyway
+ bool needsBackup = aLineLayout.NeedsBackup() &&
+ (lineReflowStatus == LineReflowStatus::Stop ||
+ lineReflowStatus == LineReflowStatus::OK);
+ if (needsBackup && aLineLayout.HaveForcedBreakPosition()) {
+ NS_WARNING(
+ "We shouldn't be backing up more than once! "
+ "Someone must have set a break opportunity beyond the available width, "
+ "even though there were better break opportunities before it");
+ needsBackup = false;
+ }
+ if (needsBackup) {
+ // We need to try backing up to before a text run
+ // XXX It's possible, in fact not unusual, for the break opportunity to
+ // already be the end of the line. We should detect that and optimize to not
+ // re-do the line.
+ if (aLineLayout.HasOptionalBreakPosition()) {
+ // We can back up!
+ lineReflowStatus = LineReflowStatus::RedoNoPull;
+ }
+ } else {
+ // In case we reflow this line again, remember that we don't
+ // need to force any breaking
+ aLineLayout.ClearOptionalBreakPosition();
+ }
+
+ if (LineReflowStatus::RedoNextBand == lineReflowStatus) {
+ // This happens only when we have a line that is impacted by
+ // floats and the first element in the line doesn't fit with
+ // the floats.
+ //
+ // If there's block space available, we either try to reflow the line
+ // past the current band (if it's non-zero and the band definitely won't
+ // widen around a shape-outside), otherwise we try one pixel down. If
+ // there's no block space available, we push the line to the next
+ // page/column.
+ NS_ASSERTION(
+ NS_UNCONSTRAINEDSIZE != aFloatAvailableSpace.mRect.BSize(outerWM),
+ "unconstrained block size on totally empty line");
+
+ // See the analogous code for blocks in BlockReflowState::ClearFloats.
+ nscoord bandBSize = aFloatAvailableSpace.mRect.BSize(outerWM);
+ if (bandBSize > 0 ||
+ NS_UNCONSTRAINEDSIZE == aState.mReflowInput.AvailableBSize()) {
+ NS_ASSERTION(bandBSize == 0 || aFloatAvailableSpace.HasFloats(),
+ "redo line on totally empty line with non-empty band...");
+ // We should never hit this case if we've placed floats on the
+ // line; if we have, then the GetFloatAvailableSpace call is wrong
+ // and needs to happen after the caller pops the float manager
+ // state.
+ aState.FloatManager()->AssertStateMatches(aFloatStateBeforeLine);
+
+ if (!aFloatAvailableSpace.MayWiden() && bandBSize > 0) {
+ // Move it down far enough to clear the current band.
+ aState.mBCoord += bandBSize;
+ } else {
+ // Move it down by one dev pixel.
+ aState.mBCoord += aState.mPresContext->DevPixelsToAppUnits(1);
+ }
+
+ aFloatAvailableSpace = aState.GetFloatAvailableSpace();
+ } else {
+ // There's nowhere to retry placing the line, so we want to push
+ // it to the next page/column where its contents can fit not
+ // next to a float.
+ lineReflowStatus = LineReflowStatus::Truncated;
+ PushTruncatedLine(aState, aLine, aKeepReflowGoing);
+ }
+
+ // XXX: a small optimization can be done here when paginating:
+ // if the new Y coordinate is past the end of the block then
+ // push the line and return now instead of later on after we are
+ // past the float.
+ } else if (LineReflowStatus::Truncated != lineReflowStatus &&
+ LineReflowStatus::RedoNoPull != lineReflowStatus) {
+ // If we are propagating out a break-before status then there is
+ // no point in placing the line.
+ if (!aState.mReflowStatus.IsInlineBreakBefore()) {
+ if (!PlaceLine(aState, aLineLayout, aLine, aFloatStateBeforeLine,
+ aFloatAvailableSpace, aAvailableSpaceBSize,
+ aKeepReflowGoing)) {
+ lineReflowStatus = LineReflowStatus::RedoMoreFloats;
+ // PlaceLine already called GetFloatAvailableSpaceForBSize or its
+ // variant for us.
+ }
+ }
+ }
+#ifdef DEBUG
+ if (gNoisyReflow) {
+ printf("Line reflow status = %s\n",
+ LineReflowStatusToString(lineReflowStatus));
+ }
+#endif
+
+ if (aLineLayout.GetDirtyNextLine()) {
+ // aLine may have been pushed to the overflow lines.
+ FrameLines* overflowLines = GetOverflowLines();
+ // We can't just compare iterators front() to aLine here, since they may be
+ // in different lists.
+ bool pushedToOverflowLines =
+ overflowLines && overflowLines->mLines.front() == aLine.get();
+ if (pushedToOverflowLines) {
+ // aLine is stale, it's associated with the main line list but it should
+ // be associated with the overflow line list now
+ aLine = overflowLines->mLines.begin();
+ }
+ nsBlockInFlowLineIterator iter(this, aLine, pushedToOverflowLines);
+ if (iter.Next() && iter.GetLine()->IsInline()) {
+ iter.GetLine()->MarkDirty();
+ if (iter.GetContainer() != this) {
+ aState.mReflowStatus.SetNextInFlowNeedsReflow();
+ }
+ }
+ }
+
+ *aLineReflowStatus = lineReflowStatus;
+}
+
+/**
+ * Reflow an inline frame. The reflow status is mapped from the frames
+ * reflow status to the lines reflow status (not to our reflow status).
+ * The line reflow status is simple: true means keep placing frames
+ * on the line; false means don't (the line is done). If the line
+ * has some sort of breaking affect then aLine's break-type will be set
+ * to something other than StyleClear::None.
+ */
+void nsBlockFrame::ReflowInlineFrame(BlockReflowState& aState,
+ nsLineLayout& aLineLayout,
+ LineIterator aLine, nsIFrame* aFrame,
+ LineReflowStatus* aLineReflowStatus) {
+ MOZ_ASSERT(aFrame);
+ *aLineReflowStatus = LineReflowStatus::OK;
+
+#ifdef NOISY_FIRST_LETTER
+ ListTag(stdout);
+ printf(": reflowing ");
+ aFrame->ListTag(stdout);
+ printf(" reflowingFirstLetter=%s\n",
+ aLineLayout.GetFirstLetterStyleOK() ? "on" : "off");
+#endif
+
+ if (aFrame->IsPlaceholderFrame()) {
+ auto ph = static_cast<nsPlaceholderFrame*>(aFrame);
+ ph->ForgetLineIsEmptySoFar();
+ }
+
+ // Reflow the inline frame
+ nsReflowStatus frameReflowStatus;
+ bool pushedFrame;
+ aLineLayout.ReflowFrame(aFrame, frameReflowStatus, nullptr, pushedFrame);
+
+ if (frameReflowStatus.NextInFlowNeedsReflow()) {
+ aLineLayout.SetDirtyNextLine();
+ }
+
+#ifdef REALLY_NOISY_REFLOW
+ aFrame->ListTag(stdout);
+ printf(": status=%s\n", ToString(frameReflowStatus).c_str());
+#endif
+
+#if defined(REFLOW_STATUS_COVERAGE)
+ RecordReflowStatus(false, frameReflowStatus);
+#endif
+
+ // Send post-reflow notification
+ aState.mPrevChild = aFrame;
+
+ /* XXX
+ This is where we need to add logic to handle some odd behavior.
+ For one thing, we should usually place at least one thing next
+ to a left float, even when that float takes up all the width on a line.
+ see bug 22496
+ */
+
+ // Process the child frames reflow status. There are 5 cases:
+ // complete, not-complete, break-before, break-after-complete,
+ // break-after-not-complete. There are two situations: we are a
+ // block or we are an inline. This makes a total of 10 cases
+ // (fortunately, there is some overlap).
+ aLine->ClearForcedLineBreak();
+ if (frameReflowStatus.IsInlineBreak() ||
+ aState.mTrailingClearFromPIF != StyleClear::None) {
+ // Always abort the line reflow (because a line break is the
+ // minimal amount of break we do).
+ *aLineReflowStatus = LineReflowStatus::Stop;
+
+ // XXX what should aLine's break-type be set to in all these cases?
+ if (frameReflowStatus.IsInlineBreakBefore()) {
+ // Break-before cases.
+ if (aFrame == aLine->mFirstChild) {
+ // If we break before the first frame on the line then we must
+ // be trying to place content where there's no room (e.g. on a
+ // line with wide floats). Inform the caller to reflow the
+ // line after skipping past a float.
+ *aLineReflowStatus = LineReflowStatus::RedoNextBand;
+ } else {
+ // It's not the first child on this line so go ahead and split
+ // the line. We will see the frame again on the next-line.
+ SplitLine(aState, aLineLayout, aLine, aFrame, aLineReflowStatus);
+
+ // If we're splitting the line because the frame didn't fit and it
+ // was pushed, then mark the line as having word wrapped. We need to
+ // know that if we're shrink wrapping our width
+ if (pushedFrame) {
+ aLine->SetLineWrapped(true);
+ }
+ }
+ } else {
+ MOZ_ASSERT(frameReflowStatus.IsInlineBreakAfter() ||
+ aState.mTrailingClearFromPIF != StyleClear::None,
+ "We should've handled inline break-before in the if-branch!");
+
+ // If a float split and its prev-in-flow was followed by a <BR>, then
+ // combine the <BR>'s float clear type with the inline's float clear type
+ // (the inline will be the very next frame after the split float).
+ StyleClear clearType = frameReflowStatus.FloatClearType();
+ if (aState.mTrailingClearFromPIF != StyleClear::None) {
+ clearType = nsLayoutUtils::CombineClearType(
+ clearType, aState.mTrailingClearFromPIF);
+ aState.mTrailingClearFromPIF = StyleClear::None;
+ }
+ // Break-after cases
+ if (clearType != StyleClear::None || aLineLayout.GetLineEndsInBR()) {
+ aLine->SetForcedLineBreakAfter(clearType);
+ }
+ if (frameReflowStatus.IsComplete()) {
+ // Split line, but after the frame just reflowed
+ SplitLine(aState, aLineLayout, aLine, aFrame->GetNextSibling(),
+ aLineReflowStatus);
+
+ if (frameReflowStatus.IsInlineBreakAfter() &&
+ !aLineLayout.GetLineEndsInBR()) {
+ aLineLayout.SetDirtyNextLine();
+ }
+ }
+ }
+ }
+
+ if (!frameReflowStatus.IsFullyComplete()) {
+ // Create a continuation for the incomplete frame. Note that the
+ // frame may already have a continuation.
+ CreateContinuationFor(aState, aLine, aFrame);
+
+ // Remember that the line has wrapped
+ if (!aLineLayout.GetLineEndsInBR()) {
+ aLine->SetLineWrapped(true);
+ }
+
+ // If we just ended a first-letter frame or reflowed a placeholder then
+ // don't split the line and don't stop the line reflow...
+ // But if we are going to stop anyways we'd better split the line.
+ if ((!frameReflowStatus.FirstLetterComplete() &&
+ !aFrame->IsPlaceholderFrame()) ||
+ *aLineReflowStatus == LineReflowStatus::Stop) {
+ // Split line after the current frame
+ *aLineReflowStatus = LineReflowStatus::Stop;
+ SplitLine(aState, aLineLayout, aLine, aFrame->GetNextSibling(),
+ aLineReflowStatus);
+ }
+ }
+}
+
+bool nsBlockFrame::CreateContinuationFor(BlockReflowState& aState,
+ nsLineBox* aLine, nsIFrame* aFrame) {
+ nsIFrame* newFrame = nullptr;
+
+ if (!aFrame->GetNextInFlow()) {
+ newFrame =
+ PresShell()->FrameConstructor()->CreateContinuingFrame(aFrame, this);
+
+ mFrames.InsertFrame(nullptr, aFrame, newFrame);
+
+ if (aLine) {
+ aLine->NoteFrameAdded(newFrame);
+ }
+ }
+#ifdef DEBUG
+ VerifyLines(false);
+#endif
+ return !!newFrame;
+}
+
+void nsBlockFrame::SplitFloat(BlockReflowState& aState, nsIFrame* aFloat,
+ const nsReflowStatus& aFloatStatus) {
+ MOZ_ASSERT(!aFloatStatus.IsFullyComplete(),
+ "why split the frame if it's fully complete?");
+ MOZ_ASSERT(aState.mBlock == this);
+
+ nsIFrame* nextInFlow = aFloat->GetNextInFlow();
+ if (nextInFlow) {
+ nsContainerFrame* oldParent = nextInFlow->GetParent();
+ oldParent->StealFrame(nextInFlow);
+ if (oldParent != this) {
+ ReparentFrame(nextInFlow, oldParent, this);
+ }
+ if (!aFloatStatus.IsOverflowIncomplete()) {
+ nextInFlow->RemoveStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER);
+ }
+ } else {
+ nextInFlow =
+ PresShell()->FrameConstructor()->CreateContinuingFrame(aFloat, this);
+ }
+ if (aFloatStatus.IsOverflowIncomplete()) {
+ nextInFlow->AddStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER);
+ }
+
+ StyleFloat floatStyle = aFloat->StyleDisplay()->mFloat;
+ if (floatStyle == StyleFloat::Left) {
+ aState.FloatManager()->SetSplitLeftFloatAcrossBreak();
+ } else {
+ MOZ_ASSERT(floatStyle == StyleFloat::Right, "Unexpected float side!");
+ aState.FloatManager()->SetSplitRightFloatAcrossBreak();
+ }
+
+ aState.AppendPushedFloatChain(nextInFlow);
+ if (MOZ_LIKELY(!HasAnyStateBits(NS_BLOCK_BFC_STATE_BITS)) ||
+ MOZ_UNLIKELY(IsTrueOverflowContainer())) {
+ aState.mReflowStatus.SetOverflowIncomplete();
+ } else {
+ aState.mReflowStatus.SetIncomplete();
+ }
+}
+
+static bool CheckPlaceholderInLine(nsIFrame* aBlock, nsLineBox* aLine,
+ nsIFrame* aFloat) {
+ if (!aFloat) {
+ return true;
+ }
+ NS_ASSERTION(!aFloat->GetPrevContinuation(),
+ "float in a line should never be a continuation");
+ NS_ASSERTION(!aFloat->HasAnyStateBits(NS_FRAME_IS_PUSHED_FLOAT),
+ "float in a line should never be a pushed float");
+ nsIFrame* ph = aFloat->FirstInFlow()->GetPlaceholderFrame();
+ for (nsIFrame* f = ph; f; f = f->GetParent()) {
+ if (f->GetParent() == aBlock) {
+ return aLine->Contains(f);
+ }
+ }
+ NS_ASSERTION(false, "aBlock is not an ancestor of aFrame!");
+ return true;
+}
+
+void nsBlockFrame::SplitLine(BlockReflowState& aState,
+ nsLineLayout& aLineLayout, LineIterator aLine,
+ nsIFrame* aFrame,
+ LineReflowStatus* aLineReflowStatus) {
+ MOZ_ASSERT(aLine->IsInline(), "illegal SplitLine on block line");
+
+ int32_t pushCount =
+ aLine->GetChildCount() - aLineLayout.GetCurrentSpanCount();
+ MOZ_ASSERT(pushCount >= 0, "bad push count");
+
+#ifdef DEBUG
+ if (gNoisyReflow) {
+ nsIFrame::IndentBy(stdout, gNoiseIndent);
+ printf("split line: from line=%p pushCount=%d aFrame=",
+ static_cast<void*>(aLine.get()), pushCount);
+ if (aFrame) {
+ aFrame->ListTag(stdout);
+ } else {
+ printf("(null)");
+ }
+ printf("\n");
+ if (gReallyNoisyReflow) {
+ aLine->List(stdout, gNoiseIndent + 1);
+ }
+ }
+#endif
+
+ if (0 != pushCount) {
+ MOZ_ASSERT(aLine->GetChildCount() > pushCount, "bad push");
+ MOZ_ASSERT(nullptr != aFrame, "whoops");
+#ifdef DEBUG
+ {
+ nsIFrame* f = aFrame;
+ int32_t count = pushCount;
+ while (f && count > 0) {
+ f = f->GetNextSibling();
+ --count;
+ }
+ NS_ASSERTION(count == 0, "Not enough frames to push");
+ }
+#endif
+
+ // Put frames being split out into their own line
+ nsLineBox* newLine = NewLineBox(aLine, aFrame, pushCount);
+ mLines.after_insert(aLine, newLine);
+#ifdef DEBUG
+ if (gReallyNoisyReflow) {
+ newLine->List(stdout, gNoiseIndent + 1);
+ }
+#endif
+
+ // Let line layout know that some frames are no longer part of its
+ // state.
+ aLineLayout.SplitLineTo(aLine->GetChildCount());
+
+ // If floats have been placed whose placeholders have been pushed to the new
+ // line, we need to reflow the old line again. We don't want to look at the
+ // frames in the new line, because as a large paragraph is laid out the
+ // we'd get O(N^2) performance. So instead we just check that the last
+ // float and the last below-current-line float are still in aLine.
+ if (!CheckPlaceholderInLine(
+ this, aLine,
+ aLine->HasFloats() ? aLine->Floats().LastElement() : nullptr) ||
+ !CheckPlaceholderInLine(
+ this, aLine,
+ aState.mBelowCurrentLineFloats.SafeLastElement(nullptr))) {
+ *aLineReflowStatus = LineReflowStatus::RedoNoPull;
+ }
+
+#ifdef DEBUG
+ VerifyLines(true);
+#endif
+ }
+}
+
+bool nsBlockFrame::IsLastLine(BlockReflowState& aState, LineIterator aLine) {
+ while (++aLine != LinesEnd()) {
+ // There is another line
+ if (0 != aLine->GetChildCount()) {
+ // If the next line is a block line then this line is the last in a
+ // group of inline lines.
+ return aLine->IsBlock();
+ }
+ // The next line is empty, try the next one
+ }
+
+ // Try our next-in-flows lines to answer the question
+ nsBlockFrame* nextInFlow = (nsBlockFrame*)GetNextInFlow();
+ while (nullptr != nextInFlow) {
+ for (const auto& line : nextInFlow->Lines()) {
+ if (0 != line.GetChildCount()) {
+ return line.IsBlock();
+ }
+ }
+ nextInFlow = (nsBlockFrame*)nextInFlow->GetNextInFlow();
+ }
+
+ // This is the last line - so don't allow justification
+ return true;
+}
+
+bool nsBlockFrame::PlaceLine(BlockReflowState& aState,
+ nsLineLayout& aLineLayout, LineIterator aLine,
+ nsFloatManager::SavedState* aFloatStateBeforeLine,
+ nsFlowAreaRect& aFlowArea,
+ nscoord& aAvailableSpaceBSize,
+ bool* aKeepReflowGoing) {
+ // Try to position the floats in a nowrap context.
+ aLineLayout.FlushNoWrapFloats();
+
+ // Trim extra white-space from the line before placing the frames
+ aLineLayout.TrimTrailingWhiteSpace();
+
+ // Vertically align the frames on this line.
+ //
+ // According to the CSS2 spec, section 12.6.1, the "marker" box
+ // participates in the height calculation of the list-item box's
+ // first line box.
+ //
+ // There are exactly two places a ::marker can be placed: near the
+ // first or second line. It's only placed on the second line in a
+ // rare case: when the first line is empty.
+ WritingMode wm = aState.mReflowInput.GetWritingMode();
+ bool addedMarker = false;
+ if (HasOutsideMarker() &&
+ ((aLine == mLines.front() &&
+ (!aLineLayout.IsZeroBSize() || (aLine == mLines.back()))) ||
+ (mLines.front() != mLines.back() && 0 == mLines.front()->BSize() &&
+ aLine == mLines.begin().next()))) {
+ ReflowOutput metrics(aState.mReflowInput);
+ nsIFrame* marker = GetOutsideMarker();
+ ReflowOutsideMarker(marker, aState, metrics, aState.mBCoord);
+ NS_ASSERTION(!MarkerIsEmpty() || metrics.BSize(wm) == 0,
+ "empty ::marker frame took up space");
+ aLineLayout.AddMarkerFrame(marker, metrics);
+ addedMarker = true;
+ }
+ aLineLayout.VerticalAlignLine();
+
+ // We want to consider the floats in the current line when determining
+ // whether the float available space is shrunk. If mLineBSize doesn't
+ // exist, we are in the first pass trying to place the line. Calling
+ // GetFloatAvailableSpace() like we did in BlockReflowState::AddFloat()
+ // for UpdateBand().
+
+ // floatAvailableSpaceWithOldLineBSize is the float available space with
+ // the old BSize, but including the floats that were added in this line.
+ LogicalRect floatAvailableSpaceWithOldLineBSize =
+ aState.mLineBSize.isNothing()
+ ? aState.GetFloatAvailableSpace(aLine->BStart()).mRect
+ : aState
+ .GetFloatAvailableSpaceForBSize(
+ aLine->BStart(), aState.mLineBSize.value(), nullptr)
+ .mRect;
+
+ // As we redo for floats, we can't reduce the amount of BSize we're
+ // checking.
+ aAvailableSpaceBSize = std::max(aAvailableSpaceBSize, aLine->BSize());
+ LogicalRect floatAvailableSpaceWithLineBSize =
+ aState
+ .GetFloatAvailableSpaceForBSize(aLine->BStart(), aAvailableSpaceBSize,
+ nullptr)
+ .mRect;
+
+ // If the available space between the floats is smaller now that we
+ // know the BSize, return false (and cause another pass with
+ // LineReflowStatus::RedoMoreFloats). We ensure aAvailableSpaceBSize
+ // never decreases, which means that we can't reduce the set of floats
+ // we intersect, which means that the available space cannot grow.
+ if (AvailableSpaceShrunk(wm, floatAvailableSpaceWithOldLineBSize,
+ floatAvailableSpaceWithLineBSize, false)) {
+ // Prepare data for redoing the line.
+ aState.mLineBSize = Some(aLine->BSize());
+
+ // Since we want to redo the line, we update aFlowArea by using the
+ // aFloatStateBeforeLine, which is the float manager's state before the
+ // line is placed.
+ LogicalRect oldFloatAvailableSpace(aFlowArea.mRect);
+ aFlowArea = aState.GetFloatAvailableSpaceForBSize(
+ aLine->BStart(), aAvailableSpaceBSize, aFloatStateBeforeLine);
+
+ NS_ASSERTION(
+ aFlowArea.mRect.BStart(wm) == oldFloatAvailableSpace.BStart(wm),
+ "yikes");
+ // Restore the BSize to the position of the next band.
+ aFlowArea.mRect.BSize(wm) = oldFloatAvailableSpace.BSize(wm);
+
+ // Enforce both IStart() and IEnd() never move outwards to prevent
+ // infinite grow-shrink loops.
+ const nscoord iStartDiff =
+ aFlowArea.mRect.IStart(wm) - oldFloatAvailableSpace.IStart(wm);
+ const nscoord iEndDiff =
+ aFlowArea.mRect.IEnd(wm) - oldFloatAvailableSpace.IEnd(wm);
+ if (iStartDiff < 0) {
+ aFlowArea.mRect.IStart(wm) -= iStartDiff;
+ aFlowArea.mRect.ISize(wm) += iStartDiff;
+ }
+ if (iEndDiff > 0) {
+ aFlowArea.mRect.ISize(wm) -= iEndDiff;
+ }
+
+ return false;
+ }
+
+#ifdef DEBUG
+ if (!GetParent()->IsAbsurdSizeAssertSuppressed()) {
+ static nscoord lastHeight = 0;
+ if (ABSURD_SIZE(aLine->BStart())) {
+ lastHeight = aLine->BStart();
+ if (abs(aLine->BStart() - lastHeight) > ABSURD_COORD / 10) {
+ nsIFrame::ListTag(stdout);
+ printf(": line=%p y=%d line.bounds.height=%d\n",
+ static_cast<void*>(aLine.get()), aLine->BStart(),
+ aLine->BSize());
+ }
+ } else {
+ lastHeight = 0;
+ }
+ }
+#endif
+
+ // Only block frames horizontally align their children because
+ // inline frames "shrink-wrap" around their children (therefore
+ // there is no extra horizontal space).
+ const nsStyleText* styleText = StyleText();
+
+ /**
+ * We don't care checking for IsLastLine properly if we don't care (if it
+ * can't change the used text-align value for the line).
+ *
+ * In other words, isLastLine really means isLastLineAndWeCare.
+ */
+ const bool isLastLine =
+ !IsInSVGTextSubtree() &&
+ styleText->TextAlignForLastLine() != styleText->mTextAlign &&
+ (aLineLayout.GetLineEndsInBR() || IsLastLine(aState, aLine));
+
+ aLineLayout.TextAlignLine(aLine, isLastLine);
+
+ // From here on, pfd->mBounds rectangles are incorrect because bidi
+ // might have moved frames around!
+ OverflowAreas overflowAreas;
+ aLineLayout.RelativePositionFrames(overflowAreas);
+ aLine->SetOverflowAreas(overflowAreas);
+ if (addedMarker) {
+ aLineLayout.RemoveMarkerFrame(GetOutsideMarker());
+ }
+
+ // Inline lines do not have margins themselves; however they are
+ // impacted by prior block margins. If this line ends up having some
+ // height then we zero out the previous block-end margin value that was
+ // already applied to the line's starting Y coordinate. Otherwise we
+ // leave it be so that the previous blocks block-end margin can be
+ // collapsed with a block that follows.
+ nscoord newBCoord;
+
+ if (!aLine->CachedIsEmpty()) {
+ // This line has some height. Therefore the application of the
+ // previous-bottom-margin should stick.
+ aState.mPrevBEndMargin.Zero();
+ newBCoord = aLine->BEnd();
+ } else {
+ // Don't let the previous-bottom-margin value affect the newBCoord
+ // coordinate (it was applied in ReflowInlineFrames speculatively)
+ // since the line is empty.
+ // We already called |ShouldApplyBStartMargin|, and if we applied it
+ // then mShouldApplyBStartMargin is set.
+ nscoord dy = aState.mFlags.mShouldApplyBStartMargin
+ ? -aState.mPrevBEndMargin.get()
+ : 0;
+ newBCoord = aState.mBCoord + dy;
+ }
+
+ if (!aState.mReflowStatus.IsFullyComplete() &&
+ ShouldAvoidBreakInside(aState.mReflowInput)) {
+ aLine->AppendFloats(std::move(aState.mCurrentLineFloats));
+ SetBreakBeforeStatusBeforeLine(aState, aLine, aKeepReflowGoing);
+ return true;
+ }
+
+ // See if the line fit (our first line always does).
+ if (mLines.front() != aLine &&
+ aState.ContentBSize() != NS_UNCONSTRAINEDSIZE &&
+ newBCoord > aState.ContentBEnd()) {
+ NS_ASSERTION(aState.mCurrentLine == aLine, "oops");
+ if (ShouldAvoidBreakInside(aState.mReflowInput)) {
+ // All our content doesn't fit, start on the next page.
+ SetBreakBeforeStatusBeforeLine(aState, aLine, aKeepReflowGoing);
+ } else {
+ // Push aLine and all of its children and anything else that
+ // follows to our next-in-flow.
+ PushTruncatedLine(aState, aLine, aKeepReflowGoing);
+ }
+ return true;
+ }
+
+ // Note that any early return before this update of aState.mBCoord
+ // must either (a) return false or (b) set aKeepReflowGoing to false.
+ // Otherwise we'll keep reflowing later lines at an incorrect
+ // position, and we might not come back and clean up the damage later.
+ aState.mBCoord = newBCoord;
+
+ // Add the already placed current-line floats to the line
+ aLine->AppendFloats(std::move(aState.mCurrentLineFloats));
+
+ // Any below current line floats to place?
+ if (!aState.mBelowCurrentLineFloats.IsEmpty()) {
+ // Reflow the below-current-line floats, which places on the line's
+ // float list.
+ aState.PlaceBelowCurrentLineFloats(aLine);
+ }
+
+ // When a line has floats, factor them into the overflow areas computations.
+ if (aLine->HasFloats()) {
+ // Union the float overflow areas (stored in aState) and the value computed
+ // by the line layout code.
+ OverflowAreas lineOverflowAreas = aState.mFloatOverflowAreas;
+ lineOverflowAreas.UnionWith(aLine->GetOverflowAreas());
+ aLine->SetOverflowAreas(lineOverflowAreas);
+
+#ifdef NOISY_OVERFLOW_AREAS
+ printf("%s: Line %p, InkOverflowRect=%s, ScrollableOverflowRect=%s\n",
+ ListTag().get(), aLine.get(),
+ ToString(aLine->InkOverflowRect()).c_str(),
+ ToString(aLine->ScrollableOverflowRect()).c_str());
+#endif
+ }
+
+ // Apply break-after clearing if necessary
+ // This must stay in sync with |ReflowDirtyLines|.
+ if (aLine->HasFloatClearTypeAfter()) {
+ std::tie(aState.mBCoord, std::ignore) =
+ aState.ClearFloats(aState.mBCoord, aLine->FloatClearTypeAfter());
+ }
+ return true;
+}
+
+void nsBlockFrame::PushLines(BlockReflowState& aState,
+ nsLineList::iterator aLineBefore) {
+ // NOTE: aLineBefore is always a normal line, not an overflow line.
+ // The following expression will assert otherwise.
+ DebugOnly<bool> check = aLineBefore == mLines.begin();
+
+ nsLineList::iterator overBegin(aLineBefore.next());
+
+ // PushTruncatedPlaceholderLine sometimes pushes the first line. Ugh.
+ bool firstLine = overBegin == LinesBegin();
+
+ if (overBegin != LinesEnd()) {
+ // Remove floats in the lines from mFloats
+ nsFrameList floats;
+ CollectFloats(overBegin->mFirstChild, floats, true);
+
+ if (floats.NotEmpty()) {
+#ifdef DEBUG
+ for (nsIFrame* f : floats) {
+ MOZ_ASSERT(!f->HasAnyStateBits(NS_FRAME_IS_PUSHED_FLOAT),
+ "CollectFloats should've removed that bit");
+ }
+#endif
+ // Push the floats onto the front of the overflow out-of-flows list
+ nsAutoOOFFrameList oofs(this);
+ oofs.mList.InsertFrames(nullptr, nullptr, std::move(floats));
+ }
+
+ // overflow lines can already exist in some cases, in particular,
+ // when shrinkwrapping and we discover that the shrinkwap causes
+ // the height of some child block to grow which creates additional
+ // overflowing content. In such cases we must prepend the new
+ // overflow to the existing overflow.
+ FrameLines* overflowLines = RemoveOverflowLines();
+ if (!overflowLines) {
+ // XXXldb use presshell arena!
+ overflowLines = new FrameLines();
+ }
+ if (overflowLines) {
+ nsIFrame* lineBeforeLastFrame;
+ if (firstLine) {
+ lineBeforeLastFrame = nullptr; // removes all frames
+ } else {
+ nsIFrame* f = overBegin->mFirstChild;
+ lineBeforeLastFrame = f ? f->GetPrevSibling() : mFrames.LastChild();
+ NS_ASSERTION(!f || lineBeforeLastFrame == aLineBefore->LastChild(),
+ "unexpected line frames");
+ }
+ nsFrameList pushedFrames = mFrames.TakeFramesAfter(lineBeforeLastFrame);
+ overflowLines->mFrames.InsertFrames(nullptr, nullptr,
+ std::move(pushedFrames));
+
+ overflowLines->mLines.splice(overflowLines->mLines.begin(), mLines,
+ overBegin, LinesEnd());
+ NS_ASSERTION(!overflowLines->mLines.empty(), "should not be empty");
+ // this takes ownership but it won't delete it immediately so we
+ // can keep using it.
+ SetOverflowLines(overflowLines);
+
+ // Mark all the overflow lines dirty so that they get reflowed when
+ // they are pulled up by our next-in-flow.
+
+ // XXXldb Can this get called O(N) times making the whole thing O(N^2)?
+ for (LineIterator line = overflowLines->mLines.begin(),
+ line_end = overflowLines->mLines.end();
+ line != line_end; ++line) {
+ line->MarkDirty();
+ line->MarkPreviousMarginDirty();
+ line->SetMovedFragments();
+ line->SetBoundsEmpty();
+ if (line->HasFloats()) {
+ line->ClearFloats();
+ }
+ }
+ }
+ }
+
+#ifdef DEBUG
+ VerifyOverflowSituation();
+#endif
+}
+
+// The overflowLines property is stored as a pointer to a line list,
+// which must be deleted. However, the following functions all maintain
+// the invariant that the property is never set if the list is empty.
+
+bool nsBlockFrame::DrainOverflowLines() {
+#ifdef DEBUG
+ VerifyOverflowSituation();
+#endif
+
+ // Steal the prev-in-flow's overflow lines and prepend them.
+ bool didFindOverflow = false;
+ nsBlockFrame* prevBlock = static_cast<nsBlockFrame*>(GetPrevInFlow());
+ if (prevBlock) {
+ prevBlock->ClearLineCursors();
+ FrameLines* overflowLines = prevBlock->RemoveOverflowLines();
+ if (overflowLines) {
+ // Make all the frames on the overflow line list mine.
+ ReparentFrames(overflowLines->mFrames, prevBlock, this);
+
+ // Collect overflow containers from our OverflowContainers list that are
+ // continuations from the frames we picked up from our prev-in-flow, then
+ // prepend those to ExcessOverflowContainers to ensure the continuations
+ // are ordered.
+ if (GetOverflowContainers()) {
+ nsFrameList ocContinuations;
+ for (auto* f : overflowLines->mFrames) {
+ auto* cont = f;
+ bool done = false;
+ while (!done && (cont = cont->GetNextContinuation()) &&
+ cont->GetParent() == this) {
+ bool onlyChild = !cont->GetPrevSibling() && !cont->GetNextSibling();
+ if (cont->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER) &&
+ TryRemoveFrame(OverflowContainersProperty(), cont)) {
+ ocContinuations.AppendFrame(nullptr, cont);
+ done = onlyChild;
+ continue;
+ }
+ break;
+ }
+ if (done) {
+ break;
+ }
+ }
+ if (!ocContinuations.IsEmpty()) {
+ if (nsFrameList* eoc = GetExcessOverflowContainers()) {
+ eoc->InsertFrames(nullptr, nullptr, std::move(ocContinuations));
+ } else {
+ SetExcessOverflowContainers(std::move(ocContinuations));
+ }
+ }
+ }
+
+ // Make the overflow out-of-flow frames mine too.
+ nsAutoOOFFrameList oofs(prevBlock);
+ if (oofs.mList.NotEmpty()) {
+ // In case we own any next-in-flows of any of the drained frames, then
+ // move those to the PushedFloat list.
+ nsFrameList pushedFloats;
+ for (nsIFrame* f : oofs.mList) {
+ nsIFrame* nif = f->GetNextInFlow();
+ for (; nif && nif->GetParent() == this; nif = nif->GetNextInFlow()) {
+ MOZ_ASSERT(nif->HasAnyStateBits(NS_FRAME_IS_PUSHED_FLOAT));
+ RemoveFloat(nif);
+ pushedFloats.AppendFrame(nullptr, nif);
+ }
+ }
+ ReparentFrames(oofs.mList, prevBlock, this);
+ mFloats.InsertFrames(nullptr, nullptr, std::move(oofs.mList));
+ if (!pushedFloats.IsEmpty()) {
+ nsFrameList* pf = EnsurePushedFloats();
+ pf->InsertFrames(nullptr, nullptr, std::move(pushedFloats));
+ }
+ }
+
+ if (!mLines.empty()) {
+ // Remember to recompute the margins on the first line. This will
+ // also recompute the correct deltaBCoord if necessary.
+ mLines.front()->MarkPreviousMarginDirty();
+ }
+ // The overflow lines have already been marked dirty and their previous
+ // margins marked dirty also.
+
+ // Prepend the overflow frames/lines to our principal list.
+ mFrames.InsertFrames(nullptr, nullptr, std::move(overflowLines->mFrames));
+ mLines.splice(mLines.begin(), overflowLines->mLines);
+ NS_ASSERTION(overflowLines->mLines.empty(), "splice should empty list");
+ delete overflowLines;
+ didFindOverflow = true;
+ }
+ }
+
+ // Now append our own overflow lines.
+ return DrainSelfOverflowList() || didFindOverflow;
+}
+
+bool nsBlockFrame::DrainSelfOverflowList() {
+ UniquePtr<FrameLines> ourOverflowLines(RemoveOverflowLines());
+ if (!ourOverflowLines) {
+ return false;
+ }
+
+ // No need to reparent frames in our own overflow lines/oofs, because they're
+ // already ours. But we should put overflow floats back in mFloats.
+ // (explicit scope to remove the OOF list before VerifyOverflowSituation)
+ {
+ nsAutoOOFFrameList oofs(this);
+ if (oofs.mList.NotEmpty()) {
+#ifdef DEBUG
+ for (nsIFrame* f : oofs.mList) {
+ MOZ_ASSERT(!f->HasAnyStateBits(NS_FRAME_IS_PUSHED_FLOAT),
+ "CollectFloats should've removed that bit");
+ }
+#endif
+ // The overflow floats go after our regular floats.
+ mFloats.AppendFrames(nullptr, std::move(oofs).mList);
+ }
+ }
+ if (!ourOverflowLines->mLines.empty()) {
+ mFrames.AppendFrames(nullptr, std::move(ourOverflowLines->mFrames));
+ mLines.splice(mLines.end(), ourOverflowLines->mLines);
+ }
+
+#ifdef DEBUG
+ VerifyOverflowSituation();
+#endif
+ return true;
+}
+
+/**
+ * Pushed floats are floats whose placeholders are in a previous
+ * continuation. They might themselves be next-continuations of a float
+ * that partially fit in an earlier continuation, or they might be the
+ * first continuation of a float that couldn't be placed at all.
+ *
+ * Pushed floats live permanently at the beginning of a block's float
+ * list, where they must live *before* any floats whose placeholders are
+ * in that block.
+ *
+ * Temporarily, during reflow, they also live on the pushed floats list,
+ * which only holds them between (a) when one continuation pushes them to
+ * its pushed floats list because they don't fit and (b) when the next
+ * continuation pulls them onto the beginning of its float list.
+ *
+ * DrainPushedFloats sets up pushed floats the way we need them at the
+ * start of reflow; they are then reflowed by ReflowPushedFloats (which
+ * might push some of them on). Floats with placeholders in this block
+ * are reflowed by (BlockReflowState/nsLineLayout)::AddFloat, which
+ * also maintains these invariants.
+ *
+ * DrainSelfPushedFloats moves any pushed floats from this block's own
+ * PushedFloats list back into mFloats. DrainPushedFloats additionally
+ * moves frames from its prev-in-flow's PushedFloats list into mFloats.
+ */
+void nsBlockFrame::DrainSelfPushedFloats() {
+ // If we're getting reflowed multiple times without our
+ // next-continuation being reflowed, we might need to pull back floats
+ // that we just put in the list to be pushed to our next-in-flow.
+ // We don't want to pull back any next-in-flows of floats on our own
+ // float list, and we only need to pull back first-in-flows whose
+ // placeholders were in earlier blocks (since first-in-flows whose
+ // placeholders are in this block will get pulled appropriately by
+ // AddFloat, and will then be more likely to be in the correct order).
+ mozilla::PresShell* presShell = PresShell();
+ nsFrameList* ourPushedFloats = GetPushedFloats();
+ if (ourPushedFloats) {
+ // When we pull back floats, we want to put them with the pushed
+ // floats, which must live at the start of our float list, but we
+ // want them at the end of those pushed floats.
+ // FIXME: This isn't quite right! What if they're all pushed floats?
+ nsIFrame* insertionPrevSibling = nullptr; /* beginning of list */
+ for (nsIFrame* f = mFloats.FirstChild();
+ f && f->HasAnyStateBits(NS_FRAME_IS_PUSHED_FLOAT);
+ f = f->GetNextSibling()) {
+ insertionPrevSibling = f;
+ }
+
+ nsIFrame* f = ourPushedFloats->LastChild();
+ while (f) {
+ nsIFrame* prevSibling = f->GetPrevSibling();
+
+ nsPlaceholderFrame* placeholder = f->GetPlaceholderFrame();
+ nsIFrame* floatOriginalParent =
+ presShell->FrameConstructor()->GetFloatContainingBlock(placeholder);
+ if (floatOriginalParent != this) {
+ // This is a first continuation that was pushed from one of our
+ // previous continuations. Take it out of the pushed floats
+ // list and put it in our floats list, before any of our
+ // floats, but after other pushed floats.
+ ourPushedFloats->RemoveFrame(f);
+ mFloats.InsertFrame(nullptr, insertionPrevSibling, f);
+ }
+
+ f = prevSibling;
+ }
+
+ if (ourPushedFloats->IsEmpty()) {
+ RemovePushedFloats()->Delete(presShell);
+ }
+ }
+}
+
+void nsBlockFrame::DrainPushedFloats() {
+ DrainSelfPushedFloats();
+
+ // After our prev-in-flow has completed reflow, it may have a pushed
+ // floats list, containing floats that we need to own. Take these.
+ nsBlockFrame* prevBlock = static_cast<nsBlockFrame*>(GetPrevInFlow());
+ if (prevBlock) {
+ AutoFrameListPtr list(PresContext(), prevBlock->RemovePushedFloats());
+ if (list && list->NotEmpty()) {
+ mFloats.InsertFrames(this, nullptr, std::move(*list));
+ }
+ }
+}
+
+nsBlockFrame::FrameLines* nsBlockFrame::GetOverflowLines() const {
+ if (!HasOverflowLines()) {
+ return nullptr;
+ }
+ FrameLines* prop = GetProperty(OverflowLinesProperty());
+ NS_ASSERTION(
+ prop && !prop->mLines.empty() &&
+ prop->mLines.front()->GetChildCount() == 0
+ ? prop->mFrames.IsEmpty()
+ : prop->mLines.front()->mFirstChild == prop->mFrames.FirstChild(),
+ "value should always be stored and non-empty when state set");
+ return prop;
+}
+
+nsBlockFrame::FrameLines* nsBlockFrame::RemoveOverflowLines() {
+ if (!HasOverflowLines()) {
+ return nullptr;
+ }
+ FrameLines* prop = TakeProperty(OverflowLinesProperty());
+ NS_ASSERTION(
+ prop && !prop->mLines.empty() &&
+ prop->mLines.front()->GetChildCount() == 0
+ ? prop->mFrames.IsEmpty()
+ : prop->mLines.front()->mFirstChild == prop->mFrames.FirstChild(),
+ "value should always be stored and non-empty when state set");
+ RemoveStateBits(NS_BLOCK_HAS_OVERFLOW_LINES);
+ return prop;
+}
+
+void nsBlockFrame::DestroyOverflowLines() {
+ NS_ASSERTION(HasOverflowLines(), "huh?");
+ FrameLines* prop = TakeProperty(OverflowLinesProperty());
+ NS_ASSERTION(prop && prop->mLines.empty(),
+ "value should always be stored but empty when destroying");
+ RemoveStateBits(NS_BLOCK_HAS_OVERFLOW_LINES);
+ delete prop;
+}
+
+// This takes ownership of aOverflowLines.
+// XXX We should allocate overflowLines from presShell arena!
+void nsBlockFrame::SetOverflowLines(FrameLines* aOverflowLines) {
+ NS_ASSERTION(aOverflowLines, "null lines");
+ NS_ASSERTION(!aOverflowLines->mLines.empty(), "empty lines");
+ NS_ASSERTION(aOverflowLines->mLines.front()->mFirstChild ==
+ aOverflowLines->mFrames.FirstChild(),
+ "invalid overflow lines / frames");
+ NS_ASSERTION(!HasAnyStateBits(NS_BLOCK_HAS_OVERFLOW_LINES),
+ "Overwriting existing overflow lines");
+
+ // Verify that we won't overwrite an existing overflow list
+ NS_ASSERTION(!GetProperty(OverflowLinesProperty()), "existing overflow list");
+ SetProperty(OverflowLinesProperty(), aOverflowLines);
+ AddStateBits(NS_BLOCK_HAS_OVERFLOW_LINES);
+}
+
+nsFrameList* nsBlockFrame::GetOverflowOutOfFlows() const {
+ if (!HasAnyStateBits(NS_BLOCK_HAS_OVERFLOW_OUT_OF_FLOWS)) {
+ return nullptr;
+ }
+ nsFrameList* result = GetProperty(OverflowOutOfFlowsProperty());
+ NS_ASSERTION(result, "value should always be non-empty when state set");
+ return result;
+}
+
+void nsBlockFrame::SetOverflowOutOfFlows(nsFrameList&& aList,
+ nsFrameList* aPropValue) {
+ MOZ_ASSERT(
+ HasAnyStateBits(NS_BLOCK_HAS_OVERFLOW_OUT_OF_FLOWS) == !!aPropValue,
+ "state does not match value");
+
+ if (aList.IsEmpty()) {
+ if (!HasAnyStateBits(NS_BLOCK_HAS_OVERFLOW_OUT_OF_FLOWS)) {
+ return;
+ }
+ nsFrameList* list = TakeProperty(OverflowOutOfFlowsProperty());
+ NS_ASSERTION(aPropValue == list, "prop value mismatch");
+ list->Clear();
+ list->Delete(PresShell());
+ RemoveStateBits(NS_BLOCK_HAS_OVERFLOW_OUT_OF_FLOWS);
+ } else if (HasAnyStateBits(NS_BLOCK_HAS_OVERFLOW_OUT_OF_FLOWS)) {
+ NS_ASSERTION(aPropValue == GetProperty(OverflowOutOfFlowsProperty()),
+ "prop value mismatch");
+ *aPropValue = std::move(aList);
+ } else {
+ SetProperty(OverflowOutOfFlowsProperty(),
+ new (PresShell()) nsFrameList(std::move(aList)));
+ AddStateBits(NS_BLOCK_HAS_OVERFLOW_OUT_OF_FLOWS);
+ }
+}
+
+nsIFrame* nsBlockFrame::GetInsideMarker() const {
+ if (!HasInsideMarker()) {
+ return nullptr;
+ }
+ NS_ASSERTION(!HasOutsideMarker(), "invalid marker state");
+ nsIFrame* frame = GetProperty(InsideMarkerProperty());
+ NS_ASSERTION(frame, "bogus inside ::marker frame");
+ return frame;
+}
+
+nsIFrame* nsBlockFrame::GetOutsideMarker() const {
+ nsFrameList* list = GetOutsideMarkerList();
+ return list ? list->FirstChild() : nullptr;
+}
+
+nsFrameList* nsBlockFrame::GetOutsideMarkerList() const {
+ if (!HasOutsideMarker()) {
+ return nullptr;
+ }
+ NS_ASSERTION(!HasInsideMarker(), "invalid marker state");
+ nsFrameList* list = GetProperty(OutsideMarkerProperty());
+ NS_ASSERTION(list && list->GetLength() == 1, "bogus outside ::marker list");
+ return list;
+}
+
+nsFrameList* nsBlockFrame::GetPushedFloats() const {
+ if (!HasPushedFloats()) {
+ return nullptr;
+ }
+ nsFrameList* result = GetProperty(PushedFloatProperty());
+ NS_ASSERTION(result, "value should always be non-empty when state set");
+ return result;
+}
+
+nsFrameList* nsBlockFrame::EnsurePushedFloats() {
+ nsFrameList* result = GetPushedFloats();
+ if (result) {
+ return result;
+ }
+
+ result = new (PresShell()) nsFrameList;
+ SetProperty(PushedFloatProperty(), result);
+ AddStateBits(NS_BLOCK_HAS_PUSHED_FLOATS);
+
+ return result;
+}
+
+nsFrameList* nsBlockFrame::RemovePushedFloats() {
+ if (!HasPushedFloats()) {
+ return nullptr;
+ }
+ nsFrameList* result = TakeProperty(PushedFloatProperty());
+ RemoveStateBits(NS_BLOCK_HAS_PUSHED_FLOATS);
+ NS_ASSERTION(result, "value should always be non-empty when state set");
+ return result;
+}
+
+//////////////////////////////////////////////////////////////////////
+// Frame list manipulation routines
+
+void nsBlockFrame::AppendFrames(ChildListID aListID, nsFrameList&& aFrameList) {
+ if (aFrameList.IsEmpty()) {
+ return;
+ }
+ if (aListID != FrameChildListID::Principal) {
+ if (FrameChildListID::Float == aListID) {
+ DrainSelfPushedFloats(); // ensure the last frame is in mFloats
+ mFloats.AppendFrames(nullptr, std::move(aFrameList));
+ return;
+ }
+ MOZ_ASSERT(FrameChildListID::NoReflowPrincipal == aListID,
+ "unexpected child list");
+ }
+
+ // Find the proper last-child for where the append should go
+ nsIFrame* lastKid = mFrames.LastChild();
+ NS_ASSERTION(
+ (mLines.empty() ? nullptr : mLines.back()->LastChild()) == lastKid,
+ "out-of-sync mLines / mFrames");
+
+#ifdef NOISY_REFLOW_REASON
+ ListTag(stdout);
+ printf(": append ");
+ for (nsIFrame* frame : aFrameList) {
+ frame->ListTag(stdout);
+ }
+ if (lastKid) {
+ printf(" after ");
+ lastKid->ListTag(stdout);
+ }
+ printf("\n");
+#endif
+
+ if (IsInSVGTextSubtree()) {
+ MOZ_ASSERT(GetParent()->IsSVGTextFrame(),
+ "unexpected block frame in SVG text");
+ // Workaround for bug 1399425 in case this bit has been removed from the
+ // SVGTextFrame just before the parser adds more descendant nodes.
+ GetParent()->AddStateBits(NS_STATE_SVG_TEXT_CORRESPONDENCE_DIRTY);
+ }
+
+ AddFrames(std::move(aFrameList), lastKid, nullptr);
+ if (aListID != FrameChildListID::NoReflowPrincipal) {
+ PresShell()->FrameNeedsReflow(
+ this, IntrinsicDirty::FrameAndAncestors,
+ NS_FRAME_HAS_DIRTY_CHILDREN); // XXX sufficient?
+ }
+}
+
+void nsBlockFrame::InsertFrames(ChildListID aListID, nsIFrame* aPrevFrame,
+ const nsLineList::iterator* aPrevFrameLine,
+ nsFrameList&& aFrameList) {
+ NS_ASSERTION(!aPrevFrame || aPrevFrame->GetParent() == this,
+ "inserting after sibling frame with different parent");
+
+ if (aListID != FrameChildListID::Principal) {
+ if (FrameChildListID::Float == aListID) {
+ DrainSelfPushedFloats(); // ensure aPrevFrame is in mFloats
+ mFloats.InsertFrames(this, aPrevFrame, std::move(aFrameList));
+ return;
+ }
+ MOZ_ASSERT(FrameChildListID::NoReflowPrincipal == aListID,
+ "unexpected child list");
+ }
+
+#ifdef NOISY_REFLOW_REASON
+ ListTag(stdout);
+ printf(": insert ");
+ for (nsIFrame* frame : aFrameList) {
+ frame->ListTag(stdout);
+ }
+ if (aPrevFrame) {
+ printf(" after ");
+ aPrevFrame->ListTag(stdout);
+ }
+ printf("\n");
+#endif
+
+ AddFrames(std::move(aFrameList), aPrevFrame, aPrevFrameLine);
+ if (aListID != FrameChildListID::NoReflowPrincipal) {
+ PresShell()->FrameNeedsReflow(
+ this, IntrinsicDirty::FrameAndAncestors,
+ NS_FRAME_HAS_DIRTY_CHILDREN); // XXX sufficient?
+ }
+}
+
+void nsBlockFrame::RemoveFrame(DestroyContext& aContext, ChildListID aListID,
+ nsIFrame* aOldFrame) {
+#ifdef NOISY_REFLOW_REASON
+ ListTag(stdout);
+ printf(": remove ");
+ aOldFrame->ListTag(stdout);
+ printf("\n");
+#endif
+
+ if (aListID == FrameChildListID::Principal) {
+ bool hasFloats = BlockHasAnyFloats(aOldFrame);
+ DoRemoveFrame(aContext, aOldFrame, REMOVE_FIXED_CONTINUATIONS);
+ if (hasFloats) {
+ MarkSameFloatManagerLinesDirty(this);
+ }
+ } else if (FrameChildListID::Float == aListID) {
+ // Make sure to mark affected lines dirty for the float frame
+ // we are removing; this way is a bit messy, but so is the rest of the code.
+ // See bug 390762.
+ NS_ASSERTION(!aOldFrame->GetPrevContinuation(),
+ "RemoveFrame should not be called on pushed floats.");
+ for (nsIFrame* f = aOldFrame;
+ f && !f->HasAnyStateBits(NS_FRAME_IS_OVERFLOW_CONTAINER);
+ f = f->GetNextContinuation()) {
+ MarkSameFloatManagerLinesDirty(
+ static_cast<nsBlockFrame*>(f->GetParent()));
+ }
+ DoRemoveOutOfFlowFrame(aContext, aOldFrame);
+ } else if (FrameChildListID::NoReflowPrincipal == aListID) {
+ // Skip the call to |FrameNeedsReflow| below by returning now.
+ DoRemoveFrame(aContext, aOldFrame, REMOVE_FIXED_CONTINUATIONS);
+ return;
+ } else {
+ MOZ_CRASH("unexpected child list");
+ }
+
+ PresShell()->FrameNeedsReflow(
+ this, IntrinsicDirty::FrameAndAncestors,
+ NS_FRAME_HAS_DIRTY_CHILDREN); // XXX sufficient?
+}
+
+static bool ShouldPutNextSiblingOnNewLine(nsIFrame* aLastFrame) {
+ LayoutFrameType type = aLastFrame->Type();
+ if (type == LayoutFrameType::Br) {
+ return true;
+ }
+ // XXX the TEXT_OFFSETS_NEED_FIXING check is a wallpaper for bug 822910.
+ if (type == LayoutFrameType::Text &&
+ !aLastFrame->HasAnyStateBits(TEXT_OFFSETS_NEED_FIXING)) {
+ return aLastFrame->HasSignificantTerminalNewline();
+ }
+ return false;
+}
+
+void nsBlockFrame::AddFrames(nsFrameList&& aFrameList, nsIFrame* aPrevSibling,
+ const nsLineList::iterator* aPrevSiblingLine) {
+ // Clear our line cursor, since our lines may change.
+ ClearLineCursors();
+
+ if (aFrameList.IsEmpty()) {
+ return;
+ }
+
+ // Attempt to find the line that contains the previous sibling
+ nsLineList* lineList = &mLines;
+ nsFrameList* frames = &mFrames;
+ nsLineList::iterator prevSibLine;
+ int32_t prevSiblingIndex;
+ if (aPrevSiblingLine) {
+ MOZ_ASSERT(aPrevSibling);
+ prevSibLine = *aPrevSiblingLine;
+ FrameLines* overflowLines = GetOverflowLines();
+ MOZ_ASSERT(prevSibLine.IsInSameList(mLines.begin()) ||
+ (overflowLines &&
+ prevSibLine.IsInSameList(overflowLines->mLines.begin())),
+ "must be one of our line lists");
+ if (overflowLines) {
+ // We need to find out which list it's actually in. Assume that
+ // *if* we have overflow lines, that our primary lines aren't
+ // huge, but our overflow lines might be.
+ nsLineList::iterator line = mLines.begin(), lineEnd = mLines.end();
+ while (line != lineEnd) {
+ if (line == prevSibLine) {
+ break;
+ }
+ ++line;
+ }
+ if (line == lineEnd) {
+ // By elimination, the line must be in our overflow lines.
+ lineList = &overflowLines->mLines;
+ frames = &overflowLines->mFrames;
+ }
+ }
+
+ nsLineList::iterator nextLine = prevSibLine.next();
+ nsIFrame* lastFrameInLine = nextLine == lineList->end()
+ ? frames->LastChild()
+ : nextLine->mFirstChild->GetPrevSibling();
+ prevSiblingIndex = prevSibLine->RIndexOf(aPrevSibling, lastFrameInLine);
+ MOZ_ASSERT(prevSiblingIndex >= 0,
+ "aPrevSibling must be in aPrevSiblingLine");
+ } else {
+ prevSibLine = lineList->end();
+ prevSiblingIndex = -1;
+ if (aPrevSibling) {
+ // XXX_perf This is technically O(N^2) in some cases, but by using
+ // RFind instead of Find, we make it O(N) in the most common case,
+ // which is appending content.
+
+ // Find the line that contains the previous sibling
+ if (!nsLineBox::RFindLineContaining(aPrevSibling, lineList->begin(),
+ prevSibLine, mFrames.LastChild(),
+ &prevSiblingIndex)) {
+ // Not in mLines - try overflow lines.
+ FrameLines* overflowLines = GetOverflowLines();
+ bool found = false;
+ if (overflowLines) {
+ prevSibLine = overflowLines->mLines.end();
+ prevSiblingIndex = -1;
+ found = nsLineBox::RFindLineContaining(
+ aPrevSibling, overflowLines->mLines.begin(), prevSibLine,
+ overflowLines->mFrames.LastChild(), &prevSiblingIndex);
+ }
+ if (MOZ_LIKELY(found)) {
+ lineList = &overflowLines->mLines;
+ frames = &overflowLines->mFrames;
+ } else {
+ // Note: defensive code! RFindLineContaining must not return
+ // false in this case, so if it does...
+ MOZ_ASSERT_UNREACHABLE("prev sibling not in line list");
+ aPrevSibling = nullptr;
+ prevSibLine = lineList->end();
+ }
+ }
+ }
+ }
+
+ // Find the frame following aPrevSibling so that we can join up the
+ // two lists of frames.
+ if (aPrevSibling) {
+ // Split line containing aPrevSibling in two if the insertion
+ // point is somewhere in the middle of the line.
+ int32_t rem = prevSibLine->GetChildCount() - prevSiblingIndex - 1;
+ if (rem) {
+ // Split the line in two where the frame(s) are being inserted.
+ nsLineBox* line =
+ NewLineBox(prevSibLine, aPrevSibling->GetNextSibling(), rem);
+ lineList->after_insert(prevSibLine, line);
+ // Mark prevSibLine dirty and as needing textrun invalidation, since
+ // we may be breaking up text in the line. Its previous line may also
+ // need to be invalidated because it may be able to pull some text up.
+ MarkLineDirty(prevSibLine, lineList);
+ // The new line will also need its textruns recomputed because of the
+ // frame changes.
+ line->MarkDirty();
+ line->SetInvalidateTextRuns(true);
+ }
+ } else if (!lineList->empty()) {
+ lineList->front()->MarkDirty();
+ lineList->front()->SetInvalidateTextRuns(true);
+ }
+ const nsFrameList::Slice& newFrames =
+ frames->InsertFrames(nullptr, aPrevSibling, std::move(aFrameList));
+
+ // Walk through the new frames being added and update the line data
+ // structures to fit.
+ for (nsIFrame* newFrame : newFrames) {
+ NS_ASSERTION(!aPrevSibling || aPrevSibling->GetNextSibling() == newFrame,
+ "Unexpected aPrevSibling");
+ NS_ASSERTION(
+ !newFrame->IsPlaceholderFrame() ||
+ (!newFrame->IsAbsolutelyPositioned() && !newFrame->IsFloating()),
+ "Placeholders should not float or be positioned");
+
+ bool isBlock = newFrame->IsBlockOutside();
+
+ // If the frame is a block frame, or if there is no previous line or if the
+ // previous line is a block line we need to make a new line. We also make
+ // a new line, as an optimization, in the two cases we know we'll need it:
+ // if the previous line ended with a <br>, or if it has significant
+ // whitespace and ended in a newline.
+ if (isBlock || prevSibLine == lineList->end() || prevSibLine->IsBlock() ||
+ (aPrevSibling && ShouldPutNextSiblingOnNewLine(aPrevSibling))) {
+ // Create a new line for the frame and add its line to the line
+ // list.
+ nsLineBox* line = NewLineBox(newFrame, isBlock);
+ if (prevSibLine != lineList->end()) {
+ // Append new line after prevSibLine
+ lineList->after_insert(prevSibLine, line);
+ ++prevSibLine;
+ } else {
+ // New line is going before the other lines
+ lineList->push_front(line);
+ prevSibLine = lineList->begin();
+ }
+ } else {
+ prevSibLine->NoteFrameAdded(newFrame);
+ // We're adding inline content to prevSibLine, so we need to mark it
+ // dirty, ensure its textruns are recomputed, and possibly do the same
+ // to its previous line since that line may be able to pull content up.
+ MarkLineDirty(prevSibLine, lineList);
+ }
+
+ aPrevSibling = newFrame;
+ }
+
+#ifdef DEBUG
+ MOZ_ASSERT(aFrameList.IsEmpty());
+ VerifyLines(true);
+#endif
+}
+
+nsContainerFrame* nsBlockFrame::GetRubyContentPseudoFrame() {
+ auto* firstChild = PrincipalChildList().FirstChild();
+ if (firstChild && firstChild->IsRubyFrame() &&
+ firstChild->Style()->GetPseudoType() ==
+ mozilla::PseudoStyleType::blockRubyContent) {
+ return static_cast<nsContainerFrame*>(firstChild);
+ }
+ return nullptr;
+}
+
+nsContainerFrame* nsBlockFrame::GetContentInsertionFrame() {
+ // 'display:block ruby' use the inner (Ruby) frame for insertions.
+ if (auto* rubyContentPseudoFrame = GetRubyContentPseudoFrame()) {
+ return rubyContentPseudoFrame;
+ }
+ return this;
+}
+
+void nsBlockFrame::AppendDirectlyOwnedAnonBoxes(
+ nsTArray<OwnedAnonBox>& aResult) {
+ if (auto* rubyContentPseudoFrame = GetRubyContentPseudoFrame()) {
+ aResult.AppendElement(OwnedAnonBox(rubyContentPseudoFrame));
+ }
+}
+
+void nsBlockFrame::RemoveFloatFromFloatCache(nsIFrame* aFloat) {
+ // Find which line contains the float, so we can update
+ // the float cache.
+ for (auto& line : Lines()) {
+ if (line.IsInline() && line.RemoveFloat(aFloat)) {
+ break;
+ }
+ }
+}
+
+void nsBlockFrame::RemoveFloat(nsIFrame* aFloat) {
+#ifdef DEBUG
+ // Floats live in mFloats, or in the PushedFloat or OverflowOutOfFlows
+ // frame list properties.
+ if (!mFloats.ContainsFrame(aFloat)) {
+ MOZ_ASSERT(
+ (GetOverflowOutOfFlows() &&
+ GetOverflowOutOfFlows()->ContainsFrame(aFloat)) ||
+ (GetPushedFloats() && GetPushedFloats()->ContainsFrame(aFloat)),
+ "aFloat is not our child or on an unexpected frame list");
+ }
+#endif
+
+ if (mFloats.StartRemoveFrame(aFloat)) {
+ return;
+ }
+
+ nsFrameList* list = GetPushedFloats();
+ if (list && list->ContinueRemoveFrame(aFloat)) {
+#if 0
+ // XXXmats not yet - need to investigate BlockReflowState::mPushedFloats
+ // first so we don't leave it pointing to a deleted list.
+ if (list->IsEmpty()) {
+ delete RemovePushedFloats();
+ }
+#endif
+ return;
+ }
+
+ {
+ nsAutoOOFFrameList oofs(this);
+ if (oofs.mList.ContinueRemoveFrame(aFloat)) {
+ return;
+ }
+ }
+}
+
+void nsBlockFrame::DoRemoveOutOfFlowFrame(DestroyContext& aContext,
+ nsIFrame* aFrame) {
+ // The containing block is always the parent of aFrame.
+ nsBlockFrame* block = (nsBlockFrame*)aFrame->GetParent();
+
+ // Remove aFrame from the appropriate list.
+ if (aFrame->IsAbsolutelyPositioned()) {
+ // This also deletes the next-in-flows
+ block->GetAbsoluteContainingBlock()->RemoveFrame(
+ aContext, FrameChildListID::Absolute, aFrame);
+ } else {
+ // First remove aFrame's next-in-flows.
+ if (nsIFrame* nif = aFrame->GetNextInFlow()) {
+ nif->GetParent()->DeleteNextInFlowChild(aContext, nif, false);
+ }
+ // Now remove aFrame from its child list and Destroy it.
+ block->RemoveFloatFromFloatCache(aFrame);
+ block->RemoveFloat(aFrame);
+ aFrame->Destroy(aContext);
+ }
+}
+
+/**
+ * This helps us iterate over the list of all normal + overflow lines
+ */
+void nsBlockFrame::TryAllLines(nsLineList::iterator* aIterator,
+ nsLineList::iterator* aStartIterator,
+ nsLineList::iterator* aEndIterator,
+ bool* aInOverflowLines,
+ FrameLines** aOverflowLines) {
+ if (*aIterator == *aEndIterator) {
+ if (!*aInOverflowLines) {
+ // Try the overflow lines
+ *aInOverflowLines = true;
+ FrameLines* lines = GetOverflowLines();
+ if (lines) {
+ *aStartIterator = lines->mLines.begin();
+ *aIterator = *aStartIterator;
+ *aEndIterator = lines->mLines.end();
+ *aOverflowLines = lines;
+ }
+ }
+ }
+}
+
+nsBlockInFlowLineIterator::nsBlockInFlowLineIterator(nsBlockFrame* aFrame,
+ LineIterator aLine)
+ : mFrame(aFrame), mLine(aLine), mLineList(&aFrame->mLines) {
+ // This will assert if aLine isn't in mLines of aFrame:
+ DebugOnly<bool> check = aLine == mFrame->LinesBegin();
+}
+
+nsBlockInFlowLineIterator::nsBlockInFlowLineIterator(nsBlockFrame* aFrame,
+ LineIterator aLine,
+ bool aInOverflow)
+ : mFrame(aFrame),
+ mLine(aLine),
+ mLineList(aInOverflow ? &aFrame->GetOverflowLines()->mLines
+ : &aFrame->mLines) {}
+
+nsBlockInFlowLineIterator::nsBlockInFlowLineIterator(nsBlockFrame* aFrame,
+ bool* aFoundValidLine)
+ : mFrame(aFrame), mLineList(&aFrame->mLines) {
+ mLine = aFrame->LinesBegin();
+ *aFoundValidLine = FindValidLine();
+}
+
+static bool StyleEstablishesBFC(const ComputedStyle* aStyle) {
+ // paint/layout containment boxes and multi-column containers establish an
+ // independent formatting context.
+ // https://drafts.csswg.org/css-contain/#containment-paint
+ // https://drafts.csswg.org/css-contain/#containment-layout
+ // https://drafts.csswg.org/css-multicol/#columns
+ return aStyle->StyleDisplay()->IsContainPaint() ||
+ aStyle->StyleDisplay()->IsContainLayout() ||
+ aStyle->GetPseudoType() == PseudoStyleType::columnContent;
+}
+
+void nsBlockFrame::DidSetComputedStyle(ComputedStyle* aOldStyle) {
+ nsContainerFrame::DidSetComputedStyle(aOldStyle);
+ if (!aOldStyle) {
+ return;
+ }
+
+ // If NS_BLOCK_STATIC_BFC flag was set when the frame was initialized, it
+ // remains set during the lifetime of the frame and always forces it to be
+ // treated as a BFC, independently of the value of NS_BLOCK_DYNAMIC_BFC.
+ // Consequently, we don't bother invalidating or updating that latter flag.
+ if (HasAnyStateBits(NS_BLOCK_STATIC_BFC)) {
+ return;
+ }
+
+ bool isBFC = StyleEstablishesBFC(Style());
+ if (StyleEstablishesBFC(aOldStyle) != isBFC) {
+ if (MaybeHasFloats()) {
+ // If the frame contains floats, this update may change their float
+ // manager. Be safe by dirtying all descendant lines of the nearest
+ // ancestor's float manager.
+ RemoveStateBits(NS_BLOCK_DYNAMIC_BFC);
+ MarkSameFloatManagerLinesDirty(this);
+ }
+ AddOrRemoveStateBits(NS_BLOCK_DYNAMIC_BFC, isBFC);
+ }
+}
+
+void nsBlockFrame::UpdateFirstLetterStyle(ServoRestyleState& aRestyleState) {
+ nsIFrame* letterFrame = GetFirstLetter();
+ if (!letterFrame) {
+ return;
+ }
+
+ // Figure out what the right style parent is. This needs to match
+ // nsCSSFrameConstructor::CreateLetterFrame.
+ nsIFrame* inFlowFrame = letterFrame;
+ if (inFlowFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW)) {
+ inFlowFrame = inFlowFrame->GetPlaceholderFrame();
+ }
+ nsIFrame* styleParent = CorrectStyleParentFrame(inFlowFrame->GetParent(),
+ PseudoStyleType::firstLetter);
+ ComputedStyle* parentStyle = styleParent->Style();
+ RefPtr<ComputedStyle> firstLetterStyle =
+ aRestyleState.StyleSet().ResolvePseudoElementStyle(
+ *mContent->AsElement(), PseudoStyleType::firstLetter, nullptr,
+ parentStyle);
+ // Note that we don't need to worry about changehints for the continuation
+ // styles: those will be handled by the styleParent already.
+ RefPtr<ComputedStyle> continuationStyle =
+ aRestyleState.StyleSet().ResolveStyleForFirstLetterContinuation(
+ parentStyle);
+ UpdateStyleOfOwnedChildFrame(letterFrame, firstLetterStyle, aRestyleState,
+ Some(continuationStyle.get()));
+
+ // We also want to update the style on the textframe inside the first-letter.
+ // We don't need to compute a changehint for this, though, since any changes
+ // to it are handled by the first-letter anyway.
+ nsIFrame* textFrame = letterFrame->PrincipalChildList().FirstChild();
+ RefPtr<ComputedStyle> firstTextStyle =
+ aRestyleState.StyleSet().ResolveStyleForText(textFrame->GetContent(),
+ firstLetterStyle);
+ textFrame->SetComputedStyle(firstTextStyle);
+
+ // We don't need to update style for textFrame's continuations: it's already
+ // set up to inherit from parentStyle, which is what we want.
+}
+
+static nsIFrame* FindChildContaining(nsBlockFrame* aFrame,
+ nsIFrame* aFindFrame) {
+ NS_ASSERTION(aFrame, "must have frame");
+ nsIFrame* child;
+ while (true) {
+ nsIFrame* block = aFrame;
+ do {
+ child = nsLayoutUtils::FindChildContainingDescendant(block, aFindFrame);
+ if (child) {
+ break;
+ }
+ block = block->GetNextContinuation();
+ } while (block);
+ if (!child) {
+ return nullptr;
+ }
+ if (!child->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW)) {
+ break;
+ }
+ aFindFrame = child->GetPlaceholderFrame();
+ }
+
+ return child;
+}
+
+nsBlockInFlowLineIterator::nsBlockInFlowLineIterator(nsBlockFrame* aFrame,
+ nsIFrame* aFindFrame,
+ bool* aFoundValidLine)
+ : mFrame(aFrame), mLineList(&aFrame->mLines) {
+ *aFoundValidLine = false;
+
+ nsIFrame* child = FindChildContaining(aFrame, aFindFrame);
+ if (!child) {
+ return;
+ }
+
+ LineIterator line_end = aFrame->LinesEnd();
+ mLine = aFrame->LinesBegin();
+ if (mLine != line_end && mLine.next() == line_end &&
+ !aFrame->HasOverflowLines()) {
+ // The block has a single line - that must be it!
+ *aFoundValidLine = true;
+ return;
+ }
+
+ // Try to use the cursor if it exists, otherwise fall back to the first line
+ if (nsLineBox* const cursor = aFrame->GetLineCursorForQuery()) {
+ mLine = line_end;
+ // Perform a simultaneous forward and reverse search starting from the
+ // line cursor.
+ nsBlockFrame::LineIterator line = aFrame->LinesBeginFrom(cursor);
+ nsBlockFrame::ReverseLineIterator rline = aFrame->LinesRBeginFrom(cursor);
+ nsBlockFrame::ReverseLineIterator rline_end = aFrame->LinesREnd();
+ // rline is positioned on the line containing 'cursor', so it's not
+ // rline_end. So we can safely increment it (i.e. move it to one line
+ // earlier) to start searching there.
+ ++rline;
+ while (line != line_end || rline != rline_end) {
+ if (line != line_end) {
+ if (line->Contains(child)) {
+ mLine = line;
+ break;
+ }
+ ++line;
+ }
+ if (rline != rline_end) {
+ if (rline->Contains(child)) {
+ mLine = rline;
+ break;
+ }
+ ++rline;
+ }
+ }
+ if (mLine != line_end) {
+ *aFoundValidLine = true;
+ if (mLine != cursor) {
+ aFrame->SetProperty(nsBlockFrame::LineCursorPropertyQuery(), mLine);
+ }
+ return;
+ }
+ } else {
+ for (mLine = aFrame->LinesBegin(); mLine != line_end; ++mLine) {
+ if (mLine->Contains(child)) {
+ *aFoundValidLine = true;
+ return;
+ }
+ }
+ }
+ // Didn't find the line
+ MOZ_ASSERT(mLine == line_end, "mLine should be line_end at this point");
+
+ // If we reach here, it means that we have not been able to find the
+ // desired frame in our in-flow lines. So we should start looking at
+ // our overflow lines. In order to do that, we set mLine to the end
+ // iterator so that FindValidLine starts to look at overflow lines,
+ // if any.
+
+ if (!FindValidLine()) {
+ return;
+ }
+
+ do {
+ if (mLine->Contains(child)) {
+ *aFoundValidLine = true;
+ return;
+ }
+ } while (Next());
+}
+
+nsBlockFrame::LineIterator nsBlockInFlowLineIterator::End() {
+ return mLineList->end();
+}
+
+bool nsBlockInFlowLineIterator::IsLastLineInList() {
+ LineIterator end = End();
+ return mLine != end && mLine.next() == end;
+}
+
+bool nsBlockInFlowLineIterator::Next() {
+ ++mLine;
+ return FindValidLine();
+}
+
+bool nsBlockInFlowLineIterator::Prev() {
+ LineIterator begin = mLineList->begin();
+ if (mLine != begin) {
+ --mLine;
+ return true;
+ }
+ bool currentlyInOverflowLines = GetInOverflow();
+ while (true) {
+ if (currentlyInOverflowLines) {
+ mLineList = &mFrame->mLines;
+ mLine = mLineList->end();
+ if (mLine != mLineList->begin()) {
+ --mLine;
+ return true;
+ }
+ } else {
+ mFrame = static_cast<nsBlockFrame*>(mFrame->GetPrevInFlow());
+ if (!mFrame) {
+ return false;
+ }
+ nsBlockFrame::FrameLines* overflowLines = mFrame->GetOverflowLines();
+ if (overflowLines) {
+ mLineList = &overflowLines->mLines;
+ mLine = mLineList->end();
+ NS_ASSERTION(mLine != mLineList->begin(), "empty overflow line list?");
+ --mLine;
+ return true;
+ }
+ }
+ currentlyInOverflowLines = !currentlyInOverflowLines;
+ }
+}
+
+bool nsBlockInFlowLineIterator::FindValidLine() {
+ LineIterator end = mLineList->end();
+ if (mLine != end) {
+ return true;
+ }
+ bool currentlyInOverflowLines = GetInOverflow();
+ while (true) {
+ if (currentlyInOverflowLines) {
+ mFrame = static_cast<nsBlockFrame*>(mFrame->GetNextInFlow());
+ if (!mFrame) {
+ return false;
+ }
+ mLineList = &mFrame->mLines;
+ mLine = mLineList->begin();
+ if (mLine != mLineList->end()) {
+ return true;
+ }
+ } else {
+ nsBlockFrame::FrameLines* overflowLines = mFrame->GetOverflowLines();
+ if (overflowLines) {
+ mLineList = &overflowLines->mLines;
+ mLine = mLineList->begin();
+ NS_ASSERTION(mLine != mLineList->end(), "empty overflow line list?");
+ return true;
+ }
+ }
+ currentlyInOverflowLines = !currentlyInOverflowLines;
+ }
+}
+
+// This function removes aDeletedFrame and all its continuations. It
+// is optimized for deleting a whole series of frames. The easy
+// implementation would invoke itself recursively on
+// aDeletedFrame->GetNextContinuation, then locate the line containing
+// aDeletedFrame and remove aDeletedFrame from that line. But here we
+// start by locating aDeletedFrame and then scanning from that point
+// on looking for continuations.
+void nsBlockFrame::DoRemoveFrame(DestroyContext& aContext,
+ nsIFrame* aDeletedFrame, uint32_t aFlags) {
+ // Clear our line cursor, since our lines may change.
+ ClearLineCursors();
+
+ if (aDeletedFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW |
+ NS_FRAME_IS_OVERFLOW_CONTAINER)) {
+ if (!aDeletedFrame->GetPrevInFlow()) {
+ NS_ASSERTION(aDeletedFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW),
+ "Expected out-of-flow frame");
+ DoRemoveOutOfFlowFrame(aContext, aDeletedFrame);
+ } else {
+ // FIXME(emilio): aContext is lost here, maybe it's not a big deal?
+ nsContainerFrame::DeleteNextInFlowChild(aContext, aDeletedFrame,
+ (aFlags & FRAMES_ARE_EMPTY) != 0);
+ }
+ return;
+ }
+
+ // Find the line that contains deletedFrame
+ nsLineList::iterator line_start = mLines.begin(), line_end = mLines.end();
+ nsLineList::iterator line = line_start;
+ FrameLines* overflowLines = nullptr;
+ bool searchingOverflowList = false;
+ // Make sure we look in the overflow lines even if the normal line
+ // list is empty
+ TryAllLines(&line, &line_start, &line_end, &searchingOverflowList,
+ &overflowLines);
+ while (line != line_end) {
+ if (line->Contains(aDeletedFrame)) {
+ break;
+ }
+ ++line;
+ TryAllLines(&line, &line_start, &line_end, &searchingOverflowList,
+ &overflowLines);
+ }
+
+ if (line == line_end) {
+ NS_ERROR("can't find deleted frame in lines");
+ return;
+ }
+
+ if (!(aFlags & FRAMES_ARE_EMPTY)) {
+ if (line != line_start) {
+ line.prev()->MarkDirty();
+ line.prev()->SetInvalidateTextRuns(true);
+ } else if (searchingOverflowList && !mLines.empty()) {
+ mLines.back()->MarkDirty();
+ mLines.back()->SetInvalidateTextRuns(true);
+ }
+ }
+
+ while (line != line_end && aDeletedFrame) {
+ MOZ_ASSERT(this == aDeletedFrame->GetParent(), "messed up delete code");
+ MOZ_ASSERT(line->Contains(aDeletedFrame), "frame not in line");
+
+ if (!(aFlags & FRAMES_ARE_EMPTY)) {
+ line->MarkDirty();
+ line->SetInvalidateTextRuns(true);
+ }
+
+ // If the frame being deleted is the last one on the line then
+ // optimize away the line->Contains(next-in-flow) call below.
+ bool isLastFrameOnLine = 1 == line->GetChildCount();
+ if (!isLastFrameOnLine) {
+ LineIterator next = line.next();
+ nsIFrame* lastFrame =
+ next != line_end
+ ? next->mFirstChild->GetPrevSibling()
+ : (searchingOverflowList ? overflowLines->mFrames.LastChild()
+ : mFrames.LastChild());
+ NS_ASSERTION(next == line_end || lastFrame == line->LastChild(),
+ "unexpected line frames");
+ isLastFrameOnLine = lastFrame == aDeletedFrame;
+ }
+
+ // Remove aDeletedFrame from the line
+ if (line->mFirstChild == aDeletedFrame) {
+ // We should be setting this to null if aDeletedFrame
+ // is the only frame on the line. HOWEVER in that case
+ // we will be removing the line anyway, see below.
+ line->mFirstChild = aDeletedFrame->GetNextSibling();
+ }
+
+ // Hmm, this won't do anything if we're removing a frame in the first
+ // overflow line... Hopefully doesn't matter
+ --line;
+ if (line != line_end && !line->IsBlock()) {
+ // Since we just removed a frame that follows some inline
+ // frames, we need to reflow the previous line.
+ line->MarkDirty();
+ }
+ ++line;
+
+ // Take aDeletedFrame out of the sibling list. Note that
+ // prevSibling will only be nullptr when we are deleting the very
+ // first frame in the main or overflow list.
+ if (searchingOverflowList) {
+ overflowLines->mFrames.RemoveFrame(aDeletedFrame);
+ } else {
+ mFrames.RemoveFrame(aDeletedFrame);
+ }
+
+ // Update the child count of the line to be accurate
+ line->NoteFrameRemoved(aDeletedFrame);
+
+ // Destroy frame; capture its next continuation first in case we need
+ // to destroy that too.
+ nsIFrame* deletedNextContinuation =
+ (aFlags & REMOVE_FIXED_CONTINUATIONS)
+ ? aDeletedFrame->GetNextContinuation()
+ : aDeletedFrame->GetNextInFlow();
+#ifdef NOISY_REMOVE_FRAME
+ printf("DoRemoveFrame: %s line=%p frame=",
+ searchingOverflowList ? "overflow" : "normal", line.get());
+ aDeletedFrame->ListTag(stdout);
+ printf(" prevSibling=%p deletedNextContinuation=%p\n",
+ aDeletedFrame->GetPrevSibling(), deletedNextContinuation);
+#endif
+
+ // If next-in-flow is an overflow container, must remove it first.
+ // FIXME: Can we do this unconditionally?
+ if (deletedNextContinuation && deletedNextContinuation->HasAnyStateBits(
+ NS_FRAME_IS_OVERFLOW_CONTAINER)) {
+ deletedNextContinuation->GetParent()->DeleteNextInFlowChild(
+ aContext, deletedNextContinuation, false);
+ deletedNextContinuation = nullptr;
+ }
+
+ aDeletedFrame->Destroy(aContext);
+ aDeletedFrame = deletedNextContinuation;
+
+ bool haveAdvancedToNextLine = false;
+ // If line is empty, remove it now.
+ if (0 == line->GetChildCount()) {
+#ifdef NOISY_REMOVE_FRAME
+ printf("DoRemoveFrame: %s line=%p became empty so it will be removed\n",
+ searchingOverflowList ? "overflow" : "normal", line.get());
+#endif
+ nsLineBox* cur = line;
+ if (!searchingOverflowList) {
+ line = mLines.erase(line);
+ // Invalidate the space taken up by the line.
+ // XXX We need to do this if we're removing a frame as a result of
+ // a call to RemoveFrame(), but we may not need to do this in all
+ // cases...
+#ifdef NOISY_BLOCK_INVALIDATE
+ nsRect inkOverflow(cur->InkOverflowRect());
+ printf("%p invalidate 10 (%d, %d, %d, %d)\n", this, inkOverflow.x,
+ inkOverflow.y, inkOverflow.width, inkOverflow.height);
+#endif
+ } else {
+ line = overflowLines->mLines.erase(line);
+ if (overflowLines->mLines.empty()) {
+ DestroyOverflowLines();
+ overflowLines = nullptr;
+ // We just invalidated our iterators. Since we were in
+ // the overflow lines list, which is now empty, set them
+ // so we're at the end of the regular line list.
+ line_start = mLines.begin();
+ line_end = mLines.end();
+ line = line_end;
+ }
+ }
+ FreeLineBox(cur);
+
+ // If we're removing a line, ReflowDirtyLines isn't going to
+ // know that it needs to slide lines unless something is marked
+ // dirty. So mark the previous margin of the next line dirty if
+ // there is one.
+ if (line != line_end) {
+ line->MarkPreviousMarginDirty();
+ }
+ haveAdvancedToNextLine = true;
+ } else {
+ // Make the line that just lost a frame dirty, and advance to
+ // the next line.
+ if (!deletedNextContinuation || isLastFrameOnLine ||
+ !line->Contains(deletedNextContinuation)) {
+ line->MarkDirty();
+ ++line;
+ haveAdvancedToNextLine = true;
+ }
+ }
+
+ if (deletedNextContinuation) {
+ // See if we should keep looking in the current flow's line list.
+ if (deletedNextContinuation->GetParent() != this) {
+ // The deceased frames continuation is not a child of the
+ // current block. So break out of the loop so that we advance
+ // to the next parent.
+ //
+ // If we have a continuation in a different block then all bets are
+ // off regarding whether we are deleting frames without actual content,
+ // so don't propagate FRAMES_ARE_EMPTY any further.
+ aFlags &= ~FRAMES_ARE_EMPTY;
+ break;
+ }
+
+ // If we advanced to the next line then check if we should switch to the
+ // overflow line list.
+ if (haveAdvancedToNextLine) {
+ if (line != line_end && !searchingOverflowList &&
+ !line->Contains(deletedNextContinuation)) {
+ // We have advanced to the next *normal* line but the next-in-flow
+ // is not there - force a switch to the overflow line list.
+ line = line_end;
+ }
+
+ TryAllLines(&line, &line_start, &line_end, &searchingOverflowList,
+ &overflowLines);
+#ifdef NOISY_REMOVE_FRAME
+ printf("DoRemoveFrame: now on %s line=%p\n",
+ searchingOverflowList ? "overflow" : "normal", line.get());
+#endif
+ }
+ }
+ }
+
+ if (!(aFlags & FRAMES_ARE_EMPTY) && line.next() != line_end) {
+ line.next()->MarkDirty();
+ line.next()->SetInvalidateTextRuns(true);
+ }
+
+#ifdef DEBUG
+ VerifyLines(true);
+ VerifyOverflowSituation();
+#endif
+
+ // Advance to next flow block if the frame has more continuations.
+ if (!aDeletedFrame) {
+ return;
+ }
+ nsBlockFrame* nextBlock = do_QueryFrame(aDeletedFrame->GetParent());
+ NS_ASSERTION(nextBlock, "Our child's continuation's parent is not a block?");
+ uint32_t flags = (aFlags & REMOVE_FIXED_CONTINUATIONS);
+ nextBlock->DoRemoveFrame(aContext, aDeletedFrame, flags);
+}
+
+static bool FindBlockLineFor(nsIFrame* aChild, nsLineList::iterator aBegin,
+ nsLineList::iterator aEnd,
+ nsLineList::iterator* aResult) {
+ MOZ_ASSERT(aChild->IsBlockOutside());
+ for (nsLineList::iterator line = aBegin; line != aEnd; ++line) {
+ MOZ_ASSERT(line->GetChildCount() > 0);
+ if (line->IsBlock() && line->mFirstChild == aChild) {
+ MOZ_ASSERT(line->GetChildCount() == 1);
+ *aResult = line;
+ return true;
+ }
+ }
+ return false;
+}
+
+static bool FindInlineLineFor(nsIFrame* aChild, const nsFrameList& aFrameList,
+ nsLineList::iterator aBegin,
+ nsLineList::iterator aEnd,
+ nsLineList::iterator* aResult) {
+ MOZ_ASSERT(!aChild->IsBlockOutside());
+ for (nsLineList::iterator line = aBegin; line != aEnd; ++line) {
+ MOZ_ASSERT(line->GetChildCount() > 0);
+ if (!line->IsBlock()) {
+ // Optimize by comparing the line's last child first.
+ nsLineList::iterator next = line.next();
+ if (aChild == (next == aEnd ? aFrameList.LastChild()
+ : next->mFirstChild->GetPrevSibling()) ||
+ line->Contains(aChild)) {
+ *aResult = line;
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+static bool FindLineFor(nsIFrame* aChild, const nsFrameList& aFrameList,
+ nsLineList::iterator aBegin, nsLineList::iterator aEnd,
+ nsLineList::iterator* aResult) {
+ return aChild->IsBlockOutside()
+ ? FindBlockLineFor(aChild, aBegin, aEnd, aResult)
+ : FindInlineLineFor(aChild, aFrameList, aBegin, aEnd, aResult);
+}
+
+void nsBlockFrame::StealFrame(nsIFrame* aChild) {
+ MOZ_ASSERT(aChild->GetParent() == this);
+
+ if (aChild->IsFloating()) {
+ RemoveFloat(aChild);
+ return;
+ }
+
+ if (MaybeStealOverflowContainerFrame(aChild)) {
+ return;
+ }
+
+ MOZ_ASSERT(!aChild->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW));
+
+ nsLineList::iterator line;
+ if (FindLineFor(aChild, mFrames, mLines.begin(), mLines.end(), &line)) {
+ RemoveFrameFromLine(aChild, line, mFrames, mLines);
+ } else {
+ FrameLines* overflowLines = GetOverflowLines();
+ DebugOnly<bool> found;
+ found = FindLineFor(aChild, overflowLines->mFrames,
+ overflowLines->mLines.begin(),
+ overflowLines->mLines.end(), &line);
+ MOZ_ASSERT(found, "Why can't we find aChild in our overflow lines?");
+ RemoveFrameFromLine(aChild, line, overflowLines->mFrames,
+ overflowLines->mLines);
+ if (overflowLines->mLines.empty()) {
+ DestroyOverflowLines();
+ }
+ }
+}
+
+void nsBlockFrame::RemoveFrameFromLine(nsIFrame* aChild,
+ nsLineList::iterator aLine,
+ nsFrameList& aFrameList,
+ nsLineList& aLineList) {
+ aFrameList.RemoveFrame(aChild);
+ if (aChild == aLine->mFirstChild) {
+ aLine->mFirstChild = aChild->GetNextSibling();
+ }
+ aLine->NoteFrameRemoved(aChild);
+ if (aLine->GetChildCount() > 0) {
+ aLine->MarkDirty();
+ } else {
+ // The line became empty - destroy it.
+ nsLineBox* lineBox = aLine;
+ aLine = aLineList.erase(aLine);
+ if (aLine != aLineList.end()) {
+ aLine->MarkPreviousMarginDirty();
+ }
+ FreeLineBox(lineBox);
+ }
+}
+
+void nsBlockFrame::DeleteNextInFlowChild(DestroyContext& aContext,
+ nsIFrame* aNextInFlow,
+ bool aDeletingEmptyFrames) {
+ MOZ_ASSERT(aNextInFlow->GetPrevInFlow(), "bad next-in-flow");
+
+ if (aNextInFlow->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW |
+ NS_FRAME_IS_OVERFLOW_CONTAINER)) {
+ nsContainerFrame::DeleteNextInFlowChild(aContext, aNextInFlow,
+ aDeletingEmptyFrames);
+ } else {
+#ifdef DEBUG
+ if (aDeletingEmptyFrames) {
+ nsLayoutUtils::AssertTreeOnlyEmptyNextInFlows(aNextInFlow);
+ }
+#endif
+ DoRemoveFrame(aContext, aNextInFlow,
+ aDeletingEmptyFrames ? FRAMES_ARE_EMPTY : 0);
+ }
+}
+
+const nsStyleText* nsBlockFrame::StyleTextForLineLayout() {
+ // Return the pointer to an unmodified style text
+ return StyleText();
+}
+
+void nsBlockFrame::ReflowFloat(BlockReflowState& aState, ReflowInput& aFloatRI,
+ nsIFrame* aFloat,
+ nsReflowStatus& aReflowStatus) {
+ MOZ_ASSERT(aReflowStatus.IsEmpty(),
+ "Caller should pass a fresh reflow status!");
+ MOZ_ASSERT(aFloat->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW),
+ "aFloat must be an out-of-flow frame");
+
+ WritingMode wm = aState.mReflowInput.GetWritingMode();
+
+ // Setup a block reflow context to reflow the float.
+ nsBlockReflowContext brc(aState.mPresContext, aState.mReflowInput);
+
+ nsIFrame* clearanceFrame = nullptr;
+ do {
+ nsCollapsingMargin margin;
+ bool mayNeedRetry = false;
+ aFloatRI.mDiscoveredClearance = nullptr;
+ // Only first in flow gets a block-start margin.
+ if (!aFloat->GetPrevInFlow()) {
+ brc.ComputeCollapsedBStartMargin(aFloatRI, &margin, clearanceFrame,
+ &mayNeedRetry);
+
+ if (mayNeedRetry && !clearanceFrame) {
+ aFloatRI.mDiscoveredClearance = &clearanceFrame;
+ // We don't need to push the float manager state because the the block
+ // has its own float manager that will be destroyed and recreated
+ }
+ }
+
+ // When reflowing a float, aSpace argument doesn't matter because we pass
+ // nullptr to aLine and we don't call nsBlockReflowContext::PlaceBlock()
+ // later.
+ brc.ReflowBlock(LogicalRect(wm), true, margin, 0, nullptr, aFloatRI,
+ aReflowStatus, aState);
+ } while (clearanceFrame);
+
+ if (aFloat->IsLetterFrame()) {
+ // We never split floating first letters; an incomplete status for such
+ // frames simply means that there is more content to be reflowed on the
+ // line.
+ if (aReflowStatus.IsIncomplete()) {
+ aReflowStatus.Reset();
+ }
+ }
+
+ NS_ASSERTION(aReflowStatus.IsFullyComplete() ||
+ aFloatRI.AvailableBSize() != NS_UNCONSTRAINEDSIZE,
+ "The status can only be incomplete or overflow-incomplete if "
+ "the available block-size is constrained!");
+
+ if (aReflowStatus.NextInFlowNeedsReflow()) {
+ aState.mReflowStatus.SetNextInFlowNeedsReflow();
+ }
+
+ const ReflowOutput& metrics = brc.GetMetrics();
+
+ // Set the rect, make sure the view is properly sized and positioned,
+ // and tell the frame we're done reflowing it
+ // XXXldb This seems like the wrong place to be doing this -- shouldn't
+ // we be doing this in BlockReflowState::FlowAndPlaceFloat after
+ // we've positioned the float, and shouldn't we be doing the equivalent
+ // of |PlaceFrameView| here?
+ WritingMode metricsWM = metrics.GetWritingMode();
+ aFloat->SetSize(metricsWM, metrics.Size(metricsWM));
+ if (aFloat->HasView()) {
+ nsContainerFrame::SyncFrameViewAfterReflow(
+ aState.mPresContext, aFloat, aFloat->GetView(), metrics.InkOverflow(),
+ ReflowChildFlags::NoMoveView);
+ }
+ aFloat->DidReflow(aState.mPresContext, &aFloatRI);
+}
+
+StyleClear nsBlockFrame::FindTrailingClear() {
+ for (nsBlockFrame* b = this; b;
+ b = static_cast<nsBlockFrame*>(b->GetPrevInFlow())) {
+ auto endLine = b->LinesRBegin();
+ if (endLine != b->LinesREnd()) {
+ return endLine->FloatClearTypeAfter();
+ }
+ }
+ return StyleClear::None;
+}
+
+void nsBlockFrame::ReflowPushedFloats(BlockReflowState& aState,
+ OverflowAreas& aOverflowAreas) {
+ // Pushed floats live at the start of our float list; see comment
+ // above nsBlockFrame::DrainPushedFloats.
+ nsIFrame* f = mFloats.FirstChild();
+ nsIFrame* prev = nullptr;
+ while (f && f->HasAnyStateBits(NS_FRAME_IS_PUSHED_FLOAT)) {
+ MOZ_ASSERT(prev == f->GetPrevSibling());
+ // When we push a first-continuation float in a non-initial reflow,
+ // it's possible that we end up with two continuations with the same
+ // parent. This happens if, on the previous reflow of the block or
+ // a previous reflow of the line containing the block, the float was
+ // split between continuations A and B of the parent, but on the
+ // current reflow, none of the float can fit in A.
+ //
+ // When this happens, we might even have the two continuations
+ // out-of-order due to the management of the pushed floats. In
+ // particular, if the float's placeholder was in a pushed line that
+ // we reflowed before it was pushed, and we split the float during
+ // that reflow, we might have the continuation of the float before
+ // the float itself. (In the general case, however, it's correct
+ // for floats in the pushed floats list to come before floats
+ // anchored in pushed lines; however, in this case it's wrong. We
+ // should probably find a way to fix it somehow, since it leads to
+ // incorrect layout in some cases.)
+ //
+ // When we have these out-of-order continuations, we might hit the
+ // next-continuation before the previous-continuation. When that
+ // happens, just push it. When we reflow the next continuation,
+ // we'll either pull all of its content back and destroy it (by
+ // calling DeleteNextInFlowChild), or nsBlockFrame::SplitFloat will
+ // pull it out of its current position and push it again (and
+ // potentially repeat this cycle for the next continuation, although
+ // hopefully then they'll be in the right order).
+ //
+ // We should also need this code for the in-order case if the first
+ // continuation of a float gets moved across more than one
+ // continuation of the containing block. In this case we'd manage
+ // to push the second continuation without this check, but not the
+ // third and later.
+ nsIFrame* prevContinuation = f->GetPrevContinuation();
+ if (prevContinuation && prevContinuation->GetParent() == f->GetParent()) {
+ mFloats.RemoveFrame(f);
+ aState.AppendPushedFloatChain(f);
+ f = !prev ? mFloats.FirstChild() : prev->GetNextSibling();
+ continue;
+ }
+
+ // Always call FlowAndPlaceFloat; we might need to place this float if it
+ // didn't belong to this block the last time it was reflowed. Note that if
+ // the float doesn't get placed, we don't consider its overflow areas.
+ // (Not-getting-placed means it didn't fit and we pushed it instead of
+ // placing it, and its position could be stale.)
+ if (aState.FlowAndPlaceFloat(f) ==
+ BlockReflowState::PlaceFloatResult::Placed) {
+ ConsiderChildOverflow(aOverflowAreas, f);
+ }
+
+ nsIFrame* next = !prev ? mFloats.FirstChild() : prev->GetNextSibling();
+ if (next == f) {
+ // We didn't push |f| so its next-sibling is next.
+ next = f->GetNextSibling();
+ prev = f;
+ } // else: we did push |f| so |prev|'s new next-sibling is next.
+ f = next;
+ }
+
+ // If there are pushed or split floats, then we may need to continue BR
+ // clearance
+ if (auto [bCoord, result] = aState.ClearFloats(0, StyleClear::Both);
+ result != ClearFloatsResult::BCoordNoChange) {
+ Unused << bCoord;
+ if (auto* prevBlock = static_cast<nsBlockFrame*>(GetPrevInFlow())) {
+ aState.mTrailingClearFromPIF = prevBlock->FindTrailingClear();
+ }
+ }
+}
+
+void nsBlockFrame::RecoverFloats(nsFloatManager& aFloatManager, WritingMode aWM,
+ const nsSize& aContainerSize) {
+ // Recover our own floats
+ nsIFrame* stop = nullptr; // Stop before we reach pushed floats that
+ // belong to our next-in-flow
+ for (nsIFrame* f = mFloats.FirstChild(); f && f != stop;
+ f = f->GetNextSibling()) {
+ LogicalRect region = nsFloatManager::GetRegionFor(aWM, f, aContainerSize);
+ aFloatManager.AddFloat(f, region, aWM, aContainerSize);
+ if (!stop && f->GetNextInFlow()) {
+ stop = f->GetNextInFlow();
+ }
+ }
+
+ // Recurse into our overflow container children
+ for (nsIFrame* oc =
+ GetChildList(FrameChildListID::OverflowContainers).FirstChild();
+ oc; oc = oc->GetNextSibling()) {
+ RecoverFloatsFor(oc, aFloatManager, aWM, aContainerSize);
+ }
+
+ // Recurse into our normal children
+ for (const auto& line : Lines()) {
+ if (line.IsBlock()) {
+ RecoverFloatsFor(line.mFirstChild, aFloatManager, aWM, aContainerSize);
+ }
+ }
+}
+
+void nsBlockFrame::RecoverFloatsFor(nsIFrame* aFrame,
+ nsFloatManager& aFloatManager,
+ WritingMode aWM,
+ const nsSize& aContainerSize) {
+ MOZ_ASSERT(aFrame, "null frame");
+
+ // Only blocks have floats
+ nsBlockFrame* block = do_QueryFrame(aFrame);
+ // Don't recover any state inside a block that has its own float manager
+ // (we don't currently have any blocks like this, though, thanks to our
+ // use of extra frames for 'overflow')
+ if (block && !nsBlockFrame::BlockNeedsFloatManager(block)) {
+ // If the element is relatively positioned, then adjust x and y
+ // accordingly so that we consider relatively positioned frames
+ // at their original position.
+
+ const LogicalRect rect = block->GetLogicalNormalRect(aWM, aContainerSize);
+ nscoord lineLeft = rect.LineLeft(aWM, aContainerSize);
+ nscoord blockStart = rect.BStart(aWM);
+ aFloatManager.Translate(lineLeft, blockStart);
+ block->RecoverFloats(aFloatManager, aWM, aContainerSize);
+ aFloatManager.Translate(-lineLeft, -blockStart);
+ }
+}
+
+bool nsBlockFrame::HasPushedFloatsFromPrevContinuation() const {
+ if (!mFloats.IsEmpty()) {
+ // If we have pushed floats, then they should be at the beginning of our
+ // float list.
+ if (mFloats.FirstChild()->HasAnyStateBits(NS_FRAME_IS_PUSHED_FLOAT)) {
+ return true;
+ }
+ }
+
+#ifdef DEBUG
+ // Double-check the above assertion that pushed floats should be at the
+ // beginning of our floats list.
+ for (nsIFrame* f : mFloats) {
+ NS_ASSERTION(!f->HasAnyStateBits(NS_FRAME_IS_PUSHED_FLOAT),
+ "pushed floats must be at the beginning of the float list");
+ }
+#endif
+
+ // We may have a pending push of pushed floats too:
+ if (HasPushedFloats()) {
+ // XXX we can return 'true' here once we make HasPushedFloats
+ // not lie. (see nsBlockFrame::RemoveFloat)
+ auto* pushedFloats = GetPushedFloats();
+ return pushedFloats && !pushedFloats->IsEmpty();
+ }
+ return false;
+}
+
+//////////////////////////////////////////////////////////////////////
+// Painting, event handling
+
+#ifdef DEBUG
+static void ComputeInkOverflowArea(nsLineList& aLines, nscoord aWidth,
+ nscoord aHeight, nsRect& aResult) {
+ nscoord xa = 0, ya = 0, xb = aWidth, yb = aHeight;
+ for (nsLineList::iterator line = aLines.begin(), line_end = aLines.end();
+ line != line_end; ++line) {
+ // Compute min and max x/y values for the reflowed frame's
+ // combined areas
+ nsRect inkOverflow(line->InkOverflowRect());
+ nscoord x = inkOverflow.x;
+ nscoord y = inkOverflow.y;
+ nscoord xmost = x + inkOverflow.width;
+ nscoord ymost = y + inkOverflow.height;
+ if (x < xa) {
+ xa = x;
+ }
+ if (xmost > xb) {
+ xb = xmost;
+ }
+ if (y < ya) {
+ ya = y;
+ }
+ if (ymost > yb) {
+ yb = ymost;
+ }
+ }
+
+ aResult.x = xa;
+ aResult.y = ya;
+ aResult.width = xb - xa;
+ aResult.height = yb - ya;
+}
+#endif
+
+#ifdef DEBUG
+static void DebugOutputDrawLine(int32_t aDepth, nsLineBox* aLine, bool aDrawn) {
+ if (nsBlockFrame::gNoisyDamageRepair) {
+ nsIFrame::IndentBy(stdout, aDepth + 1);
+ nsRect lineArea = aLine->InkOverflowRect();
+ printf("%s line=%p bounds=%d,%d,%d,%d ca=%d,%d,%d,%d\n",
+ aDrawn ? "draw" : "skip", static_cast<void*>(aLine), aLine->IStart(),
+ aLine->BStart(), aLine->ISize(), aLine->BSize(), lineArea.x,
+ lineArea.y, lineArea.width, lineArea.height);
+ }
+}
+#endif
+
+static void DisplayLine(nsDisplayListBuilder* aBuilder,
+ nsBlockFrame::LineIterator& aLine,
+ const bool aLineInLine, const nsDisplayListSet& aLists,
+ nsBlockFrame* aFrame, TextOverflow* aTextOverflow,
+ uint32_t aLineNumberForTextOverflow, int32_t aDepth,
+ int32_t& aDrawnLines) {
+#ifdef DEBUG
+ if (nsBlockFrame::gLamePaintMetrics) {
+ aDrawnLines++;
+ }
+ const bool intersect =
+ aLine->InkOverflowRect().Intersects(aBuilder->GetDirtyRect());
+ DebugOutputDrawLine(aDepth, aLine.get(), intersect);
+#endif
+
+ // Collect our line's display items in a temporary nsDisplayListCollection,
+ // so that we can apply any "text-overflow" clipping to the entire collection
+ // without affecting previous lines.
+ nsDisplayListCollection collection(aBuilder);
+
+ // Block-level child backgrounds go on the blockBorderBackgrounds list ...
+ // Inline-level child backgrounds go on the regular child content list.
+ nsDisplayListSet childLists(
+ collection,
+ aLineInLine ? collection.Content() : collection.BlockBorderBackgrounds());
+
+ auto flags =
+ aLineInLine
+ ? nsIFrame::DisplayChildFlags(nsIFrame::DisplayChildFlag::Inline)
+ : nsIFrame::DisplayChildFlags();
+
+ nsIFrame* kid = aLine->mFirstChild;
+ int32_t n = aLine->GetChildCount();
+ while (--n >= 0) {
+ aFrame->BuildDisplayListForChild(aBuilder, kid, childLists, flags);
+ kid = kid->GetNextSibling();
+ }
+
+ if (aTextOverflow && aLineInLine) {
+ aTextOverflow->ProcessLine(collection, aLine.get(),
+ aLineNumberForTextOverflow);
+ }
+
+ collection.MoveTo(aLists);
+}
+
+void nsBlockFrame::BuildDisplayList(nsDisplayListBuilder* aBuilder,
+ const nsDisplayListSet& aLists) {
+ int32_t drawnLines; // Will only be used if set (gLamePaintMetrics).
+ int32_t depth = 0;
+#ifdef DEBUG
+ if (gNoisyDamageRepair) {
+ nsRect dirty = aBuilder->GetDirtyRect();
+ depth = GetDepth();
+ nsRect ca;
+ ::ComputeInkOverflowArea(mLines, mRect.width, mRect.height, ca);
+ nsIFrame::IndentBy(stdout, depth);
+ ListTag(stdout);
+ printf(": bounds=%d,%d,%d,%d dirty(absolute)=%d,%d,%d,%d ca=%d,%d,%d,%d\n",
+ mRect.x, mRect.y, mRect.width, mRect.height, dirty.x, dirty.y,
+ dirty.width, dirty.height, ca.x, ca.y, ca.width, ca.height);
+ }
+ PRTime start = 0; // Initialize these variables to silence the compiler.
+ if (gLamePaintMetrics) {
+ start = PR_Now();
+ drawnLines = 0;
+ }
+#endif
+
+ // TODO(heycam): Should we boost the load priority of any shape-outside
+ // images using CATEGORY_DISPLAY, now that this block is being displayed?
+ // We don't have a float manager here.
+
+ DisplayBorderBackgroundOutline(aBuilder, aLists);
+
+ if (GetPrevInFlow()) {
+ DisplayOverflowContainers(aBuilder, aLists);
+ for (nsIFrame* f : mFloats) {
+ if (f->HasAnyStateBits(NS_FRAME_IS_PUSHED_FLOAT)) {
+ BuildDisplayListForChild(aBuilder, f, aLists);
+ }
+ }
+ }
+
+ aBuilder->MarkFramesForDisplayList(this, mFloats);
+
+ if (HasOutsideMarker()) {
+ // Display outside ::marker manually.
+ BuildDisplayListForChild(aBuilder, GetOutsideMarker(), aLists);
+ }
+
+ // Prepare for text-overflow processing.
+ Maybe<TextOverflow> textOverflow =
+ TextOverflow::WillProcessLines(aBuilder, this);
+
+ const bool hasDescendantPlaceHolders =
+ HasAnyStateBits(NS_FRAME_FORCE_DISPLAY_LIST_DESCEND_INTO) ||
+ ForceDescendIntoIfVisible() || aBuilder->GetIncludeAllOutOfFlows();
+
+ const auto ShouldDescendIntoLine = [&](const nsRect& aLineArea) -> bool {
+ // TODO(miko): Unfortunately |descendAlways| cannot be cached, because with
+ // some frame trees, building display list for child lines can change it.
+ // See bug 1552789.
+ const bool descendAlways =
+ HasAnyStateBits(NS_FRAME_FORCE_DISPLAY_LIST_DESCEND_INTO) ||
+ aBuilder->GetIncludeAllOutOfFlows();
+
+ return descendAlways || aLineArea.Intersects(aBuilder->GetDirtyRect()) ||
+ (ForceDescendIntoIfVisible() &&
+ aLineArea.Intersects(aBuilder->GetVisibleRect()));
+ };
+
+ Maybe<nscolor> backplateColor;
+
+ // We'll try to draw an accessibility backplate behind text (to ensure it's
+ // readable over any possible background-images), if all of the following
+ // hold:
+ // (A) the backplate feature is preffed on
+ // (B) we are not honoring the document colors
+ // (C) the force color adjust property is set to auto
+ if (StaticPrefs::browser_display_permit_backplate() &&
+ PresContext()->ForcingColors() && !IsComboboxControlFrame() &&
+ StyleText()->mForcedColorAdjust != StyleForcedColorAdjust::None) {
+ backplateColor.emplace(GetBackplateColor(this));
+ }
+
+ // Don't use the line cursor if we might have a descendant placeholder ...
+ // it might skip lines that contain placeholders but don't themselves
+ // intersect with the dirty area.
+ // In particular, we really want to check ShouldDescendIntoFrame()
+ // on all our child frames, but that might be expensive. So we
+ // approximate it by checking it on |this|; if it's true for any
+ // frame in our child list, it's also true for |this|.
+ // Also skip the cursor if we're creating text overflow markers,
+ // since we need to know what line number we're up to in order
+ // to generate unique display item keys.
+ // Lastly, the cursor should be skipped if we're drawing
+ // backplates behind text. When backplating we consider consecutive
+ // runs of text as a whole, which requires we iterate through all lines
+ // to find our backplate size.
+ nsLineBox* cursor =
+ (hasDescendantPlaceHolders || textOverflow.isSome() || backplateColor)
+ ? nullptr
+ : GetFirstLineContaining(aBuilder->GetDirtyRect().y);
+ LineIterator line_end = LinesEnd();
+
+ TextOverflow* textOverflowPtr = textOverflow.ptrOr(nullptr);
+
+ if (cursor) {
+ for (LineIterator line = mLines.begin(cursor); line != line_end; ++line) {
+ const nsRect lineArea = line->InkOverflowRect();
+ if (!lineArea.IsEmpty()) {
+ // Because we have a cursor, the combinedArea.ys are non-decreasing.
+ // Once we've passed aDirtyRect.YMost(), we can never see it again.
+ if (lineArea.y >= aBuilder->GetDirtyRect().YMost()) {
+ break;
+ }
+ MOZ_ASSERT(textOverflow.isNothing());
+
+ if (ShouldDescendIntoLine(lineArea)) {
+ DisplayLine(aBuilder, line, line->IsInline(), aLists, this, nullptr,
+ 0, depth, drawnLines);
+ }
+ }
+ }
+ } else {
+ bool nonDecreasingYs = true;
+ uint32_t lineCount = 0;
+ nscoord lastY = INT32_MIN;
+ nscoord lastYMost = INT32_MIN;
+
+ // A frame's display list cannot contain more than one copy of a
+ // given display item unless the items are uniquely identifiable.
+ // Because backplate occasionally requires multiple
+ // SolidColor items, we use an index (backplateIndex) to maintain
+ // uniqueness among them. Note this is a mapping of index to
+ // item, and the mapping is stable even if the dirty rect changes.
+ uint16_t backplateIndex = 0;
+ nsRect curBackplateArea;
+
+ auto AddBackplate = [&]() {
+ aLists.BorderBackground()->AppendNewToTopWithIndex<nsDisplaySolidColor>(
+ aBuilder, this, backplateIndex, curBackplateArea,
+ backplateColor.value());
+ };
+
+ for (LineIterator line = LinesBegin(); line != line_end; ++line) {
+ const nsRect lineArea = line->InkOverflowRect();
+ const bool lineInLine = line->IsInline();
+
+ if ((lineInLine && textOverflowPtr) || ShouldDescendIntoLine(lineArea)) {
+ DisplayLine(aBuilder, line, lineInLine, aLists, this, textOverflowPtr,
+ lineCount, depth, drawnLines);
+ }
+
+ if (!lineInLine && !curBackplateArea.IsEmpty()) {
+ // If we have encountered a non-inline line but were previously
+ // forming a backplate, we should add the backplate to the display
+ // list as-is and render future backplates disjointly.
+ MOZ_ASSERT(backplateColor,
+ "if this master switch is off, curBackplateArea "
+ "must be empty and we shouldn't get here");
+ AddBackplate();
+ backplateIndex++;
+ curBackplateArea = nsRect();
+ }
+
+ if (!lineArea.IsEmpty()) {
+ if (lineArea.y < lastY || lineArea.YMost() < lastYMost) {
+ nonDecreasingYs = false;
+ }
+ lastY = lineArea.y;
+ lastYMost = lineArea.YMost();
+ if (lineInLine && backplateColor && LineHasVisibleInlineContent(line)) {
+ nsRect lineBackplate = GetLineTextArea(line, aBuilder) +
+ aBuilder->ToReferenceFrame(this);
+ if (curBackplateArea.IsEmpty()) {
+ curBackplateArea = lineBackplate;
+ } else {
+ curBackplateArea.OrWith(lineBackplate);
+ }
+ }
+ }
+ lineCount++;
+ }
+
+ if (nonDecreasingYs && lineCount >= MIN_LINES_NEEDING_CURSOR) {
+ SetupLineCursorForDisplay();
+ }
+
+ if (!curBackplateArea.IsEmpty()) {
+ AddBackplate();
+ }
+ }
+
+ if (textOverflow.isSome()) {
+ // Put any text-overflow:ellipsis markers on top of the non-positioned
+ // content of the block's lines. (If we ever start sorting the Content()
+ // list this will end up in the wrong place.)
+ aLists.Content()->AppendToTop(&textOverflow->GetMarkers());
+ }
+
+#ifdef DEBUG
+ if (gLamePaintMetrics) {
+ PRTime end = PR_Now();
+
+ int32_t numLines = mLines.size();
+ if (!numLines) {
+ numLines = 1;
+ }
+ PRTime lines, deltaPerLine, delta;
+ lines = int64_t(numLines);
+ delta = end - start;
+ deltaPerLine = delta / lines;
+
+ ListTag(stdout);
+ char buf[400];
+ SprintfLiteral(buf,
+ ": %" PRId64 " elapsed (%" PRId64
+ " per line) lines=%d drawn=%d skip=%d",
+ delta, deltaPerLine, numLines, drawnLines,
+ numLines - drawnLines);
+ printf("%s\n", buf);
+ }
+#endif
+}
+
+#ifdef ACCESSIBILITY
+a11y::AccType nsBlockFrame::AccessibleType() {
+ if (IsTableCaption()) {
+ return GetRect().IsEmpty() ? a11y::eNoType : a11y::eHTMLCaptionType;
+ }
+
+ // block frame may be for <hr>
+ if (mContent->IsHTMLElement(nsGkAtoms::hr)) {
+ return a11y::eHTMLHRType;
+ }
+
+ if (!HasMarker() || !PresContext()) {
+ // XXXsmaug What if we're in the shadow dom?
+ if (!mContent->GetParent()) {
+ // Don't create accessible objects for the root content node, they are
+ // redundant with the nsDocAccessible object created with the document
+ // node
+ return a11y::eNoType;
+ }
+
+ if (mContent == mContent->OwnerDoc()->GetBody()) {
+ // Don't create accessible objects for the body, they are redundant with
+ // the nsDocAccessible object created with the document node
+ return a11y::eNoType;
+ }
+
+ // Not a list item with a ::marker, treat as normal HTML container.
+ return a11y::eHyperTextType;
+ }
+
+ // Create special list item accessible since we have a ::marker.
+ return a11y::eHTMLLiType;
+}
+#endif
+
+void nsBlockFrame::SetupLineCursorForDisplay() {
+ if (mLines.empty() || HasProperty(LineCursorPropertyDisplay())) {
+ return;
+ }
+
+ SetProperty(LineCursorPropertyDisplay(), mLines.front());
+ AddStateBits(NS_BLOCK_HAS_LINE_CURSOR);
+}
+
+void nsBlockFrame::SetupLineCursorForQuery() {
+ if (mLines.empty() || HasProperty(LineCursorPropertyQuery())) {
+ return;
+ }
+
+ SetProperty(LineCursorPropertyQuery(), mLines.front());
+ AddStateBits(NS_BLOCK_HAS_LINE_CURSOR);
+}
+
+nsLineBox* nsBlockFrame::GetFirstLineContaining(nscoord y) {
+ // Although this looks like a "querying" method, it is used by the
+ // display-list building code, so uses the Display cursor.
+ nsLineBox* property = GetLineCursorForDisplay();
+ if (!property) {
+ return nullptr;
+ }
+ LineIterator cursor = mLines.begin(property);
+ nsRect cursorArea = cursor->InkOverflowRect();
+
+ while ((cursorArea.IsEmpty() || cursorArea.YMost() > y) &&
+ cursor != mLines.front()) {
+ cursor = cursor.prev();
+ cursorArea = cursor->InkOverflowRect();
+ }
+ while ((cursorArea.IsEmpty() || cursorArea.YMost() <= y) &&
+ cursor != mLines.back()) {
+ cursor = cursor.next();
+ cursorArea = cursor->InkOverflowRect();
+ }
+
+ if (cursor.get() != property) {
+ SetProperty(LineCursorPropertyDisplay(), cursor.get());
+ }
+
+ return cursor.get();
+}
+
+/* virtual */
+void nsBlockFrame::ChildIsDirty(nsIFrame* aChild) {
+ // See if the child is absolutely positioned
+ if (aChild->IsAbsolutelyPositioned()) {
+ // do nothing
+ } else if (aChild == GetOutsideMarker()) {
+ // The ::marker lives in the first line, unless the first line has
+ // height 0 and there is a second line, in which case it lives
+ // in the second line.
+ LineIterator markerLine = LinesBegin();
+ if (markerLine != LinesEnd() && markerLine->BSize() == 0 &&
+ markerLine != mLines.back()) {
+ markerLine = markerLine.next();
+ }
+
+ if (markerLine != LinesEnd()) {
+ MarkLineDirty(markerLine, &mLines);
+ }
+ // otherwise we have an empty line list, and ReflowDirtyLines
+ // will handle reflowing the ::marker.
+ } else {
+ // Note that we should go through our children to mark lines dirty
+ // before the next reflow. Doing it now could make things O(N^2)
+ // since finding the right line is O(N).
+ // We don't need to worry about marking lines on the overflow list
+ // as dirty; we're guaranteed to reflow them if we take them off the
+ // overflow list.
+ // However, we might have gotten a float, in which case we need to
+ // reflow the line containing its placeholder. So find the
+ // ancestor-or-self of the placeholder that's a child of the block,
+ // and mark it as NS_FRAME_HAS_DIRTY_CHILDREN too, so that we mark
+ // its line dirty when we handle NS_BLOCK_LOOK_FOR_DIRTY_FRAMES.
+ // We need to take some care to handle the case where a float is in
+ // a different continuation than its placeholder, including marking
+ // an extra block with NS_BLOCK_LOOK_FOR_DIRTY_FRAMES.
+ if (!aChild->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW)) {
+ AddStateBits(NS_BLOCK_LOOK_FOR_DIRTY_FRAMES);
+ } else {
+ NS_ASSERTION(aChild->IsFloating(), "should be a float");
+ nsIFrame* thisFC = FirstContinuation();
+ nsIFrame* placeholderPath = aChild->GetPlaceholderFrame();
+ // SVG code sometimes sends FrameNeedsReflow notifications during
+ // frame destruction, leading to null placeholders, but we're safe
+ // ignoring those.
+ if (placeholderPath) {
+ for (;;) {
+ nsIFrame* parent = placeholderPath->GetParent();
+ if (parent->GetContent() == mContent &&
+ parent->FirstContinuation() == thisFC) {
+ parent->AddStateBits(NS_BLOCK_LOOK_FOR_DIRTY_FRAMES);
+ break;
+ }
+ placeholderPath = parent;
+ }
+ placeholderPath->AddStateBits(NS_FRAME_HAS_DIRTY_CHILDREN);
+ }
+ }
+ }
+
+ nsContainerFrame::ChildIsDirty(aChild);
+}
+
+static bool AlwaysEstablishesBFC(const nsBlockFrame* aFrame) {
+ switch (aFrame->Type()) {
+ case LayoutFrameType::ColumnSetWrapper:
+ // CSS Multi-column level 1 section 2: A multi-column container
+ // establishes a new block formatting context, as per CSS 2.1 section
+ // 9.4.1.
+ case LayoutFrameType::ComboboxControl:
+ return true;
+ case LayoutFrameType::Block:
+ return static_cast<const nsFileControlFrame*>(do_QueryFrame(aFrame)) ||
+ // Ensure that the options inside the select aren't expanded by
+ // right floats outside the select.
+ static_cast<const nsSelectsAreaFrame*>(do_QueryFrame(aFrame)) ||
+ // See bug 1373767 and bug 353894.
+ static_cast<const nsMathMLmathBlockFrame*>(do_QueryFrame(aFrame));
+ default:
+ return false;
+ }
+}
+
+void nsBlockFrame::Init(nsIContent* aContent, nsContainerFrame* aParent,
+ nsIFrame* aPrevInFlow) {
+ // These are all the block specific frame bits, they are copied from
+ // the prev-in-flow to a newly created next-in-flow, except for the
+ // NS_BLOCK_FLAGS_NON_INHERITED_MASK bits below.
+ constexpr nsFrameState NS_BLOCK_FLAGS_MASK =
+ NS_BLOCK_BFC_STATE_BITS | NS_BLOCK_CLIP_PAGINATED_OVERFLOW |
+ NS_BLOCK_HAS_FIRST_LETTER_STYLE | NS_BLOCK_FRAME_HAS_OUTSIDE_MARKER |
+ NS_BLOCK_HAS_FIRST_LETTER_CHILD | NS_BLOCK_FRAME_HAS_INSIDE_MARKER;
+
+ // This is the subset of NS_BLOCK_FLAGS_MASK that is NOT inherited
+ // by default. They should only be set on the first-in-flow.
+ constexpr nsFrameState NS_BLOCK_FLAGS_NON_INHERITED_MASK =
+ NS_BLOCK_FRAME_HAS_OUTSIDE_MARKER | NS_BLOCK_HAS_FIRST_LETTER_CHILD |
+ NS_BLOCK_FRAME_HAS_INSIDE_MARKER;
+
+ if (aPrevInFlow) {
+ // Copy over the inherited block frame bits from the prev-in-flow.
+ RemoveStateBits(NS_BLOCK_FLAGS_MASK);
+ AddStateBits(aPrevInFlow->GetStateBits() &
+ (NS_BLOCK_FLAGS_MASK & ~NS_BLOCK_FLAGS_NON_INHERITED_MASK));
+ }
+
+ nsContainerFrame::Init(aContent, aParent, aPrevInFlow);
+
+ if (!aPrevInFlow ||
+ aPrevInFlow->HasAnyStateBits(NS_BLOCK_NEEDS_BIDI_RESOLUTION)) {
+ AddStateBits(NS_BLOCK_NEEDS_BIDI_RESOLUTION);
+ }
+
+ // A display:flow-root box establishes a block formatting context.
+ //
+ // If a box has a different writing-mode value than its containing block:
+ // ...
+ // If the box is a block container, then it establishes a new block
+ // formatting context.
+ // (https://drafts.csswg.org/css-writing-modes/#block-flow)
+ //
+ // If the box has contain: paint or contain:layout (or contain:strict),
+ // then it should also establish a formatting context.
+ //
+ // Per spec, a column-span always establishes a new block formatting context.
+ //
+ // Other more specific frame types also always establish a BFC.
+ //
+ if (StyleDisplay()->mDisplay == mozilla::StyleDisplay::FlowRoot ||
+ (GetParent() &&
+ (GetWritingMode().GetBlockDir() !=
+ GetParent()->GetWritingMode().GetBlockDir() ||
+ GetWritingMode().IsVerticalSideways() !=
+ GetParent()->GetWritingMode().IsVerticalSideways())) ||
+ IsColumnSpan() || AlwaysEstablishesBFC(this)) {
+ AddStateBits(NS_BLOCK_STATIC_BFC);
+ }
+
+ if (StyleEstablishesBFC(Style())) {
+ AddStateBits(NS_BLOCK_DYNAMIC_BFC);
+ }
+
+ if (HasAnyStateBits(NS_FRAME_FONT_INFLATION_CONTAINER) &&
+ HasAnyStateBits(NS_BLOCK_BFC_STATE_BITS)) {
+ AddStateBits(NS_FRAME_FONT_INFLATION_FLOW_ROOT);
+ }
+}
+
+void nsBlockFrame::SetInitialChildList(ChildListID aListID,
+ nsFrameList&& aChildList) {
+ if (FrameChildListID::Float == aListID) {
+ mFloats = std::move(aChildList);
+ } else if (FrameChildListID::Principal == aListID) {
+#ifdef DEBUG
+ // The only times a block that is an anonymous box is allowed to have a
+ // first-letter frame are when it's the block inside a non-anonymous cell,
+ // the block inside a fieldset, button or column set, or a scrolled content
+ // block, except for <select>. Note that this means that blocks which are
+ // the anonymous block in {ib} splits do NOT get first-letter frames.
+ // Note that NS_BLOCK_HAS_FIRST_LETTER_STYLE gets set on all continuations
+ // of the block.
+ auto pseudo = Style()->GetPseudoType();
+ bool haveFirstLetterStyle =
+ (pseudo == PseudoStyleType::NotPseudo ||
+ (pseudo == PseudoStyleType::cellContent &&
+ !GetParent()->Style()->IsPseudoOrAnonBox()) ||
+ pseudo == PseudoStyleType::fieldsetContent ||
+ pseudo == PseudoStyleType::buttonContent ||
+ pseudo == PseudoStyleType::columnContent ||
+ (pseudo == PseudoStyleType::scrolledContent &&
+ !GetParent()->IsListControlFrame()) ||
+ pseudo == PseudoStyleType::mozSVGText) &&
+ !IsComboboxControlFrame() && !IsMathMLFrame() &&
+ !IsColumnSetWrapperFrame() &&
+ RefPtr<ComputedStyle>(GetFirstLetterStyle(PresContext())) != nullptr;
+ NS_ASSERTION(haveFirstLetterStyle ==
+ HasAnyStateBits(NS_BLOCK_HAS_FIRST_LETTER_STYLE),
+ "NS_BLOCK_HAS_FIRST_LETTER_STYLE state out of sync");
+#endif
+
+ AddFrames(std::move(aChildList), nullptr, nullptr);
+ } else {
+ nsContainerFrame::SetInitialChildList(aListID, std::move(aChildList));
+ }
+}
+
+void nsBlockFrame::SetMarkerFrameForListItem(nsIFrame* aMarkerFrame) {
+ MOZ_ASSERT(aMarkerFrame);
+ MOZ_ASSERT(!HasAnyStateBits(NS_BLOCK_FRAME_HAS_INSIDE_MARKER |
+ NS_BLOCK_FRAME_HAS_OUTSIDE_MARKER),
+ "How can we have a ::marker frame already?");
+
+ if (StyleList()->mListStylePosition == StyleListStylePosition::Inside) {
+ SetProperty(InsideMarkerProperty(), aMarkerFrame);
+ AddStateBits(NS_BLOCK_FRAME_HAS_INSIDE_MARKER);
+ } else {
+ if (nsBlockFrame* marker = do_QueryFrame(aMarkerFrame)) {
+ // An outside ::marker needs to be an independent formatting context
+ // to avoid being influenced by the float manager etc.
+ marker->AddStateBits(NS_BLOCK_STATIC_BFC);
+ }
+ SetProperty(OutsideMarkerProperty(),
+ new (PresShell()) nsFrameList(aMarkerFrame, aMarkerFrame));
+ AddStateBits(NS_BLOCK_FRAME_HAS_OUTSIDE_MARKER);
+ }
+}
+
+bool nsBlockFrame::MarkerIsEmpty() const {
+ NS_ASSERTION(mContent->GetPrimaryFrame()->StyleDisplay()->IsListItem() &&
+ HasOutsideMarker(),
+ "should only care when we have an outside ::marker");
+ nsIFrame* marker = GetMarker();
+ const nsStyleList* list = marker->StyleList();
+ return marker->StyleContent()->mContent.IsNone() ||
+ (list->mCounterStyle.IsNone() && list->mListStyleImage.IsNone() &&
+ marker->StyleContent()->ContentCount() == 0);
+}
+
+void nsBlockFrame::ReflowOutsideMarker(nsIFrame* aMarkerFrame,
+ BlockReflowState& aState,
+ ReflowOutput& aMetrics,
+ nscoord aLineTop) {
+ const ReflowInput& ri = aState.mReflowInput;
+
+ WritingMode markerWM = aMarkerFrame->GetWritingMode();
+ LogicalSize availSize(markerWM);
+ // Make up an inline-size since it doesn't really matter (XXX).
+ availSize.ISize(markerWM) = aState.ContentISize();
+ availSize.BSize(markerWM) = NS_UNCONSTRAINEDSIZE;
+
+ ReflowInput reflowInput(aState.mPresContext, ri, aMarkerFrame, availSize,
+ Nothing(), {}, {}, {ComputeSizeFlag::ShrinkWrap});
+ nsReflowStatus status;
+ aMarkerFrame->Reflow(aState.mPresContext, aMetrics, reflowInput, status);
+
+ // Get the float available space using our saved state from before we
+ // started reflowing the block, so that we ignore any floats inside
+ // the block.
+ // FIXME: aLineTop isn't actually set correctly by some callers, since
+ // they reposition the line.
+ LogicalRect floatAvailSpace =
+ aState
+ .GetFloatAvailableSpaceWithState(aLineTop, ShapeType::ShapeOutside,
+ &aState.mFloatManagerStateBefore)
+ .mRect;
+ // FIXME (bug 25888): need to check the entire region that the first
+ // line overlaps, not just the top pixel.
+
+ // Place the ::marker now. We want to place the ::marker relative to the
+ // border-box of the associated block (using the right/left margin of
+ // the ::marker frame as separation). However, if a line box would be
+ // displaced by floats that are *outside* the associated block, we
+ // want to displace it by the same amount. That is, we act as though
+ // the edge of the floats is the content-edge of the block, and place
+ // the ::marker at a position offset from there by the block's padding,
+ // the block's border, and the ::marker frame's margin.
+
+ // IStart from floatAvailSpace gives us the content/float start edge
+ // in the current writing mode. Then we subtract out the start
+ // border/padding and the ::marker's width and margin to offset the position.
+ WritingMode wm = ri.GetWritingMode();
+ // Get the ::marker's margin, converted to our writing mode so that we can
+ // combine it with other logical values here.
+ LogicalMargin markerMargin = reflowInput.ComputedLogicalMargin(wm);
+ nscoord iStart = floatAvailSpace.IStart(wm) -
+ ri.ComputedLogicalBorderPadding(wm).IStart(wm) -
+ markerMargin.IEnd(wm) - aMetrics.ISize(wm);
+
+ // Approximate the ::marker's position; vertical alignment will provide
+ // the final vertical location. We pass our writing-mode here, because
+ // it may be different from the ::marker frame's mode.
+ nscoord bStart = floatAvailSpace.BStart(wm);
+ aMarkerFrame->SetRect(
+ wm,
+ LogicalRect(wm, iStart, bStart, aMetrics.ISize(wm), aMetrics.BSize(wm)),
+ aState.ContainerSize());
+ aMarkerFrame->DidReflow(aState.mPresContext, &aState.mReflowInput);
+}
+
+// This is used to scan frames for any float placeholders, add their
+// floats to the list represented by aList, and remove the
+// floats from whatever list they might be in. We don't search descendants
+// that are float containing blocks. Floats that or not children of 'this'
+// are ignored (they are not added to aList).
+void nsBlockFrame::DoCollectFloats(nsIFrame* aFrame, nsFrameList& aList,
+ bool aCollectSiblings) {
+ while (aFrame) {
+ // Don't descend into float containing blocks.
+ if (!aFrame->IsFloatContainingBlock()) {
+ nsIFrame* outOfFlowFrame =
+ aFrame->IsPlaceholderFrame()
+ ? nsLayoutUtils::GetFloatFromPlaceholder(aFrame)
+ : nullptr;
+ while (outOfFlowFrame && outOfFlowFrame->GetParent() == this) {
+ RemoveFloat(outOfFlowFrame);
+ // Remove the IS_PUSHED_FLOAT bit, in case |outOfFlowFrame| came from
+ // the PushedFloats list.
+ outOfFlowFrame->RemoveStateBits(NS_FRAME_IS_PUSHED_FLOAT);
+ aList.AppendFrame(nullptr, outOfFlowFrame);
+ outOfFlowFrame = outOfFlowFrame->GetNextInFlow();
+ // FIXME: By not pulling floats whose parent is one of our
+ // later siblings, are we risking the pushed floats getting
+ // out-of-order?
+ // XXXmats nsInlineFrame's lazy reparenting depends on NOT doing that.
+ }
+
+ DoCollectFloats(aFrame->PrincipalChildList().FirstChild(), aList, true);
+ DoCollectFloats(
+ aFrame->GetChildList(FrameChildListID::Overflow).FirstChild(), aList,
+ true);
+ }
+ if (!aCollectSiblings) {
+ break;
+ }
+ aFrame = aFrame->GetNextSibling();
+ }
+}
+
+void nsBlockFrame::CheckFloats(BlockReflowState& aState) {
+#ifdef DEBUG
+ // If any line is still dirty, that must mean we're going to reflow this
+ // block again soon (e.g. because we bailed out after noticing that
+ // clearance was imposed), so don't worry if the floats are out of sync.
+ bool anyLineDirty = false;
+
+ // Check that the float list is what we would have built
+ AutoTArray<nsIFrame*, 8> lineFloats;
+ for (auto& line : Lines()) {
+ if (line.HasFloats()) {
+ lineFloats.AppendElements(line.Floats());
+ }
+ if (line.IsDirty()) {
+ anyLineDirty = true;
+ }
+ }
+
+ AutoTArray<nsIFrame*, 8> storedFloats;
+ bool equal = true;
+ bool hasHiddenFloats = false;
+ uint32_t i = 0;
+ for (nsIFrame* f : mFloats) {
+ if (f->HasAnyStateBits(NS_FRAME_IS_PUSHED_FLOAT)) {
+ continue;
+ }
+ // There are chances that the float children won't be added to lines,
+ // because in nsBlockFrame::ReflowLine, it skips reflow line if the first
+ // child of the line is IsHiddenByContentVisibilityOfInFlowParentForLayout.
+ // There are also chances that the floats in line are out of date, for
+ // instance, lines could reflow if
+ // PresShell::IsForcingLayoutForHiddenContent, and after forcingLayout is
+ // off, the reflow of lines could be skipped, but the floats are still in
+ // there. Here we can't know whether the floats hidden by c-v are included
+ // in the lines or not. So we use hasHiddenFloats to skip the float length
+ // checking.
+ if (!hasHiddenFloats &&
+ f->IsHiddenByContentVisibilityOfInFlowParentForLayout()) {
+ hasHiddenFloats = true;
+ }
+ storedFloats.AppendElement(f);
+ if (i < lineFloats.Length() && lineFloats.ElementAt(i) != f) {
+ equal = false;
+ }
+ ++i;
+ }
+
+ if ((!equal || lineFloats.Length() != storedFloats.Length()) &&
+ !anyLineDirty && !hasHiddenFloats) {
+ NS_ERROR(
+ "nsBlockFrame::CheckFloats: Explicit float list is out of sync with "
+ "float cache");
+# if defined(DEBUG_roc)
+ nsIFrame::RootFrameList(PresContext(), stdout, 0);
+ for (i = 0; i < lineFloats.Length(); ++i) {
+ printf("Line float: %p\n", lineFloats.ElementAt(i));
+ }
+ for (i = 0; i < storedFloats.Length(); ++i) {
+ printf("Stored float: %p\n", storedFloats.ElementAt(i));
+ }
+# endif
+ }
+#endif
+
+ const nsFrameList* oofs = GetOverflowOutOfFlows();
+ if (oofs && oofs->NotEmpty()) {
+ // Floats that were pushed should be removed from our float
+ // manager. Otherwise the float manager's YMost or XMost might
+ // be larger than necessary, causing this block to get an
+ // incorrect desired height (or width). Some of these floats
+ // may not actually have been added to the float manager because
+ // they weren't reflowed before being pushed; that's OK,
+ // RemoveRegions will ignore them. It is safe to do this here
+ // because we know from here on the float manager will only be
+ // used for its XMost and YMost, not to place new floats and
+ // lines.
+ aState.FloatManager()->RemoveTrailingRegions(oofs->FirstChild());
+ }
+}
+
+void nsBlockFrame::IsMarginRoot(bool* aBStartMarginRoot,
+ bool* aBEndMarginRoot) {
+ nsIFrame* parent = GetParent();
+ if (!HasAnyStateBits(NS_BLOCK_BFC_STATE_BITS)) {
+ if (!parent || parent->IsFloatContainingBlock()) {
+ *aBStartMarginRoot = false;
+ *aBEndMarginRoot = false;
+ return;
+ }
+ }
+
+ if (parent && parent->IsColumnSetFrame()) {
+ // The first column is a start margin root and the last column is an end
+ // margin root. (If the column-set is split by a column-span:all box then
+ // the first and last column in each column-set fragment are margin roots.)
+ *aBStartMarginRoot = GetPrevInFlow() == nullptr;
+ *aBEndMarginRoot = GetNextInFlow() == nullptr;
+ return;
+ }
+
+ *aBStartMarginRoot = true;
+ *aBEndMarginRoot = true;
+}
+
+/* static */
+bool nsBlockFrame::BlockNeedsFloatManager(nsIFrame* aBlock) {
+ MOZ_ASSERT(aBlock, "Must have a frame");
+ NS_ASSERTION(aBlock->IsBlockFrameOrSubclass(), "aBlock must be a block");
+
+ nsIFrame* parent = aBlock->GetParent();
+ return aBlock->HasAnyStateBits(NS_BLOCK_BFC_STATE_BITS) ||
+ (parent && !parent->IsFloatContainingBlock());
+}
+
+/* static */
+bool nsBlockFrame::BlockCanIntersectFloats(nsIFrame* aFrame) {
+ return aFrame->IsBlockFrameOrSubclass() && !aFrame->IsReplaced() &&
+ !aFrame->HasAnyStateBits(NS_BLOCK_BFC_STATE_BITS);
+}
+
+// Note that this width can vary based on the vertical position.
+// However, the cases where it varies are the cases where the width fits
+// in the available space given, which means that variation shouldn't
+// matter.
+/* static */
+nsBlockFrame::FloatAvoidingISizeToClear nsBlockFrame::ISizeToClearPastFloats(
+ const BlockReflowState& aState, const LogicalRect& aFloatAvailableSpace,
+ nsIFrame* aFloatAvoidingBlock) {
+ nscoord inlineStartOffset, inlineEndOffset;
+ WritingMode wm = aState.mReflowInput.GetWritingMode();
+
+ FloatAvoidingISizeToClear result;
+ aState.ComputeFloatAvoidingOffsets(aFloatAvoidingBlock, aFloatAvailableSpace,
+ inlineStartOffset, inlineEndOffset);
+ nscoord availISize =
+ aState.mContentArea.ISize(wm) - inlineStartOffset - inlineEndOffset;
+
+ // We actually don't want the min width here; see bug 427782; we only
+ // want to displace if the width won't compute to a value small enough
+ // to fit.
+ // All we really need here is the result of ComputeSize, and we
+ // could *almost* get that from an SizeComputationInput, except for the
+ // last argument.
+ WritingMode frWM = aFloatAvoidingBlock->GetWritingMode();
+ LogicalSize availSpace =
+ LogicalSize(wm, availISize, NS_UNCONSTRAINEDSIZE).ConvertTo(frWM, wm);
+ ReflowInput reflowInput(aState.mPresContext, aState.mReflowInput,
+ aFloatAvoidingBlock, availSpace);
+ result.borderBoxISize =
+ reflowInput.ComputedSizeWithBorderPadding(wm).ISize(wm);
+
+ // Use the margins from sizingInput rather than reflowInput so that
+ // they aren't reduced by ignoring margins in overconstrained cases.
+ SizeComputationInput sizingInput(aFloatAvoidingBlock,
+ aState.mReflowInput.mRenderingContext, wm,
+ aState.mContentArea.ISize(wm));
+ const LogicalMargin computedMargin = sizingInput.ComputedLogicalMargin(wm);
+
+ nscoord marginISize = computedMargin.IStartEnd(wm);
+ const auto& iSize = reflowInput.mStylePosition->ISize(wm);
+ if (marginISize < 0 && (iSize.IsAuto() || iSize.IsMozAvailable())) {
+ // If we get here, floatAvoidingBlock has a negative amount of inline-axis
+ // margin and an 'auto' (or ~equivalently, -moz-available) inline
+ // size. Under these circumstances, we use the margin to establish a
+ // (positive) minimum size for the border-box, in order to satisfy the
+ // equation in CSS2 10.3.3. That equation essentially simplifies to the
+ // following:
+ //
+ // iSize of margins + iSize of borderBox = iSize of containingBlock
+ //
+ // ...where "iSize of borderBox" is the sum of floatAvoidingBlock's
+ // inline-axis components of border, padding, and {width,height}.
+ //
+ // Right now, in the above equation, "iSize of margins" is the only term
+ // that we know for sure. (And we also know that it's negative, since we
+ // got here.) The other terms are as-yet unresolved, since the frame has an
+ // 'auto' iSize, and since we aren't yet sure if we'll clear this frame
+ // beyond floats or place it alongside them.
+ //
+ // However: we *do* know that the equation's "iSize of containingBlock"
+ // term *must* be non-negative, since boxes' widths and heights generally
+ // can't be negative in CSS. To satisfy that requirement, we can then
+ // infer that the equation's "iSize of borderBox" term *must* be large
+ // enough to cancel out the (known-to-be-negative) "iSize of margins"
+ // term. Therefore, marginISize value (negated to make it positive)
+ // establishes a lower-bound for how much inline-axis space our border-box
+ // will really require in order to fit alongside any floats.
+ //
+ // XXXdholbert This explanation is admittedly a bit hand-wavy and may not
+ // precisely match what any particular spec requires. It's the best
+ // reasoning I could come up with to explain engines' behavior. Also, our
+ // behavior with -moz-available doesn't seem particularly correct here, per
+ // bug 1767217, though that's probably due to a bug elsewhere in our float
+ // handling code...
+ result.borderBoxISize = std::max(result.borderBoxISize, -marginISize);
+ }
+
+ result.marginIStart = computedMargin.IStart(wm);
+ return result;
+}
+
+/* static */
+nsBlockFrame* nsBlockFrame::GetNearestAncestorBlock(nsIFrame* aCandidate) {
+ nsBlockFrame* block = nullptr;
+ while (aCandidate) {
+ block = do_QueryFrame(aCandidate);
+ if (block) {
+ // yay, candidate is a block!
+ return block;
+ }
+ // Not a block. Check its parent next.
+ aCandidate = aCandidate->GetParent();
+ }
+ MOZ_ASSERT_UNREACHABLE("Fell off frame tree looking for ancestor block!");
+ return nullptr;
+}
+
+nscoord nsBlockFrame::ComputeFinalBSize(BlockReflowState& aState,
+ nscoord aBEndEdgeOfChildren) {
+ const WritingMode wm = aState.mReflowInput.GetWritingMode();
+
+ const nscoord effectiveContentBoxBSize =
+ GetEffectiveComputedBSize(aState.mReflowInput, aState.mConsumedBSize);
+ const nscoord blockStartBP = aState.BorderPadding().BStart(wm);
+ const nscoord blockEndBP = aState.BorderPadding().BEnd(wm);
+
+ NS_ASSERTION(
+ !IsTrueOverflowContainer() || (effectiveContentBoxBSize == 0 &&
+ blockStartBP == 0 && blockEndBP == 0),
+ "An overflow container's effective content-box block-size, block-start "
+ "BP, and block-end BP should all be zero!");
+
+ const nscoord effectiveContentBoxBSizeWithBStartBP =
+ NSCoordSaturatingAdd(blockStartBP, effectiveContentBoxBSize);
+ const nscoord effectiveBorderBoxBSize =
+ NSCoordSaturatingAdd(effectiveContentBoxBSizeWithBStartBP, blockEndBP);
+
+ if (HasColumnSpanSiblings()) {
+ MOZ_ASSERT(LastInFlow()->GetNextContinuation(),
+ "Frame constructor should've created column-span siblings!");
+
+ // If a block is split by any column-spans, we calculate the final
+ // block-size by shrinkwrapping our children's block-size for all the
+ // fragments except for those after the final column-span, but we should
+ // take no more than our effective border-box block-size. If there's any
+ // leftover block-size, our next continuations will take up rest.
+ //
+ // We don't need to adjust aBri.mReflowStatus because our children's status
+ // is the same as ours.
+ return std::min(effectiveBorderBoxBSize, aBEndEdgeOfChildren);
+ }
+
+ const nscoord availBSize = aState.mReflowInput.AvailableBSize();
+ if (availBSize == NS_UNCONSTRAINEDSIZE) {
+ return effectiveBorderBoxBSize;
+ }
+
+ // Save our children's reflow status.
+ const bool isChildStatusComplete = aState.mReflowStatus.IsComplete();
+ if (isChildStatusComplete && effectiveContentBoxBSize > 0 &&
+ effectiveBorderBoxBSize > availBSize &&
+ ShouldAvoidBreakInside(aState.mReflowInput)) {
+ aState.mReflowStatus.SetInlineLineBreakBeforeAndReset();
+ return effectiveBorderBoxBSize;
+ }
+
+ const bool isBDBClone =
+ aState.mReflowInput.mStyleBorder->mBoxDecorationBreak ==
+ StyleBoxDecorationBreak::Clone;
+
+ // The maximum value our content-box block-size can take within the given
+ // available block-size.
+ const nscoord maxContentBoxBSize = aState.ContentBSize();
+
+ // The block-end edge of our content-box (relative to this frame's origin) if
+ // we consumed the maximum block-size available to us (maxContentBoxBSize).
+ const nscoord maxContentBoxBEnd = aState.ContentBEnd();
+
+ // These variables are uninitialized intentionally so that the compiler can
+ // check they are assigned in every if-else branch below.
+ nscoord finalContentBoxBSizeWithBStartBP;
+ bool isOurStatusComplete;
+
+ if (effectiveBorderBoxBSize <= availBSize) {
+ // Our effective border-box block-size can fit in the available block-size,
+ // so we are complete.
+ finalContentBoxBSizeWithBStartBP = effectiveContentBoxBSizeWithBStartBP;
+ isOurStatusComplete = true;
+ } else if (effectiveContentBoxBSizeWithBStartBP <= maxContentBoxBEnd) {
+ // Note: The following assertion should generally hold because, for
+ // box-decoration-break:clone, this "else if" branch is mathematically
+ // equivalent to the initial "if".
+ NS_ASSERTION(!isBDBClone,
+ "This else-if branch is handling a situation that's specific "
+ "to box-decoration-break:slice, i.e. a case when we can skip "
+ "our block-end border and padding!");
+
+ // Our effective content-box block-size plus the block-start border and
+ // padding can fit in the available block-size, but it cannot fit after
+ // adding the block-end border and padding. Thus, we need a continuation
+ // (unless we already weren't asking for any block-size, in which case we
+ // stay complete to avoid looping forever).
+ finalContentBoxBSizeWithBStartBP = effectiveContentBoxBSizeWithBStartBP;
+ isOurStatusComplete = effectiveContentBoxBSize == 0;
+ } else {
+ // We aren't going to be able to fit our content-box in the space available
+ // to it, which means we'll probably call ourselves incomplete to request a
+ // continuation. But before making that decision, we check for certain
+ // conditions which would force us to overflow beyond the available space --
+ // these might result in us actually being complete if we're forced to
+ // overflow far enough.
+ if (MOZ_UNLIKELY(aState.mReflowInput.mFlags.mIsTopOfPage && isBDBClone &&
+ maxContentBoxBSize <= 0 &&
+ aBEndEdgeOfChildren == blockStartBP)) {
+ // In this rare case, we are at the top of page/column, we have
+ // box-decoration-break:clone and zero available block-size for our
+ // content-box (e.g. our own block-start border and padding already exceed
+ // the available block-size), and we didn't lay out any child to consume
+ // our content-box block-size. To ensure we make progress (avoid looping
+ // forever), use 1px as our content-box block-size regardless of our
+ // effective content-box block-size, in the spirit of
+ // https://drafts.csswg.org/css-break/#breaking-rules.
+ finalContentBoxBSizeWithBStartBP = blockStartBP + AppUnitsPerCSSPixel();
+ isOurStatusComplete = effectiveContentBoxBSize <= AppUnitsPerCSSPixel();
+ } else if (aBEndEdgeOfChildren > maxContentBoxBEnd) {
+ // We have a unbreakable child whose block-end edge exceeds the available
+ // block-size for children.
+ if (aBEndEdgeOfChildren >= effectiveContentBoxBSizeWithBStartBP) {
+ // The unbreakable child's block-end edge forces us to consume all of
+ // our effective content-box block-size.
+ finalContentBoxBSizeWithBStartBP = effectiveContentBoxBSizeWithBStartBP;
+
+ // Even though we've consumed all of our effective content-box
+ // block-size, we may still need to report an incomplete status in order
+ // to get another continuation, which will be responsible for laying out
+ // & drawing our block-end border & padding. But if we have no such
+ // border & padding, or if we're forced to apply that border & padding
+ // on this frame due to box-decoration-break:clone, then we don't need
+ // to bother with that additional continuation.
+ isOurStatusComplete = (isBDBClone || blockEndBP == 0);
+ } else {
+ // The unbreakable child's block-end edge doesn't force us to consume
+ // all of our effective content-box block-size.
+ finalContentBoxBSizeWithBStartBP = aBEndEdgeOfChildren;
+ isOurStatusComplete = false;
+ }
+ } else {
+ // The children's block-end edge can fit in the content-box space that we
+ // have available for it. Consume all the space that is available so that
+ // our inline-start/inline-end borders extend all the way to the block-end
+ // edge of column/page.
+ finalContentBoxBSizeWithBStartBP = maxContentBoxBEnd;
+ isOurStatusComplete = false;
+ }
+ }
+
+ nscoord finalBorderBoxBSize = finalContentBoxBSizeWithBStartBP;
+ if (isOurStatusComplete) {
+ finalBorderBoxBSize = NSCoordSaturatingAdd(finalBorderBoxBSize, blockEndBP);
+ if (isChildStatusComplete) {
+ // We want to use children's reflow status as ours, which can be overflow
+ // incomplete. Suppress the urge to call aBri.mReflowStatus.Reset() here.
+ } else {
+ aState.mReflowStatus.SetOverflowIncomplete();
+ }
+ } else {
+ NS_ASSERTION(!IsTrueOverflowContainer(),
+ "An overflow container should always be complete because of "
+ "its zero border-box block-size!");
+ if (isBDBClone) {
+ finalBorderBoxBSize =
+ NSCoordSaturatingAdd(finalBorderBoxBSize, blockEndBP);
+ }
+ aState.mReflowStatus.SetIncomplete();
+ if (!GetNextInFlow()) {
+ aState.mReflowStatus.SetNextInFlowNeedsReflow();
+ }
+ }
+
+ return finalBorderBoxBSize;
+}
+
+nsresult nsBlockFrame::ResolveBidi() {
+ NS_ASSERTION(!GetPrevInFlow(),
+ "ResolveBidi called on non-first continuation");
+ MOZ_ASSERT(PresContext()->BidiEnabled());
+ return nsBidiPresUtils::Resolve(this);
+}
+
+void nsBlockFrame::UpdatePseudoElementStyles(ServoRestyleState& aRestyleState) {
+ // first-letter needs to be updated before first-line, because first-line can
+ // change the style of the first-letter.
+ if (HasFirstLetterChild()) {
+ UpdateFirstLetterStyle(aRestyleState);
+ }
+
+ if (nsIFrame* firstLineFrame = GetFirstLineFrame()) {
+ nsIFrame* styleParent = CorrectStyleParentFrame(firstLineFrame->GetParent(),
+ PseudoStyleType::firstLine);
+
+ ComputedStyle* parentStyle = styleParent->Style();
+ RefPtr<ComputedStyle> firstLineStyle =
+ aRestyleState.StyleSet().ResolvePseudoElementStyle(
+ *mContent->AsElement(), PseudoStyleType::firstLine, nullptr,
+ parentStyle);
+
+ // FIXME(bz): Can we make first-line continuations be non-inheriting anon
+ // boxes?
+ RefPtr<ComputedStyle> continuationStyle =
+ aRestyleState.StyleSet().ResolveInheritingAnonymousBoxStyle(
+ PseudoStyleType::mozLineFrame, parentStyle);
+
+ UpdateStyleOfOwnedChildFrame(firstLineFrame, firstLineStyle, aRestyleState,
+ Some(continuationStyle.get()));
+
+ // We also want to update the styles of the first-line's descendants. We
+ // don't need to compute a changehint for this, though, since any changes to
+ // them are handled by the first-line anyway.
+ RestyleManager* manager = PresContext()->RestyleManager();
+ for (nsIFrame* kid : firstLineFrame->PrincipalChildList()) {
+ manager->ReparentComputedStyleForFirstLine(kid);
+ }
+ }
+}
+
+nsIFrame* nsBlockFrame::GetFirstLetter() const {
+ if (!HasAnyStateBits(NS_BLOCK_HAS_FIRST_LETTER_STYLE)) {
+ // Certainly no first-letter frame.
+ return nullptr;
+ }
+
+ return GetProperty(FirstLetterProperty());
+}
+
+nsIFrame* nsBlockFrame::GetFirstLineFrame() const {
+ nsIFrame* maybeFirstLine = PrincipalChildList().FirstChild();
+ if (maybeFirstLine && maybeFirstLine->IsLineFrame()) {
+ return maybeFirstLine;
+ }
+
+ return nullptr;
+}
+
+#ifdef DEBUG
+void nsBlockFrame::VerifyLines(bool aFinalCheckOK) {
+ if (!gVerifyLines) {
+ return;
+ }
+ if (mLines.empty()) {
+ return;
+ }
+
+ nsLineBox* cursor = GetLineCursorForQuery();
+
+ // Add up the counts on each line. Also validate that IsFirstLine is
+ // set properly.
+ int32_t count = 0;
+ for (const auto& line : Lines()) {
+ if (&line == cursor) {
+ cursor = nullptr;
+ }
+ if (aFinalCheckOK) {
+ MOZ_ASSERT(line.GetChildCount(), "empty line");
+ if (line.IsBlock()) {
+ NS_ASSERTION(1 == line.GetChildCount(), "bad first line");
+ }
+ }
+ count += line.GetChildCount();
+ }
+
+ // Then count the frames
+ int32_t frameCount = 0;
+ nsIFrame* frame = mLines.front()->mFirstChild;
+ while (frame) {
+ frameCount++;
+ frame = frame->GetNextSibling();
+ }
+ NS_ASSERTION(count == frameCount, "bad line list");
+
+ // Next: test that each line has right number of frames on it
+ for (LineIterator line = LinesBegin(), line_end = LinesEnd();
+ line != line_end;) {
+ count = line->GetChildCount();
+ frame = line->mFirstChild;
+ while (--count >= 0) {
+ frame = frame->GetNextSibling();
+ }
+ ++line;
+ if ((line != line_end) && (0 != line->GetChildCount())) {
+ NS_ASSERTION(frame == line->mFirstChild, "bad line list");
+ }
+ }
+
+ if (cursor) {
+ FrameLines* overflowLines = GetOverflowLines();
+ if (overflowLines) {
+ LineIterator line = overflowLines->mLines.begin();
+ LineIterator line_end = overflowLines->mLines.end();
+ for (; line != line_end; ++line) {
+ if (line == cursor) {
+ cursor = nullptr;
+ break;
+ }
+ }
+ }
+ }
+ NS_ASSERTION(!cursor, "stale LineCursorProperty");
+}
+
+void nsBlockFrame::VerifyOverflowSituation() {
+ // Overflow out-of-flows must not have a next-in-flow in mFloats or mFrames.
+ nsFrameList* oofs = GetOverflowOutOfFlows();
+ if (oofs) {
+ for (nsIFrame* f : *oofs) {
+ nsIFrame* nif = f->GetNextInFlow();
+ MOZ_ASSERT(!nif ||
+ (!mFloats.ContainsFrame(nif) && !mFrames.ContainsFrame(nif)));
+ }
+ }
+
+ // Pushed floats must not have a next-in-flow in mFloats or mFrames.
+ oofs = GetPushedFloats();
+ if (oofs) {
+ for (nsIFrame* f : *oofs) {
+ nsIFrame* nif = f->GetNextInFlow();
+ MOZ_ASSERT(!nif ||
+ (!mFloats.ContainsFrame(nif) && !mFrames.ContainsFrame(nif)));
+ }
+ }
+
+ // A child float next-in-flow's parent must be |this| or a next-in-flow of
+ // |this|. Later next-in-flows must have the same or later parents.
+ ChildListID childLists[] = {FrameChildListID::Float,
+ FrameChildListID::PushedFloats};
+ for (size_t i = 0; i < ArrayLength(childLists); ++i) {
+ const nsFrameList& children = GetChildList(childLists[i]);
+ for (nsIFrame* f : children) {
+ nsIFrame* parent = this;
+ nsIFrame* nif = f->GetNextInFlow();
+ for (; nif; nif = nif->GetNextInFlow()) {
+ bool found = false;
+ for (nsIFrame* p = parent; p; p = p->GetNextInFlow()) {
+ if (nif->GetParent() == p) {
+ parent = p;
+ found = true;
+ break;
+ }
+ }
+ MOZ_ASSERT(
+ found,
+ "next-in-flow is a child of parent earlier in the frame tree?");
+ }
+ }
+ }
+
+ nsBlockFrame* flow = static_cast<nsBlockFrame*>(FirstInFlow());
+ while (flow) {
+ FrameLines* overflowLines = flow->GetOverflowLines();
+ if (overflowLines) {
+ NS_ASSERTION(!overflowLines->mLines.empty(),
+ "should not be empty if present");
+ NS_ASSERTION(overflowLines->mLines.front()->mFirstChild,
+ "bad overflow lines");
+ NS_ASSERTION(overflowLines->mLines.front()->mFirstChild ==
+ overflowLines->mFrames.FirstChild(),
+ "bad overflow frames / lines");
+ }
+ auto checkCursor = [&](nsLineBox* cursor) -> bool {
+ if (!cursor) {
+ return true;
+ }
+ LineIterator line = flow->LinesBegin();
+ LineIterator line_end = flow->LinesEnd();
+ for (; line != line_end && line != cursor; ++line)
+ ;
+ if (line == line_end && overflowLines) {
+ line = overflowLines->mLines.begin();
+ line_end = overflowLines->mLines.end();
+ for (; line != line_end && line != cursor; ++line)
+ ;
+ }
+ return line != line_end;
+ };
+ MOZ_ASSERT(checkCursor(flow->GetLineCursorForDisplay()),
+ "stale LineCursorPropertyDisplay");
+ MOZ_ASSERT(checkCursor(flow->GetLineCursorForQuery()),
+ "stale LineCursorPropertyQuery");
+ flow = static_cast<nsBlockFrame*>(flow->GetNextInFlow());
+ }
+}
+
+int32_t nsBlockFrame::GetDepth() const {
+ int32_t depth = 0;
+ nsIFrame* parent = GetParent();
+ while (parent) {
+ parent = parent->GetParent();
+ depth++;
+ }
+ return depth;
+}
+
+already_AddRefed<ComputedStyle> nsBlockFrame::GetFirstLetterStyle(
+ nsPresContext* aPresContext) {
+ return aPresContext->StyleSet()->ProbePseudoElementStyle(
+ *mContent->AsElement(), PseudoStyleType::firstLetter, nullptr, Style());
+}
+#endif