The Tor Browser / file revision

 /* -*- 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/. */

 /*

  * rendering object for CSS display:block, inline-block, and list-item

  * boxes, also used for various anonymous boxes

  */

 #include "nsBlockFrame.h"

 #include "mozilla/DebugOnly.h"

 #include "nsCOMPtr.h"

 #include "nsAbsoluteContainingBlock.h"

 #include "nsBlockReflowContext.h"

 #include "nsBlockReflowState.h"

 #include "nsBulletFrame.h"

 #include "nsLineBox.h"

 #include "nsLineLayout.h"

 #include "nsPlaceholderFrame.h"

 #include "nsStyleConsts.h"

 #include "nsFrameManager.h"

 #include "nsPresContext.h"

 #include "nsIPresShell.h"

 #include "nsStyleContext.h"

 #include "nsHTMLParts.h"

 #include "nsGkAtoms.h"

 #include "nsGenericHTMLElement.h"

 #include "nsAttrValueInlines.h"

 #include "prprf.h"

 #include "nsFloatManager.h"

 #include "prenv.h"

 #include "plstr.h"

 #include "nsError.h"

 #include "nsAutoPtr.h"

 #include "nsIScrollableFrame.h"

 #include <algorithm>

 #ifdef ACCESSIBILITY

 #include "nsIDOMHTMLDocument.h"

 #endif

 #include "nsLayoutUtils.h"

 #include "nsDisplayList.h"

 #include "nsCSSAnonBoxes.h"

 #include "nsCSSFrameConstructor.h"

 #include "nsRenderingContext.h"

 #include "TextOverflow.h"

 #include "nsIFrameInlines.h"

 #include "nsBidiPresUtils.h"

 static const int MIN_LINES_NEEDING_CURSOR = 20;

 static const char16_t kDiscCharacter = 0x2022;

 static const char16_t kCircleCharacter = 0x25e6;

 static const char16_t kSquareCharacter = 0x25aa;

 #define DISABLE_FLOAT_BREAKING_IN_COLUMNS

 using namespace mozilla;

 using namespace mozilla::css;

 using namespace mozilla::layout;

 #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 = PL_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 (PL_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

 // add in a sanity check for absurdly deep frame trees.  See bug 42138

 // can't just use IsFrameTreeTooDeep() because that method has side effects we don't want

 #define MAX_DEPTH_FOR_LIST_RENUMBERING 200  // 200 open displayable tags is pretty unrealistic

 //----------------------------------------------------------------------

 // Debugging support code

 #ifdef DEBUG

 const char* nsBlockFrame::kReflowCommandType[] = {

   "ContentChanged",

   "StyleChanged",

   "ReflowDirty",

   "Timeout",

   "UserDefined",

 };

 #endif

 #ifdef REALLY_NOISY_FIRST_LINE

 static void

 DumpStyleGeneaology(nsIFrame* aFrame, const char* gap)

 {

   fputs(gap, stdout);

   nsFrame::ListTag(stdout, aFrame);

   printf(": ");

   nsStyleContext* sc = aFrame->StyleContext();

   while (nullptr != sc) {

     nsStyleContext* psc;

     printf("%p ", sc);

     psc = sc->GetParent();

     sc = psc;

   }

   printf("\n");

 }

 #endif

 #ifdef REFLOW_STATUS_COVERAGE

 static void

 RecordReflowStatus(bool aChildIsBlock, 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 (NS_INLINE_IS_BREAK(aFrameReflowStatus)) {

     if (NS_INLINE_IS_BREAK_BEFORE(aFrameReflowStatus)) {

       newS |= 1;

     }

     else if (NS_FRAME_IS_NOT_COMPLETE(aFrameReflowStatus)) {

       newS |= 2;

     }

     else {

       newS |= 4;

     }

   }

   else if (NS_FRAME_IS_NOT_COMPLETE(aFrameReflowStatus)) {

     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

 // Destructor function for the overflowLines frame property

 static void

 DestroyOverflowLines(void* aPropertyValue)

 {

   NS_ERROR("Overflow lines should never be destroyed by the FramePropertyTable");

 }

 NS_DECLARE_FRAME_PROPERTY(OverflowLinesProperty, DestroyOverflowLines)

 NS_DECLARE_FRAME_PROPERTY_FRAMELIST(OverflowOutOfFlowsProperty)

 NS_DECLARE_FRAME_PROPERTY_FRAMELIST(PushedFloatProperty)

 NS_DECLARE_FRAME_PROPERTY_FRAMELIST(OutsideBulletProperty)

 NS_DECLARE_FRAME_PROPERTY(InsideBulletProperty, nullptr)

 NS_DECLARE_FRAME_PROPERTY(BottomEdgeOfChildrenProperty, nullptr)

 //----------------------------------------------------------------------

 nsIFrame*

 NS_NewBlockFrame(nsIPresShell* aPresShell, nsStyleContext* aContext, nsFrameState aFlags)

 {

   nsBlockFrame* it = new (aPresShell) nsBlockFrame(aContext);

   it->SetFlags(aFlags);

   return it;

 }

 NS_IMPL_FRAMEARENA_HELPERS(nsBlockFrame)

 nsBlockFrame::~nsBlockFrame()

 {

 }

 void

 nsBlockFrame::DestroyFrom(nsIFrame* aDestructRoot)

 {

   ClearLineCursor();

   DestroyAbsoluteFrames(aDestructRoot);

   mFloats.DestroyFramesFrom(aDestructRoot);

   nsPresContext* presContext = PresContext();

   nsIPresShell* shell = presContext->PresShell();

   nsLineBox::DeleteLineList(presContext, mLines, aDestructRoot,

                             &mFrames);

   FramePropertyTable* props = presContext->PropertyTable();

   if (HasPushedFloats()) {

     SafelyDestroyFrameListProp(aDestructRoot, shell, props,

                                PushedFloatProperty());

     RemoveStateBits(NS_BLOCK_HAS_PUSHED_FLOATS);

   }

   // destroy overflow lines now

   FrameLines* overflowLines = RemoveOverflowLines();

   if (overflowLines) {

     nsLineBox::DeleteLineList(presContext, overflowLines->mLines,

                               aDestructRoot, &overflowLines->mFrames);

     delete overflowLines;

   }

   if (GetStateBits() & NS_BLOCK_HAS_OVERFLOW_OUT_OF_FLOWS) {

     SafelyDestroyFrameListProp(aDestructRoot, shell, props,

                                OverflowOutOfFlowsProperty());

     RemoveStateBits(NS_BLOCK_HAS_OVERFLOW_OUT_OF_FLOWS);

   }

   if (HasOutsideBullet()) {

     SafelyDestroyFrameListProp(aDestructRoot, shell, props,

                                OutsideBulletProperty());

     RemoveStateBits(NS_BLOCK_FRAME_HAS_OUTSIDE_BULLET);

   }

   nsBlockFrameSuper::DestroyFrom(aDestructRoot);

 }

 /* virtual */ nsILineIterator*

 nsBlockFrame::GetLineIterator()

 {

   nsLineIterator* it = new nsLineIterator;

   if (!it)

     return nullptr;

   const nsStyleVisibility* visibility = StyleVisibility();

   nsresult rv = it->Init(mLines, visibility->mDirection == NS_STYLE_DIRECTION_RTL);

   if (NS_FAILED(rv)) {

     delete it;

     return nullptr;

   }

   return it;

 }

 NS_QUERYFRAME_HEAD(nsBlockFrame)

   NS_QUERYFRAME_ENTRY(nsBlockFrame)

 NS_QUERYFRAME_TAIL_INHERITING(nsBlockFrameSuper)

 nsSplittableType

 nsBlockFrame::GetSplittableType() const

 {

   return NS_FRAME_SPLITTABLE_NON_RECTANGULAR;

 }

 #ifdef DEBUG_FRAME_DUMP

 void

 nsBlockFrame::List(FILE* out, const char* aPrefix, uint32_t 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()) {

     const_line_iterator line = begin_lines(), line_end = end_lines();

     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 += "  ";

     const_line_iterator 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

   ChildListIterator lists(this);

   ChildListIDs skip(kPrincipalList | kOverflowList);

   for (; !lists.IsDone(); lists.Next()) {

     if (skip.Contains(lists.CurrentID())) {

       continue;

     }

     fprintf_stderr(out, "%s%s %p <\n", pfx.get(),

       mozilla::layout::ChildListName(lists.CurrentID()),

       &GetChildList(lists.CurrentID()));

     nsCString nestedPfx(pfx);

     nestedPfx += "  ";

     nsFrameList::Enumerator childFrames(lists.CurrentList());

     for (; !childFrames.AtEnd(); childFrames.Next()) {

       nsIFrame* kid = childFrames.get();

       kid->List(out, nestedPfx.get(), aFlags);

     }

     fprintf_stderr(out, "%s>\n", pfx.get());

   }

   fprintf_stderr(out, "%s>\n", aPrefix);

 }

 nsresult

 nsBlockFrame::GetFrameName(nsAString& aResult) const

 {

   return MakeFrameName(NS_LITERAL_STRING("Block"), aResult);

 }

 #endif

 #ifdef DEBUG

 nsFrameState

 nsBlockFrame::GetDebugStateBits() const

 {

   // We don't want to include our cursor flag in the bits the

   // regression tester looks at

   return nsBlockFrameSuper::GetDebugStateBits() & ~NS_BLOCK_HAS_LINE_CURSOR;

 }

 #endif

 nsIAtom*

 nsBlockFrame::GetType() const

 {

   return nsGkAtoms::blockFrame;

 }

 void

 nsBlockFrame::InvalidateFrame(uint32_t aDisplayItemKey)

 {

   if (IsSVGText()) {

     NS_ASSERTION(GetParent()->GetType() == nsGkAtoms::svgTextFrame,

                  "unexpected block frame in SVG text");

     GetParent()->InvalidateFrame();

     return;

   }

   nsBlockFrameSuper::InvalidateFrame(aDisplayItemKey);

 }

 void

 nsBlockFrame::InvalidateFrameWithRect(const nsRect& aRect, uint32_t aDisplayItemKey)

 {

   if (IsSVGText()) {

     NS_ASSERTION(GetParent()->GetType() == nsGkAtoms::svgTextFrame,

                  "unexpected block frame in SVG text");

     GetParent()->InvalidateFrame();

     return;

   }

   nsBlockFrameSuper::InvalidateFrameWithRect(aRect, aDisplayItemKey);

 }

 nscoord

 nsBlockFrame::GetBaseline() const

 {

   nscoord result;

   if (nsLayoutUtils::GetLastLineBaseline(this, &result))

     return result;

   return nsFrame::GetBaseline();

 }

 nscoord

 nsBlockFrame::GetCaretBaseline() const

 {

   nsRect contentRect = GetContentRect();

   nsMargin bp = GetUsedBorderAndPadding();

   if (!mLines.empty()) {

     const_line_iterator line = begin_lines();

     const nsLineBox* firstLine = line;

     if (firstLine->GetChildCount()) {

       return bp.top + firstLine->mFirstChild->GetCaretBaseline();

     }

   }

   nsRefPtr<nsFontMetrics> fm;

   float inflation = nsLayoutUtils::FontSizeInflationFor(this);

   nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm), inflation);

   nscoord lineHeight =

     nsHTMLReflowState::CalcLineHeight(GetContent(), StyleContext(),

                                       contentRect.height, inflation);

   return nsLayoutUtils::GetCenteredFontBaseline(fm, lineHeight) + bp.top;

 }

 /////////////////////////////////////////////////////////////////////////////

 // Child frame enumeration

 const nsFrameList&

 nsBlockFrame::GetChildList(ChildListID aListID) const

 {

   switch (aListID) {

     case kPrincipalList:

       return mFrames;

     case kOverflowList: {

       FrameLines* overflowLines = GetOverflowLines();

       return overflowLines ? overflowLines->mFrames : nsFrameList::EmptyList();

     }

     case kFloatList:

       return mFloats;

     case kOverflowOutOfFlowList: {

       const nsFrameList* list = GetOverflowOutOfFlows();

       return list ? *list : nsFrameList::EmptyList();

     }

     case kPushedFloatsList: {

       const nsFrameList* list = GetPushedFloats();

       return list ? *list : nsFrameList::EmptyList();

     }

     case kBulletList: {

       const nsFrameList* list = GetOutsideBulletList();

       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, kOverflowList);

   }

   const nsFrameList* list = GetOverflowOutOfFlows();

   if (list) {

     list->AppendIfNonempty(aLists, kOverflowOutOfFlowList);

   }

   mFloats.AppendIfNonempty(aLists, kFloatList);

   list = GetOutsideBulletList();

   if (list) {

     list->AppendIfNonempty(aLists, kBulletList);

   }

   list = GetPushedFloats();

   if (list) {

     list->AppendIfNonempty(aLists, kPushedFloatsList);

   }

 }

 /* virtual */ bool

 nsBlockFrame::IsFloatContainingBlock() const

 {

   return true;

 }

 static void

 ReparentFrame(nsIFrame* aFrame, nsIFrame* aOldParent, nsIFrame* aNewParent)

 {

   NS_ASSERTION(aOldParent == aFrame->GetParent(),

                "Parent not consistent with expectations");

   aFrame->SetParent(aNewParent);

   // When pushing and pulling frames we need to check for whether any

   // views need to be reparented

   nsContainerFrame::ReparentFrameView(aFrame, aOldParent, aNewParent);

 }

 static void

 ReparentFrames(nsFrameList& aFrameList, nsIFrame* aOldParent,

                nsIFrame* aNewParent)

 {

   for (nsFrameList::Enumerator e(aFrameList); !e.AtEnd(); e.Next()) {

     ReparentFrame(e.get(), aOldParent, aNewParent);

   }

 }

 /**

  * 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* lastFrame = isLastLine ? aFromFrames.LastChild()

                                    : next->mFirstChild->GetPrevSibling();

   nsFrameList::FrameLinkEnumerator linkToBreak(aFromFrames, lastFrame);

   *aOutFrames = aFromFrames.ExtractHead(linkToBreak);

   return isLastLine;

 }

 //////////////////////////////////////////////////////////////////////

 // Reflow methods

 /* virtual */ void

 nsBlockFrame::MarkIntrinsicWidthsDirty()

 {

   nsBlockFrame* dirtyBlock = static_cast<nsBlockFrame*>(FirstContinuation());

   dirtyBlock->mMinWidth = NS_INTRINSIC_WIDTH_UNKNOWN;

   dirtyBlock->mPrefWidth = NS_INTRINSIC_WIDTH_UNKNOWN;

   if (!(GetStateBits() & NS_BLOCK_NEEDS_BIDI_RESOLUTION)) {

     for (nsIFrame* frame = dirtyBlock; frame; 

          frame = frame->GetNextContinuation()) {

       frame->AddStateBits(NS_BLOCK_NEEDS_BIDI_RESOLUTION);

     }

   }

   nsBlockFrameSuper::MarkIntrinsicWidthsDirty();

 }

 void

 nsBlockFrame::CheckIntrinsicCacheAgainstShrinkWrapState()

 {

   nsPresContext *presContext = PresContext();

   if (!nsLayoutUtils::FontSizeInflationEnabled(presContext)) {

     return;

   }

   bool inflationEnabled =

     !presContext->mInflationDisabledForShrinkWrap;

   if (inflationEnabled !=

       !!(GetStateBits() & NS_BLOCK_FRAME_INTRINSICS_INFLATED)) {

     mMinWidth = NS_INTRINSIC_WIDTH_UNKNOWN;

     mPrefWidth = NS_INTRINSIC_WIDTH_UNKNOWN;

     if (inflationEnabled) {

       AddStateBits(NS_BLOCK_FRAME_INTRINSICS_INFLATED);

     } else {

       RemoveStateBits(NS_BLOCK_FRAME_INTRINSICS_INFLATED);

     }

   }

 }

 /* virtual */ nscoord

 nsBlockFrame::GetMinWidth(nsRenderingContext *aRenderingContext)

 {

   nsIFrame* firstInFlow = FirstContinuation();

   if (firstInFlow != this)

     return firstInFlow->GetMinWidth(aRenderingContext);

   DISPLAY_MIN_WIDTH(this, mMinWidth);

   CheckIntrinsicCacheAgainstShrinkWrapState();

   if (mMinWidth != NS_INTRINSIC_WIDTH_UNKNOWN)

     return mMinWidth;

 #ifdef DEBUG

   if (gNoisyIntrinsic) {

     IndentBy(stdout, gNoiseIndent);

     ListTag(stdout);

     printf(": GetMinWidth\n");

   }

   AutoNoisyIndenter indenter(gNoisyIntrinsic);

 #endif

   for (nsBlockFrame* curFrame = this; curFrame;

        curFrame = static_cast<nsBlockFrame*>(curFrame->GetNextContinuation())) {

     curFrame->LazyMarkLinesDirty();

   }

   if (GetStateBits() & NS_BLOCK_NEEDS_BIDI_RESOLUTION)

     ResolveBidi();

   InlineMinWidthData data;

   for (nsBlockFrame* curFrame = this; curFrame;

        curFrame = static_cast<nsBlockFrame*>(curFrame->GetNextContinuation())) {

     for (line_iterator line = curFrame->begin_lines(), line_end = curFrame->end_lines();

       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(aRenderingContext);

         data.currentLine = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,

                         line->mFirstChild, nsLayoutUtils::MIN_WIDTH);

         data.ForceBreak(aRenderingContext);

       } else {

         if (!curFrame->GetPrevContinuation() &&

             line == curFrame->begin_lines()) {

           // Only add text-indent if it has no percentages; using a

           // percentage basis of 0 unconditionally would give strange

           // behavior for calc(10%-3px).

           const nsStyleCoord &indent = StyleText()->mTextIndent;

           if (indent.ConvertsToLength())

             data.currentLine += nsRuleNode::ComputeCoordPercentCalc(indent, 0);

         }

         // XXX Bug NNNNNN Should probably handle percentage text-indent.

         data.line = &line;

         data.lineContainer = curFrame;

         nsIFrame *kid = line->mFirstChild;

         for (int32_t i = 0, i_end = line->GetChildCount(); i != i_end;

              ++i, kid = kid->GetNextSibling()) {

           kid->AddInlineMinWidth(aRenderingContext, &data);

         }

       }

 #ifdef DEBUG

       if (gNoisyIntrinsic) {

         IndentBy(stdout, gNoiseIndent);

         printf("min: [prevLines=%d currentLine=%d]\n",

                data.prevLines, data.currentLine);

       }

 #endif

     }

   }

   data.ForceBreak(aRenderingContext);

   mMinWidth = data.prevLines;

   return mMinWidth;

 }

 /* virtual */ nscoord

 nsBlockFrame::GetPrefWidth(nsRenderingContext *aRenderingContext)

 {

   nsIFrame* firstInFlow = FirstContinuation();

   if (firstInFlow != this)

     return firstInFlow->GetPrefWidth(aRenderingContext);

   DISPLAY_PREF_WIDTH(this, mPrefWidth);

   CheckIntrinsicCacheAgainstShrinkWrapState();

   if (mPrefWidth != NS_INTRINSIC_WIDTH_UNKNOWN)

     return mPrefWidth;

 #ifdef DEBUG

   if (gNoisyIntrinsic) {

     IndentBy(stdout, gNoiseIndent);

     ListTag(stdout);

     printf(": GetPrefWidth\n");

   }

   AutoNoisyIndenter indenter(gNoisyIntrinsic);

 #endif

   for (nsBlockFrame* curFrame = this; curFrame;

        curFrame = static_cast<nsBlockFrame*>(curFrame->GetNextContinuation())) {

     curFrame->LazyMarkLinesDirty();

   }

   if (GetStateBits() & NS_BLOCK_NEEDS_BIDI_RESOLUTION)

     ResolveBidi();

   InlinePrefWidthData data;

   for (nsBlockFrame* curFrame = this; curFrame;

        curFrame = static_cast<nsBlockFrame*>(curFrame->GetNextContinuation())) {

     for (line_iterator line = curFrame->begin_lines(), line_end = curFrame->end_lines();

          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(aRenderingContext);

         data.currentLine = nsLayoutUtils::IntrinsicForContainer(aRenderingContext,

                         line->mFirstChild, nsLayoutUtils::PREF_WIDTH);

         data.ForceBreak(aRenderingContext);

       } else {

         if (!curFrame->GetPrevContinuation() &&

             line == curFrame->begin_lines()) {

           // Only add text-indent if it has no percentages; using a

           // percentage basis of 0 unconditionally would give strange

           // behavior for calc(10%-3px).

           const nsStyleCoord &indent = StyleText()->mTextIndent;

           if (indent.ConvertsToLength())

             data.currentLine += nsRuleNode::ComputeCoordPercentCalc(indent, 0);

         }

         // XXX Bug NNNNNN Should probably handle percentage text-indent.

         data.line = &line;

         data.lineContainer = curFrame;

         nsIFrame *kid = line->mFirstChild;

         for (int32_t i = 0, i_end = line->GetChildCount(); i != i_end;

              ++i, kid = kid->GetNextSibling()) {

           kid->AddInlinePrefWidth(aRenderingContext, &data);

         }

       }

 #ifdef DEBUG

       if (gNoisyIntrinsic) {

         IndentBy(stdout, gNoiseIndent);

         printf("pref: [prevLines=%d currentLine=%d]\n",

                data.prevLines, data.currentLine);

       }

 #endif

     }

   }

   data.ForceBreak(aRenderingContext);

   mPrefWidth = data.prevLines;

   return mPrefWidth;

 }

 nsRect

 nsBlockFrame::ComputeTightBounds(gfxContext* aContext) const

 {

   // be conservative

   if (StyleContext()->HasTextDecorationLines()) {

     return GetVisualOverflowRect();

   }

   return ComputeSimpleTightBounds(aContext);

 }

 /* virtual */ nsresult

 nsBlockFrame::GetPrefWidthTightBounds(nsRenderingContext* aRenderingContext,

                                       nscoord* aX,

                                       nscoord* aXMost)

 {

   nsIFrame* firstInFlow = FirstContinuation();

   if (firstInFlow != this) {

     return firstInFlow->GetPrefWidthTightBounds(aRenderingContext, aX, aXMost);

   }

   *aX = 0;

   *aXMost = 0;

   nsresult rv;

   InlinePrefWidthData data;

   for (nsBlockFrame* curFrame = this; curFrame;

        curFrame = static_cast<nsBlockFrame*>(curFrame->GetNextContinuation())) {

     for (line_iterator line = curFrame->begin_lines(), line_end = curFrame->end_lines();

          line != line_end; ++line)

     {

       nscoord childX, childXMost;

       if (line->IsBlock()) {

         data.ForceBreak(aRenderingContext);

         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() &&

             line == curFrame->begin_lines()) {

           // Only add text-indent if it has no percentages; using a

           // percentage basis of 0 unconditionally would give strange

           // behavior for calc(10%-3px).

           const nsStyleCoord &indent = StyleText()->mTextIndent;

           if (indent.ConvertsToLength()) {

             data.currentLine += nsRuleNode::ComputeCoordPercentCalc(indent, 0);

           }

         }

         // XXX Bug NNNNNN Should probably handle percentage text-indent.

         data.line = &line;

         data.lineContainer = 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.currentLine + childX);

           *aXMost = std::max(*aXMost, data.currentLine + childXMost);

           kid->AddInlinePrefWidth(aRenderingContext, &data);

         }

       }

     }

   }

   data.ForceBreak(aRenderingContext);

   return NS_OK;

 }

 static bool

 AvailableSpaceShrunk(const nsRect& aOldAvailableSpace,

                      const nsRect& aNewAvailableSpace)

 {

   if (aNewAvailableSpace.width == 0) {

     // Positions are not significant if the width is zero.

     return aOldAvailableSpace.width != 0;

   }

   NS_ASSERTION(aOldAvailableSpace.x <= aNewAvailableSpace.x &&

                aOldAvailableSpace.XMost() >= aNewAvailableSpace.XMost(),

                "available space should never grow");

   return aOldAvailableSpace.width != aNewAvailableSpace.width;

 }

 static nsSize

 CalculateContainingBlockSizeForAbsolutes(const nsHTMLReflowState& aReflowState,

                                          nsSize aFrameSize)

 {

   // The issue here is that for a 'height' of 'auto' the reflow state

   // 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 = aReflowState.frame;

   nsSize cbSize(aFrameSize);

     // Containing block is relative to the padding edge

   const nsMargin& border =

     aReflowState.ComputedPhysicalBorderPadding() - aReflowState.ComputedPhysicalPadding();

   cbSize.width -= border.LeftRight();

   cbSize.height -= border.TopBottom();

   if (frame->GetParent()->GetContent() == frame->GetContent() &&

       frame->GetParent()->GetType() != nsGkAtoms::canvasFrame) {

     // 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 state for the outermost frame for this

     // content, except for fieldsets where the inner anonymous frame has

     // the correct padding area with the legend taken into account.

     const nsHTMLReflowState* aLastRS = &aReflowState;

     const nsHTMLReflowState* lastButOneRS = &aReflowState;

     while (aLastRS->parentReflowState &&

            aLastRS->parentReflowState->frame->GetContent() == frame->GetContent() &&

            aLastRS->parentReflowState->frame->GetType() != nsGkAtoms::fieldSetFrame) {

       lastButOneRS = aLastRS;

       aLastRS = aLastRS->parentReflowState;

     }

     if (aLastRS != &aReflowState) {

       // Scrollbars need to be specifically excluded, if present, because they are outside the

       // padding-edge. We need better APIs for getting the various boxes from a frame.

       nsIScrollableFrame* scrollFrame = do_QueryFrame(aLastRS->frame);

       nsMargin scrollbars(0,0,0,0);

       if (scrollFrame) {

         scrollbars =

           scrollFrame->GetDesiredScrollbarSizes(aLastRS->frame->PresContext(),

                                                 aLastRS->rendContext);

         if (!lastButOneRS->mFlags.mAssumingHScrollbar) {

           scrollbars.top = scrollbars.bottom = 0;

         }

         if (!lastButOneRS->mFlags.mAssumingVScrollbar) {

           scrollbars.left = scrollbars.right = 0;

         }

       }

       // We found a reflow state for the outermost wrapping frame, so use

       // its computed metrics if available

       if (aLastRS->ComputedWidth() != NS_UNCONSTRAINEDSIZE) {

         cbSize.width = std::max(0,

           aLastRS->ComputedWidth() + aLastRS->ComputedPhysicalPadding().LeftRight() - scrollbars.LeftRight());

       }

       if (aLastRS->ComputedHeight() != NS_UNCONSTRAINEDSIZE) {

         cbSize.height = std::max(0,

           aLastRS->ComputedHeight() + aLastRS->ComputedPhysicalPadding().TopBottom() - scrollbars.TopBottom());

       }

     }

   }

   return cbSize;

 }

 nsresult

 nsBlockFrame::Reflow(nsPresContext*           aPresContext,

                      nsHTMLReflowMetrics&     aMetrics,

                      const nsHTMLReflowState& aReflowState,

                      nsReflowStatus&          aStatus)

 {

   DO_GLOBAL_REFLOW_COUNT("nsBlockFrame");

   DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aStatus);

 #ifdef DEBUG

   if (gNoisyReflow) {

     IndentBy(stdout, gNoiseIndent);

     ListTag(stdout);

     printf(": begin reflow availSize=%d,%d computedSize=%d,%d\n",

            aReflowState.AvailableWidth(), aReflowState.AvailableHeight(),

            aReflowState.ComputedWidth(), aReflowState.ComputedHeight());

   }

   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

   const nsHTMLReflowState *reflowState = &aReflowState;

   nscoord consumedHeight = GetConsumedHeight();

   nscoord effectiveComputedHeight = GetEffectiveComputedHeight(aReflowState,

                                                                consumedHeight);

   Maybe<nsHTMLReflowState> mutableReflowState;

   // If we have non-auto height, we're clipping our kids and we fit,

   // make sure our kids fit too.

   if (aReflowState.AvailableHeight() != NS_UNCONSTRAINEDSIZE &&

       aReflowState.ComputedHeight() != NS_AUTOHEIGHT &&

       ShouldApplyOverflowClipping(this, aReflowState.mStyleDisplay)) {

     LogicalMargin blockDirExtras = aReflowState.ComputedLogicalBorderPadding();

     WritingMode wm = aReflowState.GetWritingMode();

     if (GetLogicalSkipSides() & (LOGICAL_SIDE_B_START)) {

       blockDirExtras.BStart(wm) = 0;

     } else {

       // Bottom margin never causes us to create continuations, so we

       // don't need to worry about whether it fits in its entirety.

       blockDirExtras.BStart(wm) +=

         aReflowState.ComputedLogicalMargin().BStart(wm);

     }

     if (effectiveComputedHeight + blockDirExtras.BStartEnd(wm) <=

         aReflowState.AvailableBSize()) {

       mutableReflowState.construct(aReflowState);

       mutableReflowState.ref().AvailableBSize() = NS_UNCONSTRAINEDSIZE;

       reflowState = mutableReflowState.addr();

     }

   }

   // 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<nsHTMLReflowState&>(*reflowState));

   // 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);

   // OK, some lines may be reflowed. Blow away any saved line cursor

   // because we may invalidate the nondecreasing

   // overflowArea.VisualOverflow().y/yMost invariant, and we may even

   // delete the line with the line cursor.

   ClearLineCursor();

   if (IsFrameTreeTooDeep(*reflowState, aMetrics, aStatus)) {

     return NS_OK;

   }

   bool topMarginRoot, bottomMarginRoot;

   IsMarginRoot(&topMarginRoot, &bottomMarginRoot);

   // Cache the consumed height in the block reflow state so that we don't have

   // to continually recompute it.

   nsBlockReflowState state(*reflowState, aPresContext, this,

                            topMarginRoot, bottomMarginRoot, needFloatManager,

                            consumedHeight);

   if (GetStateBits() & NS_BLOCK_NEEDS_BIDI_RESOLUTION)

     static_cast<nsBlockFrame*>(FirstContinuation())->ResolveBidi();

   if (RenumberLists(aPresContext)) {

     AddStateBits(NS_FRAME_HAS_DIRTY_CHILDREN);

   }

   nsresult rv = NS_OK;

   // 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();

   // Handle paginated overflow (see nsContainerFrame.h)

   nsOverflowAreas ocBounds;

   nsReflowStatus ocStatus = NS_FRAME_COMPLETE;

   if (GetPrevInFlow()) {

     ReflowOverflowContainerChildren(aPresContext, *reflowState, ocBounds, 0,

                                     ocStatus);

   }

   // 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(state);

   nsOverflowAreas fcBounds;

   nsReflowStatus fcStatus = NS_FRAME_COMPLETE;

   ReflowPushedFloats(state, fcBounds, fcStatus);

   // If we're not dirty (which means we'll mark everything dirty later)

   // and our width has changed, mark the lines dirty that we need to

   // mark dirty for a resize reflow.

   if (!(GetStateBits() & NS_FRAME_IS_DIRTY) && reflowState->mFlags.mHResize) {

     PrepareResizeReflow(state);

   }

   LazyMarkLinesDirty();

   mState &= ~NS_FRAME_FIRST_REFLOW;

   // Now reflow...

   rv = 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 of NS_FRAME_COMPLETE, 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 (NS_FRAME_IS_COMPLETE(state.mReflowStatus)) {

     nsBlockFrame* nif = static_cast<nsBlockFrame*>(GetNextInFlow());

     while (nif) {

       if (nif->HasPushedFloatsFromPrevContinuation()) {

         NS_MergeReflowStatusInto(&state.mReflowStatus, NS_FRAME_NOT_COMPLETE);

       }

       nif = static_cast<nsBlockFrame*>(nif->GetNextInFlow());

     }

   }

   NS_ASSERTION(NS_SUCCEEDED(rv), "reflow dirty lines failed");

   if (NS_FAILED(rv)) return rv;

   NS_MergeReflowStatusInto(&state.mReflowStatus, ocStatus);

   NS_MergeReflowStatusInto(&state.mReflowStatus, fcStatus);

   // If we end in a BR with clear and affected floats continue,

   // we need to continue, too.

   if (NS_UNCONSTRAINEDSIZE != reflowState->AvailableHeight() &&

       NS_FRAME_IS_COMPLETE(state.mReflowStatus) &&

       state.mFloatManager->ClearContinues(FindTrailingClear())) {

     NS_FRAME_SET_INCOMPLETE(state.mReflowStatus);

   }

   if (!NS_FRAME_IS_FULLY_COMPLETE(state.mReflowStatus)) {

     if (HasOverflowLines() || HasPushedFloats()) {

       state.mReflowStatus |= NS_FRAME_REFLOW_NEXTINFLOW;

     }

 #ifdef DEBUG_kipp

     ListTag(stdout); printf(": block is not fully complete\n");

 #endif

   }

   // Place the "marker" (bullet) frame if it is placed next to a block

   // child.

   //

   // 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 bullet 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 (HasOutsideBullet() && !mLines.empty() &&

       (mLines.front()->IsBlock() ||

        (0 == mLines.front()->BSize() &&

         mLines.front() != mLines.back() &&

         mLines.begin().next()->IsBlock()))) {

     // Reflow the bullet

     nsHTMLReflowMetrics metrics(aReflowState);

     // XXX Use the entire line when we fix bug 25888.

     nsLayoutUtils::LinePosition position;

     bool havePosition = nsLayoutUtils::GetFirstLinePosition(this, &position);

     nscoord lineTop = havePosition ? position.mTop

                                    : reflowState->ComputedPhysicalBorderPadding().top;

     nsIFrame* bullet = GetOutsideBullet();

     ReflowBullet(bullet, state, metrics, lineTop);

     NS_ASSERTION(!BulletIsEmpty() || metrics.Height() == 0,

                  "empty bullet took up space");

     if (havePosition && !BulletIsEmpty()) {

       // We have some lines to align the bullet with.  

       // Doing the alignment using the baseline will also cater for

       // bullets that are placed next to a child block (bug 92896)

       // Tall bullets won't look particularly nice here...

       nsRect bbox = bullet->GetRect();

       bbox.y = position.mBaseline - metrics.TopAscent();

       bullet->SetRect(bbox);

     }

     // Otherwise just leave the bullet where it is, up against our top padding.

   }

   CheckFloats(state);

   // Compute our final size

   nscoord bottomEdgeOfChildren;

   ComputeFinalSize(*reflowState, state, aMetrics, &bottomEdgeOfChildren);

   nsRect areaBounds = nsRect(0, 0, aMetrics.Width(), aMetrics.Height());

   ComputeOverflowAreas(areaBounds, reflowState->mStyleDisplay,

                        bottomEdgeOfChildren, aMetrics.mOverflowAreas);

   // Factor overflow container child bounds into the overflow area

   aMetrics.mOverflowAreas.UnionWith(ocBounds);

   // Factor pushed float child bounds into the overflow area

   aMetrics.mOverflowAreas.UnionWith(fcBounds);

   // 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.

   if (HasAbsolutelyPositionedChildren()) {

     nsAbsoluteContainingBlock* absoluteContainer = GetAbsoluteContainingBlock();

     bool haveInterrupt = aPresContext->HasPendingInterrupt();

     if (reflowState->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 && (GetStateBits() & NS_FRAME_IS_DIRTY)) {

         absoluteContainer->MarkAllFramesDirty();

       } else {

         absoluteContainer->MarkSizeDependentFramesDirty();

       }

     } else {

       nsSize containingBlockSize =

         CalculateContainingBlockSizeForAbsolutes(*reflowState,

                                                  nsSize(aMetrics.Width(),

                                                         aMetrics.Height()));

       // 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.

       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 == reflowState->ComputedHeight()) &&

         aMetrics.Height() != oldSize.height;

       nsRect containingBlock(nsPoint(0, 0), containingBlockSize);

       absoluteContainer->Reflow(this, aPresContext, *reflowState,

                                 state.mReflowStatus,

                                 containingBlock, true,

                                 cbWidthChanged, cbHeightChanged,

                                 &aMetrics.mOverflowAreas);

       //XXXfr Why isn't this rv (and others in this file) checked/returned?

     }

   }

   FinishAndStoreOverflow(&aMetrics);

   // Clear the float manager pointer in the block reflow state so we

   // don't waste time translating the coordinate system back on a dead

   // float manager.

   if (needFloatManager)

     state.mFloatManager = nullptr;

   aStatus = state.mReflowStatus;

 #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=%x (%scomplete) metrics=%d,%d carriedMargin=%d",

            aStatus, NS_FRAME_IS_COMPLETE(aStatus) ? "" : "not ",

            aMetrics.Width(), aMetrics.Height(),

            aMetrics.mCarriedOutBottomMargin.get());

     if (HasOverflowAreas()) {

       printf(" overflow-vis={%d,%d,%d,%d}",

              aMetrics.VisualOverflow().x,

              aMetrics.VisualOverflow().y,

              aMetrics.VisualOverflow().width,

              aMetrics.VisualOverflow().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];

     PR_snprintf(buf, sizeof(buf),

                 ": %lld elapsed (%lld per line) (%d lines; %d new lines)",

                 delta, perLineDelta, numLines, ectc - ctc);

     printf("%s\n", buf);

   }

 #endif

   NS_FRAME_SET_TRUNCATION(aStatus, (*reflowState), aMetrics);

   return rv;

 }

 bool

 nsBlockFrame::CheckForCollapsedBottomMarginFromClearanceLine()

 {

   line_iterator begin = begin_lines();

   line_iterator line = end_lines();

   while (true) {

     if (begin == line) {

       return false;

     }

     --line;

     if (line->BSize() != 0 || !line->CachedIsEmpty()) {

       return false;

     }

     if (line->HasClearance()) {

       return true;

     }

   }

   // not reached

 }

 void

 nsBlockFrame::ComputeFinalSize(const nsHTMLReflowState& aReflowState,

                                nsBlockReflowState&      aState,

                                nsHTMLReflowMetrics&     aMetrics,

                                nscoord*                 aBottomEdgeOfChildren)

 {

   const nsMargin& borderPadding = aState.BorderPadding();

 #ifdef NOISY_FINAL_SIZE

   ListTag(stdout);

   printf(": mY=%d mIsBottomMarginRoot=%s mPrevBottomMargin=%d bp=%d,%d\n",

          aState.mY, aState.GetFlag(BRS_ISBOTTOMMARGINROOT) ? "yes" : "no",

          aState.mPrevBottomMargin,

          borderPadding.top, borderPadding.bottom);

 #endif

   // Compute final width

   aMetrics.Width() =

     NSCoordSaturatingAdd(NSCoordSaturatingAdd(borderPadding.left,

                                               aReflowState.ComputedWidth()), 

                          borderPadding.right);

   // Return bottom 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.mCarriedOutBottomMargin.IsZero(),

   //             "someone else set the margin");

   nscoord nonCarriedOutVerticalMargin = 0;

   if (!aState.GetFlag(BRS_ISBOTTOMMARGINROOT)) {

     // Apply rule from CSS 2.1 section 8.3.1. If we have some empty

     // line with clearance and a non-zero top margin and all

     // subsequent lines are empty, then we do not allow our children's

     // carried out bottom margin to be carried out of us and collapse

     // with our own bottom margin.

     if (CheckForCollapsedBottomMarginFromClearanceLine()) {

       // Convert the children's carried out margin to something that

       // we will include in our height

       nonCarriedOutVerticalMargin = aState.mPrevBottomMargin.get();

       aState.mPrevBottomMargin.Zero();

     }

     aMetrics.mCarriedOutBottomMargin = aState.mPrevBottomMargin;

   } else {

     aMetrics.mCarriedOutBottomMargin.Zero();

   }

   nscoord bottomEdgeOfChildren = aState.mY + nonCarriedOutVerticalMargin;

   // Shrink wrap our height around our contents.

   if (aState.GetFlag(BRS_ISBOTTOMMARGINROOT) ||

       NS_UNCONSTRAINEDSIZE != aReflowState.ComputedHeight()) {

     // When we are a bottom-margin root make sure that our last

     // childs bottom 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 (bottomEdgeOfChildren < aState.mReflowState.AvailableHeight())

     {

       // Truncate bottom margin if it doesn't fit to our available height.

       bottomEdgeOfChildren =

         std::min(bottomEdgeOfChildren + aState.mPrevBottomMargin.get(),

                aState.mReflowState.AvailableHeight());

     }

   }

   if (aState.GetFlag(BRS_FLOAT_MGR)) {

     // Include the float manager's state to properly account for the

     // bottom margin of any floated elements; e.g., inside a table cell.

     nscoord floatHeight =

       aState.ClearFloats(bottomEdgeOfChildren, NS_STYLE_CLEAR_BOTH,

                          nullptr, nsFloatManager::DONT_CLEAR_PUSHED_FLOATS);

     bottomEdgeOfChildren = std::max(bottomEdgeOfChildren, floatHeight);

   }

   if (NS_UNCONSTRAINEDSIZE != aReflowState.ComputedHeight()

       && (mParent->GetType() != nsGkAtoms::columnSetFrame ||

           aReflowState.parentReflowState->AvailableHeight() == NS_UNCONSTRAINEDSIZE)) {

     ComputeFinalHeight(aReflowState, &aState.mReflowStatus,

                        aState.mY + nonCarriedOutVerticalMargin,

                        borderPadding, aMetrics, aState.mConsumedHeight);

     if (!NS_FRAME_IS_COMPLETE(aState.mReflowStatus)) {

       // Use the current height; continuations will take up the rest.

       // Do extend the height to at least consume the available

       // height, otherwise our left/right borders (for example) won't

       // extend all the way to the break.

       aMetrics.Height() = std::max(aReflowState.AvailableHeight(),

                                aState.mY + nonCarriedOutVerticalMargin);

       // ... but don't take up more height than is available

       nscoord effectiveComputedHeight =

         GetEffectiveComputedHeight(aReflowState, aState.GetConsumedHeight());

       aMetrics.Height() = std::min(aMetrics.Height(),

                                borderPadding.top + effectiveComputedHeight);

       // XXX It's pretty wrong that our bottom border still gets drawn on

       // on its own on the last-in-flow, even if we ran out of height

       // here. We need GetSkipSides to check whether we ran out of content

       // height in the current frame, not whether it's last-in-flow.

     }

     // Don't carry out a bottom margin when our height is fixed.

     aMetrics.mCarriedOutBottomMargin.Zero();

   }

   else if (NS_FRAME_IS_COMPLETE(aState.mReflowStatus)) {

     nscoord contentHeight = bottomEdgeOfChildren - borderPadding.top;

     nscoord autoHeight = aReflowState.ApplyMinMaxHeight(contentHeight);

     if (autoHeight != contentHeight) {

       // Our min-height or max-height made our height change.  Don't carry out

       // our kids' bottom margins.

       aMetrics.mCarriedOutBottomMargin.Zero();

     }

     autoHeight += borderPadding.top + borderPadding.bottom;

     aMetrics.Height() = autoHeight;

   }

   else {

     NS_ASSERTION(aReflowState.AvailableHeight() != NS_UNCONSTRAINEDSIZE,

       "Shouldn't be incomplete if availableHeight is UNCONSTRAINED.");

     aMetrics.Height() = std::max(aState.mY, aReflowState.AvailableHeight());

     if (aReflowState.AvailableHeight() == NS_UNCONSTRAINEDSIZE)

       // This should never happen, but it does. See bug 414255

       aMetrics.Height() = aState.mY;

   }

   if (IS_TRUE_OVERFLOW_CONTAINER(this) &&

       NS_FRAME_IS_NOT_COMPLETE(aState.mReflowStatus)) {

     // Overflow containers can only be overflow complete.

     // Note that auto height overflow containers have no normal children

     NS_ASSERTION(aMetrics.Height() == 0, "overflow containers must be zero-height");

     NS_FRAME_SET_OVERFLOW_INCOMPLETE(aState.mReflowStatus);

   }

   // Screen out negative heights --- can happen due to integer overflows :-(

   aMetrics.Height() = std::max(0, aMetrics.Height());

   *aBottomEdgeOfChildren = bottomEdgeOfChildren;

   FrameProperties properties = Properties();

   if (bottomEdgeOfChildren != aMetrics.Height() - borderPadding.bottom) {

     properties.Set(BottomEdgeOfChildrenProperty(),

                    NS_INT32_TO_PTR(bottomEdgeOfChildren));

   } else {

     properties.Delete(BottomEdgeOfChildrenProperty());

   }

 #ifdef DEBUG_blocks

   if (CRAZY_SIZE(aMetrics.Width()) || CRAZY_SIZE(aMetrics.Height())) {

     ListTag(stdout);

     printf(": WARNING: desired:%d,%d\n", aMetrics.Width(), aMetrics.Height());

   }

 #endif

 }

 static void

 ConsiderBottomEdgeOfChildren(nscoord aBottomEdgeOfChildren,

                              nsOverflowAreas& aOverflowAreas)

 {

   // Factor in the bottom 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 bottom 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.

   NS_FOR_FRAME_OVERFLOW_TYPES(otype) {

     nsRect& o = aOverflowAreas.Overflow(otype);

     o.height = std::max(o.YMost(), aBottomEdgeOfChildren) - o.y;

   }

 }

 void

 nsBlockFrame::ComputeOverflowAreas(const nsRect&         aBounds,

                                    const nsStyleDisplay* aDisplay,

                                    nscoord               aBottomEdgeOfChildren,

                                    nsOverflowAreas&      aOverflowAreas)

 {

   // Compute the overflow areas of our children

   // XXX_perf: This can be done incrementally.  It is currently one of

   // the things that makes incremental reflow O(N^2).

   nsOverflowAreas areas(aBounds, aBounds);

   if (!ShouldApplyOverflowClipping(this, aDisplay)) {

     for (line_iterator line = begin_lines(), line_end = end_lines();

          line != line_end;

          ++line) {

       areas.UnionWith(line->GetOverflowAreas());

     }

     // Factor an outside bullet in; normally the bullet 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?

     nsIFrame* outsideBullet = GetOutsideBullet();

     if (outsideBullet) {

       areas.UnionAllWith(outsideBullet->GetRect());

     }

     ConsiderBottomEdgeOfChildren(aBottomEdgeOfChildren, areas);

   }

 #ifdef NOISY_COMBINED_AREA

   ListTag(stdout);

   printf(": ca=%d,%d,%d,%d\n", area.x, area.y, area.width, area.height);

 #endif

   aOverflowAreas = areas;

 }

 bool

 nsBlockFrame::UpdateOverflow()

 {

   nsRect rect(nsPoint(0, 0), GetSize());

   nsOverflowAreas overflowAreas(rect, rect);

   // 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 (line_iterator line = begin_lines(), line_end = end_lines();

        line != line_end;

        ++line) {

     nsRect bounds = line->GetPhysicalBounds();

     nsOverflowAreas 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 (nsFloatCache* fc = line->GetFirstFloat(); fc; fc = fc->Next()) {

         ConsiderChildOverflow(lineAreas, fc->mFloat);

       }

     }

     line->SetOverflowAreas(lineAreas);

     overflowAreas.UnionWith(lineAreas);

   }

   // Line cursor invariants depend on the overflow areas of the lines, so

   // we must clear the line cursor since those areas may have changed.

   ClearLineCursor();

   // Union with child frames, skipping the principal and float lists

   // since we already handled those using the line boxes.

   nsLayoutUtils::UnionChildOverflow(this, overflowAreas,

                                     kPrincipalList | kFloatList);

   bool found;

   nscoord bottomEdgeOfChildren = NS_PTR_TO_INT32(

     Properties().Get(BottomEdgeOfChildrenProperty(), &found));

   if (found) {

     ConsiderBottomEdgeOfChildren(bottomEdgeOfChildren, overflowAreas);

   }

   return FinishAndStoreOverflow(overflowAreas, GetSize());

 }

 void

 nsBlockFrame::LazyMarkLinesDirty()

 {

   if (GetStateBits() & NS_BLOCK_LOOK_FOR_DIRTY_FRAMES) {

     for (line_iterator line = begin_lines(), line_end = end_lines();

          line != line_end; ++line) {

       int32_t n = line->GetChildCount();

       for (nsIFrame* lineFrame = line->mFirstChild;

            n > 0; lineFrame = lineFrame->GetNextSibling(), --n) {

         if (NS_SUBTREE_DIRTY(lineFrame)) {

           // NOTE:  MarkLineDirty does more than just marking the line dirty.

           MarkLineDirty(line, &mLines);

           break;

         }

       }

     }

     RemoveStateBits(NS_BLOCK_LOOK_FOR_DIRTY_FRAMES);

   }

 }

 void

 nsBlockFrame::MarkLineDirty(line_iterator 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(uint8_t aAlignment,

               uint8_t aDirection,

               uint8_t aUnicodeBidi,

               nsIFrame* aFrame)

 {

   return aFrame->IsSVGText() ||

          NS_STYLE_TEXT_ALIGN_LEFT == aAlignment ||

          (((NS_STYLE_TEXT_ALIGN_DEFAULT == aAlignment &&

            NS_STYLE_DIRECTION_LTR == aDirection) ||

           (NS_STYLE_TEXT_ALIGN_END == aAlignment &&

            NS_STYLE_DIRECTION_RTL == aDirection)) &&

          !(NS_STYLE_UNICODE_BIDI_PLAINTEXT & aUnicodeBidi));

 }

 void

 nsBlockFrame::PrepareResizeReflow(nsBlockReflowState& aState)

 {

   // See if we can try and avoid marking all the lines as dirty

   bool tryAndSkipLines =

     // The left content-edge must be a constant distance from the left

     // border-edge.

     !StylePadding()->mPadding.GetLeft().HasPercent();

 #ifdef DEBUG

   if (gDisableResizeOpt) {

     tryAndSkipLines = false;

   }

   if (gNoisyReflow) {

     if (!tryAndSkipLines) {

       IndentBy(stdout, gNoiseIndent);

       ListTag(stdout);

       printf(": marking all lines dirty: availWidth=%d\n",

              aState.mReflowState.AvailableWidth());

     }

   }

 #endif

   if (tryAndSkipLines) {

     nscoord newAvailWidth = aState.mReflowState.ComputedPhysicalBorderPadding().left +

                             aState.mReflowState.ComputedWidth();

     NS_ASSERTION(NS_UNCONSTRAINEDSIZE != aState.mReflowState.ComputedPhysicalBorderPadding().left &&

                  NS_UNCONSTRAINEDSIZE != aState.mReflowState.ComputedWidth(),

                  "math on NS_UNCONSTRAINEDSIZE");

 #ifdef DEBUG

     if (gNoisyReflow) {

       IndentBy(stdout, gNoiseIndent);

       ListTag(stdout);

       printf(": trying to avoid marking all lines dirty\n");

     }

 #endif

     for (line_iterator line = begin_lines(), line_end = end_lines();

          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->HasBreakAfter()) ||

           ((isLastLine || !line->IsLineWrapped())) ||

           line->ResizeReflowOptimizationDisabled() ||

           line->IsImpactedByFloat() ||

           (line->IEnd() > newAvailWidth)) {

         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 breakTypeBefore/After=%d/%d xmost=%d\n",

            static_cast<void*>(line.get()),

            static_cast<void*>((line.next() != end_lines() ? line.next().get() : nullptr)),

            line->IsBlock() ? "block" : "inline",

            line->HasBreakAfter() ? "has-break-after " : "",

            line->HasFloats() ? "has-floats " : "",

            line->IsImpactedByFloat() ? "impacted " : "",

            line->GetBreakTypeBefore(), line->GetBreakTypeAfter(),

            line->IEnd());

       }

 #endif

     }

   }

   else {

     // Mark everything dirty

     for (line_iterator line = begin_lines(), line_end = end_lines();

          line != line_end;

          ++line)

     {

       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 |aDeltaY| and any impact by a float,

  *     either the previous reflow or now.

  *

  * When entering this function, |aLine| is still at its old position and

  * |aDeltaY| indicates how much it will later be slid (assuming it

  * doesn't get marked dirty and reflowed entirely).

  */

 void

 nsBlockFrame::PropagateFloatDamage(nsBlockReflowState& aState,

                                    nsLineBox* aLine,

                                    nscoord aDeltaY)

 {

   nsFloatManager *floatManager = aState.mReflowState.mFloatManager;

   NS_ASSERTION((aState.mReflowState.parentReflowState &&

                 aState.mReflowState.parentReflowState->mFloatManager == floatManager) ||

                 aState.mReflowState.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 lineYA = aLine->BStart() + aDeltaY;

     nscoord lineYB = lineYA + aLine->BSize();

     // Scrollable overflow should be sufficient for things that affect

     // layout.

     nsRect overflow = aLine->GetOverflowArea(eScrollableOverflow);

     nscoord lineYCombinedA = overflow.y + aDeltaY;

     nscoord lineYCombinedB = lineYCombinedA + overflow.height;

     if (floatManager->IntersectsDamage(lineYA, lineYB) ||

         floatManager->IntersectsDamage(lineYCombinedA, lineYCombinedB)) {

       aLine->MarkDirty();

       return;

     }

   }

   // Check if the line is moving relative to the float manager

   if (aDeltaY + aState.mReflowState.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.GetFloatAvailableSpaceForHeight(aLine->BStart() + aDeltaY,

                                                aLine->BSize(),

                                                nullptr);

 #ifdef REALLY_NOISY_REFLOW

     printf("nsBlockFrame::PropagateFloatDamage %p was = %d, is=%d\n", 

            this, wasImpactedByFloat, floatAvailableSpace.mHasFloats);

 #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.mHasFloats) {

         aLine->MarkDirty();

       }

     }

   }

 }

 static bool LineHasClear(nsLineBox* aLine) {

   return aLine->IsBlock()

     ? (aLine->GetBreakTypeBefore() ||

        (aLine->mFirstChild->GetStateBits() & NS_BLOCK_HAS_CLEAR_CHILDREN) ||

        !nsBlockFrame::BlockCanIntersectFloats(aLine->mFirstChild))

     : aLine->HasFloatBreakAfter();

 }

 /**

  * 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.FirstChild(); f; f = f->GetNextSibling()) {

       ReparentFrame(f, aOldParent, this);

     }

     mFloats.AppendFrames(nullptr, list);

   }

 }

 static void DumpLine(const nsBlockReflowState& aState, nsLineBox* aLine,

                      nscoord aDeltaY, int32_t aDeltaIndent) {

 #ifdef DEBUG

   if (nsBlockFrame::gNoisyReflow) {

     nsRect ovis(aLine->GetVisualOverflowArea());

     nsRect oscr(aLine->GetScrollableOverflowArea());

     nsBlockFrame::IndentBy(stdout, nsBlockFrame::gNoiseIndent + aDeltaIndent);

     printf("line=%p mY=%d dirty=%s oldBounds={%d,%d,%d,%d} oldoverflow-vis={%d,%d,%d,%d} oldoverflow-scr={%d,%d,%d,%d} deltaY=%d mPrevBottomMargin=%d childCount=%d\n",

            static_cast<void*>(aLine), aState.mY,

            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,

            aDeltaY, aState.mPrevBottomMargin.get(), aLine->GetChildCount());

   }

 #endif

 }

 /**

  * Reflow the dirty lines

  */

 nsresult

 nsBlockFrame::ReflowDirtyLines(nsBlockReflowState& aState)

 {

   nsresult rv = NS_OK;

   bool keepGoing = true;

   bool repositionViews = false; // should we really need this?

   bool foundAnyClears = aState.mFloatBreakType != NS_STYLE_CLEAR_NONE;

   bool willReflowAgain = false;

 #ifdef DEBUG

   if (gNoisyReflow) {

     IndentBy(stdout, gNoiseIndent);

     ListTag(stdout);

     printf(": reflowing dirty lines");

     printf(" computedWidth=%d\n", aState.mReflowState.ComputedWidth());

   }

   AutoNoisyIndenter indent(gNoisyReflow);

 #endif

   bool selfDirty = (GetStateBits() & NS_FRAME_IS_DIRTY) ||

                      (aState.mReflowState.mFlags.mVResize &&

                       (GetStateBits() & NS_FRAME_CONTAINS_RELATIVE_HEIGHT));

   // Reflow our last line if our availableHeight has increased

   // so that we (and our last child) pull up content as necessary

   if (aState.mReflowState.AvailableHeight() != NS_UNCONSTRAINEDSIZE

       && GetNextInFlow() && aState.mReflowState.AvailableHeight() > mRect.height) {

     line_iterator lastLine = end_lines();

     if (lastLine != begin_lines()) {

       --lastLine;

       lastLine->MarkDirty();

     }

   }

     // the amount by which we will slide the current line if it is not

     // dirty

   nscoord deltaY = 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()->GetStateBits() & NS_FRAME_IS_PUSHED_FLOAT);

   bool lastLineMovedUp = false;

   // We save up information about BR-clearance here

   uint8_t inlineFloatBreakType = aState.mFloatBreakType;

   line_iterator line = begin_lines(), line_end = end_lines();

   // Reflow the lines that are already ours

   for ( ; line != line_end; ++line, aState.AdvanceToNextLine()) {

     DumpLine(aState, line, deltaY, 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->GetStateBits() & NS_BLOCK_HAS_CLEAR_CHILDREN)) {

       line->MarkDirty();

     }

     nsIFrame *replacedBlock = nullptr;

     if (line->IsBlock() &&

         !nsBlockFrame::BlockCanIntersectFloats(line->mFirstChild)) {

       replacedBlock = 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->GetBreakTypeBefore() != NS_STYLE_CLEAR_NONE ||

          replacedBlock)) {

       nscoord curY = aState.mY;

       // See where we would be after applying any clearance due to

       // BRs.

       if (inlineFloatBreakType != NS_STYLE_CLEAR_NONE) {

         curY = aState.ClearFloats(curY, inlineFloatBreakType);

       }

       nscoord newY =

         aState.ClearFloats(curY, line->GetBreakTypeBefore(), replacedBlock);

       if (line->HasClearance()) {

         // Reflow the line if it might not have clearance anymore.

         if (newY == curY

             // aState.mY is the clearance point which should be the

             // top border-edge of the block frame. If sliding the

             // block by deltaY isn't going to put it in the predicted

             // position, then we'd better reflow the line.

             || newY != line->BStart() + deltaY) {

           line->MarkDirty();

         }

       } else {

         // Reflow the line if the line might have clearance now.

         if (curY != newY) {

           line->MarkDirty();

         }

       }

     }

     // We might have to reflow a line that is after a clearing BR.

     if (inlineFloatBreakType != NS_STYLE_CLEAR_NONE) {

       aState.mY = aState.ClearFloats(aState.mY, inlineFloatBreakType);

       if (aState.mY != line->BStart() + deltaY) {

         // SlideLine is not going to put the line where the clearance

         // put it. Reflow the line to be sure.

         line->MarkDirty();

       }

       inlineFloatBreakType = NS_STYLE_CLEAR_NONE;

     }

     bool previousMarginWasDirty = line->IsPreviousMarginDirty();

     if (previousMarginWasDirty) {

       // If the previous margin is dirty, reflow the current line

       line->MarkDirty();

       line->ClearPreviousMarginDirty();

     } else if (line->BEnd() + deltaY > aState.mBottomEdge) {

       // Lines that aren't dirty but get slid past our height constraint must

       // be reflowed.

       line->MarkDirty();

     }

     // If we have a constrained height (i.e., breaking columns/pages),

     // and the distance to the bottom might have changed, then we need

     // to reflow any line that might have floats in it, both because the

     // breakpoints within those floats may have changed and because we

     // might have to push/pull the floats in their entirety.

     // FIXME: What about a deltaY or height change that forces us to

     // push lines?  Why does that work?

     if (!line->IsDirty() &&

         aState.mReflowState.AvailableHeight() != NS_UNCONSTRAINEDSIZE &&

         (deltaY != 0 || aState.mReflowState.mFlags.mVResize ||

          aState.mReflowState.mFlags.mMustReflowPlaceholders) &&

         (line->IsBlock() || line->HasFloats() || line->HadFloatPushed())) {

       line->MarkDirty();

     }

     if (!line->IsDirty()) {

       // See if there's any reflow damage that requires that we mark the

       // line dirty.

       PropagateFloatDamage(aState, line, deltaY);

     }

     // If the container width has changed reset the container width. If the

     // line's writing mode is not ltr, or if the line is not left-aligned, also

     // mark the line dirty.

     if (aState.mContainerWidth != line->mContainerWidth) {

       line->mContainerWidth = aState.mContainerWidth;

       bool isLastLine = line == mLines.back() &&

                         !GetNextInFlow() &&

                         NS_STYLE_TEXT_ALIGN_AUTO == StyleText()->mTextAlignLast;

       uint8_t align = isLastLine ?

         StyleText()->mTextAlign : StyleText()->mTextAlignLast;

       if (line->mWritingMode.IsVertical() ||

           !line->mWritingMode.IsBidiLTR() ||

           !IsAlignedLeft(align,

                          aState.mReflowState.mStyleVisibility->mDirection,

                          StyleTextReset()->mUnicodeBidi, this)) {

         line->MarkDirty();

       }

     }

     if (needToRecoverState && line->IsDirty()) {

       // We need to reconstruct the bottom margin only if we didn't

       // reflow the previous line and we do need to reflow (or repair

       // the top position of) the next line.

       aState.ReconstructMarginAbove(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.mY| 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.mReflowState.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 deltaY value - the running value is implicit in

       // aState.mY.

       nscoord oldY = line->BStart();

       nscoord oldYMost = line->BEnd();

       NS_ASSERTION(!willReflowAgain || !line->IsBlock(),

                    "Don't reflow blocks while willReflowAgain is true, reflow of block abs-pos children depends on this");

       // Reflow the dirty line. If it's an incremental reflow, then force

       // it to invalidate the dirty area if necessary

       rv = ReflowLine(aState, line, &keepGoing);

       NS_ENSURE_SUCCESS(rv, rv);

       if (aState.mReflowState.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, deltaY, -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 bottom 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 bottom 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 bottom 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

       // bottom 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

       // ShouldApplyTopMargin decision. The three things that matter

       // are the line's emptiness, its adjacency to the top of the block,

       // and whether it has clearance (the latter only matters if the block

       // was and is adjacent to the top 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->ShouldApplyTopMargin.

       if (line.next() != end_lines()) {

         bool maybeWasEmpty = oldY == 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 |deltaY|

         }

       }

       // If the line was just reflowed for the first time, then its

       // old mBounds cannot be trusted so this deltaY 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 deltaY will not be

       // used.

       deltaY = line->BEnd() - oldYMost;

       // 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 = deltaY < 0;

       if (deltaY != 0)

         SlideLine(aState, line, deltaY);

       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 deltaY.

       } else {

         // XXX EVIL O(N^2) EVIL

         aState.RecoverStateFrom(line, deltaY);

       }

       // Keep mY 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 mY if the line is not

       // empty, because that's what PlaceLine does. (Empty blocks may

       // want to update mY, e.g. if they have clearance.)

       if (line->IsBlock() || !line->CachedIsEmpty()) {

         aState.mY = 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->GetFirstPrincipalChild()) {

           inlineKid->PullOverflowsFromPrevInFlow();

         }

       }

     }

     // Record if we need to clear floats before reflowing the next

     // line. Note that inlineFloatBreakType will be handled and

     // cleared before the next line is processed, so there is no

     // need to combine break types here.

     if (line->HasFloatBreakAfter()) {

       inlineFloatBreakType = line->GetBreakTypeAfter();

     }

     if (LineHasClear(line.get())) {

       foundAnyClears = true;

     }

     DumpLine(aState, line, deltaY, -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 (inlineFloatBreakType != NS_STYLE_CLEAR_NONE) {

     aState.mY = aState.ClearFloats(aState.mY, inlineFloatBreakType);

   }

   if (needToRecoverState) {

     // Is this expensive?

     aState.ReconstructMarginAbove(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.mReflowState.AvailableHeight() != NS_UNCONSTRAINEDSIZE;

   bool skipPull = willReflowAgain && heightConstrained;

   if (!skipPull && heightConstrained && aState.mNextInFlow &&

       (aState.mReflowState.mFlags.mNextInFlowUntouched &&

        !lastLineMovedUp && 

        !(GetStateBits() & 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.) 

     line_iterator lineIter = this->end_lines();

     if (lineIter != this->begin_lines()) {

       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 (IS_TRUE_OVERFLOW_CONTAINER(aState.mNextInFlow))

       NS_FRAME_SET_OVERFLOW_INCOMPLETE(aState.mReflowStatus);

     else

       NS_FRAME_SET_INCOMPLETE(aState.mReflowStatus);

   }

   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 (pulledLine == nextInFlow->GetLineCursor()) {

         nextInFlow->ClearLineCursor();

       }

       ReparentFrames(pulledFrames, nextInFlow, this);

       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, pulledFrames);

       // Add line to our line list, and set its last child as our new prev-child

       line = mLines.before_insert(end_lines(), pulledLine);

       aState.mPrevChild = mFrames.LastChild();

       // Reparent floats whose placeholders are in the line.

       ReparentFloats(pulledLine->mFirstChild, nextInFlow, true);

       DumpLine(aState, pulledLine, deltaY, 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 != end_lines()) {

           rv = ReflowLine(aState, line, &keepGoing);

           NS_ENSURE_SUCCESS(rv, rv);

           if (aState.mReflowState.WillReflowAgainForClearance()) {

             line->MarkDirty();

             keepGoing = false;

             NS_FRAME_SET_INCOMPLETE(aState.mReflowStatus);

             break;

           }

           DumpLine(aState, line, deltaY, -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 (NS_FRAME_IS_NOT_COMPLETE(aState.mReflowStatus)) {

       aState.mReflowStatus |= NS_FRAME_REFLOW_NEXTINFLOW;

     } //XXXfr shouldn't set this flag when nextinflow has no lines

   }

   // Handle an odd-ball case: a list-item with no lines

   if (HasOutsideBullet() && mLines.empty()) {

     nsHTMLReflowMetrics metrics(aState.mReflowState);

     nsIFrame* bullet = GetOutsideBullet();

     ReflowBullet(bullet, aState, metrics,

                  aState.mReflowState.ComputedPhysicalBorderPadding().top);

     NS_ASSERTION(!BulletIsEmpty() || metrics.Height() == 0,

                  "empty bullet took up space");

     if (!BulletIsEmpty()) {

       // There are no lines so we have to fake up some y motion so that

       // we end up with *some* height.

       if (metrics.TopAscent() == nsHTMLReflowMetrics::ASK_FOR_BASELINE) {

         nscoord ascent;

         if (nsLayoutUtils::GetFirstLineBaseline(bullet, &ascent)) {

           metrics.SetTopAscent(ascent);

         } else {

           metrics.SetTopAscent(metrics.Height());

         }

       }

       nsRefPtr<nsFontMetrics> fm;

       nsLayoutUtils::GetFontMetricsForFrame(this, getter_AddRefs(fm),

         nsLayoutUtils::FontSizeInflationFor(this));

       aState.mReflowState.rendContext->SetFont(fm); // FIXME: needed?

       nscoord minAscent =

         nsLayoutUtils::GetCenteredFontBaseline(fm, aState.mMinLineHeight);

       nscoord minDescent = aState.mMinLineHeight - minAscent;

       aState.mY += std::max(minAscent, metrics.TopAscent()) +

                    std::max(minDescent, metrics.Height() - metrics.TopAscent());

       nscoord offset = minAscent - metrics.TopAscent();

       if (offset > 0) {

         bullet->SetRect(bullet->GetRect() + nsPoint(0, offset));

       }

     }

   }

   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=%x)\n",

            aState.mReflowStatus);

   }

 #endif

   return rv;

 }

 static void MarkAllDescendantLinesDirty(nsBlockFrame* aBlock)

 {

   nsLineList::iterator line = aBlock->begin_lines();

   nsLineList::iterator endLine = aBlock->end_lines();

   while (line != endLine) {

     if (line->IsBlock()) {

       nsIFrame* f = line->mFirstChild;

       nsBlockFrame* bf = nsLayoutUtils::GetAsBlock(f);

       if (bf) {

         MarkAllDescendantLinesDirty(bf);

       }

     }

     line->MarkDirty();

     ++line;

   }

 }

 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 (GetStateBits() & 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->AddStateBits(NS_FRAME_IS_DIRTY);

     }

     // And mark all the floats whose reflows we might be skipping dirty too.

     if (aLine->HasFloats()) {

       for (nsFloatCache* fc = aLine->GetFirstFloat(); fc; fc = fc->Next()) {

         fc->mFloat->AddStateBits(NS_FRAME_IS_DIRTY);

       }

     }

   } 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 = nsLayoutUtils::GetAsBlock(aLine->mFirstChild);

     if (bf) {

       MarkAllDescendantLinesDirty(bf);

     }

   }

 }

 void

 nsBlockFrame::DeleteLine(nsBlockReflowState& aState,

                          nsLineList::iterator aLine,

                          nsLineList::iterator aLineEnd)

 {

   NS_PRECONDITION(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.

  */

 nsresult

 nsBlockFrame::ReflowLine(nsBlockReflowState& aState,

                          line_iterator aLine,

                          bool* aKeepReflowGoing)

 {

   nsresult rv = NS_OK;

   NS_ABORT_IF_FALSE(aLine->GetChildCount(), "reflowing empty line");

   // Setup the line-layout for the new line

   aState.mCurrentLine = aLine;

   aLine->ClearDirty();

   aLine->InvalidateCachedIsEmpty();

   aLine->ClearHadFloatPushed();

   // Now that we know what kind of line we have, reflow it

   if (aLine->IsBlock()) {

     rv = ReflowBlockFrame(aState, aLine, aKeepReflowGoing);

   } else {

     aLine->SetLineWrapped(false);

     rv = ReflowInlineFrames(aState, aLine, aKeepReflowGoing);

   }

   return rv;

 }

 nsIFrame*

 nsBlockFrame::PullFrame(nsBlockReflowState& aState,

                         line_iterator       aLine)

 {

   // First check our remaining lines.

   if (end_lines() != 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;

   NS_ABORT_IF_FALSE(fromLine, "bad line to pull from");

   NS_ABORT_IF_FALSE(fromLine->GetChildCount(), "empty line");

   NS_ABORT_IF_FALSE(aLine->GetChildCount(), "empty line");

   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.