Replace ASSERT with DCHECK in core/layout/ excluding subdirs

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2000 Dirk Mueller (mueller@kde.org)
  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2011 Apple Inc.
  *               All rights reserved.
  * Copyright (C) 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Torch Mobile Inc. All rights reserved.
  *               (http://www.torchmobile.com/)
@@ skipping 118 matching lines @@
   LayoutPoint m_paintOffset;
   std::unique_ptr<void*> m_rarePaintData;
 };
 
 static_assert(sizeof(LayoutObject) == sizeof(SameSizeAsLayoutObject),
               "LayoutObject should stay small");
 
 bool LayoutObject::s_affectsParentBlock = false;
 
 void* LayoutObject::operator new(size_t sz) {
-  ASSERT(isMainThread());
+  DCHECK(isMainThread());
   return PartitionAlloc(WTF::Partitions::layoutPartition(), sz,
                         WTF_HEAP_PROFILER_TYPE_NAME(LayoutObject));
 }
 
 void LayoutObject::operator delete(void* ptr) {
-  ASSERT(isMainThread());
+  DCHECK(isMainThread());
   WTF::PartitionFree(ptr);
 }
 
 LayoutObject* LayoutObject::createObject(Element* element,
                                          const ComputedStyle& style) {
-  ASSERT(isAllowedToModifyLayoutTreeStructure(element->document()));
+  DCHECK(isAllowedToModifyLayoutTreeStructure(element->document()));
 
   // Minimal support for content properties replacing an entire element.
   // Works only if we have exactly one piece of content and it's a URL.
   // Otherwise acts as if we didn't support this feature.
   const ContentData* contentData = style.contentData();
   if (contentData && !contentData->next() && contentData->isImage() &&
       !element->isPseudoElement()) {
     LayoutImage* image = new LayoutImage(element);
     // LayoutImageResourceStyleImage requires a style being present on the image
     // but we don't want to trigger a style change now as the node is not fully
@@ skipping 100 matching lines @@
     bool insideFlowThread) {
   LayoutObject* next;
   for (LayoutObject* object = this; object; object = next) {
     // If object is a fragmentation context it already updated the descendants
     // flag accordingly.
     if (object->isLayoutFlowThread()) {
       next = object->nextInPreOrderAfterChildren(this);
       continue;
     }
     next = object->nextInPreOrder(this);
-    ASSERT(insideFlowThread != object->isInsideFlowThread());
+    DCHECK_NE(insideFlowThread, object->isInsideFlowThread());
     object->setIsInsideFlowThread(insideFlowThread);
   }
 }
 
 bool LayoutObject::requiresAnonymousTableWrappers(
     const LayoutObject* newChild) const {
   // Check should agree with:
   // CSS 2.1 Tables: 17.2.1 Anonymous table objects
   // http://www.w3.org/TR/CSS21/tables.html#anonymous-boxes
   if (newChild->isLayoutTableCol()) {
     const LayoutTableCol* newTableColumn = toLayoutTableCol(newChild);
     bool isColumnInColumnGroup =
         newTableColumn->isTableColumn() && isLayoutTableCol();
     return !isTable() && !isColumnInColumnGroup;
   }
   if (newChild->isTableCaption())
     return !isTable();
   if (newChild->isTableSection())
     return !isTable();
   if (newChild->isTableRow())
     return !isTableSection();
   if (newChild->isTableCell())
     return !isTableRow();
   return false;
 }
 
 DISABLE_CFI_PERF
 void LayoutObject::addChild(LayoutObject* newChild, LayoutObject* beforeChild) {
-  ASSERT(isAllowedToModifyLayoutTreeStructure(document()));
+  DCHECK(isAllowedToModifyLayoutTreeStructure(document()));
 
   LayoutObjectChildList* children = virtualChildren();
-  ASSERT(children);
+  DCHECK(children);
   if (!children)
     return;
 
   if (requiresAnonymousTableWrappers(newChild)) {
     // Generate an anonymous table or reuse existing one from previous child
     // Per: 17.2.1 Anonymous table objects 3. Generate missing parents
     // http://www.w3.org/TR/CSS21/tables.html#anonymous-boxes
     LayoutTable* table;
     LayoutObject* afterChild =
         beforeChild ? beforeChild->previousSibling() : children->lastChild();
@@ skipping 26 matching lines @@
   // To avoid the problem altogether, detect early if we're inside a hidden SVG
   // subtree and stop creating layers at all for these cases - they're not used
   // anyways.
   if (newChild->hasLayer() && !layerCreationAllowedForSubtree())
     toLayoutBoxModelObject(newChild)
         ->layer()
         ->removeOnlyThisLayerAfterStyleChange();
 }
 
 void LayoutObject::removeChild(LayoutObject* oldChild) {
-  ASSERT(isAllowedToModifyLayoutTreeStructure(document()));
+  DCHECK(isAllowedToModifyLayoutTreeStructure(document()));
 
   LayoutObjectChildList* children = virtualChildren();
-  ASSERT(children);
+  DCHECK(children);
   if (!children)
     return;
 
   children->removeChildNode(this, oldChild);
 }
 
 void LayoutObject::setDangerousOneWayParent(LayoutObject* parent) {
-  ASSERT(!previousSibling());
-  ASSERT(!nextSibling());
-  ASSERT(!parent || !m_parent);
+  DCHECK(!previousSibling());
+  DCHECK(!nextSibling());
+  DCHECK(!parent || !m_parent);
   setParent(parent);
 }
 
 void LayoutObject::registerSubtreeChangeListenerOnDescendants(bool value) {
   // If we're set to the same value then we're done as that means it's
   // set down the tree that way already.
   if (m_bitfields.subtreeChangeListenerRegistered() == value)
     return;
 
   m_bitfields.setSubtreeChangeListenerRegistered(value);
@@ skipping 20 matching lines @@
   notifyAncestorsOfSubtreeChange();
 
   // We can modify the layout tree during layout which means that we may
   // try to schedule this during performLayout. This should no longer
   // happen when crbug.com/370457 is fixed.
   DeprecatedScheduleStyleRecalcDuringLayout marker(document().lifecycle());
   document().scheduleLayoutTreeUpdateIfNeeded();
 }
 
 void LayoutObject::handleSubtreeModifications() {
-  ASSERT(wasNotifiedOfSubtreeChange());
-  ASSERT(document().lifecycle().stateAllowsLayoutTreeNotifications());
+  DCHECK(wasNotifiedOfSubtreeChange());
+  DCHECK(document().lifecycle().stateAllowsLayoutTreeNotifications());
 
   if (consumesSubtreeChangeNotification())
     subtreeDidChange();
 
   m_bitfields.setNotifiedOfSubtreeChange(false);
 
   for (LayoutObject* object = slowFirstChild(); object;
        object = object->nextSibling()) {
     if (!object->wasNotifiedOfSubtreeChange())
       continue;
@@ skipping 132 matching lines @@
   for (LayoutObject* curr = slowFirstChild(); curr; curr = curr->nextSibling())
     curr->removeLayers(parentLayer);
 }
 
 void LayoutObject::moveLayers(PaintLayer* oldParent, PaintLayer* newParent) {
   if (!newParent)
     return;
 
   if (hasLayer()) {
     PaintLayer* layer = toLayoutBoxModelObject(this)->layer();
-    ASSERT(oldParent == layer->parent());
+    DCHECK_EQ(oldParent, layer->parent());
     if (oldParent)
       oldParent->removeChild(layer);
     newParent->addChild(layer);
     return;
   }
 
   for (LayoutObject* curr = slowFirstChild(); curr; curr = curr->nextSibling())
     curr->moveLayers(oldParent, newParent);
 }
 
@@ skipping 116 matching lines @@
 
     LayoutBox* ancestorBox = toLayoutBox(ancestor);
     if (ancestorBox->canBeScrolledAndHasScrollableArea())
       return ancestorBox;
   }
 
   return nullptr;
 }
 
 LayoutFlowThread* LayoutObject::locateFlowThreadContainingBlock() const {
-  ASSERT(isInsideFlowThread());
+  DCHECK(isInsideFlowThread());
 
   // See if we have the thread cached because we're in the middle of layout.
   if (LayoutState* layoutState = view()->layoutState()) {
     // TODO(mstensho): We should really just return whatever
     // layoutState->flowThread() returns here, also if the value is nullptr.
     if (LayoutFlowThread* flowThread = layoutState->flowThread())
       return flowThread;
   }
 
   // Not in the middle of layout so have to find the thread the slow way.
@@ skipping 58 matching lines @@
     return false;
 
   return true;
 }
 
 void LayoutObject::markContainerChainForLayout(bool scheduleRelayout,
                                                SubtreeLayoutScope* layouter) {
 #if DCHECK_IS_ON()
   DCHECK(!isSetNeedsLayoutForbidden());
 #endif
-  ASSERT(!layouter || this != layouter->root());
+  DCHECK(!layouter || this != layouter->root());
   // When we're in layout, we're marking a descendant as needing layout with
   // the intention of visiting it during this layout. We shouldn't be
   // scheduling it to be laid out later. Also, scheduleRelayout() must not be
   // called while iterating FrameView::m_layoutSubtreeRootList.
   scheduleRelayout &= !frameView()->isInPerformLayout();
 
   LayoutObject* object = container();
   LayoutObject* last = this;
 
   bool simplifiedNormalFlowLayout = needsSimplifiedNormalFlowLayout() &&
@@ skipping 40 matching lines @@
       break;
     object = container;
   }
 
   if (scheduleRelayout)
     last->scheduleRelayout();
 }
 
 #if DCHECK_IS_ON()
 void LayoutObject::checkBlockPositionedObjectsNeedLayout() {
-  ASSERT(!needsLayout());
+  DCHECK(!needsLayout());
 
   if (isLayoutBlock())
     toLayoutBlock(this)->checkPositionedObjectsNeedLayout();
 }
 #endif
 
 void LayoutObject::setPreferredLogicalWidthsDirty(MarkingBehavior markParents) {
   m_bitfields.setPreferredLogicalWidthsDirty(true);
   if (markParents == MarkContainerChain &&
       (isText() || !style()->hasOutOfFlowPosition()))
@@ skipping 43 matching lines @@
     AncestorSkipInfo* skipInfo) const {
   DCHECK(!isText());
 
   LayoutObject* object = parent();
   for (; object && !object->canContainFixedPositionObjects();
        object = object->parent()) {
     if (skipInfo)
       skipInfo->update(*object);
   }
 
-  ASSERT(!object || !object->isAnonymousBlock());
+  DCHECK(!object || !object->isAnonymousBlock());
   return toLayoutBlock(object);
 }
 
 LayoutBlock* LayoutObject::containingBlockForAbsolutePosition(
     AncestorSkipInfo* skipInfo) const {
   LayoutObject* object = containerForAbsolutePosition(skipInfo);
 
   // For relpositioned inlines, we return the nearest non-anonymous enclosing
   // block. We don't try to return the inline itself. This allows us to avoid
   // having a positioned objects list in all LayoutInlines and lets us return a
@@ skipping 274 matching lines @@
 
 LayoutRect LayoutObject::selectionRectInViewCoordinates() const {
   LayoutRect selectionRect = localSelectionRect();
   if (!selectionRect.isEmpty())
     mapToVisualRectInAncestorSpace(view(), selectionRect);
   return selectionRect;
 }
 
 PaintInvalidationReason LayoutObject::invalidatePaintIfNeeded(
     const PaintInvalidationState& paintInvalidationState) {
-  DCHECK(&paintInvalidationState.currentObject() == this);
+  DCHECK_EQ(&paintInvalidationState.currentObject(), this);
 
   if (styleRef().hasOutline()) {
     PaintLayer& layer = paintInvalidationState.paintingLayer();
     if (&layer.layoutObject() != this)
       layer.setNeedsPaintPhaseDescendantOutlines();
   }
 
   LayoutView* v = view();
   if (v->document().printing())
     return PaintInvalidationNone;  // Don't invalidate paints if we're printing.
@@ skipping 351 matching lines @@
     bool requiresLayer =
         toLayoutBoxModelObject(this)->layerTypeRequired() != NoPaintLayer;
     if (hasLayer() != requiresLayer)
       diff.setNeedsFullLayout();
   }
 
   return diff;
 }
 
 void LayoutObject::setPseudoStyle(PassRefPtr<ComputedStyle> pseudoStyle) {
-  ASSERT(pseudoStyle->styleType() == PseudoIdBefore ||
+  DCHECK(pseudoStyle->styleType() == PseudoIdBefore ||
          pseudoStyle->styleType() == PseudoIdAfter ||
          pseudoStyle->styleType() == PseudoIdFirstLetter);
 
   // FIXME: We should consider just making all pseudo items use an inherited
   // style.
 
   // Images are special and must inherit the pseudoStyle so the width and height
   // of the pseudo element doesn't change the size of the image. In all other
   // cases we can just share the style.
   //
@@ skipping 58 matching lines @@
 
 void LayoutObject::setNeedsOverflowRecalcAfterStyleChange() {
   bool neededRecalc = needsOverflowRecalcAfterStyleChange();
   setSelfNeedsOverflowRecalcAfterStyleChange();
   if (!neededRecalc)
     markAncestorsForOverflowRecalcIfNeeded();
 }
 
 DISABLE_CFI_PERF
 void LayoutObject::setStyle(PassRefPtr<ComputedStyle> style) {
-  ASSERT(style);
+  DCHECK(style);
 
   if (m_style == style) {
     // We need to run through adjustStyleDifference() for iframes, plugins, and
     // canvas so style sharing is disabled for them. That should ensure that we
     // never hit this code path.
-    ASSERT(!isLayoutIFrame() && !isEmbeddedObject() && !isCanvas());
+    DCHECK(!isLayoutIFrame());
+    DCHECK(!isEmbeddedObject());
+    DCHECK(!isCanvas());
     return;
   }
 
   StyleDifference diff;
   if (m_style)
     diff = m_style->visualInvalidationDiff(*style);
 
   diff = adjustStyleDifference(diff);
 
   styleWillChange(diff, *style);
@@ skipping 180 matching lines @@
   if (!node())
     return;
   if (!node()->isElementNode())
     return;
   if (ElementAnimations* animations = toElement(node())->elementAnimations())
     animations->clearBaseComputedStyle();
 }
 
 static bool areNonIdenticalCursorListsEqual(const ComputedStyle* a,
                                             const ComputedStyle* b) {
-  ASSERT(a->cursors() != b->cursors());
+  DCHECK_NE(a->cursors(), b->cursors());
   return a->cursors() && b->cursors() && *a->cursors() == *b->cursors();
 }
 
 static inline bool areCursorsEqual(const ComputedStyle* a,
                                    const ComputedStyle* b) {
   return a->cursor() == b->cursor() && (a->cursors() == b->cursors() ||
                                         areNonIdenticalCursorListsEqual(a, b));
 }
 
 void LayoutObject::setScrollAnchorDisablingStyleChangedOnAncestor() {
@@ skipping 428 matching lines @@
   transform.makeIdentity();
   transform.translate(offsetInContainer.width().toFloat(),
                       offsetInContainer.height().toFloat());
   PaintLayer* layer = hasLayer() ? toLayoutBoxModelObject(this)->layer() : 0;
   if (layer && layer->transform())
     transform.multiply(layer->currentTransform());
 
   if (containerObject && containerObject->hasLayer() &&
       containerObject->style()->hasPerspective()) {
     // Perpsective on the container affects us, so we have to factor it in here.
-    ASSERT(containerObject->hasLayer());
+    DCHECK(containerObject->hasLayer());
     FloatPoint perspectiveOrigin =
         toLayoutBoxModelObject(containerObject)->layer()->perspectiveOrigin();
 
     TransformationMatrix perspectiveMatrix;
     perspectiveMatrix.applyPerspective(containerObject->style()->perspective());
 
     transform.translateRight3d(-perspectiveOrigin.x(), -perspectiveOrigin.y(),
                                0);
     transform = perspectiveMatrix * transform;
     transform.translateRight3d(perspectiveOrigin.x(), perspectiveOrigin.y(), 0);
@@ skipping 68 matching lines @@
 TransformationMatrix LayoutObject::localToAncestorTransform(
     const LayoutBoxModelObject* ancestor,
     MapCoordinatesFlags mode) const {
   TransformState transformState(TransformState::ApplyTransformDirection);
   mapLocalToAncestor(ancestor, transformState,
                      mode | ApplyContainerFlip | UseTransforms);
   return transformState.accumulatedTransform();
 }
 
 LayoutSize LayoutObject::offsetFromContainer(const LayoutObject* o) const {
-  ASSERT(o == container());
+  DCHECK_EQ(o, container());
   return o->hasOverflowClip()
              ? LayoutSize(-toLayoutBox(o)->scrolledContentOffset())
              : LayoutSize();
 }
 
 LayoutSize LayoutObject::offsetFromAncestorContainer(
     const LayoutObject* ancestorContainer) const {
   if (ancestorContainer == this)
     return LayoutSize();
 
   LayoutSize offset;
   LayoutPoint referencePoint;
   const LayoutObject* currContainer = this;
   do {
     const LayoutObject* nextContainer = currContainer->container();
     // This means we reached the top without finding container.
     DCHECK(nextContainer);
     if (!nextContainer)
       break;
-    ASSERT(!currContainer->hasTransformRelatedProperty());
+    DCHECK(!currContainer->hasTransformRelatedProperty());
     LayoutSize currentOffset =
         currContainer->offsetFromContainer(nextContainer);
     offset += currentOffset;
     referencePoint.move(currentOffset);
     currContainer = nextContainer;
   } while (currContainer != ancestorContainer);
 
   return offset;
 }
 
@@ skipping 29 matching lines @@
   }
 
   this->addLayerHitTestRects(layerRects, currentLayer, layerOffset,
                              LayoutRect());
 }
 
 void LayoutObject::addLayerHitTestRects(LayerHitTestRects& layerRects,
                                         const PaintLayer* currentLayer,
                                         const LayoutPoint& layerOffset,
                                         const LayoutRect& containerRect) const {
-  ASSERT(currentLayer);
-  ASSERT(currentLayer == this->enclosingLayer());
+  DCHECK(currentLayer);
+  DCHECK_EQ(currentLayer, this->enclosingLayer());
 
   // Compute the rects for this layoutObject only and add them to the results.
   // Note that we could avoid passing the offset and instead adjust each result,
   // but this seems slightly simpler.
   Vector<LayoutRect> ownRects;
   LayoutRect newContainerRect;
   computeSelfHitTestRects(ownRects, layerOffset);
 
   // When we get to have a lot of rects on a layer, the performance cost of
   // tracking those rects outweighs the benefit of doing compositor thread hit
@@ skipping 214 matching lines @@
     removeShapeImageClient(m_style->shapeOutside());
     removeCursorImageClient(m_style->cursors());
   }
 
   if (frameView())
     setIsBackgroundAttachmentFixedObject(false);
 }
 
 DISABLE_CFI_PERF
 void LayoutObject::insertedIntoTree() {
-  // FIXME: We should ASSERT(isRooted()) here but generated content makes some
+  // FIXME: We should DCHECK(isRooted()) here but generated content makes some
   // out-of-order insertion.
 
   // Keep our layer hierarchy updated. Optimize for the common case where we
   // don't have any children and don't have a layer attached to ourselves.
   PaintLayer* layer = nullptr;
   if (slowFirstChild() || hasLayer()) {
     layer = parent()->enclosingLayer();
     addLayers(layer);
   }
 
@@ skipping 46 matching lines @@
     if (anchor->refersTo(layoutObject)) {
       found = true;
       if (behavior == Clear)
         anchor->notifyRemoved(layoutObject);
     }
   }
   return found;
 }
 
 void LayoutObject::willBeRemovedFromTree() {
-  // FIXME: We should ASSERT(isRooted()) but we have some out-of-order removals
+  // FIXME: We should DCHECK(isRooted()) but we have some out-of-order removals
   // which would need to be fixed first.
 
   // If we remove a visible child from an invisible parent, we don't know the
   // layer visibility any more.
   PaintLayer* layer = nullptr;
   if (parent()->style()->visibility() != EVisibility::kVisible &&
       style()->visibility() == EVisibility::kVisible && !hasLayer()) {
     layer = parent()->enclosingLayer();
     if (layer)
       layer->dirtyVisibleContentStatus();
@@ skipping 281 matching lines @@
           PseudoStyleRequest(PseudoIdFirstLineInherited), parentStyle);
     }
   }
   return nullptr;
 }
 
 PassRefPtr<ComputedStyle> LayoutObject::uncachedFirstLineStyle() const {
   if (!document().styleEngine().usesFirstLineRules())
     return nullptr;
 
-  ASSERT(!isText());
+  DCHECK(!isText());
 
   return firstLineStyleForCachedUncachedType(Uncached, this, m_style.get());
 }
 
 ComputedStyle* LayoutObject::cachedFirstLineStyle() const {
-  ASSERT(document().styleEngine().usesFirstLineRules());
+  DCHECK(document().styleEngine().usesFirstLineRules());
 
   if (RefPtr<ComputedStyle> style = firstLineStyleForCachedUncachedType(
           Cached, isText() ? parent() : this, m_style.get()))
     return style.get();
 
   return m_style.get();
 }
 
 ComputedStyle* LayoutObject::getCachedPseudoStyle(
     PseudoId pseudo,
@@ skipping 113 matching lines @@
 
 bool LayoutObject::isInert() const {
   const LayoutObject* layoutObject = this;
   while (!layoutObject->node())
     layoutObject = layoutObject->parent();
   return layoutObject->node()->isInert();
 }
 
 void LayoutObject::imageChanged(ImageResourceContent* image,
                                 const IntRect* rect) {
-  ASSERT(m_node);
+  DCHECK(m_node);
 
   // Image change notifications should not be received during paint because
   // the resulting invalidations will be cleared following paint. This can also
   // lead to modifying the tree out from under paint(), see: crbug.com/616700.
-  DCHECK(document().lifecycle().state() !=
-         DocumentLifecycle::LifecycleState::InPaint);
+  DCHECK_NE(document().lifecycle().state(),
+            DocumentLifecycle::LifecycleState::InPaint);
 
   imageChanged(static_cast<WrappedImagePtr>(image), rect);
 }
 
 Element* LayoutObject::offsetParent(const Element* base) const {
   if (isDocumentElement() || isBody())
     return nullptr;
 
   if (isFixedPositioned())
     return nullptr;
@@ skipping 102 matching lines @@
 
 PositionWithAffinity LayoutObject::createPositionWithAffinity(int offset) {
   return createPositionWithAffinity(offset, TextAffinity::Downstream);
 }
 
 PositionWithAffinity LayoutObject::createPositionWithAffinity(
     const Position& position) {
   if (position.isNotNull())
     return PositionWithAffinity(position);
 
-  ASSERT(!node());
+  DCHECK(!node());
   return createPositionWithAffinity(0);
 }
 
 CursorDirective LayoutObject::getCursor(const LayoutPoint&, Cursor&) const {
   return SetCursorBasedOnStyle;
 }
 
 bool LayoutObject::canUpdateSelectionOnRootLineBoxes() const {
   if (needsLayout())
     return false;
@@ skipping 189 matching lines @@
 void LayoutObject::
     setShouldDoFullPaintInvalidationIncludingNonCompositingDescendants() {
   // Clear first because PaintInvalidationSubtree overrides other full paint
   // invalidation reasons.
   clearShouldDoFullPaintInvalidation();
   setShouldDoFullPaintInvalidation(PaintInvalidationSubtree);
 }
 
 void LayoutObject::setIsBackgroundAttachmentFixedObject(
     bool isBackgroundAttachmentFixedObject) {
-  ASSERT(frameView());
+  DCHECK(frameView());
   if (m_bitfields.isBackgroundAttachmentFixedObject() ==
       isBackgroundAttachmentFixedObject)
     return;
   m_bitfields.setIsBackgroundAttachmentFixedObject(
       isBackgroundAttachmentFixedObject);
   if (isBackgroundAttachmentFixedObject)
     frameView()->addBackgroundAttachmentFixedObject(this);
   else
     frameView()->removeBackgroundAttachmentFixedObject(this);
 }
@@ skipping 118 matching lines @@
     const blink::LayoutObject* root = object1;
     while (root->parent())
       root = root->parent();
     root->showLayoutTreeAndMark(object1, "*", object2, "-", 0);
   } else {
     WTFLogAlways("%s", "Cannot showLayoutTree. Root is (nil)");
   }
 }
 
 #endif