Replace ASSERT with DCHECK in core/layout/ excluding subdirs

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

 /*
  * Copyright (C) 2012 Apple 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:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 104 matching lines @@
   LayoutBox* firstBox = flowThread.firstMultiColumnBox();
   return firstBox && (firstBox != flowThread.lastMultiColumnBox() ||
                       firstBox->isLayoutMultiColumnSpannerPlaceholder());
 }
 
 // Find the next layout object that has the multicol container in its containing
 // block chain, skipping nested multicol containers.
 static LayoutObject* nextInPreOrderAfterChildrenSkippingOutOfFlow(
     LayoutMultiColumnFlowThread* flowThread,
     LayoutObject* descendant) {
-  ASSERT(descendant->isDescendantOf(flowThread));
+  DCHECK(descendant->isDescendantOf(flowThread));
   LayoutObject* object = descendant->nextInPreOrderAfterChildren(flowThread);
   while (object) {
     // Walk through the siblings and find the first one which is either in-flow
     // or has this flow thread as its containing block flow thread.
     if (!object->isOutOfFlowPositioned())
       break;
     if (object->containingBlock()->flowThreadContainingBlock() == flowThread) {
       // This out-of-flow object is still part of the flow thread, because its
       // containing block (probably relatively positioned) is part of the flow
       // thread.
       break;
     }
     object = object->nextInPreOrderAfterChildren(flowThread);
   }
   if (!object)
     return nullptr;
 #if DCHECK_IS_ON()
   // Make sure that we didn't stumble into an inner multicol container.
   for (LayoutObject* walker = object->parent(); walker && walker != flowThread;
        walker = walker->parent())
-    ASSERT(!isMultiColumnContainer(*walker));
+    DCHECK(!isMultiColumnContainer(*walker));
 #endif
   return object;
 }
 
 // Find the previous layout object that has the multicol container in its
 // containing block chain, skipping nested multicol containers.
 static LayoutObject* previousInPreOrderSkippingOutOfFlow(
     LayoutMultiColumnFlowThread* flowThread,
     LayoutObject* descendant) {
-  ASSERT(descendant->isDescendantOf(flowThread));
+  DCHECK(descendant->isDescendantOf(flowThread));
   LayoutObject* object = descendant->previousInPreOrder(flowThread);
   while (object && object != flowThread) {
     if (object->isColumnSpanAll()) {
       LayoutMultiColumnFlowThread* placeholderFlowThread =
           toLayoutBox(object)->spannerPlaceholder()->flowThread();
       if (placeholderFlowThread == flowThread)
         break;
       // We're inside an inner multicol container. We have no business there.
       // Continue on the outside.
       object = placeholderFlowThread->parent();
-      ASSERT(object->isDescendantOf(flowThread));
+      DCHECK(object->isDescendantOf(flowThread));
       continue;
     }
     if (object->flowThreadContainingBlock() == flowThread) {
       LayoutObject* ancestor;
       for (ancestor = object->parent();; ancestor = ancestor->parent()) {
         if (ancestor == flowThread)
           return object;
         if (isMultiColumnContainer(*ancestor)) {
           // We're inside an inner multicol container. We have no business
           // there.
           break;
         }
       }
       object = ancestor;
-      ASSERT(ancestor->isDescendantOf(flowThread));
+      DCHECK(ancestor->isDescendantOf(flowThread));
       continue;  // Continue on the outside of the inner flow thread.
     }
     // We're inside something that's out-of-flow. Keep looking upwards and
     // backwards in the tree.
     object = object->previousInPreOrder(flowThread);
   }
   if (!object || object == flowThread)
     return nullptr;
 #if DCHECK_IS_ON()
   // Make sure that we didn't stumble into an inner multicol container.
   for (LayoutObject* walker = object->parent(); walker && walker != flowThread;
        walker = walker->parent())
-    ASSERT(!isMultiColumnContainer(*walker));
+    DCHECK(!isMultiColumnContainer(*walker));
 #endif
   return object;
 }
 
 static LayoutObject* firstLayoutObjectInSet(LayoutMultiColumnSet* multicolSet) {
   LayoutBox* sibling = multicolSet->previousSiblingMultiColumnBox();
   if (!sibling)
     return multicolSet->flowThread()->firstChild();
   // Adjacent column content sets should not occur. We would have no way of
   // figuring out what each of them contains then.
-  ASSERT(sibling->isLayoutMultiColumnSpannerPlaceholder());
+  DCHECK(sibling->isLayoutMultiColumnSpannerPlaceholder());
   LayoutBox* spanner = toLayoutMultiColumnSpannerPlaceholder(sibling)
                            ->layoutObjectInFlowThread();
   return nextInPreOrderAfterChildrenSkippingOutOfFlow(
       multicolSet->multiColumnFlowThread(), spanner);
 }
 
 static LayoutObject* lastLayoutObjectInSet(LayoutMultiColumnSet* multicolSet) {
   LayoutBox* sibling = multicolSet->nextSiblingMultiColumnBox();
   // By right we should return lastLeafChild() here, but the caller doesn't
   // care, so just return nullptr.
   if (!sibling)
     return nullptr;
   // Adjacent column content sets should not occur. We would have no way of
   // figuring out what each of them contains then.
-  ASSERT(sibling->isLayoutMultiColumnSpannerPlaceholder());
+  DCHECK(sibling->isLayoutMultiColumnSpannerPlaceholder());
   LayoutBox* spanner = toLayoutMultiColumnSpannerPlaceholder(sibling)
                            ->layoutObjectInFlowThread();
   return previousInPreOrderSkippingOutOfFlow(
       multicolSet->multiColumnFlowThread(), spanner);
 }
 
 LayoutMultiColumnSet* LayoutMultiColumnFlowThread::mapDescendantToColumnSet(
     LayoutObject* layoutObject) const {
   // Should not be used for spanners or content inside them.
   DCHECK(!containingColumnSpannerPlaceholder(layoutObject));
-  DCHECK(layoutObject != this);
+  DCHECK_NE(layoutObject, this);
   DCHECK(layoutObject->isDescendantOf(this));
   // Out-of-flow objects don't belong in column sets.
   DCHECK(layoutObject->containingBlock()->isDescendantOf(this));
-  DCHECK(layoutObject->flowThreadContainingBlock() == this);
+  DCHECK_EQ(layoutObject->flowThreadContainingBlock(), this);
   DCHECK(!layoutObject->isLayoutMultiColumnSet());
   DCHECK(!layoutObject->isLayoutMultiColumnSpannerPlaceholder());
   LayoutMultiColumnSet* multicolSet = firstMultiColumnSet();
   if (!multicolSet)
     return nullptr;
   if (!multicolSet->nextSiblingMultiColumnSet())
     return multicolSet;
 
   // This is potentially SLOW! But luckily very uncommon. You would have to
   // dynamically insert a spanner into the middle of column contents to need
   // this.
   for (; multicolSet; multicolSet = multicolSet->nextSiblingMultiColumnSet()) {
     LayoutObject* firstLayoutObject = firstLayoutObjectInSet(multicolSet);
     LayoutObject* lastLayoutObject = lastLayoutObjectInSet(multicolSet);
-    ASSERT(firstLayoutObject);
+    DCHECK(firstLayoutObject);
 
     for (LayoutObject* walker = firstLayoutObject; walker;
          walker = walker->nextInPreOrder(this)) {
       if (walker == layoutObject)
         return multicolSet;
       if (walker == lastLayoutObject)
         break;
     }
   }
 
   return nullptr;
 }
 
 LayoutMultiColumnSpannerPlaceholder*
 LayoutMultiColumnFlowThread::containingColumnSpannerPlaceholder(
     const LayoutObject* descendant) const {
-  ASSERT(descendant->isDescendantOf(this));
+  DCHECK(descendant->isDescendantOf(this));
 
   if (!hasAnyColumnSpanners(*this))
     return nullptr;
 
   // We have spanners. See if the layoutObject in question is one or inside of
   // one then.
   for (const LayoutObject* ancestor = descendant; ancestor && ancestor != this;
        ancestor = ancestor->parent()) {
     if (LayoutMultiColumnSpannerPlaceholder* placeholder =
             ancestor->spannerPlaceholder())
       return placeholder;
   }
   return nullptr;
 }
 
 void LayoutMultiColumnFlowThread::populate() {
   LayoutBlockFlow* multicolContainer = multiColumnBlockFlow();
-  ASSERT(!nextSibling());
+  DCHECK(!nextSibling());
   // Reparent children preceding the flow thread into the flow thread. It's
   // multicol content now. At this point there's obviously nothing after the
   // flow thread, but layoutObjects (column sets and spanners) will be inserted
   // there as we insert elements into the flow thread.
   multicolContainer->removeFloatingObjectsFromDescendants();
   multicolContainer->moveChildrenTo(this, multicolContainer->firstChild(), this,
                                     true);
 }
 
 void LayoutMultiColumnFlowThread::evacuateAndDestroy() {
   LayoutBlockFlow* multicolContainer = multiColumnBlockFlow();
   m_isBeingEvacuated = true;
 
   // Remove all sets and spanners.
   while (LayoutBox* columnBox = firstMultiColumnBox()) {
-    ASSERT(columnBox->isAnonymous());
+    DCHECK(columnBox->isAnonymous());
     columnBox->destroy();
   }
 
-  ASSERT(!previousSibling());
-  ASSERT(!nextSibling());
+  DCHECK(!previousSibling());
+  DCHECK(!nextSibling());
 
   // Finally we can promote all flow thread's children. Before we move them to
   // the flow thread's container, we need to unregister the flow thread, so that
   // they aren't just re-added again to the flow thread that we're trying to
   // empty.
   multicolContainer->resetMultiColumnFlowThread();
   moveAllChildrenTo(multicolContainer, true);
 
   // We used to manually nuke the line box tree here, but that should happen
   // automatically when moving children around (the code above).
-  ASSERT(!firstLineBox());
+  DCHECK(!firstLineBox());
 
   destroy();
 }
 
 LayoutUnit LayoutMultiColumnFlowThread::maxColumnLogicalHeight() const {
   if (m_columnHeightAvailable) {
     // If height is non-auto, it's already constrained against max-height as
     // well. Just return it.
     return m_columnHeightAvailable;
   }
@@ skipping 241 matching lines @@
 }
 
 void LayoutMultiColumnFlowThread::columnRuleStyleDidChange() {
   for (LayoutMultiColumnSet* columnSet = firstMultiColumnSet(); columnSet;
        columnSet = columnSet->nextSiblingMultiColumnSet())
     columnSet->setShouldDoFullPaintInvalidation(PaintInvalidationStyleChange);
 }
 
 bool LayoutMultiColumnFlowThread::removeSpannerPlaceholderIfNoLongerValid(
     LayoutBox* spannerObjectInFlowThread) {
-  ASSERT(spannerObjectInFlowThread->spannerPlaceholder());
+  DCHECK(spannerObjectInFlowThread->spannerPlaceholder());
   if (descendantIsValidColumnSpanner(spannerObjectInFlowThread))
     return false;  // Still a valid spanner.
 
   // No longer a valid spanner. Get rid of the placeholder.
   destroySpannerPlaceholder(spannerObjectInFlowThread->spannerPlaceholder());
-  ASSERT(!spannerObjectInFlowThread->spannerPlaceholder());
+  DCHECK(!spannerObjectInFlowThread->spannerPlaceholder());
 
   // We may have a new containing block, since we're no longer a spanner. Mark
   // it for relayout.
   spannerObjectInFlowThread->containingBlock()
       ->setNeedsLayoutAndPrefWidthsRecalc(
           LayoutInvalidationReason::ColumnsChanged);
 
   // Now generate a column set for this ex-spanner, if needed and none is there
   // for us already.
   flowThreadDescendantWasInserted(spannerObjectInFlowThread);
@@ skipping 66 matching lines @@
             lastRow.blockOffsetInEnclosingFragmentationContext() +
             lastRow.logicalHeight();
         enclosingFlowThread->appendNewFragmentainerGroupIfNeeded(
             logicalOffsetInOuter, AssociateWithLatterPage);
       }
 
       const MultiColumnFragmentainerGroup& newRow =
           columnSet->appendNewFragmentainerGroup();
       // Zero-height rows should really not occur here, but if it does anyway,
       // break, so that we don't get stuck in an infinite loop.
-      ASSERT(newRow.logicalHeight() > 0);
+      DCHECK_GT(newRow.logicalHeight(), 0);
       if (newRow.logicalHeight() <= 0)
         break;
     } while (columnSet->needsNewFragmentainerGroupAt(offsetInFlowThread,
                                                      pageBoundaryRule));
   }
 }
 
 bool LayoutMultiColumnFlowThread::isFragmentainerLogicalHeightKnown() {
   return isPageLogicalHeightKnown();
 }
@@ skipping 37 matching lines @@
     LayoutUnit& width,
     unsigned& count) const {
   LayoutBlock* columnBlock = multiColumnBlockFlow();
   const ComputedStyle* columnStyle = columnBlock->style();
   LayoutUnit availableWidth = columnBlock->contentLogicalWidth();
   LayoutUnit columnGap = LayoutUnit(columnBlock->columnGap());
   LayoutUnit computedColumnWidth =
       max(LayoutUnit(1), LayoutUnit(columnStyle->columnWidth()));
   unsigned computedColumnCount = max<int>(1, columnStyle->columnCount());
 
-  ASSERT(!columnStyle->hasAutoColumnCount() ||
+  DCHECK(!columnStyle->hasAutoColumnCount() ||
          !columnStyle->hasAutoColumnWidth());
   if (columnStyle->hasAutoColumnWidth() && !columnStyle->hasAutoColumnCount()) {
     count = computedColumnCount;
     width = ((availableWidth - ((count - 1) * columnGap)) / count)
                 .clampNegativeToZero();
   } else if (!columnStyle->hasAutoColumnWidth() &&
              columnStyle->hasAutoColumnCount()) {
     count = std::max(LayoutUnit(1), (availableWidth + columnGap) /
                                         (computedColumnWidth + columnGap))
                 .toUnsigned();
@@ skipping 11 matching lines @@
 void LayoutMultiColumnFlowThread::createAndInsertMultiColumnSet(
     LayoutBox* insertBefore) {
   LayoutBlockFlow* multicolContainer = multiColumnBlockFlow();
   LayoutMultiColumnSet* newSet = LayoutMultiColumnSet::createAnonymous(
       *this, multicolContainer->styleRef());
   multicolContainer->LayoutBlock::addChild(newSet, insertBefore);
   invalidateColumnSets();
 
   // We cannot handle immediate column set siblings (and there's no need for it,
   // either). There has to be at least one spanner separating them.
-  ASSERT(!newSet->previousSiblingMultiColumnBox() ||
+  DCHECK(!newSet->previousSiblingMultiColumnBox() ||
          !newSet->previousSiblingMultiColumnBox()->isLayoutMultiColumnSet());
-  ASSERT(!newSet->nextSiblingMultiColumnBox() ||
+  DCHECK(!newSet->nextSiblingMultiColumnBox() ||
          !newSet->nextSiblingMultiColumnBox()->isLayoutMultiColumnSet());
 }
 
 void LayoutMultiColumnFlowThread::createAndInsertSpannerPlaceholder(
     LayoutBox* spannerObjectInFlowThread,
     LayoutObject* insertedBeforeInFlowThread) {
   LayoutBox* insertBeforeColumnBox = nullptr;
   LayoutMultiColumnSet* setToSplit = nullptr;
   if (insertedBeforeInFlowThread) {
     // The spanner is inserted before something. Figure out what this entails.
@@ skipping 13 matching lines @@
       } else if (LayoutMultiColumnSpannerPlaceholder* previousPlaceholder =
                      containingColumnSpannerPlaceholder(previousLayoutObject)) {
         // Before us is another spanner. We belong right after it then.
         insertBeforeColumnBox =
             previousPlaceholder->nextSiblingMultiColumnBox();
       } else {
         // We're inside regular column content with both feet. Find out which
         // column set this is. It needs to be split it into two sets, so that we
         // can insert a new spanner placeholder between them.
         setToSplit = mapDescendantToColumnSet(previousLayoutObject);
-        ASSERT(setToSplit ==
-               mapDescendantToColumnSet(insertedBeforeInFlowThread));
+        DCHECK_EQ(setToSplit,
+                  mapDescendantToColumnSet(insertedBeforeInFlowThread));
         insertBeforeColumnBox = setToSplit->nextSiblingMultiColumnBox();
         // We've found out which set that needs to be split. Now proceed to
         // inserting the spanner placeholder, and then insert a second column
         // set.
       }
     }
-    ASSERT(setToSplit || insertBeforeColumnBox);
+    DCHECK(setToSplit || insertBeforeColumnBox);
   }
 
   LayoutBlockFlow* multicolContainer = multiColumnBlockFlow();
   LayoutMultiColumnSpannerPlaceholder* newPlaceholder =
       LayoutMultiColumnSpannerPlaceholder::createAnonymous(
           multicolContainer->styleRef(), *spannerObjectInFlowThread);
-  ASSERT(!insertBeforeColumnBox ||
+  DCHECK(!insertBeforeColumnBox ||
          insertBeforeColumnBox->parent() == multicolContainer);
   multicolContainer->LayoutBlock::addChild(newPlaceholder,
                                            insertBeforeColumnBox);
   spannerObjectInFlowThread->setSpannerPlaceholder(*newPlaceholder);
 
   if (setToSplit)
     createAndInsertMultiColumnSet(insertBeforeColumnBox);
 }
 
 void LayoutMultiColumnFlowThread::destroySpannerPlaceholder(
@@ skipping 17 matching lines @@
   //   one (return true).
   // - When the descendant doesn't have a spanner placeholder and still should
   //   not have one (return false).
   // - When the descendant has a spanner placeholder but should no longer have
   //   one (return false).
   // - When the descendant has a spanner placeholder and should still have one
   //   (return true).
 
   // We assume that we're inside the flow thread. This function is not to be
   // called otherwise.
-  ASSERT(descendant->isDescendantOf(this));
+  DCHECK(descendant->isDescendantOf(this));
 
   // The spec says that column-span only applies to in-flow block-level
   // elements.
   if (descendant->style()->getColumnSpan() != ColumnSpanAll ||
       !descendant->isBox() || descendant->isInline() ||
       descendant->isFloatingOrOutOfFlowPositioned())
     return false;
 
   if (!descendant->containingBlock()->isLayoutBlockFlow()) {
     // Needs to be in a block-flow container, and not e.g. a table.
     return false;
   }
 
   // This looks like a spanner, but if we're inside something unbreakable or
   // something that establishes a new formatting context, it's not to be treated
   // as one.
   for (LayoutBox* ancestor = toLayoutBox(descendant)->parentBox(); ancestor;
        ancestor = ancestor->containingBlock()) {
     if (ancestor->isLayoutFlowThread()) {
-      ASSERT(ancestor == this);
+      DCHECK_EQ(ancestor, this);
       return true;
     }
     if (!canContainSpannerInParentFragmentationContext(*ancestor))
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 void LayoutMultiColumnFlowThread::addColumnSetToThread(
     LayoutMultiColumnSet* columnSet) {
   if (LayoutMultiColumnSet* nextSet = columnSet->nextSiblingMultiColumnSet()) {
     LayoutMultiColumnSetList::iterator it = m_multiColumnSetList.find(nextSet);
-    ASSERT(it != m_multiColumnSetList.end());
+    DCHECK(it != m_multiColumnSetList.end());
     m_multiColumnSetList.insertBefore(it, columnSet);
   } else {
     m_multiColumnSetList.insert(columnSet);
   }
 }
 
 void LayoutMultiColumnFlowThread::willBeRemovedFromTree() {
   // Detach all column sets from the flow thread. Cannot destroy them at this
   // point, since they are siblings of this object, and there may be pointers to
   // this object's sibling somewhere further up on the call stack.
   for (LayoutMultiColumnSet* columnSet = firstMultiColumnSet(); columnSet;
        columnSet = columnSet->nextSiblingMultiColumnSet())
     columnSet->detachFromFlowThread();
   multiColumnBlockFlow()->resetMultiColumnFlowThread();
   LayoutFlowThread::willBeRemovedFromTree();
 }
 
 void LayoutMultiColumnFlowThread::skipColumnSpanner(
     LayoutBox* layoutObject,
     LayoutUnit logicalTopInFlowThread) {
-  ASSERT(layoutObject->isColumnSpanAll());
+  DCHECK(layoutObject->isColumnSpanAll());
   LayoutMultiColumnSpannerPlaceholder* placeholder =
       layoutObject->spannerPlaceholder();
   LayoutBox* previousColumnBox = placeholder->previousSiblingMultiColumnBox();
   if (previousColumnBox && previousColumnBox->isLayoutMultiColumnSet())
     toLayoutMultiColumnSet(previousColumnBox)->endFlow(logicalTopInFlowThread);
   LayoutBox* nextColumnBox = placeholder->nextSiblingMultiColumnBox();
   if (nextColumnBox && nextColumnBox->isLayoutMultiColumnSet()) {
     LayoutMultiColumnSet* nextSet = toLayoutMultiColumnSet(nextColumnBox);
     m_lastSetWorkedOn = nextSet;
     nextSet->beginFlow(logicalTopInFlowThread);
@@ skipping 41 matching lines @@
       child.containingBlock()->flowThreadContainingBlock() != flowThread) {
     // Out-of-flow with its containing block on the outside of the multicol
     // container.
     return true;
   }
   return false;
 }
 
 void LayoutMultiColumnFlowThread::flowThreadDescendantWasInserted(
     LayoutObject* descendant) {
-  ASSERT(!m_isBeingEvacuated);
+  DCHECK(!m_isBeingEvacuated);
   // This method ensures that the list of column sets and spanner placeholders
   // reflects the multicol content after having inserted a descendant (or
   // descendant subtree). See the header file for more information. Go through
   // the subtree that was just inserted and create column sets (needed by
   // regular column content) and spanner placeholders (one needed by each
   // spanner) where needed.
   if (shouldSkipInsertedOrRemovedChild(this, *descendant))
     return;
   LayoutObject* objectAfterSubtree =
       nextInPreOrderAfterChildrenSkippingOutOfFlow(this, descendant);
@@ skipping 22 matching lines @@
               objectAfterSubtree->spannerPlaceholder()) {
         // If inserted right before a spanner, we need to make sure that there's
         // a set for us there.
         LayoutBox* previous = placeholder->previousSiblingMultiColumnBox();
         if (!previous || !previous->isLayoutMultiColumnSet())
           createAndInsertMultiColumnSet(placeholder);
       } else {
         // Otherwise, since |objectAfterSubtree| isn't a spanner, it has to mean
         // that there's already a set for that content. We can use it for this
         // layoutObject too.
-        ASSERT(mapDescendantToColumnSet(objectAfterSubtree));
-        ASSERT(mapDescendantToColumnSet(layoutObject) ==
-               mapDescendantToColumnSet(objectAfterSubtree));
+        DCHECK(mapDescendantToColumnSet(objectAfterSubtree));
+        DCHECK_EQ(mapDescendantToColumnSet(layoutObject),
+                  mapDescendantToColumnSet(objectAfterSubtree));
       }
     } else {
       // Inserting at the end. Then we just need to make sure that there's a
       // column set at the end.
       LayoutBox* lastColumnBox = lastMultiColumnBox();
       if (!lastColumnBox || !lastColumnBox->isLayoutMultiColumnSet())
         createAndInsertMultiColumnSet();
     }
   }
 }
@@ skipping 58 matching lines @@
       return;  // Followed by column content. Set still needed.
   }
   // We have now determined that, with the removal of |descendant|, we should
   // remove a column set. Locate it and remove it. Do it without involving
   // mapDescendantToColumnSet(), as that might be very slow. Deduce the right
   // set from the spanner placeholders that we've already found.
   LayoutMultiColumnSet* columnSetToRemove;
   if (adjacentNextSpannerPlaceholder) {
     columnSetToRemove = toLayoutMultiColumnSet(
         adjacentNextSpannerPlaceholder->previousSiblingMultiColumnBox());
-    ASSERT(!adjacentPreviousSpannerPlaceholder ||
+    DCHECK(!adjacentPreviousSpannerPlaceholder ||
            columnSetToRemove ==
                adjacentPreviousSpannerPlaceholder->nextSiblingMultiColumnBox());
   } else if (adjacentPreviousSpannerPlaceholder) {
     columnSetToRemove = toLayoutMultiColumnSet(
         adjacentPreviousSpannerPlaceholder->nextSiblingMultiColumnBox());
   } else {
     // If there were no adjacent spanners, it has to mean that there's only one
     // column set, since it's only spanners that may cause creation of
     // multiple sets.
     columnSetToRemove = firstMultiColumnSet();
-    ASSERT(columnSetToRemove);
-    ASSERT(!columnSetToRemove->nextSiblingMultiColumnSet());
+    DCHECK(columnSetToRemove);
+    DCHECK(!columnSetToRemove->nextSiblingMultiColumnSet());
   }
-  ASSERT(columnSetToRemove);
+  DCHECK(columnSetToRemove);
   columnSetToRemove->destroy();
 }
 
 static inline bool needsToReinsertIntoFlowThread(
     const ComputedStyle& oldStyle,
     const ComputedStyle& newStyle) {
   // If we've become (or are about to become) a container for absolutely
   // positioned descendants, or if we're no longer going to be one, we need to
   // re-evaluate the need for column sets. There may be out-of-flow descendants
   // further down that become part of the flow thread, or cease to be part of
@@ skipping 52 matching lines @@
     const ComputedStyle& oldStyle) {
   bool toggleSpannersIfNeeded = s_toggleSpannersIfNeeded;
   s_toggleSpannersIfNeeded = false;
 
   if (needsToInsertIntoFlowThread(oldStyle, descendant->styleRef())) {
     flowThreadDescendantWasInserted(descendant);
     return;
   }
   if (descendantIsValidColumnSpanner(descendant)) {
     // We went from being regular column content to becoming a spanner.
-    ASSERT(!descendant->spannerPlaceholder());
+    DCHECK(!descendant->spannerPlaceholder());
 
     // First remove this as regular column content. Note that this will walk the
     // entire subtree of |descendant|. There might be spanners there (which
     // won't be spanners anymore, since we're not allowed to nest spanners),
     // whose placeholders must die.
     flowThreadDescendantWillBeRemoved(descendant);
 
     createAndInsertSpannerPlaceholder(
         descendant,
         nextInPreOrderAfterChildrenSkippingOutOfFlow(this, descendant));
     return;
   }
 
   if (!toggleSpannersIfNeeded)
     return;
 #if DCHECK_IS_ON()
   // Make sure that we were preceded by a call to
   // flowThreadDescendantStyleWillChange() with the same descendant as we have
   // now.
-  DCHECK(s_styleChangedBox == descendant);
+  DCHECK_EQ(s_styleChangedBox, descendant);
 #endif
 
   if (s_couldContainSpanners !=
       canContainSpannerInParentFragmentationContext(*descendant))
     toggleSpannersInSubtree(descendant);
 }
 
 void LayoutMultiColumnFlowThread::toggleSpannersInSubtree(
     LayoutBox* descendant) {
-  DCHECK(s_couldContainSpanners !=
-         canContainSpannerInParentFragmentationContext(*descendant));
+  DCHECK_NE(s_couldContainSpanners,
+            canContainSpannerInParentFragmentationContext(*descendant));
 
   // If there are no spanners at all in this multicol container, there's no
   // need to look for any to remove.
   if (s_couldContainSpanners && !hasAnyColumnSpanners(*this))
     return;
 
   bool walkChildren;
   for (LayoutObject* object = descendant->nextInPreOrder(descendant); object;
        object = walkChildren
                     ? object->nextInPreOrder(descendant)
@@ skipping 72 matching lines @@
   computedValues.m_position = logicalTop;
 }
 
 void LayoutMultiColumnFlowThread::updateLogicalWidth() {
   LayoutUnit columnWidth;
   calculateColumnCountAndWidth(columnWidth, m_columnCount);
   setLogicalWidth(columnWidth);
 }
 
 void LayoutMultiColumnFlowThread::layout() {
-  ASSERT(!m_lastSetWorkedOn);
+  DCHECK(!m_lastSetWorkedOn);
   m_lastSetWorkedOn = firstMultiColumnSet();
   if (m_lastSetWorkedOn)
     m_lastSetWorkedOn->beginFlow(LayoutUnit());
   LayoutFlowThread::layout();
   if (LayoutMultiColumnSet* lastSet = lastMultiColumnSet()) {
-    ASSERT(lastSet == m_lastSetWorkedOn);
+    DCHECK_EQ(lastSet, m_lastSetWorkedOn);
     if (!lastSet->nextSiblingMultiColumnSet()) {
       // Include trailing overflow in the last column set (also if the last set
       // is followed by one or more spanner placeholders). The idea is that we
       // will generate additional columns and pages to hold that overflow,
       // since people do write bad content like <body style="height:0px"> in
       // multi-column layouts.
       // TODO(mstensho): Once we support nested multicol, adding in overflow
       // here may result in the need for creating additional rows, since there
       // may not be enough space remaining in the currently last row.
       LayoutRect layoutRect = layoutOverflowRect();
       LayoutUnit logicalBottomInFlowThread =
           isHorizontalWritingMode() ? layoutRect.maxY() : layoutRect.maxX();
-      ASSERT(logicalBottomInFlowThread >= logicalHeight());
+      DCHECK_GE(logicalBottomInFlowThread, logicalHeight());
       lastSet->endFlow(logicalBottomInFlowThread);
     }
   }
   m_lastSetWorkedOn = nullptr;
 }
 
 void LayoutMultiColumnFlowThread::contentWasLaidOut(
     LayoutUnit logicalBottomInFlowThreadAfterPagination) {
   // Check if we need another fragmentainer group. If we've run out of columns
   // in the last fragmentainer group (column row), we need to insert another
@@ skipping 43 matching lines @@
     const {
   return MultiColumnLayoutState(m_lastSetWorkedOn);
 }
 
 void LayoutMultiColumnFlowThread::restoreMultiColumnLayoutState(
     const MultiColumnLayoutState& state) {
   m_lastSetWorkedOn = state.columnSet();
 }
 
 }  // namespace blink