Replace ASSERT with DCHECK in core/layout/ excluding subdirs

third_party/WebKit/Source/core/layout/LayoutBlock.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 91 matching lines @@
       m_hasPercentHeightDescendants(false),
       m_paginationStateChanged(false) {
   // LayoutBlockFlow calls setChildrenInline(true).
   // By default, subclasses do not have inline children.
 }
 
 void LayoutBlock::removeFromGlobalMaps() {
   if (hasPositionedObjects()) {
     std::unique_ptr<TrackedLayoutBoxListHashSet> descendants =
         gPositionedDescendantsMap->take(this);
-    ASSERT(!descendants->isEmpty());
+    DCHECK(!descendants->isEmpty());
     for (LayoutBox* descendant : *descendants) {
-      ASSERT(gPositionedContainerMap->at(descendant) == this);
+      DCHECK_EQ(gPositionedContainerMap->at(descendant), this);
       gPositionedContainerMap->erase(descendant);
     }
   }
   if (hasPercentHeightDescendants()) {
     std::unique_ptr<TrackedLayoutBoxListHashSet> descendants =
         gPercentHeightDescendantsMap->take(this);
-    ASSERT(!descendants->isEmpty());
+    DCHECK(!descendants->isEmpty());
     for (LayoutBox* descendant : *descendants) {
-      ASSERT(descendant->percentHeightContainer() == this);
+      DCHECK_EQ(descendant->percentHeightContainer(), this);
       descendant->setPercentHeightContainer(nullptr);
     }
   }
 }
 
 LayoutBlock::~LayoutBlock() {
   removeFromGlobalMaps();
 }
 
 void LayoutBlock::willBeDestroyed() {
@@ skipping 149 matching lines @@
   setHasOverflowClip(shouldClipOverflow);
 }
 
 bool LayoutBlock::allowsOverflowClip() const {
   // If overflow has been propagated to the viewport, it has no effect here.
   return node() != document().viewportDefiningElement();
 }
 
 void LayoutBlock::addChildBeforeDescendant(LayoutObject* newChild,
                                            LayoutObject* beforeDescendant) {
-  ASSERT(beforeDescendant->parent() != this);
+  DCHECK_NE(beforeDescendant->parent(), this);
   LayoutObject* beforeDescendantContainer = beforeDescendant->parent();
   while (beforeDescendantContainer->parent() != this)
     beforeDescendantContainer = beforeDescendantContainer->parent();
-  ASSERT(beforeDescendantContainer);
+  DCHECK(beforeDescendantContainer);
 
   // We really can't go on if what we have found isn't anonymous. We're not
   // supposed to use some random non-anonymous object and put the child there.
   // That's a recipe for security issues.
   CHECK(beforeDescendantContainer->isAnonymous());
 
   // If the requested insertion point is not one of our children, then this is
   // because there is an anonymous container within this object that contains
   // the beforeDescendant.
   if (beforeDescendantContainer->isAnonymousBlock()
       // Full screen layoutObjects and full screen placeholders act as anonymous
       // blocks, not tables:
       || beforeDescendantContainer->isLayoutFullScreen() ||
       beforeDescendantContainer->isLayoutFullScreenPlaceholder()) {
     // Insert the child into the anonymous block box instead of here.
     if (newChild->isInline() || newChild->isFloatingOrOutOfFlowPositioned() ||
         beforeDescendant->parent()->slowFirstChild() != beforeDescendant)
       beforeDescendant->parent()->addChild(newChild, beforeDescendant);
     else
       addChild(newChild, beforeDescendant->parent());
     return;
   }
 
-  ASSERT(beforeDescendantContainer->isTable());
+  DCHECK(beforeDescendantContainer->isTable());
   if (newChild->isTablePart()) {
     // Insert into the anonymous table.
     beforeDescendantContainer->addChild(newChild, beforeDescendant);
     return;
   }
 
   LayoutObject* beforeChild = splitAnonymousBoxesAroundChild(beforeDescendant);
 
-  ASSERT(beforeChild->parent() == this);
+  DCHECK_EQ(beforeChild->parent(), this);
   if (beforeChild->parent() != this) {
     // We should never reach here. If we do, we need to use the
     // safe fallback to use the topmost beforeChild container.
     beforeChild = beforeDescendantContainer;
   }
 
   addChild(newChild, beforeChild);
 }
 
 void LayoutBlock::addChild(LayoutObject* newChild, LayoutObject* beforeChild) {
   if (beforeChild && beforeChild->parent() != this) {
     addChildBeforeDescendant(newChild, beforeChild);
     return;
   }
 
   // Only LayoutBlockFlow should have inline children, and then we shouldn't be
   // here.
-  ASSERT(!childrenInline());
+  DCHECK(!childrenInline());
 
   if (newChild->isInline() || newChild->isFloatingOrOutOfFlowPositioned()) {
     // If we're inserting an inline child but all of our children are blocks,
     // then we have to make sure it is put into an anomyous block box. We try to
     // use an existing anonymous box if possible, otherwise a new one is created
     // and inserted into our list of children in the appropriate position.
     LayoutObject* afterChild =
         beforeChild ? beforeChild->previousSibling() : lastChild();
 
     if (afterChild && afterChild->isAnonymousBlock()) {
       afterChild->addChild(newChild);
       return;
     }
 
     if (newChild->isInline()) {
       // No suitable existing anonymous box - create a new one.
       LayoutBlock* newBox = createAnonymousBlock();
       LayoutBox::addChild(newBox, beforeChild);
       newBox->addChild(newChild);
       return;
     }
   }
 
   LayoutBox::addChild(newChild, beforeChild);
 }
 
 void LayoutBlock::removeLeftoverAnonymousBlock(LayoutBlock* child) {
-  ASSERT(child->isAnonymousBlock());
-  ASSERT(!child->childrenInline());
-  ASSERT(child->parent() == this);
+  DCHECK(child->isAnonymousBlock());
+  DCHECK(!child->childrenInline());
+  DCHECK_EQ(child->parent(), this);
 
   if (child->continuation())
     return;
 
   // Promote all the leftover anonymous block's children (to become children of
   // this block instead). We still want to keep the leftover block in the tree
   // for a moment, for notification purposes done further below (flow threads
   // and grids).
   child->moveAllChildrenTo(this, child->nextSibling());
 
@@ skipping 540 matching lines @@
   if (inlineBoxWrapper() && canUpdateSelectionOnRootLineBoxes())
     inlineBoxWrapper()->root().setHasSelectedChildren(state != SelectionNone);
 }
 
 TrackedLayoutBoxListHashSet* LayoutBlock::positionedObjectsInternal() const {
   return gPositionedDescendantsMap ? gPositionedDescendantsMap->at(this)
                                    : nullptr;
 }
 
 void LayoutBlock::insertPositionedObject(LayoutBox* o) {
-  ASSERT(!isAnonymousBlock());
-  ASSERT(o->containingBlock() == this);
+  DCHECK(!isAnonymousBlock());
+  DCHECK_EQ(o->containingBlock(), this);
 
   if (gPositionedContainerMap) {
     auto containerMapIt = gPositionedContainerMap->find(o);
     if (containerMapIt != gPositionedContainerMap->end()) {
       if (containerMapIt->value == this) {
-        ASSERT(hasPositionedObjects() && positionedObjects()->contains(o));
+        DCHECK(hasPositionedObjects());
+        DCHECK(positionedObjects()->contains(o));
         return;
       }
       removePositionedObject(o);
     }
   } else {
     gPositionedContainerMap = new TrackedContainerMap;
   }
   gPositionedContainerMap->set(o, this);
 
   if (!gPositionedDescendantsMap)
@@ skipping 12 matching lines @@
 void LayoutBlock::removePositionedObject(LayoutBox* o) {
   if (!gPositionedContainerMap)
     return;
 
   LayoutBlock* container = gPositionedContainerMap->take(o);
   if (!container)
     return;
 
   TrackedLayoutBoxListHashSet* positionedDescendants =
       gPositionedDescendantsMap->at(container);
-  ASSERT(positionedDescendants && positionedDescendants->contains(o));
+  DCHECK(positionedDescendants);
+  DCHECK(positionedDescendants->contains(o));
   positionedDescendants->erase(o);
   if (positionedDescendants->isEmpty()) {
     gPositionedDescendantsMap->erase(container);
     container->m_hasPositionedObjects = false;
   }
 }
 
 PaintInvalidationReason LayoutBlock::invalidatePaintIfNeeded(
     const PaintInvalidationState& paintInvalidationState) {
   return LayoutBox::invalidatePaintIfNeeded(paintInvalidationState);
@@ skipping 45 matching lines @@
       while (p && !p->isLayoutBlock())
         p = p->parent();
       if (p)
         p->setChildNeedsLayout();
 
       deadObjects.push_back(positionedObject);
     }
   }
 
   for (auto object : deadObjects) {
-    ASSERT(gPositionedContainerMap->at(object) == this);
+    DCHECK_EQ(gPositionedContainerMap->at(object), this);
     positionedDescendants->erase(object);
     gPositionedContainerMap->erase(object);
   }
   if (positionedDescendants->isEmpty()) {
     gPositionedDescendantsMap->erase(this);
     m_hasPositionedObjects = false;
   }
 }
 
 void LayoutBlock::addPercentHeightDescendant(LayoutBox* descendant) {
   if (descendant->percentHeightContainer()) {
     if (descendant->percentHeightContainer() == this) {
-      ASSERT(hasPercentHeightDescendant(descendant));
+      DCHECK(hasPercentHeightDescendant(descendant));
       return;
     }
     descendant->removeFromPercentHeightContainer();
   }
   descendant->setPercentHeightContainer(this);
 
   if (!gPercentHeightDescendantsMap)
     gPercentHeightDescendantsMap = new TrackedDescendantsMap;
   TrackedLayoutBoxListHashSet* descendantSet =
       gPercentHeightDescendantsMap->at(this);
@@ skipping 23 matching lines @@
                                       : nullptr;
 }
 
 void LayoutBlock::dirtyForLayoutFromPercentageHeightDescendants(
     SubtreeLayoutScope& layoutScope) {
   TrackedLayoutBoxListHashSet* descendants = percentHeightDescendants();
   if (!descendants)
     return;
 
   for (auto* box : *descendants) {
-    ASSERT(box->isDescendantOf(this));
+    DCHECK(box->isDescendantOf(this));
     while (box != this) {
       if (box->normalChildNeedsLayout())
         break;
       layoutScope.setChildNeedsLayout(box);
       box = box->containingBlock();
-      ASSERT(box);
+      DCHECK(box);
       if (!box)
         break;
     }
   }
 }
 
 LayoutUnit LayoutBlock::textIndentOffset() const {
   LayoutUnit cw;
   if (style()->textIndent().isPercentOrCalc())
     cw = containingBlock()->availableLogicalWidth();
@@ skipping 26 matching lines @@
             nodeForHitTest(), locationInContainer) == StopHitTesting)
       return true;
   }
   return false;
 }
 
 bool LayoutBlock::hitTestChildren(HitTestResult& result,
                                   const HitTestLocation& locationInContainer,
                                   const LayoutPoint& accumulatedOffset,
                                   HitTestAction hitTestAction) {
-  ASSERT(!childrenInline());
+  DCHECK(!childrenInline());
   LayoutPoint scrolledOffset(hasOverflowClip()
                                  ? accumulatedOffset - scrolledContentOffset()
                                  : accumulatedOffset);
   HitTestAction childHitTest = hitTestAction;
   if (hitTestAction == HitTestChildBlockBackgrounds)
     childHitTest = HitTestChildBlockBackground;
   for (LayoutBox* child = lastChildBox(); child;
        child = child->previousSiblingBox()) {
     LayoutPoint childPoint = flipForWritingModeForChild(child, scrolledOffset);
     if (!child->hasSelfPaintingLayer() && !child->isFloating() &&
@@ skipping 25 matching lines @@
               : box->getLineLayoutItem().caretMaxOffset());
 
   InlineTextBox* textBox = toInlineTextBox(box);
   return Position::editingPositionOf(
       box->getLineLayoutItem().nonPseudoNode(),
       start ? textBox->start() : textBox->start() + textBox->len());
 }
 
 static inline bool isEditingBoundary(LayoutObject* ancestor,
                                      LineLayoutBox child) {
-  ASSERT(!ancestor || ancestor->nonPseudoNode());
-  ASSERT(child && child.nonPseudoNode());
+  DCHECK(!ancestor || ancestor->nonPseudoNode());
+  DCHECK(child);
+  DCHECK(child.nonPseudoNode());
   return !ancestor || !ancestor->parent() ||
          (ancestor->hasLayer() && ancestor->parent()->isLayoutView()) ||
          hasEditableStyle(*ancestor->nonPseudoNode()) ==
              hasEditableStyle(*child.nonPseudoNode());
 }
 
 // FIXME: This function should go on LayoutObject.
 // Then all cases in which positionForPoint recurs could call this instead to
 // prevent crossing editable boundaries. This would require many tests.
 PositionWithAffinity LayoutBlock::positionForPointRespectingEditingBoundaries(
@@ skipping 32 matching lines @@
                                ? pointInChildCoordinates.x()
                                : pointInChildCoordinates.y();
   if (logicalLeft < childMiddle)
     return ancestor->createPositionWithAffinity(childNode->nodeIndex());
   return ancestor->createPositionWithAffinity(childNode->nodeIndex() + 1,
                                               TextAffinity::Upstream);
 }
 
 PositionWithAffinity LayoutBlock::positionForPointIfOutsideAtomicInlineLevel(
     const LayoutPoint& point) {
-  ASSERT(isAtomicInlineLevel());
+  DCHECK(isAtomicInlineLevel());
   // FIXME: This seems wrong when the object's writing-mode doesn't match the
   // line's writing-mode.
   LayoutUnit pointLogicalLeft =
       isHorizontalWritingMode() ? point.x() : point.y();
   LayoutUnit pointLogicalTop =
       isHorizontalWritingMode() ? point.y() : point.x();
 
   if (pointLogicalLeft < 0)
     return createPositionWithAffinity(caretMinOffset());
   if (pointLogicalLeft >= logicalWidth())
@@ skipping 21 matching lines @@
     if (!position.isNull())
       return position;
   }
 
   LayoutPoint pointInContents = point;
   offsetForContents(pointInContents);
   LayoutPoint pointInLogicalContents(pointInContents);
   if (!isHorizontalWritingMode())
     pointInLogicalContents = pointInLogicalContents.transposedPoint();
 
-  ASSERT(!childrenInline());
+  DCHECK(!childrenInline());
 
   LayoutBox* lastCandidateBox = lastChildBox();
   while (lastCandidateBox && !isChildHitTestCandidate(lastCandidateBox))
     lastCandidateBox = lastCandidateBox->previousSiblingBox();
 
   bool blocksAreFlipped = style()->isFlippedBlocksWritingMode();
   if (lastCandidateBox) {
     if (pointInLogicalContents.y() > logicalTopForChild(*lastCandidateBox) ||
         (!blocksAreFlipped &&
          pointInLogicalContents.y() == logicalTopForChild(*lastCandidateBox)))
@@ skipping 75 matching lines @@
                                         LayoutUnit(tableCellWidth.value())));
   }
 
   int scrollbarWidth = scrollbarLogicalWidth();
   maxLogicalWidth += scrollbarWidth;
   minLogicalWidth += scrollbarWidth;
 }
 
 DISABLE_CFI_PERF
 void LayoutBlock::computePreferredLogicalWidths() {
-  ASSERT(preferredLogicalWidthsDirty());
+  DCHECK(preferredLogicalWidthsDirty());
 
   m_minPreferredLogicalWidth = LayoutUnit();
   m_maxPreferredLogicalWidth = LayoutUnit();
 
   // FIXME: The isFixed() calls here should probably be checking for isSpecified
   // since you should be able to use percentage, calc or viewport relative
   // values for width.
   const ComputedStyle& styleToUse = styleRef();
   if (!isTableCell() && styleToUse.logicalWidth().isFixed() &&
       styleToUse.logicalWidth().value() >= 0 &&
@@ skipping 260 matching lines @@
     if (baselinePos != -1)
       return beforeMarginInLineDirection(direction) + baselinePos;
 
     return LayoutBox::baselinePosition(baselineType, firstLine, direction,
                                        linePositionMode);
   }
 
   // If we're not replaced, we'll only get called with
   // PositionOfInteriorLineBoxes.
   // Note that inline-block counts as replaced here.
-  ASSERT(linePositionMode == PositionOfInteriorLineBoxes);
+  DCHECK_EQ(linePositionMode, PositionOfInteriorLineBoxes);
 
   const SimpleFontData* fontData = style(firstLine)->font().primaryFont();
   DCHECK(fontData);
   if (!fontData)
     return -1;
 
   const FontMetrics& fontMetrics = fontData->getFontMetrics();
   return (fontMetrics.ascent(baselineType) +
           (lineHeight(firstLine, direction, linePositionMode) -
            fontMetrics.height()) /
@@ skipping 14 matching lines @@
                  PositionOfInteriorLineBoxes));
 }
 
 // TODO(mstensho): Figure out if all of this baseline code is needed here, or if
 // it should be moved down to LayoutBlockFlow. LayoutDeprecatedFlexibleBox and
 // LayoutGrid lack baseline calculation overrides, so the code is here just for
 // them. Just walking the block children in logical order seems rather wrong for
 // those two layout modes, though.
 
 int LayoutBlock::firstLineBoxBaseline() const {
-  ASSERT(!childrenInline());
+  DCHECK(!childrenInline());
   if (isWritingModeRoot() && !isRubyRun())
     return -1;
 
   for (LayoutBox* curr = firstChildBox(); curr; curr = curr->nextSiblingBox()) {
     if (!curr->isFloatingOrOutOfFlowPositioned()) {
       int result = curr->firstLineBoxBaseline();
       if (result != -1)
         return (curr->logicalTop() + result)
             .toInt();  // Translate to our coordinate space.
     }
   }
   return -1;
 }
 
 int LayoutBlock::inlineBlockBaseline(LineDirectionMode lineDirection) const {
-  ASSERT(!childrenInline());
+  DCHECK(!childrenInline());
   if ((!style()->isOverflowVisible() &&
        !shouldIgnoreOverflowPropertyForInlineBlockBaseline()) ||
       style()->containsSize()) {
     // We are not calling LayoutBox::baselinePosition here because the caller
     // should add the margin-top/margin-right, not us.
     return (lineDirection == HorizontalLine ? size().height() + marginBottom()
                                             : size().width() + marginLeft())
         .toInt();
   }
 
@@ skipping 239 matching lines @@
   newBox->setStyle(std::move(newStyle));
   return newBox;
 }
 
 bool LayoutBlock::recalcNormalFlowChildOverflowIfNeeded(
     LayoutObject* layoutObject) {
   if (layoutObject->isOutOfFlowPositioned() ||
       !layoutObject->needsOverflowRecalcAfterStyleChange())
     return false;
 
-  ASSERT(layoutObject->isLayoutBlock());
+  DCHECK(layoutObject->isLayoutBlock());
   return toLayoutBlock(layoutObject)->recalcOverflowAfterStyleChange();
 }
 
 bool LayoutBlock::recalcChildOverflowAfterStyleChange() {
-  ASSERT(childNeedsOverflowRecalcAfterStyleChange());
+  DCHECK(childNeedsOverflowRecalcAfterStyleChange());
   clearChildNeedsOverflowRecalcAfterStyleChange();
 
   bool childrenOverflowChanged = false;
 
   if (childrenInline()) {
     SECURITY_DCHECK(isLayoutBlockFlow());
     childrenOverflowChanged =
         toLayoutBlockFlow(this)->recalcInlineChildrenOverflowAfterStyleChange();
   } else {
     for (LayoutBox* box = firstChildBox(); box; box = box->nextSiblingBox()) {
@@ skipping 20 matching lines @@
     if (!block->recalcOverflowAfterStyleChange() ||
         box->style()->position() == EPosition::kFixed)
       continue;
 
     childrenOverflowChanged = true;
   }
   return childrenOverflowChanged;
 }
 
 bool LayoutBlock::recalcOverflowAfterStyleChange() {
-  ASSERT(needsOverflowRecalcAfterStyleChange());
+  DCHECK(needsOverflowRecalcAfterStyleChange());
 
   bool childrenOverflowChanged = false;
   if (childNeedsOverflowRecalcAfterStyleChange())
     childrenOverflowChanged = recalcChildOverflowAfterStyleChange();
 
   if (!selfNeedsOverflowRecalcAfterStyleChange() && !childrenOverflowChanged)
     return false;
 
   clearSelfNeedsOverflowRecalcAfterStyleChange();
   // If the current block needs layout, overflow will be recalculated during
@@ skipping 54 matching lines @@
     return;
 
   if (TrackedLayoutBoxListHashSet* positionedDescendantSet =
           positionedObjects()) {
     TrackedLayoutBoxListHashSet::const_iterator end =
         positionedDescendantSet->end();
     for (TrackedLayoutBoxListHashSet::const_iterator it =
              positionedDescendantSet->begin();
          it != end; ++it) {
       LayoutBox* currBox = *it;
-      ASSERT(!currBox->needsLayout());
+      DCHECK(!currBox->needsLayout());
     }
   }
 }
 
 #endif
 
 LayoutUnit LayoutBlock::availableLogicalHeightForPercentageComputation() const {
   LayoutUnit availableHeight(-1);
 
   // For anonymous blocks that are skipped during percentage height calculation,
@@ skipping 57 matching lines @@
   }
 
   return availableHeight;
 }
 
 bool LayoutBlock::hasDefiniteLogicalHeight() const {
   return availableLogicalHeightForPercentageComputation() != LayoutUnit(-1);
 }
 
 }  // namespace blink