Replace ASSERT with DCHECK in core/layout/ excluding subdirs

third_party/WebKit/Source/core/layout/LayoutBoxModelObject.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 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Google 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
@@ skipping 78 matching lines @@
 
 class FloatStateForStyleChange {
  public:
   static void setWasFloating(LayoutBoxModelObject* boxModelObject,
                              bool wasFloating) {
     s_wasFloating = wasFloating;
     s_boxModelObject = boxModelObject;
   }
 
   static bool wasFloating(LayoutBoxModelObject* boxModelObject) {
-    ASSERT(boxModelObject == s_boxModelObject);
+    DCHECK_EQ(boxModelObject, s_boxModelObject);
     return s_wasFloating;
   }
 
  private:
   // Used to store state between styleWillChange and styleDidChange
   static bool s_wasFloating;
   static LayoutBoxModelObject* s_boxModelObject;
 };
 
 bool FloatStateForStyleChange::s_wasFloating = false;
@@ skipping 117 matching lines @@
         continue;
       }
     }
     return BackgroundPaintInGraphicsLayer;
   }
   return paintLocation;
 }
 
 LayoutBoxModelObject::~LayoutBoxModelObject() {
   // Our layer should have been destroyed and cleared by now
-  ASSERT(!hasLayer());
-  ASSERT(!m_layer);
+  DCHECK(!hasLayer());
+  DCHECK(!m_layer);
 }
 
 void LayoutBoxModelObject::willBeDestroyed() {
   ImageQualityController::remove(*this);
 
   // A continuation of this LayoutObject should be destroyed at subclasses.
-  ASSERT(!continuation());
+  DCHECK(!continuation());
 
   if (isPositioned()) {
     // Don't use this->view() because the document's layoutView has been set to
     // 0 during destruction.
     if (LocalFrame* frame = this->frame()) {
       if (FrameView* frameView = frame->view()) {
         if (style()->hasViewportConstrainedPosition())
           frameView->removeViewportConstrainedObject(*this);
       }
     }
@@ skipping 237 matching lines @@
   // as if we have saved constraints for this layer they were saved in the
   // previous frame.
   DisableCompositingQueryAsserts disabler;
   if (const PaintLayer* ancestorOverflowLayer =
           enclosing->ancestorOverflowLayer())
     ancestorOverflowLayer->getScrollableArea()
         ->invalidateAllStickyConstraints();
 }
 
 void LayoutBoxModelObject::createLayer() {
-  ASSERT(!m_layer);
+  DCHECK(!m_layer);
   m_layer = WTF::makeUnique<PaintLayer>(*this);
   setHasLayer(true);
   m_layer->insertOnlyThisLayerAfterStyleChange();
 }
 
 void LayoutBoxModelObject::destroyLayer() {
   setHasLayer(false);
   m_layer = nullptr;
 }
 
@@ skipping 146 matching lines @@
          object = object->nextInPreOrder(object)) {
       if (object->isBox()) {
         const LayoutBox& box = toLayoutBox(*object);
         if (box.logicalHeight() && box.logicalWidth())
           return true;
       } else if (object->isLayoutInline()) {
         const LayoutInline& layoutInline = toLayoutInline(*object);
         if (!layoutInline.linesBoundingBox().isEmpty())
           return true;
       } else {
-        ASSERT(object->isText());
+        DCHECK(object->isText());
       }
     }
   }
   return false;
 }
 
 void LayoutBoxModelObject::absoluteQuadsForSelf(
     Vector<FloatQuad>& quads,
     MapCoordinatesFlags mode) const {
   NOTREACHED();
@@ skipping 534 matching lines @@
 LayoutUnit LayoutBoxModelObject::containingBlockLogicalWidthForContent() const {
   return containingBlock()->availableLogicalWidth();
 }
 
 LayoutBoxModelObject* LayoutBoxModelObject::continuation() const {
   return (!continuationMap) ? nullptr : continuationMap->at(this);
 }
 
 void LayoutBoxModelObject::setContinuation(LayoutBoxModelObject* continuation) {
   if (continuation) {
-    ASSERT(continuation->isLayoutInline() || continuation->isLayoutBlockFlow());
+    DCHECK(continuation->isLayoutInline() || continuation->isLayoutBlockFlow());
     if (!continuationMap)
       continuationMap = new ContinuationMap;
     continuationMap->set(this, continuation);
   } else {
     if (continuationMap)
       continuationMap->erase(this);
   }
 }
 
 void LayoutBoxModelObject::computeLayerHitTestRects(
@@ skipping 84 matching lines @@
       height;
   LayoutUnit y = paddingTop() + borderTop() + (verticalSpace / 2);
   return currentStyle.isHorizontalWritingMode()
              ? LayoutRect(x, y, caretWidth, height)
              : LayoutRect(y, x, height, caretWidth);
 }
 
 const LayoutObject* LayoutBoxModelObject::pushMappingToContainer(
     const LayoutBoxModelObject* ancestorToStopAt,
     LayoutGeometryMap& geometryMap) const {
-  ASSERT(ancestorToStopAt != this);
+  DCHECK_NE(ancestorToStopAt, this);
 
   AncestorSkipInfo skipInfo(ancestorToStopAt);
   LayoutObject* container = this->container(&skipInfo);
   if (!container)
     return nullptr;
 
   bool isInline = isLayoutInline();
   bool isFixedPos = !isInline && style()->position() == EPosition::kFixed;
   bool containsFixedPosition = canContainFixedPositionObjects();
 
@@ skipping 41 matching lines @@
   return skipInfo.ancestorSkipped() ? ancestorToStopAt : container;
 }
 
 void LayoutBoxModelObject::moveChildTo(LayoutBoxModelObject* toBoxModelObject,
                                        LayoutObject* child,
                                        LayoutObject* beforeChild,
                                        bool fullRemoveInsert) {
   // We assume that callers have cleared their positioned objects list for child
   // moves (!fullRemoveInsert) so the positioned layoutObject maps don't become
   // stale. It would be too slow to do the map lookup on each call.
-  ASSERT(!fullRemoveInsert || !isLayoutBlock() ||
+  DCHECK(!fullRemoveInsert || !isLayoutBlock() ||
          !toLayoutBlock(this)->hasPositionedObjects());
 
-  ASSERT(this == child->parent());
-  ASSERT(!beforeChild || toBoxModelObject == beforeChild->parent());
+  DCHECK_EQ(this, child->parent());
+  DCHECK(!beforeChild || toBoxModelObject == beforeChild->parent());
 
   // If a child is moving from a block-flow to an inline-flow parent then any
   // floats currently intruding into the child can no longer do so. This can
   // happen if a block becomes floating or out-of-flow and is moved to an
   // anonymous block. Remove all floats from their float-lists immediately as
   // markAllDescendantsWithFloatsForLayout won't attempt to remove floats from
   // parents that have inline-flow if we try later.
   if (child->isLayoutBlockFlow() && toBoxModelObject->childrenInline() &&
       !childrenInline()) {
     toLayoutBlockFlow(child)->removeFloatingObjectsFromDescendants();
-    ASSERT(!toLayoutBlockFlow(child)->containsFloats());
+    DCHECK(!toLayoutBlockFlow(child)->containsFloats());
   }
 
   if (fullRemoveInsert && isLayoutBlock() && child->isBox())
     toLayoutBox(child)->removeFromPercentHeightContainer();
 
   if (fullRemoveInsert && (toBoxModelObject->isLayoutBlock() ||
                            toBoxModelObject->isLayoutInline())) {
     // Takes care of adding the new child correctly if toBlock and fromBlock
     // have different kind of children (block vs inline).
     toBoxModelObject->addChild(virtualChildren()->removeChildNode(this, child),
@@ skipping 16 matching lines @@
   // anonymous blocks which can no longer carry positioned objects (see r120761)
   // or when fullRemoveInsert is false.
   if (fullRemoveInsert && isLayoutBlock()) {
     LayoutBlock* block = toLayoutBlock(this);
     block->removePositionedObjects(nullptr);
     block->removeFromPercentHeightContainer();
     if (block->isLayoutBlockFlow())
       toLayoutBlockFlow(block)->removeFloatingObjects();
   }
 
-  ASSERT(!beforeChild || toBoxModelObject == beforeChild->parent());
+  DCHECK(!beforeChild || toBoxModelObject == beforeChild->parent());
   for (LayoutObject* child = startChild; child && child != endChild;) {
     // Save our next sibling as moveChildTo will clear it.
     LayoutObject* nextSibling = child->nextSibling();
     moveChildTo(toBoxModelObject, child, beforeChild, fullRemoveInsert);
     child = nextSibling;
   }
 }
 
 bool LayoutBoxModelObject::backgroundStolenForBeingBody(
     const ComputedStyle* rootElementStyle) const {
@@ skipping 13 matching lines @@
   if (rootElementStyle->hasBackground())
     return false;
 
   if (node() != document().firstBodyElement())
     return false;
 
   return true;
 }
 
 }  // namespace blink