The Tor Browser: comparison layout/generic/nsBlockReflowContext.cpp

--1:000000000000
+:630b5f6746c8
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+// vim:cindent:ts=2:et:sw=2:
+/* 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/. */
+/* class that a parent frame uses to reflow a block frame */
+#include "nsBlockReflowContext.h"
+#include "nsBlockReflowState.h"
+#include "nsFloatManager.h"
+#include "nsContainerFrame.h"
+#include "nsBlockFrame.h"
+#include "nsLineBox.h"
+#include "nsLayoutUtils.h"
+#ifdef DEBUG
+#undef  NOISY_MAX_ELEMENT_SIZE
+#undef   REALLY_NOISY_MAX_ELEMENT_SIZE
+#undef  NOISY_VERTICAL_MARGINS
+#else
+#undef  NOISY_MAX_ELEMENT_SIZE
+#undef   REALLY_NOISY_MAX_ELEMENT_SIZE
+#undef  NOISY_VERTICAL_MARGINS
+#endif
+nsBlockReflowContext::nsBlockReflowContext(nsPresContext* aPresContext,
+const nsHTMLReflowState& aParentRS)
+: mPresContext(aPresContext),
+mOuterReflowState(aParentRS),
+mMetrics(aParentRS.GetWritingMode())
+{
+}
+static nsIFrame* DescendIntoBlockLevelFrame(nsIFrame* aFrame)
+{
+nsIAtom* type = aFrame->GetType();
+if (type == nsGkAtoms::columnSetFrame)
+return DescendIntoBlockLevelFrame(aFrame->GetFirstPrincipalChild());
+return aFrame;
+}
+bool
+nsBlockReflowContext::ComputeCollapsedTopMargin(const nsHTMLReflowState& aRS,
+nsCollapsingMargin* aMargin, nsIFrame* aClearanceFrame,
+bool* aMayNeedRetry, bool* aBlockIsEmpty)
+{
+// Include frame's top margin
+aMargin->Include(aRS.ComputedPhysicalMargin().top);
+// The inclusion of the bottom margin when empty is done by the caller
+// since it doesn't need to be done by the top-level (non-recursive)
+// caller.
+#ifdef NOISY_VERTICAL_MARGINS
+nsFrame::ListTag(stdout, aRS.frame);
+printf(": %d => %d\n", aRS.ComputedPhysicalMargin().top, aMargin->get());
+#endif
+bool dirtiedLine = false;
+bool setBlockIsEmpty = false;
+// Calculate the frame's generational top-margin from its child
+// blocks. Note that if the frame has a non-zero top-border or
+// top-padding then this step is skipped because it will be a margin
+// root.  It is also skipped if the frame is a margin root for other
+// reasons.
+nsIFrame* frame = DescendIntoBlockLevelFrame(aRS.frame);
+nsPresContext* prescontext = frame->PresContext();
+nsBlockFrame* block = nullptr;
+if (0 == aRS.ComputedPhysicalBorderPadding().top) {
+block = nsLayoutUtils::GetAsBlock(frame);
+if (block) {
+bool topMarginRoot, unused;
+block->IsMarginRoot(&topMarginRoot, &unused);
+if (topMarginRoot) {
+block = nullptr;
+}
+}
+}
+// iterate not just through the lines of 'block' but also its
+// overflow lines and the normal and overflow lines of its next in
+// flows. Note that this will traverse some frames more than once:
+// for example, if A contains B and A->nextinflow contains
+// B->nextinflow, we'll traverse B->nextinflow twice. But this is
+// OK because our traversal is idempotent.
+for ( ;block; block = static_cast<nsBlockFrame*>(block->GetNextInFlow())) {
+for (int overflowLines = 0; overflowLines <= 1; ++overflowLines) {
+nsBlockFrame::line_iterator line;
+nsBlockFrame::line_iterator line_end;
+bool anyLines = true;
+if (overflowLines) {
+nsBlockFrame::FrameLines* frames = block->GetOverflowLines();
+nsLineList* lines = frames ? &frames->mLines : nullptr;
+if (!lines) {
+anyLines = false;
+} else {
+line = lines->begin();
+line_end = lines->end();
+}
+} else {
+line = block->begin_lines();
+line_end = block->end_lines();
+}
+for (; anyLines && line != line_end; ++line) {
+if (!aClearanceFrame && line->HasClearance()) {
+// If we don't have a clearance frame, then we're computing
+// the collapsed margin in the first pass, assuming that all
+// lines have no clearance. So clear their clearance flags.
+line->ClearHasClearance();
+line->MarkDirty();
+dirtiedLine = true;
+}
+bool isEmpty;
+if (line->IsInline()) {
+isEmpty = line->IsEmpty();
+} else {
+nsIFrame* kid = line->mFirstChild;
+if (kid == aClearanceFrame) {
+line->SetHasClearance();
+line->MarkDirty();
+dirtiedLine = true;
+goto done;
+}
+// Here is where we recur. Now that we have determined that a
+// generational collapse is required we need to compute the
+// child blocks margin and so in so that we can look into
+// it. For its margins to be computed we need to have a reflow
+// state for it.
+// We may have to construct an extra reflow state here if
+// we drilled down through a block wrapper. At the moment
+// we can only drill down one level so we only have to support
+// one extra reflow state.
+const nsHTMLReflowState* outerReflowState = &aRS;
+if (frame != aRS.frame) {
+NS_ASSERTION(frame->GetParent() == aRS.frame,
+"Can only drill through one level of block wrapper");
+nsSize availSpace(aRS.ComputedWidth(), aRS.ComputedHeight());
+outerReflowState = new nsHTMLReflowState(prescontext,
+aRS, frame, availSpace);
+}
+{
+nsSize availSpace(outerReflowState->ComputedWidth(),
+outerReflowState->ComputedHeight());
+nsHTMLReflowState innerReflowState(prescontext,
+*outerReflowState, kid,
+availSpace);
+// Record that we're being optimistic by assuming the kid
+// has no clearance
+if (kid->StyleDisplay()->mBreakType != NS_STYLE_CLEAR_NONE) {
+*aMayNeedRetry = true;
+}
+if (ComputeCollapsedTopMargin(innerReflowState, aMargin, aClearanceFrame, aMayNeedRetry, &isEmpty)) {
+line->MarkDirty();
+dirtiedLine = true;
+}
+if (isEmpty)
+aMargin->Include(innerReflowState.ComputedPhysicalMargin().bottom);
+}
+if (outerReflowState != &aRS) {
+delete const_cast<nsHTMLReflowState*>(outerReflowState);
+}
+}
+if (!isEmpty) {
+if (!setBlockIsEmpty && aBlockIsEmpty) {
+setBlockIsEmpty = true;
+*aBlockIsEmpty = false;
+}
+goto done;
+}
+}
+if (!setBlockIsEmpty && aBlockIsEmpty) {
+// The first time we reach here is when this is the first block
+// and we have processed all its normal lines.
+setBlockIsEmpty = true;
+// All lines are empty, or we wouldn't be here!
+*aBlockIsEmpty = aRS.frame->IsSelfEmpty();
+}
+}
+}
+done:
+if (!setBlockIsEmpty && aBlockIsEmpty) {
+*aBlockIsEmpty = aRS.frame->IsEmpty();
+}
+#ifdef NOISY_VERTICAL_MARGINS
+nsFrame::ListTag(stdout, aRS.frame);
+printf(": => %d\n", aMargin->get());
+#endif
+return dirtiedLine;
+}
+nsresult
+nsBlockReflowContext::ReflowBlock(const nsRect&       aSpace,
+bool                aApplyTopMargin,
+nsCollapsingMargin& aPrevMargin,
+nscoord             aClearance,
+bool                aIsAdjacentWithTop,
+nsLineBox*          aLine,
+nsHTMLReflowState&  aFrameRS,
+nsReflowStatus&     aFrameReflowStatus,
+nsBlockReflowState& aState)
+{
+nsresult rv = NS_OK;
+mFrame = aFrameRS.frame;
+mSpace = aSpace;
+if (!aIsAdjacentWithTop) {
+aFrameRS.mFlags.mIsTopOfPage = false;  // make sure this is cleared
+}
+if (aApplyTopMargin) {
+mTopMargin = aPrevMargin;
+#ifdef NOISY_VERTICAL_MARGINS
+nsFrame::ListTag(stdout, mOuterReflowState.frame);
+printf(": reflowing ");
+nsFrame::ListTag(stdout, mFrame);
+printf(" margin => %d, clearance => %d\n", mTopMargin.get(), aClearance);
+#endif
+// Adjust the available height if its constrained so that the
+// child frame doesn't think it can reflow into its margin area.
+if (NS_UNCONSTRAINEDSIZE != aFrameRS.AvailableHeight()) {
+aFrameRS.AvailableHeight() -= mTopMargin.get() + aClearance;
+}
+}
+nscoord tx = 0, ty = 0;
+// The values of x and y do not matter for floats, so don't bother calculating
+// them. Floats are guaranteed to have their own float manager, so tx and ty
+// don't matter.  mX and mY don't matter becacuse they are only used in
+// PlaceBlock, which is not used for floats.
+if (aLine) {
+// Compute x/y coordinate where reflow will begin. Use the rules
+// from 10.3.3 to determine what to apply. At this point in the
+// reflow auto left/right margins will have a zero value.
+mX = tx = mSpace.x + aFrameRS.ComputedPhysicalMargin().left;
+mY = ty = mSpace.y + mTopMargin.get() + aClearance;
+if ((mFrame->GetStateBits() & NS_BLOCK_FLOAT_MGR) == 0)
+aFrameRS.mBlockDelta =
+mOuterReflowState.mBlockDelta + ty - aLine->BStart();
+}
+// Let frame know that we are reflowing it
+mFrame->WillReflow(mPresContext);
+#ifdef DEBUG
+mMetrics.Width() = nscoord(0xdeadbeef);
+mMetrics.Height() = nscoord(0xdeadbeef);
+#endif
+mOuterReflowState.mFloatManager->Translate(tx, ty);
+rv = mFrame->Reflow(mPresContext, mMetrics, aFrameRS, aFrameReflowStatus);
+mOuterReflowState.mFloatManager->Translate(-tx, -ty);
+#ifdef DEBUG
+if (!NS_INLINE_IS_BREAK_BEFORE(aFrameReflowStatus)) {
+if (CRAZY_SIZE(mMetrics.Width()) || CRAZY_SIZE(mMetrics.Height())) {
+printf("nsBlockReflowContext: ");
+nsFrame::ListTag(stdout, mFrame);
+printf(" metrics=%d,%d!\n", mMetrics.Width(), mMetrics.Height());
+}
+if ((mMetrics.Width() == nscoord(0xdeadbeef)) ||
+(mMetrics.Height() == nscoord(0xdeadbeef))) {
+printf("nsBlockReflowContext: ");
+nsFrame::ListTag(stdout, mFrame);
+printf(" didn't set w/h %d,%d!\n", mMetrics.Width(), mMetrics.Height());
+}
+}
+#endif
+if (!mFrame->HasOverflowAreas()) {
+mMetrics.SetOverflowAreasToDesiredBounds();
+}
+if (!NS_INLINE_IS_BREAK_BEFORE(aFrameReflowStatus) ||
+(mFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW)) {
+// If frame is complete and has a next-in-flow, we need to delete
+// them now. Do not do this when a break-before is signaled because
+// the frame is going to get reflowed again (and may end up wanting
+// a next-in-flow where it ends up), unless it is an out of flow frame.
+if (NS_FRAME_IS_FULLY_COMPLETE(aFrameReflowStatus)) {
+nsIFrame* kidNextInFlow = mFrame->GetNextInFlow();
+if (nullptr != kidNextInFlow) {
+// Remove all of the childs next-in-flows. Make sure that we ask
+// the right parent to do the removal (it's possible that the
+// parent is not this because we are executing pullup code).
+// Floats will eventually be removed via nsBlockFrame::RemoveFloat
+// which detaches the placeholder from the float.
+nsOverflowContinuationTracker::AutoFinish fini(aState.mOverflowTracker, mFrame);
+static_cast<nsContainerFrame*>(kidNextInFlow->GetParent())
+->DeleteNextInFlowChild(kidNextInFlow, true);
+}
+}
+}
+return rv;
+}
+/**
+* Attempt to place the block frame within the available space.  If
+* it fits, apply horizontal positioning (CSS 10.3.3), collapse
+* margins (CSS2 8.3.1). Also apply relative positioning.
+*/
+bool
+nsBlockReflowContext::PlaceBlock(const nsHTMLReflowState&  aReflowState,
+bool                      aForceFit,
+nsLineBox*                aLine,
+nsCollapsingMargin&       aBottomMarginResult,
+nsOverflowAreas&          aOverflowAreas,
+nsReflowStatus            aReflowStatus,
+nscoord                   aContainerWidth)
+{
+// Compute collapsed bottom margin value.
+if (NS_FRAME_IS_COMPLETE(aReflowStatus)) {
+aBottomMarginResult = mMetrics.mCarriedOutBottomMargin;
+aBottomMarginResult.Include(aReflowState.ComputedPhysicalMargin().bottom);
+} else {
+// The used bottom-margin is set to zero above a break.
+aBottomMarginResult.Zero();
+}
+nsPoint position(mX, mY);
+nscoord backupContainingBlockAdvance = 0;
+// Check whether the block's bottom margin collapses with its top
+// margin. See CSS 2.1 section 8.3.1; those rules seem to match
+// nsBlockFrame::IsEmpty(). Any such block must have zero height so
+// check that first. Note that a block can have clearance and still
+// have adjoining top/bottom margins, because the clearance goes
+// above the top margin.
+// Mark the frame as non-dirty; it has been reflowed (or we wouldn't
+// be here), and we don't want to assert in CachedIsEmpty()
+mFrame->RemoveStateBits(NS_FRAME_IS_DIRTY);
+bool empty = 0 == mMetrics.Height() && aLine->CachedIsEmpty();
+if (empty) {
+// Collapse the bottom margin with the top margin that was already
+// applied.
+aBottomMarginResult.Include(mTopMargin);
+#ifdef NOISY_VERTICAL_MARGINS
+printf("  ");
+nsFrame::ListTag(stdout, mOuterReflowState.frame);
+printf(": ");
+nsFrame::ListTag(stdout, mFrame);
+printf(" -- collapsing top & bottom margin together; y=%d spaceY=%d\n",
+position.y, mSpace.y);
+#endif
+// Section 8.3.1 of CSS 2.1 says that blocks with adjoining
+// top/bottom margins whose top margin collapses with their
+// parent's top margin should have their top border-edge at the
+// top border-edge of their parent. We actually don't have to do
+// anything special to make this happen. In that situation,
+// nsBlockFrame::ShouldApplyTopMargin will have returned false,
+// and mTopMargin and aClearance will have been zero in
+// ReflowBlock.
+// If we did apply our top margin, but now we're collapsing it
+// into the bottom margin, we need to back up the containing
+// block's y-advance by our top margin so that it doesn't get
+// counted twice. Note that here we're allowing the line's bounds
+// to become different from the block's position; we do this
+// because the containing block will place the next line at the
+// line's YMost, and it must place the next line at a different
+// point from where this empty block will be.
+backupContainingBlockAdvance = mTopMargin.get();
+}
+// See if the frame fit. If it's the first frame or empty then it
+// always fits. If the height is unconstrained then it always fits,
+// even if there's some sort of integer overflow that makes y +
+// mMetrics.Height() appear to go beyond the available height.
+if (!empty && !aForceFit && mSpace.height != NS_UNCONSTRAINEDSIZE) {
+nscoord yMost = position.y - backupContainingBlockAdvance + mMetrics.Height();
+if (yMost > mSpace.YMost()) {
+// didn't fit, we must acquit.
+mFrame->DidReflow(mPresContext, &aReflowState, nsDidReflowStatus::FINISHED);
+return false;
+}
+}
+aLine->SetBounds(aReflowState.GetWritingMode(),
+nsRect(position.x,
+position.y - backupContainingBlockAdvance,
+mMetrics.Width(),
+mMetrics.Height()),
+aContainerWidth);
+aReflowState.ApplyRelativePositioning(&position);
+// Now place the frame and complete the reflow process
+nsContainerFrame::FinishReflowChild(mFrame, mPresContext, mMetrics,
+&aReflowState, position.x, position.y, 0);
+aOverflowAreas = mMetrics.mOverflowAreas + position;
+return true;
+}

The Tor Browser / file comparison

comparison: layout/generic/nsBlockReflowContext.cpp

layout/generic/nsBlockReflowContext.cpp