Replace ASSERT with DCHECK in core/layout/<sub dirs>

third_party/WebKit/Source/core/layout/line/InlineFlowBox.cpp

 /*
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc.
  *               All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 73 matching lines @@
     const ComputedStyle& parentStyle,
     const ComputedStyle& childStyle,
     bool isRoot) {
   return parentStyle.hasIdenticalAscentDescentAndLineGap(childStyle) &&
          parentStyle.lineHeight() == childStyle.lineHeight() &&
          (parentStyle.verticalAlign() == EVerticalAlign::kBaseline || isRoot) &&
          childStyle.verticalAlign() == EVerticalAlign::kBaseline;
 }
 
 void InlineFlowBox::addToLine(InlineBox* child) {
-  ASSERT(!child->parent());
-  ASSERT(!child->nextOnLine());
-  ASSERT(!child->prevOnLine());
+  DCHECK(!child->parent());
+  DCHECK(!child->nextOnLine());
+  DCHECK(!child->prevOnLine());
   checkConsistency();
 
   child->setParent(this);
   if (!m_firstChild) {
     m_firstChild = child;
     m_lastChild = child;
   } else {
     m_lastChild->setNextOnLine(child);
     child->setPrevOnLine(m_lastChild);
     m_lastChild = child;
@@ skipping 29 matching lines @@
           childStyle.getTextEmphasisMark() != TextEmphasisMarkNone)
         shouldClearDescendantsHaveSameLineHeightAndBaseline = true;
     } else {
       if (child->getLineLayoutItem().isBR()) {
         // FIXME: This is dumb. We only turn off because current layout test
         // results expect the <br> to be 0-height on the baseline.
         // Other than making a zillion tests have to regenerate results, there's
         // no reason to ditch the optimization here.
         shouldClearDescendantsHaveSameLineHeightAndBaseline = true;
       } else {
-        ASSERT(isInlineFlowBox());
+        DCHECK(isInlineFlowBox());
         InlineFlowBox* childFlowBox = toInlineFlowBox(child);
         // Check the child's bit, and then also check for differences in font,
         // line-height, vertical-align
         if (!childFlowBox->descendantsHaveSameLineHeightAndBaseline() ||
             !hasIdenticalLineHeightProperties(parentStyle, childStyle, root) ||
             childStyle.hasBorder() || childStyle.hasPadding() ||
             childStyle.hasTextCombine()) {
           shouldClearDescendantsHaveSameLineHeightAndBaseline = true;
         }
       }
@@ skipping 59 matching lines @@
 
   child->setParent(nullptr);
 
   checkConsistency();
 }
 
 void InlineFlowBox::deleteLine() {
   InlineBox* child = firstChild();
   InlineBox* next = nullptr;
   while (child) {
-    ASSERT(this == child->parent());
+    DCHECK_EQ(this, child->parent());
     next = child->nextOnLine();
 #if DCHECK_IS_ON()
     child->setParent(nullptr);
 #endif
     child->deleteLine();
     child = next;
   }
 #if DCHECK_IS_ON()
   m_firstChild = nullptr;
   m_lastChild = nullptr;
@@ skipping 526 matching lines @@
             LineLayoutBoxModel(curr->getLineLayoutItem());
         newLogicalTop -= boxObject.borderAndPaddingOver();
         borderPaddingHeight = boxObject.borderAndPaddingLogicalHeight();
       }
       newLogicalTopIncludingMargins = newLogicalTop;
     } else if (!curr->getLineLayoutItem().isBR()) {
       LineLayoutBox box = LineLayoutBox(curr->getLineLayoutItem());
       newLogicalTopIncludingMargins = newLogicalTop;
       // TODO(kojii): isHorizontal() does not match to
       // m_layoutObject.isHorizontalWritingMode(). crbug.com/552954
-      // ASSERT(curr->isHorizontal() ==
+      // DCHECK_EQ(curr->isHorizontal(),
       // curr->getLineLayoutItem().style()->isHorizontalWritingMode());
       // We may flip lines in case of verticalLR mode, so we can
       // assume verticalRL for now.
       LayoutUnit overSideMargin =
           curr->isHorizontal() ? box.marginTop() : box.marginRight();
       LayoutUnit underSideMargin =
           curr->isHorizontal() ? box.marginBottom() : box.marginLeft();
       newLogicalTop += overSideMargin;
       boxHeightIncludingMargins += overSideMargin + underSideMargin;
     }
@@ skipping 411 matching lines @@
     it->value.second = glyphOverflow;
   }
 }
 
 void InlineFlowBox::computeOverflow(
     LayoutUnit lineTop,
     LayoutUnit lineBottom,
     GlyphOverflowAndFallbackFontsMap& textBoxDataMap) {
   // If we know we have no overflow, we can just bail.
   if (knownToHaveNoOverflow()) {
-    ASSERT(!m_overflow);
+    DCHECK(!m_overflow);
     return;
   }
 
   if (m_overflow)
     m_overflow.reset();
 
   // Visual overflow just includes overflow for stuff we need to issues paint
   // invalidations for ourselves. Self-painting layers are ignored.
   // Layout overflow is used to determine scrolling extent, so it still includes
   // child layers and also factors in transforms, relative positioning, etc.
@@ skipping 41 matching lines @@
                                logicalVisualOverflow);
     }
   }
 
   setOverflowFromLogicalRects(logicalLayoutOverflow, logicalVisualOverflow,
                               lineTop, lineBottom);
 }
 
 void InlineFlowBox::setLayoutOverflow(const LayoutRect& rect,
                                       const LayoutRect& frameBox) {
-  ASSERT(!knownToHaveNoOverflow());
+  DCHECK(!knownToHaveNoOverflow());
   if (frameBox.contains(rect) || rect.isEmpty())
     return;
 
   if (!m_overflow)
     m_overflow = WTF::makeUnique<SimpleOverflowModel>(frameBox, frameBox);
 
   m_overflow->setLayoutOverflow(rect);
 }
 
 void InlineFlowBox::setVisualOverflow(const LayoutRect& rect,
                                       const LayoutRect& frameBox) {
-  ASSERT(!knownToHaveNoOverflow());
+  DCHECK(!knownToHaveNoOverflow());
   if (frameBox.contains(rect) || rect.isEmpty())
     return;
 
   if (!m_overflow)
     m_overflow = WTF::makeUnique<SimpleOverflowModel>(frameBox, frameBox);
 
   m_overflow->setVisualOverflow(rect);
 }
 
 void InlineFlowBox::setOverflowFromLogicalRects(
     const LayoutRect& logicalLayoutOverflow,
     const LayoutRect& logicalVisualOverflow,
     LayoutUnit lineTop,
     LayoutUnit lineBottom) {
-  ASSERT(!knownToHaveNoOverflow());
+  DCHECK(!knownToHaveNoOverflow());
   LayoutRect frameBox = frameRectIncludingLineHeight(lineTop, lineBottom);
 
   LayoutRect layoutOverflow(isHorizontal()
                                 ? logicalLayoutOverflow
                                 : logicalLayoutOverflow.transposedRect());
   setLayoutOverflow(layoutOverflow, frameBox);
 
   LayoutRect visualOverflow(isHorizontal()
                                 ? logicalVisualOverflow
                                 : logicalVisualOverflow.transposedRect());
@@ skipping 43 matching lines @@
     LineLayoutItem currLayoutItem = curr->getLineLayoutItem();
     while (true) {
       // If the previous inline box is not a descendant of a current inline's
       // parent, the parent is a culled inline and we hit test it.
       // Otherwise, move to the previous inline box because we hit test first
       // all candidate inline boxes under the parent to take a pre-order tree
       // traversal in reverse.
       bool hasSibling =
           currLayoutItem.previousSibling() || currLayoutItem.nextSibling();
       LineLayoutItem culledParent = currLayoutItem.parent();
-      ASSERT(culledParent);
+      DCHECK(culledParent);
 
       if (culledParent == getLineLayoutItem() ||
           (hasSibling && prev &&
            prev->getLineLayoutItem().isDescendantOf(culledParent)))
         break;
 
       if (culledParent.isLayoutInline() &&
           LineLayoutInline(culledParent)
               .hitTestCulledInline(result, locationInContainer,
                                    accumulatedOffset))
@@ skipping 347 matching lines @@
   for (const InlineBox* box = firstChild(); box; box = box->nextOnLine())
     box->showLineTreeAndMark(markedBox1, markedLabel1, markedBox2, markedLabel2,
                              obj, depth + 1);
 }
 
 #endif
 
 #if DCHECK_IS_ON()
 void InlineFlowBox::checkConsistency() const {
 #ifdef CHECK_CONSISTENCY
-  ASSERT(!m_hasBadChildList);
+  DCHECK(!m_hasBadChildList);
   const InlineBox* prev = nullptr;
   for (const InlineBox* child = m_firstChild; child;
        child = child->nextOnLine()) {
-    ASSERT(child->parent() == this);
-    ASSERT(child->prevOnLine() == prev);
+    DCHECK_EQ(child->parent(), this);
+    DCHECK_EQ(child->prevOnLine(), prev);
     prev = child;
   }
-  ASSERT(prev == m_lastChild);
+  DCHECK_EQ(prev, m_lastChild);
 #endif
 }
 
 #endif
 
 }  // namespace blink