Replace ASSERT with DCHECK in core/layout/ excluding subdirs

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2007 David Smith (catfish.man@gmail.com)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Apple Inc.
  *               All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. 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
@@ skipping 230 matching lines @@
 }
 
 inline void FindNextFloatLogicalBottomAdapter::collectIfNeeded(
     const IntervalType& interval) {
   const FloatingObject& floatingObject = *(interval.data());
   if (!rangesIntersect(interval.low(), interval.high(), m_belowLogicalHeight,
                        m_aboveLogicalHeight))
     return;
 
   // All the objects returned from the tree should be already placed.
-  ASSERT(floatingObject.isPlaced());
-  ASSERT(rangesIntersect(m_layoutObject.logicalTopForFloat(floatingObject),
+  DCHECK(floatingObject.isPlaced());
+  DCHECK(rangesIntersect(m_layoutObject.logicalTopForFloat(floatingObject),
                          m_layoutObject.logicalBottomForFloat(floatingObject),
                          m_belowLogicalHeight, m_aboveLogicalHeight));
 
   LayoutUnit floatBottom = m_layoutObject.logicalBottomForFloat(floatingObject);
 
   if (ShapeOutsideInfo* shapeOutside =
           floatingObject.layoutObject()->shapeOutsideInfo()) {
     LayoutUnit shapeBottom =
         m_layoutObject.logicalTopForFloat(floatingObject) +
         m_layoutObject.marginBeforeForChild(*floatingObject.layoutObject()) +
@@ skipping 29 matching lines @@
   placedFloatsTree().allOverlapsWithAdapter(adapter);
 
   return adapter.nextLogicalBottom();
 }
 
 FloatingObjects::~FloatingObjects() {}
 void FloatingObjects::clearLineBoxTreePointers() {
   // Clear references to originating lines, since the lines are being deleted
   FloatingObjectSetIterator end = m_set.end();
   for (FloatingObjectSetIterator it = m_set.begin(); it != end; ++it) {
-    ASSERT(
+    DCHECK(
         !((*it)->originatingLine()) ||
         (*it)->originatingLine()->getLineLayoutItem().isEqual(m_layoutObject));
     (*it)->setOriginatingLine(nullptr);
   }
 }
 
 FloatingObjects::FloatingObjects(const LayoutBlockFlow* layoutObject,
                                  bool horizontalWritingMode)
     : m_placedFloatsTree(UninitializedTree),
       m_leftObjectsCount(0),
@@ skipping 79 matching lines @@
                                       lowestFloatingObject);
   }
 
   return lowestFloatBottom;
 }
 
 bool FloatingObjects::hasLowestFloatLogicalBottomCached(
     bool isHorizontal,
     FloatingObject::Type type) const {
   int floatIndex = static_cast<int>(type) - 1;
-  ASSERT(floatIndex < static_cast<int>(sizeof(m_lowestFloatBottomCache) /
-                                       sizeof(FloatBottomCachedValue)));
-  ASSERT(floatIndex >= 0);
+  DCHECK_LT(floatIndex, static_cast<int>(sizeof(m_lowestFloatBottomCache) /
+                                         sizeof(FloatBottomCachedValue)));
+  DCHECK_GE(floatIndex, 0);
   return (m_cachedHorizontalWritingMode == isHorizontal &&
           !m_lowestFloatBottomCache[floatIndex].dirty);
 }
 
 LayoutUnit FloatingObjects::getCachedlowestFloatLogicalBottom(
     FloatingObject::Type type) const {
   int floatIndex = static_cast<int>(type) - 1;
-  ASSERT(floatIndex < static_cast<int>(sizeof(m_lowestFloatBottomCache) /
-                                       sizeof(FloatBottomCachedValue)));
-  ASSERT(floatIndex >= 0);
+  DCHECK_LT(floatIndex, static_cast<int>(sizeof(m_lowestFloatBottomCache) /
+                                         sizeof(FloatBottomCachedValue)));
+  DCHECK_GE(floatIndex, 0);
   if (!m_lowestFloatBottomCache[floatIndex].floatingObject)
     return LayoutUnit();
   return m_layoutObject->logicalBottomForFloat(
       *m_lowestFloatBottomCache[floatIndex].floatingObject);
 }
 
 void FloatingObjects::setCachedLowestFloatLogicalBottom(
     bool isHorizontal,
     FloatingObject::Type type,
     FloatingObject* floatingObject) {
   int floatIndex = static_cast<int>(type) - 1;
-  ASSERT(floatIndex < static_cast<int>(sizeof(m_lowestFloatBottomCache) /
-                                       sizeof(FloatBottomCachedValue)));
-  ASSERT(floatIndex >= 0);
+  DCHECK_LT(floatIndex, static_cast<int>(sizeof(m_lowestFloatBottomCache) /
+                                         sizeof(FloatBottomCachedValue)));
+  DCHECK_GE(floatIndex, 0);
   m_cachedHorizontalWritingMode = isHorizontal;
   m_lowestFloatBottomCache[floatIndex].floatingObject = floatingObject;
   m_lowestFloatBottomCache[floatIndex].dirty = false;
 }
 
 FloatingObject* FloatingObjects::lowestFloatingObject() const {
   bool isInHorizontalWritingMode = m_horizontalWritingMode;
   if (!hasLowestFloatLogicalBottomCached(isInHorizontalWritingMode,
                                          FloatingObject::FloatLeft) &&
       !hasLowestFloatLogicalBottomCached(isInHorizontalWritingMode,
@@ skipping 51 matching lines @@
   if (m_horizontalWritingMode)
     return FloatingObjectInterval(floatingObject.frameRect().y(),
                                   floatingObject.frameRect().maxY(),
                                   &floatingObject);
   return FloatingObjectInterval(floatingObject.frameRect().x(),
                                 floatingObject.frameRect().maxX(),
                                 &floatingObject);
 }
 
 void FloatingObjects::addPlacedObject(FloatingObject& floatingObject) {
-  ASSERT(!floatingObject.isInPlacedTree());
+  DCHECK(!floatingObject.isInPlacedTree());
 
   floatingObject.setIsPlaced(true);
   if (m_placedFloatsTree.isInitialized())
     m_placedFloatsTree.add(intervalForFloatingObject(floatingObject));
 
 #if DCHECK_IS_ON()
   floatingObject.setIsInPlacedTree(true);
 #endif
   markLowestFloatLogicalBottomCacheAsDirty();
 }
 
 void FloatingObjects::removePlacedObject(FloatingObject& floatingObject) {
-  ASSERT(floatingObject.isPlaced() && floatingObject.isInPlacedTree());
+  DCHECK(floatingObject.isPlaced());
+  DCHECK(floatingObject.isInPlacedTree());
 
   if (m_placedFloatsTree.isInitialized()) {
     bool removed =
         m_placedFloatsTree.remove(intervalForFloatingObject(floatingObject));
     DCHECK(removed);
   }
 
   floatingObject.setIsPlaced(false);
 #if DCHECK_IS_ON()
   floatingObject.setIsInPlacedTree(false);
 #endif
   markLowestFloatLogicalBottomCacheAsDirty();
 }
 
 FloatingObject* FloatingObjects::add(
     std::unique_ptr<FloatingObject> floatingObject) {
   FloatingObject* newObject = floatingObject.release();
   increaseObjectsCount(newObject->getType());
   m_set.insert(WTF::wrapUnique(newObject));
   if (newObject->isPlaced())
     addPlacedObject(*newObject);
   markLowestFloatLogicalBottomCacheAsDirty();
   return newObject;
 }
 
 void FloatingObjects::remove(FloatingObject* toBeRemoved) {
   decreaseObjectsCount(toBeRemoved->getType());
   std::unique_ptr<FloatingObject> floatingObject = m_set.take(toBeRemoved);
-  ASSERT(floatingObject->isPlaced() || !floatingObject->isInPlacedTree());
+  DCHECK(floatingObject->isPlaced() || !floatingObject->isInPlacedTree());
   if (floatingObject->isPlaced())
     removePlacedObject(*floatingObject);
   markLowestFloatLogicalBottomCacheAsDirty();
-  ASSERT(!floatingObject->originatingLine());
+  DCHECK(!floatingObject->originatingLine());
 }
 
 void FloatingObjects::computePlacedFloatsTree() {
-  ASSERT(!m_placedFloatsTree.isInitialized());
+  DCHECK(!m_placedFloatsTree.isInitialized());
   if (m_set.isEmpty())
     return;
   m_placedFloatsTree.initIfNeeded(m_layoutObject->view()->intervalArena());
   FloatingObjectSetIterator it = m_set.begin();
   FloatingObjectSetIterator end = m_set.end();
   for (; it != end; ++it) {
     FloatingObject& floatingObject = *it->get();
     if (floatingObject.isPlaced())
       m_placedFloatsTree.add(intervalForFloatingObject(floatingObject));
   }
@@ skipping 89 matching lines @@
 ComputeFloatOffsetAdapter<FloatTypeValue>::collectIfNeeded(
     const IntervalType& interval) {
   const FloatingObject& floatingObject = *(interval.data());
   if (floatingObject.getType() != FloatTypeValue ||
       !rangesIntersect(interval.low(), interval.high(), m_lineTop,
                        m_lineBottom))
     return;
 
   // Make sure the float hasn't changed since it was added to the placed floats
   // tree.
-  ASSERT(floatingObject.isPlaced());
-  ASSERT(interval.low() == m_layoutObject->logicalTopForFloat(floatingObject));
-  ASSERT(interval.high() ==
-         m_layoutObject->logicalBottomForFloat(floatingObject));
+  DCHECK(floatingObject.isPlaced());
+  DCHECK_EQ(interval.low(), m_layoutObject->logicalTopForFloat(floatingObject));
+  DCHECK_EQ(interval.high(),
+            m_layoutObject->logicalBottomForFloat(floatingObject));
 
   bool floatIsNewExtreme = updateOffsetIfNeeded(floatingObject);
   if (floatIsNewExtreme)
     m_outermostFloat = &floatingObject;
 }
 
 template <>
 inline bool ComputeFloatOffsetForLineLayoutAdapter<FloatingObject::FloatLeft>::
     updateOffsetIfNeeded(const FloatingObject& floatingObject) {
   LayoutUnit logicalRight =
@@ skipping 50 matching lines @@
     const FloatingObject* floatingObject) {
   return String::format("%p (%gx%g %gx%g)", floatingObject,
                         floatingObject->frameRect().x().toFloat(),
                         floatingObject->frameRect().y().toFloat(),
                         floatingObject->frameRect().maxX().toFloat(),
                         floatingObject->frameRect().maxY().toFloat());
 }
 #endif
 
 }  // namespace blink