Replace ASSERT with DCHECK in core/layout/ excluding subdirs

third_party/WebKit/Source/core/layout/LayoutBlockFlow.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 115 matching lines @@
   void clearMargin() {
     m_positiveMargin = LayoutUnit();
     m_negativeMargin = LayoutUnit();
   }
   void setHasMarginBeforeQuirk(bool b) { m_hasMarginBeforeQuirk = b; }
   void setHasMarginAfterQuirk(bool b) { m_hasMarginAfterQuirk = b; }
   void setDeterminedMarginBeforeQuirk(bool b) {
     m_determinedMarginBeforeQuirk = b;
   }
   void setPositiveMargin(LayoutUnit p) {
-    ASSERT(!m_discardMargin);
+    DCHECK(!m_discardMargin);
     m_positiveMargin = p;
   }
   void setNegativeMargin(LayoutUnit n) {
-    ASSERT(!m_discardMargin);
+    DCHECK(!m_discardMargin);
     m_negativeMargin = n;
   }
   void setPositiveMarginIfLarger(LayoutUnit p) {
-    ASSERT(!m_discardMargin);
+    DCHECK(!m_discardMargin);
     if (p > m_positiveMargin)
       m_positiveMargin = p;
   }
   void setNegativeMarginIfLarger(LayoutUnit n) {
-    ASSERT(!m_discardMargin);
+    DCHECK(!m_discardMargin);
     if (n > m_negativeMargin)
       m_negativeMargin = n;
   }
 
   void setMargin(LayoutUnit p, LayoutUnit n) {
-    ASSERT(!m_discardMargin);
+    DCHECK(!m_discardMargin);
     m_positiveMargin = p;
     m_negativeMargin = n;
   }
   void setCanCollapseMarginAfterWithChildren(bool collapse) {
     m_canCollapseMarginAfterWithChildren = collapse;
   }
   void setCanCollapseMarginAfterWithLastChild(bool collapse) {
     m_canCollapseMarginAfterWithLastChild = collapse;
   }
   void setDiscardMargin(bool value) { m_discardMargin = value; }
