Add m-esr52 at 52.6.0

1 files changed, 464 insertions, 0 deletions

diff --git a/layout/generic/nsBlockReflowContext.cpp b/layout/generic/nsBlockReflowContext.cpp
new file mode 100644
index 000000000..3be74c929
--- /dev/null
+++ b/layout/generic/nsBlockReflowContext.cpp
@@ -0,0 +1,464 @@
+/* -*- 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 "BlockReflowInput.h"
+#include "nsFloatManager.h"
+#include "nsColumnSetFrame.h"
+#include "nsContainerFrame.h"
+#include "nsBlockFrame.h"
+#include "nsLineBox.h"
+#include "nsLayoutUtils.h"
+
+using namespace mozilla;
+
+#ifdef DEBUG
+#undef  NOISY_MAX_ELEMENT_SIZE
+#undef   REALLY_NOISY_MAX_ELEMENT_SIZE
+#undef  NOISY_BLOCK_DIR_MARGINS
+#else
+#undef  NOISY_MAX_ELEMENT_SIZE
+#undef   REALLY_NOISY_MAX_ELEMENT_SIZE
+#undef  NOISY_BLOCK_DIR_MARGINS
+#endif
+
+nsBlockReflowContext::nsBlockReflowContext(nsPresContext* aPresContext,
+                                           const ReflowInput& aParentRS)
+  : mPresContext(aPresContext),
+    mOuterReflowInput(aParentRS),
+    mSpace(aParentRS.GetWritingMode()),
+    mMetrics(aParentRS)
+{
+}
+
+static nsIFrame* DescendIntoBlockLevelFrame(nsIFrame* aFrame)
+{
+  nsIAtom* type = aFrame->GetType();
+  if (type == nsGkAtoms::columnSetFrame) {
+    static_cast<nsColumnSetFrame*>(aFrame)->DrainOverflowColumns();
+    nsIFrame* child = aFrame->PrincipalChildList().FirstChild();
+    if (child) {
+      return DescendIntoBlockLevelFrame(child);
+    }
+  }
+  return aFrame;
+}
+
+bool
+nsBlockReflowContext::ComputeCollapsedBStartMargin(const ReflowInput& aRI,
+                                                   nsCollapsingMargin* aMargin,
+                                                   nsIFrame* aClearanceFrame,
+                                                   bool* aMayNeedRetry,
+                                                   bool* aBlockIsEmpty)
+{
+  WritingMode wm = aRI.GetWritingMode();
+  WritingMode parentWM = mMetrics.GetWritingMode();
+
+  // Include block-start element of frame's margin
+  aMargin->Include(aRI.ComputedLogicalMargin().ConvertTo(parentWM, wm).BStart(parentWM));
+
+  // The inclusion of the block-end 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_BLOCKDIR_MARGINS
+  nsFrame::ListTag(stdout, aRI.mFrame);
+  printf(": %d => %d\n", aRI.ComputedLogicalMargin().BStart(wm), aMargin->get());
+#endif
+
+  bool dirtiedLine = false;
+  bool setBlockIsEmpty = false;
+
+  // Calculate the frame's generational block-start-margin from its child
+  // blocks. Note that if the frame has a non-zero block-start-border or
+  // block-start-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(aRI.mFrame);
+  nsPresContext* prescontext = frame->PresContext();
+  nsBlockFrame* block = nullptr;
+  if (0 == aRI.ComputedLogicalBorderPadding().BStart(wm)) {
+    block = nsLayoutUtils::GetAsBlock(frame);
+    if (block) {
+      bool bStartMarginRoot, unused;
+      block->IsMarginRoot(&bStartMarginRoot, &unused);
+      if (bStartMarginRoot) {
+        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::LineIterator line;
+      nsBlockFrame::LineIterator 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->LinesBegin();
+        line_end = block->LinesEnd();
+      }
+      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;
+            if (!setBlockIsEmpty && aBlockIsEmpty) {
+              setBlockIsEmpty = true;
+              *aBlockIsEmpty = false;
+            }
+            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 ReflowInput* outerReflowInput = &aRI;
+          if (frame != aRI.mFrame) {
+            NS_ASSERTION(frame->GetParent() == aRI.mFrame,
+                         "Can only drill through one level of block wrapper");
+            LogicalSize availSpace = aRI.ComputedSize(frame->GetWritingMode());
+            outerReflowInput = new ReflowInput(prescontext,
+                                                     aRI, frame, availSpace);
+          }
+          {
+            LogicalSize availSpace =
+              outerReflowInput->ComputedSize(kid->GetWritingMode());
+            ReflowInput innerReflowInput(prescontext,
+                                               *outerReflowInput, kid,
+                                               availSpace);
+            // Record that we're being optimistic by assuming the kid
+            // has no clearance
+            if (kid->StyleDisplay()->mBreakType != StyleClear::None ||
+                !nsBlockFrame::BlockCanIntersectFloats(kid)) {
+              *aMayNeedRetry = true;
+            }
+            if (ComputeCollapsedBStartMargin(innerReflowInput, aMargin,
+                                             aClearanceFrame, aMayNeedRetry,
+                                             &isEmpty)) {
+              line->MarkDirty();
+              dirtiedLine = true;
+            }
+            if (isEmpty) {
+              WritingMode innerWM = innerReflowInput.GetWritingMode();
+              LogicalMargin innerMargin =
+                innerReflowInput.ComputedLogicalMargin().ConvertTo(parentWM, innerWM);
+              aMargin->Include(innerMargin.BEnd(parentWM));
+            }
+          }
+          if (outerReflowInput != &aRI) {
+            delete const_cast<ReflowInput*>(outerReflowInput);
+          }
+        }
+        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 = aRI.mFrame->IsSelfEmpty();
+      }
+    }
+  }
+  done:
+
+  if (!setBlockIsEmpty && aBlockIsEmpty) {
+    *aBlockIsEmpty = aRI.mFrame->IsEmpty();
+  }
+  
+#ifdef NOISY_BLOCKDIR_MARGINS
+  nsFrame::ListTag(stdout, aRI.mFrame);
+  printf(": => %d\n", aMargin->get());
+#endif
+
+  return dirtiedLine;
+}
+
+void
+nsBlockReflowContext::ReflowBlock(const LogicalRect&  aSpace,
+                                  bool                aApplyBStartMargin,
+                                  nsCollapsingMargin& aPrevMargin,
+                                  nscoord             aClearance,
+                                  bool                aIsAdjacentWithBStart,
+                                  nsLineBox*          aLine,
+                                  ReflowInput&  aFrameRI,
+                                  nsReflowStatus&     aFrameReflowStatus,
+                                  BlockReflowInput& aState)
+{
+  mFrame = aFrameRI.mFrame;
+  mWritingMode = aState.mReflowInput.GetWritingMode();
+  mContainerSize = aState.ContainerSize();
+  mSpace = aSpace;
+
+  if (!aIsAdjacentWithBStart) {
+    aFrameRI.mFlags.mIsTopOfPage = false;  // make sure this is cleared
+  }
+
+  if (aApplyBStartMargin) {
+    mBStartMargin = aPrevMargin;
+
+#ifdef NOISY_BLOCKDIR_MARGINS
+    nsFrame::ListTag(stdout, mOuterReflowInput.mFrame);
+    printf(": reflowing ");
+    nsFrame::ListTag(stdout, mFrame);
+    printf(" margin => %d, clearance => %d\n", mBStartMargin.get(), aClearance);
+#endif
+
+    // Adjust the available size if it's constrained so that the
+    // child frame doesn't think it can reflow into its margin area.
+    if (mWritingMode.IsOrthogonalTo(mFrame->GetWritingMode())) {
+      if (NS_UNCONSTRAINEDSIZE != aFrameRI.AvailableISize()) {
+        aFrameRI.AvailableISize() -= mBStartMargin.get() + aClearance;
+      }
+    } else {
+      if (NS_UNCONSTRAINEDSIZE != aFrameRI.AvailableBSize()) {
+        aFrameRI.AvailableBSize() -= mBStartMargin.get() + aClearance;
+      }
+    }
+  } else {
+    // nsBlockFrame::ReflowBlock might call us multiple times with
+    // *different* values of aApplyBStartMargin.
+    mBStartMargin.Zero();
+  }
+
+  nscoord tI = 0, tB = 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 tI and tB don't matter.  mICoord and mBCoord don't
+  // matter becacuse they are only used in PlaceBlock, which is not used
+  // for floats.
+  if (aLine) {
+    // Compute inline/block coordinate where reflow will begin. Use the
+    // rules from 10.3.3 to determine what to apply. At this point in the
+    // reflow auto inline-start/end margins will have a zero value.
+
+    WritingMode frameWM = aFrameRI.GetWritingMode();
+    LogicalMargin usedMargin =
+      aFrameRI.ComputedLogicalMargin().ConvertTo(mWritingMode, frameWM);
+    mICoord = mSpace.IStart(mWritingMode) + usedMargin.IStart(mWritingMode);
+    mBCoord = mSpace.BStart(mWritingMode) + mBStartMargin.get() + aClearance;
+
+    LogicalRect space(mWritingMode, mICoord, mBCoord,
+                      mSpace.ISize(mWritingMode) -
+                      usedMargin.IStartEnd(mWritingMode),
+                      mSpace.BSize(mWritingMode) -
+                      usedMargin.BStartEnd(mWritingMode));
+    tI = space.LineLeft(mWritingMode, mContainerSize);
+    tB = mBCoord;
+
+    if ((mFrame->GetStateBits() & NS_BLOCK_FLOAT_MGR) == 0)
+      aFrameRI.mBlockDelta =
+        mOuterReflowInput.mBlockDelta + mBCoord - aLine->BStart();
+  }
+
+#ifdef DEBUG
+  mMetrics.ISize(mWritingMode) = nscoord(0xdeadbeef);
+  mMetrics.BSize(mWritingMode) = nscoord(0xdeadbeef);
+#endif
+
+  mOuterReflowInput.mFloatManager->Translate(tI, tB);
+  mFrame->Reflow(mPresContext, mMetrics, aFrameRI, aFrameReflowStatus);
+  mOuterReflowInput.mFloatManager->Translate(-tI, -tB);
+
+#ifdef DEBUG
+  if (!NS_INLINE_IS_BREAK_BEFORE(aFrameReflowStatus)) {
+    if ((CRAZY_SIZE(mMetrics.ISize(mWritingMode)) ||
+         CRAZY_SIZE(mMetrics.BSize(mWritingMode))) &&
+        !mFrame->GetParent()->IsCrazySizeAssertSuppressed()) {
+      printf("nsBlockReflowContext: ");
+      nsFrame::ListTag(stdout, mFrame);
+      printf(" metrics=%d,%d!\n",
+             mMetrics.ISize(mWritingMode), mMetrics.BSize(mWritingMode));
+    }
+    if ((mMetrics.ISize(mWritingMode) == nscoord(0xdeadbeef)) ||
+        (mMetrics.BSize(mWritingMode) == nscoord(0xdeadbeef))) {
+      printf("nsBlockReflowContext: ");
+      nsFrame::ListTag(stdout, mFrame);
+      printf(" didn't set i/b %d,%d!\n",
+             mMetrics.ISize(mWritingMode), mMetrics.BSize(mWritingMode));
+    }
+  }
+#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);
+        kidNextInFlow->GetParent()->DeleteNextInFlowChild(kidNextInFlow, true);
+      }
+    }
+  }
+}
+
+/**
+ * Attempt to place the block frame within the available space.  If
+ * it fits, apply inline-dir ("horizontal") positioning (CSS 10.3.3),
+ * collapse margins (CSS2 8.3.1). Also apply relative positioning.
+ */
+bool
+nsBlockReflowContext::PlaceBlock(const ReflowInput&  aReflowInput,
+                                 bool                      aForceFit,
+                                 nsLineBox*                aLine,
+                                 nsCollapsingMargin&       aBEndMarginResult,
+                                 nsOverflowAreas&          aOverflowAreas,
+                                 nsReflowStatus            aReflowStatus)
+{
+  // Compute collapsed block-end margin value.
+  WritingMode wm = aReflowInput.GetWritingMode();
+  WritingMode parentWM = mMetrics.GetWritingMode();
+  if (NS_FRAME_IS_COMPLETE(aReflowStatus)) {
+    aBEndMarginResult = mMetrics.mCarriedOutBEndMargin;
+    aBEndMarginResult.Include(aReflowInput.ComputedLogicalMargin().
+      ConvertTo(parentWM, wm).BEnd(parentWM));
+  } else {
+    // The used block-end-margin is set to zero before a break.
+    aBEndMarginResult.Zero();
+  }
+
+  nscoord backupContainingBlockAdvance = 0;
+
+  // Check whether the block's block-end margin collapses with its block-start
+  // margin. See CSS 2.1 section 8.3.1; those rules seem to match
+  // nsBlockFrame::IsEmpty(). Any such block must have zero block-size so
+  // check that first. Note that a block can have clearance and still
+  // have adjoining block-start/end margins, because the clearance goes
+  // above the block-start 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.BSize(parentWM) && aLine->CachedIsEmpty();
+  if (empty) {
+    // Collapse the block-end margin with the block-start margin that was
+    // already applied.
+    aBEndMarginResult.Include(mBStartMargin);
+
+#ifdef NOISY_BLOCKDIR_MARGINS
+    printf("  ");
+    nsFrame::ListTag(stdout, mOuterReflowInput.mFrame);
+    printf(": ");
+    nsFrame::ListTag(stdout, mFrame);
+    printf(" -- collapsing block start & end margin together; BStart=%d spaceBStart=%d\n",
+           mBCoord, mSpace.BStart(mWritingMode));
+#endif
+    // Section 8.3.1 of CSS 2.1 says that blocks with adjoining
+    // "top/bottom" (i.e. block-start/end) 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::ShouldApplyBStartMargin will have returned false,
+    // and mBStartMargin and aClearance will have been zero in
+    // ReflowBlock.
+
+    // If we did apply our block-start margin, but now we're collapsing it
+    // into the block-end margin, we need to back up the containing
+    // block's bCoord-advance by our block-start 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 BEnd, and it must place the next line at a different
+    // point from where this empty block will be.
+    backupContainingBlockAdvance = mBStartMargin.get();
+  }
+
+  // See if the frame fit. If it's the first frame or empty then it
+  // always fits. If the block-size is unconstrained then it always fits,
+  // even if there's some sort of integer overflow that makes bCoord +
+  // mMetrics.BSize() appear to go beyond the available block size.
+  if (!empty && !aForceFit &&
+      mSpace.BSize(mWritingMode) != NS_UNCONSTRAINEDSIZE) {
+    nscoord bEnd = mBCoord -
+                   backupContainingBlockAdvance + mMetrics.BSize(mWritingMode);
+    if (bEnd > mSpace.BEnd(mWritingMode)) {
+      // didn't fit, we must acquit.
+      mFrame->DidReflow(mPresContext, &aReflowInput,
+                        nsDidReflowStatus::FINISHED);
+      return false;
+    }
+  }
+
+  aLine->SetBounds(mWritingMode,
+                   mICoord, mBCoord - backupContainingBlockAdvance,
+                   mMetrics.ISize(mWritingMode), mMetrics.BSize(mWritingMode),
+                   mContainerSize);
+
+  WritingMode frameWM = mFrame->GetWritingMode();
+  LogicalPoint logPos =
+    LogicalPoint(mWritingMode, mICoord, mBCoord).
+      ConvertTo(frameWM, mWritingMode,
+                mContainerSize - mMetrics.PhysicalSize());
+
+  // ApplyRelativePositioning in right-to-left writing modes needs to
+  // know the updated frame width
+  mFrame->SetSize(mWritingMode, mMetrics.Size(mWritingMode));
+  aReflowInput.ApplyRelativePositioning(&logPos, mContainerSize);
+
+  // Now place the frame and complete the reflow process
+  nsContainerFrame::FinishReflowChild(mFrame, mPresContext, mMetrics,
+                                      &aReflowInput, frameWM, logPos,
+                                      mContainerSize, 0);
+
+  aOverflowAreas = mMetrics.mOverflowAreas + mFrame->GetPosition();
+
+  return true;
+}