Replace ASSERT with DCHECK in core/layout/ excluding subdirs

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 136 matching lines @@
 
 void LayoutBox::willBeRemovedFromTree() {
   if (!documentBeingDestroyed() && isOrthogonalWritingModeRoot())
     unmarkOrthogonalWritingModeRoot();
 
   clearScrollSnapMapping();
   LayoutBoxModelObject::willBeRemovedFromTree();
 }
 
 void LayoutBox::removeFloatingOrPositionedChildFromBlockLists() {
-  ASSERT(isFloatingOrOutOfFlowPositioned());
+  DCHECK(isFloatingOrOutOfFlowPositioned());
 
   if (documentBeingDestroyed())
     return;
 
   if (isFloating()) {
     LayoutBlockFlow* parentBlockFlow = nullptr;
     for (LayoutObject* curr = parent(); curr; curr = curr->parent()) {
       if (curr->isLayoutBlockFlow()) {
         LayoutBlockFlow* currBlockFlow = toLayoutBlockFlow(curr);
         if (!parentBlockFlow || currBlockFlow->containsFloat(this))
@@ skipping 95 matching lines @@
   }
 
   // If our zoom factor changes and we have a defined scrollLeft/Top, we need to
   // adjust that value into the new zoomed coordinate space.  Note that the new
   // scroll offset may be outside the normal min/max range of the scrollable
   // area, which is weird but OK, because the scrollable area will update its
   // min/max in updateAfterLayout().
   if (hasOverflowClip() && oldStyle &&
       oldStyle->effectiveZoom() != newStyle.effectiveZoom()) {
     PaintLayerScrollableArea* scrollableArea = this->getScrollableArea();
-    ASSERT(scrollableArea);
+    DCHECK(scrollableArea);
     // We use getScrollOffset() rather than scrollPosition(), because scroll
     // offset is the distance from the beginning of flow for the box, which is
     // the dimension we want to preserve.
     ScrollOffset oldOffset = scrollableArea->getScrollOffset();
     if (oldOffset.width() || oldOffset.height()) {
       ScrollOffset newOffset = oldOffset.scaledBy(newStyle.effectiveZoom() /
                                                   oldStyle->effectiveZoom());
       scrollableArea->setScrollOffsetUnconditionally(newOffset);
     }
   }
@@ skipping 193 matching lines @@
 void LayoutBox::updateFromStyle() {
   LayoutBoxModelObject::updateFromStyle();
 
   const ComputedStyle& styleToUse = styleRef();
   setFloating(!isOutOfFlowPositioned() && styleToUse.isFloating());
   setHasTransformRelatedProperty(styleToUse.hasTransformRelatedProperty());
   setHasReflection(styleToUse.boxReflect());
 }
 
 void LayoutBox::layout() {
-  ASSERT(needsLayout());
+  DCHECK(needsLayout());
   LayoutAnalyzer::Scope analyzer(*this);
 
   LayoutObject* child = slowFirstChild();
   if (!child) {
     clearNeedsLayout();
     return;
   }
 
   LayoutState state(*this);
   while (child) {
     child->layoutIfNeeded();
-    ASSERT(!child->needsLayout());
+    DCHECK(!child->needsLayout());
     child = child->nextSibling();
   }
   invalidateBackgroundObscurationStatus();
   clearNeedsLayout();
 }
 
 // More IE extensions.  clientWidth and clientHeight represent the interior of
 // an object excluding border and scrollbar.
 DISABLE_CFI_PERF
 LayoutUnit LayoutBox::clientWidth() const {
@@ skipping 131 matching lines @@
     }
   }
   return false;
 }
 
 void LayoutBox::scrollRectToVisible(const LayoutRect& rect,
                                     const ScrollAlignment& alignX,
                                     const ScrollAlignment& alignY,
                                     ScrollType scrollType,
                                     bool makeVisibleInVisualViewport) {
-  ASSERT(scrollType == ProgrammaticScroll || scrollType == UserScroll);
+  DCHECK(scrollType == ProgrammaticScroll || scrollType == UserScroll);
   // Presumably the same issue as in setScrollTop. See crbug.com/343132.
   DisableCompositingQueryAsserts disabler;
 
   LayoutRect rectToScroll = rect;
   if (rectToScroll.width() <= 0)
     rectToScroll.setWidth(LayoutUnit(1));
   if (rectToScroll.height() <= 0)
     rectToScroll.setHeight(LayoutUnit(1));
 
   LayoutBox* parentBox = nullptr;
@@ skipping 420 matching lines @@
 void LayoutBox::scrollByRecursively(const ScrollOffset& delta) {
   if (delta.isZero())
     return;
 
   bool restrictedByLineClamp = false;
   if (parent())
     restrictedByLineClamp = !parent()->style()->lineClamp().isNone();
 
   if (hasOverflowClip() && !restrictedByLineClamp) {
     PaintLayerScrollableArea* scrollableArea = this->getScrollableArea();
-    ASSERT(scrollableArea);
+    DCHECK(scrollableArea);
 
     ScrollOffset newScrollOffset = scrollableArea->getScrollOffset() + delta;
     scrollableArea->setScrollOffset(newScrollOffset, ProgrammaticScroll);
 
     // If this layer can't do the scroll we ask the next layer up that can
     // scroll to try.
     ScrollOffset remainingScrollOffset =
         newScrollOffset - scrollableArea->getScrollOffset();
     if (!remainingScrollOffset.isZero() && parent()) {
       if (LayoutBox* scrollableBox = enclosingScrollableBox())
@@ skipping 26 matching lines @@
   int adjustmentWidth = verticalScrollbarWidth();
   if (hasFlippedBlocksWritingMode() ||
       (isHorizontalWritingMode() &&
        shouldPlaceBlockDirectionScrollbarOnLogicalLeft())) {
     size.expand(adjustmentWidth, 0);
   }
   return size;
 }
 
 IntSize LayoutBox::scrolledContentOffset() const {
-  ASSERT(hasOverflowClip());
-  ASSERT(hasLayer());
+  DCHECK(hasOverflowClip());
+  DCHECK(hasLayer());
   // FIXME: Return DoubleSize here. crbug.com/414283.
   PaintLayerScrollableArea* scrollableArea = getScrollableArea();
   IntSize result =
       scrollableArea->scrollOffsetInt() + originAdjustmentForScrollbars();
   if (isHorizontalWritingMode() &&
       shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
     result.expand(-verticalScrollbarWidth(), 0);
   return result;
 }
 
@@ skipping 46 matching lines @@
   maxLogicalWidth = maxPreferredLogicalWidth() - borderAndPaddingLogicalWidth();
 }
 
 LayoutUnit LayoutBox::minPreferredLogicalWidth() const {
   if (preferredLogicalWidthsDirty()) {
 #if DCHECK_IS_ON()
     SetLayoutNeededForbiddenScope layoutForbiddenScope(
         const_cast<LayoutBox&>(*this));
 #endif
     const_cast<LayoutBox*>(this)->computePreferredLogicalWidths();
-    ASSERT(!preferredLogicalWidthsDirty());
+    DCHECK(!preferredLogicalWidthsDirty());
   }
 
   return m_minPreferredLogicalWidth;
 }
 
 DISABLE_CFI_PERF
 LayoutUnit LayoutBox::maxPreferredLogicalWidth() const {
   if (preferredLogicalWidthsDirty()) {
 #if DCHECK_IS_ON()
     SetLayoutNeededForbiddenScope layoutForbiddenScope(
         const_cast<LayoutBox&>(*this));
 #endif
     const_cast<LayoutBox*>(this)->computePreferredLogicalWidths();
-    ASSERT(!preferredLogicalWidthsDirty());
+    DCHECK(!preferredLogicalWidthsDirty());
   }
 
   return m_maxPreferredLogicalWidth;
 }
 
 bool LayoutBox::hasOverrideLogicalContentHeight() const {
   return m_rareData && m_rareData->m_overrideLogicalContentHeight != -1;
 }
 
 bool LayoutBox::hasOverrideLogicalContentWidth() const {
   return m_rareData && m_rareData->m_overrideLogicalContentWidth != -1;
 }
 
 void LayoutBox::setOverrideLogicalContentHeight(LayoutUnit height) {
-  ASSERT(height >= 0);
+  DCHECK_GE(height, 0);
   ensureRareData().m_overrideLogicalContentHeight = height;
 }
 
 void LayoutBox::setOverrideLogicalContentWidth(LayoutUnit width) {
-  ASSERT(width >= 0);
+  DCHECK_GE(width, 0);
   ensureRareData().m_overrideLogicalContentWidth = width;
 }
 
 void LayoutBox::clearOverrideLogicalContentHeight() {
   if (m_rareData)
     m_rareData->m_overrideLogicalContentHeight = LayoutUnit(-1);
 }
 
 void LayoutBox::clearOverrideLogicalContentWidth() {
   if (m_rareData)
     m_rareData->m_overrideLogicalContentWidth = LayoutUnit(-1);
 }
 
 void LayoutBox::clearOverrideSize() {
   clearOverrideLogicalContentHeight();
   clearOverrideLogicalContentWidth();
 }
 
 LayoutUnit LayoutBox::overrideLogicalContentWidth() const {
-  ASSERT(hasOverrideLogicalContentWidth());
+  DCHECK(hasOverrideLogicalContentWidth());
   return m_rareData->m_overrideLogicalContentWidth;
 }
 
 LayoutUnit LayoutBox::overrideLogicalContentHeight() const {
-  ASSERT(hasOverrideLogicalContentHeight());
+  DCHECK(hasOverrideLogicalContentHeight());
   return m_rareData->m_overrideLogicalContentHeight;
 }
 
 // TODO (lajava) Now that we have implemented these functions based on physical
 // direction, we'd rather remove the logical ones.
 LayoutUnit LayoutBox::overrideContainingBlockContentLogicalWidth() const {
   DCHECK(hasOverrideContainingBlockLogicalWidth());
   return m_rareData->m_overrideContainingBlockContentLogicalWidth;
 }
 
@@ skipping 729 matching lines @@
   // propagate 'fixed' up only if this box is fixed position.
   if (canContainFixedPositionObjects() && !isFixedPos)
     mode &= ~IsFixed;
   else if (isFixedPos)
     mode |= IsFixed;
 
   LayoutBoxModelObject::mapAncestorToLocal(ancestor, transformState, mode);
 }
 
 LayoutSize LayoutBox::offsetFromContainer(const LayoutObject* o) const {
-  ASSERT(o == container());
+  DCHECK_EQ(o, container());
 
   LayoutSize offset;
   if (isInFlowPositioned())
     offset += offsetForInFlowPosition();
 
   offset += physicalLocationOffset();
 
   if (o->hasOverflowClip())
     offset -= toLayoutBox(o)->scrolledContentOffset();
 
@@ skipping 44 matching lines @@
     // Nuke the box.
     box->remove(DontMarkLineBoxes);
     box->destroy();
   } else if (isAtomicInlineLevel()) {
     setLocationAndUpdateOverflowControlsIfNeeded(box->location());
     setInlineBoxWrapper(box);
   }
 }
 
 void LayoutBox::moveWithEdgeOfInlineContainerIfNecessary(bool isHorizontal) {
-  ASSERT(isOutOfFlowPositioned() && container()->isLayoutInline() &&
-         container()->isInFlowPositioned());
+  DCHECK(isOutOfFlowPositioned());
+  DCHECK(container()->isLayoutInline());
+  DCHECK(container()->isInFlowPositioned());
   // If this object is inside a relative positioned inline and its inline
   // position is an explicit offset from the edge of its container then it will
   // need to move if its inline container has changed width. We do not track if
   // the width has changed but if we are here then we are laying out lines
   // inside it, so it probably has - mark our object for layout so that it can
   // move to the new offset created by the new width.
   if (!normalChildNeedsLayout() &&
       !style()->hasStaticInlinePosition(isHorizontal))
     setChildNeedsLayout(MarkOnlyThis);
 }
@@ skipping 163 matching lines @@
     EBreakBetween secondValue) {
   if (fragmentainerBreakPrecedence(secondValue) >=
       fragmentainerBreakPrecedence(firstValue))
     return secondValue;
   return firstValue;
 }
 
 EBreakBetween LayoutBox::classABreakPointValue(
     EBreakBetween previousBreakAfterValue) const {
   // First assert that we're at a class A break point.
-  ASSERT(isBreakBetweenControllable(previousBreakAfterValue));
+  DCHECK(isBreakBetweenControllable(previousBreakAfterValue));
 
   return joinFragmentainerBreakValues(previousBreakAfterValue, breakBefore());
 }
 
 bool LayoutBox::needsForcedBreakBefore(
     EBreakBetween previousBreakAfterValue) const {
   // Forced break values are only honored when specified on in-flow objects, but
   // floats and out-of-flow positioned objects may be affected by a break-after
   // value of the previous in-flow object, even though we're not at a class A
   // break point.
@@ skipping 76 matching lines @@
 
   if (ancestor == this)
     return true;
 
   AncestorSkipInfo skipInfo(ancestor, true);
   LayoutObject* container = this->container(&skipInfo);
   LayoutBox* tableRowContainer = nullptr;
   // Skip table row because cells and rows are in the same coordinate space (see
   // below, however for more comments about when |ancestor| is the table row).
   if (isTableCell()) {
-    DCHECK(container->isTableRow() && parentBox() == container);
+    DCHECK(container->isTableRow());
+    DCHECK_EQ(parentBox(), container);
     if (container != ancestor)
       container = container->parent();
     else
       tableRowContainer = toLayoutBox(container);
   }
   if (!container)
     return true;
 
   LayoutPoint containerOffset;
   if (container->isBox()) {
@@ skipping 110 matching lines @@
   computeLogicalWidth(computedValues);
 
   setLogicalWidth(computedValues.m_extent);
   setLogicalLeft(computedValues.m_position);
   setMarginStart(computedValues.m_margins.m_start);
   setMarginEnd(computedValues.m_margins.m_end);
 }
 
 static float getMaxWidthListMarker(const LayoutBox* layoutObject) {
 #if DCHECK_IS_ON()
-  ASSERT(layoutObject);
+  DCHECK(layoutObject);
   Node* parentNode = layoutObject->generatingNode();
-  ASSERT(parentNode);
-  ASSERT(isHTMLOListElement(parentNode) || isHTMLUListElement(parentNode));
-  ASSERT(layoutObject->style()->textAutosizingMultiplier() != 1);
+  DCHECK(parentNode);
+  DCHECK(isHTMLOListElement(parentNode) || isHTMLUListElement(parentNode));
+  DCHECK_NE(layoutObject->style()->textAutosizingMultiplier(), 1);
 #endif
   float maxWidth = 0;
   for (LayoutObject* child = layoutObject->slowFirstChild(); child;
        child = child->nextSibling()) {
     if (!child->isListItem())
       continue;
 
     LayoutBox* listItem = toLayoutBox(child);
     for (LayoutObject* itemChild = listItem->slowFirstChild(); itemChild;
          itemChild = itemChild->nextSibling()) {
@@ skipping 132 matching lines @@
 LayoutUnit LayoutBox::fillAvailableMeasure(
     LayoutUnit availableLogicalWidth) const {
   LayoutUnit marginStart;
   LayoutUnit marginEnd;
   return fillAvailableMeasure(availableLogicalWidth, marginStart, marginEnd);
 }
 
 LayoutUnit LayoutBox::fillAvailableMeasure(LayoutUnit availableLogicalWidth,
                                            LayoutUnit& marginStart,
                                            LayoutUnit& marginEnd) const {
-  ASSERT(availableLogicalWidth >= 0);
+  DCHECK_GE(availableLogicalWidth, 0);
   marginStart =
       minimumValueForLength(style()->marginStart(), availableLogicalWidth);
   marginEnd =
       minimumValueForLength(style()->marginEnd(), availableLogicalWidth);
   LayoutUnit available = availableLogicalWidth - marginStart - marginEnd;
   available = std::max(available, LayoutUnit());
   return available;
 }
 
 DISABLE_CFI_PERF
@@ skipping 25 matching lines @@
 
   NOTREACHED();
   return LayoutUnit();
 }
 
 DISABLE_CFI_PERF
 LayoutUnit LayoutBox::computeLogicalWidthUsing(SizeType widthType,
                                                const Length& logicalWidth,
                                                LayoutUnit availableLogicalWidth,
                                                const LayoutBlock* cb) const {
-  ASSERT(widthType == MinSize || widthType == MainOrPreferredSize ||
+  DCHECK(widthType == MinSize || widthType == MainOrPreferredSize ||
          !logicalWidth.isAuto());
   if (widthType == MinSize && logicalWidth.isAuto())
     return adjustBorderBoxLogicalWidthForBoxSizing(0);
 
   if (!logicalWidth.isIntrinsicOrAuto()) {
     // FIXME: If the containing block flow is perpendicular to our direction we
     // need to use the available logical height instead.
     return adjustBorderBoxLogicalWidthForBoxSizing(
         valueForLength(logicalWidth, availableLogicalWidth));
   }
@@ skipping 133 matching lines @@
 void LayoutBox::computeMarginsForDirection(MarginDirection flowDirection,
                                            const LayoutBlock* containingBlock,
                                            LayoutUnit containerWidth,
                                            LayoutUnit childWidth,
                                            LayoutUnit& marginStart,
                                            LayoutUnit& marginEnd,
                                            Length marginStartLength,
                                            Length marginEndLength) const {
   // First assert that we're not calling this method on box types that don't
   // support margins.
-  ASSERT(!isTableCell());
-  ASSERT(!isTableRow());
-  ASSERT(!isTableSection());
-  ASSERT(!isLayoutTableCol());
+  DCHECK(!isTableCell());
+  DCHECK(!isTableRow());
+  DCHECK(!isTableSection());
+  DCHECK(!isLayoutTableCol());
   if (flowDirection == BlockDirection || isFloating() || isInline()) {
     // Margins are calculated with respect to the logical width of
     // the containing block (8.3)
     // Inline blocks/tables and floats don't have their margins increased.
     marginStart = minimumValueForLength(marginStartLength, containerWidth);
     marginEnd = minimumValueForLength(marginEndLength, containerWidth);
     return;
   }
 
   if (containingBlock->isFlexibleBox()) {
@@ skipping 189 matching lines @@
           computedValues.m_extent - borderAndPaddingLogicalHeight());
       if (heightResult == -1)
         heightResult = computedValues.m_extent;
       heightResult = constrainLogicalHeightByMinMax(
           heightResult,
           computedValues.m_extent - borderAndPaddingLogicalHeight());
     } else {
       // The only times we don't check min/max height are when a fixed length
       // has been given as an override.  Just use that.  The value has already
       // been adjusted for box-sizing.
-      ASSERT(h.isFixed());
+      DCHECK(h.isFixed());
       heightResult = LayoutUnit(h.value()) + borderAndPaddingLogicalHeight();
     }
 
     computedValues.m_extent = heightResult;
     computeMarginsForDirection(
         flowDirection, cb, containingBlockLogicalWidthForContent(),
         computedValues.m_extent, computedValues.m_margins.m_before,
         computedValues.m_margins.m_after, style()->marginBefore(),
         style()->marginAfter());
   }
@@ skipping 250 matching lines @@
               style()->logicalMaxWidth().isMaxSizeNone()
           ? logicalWidth
           : computeReplacedLogicalWidthUsing(MaxSize,
                                              style()->logicalMaxWidth());
   return std::max(minLogicalWidth, std::min(logicalWidth, maxLogicalWidth));
 }
 
 LayoutUnit LayoutBox::computeReplacedLogicalWidthUsing(
     SizeType sizeType,
     const Length& logicalWidth) const {
-  ASSERT(sizeType == MinSize || sizeType == MainOrPreferredSize ||
+  DCHECK(sizeType == MinSize || sizeType == MainOrPreferredSize ||
          !logicalWidth.isAuto());
   if (sizeType == MinSize && logicalWidth.isAuto())
     return adjustContentBoxLogicalWidthForBoxSizing(LayoutUnit());
 
   switch (logicalWidth.type()) {
     case Fixed:
       return adjustContentBoxLogicalWidthForBoxSizing(logicalWidth.value());
     case MinContent:
     case MaxContent: {
       // MinContent/MaxContent don't need the availableLogicalWidth argument.
@@ skipping 40 matching lines @@
   return LayoutUnit();
 }
 
 LayoutUnit LayoutBox::computeReplacedLogicalHeight(LayoutUnit) const {
   return computeReplacedLogicalHeightRespectingMinMaxHeight(
       computeReplacedLogicalHeightUsing(MainOrPreferredSize,
                                         style()->logicalHeight()));
 }
 
 bool LayoutBox::logicalHeightComputesAsNone(SizeType sizeType) const {
-  ASSERT(sizeType == MinSize || sizeType == MaxSize);
+  DCHECK(sizeType == MinSize || sizeType == MaxSize);
   Length logicalHeight = sizeType == MinSize ? style()->logicalMinHeight()
                                              : style()->logicalMaxHeight();
   Length initialLogicalHeight = sizeType == MinSize
                                     ? ComputedStyle::initialMinSize()
                                     : ComputedStyle::initialMaxSize();
 
   if (logicalHeight == initialLogicalHeight)
     return true;
 
   if (LayoutBlock* cb = containingBlockForAutoHeightDetection(logicalHeight))
@@ skipping 14 matching lines @@
   LayoutUnit maxLogicalHeight = logicalHeight;
   if (!logicalHeightComputesAsNone(MaxSize))
     maxLogicalHeight =
         computeReplacedLogicalHeightUsing(MaxSize, style()->logicalMaxHeight());
   return std::max(minLogicalHeight, std::min(logicalHeight, maxLogicalHeight));
 }
 
 LayoutUnit LayoutBox::computeReplacedLogicalHeightUsing(
     SizeType sizeType,
     const Length& logicalHeight) const {
-  ASSERT(sizeType == MinSize || sizeType == MainOrPreferredSize ||
+  DCHECK(sizeType == MinSize || sizeType == MainOrPreferredSize ||
          !logicalHeight.isAuto());
   if (sizeType == MinSize && logicalHeight.isAuto())
     return adjustContentBoxLogicalHeightForBoxSizing(LayoutUnit());
 
   switch (logicalHeight.type()) {
     case Fixed:
       return adjustContentBoxLogicalHeightForBoxSizing(logicalHeight.value());
     case Percent:
     case Calculated: {
       // TODO(rego): Check if we can somehow reuse
@@ skipping 216 matching lines @@
 
   // Ensure we compute our width based on the width of our rel-pos inline
   // container rather than any anonymous block created to manage a block-flow
   // ancestor of ours in the rel-pos inline's inline flow.
   if (containingBlock->isAnonymousBlock() && containingBlock->isRelPositioned())
     containingBlock = toLayoutBox(containingBlock)->continuation();
   else if (containingBlock->isBox())
     return std::max(LayoutUnit(),
                     toLayoutBox(containingBlock)->clientLogicalWidth());
 
-  ASSERT(containingBlock->isLayoutInline() &&
-         containingBlock->isInFlowPositioned());
+  DCHECK(containingBlock->isLayoutInline());
+  DCHECK(containingBlock->isInFlowPositioned());
 
   const LayoutInline* flow = toLayoutInline(containingBlock);
   InlineFlowBox* first = flow->firstLineBox();
   InlineFlowBox* last = flow->lastLineBox();
 
   // If the containing block is empty, return a width of 0.
   if (!first || !last)
     return LayoutUnit();
 
   LayoutUnit fromLeft;
@@ skipping 36 matching lines @@
   if (hasOverrideContainingBlockLogicalHeight())
     return overrideContainingBlockContentLogicalHeight();
 
   if (containingBlock->isBox()) {
     const LayoutBlock* cb = containingBlock->isLayoutBlock()
                                 ? toLayoutBlock(containingBlock)
                                 : containingBlock->containingBlock();
     return cb->clientLogicalHeight();
   }
 
-  ASSERT(containingBlock->isLayoutInline() &&
-         containingBlock->isInFlowPositioned());
+  DCHECK(containingBlock->isLayoutInline());
+  DCHECK(containingBlock->isInFlowPositioned());
 
   const LayoutInline* flow = toLayoutInline(containingBlock);
   InlineFlowBox* first = flow->firstLineBox();
   InlineFlowBox* last = flow->lastLineBox();
 
   // If the containing block is empty, return a height of 0.
   if (!first || !last)
     return LayoutUnit();
 
   LayoutUnit heightResult;
@@ skipping 262 matching lines @@
     TextDirection containerDirection,
     LayoutUnit containerLogicalWidth,
     LayoutUnit bordersPlusPadding,
     const Length& logicalLeft,
     const Length& logicalRight,
     const Length& marginLogicalLeft,
     const Length& marginLogicalRight,
     LogicalExtentComputedValues& computedValues) const {
   LayoutUnit logicalWidthValue;
 
-  ASSERT(widthSizeType == MinSize || widthSizeType == MainOrPreferredSize ||
+  DCHECK(widthSizeType == MinSize || widthSizeType == MainOrPreferredSize ||
          !logicalWidth.isAuto());
   if (widthSizeType == MinSize && logicalWidth.isAuto())
     logicalWidthValue = LayoutUnit();
   else if (logicalWidth.isIntrinsic())
     logicalWidthValue =
         computeIntrinsicLogicalWidthUsing(logicalWidth, containerLogicalWidth,
                                           bordersPlusPadding) -
         bordersPlusPadding;
   else
     logicalWidthValue = adjustContentBoxLogicalWidthForBoxSizing(
         valueForLength(logicalWidth, containerLogicalWidth));
 
   // 'left' and 'right' cannot both be 'auto' because one would of been
   // converted to the static position already
-  ASSERT(!(logicalLeft.isAuto() && logicalRight.isAuto()));
+  DCHECK(!(logicalLeft.isAuto() && logicalRight.isAuto()));
 
   // minimumValueForLength will convert 'auto' to 0 so that it doesn't impact
   // the available space computation below.
   LayoutUnit logicalLeftValue =
       minimumValueForLength(logicalLeft, containerLogicalWidth);
   LayoutUnit logicalRightValue =
       minimumValueForLength(logicalRight, containerLogicalWidth);
 
   const LayoutUnit containerRelativeLogicalWidth =
       containingBlockLogicalWidthForPositioned(containerBlock, false);
@@ skipping 363 matching lines @@
     Length logicalHeightLength,
     const LayoutBoxModelObject* containerBlock,
     LayoutUnit containerLogicalHeight,
     LayoutUnit bordersPlusPadding,
     LayoutUnit logicalHeight,
     const Length& logicalTop,
     const Length& logicalBottom,
     const Length& marginBefore,
     const Length& marginAfter,
     LogicalExtentComputedValues& computedValues) const {
-  ASSERT(heightSizeType == MinSize || heightSizeType == MainOrPreferredSize ||
+  DCHECK(heightSizeType == MinSize || heightSizeType == MainOrPreferredSize ||
          !logicalHeightLength.isAuto());
   if (heightSizeType == MinSize && logicalHeightLength.isAuto())
     logicalHeightLength = Length(0, Fixed);
 
   // 'top' and 'bottom' cannot both be 'auto' because 'top would of been
   // converted to the static position in computePositionedLogicalHeight()
-  ASSERT(!(logicalTop.isAuto() && logicalBottom.isAuto()));
+  DCHECK(!(logicalTop.isAuto() && logicalBottom.isAuto()));
 
   LayoutUnit logicalHeightValue;
   LayoutUnit contentLogicalHeight = logicalHeight - bordersPlusPadding;
 
   const LayoutUnit containerRelativeLogicalWidth =
       containingBlockLogicalWidthForPositioned(containerBlock, false);
 
   LayoutUnit logicalTopValue;
 
   bool logicalHeightIsAuto = logicalHeightLength.isAuto();
@@ skipping 408 matching lines @@
     SubtreeLayoutScope& layoutScope) {
   DCHECK(!child.needsLayout());
   LayoutState* layoutState = view()->layoutState();
 
   if (layoutState->paginationStateChanged() ||
       (layoutState->isPaginated() && childNeedsRelayoutForPagination(child)))
     layoutScope.setChildNeedsLayout(&child);
 }
 
 void LayoutBox::markOrthogonalWritingModeRoot() {
-  ASSERT(frameView());
+  DCHECK(frameView());
   frameView()->addOrthogonalWritingModeRoot(*this);
 }
 
 void LayoutBox::unmarkOrthogonalWritingModeRoot() {
-  ASSERT(frameView());
+  DCHECK(frameView());
   frameView()->removeOrthogonalWritingModeRoot(*this);
 }
 
 void LayoutBox::addVisualEffectOverflow() {
   if (!style()->hasVisualOverflowingEffect())
     return;
 
   // Add in the final overflow with shadows, outsets and outline combined.
   LayoutRect visualEffectOverflow = borderBoxRect();
   visualEffectOverflow.expand(computeVisualEffectOverflowOutsets());
   addSelfVisualOverflow(visualEffectOverflow);
 }
 
 LayoutRectOutsets LayoutBox::computeVisualEffectOverflowOutsets() {
-  ASSERT(style()->hasVisualOverflowingEffect());
+  DCHECK(style()->hasVisualOverflowingEffect());
 
   LayoutUnit top;
   LayoutUnit right;
   LayoutUnit bottom;
   LayoutUnit left;
 
   if (const ShadowList* boxShadow = style()->boxShadow()) {
     // FIXME: Use LayoutUnit edge outsets, and then simplify this.
     FloatRectOutsets outsets = boxShadow->rectOutsetsIncludingOriginal();
     top = LayoutUnit(outsets.top());
@@ skipping 222 matching lines @@
     return direction == HorizontalLine ? marginHeight() + size().height()
                                        : marginWidth() + size().width();
   return LayoutUnit();
 }
 
 DISABLE_CFI_PERF
 int LayoutBox::baselinePosition(FontBaseline baselineType,
                                 bool /*firstLine*/,
                                 LineDirectionMode direction,
                                 LinePositionMode linePositionMode) const {
-  ASSERT(linePositionMode == PositionOnContainingLine);
+  DCHECK_EQ(linePositionMode, PositionOnContainingLine);
   if (isAtomicInlineLevel()) {
     int result = direction == HorizontalLine
                      ? roundToInt(marginHeight() + size().height())
                      : roundToInt(marginWidth() + size().width());
     if (baselineType == AlphabeticBaseline)
       return result;
     return result - result / 2;
   }
   return 0;
 }
@@ skipping 171 matching lines @@
   LayoutObject* container = this->container();
   while (container && !container->isBox())
     container = container->container();
   return toLayoutBox(container);
 }
 
 LayoutPoint LayoutBox::physicalLocation(
     const LayoutBox* flippedBlocksContainer) const {
   const LayoutBox* containerBox;
   if (flippedBlocksContainer) {
-    DCHECK(flippedBlocksContainer == locationContainer());
+    DCHECK_EQ(flippedBlocksContainer, locationContainer());
     containerBox = flippedBlocksContainer;
   } else {
     containerBox = locationContainer();
   }
   if (!containerBox)
     return location();
   return containerBox->flipForWritingModeForChild(this, location());
 }
 
 bool LayoutBox::hasRelativeLogicalWidth() const {
@@ skipping 49 matching lines @@
       LayoutBox* parentBox = toLayoutBox(boxToSplit->parent());
       // We need to invalidate the |parentBox| before inserting the new node
       // so that the table paint invalidation logic knows the structure is
       // dirty. See for example LayoutTableCell:localVisualRect().
       markBoxForRelayoutAfterSplit(parentBox);
       parentBox->virtualChildren()->insertChildNode(parentBox, postBox,
                                                     boxToSplit->nextSibling());
       boxToSplit->moveChildrenTo(postBox, beforeChild, 0, true);
 
       LayoutObject* child = postBox->slowFirstChild();
-      ASSERT(child);
+      DCHECK(child);
       if (child && !child->nextSibling())
         collapseLoneAnonymousBlockChild(postBox, child);
       child = boxToSplit->slowFirstChild();
-      ASSERT(child);
+      DCHECK(child);
       if (child && !child->nextSibling())
         collapseLoneAnonymousBlockChild(boxToSplit, child);
 
       markBoxForRelayoutAfterSplit(boxToSplit);
       markBoxForRelayoutAfterSplit(postBox);
       boxAtTopOfNewBranch = postBox;
 
       beforeChild = postBox;
     } else {
       beforeChild = boxToSplit;
     }
   }
 
   // Splitting the box means the left side of the container chain will lose any
   // percent height descendants below |boxAtTopOfNewBranch| on the right hand
   // side.
   if (boxAtTopOfNewBranch) {
     boxAtTopOfNewBranch->clearPercentHeightDescendants();
     markBoxForRelayoutAfterSplit(this);
   }
 
-  ASSERT(beforeChild->parent() == this);
+  DCHECK_EQ(beforeChild->parent(), this);
   return beforeChild;
 }
 
 LayoutUnit LayoutBox::offsetFromLogicalTopOfFirstPage() const {
   LayoutState* layoutState = view()->layoutState();
   if (!layoutState || !layoutState->isPaginated())
     return LayoutUnit();
 
   if (layoutState->layoutObject() == this) {
     LayoutSize offset = layoutState->paginationOffset();
     return isHorizontalWritingMode() ? offset.height() : offset.width();
   }
 
   // A LayoutBlock always establishes a layout state, and this method is only
   // meant to be called on the object currently being laid out.
-  ASSERT(!isLayoutBlock());
+  DCHECK(!isLayoutBlock());
 
   // In case this box doesn't establish a layout state, try the containing
   // block.
   LayoutBlock* containerBlock = containingBlock();
-  ASSERT(layoutState->layoutObject() == containerBlock);
+  DCHECK(layoutState->layoutObject() == containerBlock);
   return containerBlock->offsetFromLogicalTopOfFirstPage() + logicalTop();
 }
 
 void LayoutBox::setOffsetToNextPage(LayoutUnit offset) {
   if (!m_rareData && !offset)
     return;
   ensureRareData().m_offsetToNextPage = offset;
 }
 
 void LayoutBox::logicalExtentAfterUpdatingLogicalWidth(
@@ skipping 152 matching lines @@
                                                : nullptr;
 }
 
 void LayoutBox::clearPreviousVisualRects() {
   LayoutBoxModelObject::clearPreviousVisualRects();
   if (PaintLayerScrollableArea* scrollableArea = this->getScrollableArea())
     scrollableArea->clearPreviousVisualRects();
 }
 
 void LayoutBox::setPercentHeightContainer(LayoutBlock* container) {
-  ASSERT(!container || !percentHeightContainer());
+  DCHECK(!container || !percentHeightContainer());
   if (!container && !m_rareData)
     return;
   ensureRareData().m_percentHeightContainer = container;
 }
 
 void LayoutBox::removeFromPercentHeightContainer() {
   if (!percentHeightContainer())
     return;
 
-  ASSERT(percentHeightContainer()->hasPercentHeightDescendant(this));
+  DCHECK(percentHeightContainer()->hasPercentHeightDescendant(this));
   percentHeightContainer()->removePercentHeightDescendant(this);
   // The above call should call this object's
   // setPercentHeightContainer(nullptr).
-  ASSERT(!percentHeightContainer());
+  DCHECK(!percentHeightContainer());
 }
 
 void LayoutBox::clearPercentHeightDescendants() {
   for (LayoutObject* curr = slowFirstChild(); curr;
        curr = curr->nextInPreOrder(this)) {
     if (curr->isBox())
       toLayoutBox(curr)->removeFromPercentHeightContainer();
   }
 }
 
@@ skipping 41 matching lines @@
   if (!pageLogicalHeightForOffset(offset))
     return false;
   return pageRemainingLogicalHeightForOffset(offset, AssociateWithLatterPage) <
          logicalHeight;
 }
 
 LayoutUnit LayoutBox::calculatePaginationStrutToFitContent(
     LayoutUnit offset,
     LayoutUnit strutToNextPage,
     LayoutUnit contentLogicalHeight) const {
-  ASSERT(strutToNextPage ==
-         pageRemainingLogicalHeightForOffset(offset, AssociateWithLatterPage));
+  DCHECK_EQ(strutToNextPage, pageRemainingLogicalHeightForOffset(
+                                 offset, AssociateWithLatterPage));
   // If we're a cell in a row that straddles a page then avoid the repeating
   // header group if necessary.
   if (isTableCell()) {
     const LayoutTableCell* cell = toLayoutTableCell(this);
     if (!cell->row()->isFirstRowInSectionAfterHeader())
       strutToNextPage += cell->table()->rowOffsetFromRepeatingHeader();
   }
   LayoutUnit nextPageLogicalTop = offset + strutToNextPage;
   if (pageLogicalHeightForOffset(nextPageLogicalTop) >= contentLogicalHeight)
     return strutToNextPage;  // Content fits just fine in the next page or
@@ skipping 75 matching lines @@
 
 void LayoutBox::MutableForPainting::
     savePreviousContentBoxSizeAndLayoutOverflowRect() {
   auto& rareData = layoutBox().ensureRareData();
   rareData.m_hasPreviousContentBoxSizeAndLayoutOverflowRect = true;
   rareData.m_previousContentBoxSize = layoutBox().contentBoxRect().size();
   rareData.m_previousLayoutOverflowRect = layoutBox().layoutOverflowRect();
 }
 
 }  // namespace blink