@@ skipping 109 matching lines @@
 bool LayoutBlockFlow::updateLogicalWidthAndColumnWidth() {
   bool relayoutChildren = LayoutBlock::updateLogicalWidthAndColumnWidth();
   if (LayoutMultiColumnFlowThread* flowThread = multiColumnFlowThread()) {
     if (flowThread->needsNewWidth())
       return true;
   }
   return relayoutChildren;
 }
 
 void LayoutBlockFlow::setBreakAtLineToAvoidWidow(int lineToBreak) {
-  ASSERT(lineToBreak >= 0);
+  DCHECK_GE(lineToBreak, 0);
   ensureRareData();
-  ASSERT(!m_rareData->m_didBreakAtLineToAvoidWidow);
+  DCHECK(!m_rareData->m_didBreakAtLineToAvoidWidow);
   m_rareData->m_lineBreakToAvoidWidow = lineToBreak;
 }
 
 void LayoutBlockFlow::setDidBreakAtLineToAvoidWidow() {
-  ASSERT(!shouldBreakAtLineToAvoidWidow());
+  DCHECK(!shouldBreakAtLineToAvoidWidow());
 
   // This function should be called only after a break was applied to avoid
   // widows so assert |m_rareData| exists.
-  ASSERT(m_rareData);
+  DCHECK(m_rareData);
 
   m_rareData->m_didBreakAtLineToAvoidWidow = true;
 }
 
 void LayoutBlockFlow::clearDidBreakAtLineToAvoidWidow() {
   if (!m_rareData)
     return;
 
   m_rareData->m_didBreakAtLineToAvoidWidow = false;
 }
 
 void LayoutBlockFlow::clearShouldBreakAtLineToAvoidWidow() const {
-  ASSERT(shouldBreakAtLineToAvoidWidow());
+  DCHECK(shouldBreakAtLineToAvoidWidow());
   if (!m_rareData)
     return;
 
   m_rareData->m_lineBreakToAvoidWidow = -1;
 }
 
 bool LayoutBlockFlow::isSelfCollapsingBlock() const {
   if (needsLayout()) {
     // Sometimes we don't lay out objects in DOM order (column spanners being
     // one such relevant type of object right here). As long as the object in
     // question establishes a new formatting context, that's nothing to worry
     // about, though.
-    ASSERT(createsNewFormattingContext());
+    DCHECK(createsNewFormattingContext());
     return false;
   }
-  ASSERT(!m_isSelfCollapsing == !checkIfIsSelfCollapsingBlock());
+  DCHECK_EQ(!m_isSelfCollapsing, !checkIfIsSelfCollapsingBlock());
   return m_isSelfCollapsing;
 }
 
 bool LayoutBlockFlow::checkIfIsSelfCollapsingBlock() const {
   // We are not self-collapsing if we
   // (a) have a non-zero height according to layout (an optimization to avoid
   //     wasting time)
   // (b) have border/padding,
   // (c) have a min-height
   // (d) have specified that one of our margins can't collapse using a CSS
   //     extension
   // (e) establish a new block formatting context.
 
   // The early exit must be done before we check for clean layout.
   // We should be able to give a quick answer if the box is a relayout boundary.
   // Being a relayout boundary implies a block formatting context, and also
   // our internal layout shouldn't affect our container in any way.
   if (createsNewFormattingContext())
     return false;
 
   // Placeholder elements are not laid out until the dimensions of their parent
   // text control are known, so they don't get layout until their parent has had
   // layout - this is unique in the layout tree and means when we call
   // isSelfCollapsingBlock on them we find that they still need layout.
-  ASSERT(!needsLayout() ||
+  DCHECK(!needsLayout() ||
          (node() && node()->isElementNode() &&
           toElement(node())->shadowPseudoId() == "-webkit-input-placeholder"));
 
   if (logicalHeight() > LayoutUnit() || borderAndPaddingLogicalHeight() ||
       style()->logicalMinHeight().isPositive() ||
       style()->marginBeforeCollapse() == MarginCollapseSeparate ||
       style()->marginAfterCollapse() == MarginCollapseSeparate)
     return false;
 
   Length logicalHeightLength = style()->logicalHeight();
@@ skipping 28 matching lines @@
       if (!child->isSelfCollapsingBlock())
         return false;
     }
     return true;
   }
   return false;
 }
 
 DISABLE_CFI_PERF
 void LayoutBlockFlow::layoutBlock(bool relayoutChildren) {
-  ASSERT(needsLayout());
-  ASSERT(isInlineBlockOrInlineTable() || !isInline());
+  DCHECK(needsLayout());
+  DCHECK(isInlineBlockOrInlineTable() || !isInline());
 
   if (!relayoutChildren && simplifiedLayout())
     return;
 
   LayoutAnalyzer::BlockScope analyzer(*this);
   SubtreeLayoutScope layoutScope(*this);
 
   LayoutUnit previousHeight = logicalHeight();
   LayoutUnit oldLeft = logicalLeft();
   bool logicalWidthChanged = updateLogicalWidthAndColumnWidth();
@@ skipping 552 matching lines @@
   LayoutUnit logicalTopAfterPagination =
       std::max(logicalTopWithContentStrut, logicalTopAfterUnsplittable);
   LayoutUnit newLogicalTop = logicalTop;
 
   // Forced breaks may already have caused a strut, and this needs to be added
   // together with any strut detected here in this method.
   LayoutUnit previousStrut = child.paginationStrut();
 
   if (LayoutUnit paginationStrut =
           logicalTopAfterPagination - logicalTop + previousStrut) {
-    ASSERT(paginationStrut > 0);
+    DCHECK_GT(paginationStrut, 0);
     // If we're not at the first in-flow child, there's a class A break point
     // before the child. If we *are* at the first in-flow child, but the child
     // isn't flush with the content edge of its container, due to e.g.
     // clearance, there's a class C break point before the child. Otherwise we
     // should propagate the strut to our parent block, and attempt to break
     // there instead. See https://drafts.csswg.org/css-break/#possible-breaks
     bool canBreak = !layoutInfo.isAtFirstInFlowChild() || !atBeforeSideOfBlock;
     if (!canBreak && child.getPaginationBreakability() == ForbidBreaks &&
         !allowsPaginationStrut()) {
       // The child is monolithic content, e.g. an image. It is truly
@@ skipping 389 matching lines @@
             LayoutUnit oldLogicalTop = logicalTopForFloat(*oldFloatingObject);
             if (logicalTop != oldLogicalTop) {
               changeLogicalTop = std::min(changeLogicalTop,
                                           std::min(logicalTop, oldLogicalTop));
               changeLogicalBottom = std::max(
                   changeLogicalBottom, std::max(logicalTop, oldLogicalTop));
             }
           }
 
           if (oldFloatingObject->originatingLine() && !selfNeedsLayout()) {
-            ASSERT(oldFloatingObject->originatingLine()
+            DCHECK(oldFloatingObject->originatingLine()
                        ->getLineLayoutItem()
                        .isEqual(this));
             oldFloatingObject->originatingLine()->markDirty();
           }
 
           floatMap.erase(floatingObject.layoutObject());
         } else {
           changeLogicalTop = LayoutUnit();
           changeLogicalBottom = std::max(changeLogicalBottom, logicalBottom);
         }
@@ skipping 113 matching lines @@
                        LayoutUnit afterBorderPadding)
     : m_canCollapseMarginAfterWithLastChild(true),
       m_atBeforeSideOfBlock(true),
       m_atAfterSideOfBlock(false),
       m_hasMarginBeforeQuirk(false),
       m_hasMarginAfterQuirk(false),
       m_determinedMarginBeforeQuirk(false),
       m_discardMargin(false),
       m_lastChildIsSelfCollapsingBlockWithClearance(false) {
   const ComputedStyle& blockStyle = blockFlow->styleRef();
-  ASSERT(blockFlow->isLayoutView() || blockFlow->parent());
+  DCHECK(blockFlow->isLayoutView() || blockFlow->parent());
   m_canCollapseWithChildren = !blockFlow->createsNewFormattingContext() &&
                               !blockFlow->isLayoutFlowThread() &&
                               !blockFlow->isLayoutView();
 
   m_canCollapseMarginBeforeWithChildren =
       m_canCollapseWithChildren && !beforeBorderPadding &&
       blockStyle.marginBeforeCollapse() != MarginCollapseSeparate;
 
   // If any height other than auto is specified in CSS, then we don't collapse
   // our bottom margins with our children's margins. To do otherwise would be to
@@ skipping 234 matching lines @@
       if (!marginInfo.canCollapseWithMarginBefore()) {
         // We need to make sure that the position of the self-collapsing block
         // is correct, since it could have overflowing content
         // that needs to be positioned correctly (e.g., a block that
         // had a specified height of 0 but that actually had subcontent).
         logicalTop = logicalHeight() + collapsedBeforePos - collapsedBeforeNeg;
       }
     }
   } else {
     if (mustSeparateMarginBeforeForChild(child)) {
-      ASSERT(!marginInfo.discardMargin() ||
+      DCHECK(!marginInfo.discardMargin() ||
              (marginInfo.discardMargin() && !marginInfo.margin()));
       // If we are at the before side of the block and we collapse, ignore the
       // computed margin and just add the child margin to the container height.
       // This will correctly position the child inside the container.
       LayoutUnit separateMargin = !marginInfo.canCollapseWithMarginBefore()
                                       ? marginInfo.margin()
                                       : LayoutUnit();
       setLogicalHeight(logicalHeight() + separateMargin +
                        marginBeforeForChild(child));
       logicalTop = logicalHeight();
@@ skipping 388 matching lines @@
                                              LayoutUnit afterSide,
                                              MarginInfo& marginInfo) {
   marginInfo.setAtAfterSideOfBlock(true);
 
   // If our last child was a self-collapsing block with clearance then our
   // logical height is flush with the bottom edge of the float that the child
   // clears. The correct vertical position for the margin-collapsing we want to
   // perform now is at the child's margin-top - so adjust our height to that
   // position.
   if (marginInfo.lastChildIsSelfCollapsingBlockWithClearance()) {
-    ASSERT(lastChild);
+    DCHECK(lastChild);
     setLogicalHeight(logicalHeight() -
                      marginValuesForChild(*lastChild).positiveMarginBefore());
   }
 
   if (marginInfo.canCollapseMarginAfterWithChildren() &&
       !marginInfo.canCollapseMarginAfterWithLastChild())
     marginInfo.setCanCollapseMarginAfterWithChildren(false);
 
   // If we can't collapse with children then go ahead and add in the bottom
   // margin.
@@ skipping 19 matching lines @@
   // siblings. So propagate the break-after value, and keep looking for a class
   // A break point (at the next in-flow block-level object), where we'll join
   // this break-after value with the break-before value there.
   if (view()->layoutState()->isPaginated() && lastChild)
     setBreakAfter(
         joinFragmentainerBreakValues(breakAfter(), lastChild->breakAfter()));
 }
 
 void LayoutBlockFlow::setMustDiscardMarginBefore(bool value) {
   if (style()->marginBeforeCollapse() == MarginCollapseDiscard) {
-    ASSERT(value);
+    DCHECK(value);
     return;
   }
 
   if (!m_rareData && !value)
     return;
 
   if (!m_rareData)
     m_rareData = WTF::makeUnique<LayoutBlockFlowRareData>(this);
 
   m_rareData->m_discardMarginBefore = value;
 }
 
 void LayoutBlockFlow::setMustDiscardMarginAfter(bool value) {
   if (style()->marginAfterCollapse() == MarginCollapseDiscard) {
-    ASSERT(value);
+    DCHECK(value);
     return;
   }
 
   if (!m_rareData && !value)
     return;
 
   if (!m_rareData)
     m_rareData = WTF::makeUnique<LayoutBlockFlowRareData>(this);
 
   m_rareData->m_discardMarginAfter = value;
 }
 
 bool LayoutBlockFlow::mustDiscardMarginBefore() const {
   return style()->marginBeforeCollapse() == MarginCollapseDiscard ||
          (m_rareData && m_rareData->m_discardMarginBefore);
 }
 
 bool LayoutBlockFlow::mustDiscardMarginAfter() const {
   return style()->marginAfterCollapse() == MarginCollapseDiscard ||
          (m_rareData && m_rareData->m_discardMarginAfter);
 }
 
 bool LayoutBlockFlow::mustDiscardMarginBeforeForChild(
     const LayoutBox& child) const {
-  ASSERT(!child.selfNeedsLayout());
+  DCHECK(!child.selfNeedsLayout());
   if (!child.isWritingModeRoot())
     return child.isLayoutBlockFlow()
                ? toLayoutBlockFlow(&child)->mustDiscardMarginBefore()
                : (child.style()->marginBeforeCollapse() ==
                   MarginCollapseDiscard);
   if (child.isHorizontalWritingMode() == isHorizontalWritingMode())
     return child.isLayoutBlockFlow()
                ? toLayoutBlockFlow(&child)->mustDiscardMarginAfter()
                : (child.style()->marginAfterCollapse() ==
                   MarginCollapseDiscard);
 
   // FIXME: We return false here because the implementation is not geometrically
   // complete. We have values only for before/after, not start/end.
   // In case the boxes are perpendicular we assume the property is not
   // specified.
   return false;
 }
 
 bool LayoutBlockFlow::mustDiscardMarginAfterForChild(
     const LayoutBox& child) const {
-  ASSERT(!child.selfNeedsLayout());
+  DCHECK(!child.selfNeedsLayout());
   if (!child.isWritingModeRoot())
     return child.isLayoutBlockFlow()
                ? toLayoutBlockFlow(&child)->mustDiscardMarginAfter()
                : (child.style()->marginAfterCollapse() ==
                   MarginCollapseDiscard);
   if (child.isHorizontalWritingMode() == isHorizontalWritingMode())
     return child.isLayoutBlockFlow()
                ? toLayoutBlockFlow(&child)->mustDiscardMarginBefore()
                : (child.style()->marginBeforeCollapse() ==
                   MarginCollapseDiscard);
@@ skipping 19 matching lines @@
         neg == LayoutBlockFlowRareData::negativeMarginAfterDefault(this))
       return;
     m_rareData = WTF::makeUnique<LayoutBlockFlowRareData>(this);
   }
   m_rareData->m_margins.setPositiveMarginAfter(pos);
   m_rareData->m_margins.setNegativeMarginAfter(neg);
 }
 
 bool LayoutBlockFlow::mustSeparateMarginBeforeForChild(
     const LayoutBox& child) const {
-  ASSERT(!child.selfNeedsLayout());
+  DCHECK(!child.selfNeedsLayout());
   const ComputedStyle& childStyle = child.styleRef();
   if (!child.isWritingModeRoot())
     return childStyle.marginBeforeCollapse() == MarginCollapseSeparate;
   if (child.isHorizontalWritingMode() == isHorizontalWritingMode())
     return childStyle.marginAfterCollapse() == MarginCollapseSeparate;
 
   // FIXME: See |mustDiscardMarginBeforeForChild| above.
   return false;
 }
 
 bool LayoutBlockFlow::mustSeparateMarginAfterForChild(
     const LayoutBox& child) const {
-  ASSERT(!child.selfNeedsLayout());
+  DCHECK(!child.selfNeedsLayout());
   const ComputedStyle& childStyle = child.styleRef();
   if (!child.isWritingModeRoot())
     return childStyle.marginAfterCollapse() == MarginCollapseSeparate;
   if (child.isHorizontalWritingMode() == isHorizontalWritingMode())
     return childStyle.marginBeforeCollapse() == MarginCollapseSeparate;
 
   // FIXME: See |mustDiscardMarginBeforeForChild| above.
   return false;
 }
 
