Replace ASSERT with DCHECK in core/layout/ excluding subdirs

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

 /*
  * Copyright (C) 2011 Adobe Systems Incorporated. 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.
@@ skipping 24 matching lines @@
 namespace blink {
 
 LayoutFlowThread::LayoutFlowThread()
     : LayoutBlockFlow(nullptr),
       m_columnSetsInvalidated(false),
       m_pageLogicalSizeChanged(false) {}
 
 LayoutFlowThread* LayoutFlowThread::locateFlowThreadContainingBlockOf(
     const LayoutObject& descendant,
     AncestorSearchConstraint constraint) {
-  ASSERT(descendant.isInsideFlowThread());
+  DCHECK(descendant.isInsideFlowThread());
   LayoutObject* curr = const_cast<LayoutObject*>(&descendant);
   while (curr) {
     if (curr->isSVGChild())
       return nullptr;
     if (curr->isLayoutFlowThread())
       return toLayoutFlowThread(curr);
     LayoutObject* container = curr->container();
     // If we're inside something strictly unbreakable (due to having scrollbars
     // or being writing mode roots, for instance), it's also strictly
     // unbreakable in any outer fragmentation context. As such, what goes on
@@ skipping 13 matching lines @@
         return nullptr;
       }
       curr = curr->parent();
     }
   }
   return nullptr;
 }
 
 void LayoutFlowThread::removeColumnSetFromThread(
     LayoutMultiColumnSet* columnSet) {
-  ASSERT(columnSet);
+  DCHECK(columnSet);
   m_multiColumnSetList.erase(columnSet);
   invalidateColumnSets();
   // Clear the interval tree right away, instead of leaving it around with dead
   // objects. Not that anyone _should_ try to access the interval tree when the
   // column sets are marked as invalid, but this is actually possible if other
   // parts of the engine has bugs that cause us to not lay out everything that
   // was marked for layout, so that LayoutObject::assertLaidOut() (and a LOT
   // of other assertions) fails.
   m_multiColumnSetIntervalTree.clear();
 }
 
 void LayoutFlowThread::validateColumnSets() {
   m_columnSetsInvalidated = false;
   // Called to get the maximum logical width for the columnSet.
   updateLogicalWidth();
   generateColumnSetIntervalTree();
 }
 
 bool LayoutFlowThread::mapToVisualRectInAncestorSpaceInternal(
     const LayoutBoxModelObject* ancestor,
     TransformState& transformState,
     VisualRectFlags visualRectFlags) const {
   // A flow thread should never be an invalidation container.
-  DCHECK(ancestor != this);
+  DCHECK_NE(ancestor, this);
   transformState.flatten();
   LayoutRect rect(transformState.lastPlanarQuad().boundingBox());
   rect = fragmentsBoundingBox(rect);
   transformState.setQuad(FloatQuad(FloatRect(rect)));
   return LayoutBlockFlow::mapToVisualRectInAncestorSpaceInternal(
       ancestor, transformState, visualRectFlags);
 }
 
 void LayoutFlowThread::layout() {
   m_pageLogicalSizeChanged = m_columnSetsInvalidated && everHadLayout();
@@ skipping 91 matching lines @@
   LayoutMultiColumnSet* columnSet =
       columnSetAtBlockOffset(flowThreadOffset, AssociateWithLatterPage);
   if (!columnSet)
     return flowThreadOffset;
   return columnSet->nextLogicalTopForUnbreakableContent(flowThreadOffset,
                                                         contentLogicalHeight);
 }
 
 LayoutRect LayoutFlowThread::fragmentsBoundingBox(
     const LayoutRect& layerBoundingBox) const {
-  ASSERT(!RuntimeEnabledFeatures::slimmingPaintV2Enabled() ||
+  DCHECK(!RuntimeEnabledFeatures::slimmingPaintV2Enabled() ||
          !m_columnSetsInvalidated);
 
   LayoutRect result;
   for (auto* columnSet : m_multiColumnSetList)
     result.unite(columnSet->fragmentsBoundingBox(layerBoundingBox));
 
   return result;
 }
 
 void LayoutFlowThread::flowThreadToContainingCoordinateSpace(
@@ skipping 18 matching lines @@
 
 void LayoutFlowThread::MultiColumnSetSearchAdapter::collectIfNeeded(
     const MultiColumnSetInterval& interval) {
   if (m_result)
     return;
   if (interval.low() <= m_offset && interval.high() > m_offset)
     m_result = interval.data();
 }
 
 }  // namespace blink