@@ skipping 159 matching lines @@
 
 void LayoutBlockFlow::deleteLineBoxTree() {
   if (containsFloats())
     m_floatingObjects->clearLineBoxTreePointers();
 
   m_lineBoxes.deleteLineBoxTree();
 }
 
 int LayoutBlockFlow::lineCount(const RootInlineBox* stopRootInlineBox) const {
 #ifndef NDEBUG
-  ASSERT(!stopRootInlineBox ||
+  DCHECK(!stopRootInlineBox ||
          stopRootInlineBox->block().debugPointer() == this);
 #endif
   if (!childrenInline())
     return 0;
 
   int count = 0;
   for (const RootInlineBox* box = firstRootBox(); box;
        box = box->nextRootBox()) {
     count++;
     if (box == stopRootInlineBox)
@@ skipping 212 matching lines @@
         // addition of overhanging floats from previous siblings when negative
         // margins exist on a child (see the addOverhangingFloats call at the
         // end of collapseMargins).
         if (childLogicalWidthAtOldLogicalTopOffset !=
             childLogicalWidthAtNewLogicalTopOffset)
           child->setChildNeedsLayout(MarkOnlyThis);
         return newLogicalTop - logicalTop;
       }
 
       newLogicalTop = nextFloatLogicalBottomBelowForBlock(newLogicalTop);
-      ASSERT(newLogicalTop >= logicalTop);
+      DCHECK_GE(newLogicalTop, logicalTop);
       if (newLogicalTop < logicalTop)
         break;
     }
     NOTREACHED();
   }
   return result;
 }
 
 void LayoutBlockFlow::createFloatingObjects() {
   m_floatingObjects =
@@ skipping 165 matching lines @@
   LayoutBoxModelObject* continuation = this->continuation();
   return continuation && continuation->isInline() ? toLayoutInline(continuation)
                                                   : nullptr;
 }
 
 void LayoutBlockFlow::addChild(LayoutObject* newChild,
                                LayoutObject* beforeChild) {
   if (LayoutMultiColumnFlowThread* flowThread = multiColumnFlowThread()) {
     if (beforeChild == flowThread)
       beforeChild = flowThread->firstChild();
-    ASSERT(!beforeChild || beforeChild->isDescendantOf(flowThread));
+    DCHECK(!beforeChild || beforeChild->isDescendantOf(flowThread));
     flowThread->addChild(newChild, beforeChild);
     return;
   }
 
   if (beforeChild && beforeChild->parent() != this) {
     addChildBeforeDescendant(newChild, beforeChild);
     return;
   }
 
   bool madeBoxesNonInline = false;
 
   // A block has to either have all of its children inline, or all of its
   // children as blocks.
   // So, if our children are currently inline and a block child has to be
   // inserted, we move all our inline children into anonymous block boxes.
   bool childIsBlockLevel =
       !newChild->isInline() && !newChild->isFloatingOrOutOfFlowPositioned();
   if (childrenInline()) {
     if (childIsBlockLevel) {
       // Wrap the inline content in anonymous blocks, to allow for the new block
       // child to be inserted.
       makeChildrenNonInline(beforeChild);
       madeBoxesNonInline = true;
 
       if (beforeChild && beforeChild->parent() != this) {
         beforeChild = beforeChild->parent();
-        ASSERT(beforeChild->isAnonymousBlock());
-        ASSERT(beforeChild->parent() == this);
+        DCHECK(beforeChild->isAnonymousBlock());
+        DCHECK_EQ(beforeChild->parent(), this);
       }
     }
   } else if (!childIsBlockLevel) {
     // This block has block children. We may want to put the new child into an
     // anomyous block. Floats and out-of-flow children may live among either
     // block or inline children, so for such children, only put them inside an
     // anonymous block if one already exists. If the child is inline, on the
     // other hand, we *have to* put it inside an anonymous block, so create a
     // new one if there is none for us there already.
     LayoutObject* afterChild =
@@ skipping 212 matching lines @@
 
   if (!isMergeableAnonymousBlock(this) ||
       !isMergeableAnonymousBlock(siblingThatMayBeDeleted))
     return false;
 
   setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(
       LayoutInvalidationReason::AnonymousBlockChange);
 
   // If the inlineness of children of the two block don't match, we'd need
   // special code here (but there should be no need for it).
-  ASSERT(siblingThatMayBeDeleted->childrenInline() == childrenInline());
+  DCHECK_EQ(siblingThatMayBeDeleted->childrenInline(), childrenInline());
   // Take all the children out of the |next| block and put them in
   // the |prev| block.
   siblingThatMayBeDeleted->moveAllChildrenIncludingFloatsTo(
       this, siblingThatMayBeDeleted->hasLayer() || hasLayer());
   // Delete the now-empty block's lines and nuke it.
   siblingThatMayBeDeleted->deleteLineBoxTree();
   siblingThatMayBeDeleted->destroy();
   return true;
 }
 
@@ skipping 124 matching lines @@
 }
 
 void LayoutBlockFlow::makeChildrenNonInline(LayoutObject* insertionPoint) {
   // makeChildrenNonInline takes a block whose children are *all* inline and it
   // makes sure that inline children are coalesced under anonymous blocks.
   // If |insertionPoint| is defined, then it represents the insertion point for
   // the new block child that is causing us to have to wrap all the inlines.
   // This means that we cannot coalesce inlines before |insertionPoint| with
   // inlines following |insertionPoint|, because the new child is going to be
   // inserted in between the inlines, splitting them.
-  ASSERT(!isInline() || isAtomicInlineLevel());
-  ASSERT(!insertionPoint || insertionPoint->parent() == this);
+  DCHECK(!isInline() || isAtomicInlineLevel());
+  DCHECK(!insertionPoint || insertionPoint->parent() == this);
 
   setChildrenInline(false);
 
   LayoutObject* child = firstChild();
   if (!child)
     return;
 
   deleteLineBoxTree();
 
   while (child) {
     LayoutObject* inlineRunStart;
     LayoutObject* inlineRunEnd;
     getInlineRun(child, insertionPoint, inlineRunStart, inlineRunEnd);
 
     if (!inlineRunStart)
       break;
 
     child = inlineRunEnd->nextSibling();
 
     LayoutBlock* block = createAnonymousBlock();
     children()->insertChildNode(this, block, inlineRunStart);
     moveChildrenTo(block, inlineRunStart, child);
   }
 
 #if DCHECK_IS_ON()
   for (LayoutObject* c = firstChild(); c; c = c->nextSibling())
-    ASSERT(!c->isInline());
+    DCHECK(!c->isInline());
 #endif
 
   setShouldDoFullPaintInvalidation();
 }
 
 void LayoutBlockFlow::childBecameNonInline(LayoutObject*) {
   makeChildrenNonInline();
   if (isAnonymousBlock() && parent() && parent()->isLayoutBlock())
     toLayoutBlock(parent())->removeLeftoverAnonymousBlock(this);
   // |this| may be dead here
@@ skipping 129 matching lines @@
     // Use the original width of the float here, since the local variable
     // |floatLogicalWidth| was capped to the available line width. See
     // fast/block/float/clamped-right-float.html.
     floatLogicalLeft -= logicalWidthForFloat(floatingObject);
   }
 
   return LayoutPoint(floatLogicalLeft, logicalTopOffset);
 }
 
 FloatingObject* LayoutBlockFlow::insertFloatingObject(LayoutBox& floatBox) {
-  ASSERT(floatBox.isFloating());
+  DCHECK(floatBox.isFloating());
 
   // Create the list of special objects if we don't aleady have one
   if (!m_floatingObjects) {
     createFloatingObjects();
   } else {
     // Don't insert the object again if it's already in the list
     const FloatingObjectSet& floatingObjectSet = m_floatingObjects->set();
     FloatingObjectSetIterator it =
         floatingObjectSet.find<FloatingObjectHashTranslator>(&floatBox);
     if (it != floatingObjectSet.end())
@@ skipping 22 matching lines @@
             logicalTop == LayoutUnit::max()) {
           logicalBottom = LayoutUnit::max();
         } else {
           // Special-case zero- and less-than-zero-height floats: those don't
           // touch the line that they're on, but it still needs to be dirtied.
           // This is accomplished by pretending they have a height of 1.
           logicalBottom = std::max(logicalBottom, logicalTop + 1);
         }
         if (floatingObject.originatingLine()) {
           if (!selfNeedsLayout()) {
-            ASSERT(
+            DCHECK(
                 floatingObject.originatingLine()->getLineLayoutItem().isEqual(
                     this));
             floatingObject.originatingLine()->markDirty();
           }
 #if DCHECK_IS_ON()
           floatingObject.setOriginatingLine(nullptr);
 #endif
         }
         markLinesDirtyInBlockRange(LayoutUnit(), logicalBottom);
       }
@@ skipping 198 matching lines @@
       floatingObjectSet.find<FloatingObjectHashTranslator>(layoutBox);
   if (it == floatingObjectSet.end())
     return false;
 
   return isOverhangingFloat(**it);
 }
 
 void LayoutBlockFlow::addIntrudingFloats(LayoutBlockFlow* prev,
                                          LayoutUnit logicalLeftOffset,
                                          LayoutUnit logicalTopOffset) {
-  ASSERT(!avoidsFloats());
+  DCHECK(!avoidsFloats());
 
   // If we create our own block formatting context then our contents don't
   // interact with floats outside it, even those from our parent.
   if (createsNewFormattingContext())
     return;
 
   // If the parent or previous sibling doesn't have any floats to add, don't
   // bother.
   if (!prev->m_floatingObjects)
     return;
@@ skipping 248 matching lines @@
     LayoutUnit logicalHeight) const {
   if (m_floatingObjects && m_floatingObjects->hasRightObjects())
     return m_floatingObjects->logicalRightOffset(fixedOffset, logicalTop,
                                                  logicalHeight);
 
   return fixedOffset;
 }
 
 void LayoutBlockFlow::updateAncestorShouldPaintFloatingObject(
     const LayoutBox& floatBox) {
-  ASSERT(floatBox.isFloating());
+  DCHECK(floatBox.isFloating());
   bool floatBoxIsSelfPaintingLayer =
       floatBox.hasLayer() && floatBox.layer()->isSelfPaintingLayer();
   for (LayoutObject* ancestor = floatBox.parent();
        ancestor && ancestor->isLayoutBlockFlow();
        ancestor = ancestor->parent()) {
     LayoutBlockFlow* ancestorBlock = toLayoutBlockFlow(ancestor);
     FloatingObjects* ancestorFloatingObjects =
         ancestorBlock->m_floatingObjects.get();
     if (!ancestorFloatingObjects)
       break;
@@ skipping 185 matching lines @@
 void LayoutBlockFlow::createOrDestroyMultiColumnFlowThreadIfNeeded(
     const ComputedStyle* oldStyle) {
   // Paged overflow trumps multicol in this implementation. Ideally, it should
   // be possible to have both paged overflow and multicol on the same element,
   // but then we need two flow threads. Anyway, this is nothing to worry about
   // until we can actually nest multicol properly inside other fragmentation
   // contexts.
   FlowThreadType type = getFlowThreadType(styleRef());
 
   if (multiColumnFlowThread()) {
-    ASSERT(oldStyle);
+    DCHECK(oldStyle);
     if (type != getFlowThreadType(*oldStyle)) {
       // If we're no longer to be multicol/paged, destroy the flow thread. Also
       // destroy it when switching between multicol and paged, since that
       // affects the column set structure (multicol containers may have
       // spanners, paged containers may not).
       multiColumnFlowThread()->evacuateAndDestroy();
-      ASSERT(!multiColumnFlowThread());
+      DCHECK(!multiColumnFlowThread());
       m_paginationStateChanged = true;
     }
   }
 
   if (type == NoFlowThread || multiColumnFlowThread())
     return;
 
   // Ruby elements manage child insertion in a special way, and would mess up
   // insertion of the flow thread. The flow thread needs to be a direct child of
   // the multicol block (|this|).
@@ skipping 10 matching lines @@
   // support multicol.
   if (isFileUploadControl() || isTextControl() || isListBox())
     return;
 
   LayoutMultiColumnFlowThread* flowThread = createMultiColumnFlowThread(type);
   addChild(flowThread);
   m_paginationStateChanged = true;
 
   // Check that addChild() put the flow thread as a direct child, and didn't do
   // fancy things.
-  ASSERT(flowThread->parent() == this);
+  DCHECK_EQ(flowThread->parent(), this);
 
   flowThread->populate();
   LayoutBlockFlowRareData& rareData = ensureRareData();
-  ASSERT(!rareData.m_multiColumnFlowThread);
+  DCHECK(!rareData.m_multiColumnFlowThread);
   rareData.m_multiColumnFlowThread = flowThread;
 }
 
 LayoutBlockFlow::LayoutBlockFlowRareData& LayoutBlockFlow::ensureRareData() {
   if (m_rareData)
     return *m_rareData;
 
   m_rareData = WTF::makeUnique<LayoutBlockFlowRareData>(this);
   return *m_rareData;
 }
 
 void LayoutBlockFlow::positionDialog() {
   HTMLDialogElement* dialog = toHTMLDialogElement(node());
   if (dialog->getCenteringMode() == HTMLDialogElement::NotCentered)
     return;
 
   bool canCenterDialog = (style()->position() == EPosition::kAbsolute ||
                           style()->position() == EPosition::kFixed) &&
                          style()->hasAutoTopAndBottom();
 
   if (dialog->getCenteringMode() == HTMLDialogElement::Centered) {
     if (canCenterDialog)
       setY(dialog->centeredPosition());
     return;
   }
 
-  ASSERT(dialog->getCenteringMode() == HTMLDialogElement::NeedsCentering);
+  DCHECK_EQ(dialog->getCenteringMode(), HTMLDialogElement::NeedsCentering);
   if (!canCenterDialog) {
     dialog->setNotCentered();
     return;
   }
 
   FrameView* frameView = document().view();
   LayoutUnit top = LayoutUnit((style()->position() == EPosition::kFixed)
                                   ? 0
                                   : frameView->scrollOffsetInt().height());
   int visibleHeight = frameView->visibleContentRect(IncludeScrollbars).height();
   if (size().height() < visibleHeight)
     top += (visibleHeight - size().height()) / 2;
   setY(top);
   dialog->setCentered(top);
 }
 
 void LayoutBlockFlow::simplifiedNormalFlowInlineLayout() {
-  ASSERT(childrenInline());
+  DCHECK(childrenInline());
   ListHashSet<RootInlineBox*> lineBoxes;
   for (InlineWalker walker(LineLayoutBlockFlow(this)); !walker.atEnd();
        walker.advance()) {
     LayoutObject* o = walker.current().layoutObject();
     if (!o->isOutOfFlowPositioned() &&
         (o->isAtomicInlineLevel() || o->isFloating())) {
       o->layoutIfNeeded();
       if (toLayoutBox(o)->inlineBoxWrapper()) {
         RootInlineBox& box = toLayoutBox(o)->inlineBoxWrapper()->root();
         lineBoxes.insert(&box);
       }
     } else if (o->isText() ||
                (o->isLayoutInline() && !walker.atEndOfInline())) {
       o->clearNeedsLayout();
     }
   }
 
   // FIXME: Glyph overflow will get lost in this case, but not really a big
   // deal.
   GlyphOverflowAndFallbackFontsMap textBoxDataMap;
   for (ListHashSet<RootInlineBox*>::const_iterator it = lineBoxes.begin();
        it != lineBoxes.end(); ++it) {
     RootInlineBox* box = *it;
     box->computeOverflow(box->lineTop(), box->lineBottom(), textBoxDataMap);
   }
 }
 
 bool LayoutBlockFlow::recalcInlineChildrenOverflowAfterStyleChange() {
-  ASSERT(childrenInline());
+  DCHECK(childrenInline());
   bool childrenOverflowChanged = false;
   ListHashSet<RootInlineBox*> lineBoxes;
   for (InlineWalker walker(LineLayoutBlockFlow(this)); !walker.atEnd();
        walker.advance()) {
     LayoutObject* layoutObject = walker.current().layoutObject();
     if (recalcNormalFlowChildOverflowIfNeeded(layoutObject)) {
       childrenOverflowChanged = true;
       if (InlineBox* inlineBoxWrapper =
               toLayoutBlock(layoutObject)->inlineBoxWrapper())
         lineBoxes.insert(&inlineBoxWrapper->root());
@@ skipping 120 matching lines @@
       point = point.transposedPoint();
     if (closestBox->getLineLayoutItem().isAtomicInlineLevel())
       return positionForPointRespectingEditingBoundaries(
           LineLayoutBox(closestBox->getLineLayoutItem()), point);
     return closestBox->getLineLayoutItem().positionForPoint(point);
   }
 
   if (lastRootBoxWithChildren) {
     // We hit this case for Mac behavior when the Y coordinate is below the last
     // box.
-    ASSERT(moveCaretToBoundary);
+    DCHECK(moveCaretToBoundary);
     InlineBox* logicallyLastBox;
     if (lastRootBoxWithChildren->getLogicalEndBoxWithNode(logicallyLastBox))
       return PositionWithAffinity(positionForBox(logicallyLastBox, false));
   }
 
   // Can't reach this. We have a root line box, but it has no kids.
   // FIXME: This should NOTREACHED(), but clicking on placeholder text
   // seems to hit this code path.
   return createPositionWithAffinity(0);
 }
@@ skipping 76 matching lines @@
   return LayoutBlock::invalidatePaintIfNeeded(paintInvalidationState);
 }
 
 void LayoutBlockFlow::invalidateDisplayItemClients(
     PaintInvalidationReason invalidationReason) const {
   BlockFlowPaintInvalidator(*this).invalidateDisplayItemClients(
       invalidationReason);
 }
 
 }  // namespace blink