Replace ASSERT with DCHECK in core/layout/ excluding subdirs

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

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 Apple 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
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
@@ skipping 160 matching lines @@
   for (LayoutInline* currCont = continuation; currCont;
        currCont = currCont->inlineElementContinuation()) {
     LayoutBoxModelObject* nextCont = currCont->continuation();
     currCont->setContinuation(nullptr);
     currCont->setStyle(mutableStyle());
     currCont->setContinuation(nextCont);
     endOfContinuation = currCont;
   }
 
   if (continuation && oldStyle) {
-    ASSERT(endOfContinuation);
+    DCHECK(endOfContinuation);
     LayoutObject* block = containingBlock()->nextSibling();
     // If an inline's in-flow positioning has changed then any descendant blocks
     // will need to change their styles accordingly.
     if (block && block->isAnonymousBlock() &&
         newStyle.position() != oldStyle->position() &&
         (newStyle.hasInFlowPosition() || oldStyle->hasInFlowPosition()))
       updateInFlowPositionOfAnonymousBlockContinuations(
           block, newStyle, *oldStyle, endOfContinuation->containingBlock());
   }
 
@@ skipping 195 matching lines @@
     to->addChildIgnoringContinuation(
         children()->removeChildNode(this, currentChild), nullptr);
   }
 }
 
 void LayoutInline::splitInlines(LayoutBlockFlow* fromBlock,
                                 LayoutBlockFlow* toBlock,
                                 LayoutBlockFlow* middleBlock,
                                 LayoutObject* beforeChild,
                                 LayoutBoxModelObject* oldCont) {
-  ASSERT(isDescendantOf(fromBlock));
+  DCHECK(isDescendantOf(fromBlock));
 
   // If we're splitting the inline containing the fullscreened element,
   // |beforeChild| may be the layoutObject for the fullscreened element.
   // However, that layoutObject is wrapped in a LayoutFullScreen, so |this| is
   // not its parent. Since the splitting logic expects |this| to be the parent,
   // set |beforeChild| to be the LayoutFullScreen.
   if (Fullscreen* fullscreen = Fullscreen::fromIfExists(document())) {
     const Element* fullScreenElement = fullscreen->currentFullScreenElement();
     if (fullScreenElement && beforeChild &&
         beforeChild->node() == fullScreenElement)
@@ skipping 55 matching lines @@
     // *after* |current| and append them all to the |cloneInlineParent|.
     currentParent->moveChildrenToIgnoringContinuation(cloneInlineParent,
                                                       current->nextSibling());
 
     currentParent = current;
     cloneInlineParent = cloneInline;
   }
 
   // The last inline to clone is |this|, and the current |cloneInline| is cloned
   // from |this|.
-  ASSERT(this == inlinesToClone.front());
+  DCHECK_EQ(this, inlinesToClone.front());
 
   // Hook |cloneInline| up as the continuation of the middle block.
   cloneInline->setContinuation(oldCont);
   middleBlock->setContinuation(cloneInline);
 
   // Now take all of the children from |beforeChild| to the end and remove
   // them from |this| and place them in the clone.
   moveChildrenToIgnoringContinuation(cloneInline, beforeChild);
 }
 
@@ skipping 67 matching lines @@
       LayoutInvalidationReason::AnonymousBlockChange);
   post->setNeedsLayoutAndPrefWidthsRecalcAndFullPaintInvalidation(
       LayoutInvalidationReason::AnonymousBlockChange);
 }
 
 void LayoutInline::addChildToContinuation(LayoutObject* newChild,
                                           LayoutObject* beforeChild) {
   // A continuation always consists of two potential candidates: an inline or an
   // anonymous block box holding block children.
   LayoutBoxModelObject* flow = continuationBefore(beforeChild);
-  ASSERT(!beforeChild || beforeChild->parent()->isAnonymousBlock() ||
+  DCHECK(!beforeChild || beforeChild->parent()->isAnonymousBlock() ||
          beforeChild->parent()->isLayoutInline());
   LayoutBoxModelObject* beforeChildParent = nullptr;
   if (beforeChild) {
     beforeChildParent = toLayoutBoxModelObject(beforeChild->parent());
   } else {
     LayoutBoxModelObject* cont = nextContinuation(flow);
     if (cont)
       beforeChildParent = cont;
     else
       beforeChildParent = flow;
@@ skipping 42 matching lines @@
 
 static inline void computeItemTopHeight(const LayoutInline* container,
                                         const RootInlineBox& rootBox,
                                         LayoutUnit* top,
                                         LayoutUnit* height) {
   bool firstLine = rootBox.isFirstLineStyle();
   const SimpleFontData* fontData =
       rootBox.getLineLayoutItem().style(firstLine)->font().primaryFont();
   const SimpleFontData* containerFontData =
       container->style(firstLine)->font().primaryFont();
-  DCHECK(fontData && containerFontData);
+  DCHECK(fontData);
+  DCHECK(containerFontData);
   if (!fontData || !containerFontData) {
     *top = LayoutUnit();
     *height = LayoutUnit();
     return;
   }
   auto metrics = fontData->getFontMetrics();
   auto containerMetrics = containerFontData->getFontMetrics();
   *top = rootBox.logicalTop() + (metrics.ascent() - containerMetrics.ascent());
   *height = LayoutUnit(containerMetrics.height());
 }
@@ skipping 258 matching lines @@
   Region& m_region;
   const HitTestLocation& m_location;
 };
 
 }  // unnamed namespace
 
 bool LayoutInline::hitTestCulledInline(
     HitTestResult& result,
     const HitTestLocation& locationInContainer,
     const LayoutPoint& accumulatedOffset) {
-  ASSERT(!alwaysCreateLineBoxes());
+  DCHECK(!alwaysCreateLineBoxes());
   if (!visibleToHitTestRequest(result.hitTestRequest()))
     return false;
 
   HitTestLocation adjustedLocation(locationInContainer,
                                    -toLayoutSize(accumulatedOffset));
 
   Region regionResult;
   HitTestCulledInlinesGeneratorContext context(regionResult, adjustedLocation);
   generateCulledLineBoxRects(context, this);
 
@@ skipping 37 matching lines @@
   void operator()(const LayoutRect& rect) { operator()(FloatRect(rect)); }
 
  private:
   FloatRect& m_rect;
 };
 
 }  // unnamed namespace
 
 LayoutRect LayoutInline::linesBoundingBox() const {
   if (!alwaysCreateLineBoxes()) {
-    ASSERT(!firstLineBox());
+    DCHECK(!firstLineBox());
     FloatRect floatResult;
     LinesBoundingBoxGeneratorContext context(floatResult);
     generateCulledLineBoxRects(context, this);
     return enclosingLayoutRect(floatResult);
   }
 
   LayoutRect result;
 
   // See <rdar://problem/5289721>, for an unknown reason the linked list here is
   // sometimes inconsistent, first is non-zero and last is zero.  We have been
   // unable to reproduce this at all (and consequently unable to figure ot why
   // this is happening).  The assert will hopefully catch the problem in debug
   // builds and help us someday figure out why.  We also put in a redundant
   // check of lastLineBox() to avoid the crash for now.
-  ASSERT(!firstLineBox() ==
-         !lastLineBox());  // Either both are null or both exist.
+  DCHECK_EQ(!firstLineBox(),
+            !lastLineBox());  // Either both are null or both exist.
   if (firstLineBox() && lastLineBox()) {
     // Return the width of the minimal left side and the maximal right side.
     LayoutUnit logicalLeftSide;
     LayoutUnit logicalRightSide;
     for (InlineFlowBox* curr = firstLineBox(); curr;
          curr = curr->nextLineBox()) {
       if (curr == firstLineBox() || curr->logicalLeft() < logicalLeftSide)
         logicalLeftSide = curr->logicalLeft();
       if (curr == firstLineBox() || curr->logicalRight() > logicalRightSide)
         logicalRightSide = curr->logicalRight();
@@ skipping 212 matching lines @@
 }
 
 bool LayoutInline::mapToVisualRectInAncestorSpaceInternal(
     const LayoutBoxModelObject* ancestor,
     TransformState& transformState,
     VisualRectFlags visualRectFlags) const {
   if (ancestor == this)
     return true;
 
   LayoutObject* container = this->container();
-  ASSERT(container == parent());
+  DCHECK_EQ(container, parent());
   if (!container)
     return true;
 
   bool preserve3D = container->style()->preserves3D();
 
   TransformState::TransformAccumulation accumulation =
       preserve3D ? TransformState::AccumulateTransform
                  : TransformState::FlattenTransform;
 
   if (style()->hasInFlowPosition() && layer()) {
@@ skipping 18 matching lines @@
     LayoutRect rect(transformState.lastPlanarQuad().boundingBox());
     containerBox->flipForWritingMode(rect);
     transformState.setQuad(FloatQuad(FloatRect(rect)));
   }
   return container->mapToVisualRectInAncestorSpaceInternal(
       ancestor, transformState, visualRectFlags);
 }
 
 LayoutSize LayoutInline::offsetFromContainer(
     const LayoutObject* container) const {
-  ASSERT(container == this->container());
+  DCHECK_EQ(container, this->container());
 
   LayoutSize offset;
   if (isInFlowPositioned())
     offset += offsetForInFlowPosition();
 
   if (container->hasOverflowClip())
     offset -= toLayoutBox(container)->scrolledContentOffset();
 
   return offset;
 }
@@ skipping 96 matching lines @@
       return LayoutUnit(s->computedLineHeight());
   }
 
   return LayoutUnit(style()->computedLineHeight());
 }
 
 int LayoutInline::baselinePosition(FontBaseline baselineType,
                                    bool firstLine,
                                    LineDirectionMode direction,
                                    LinePositionMode linePositionMode) const {
-  ASSERT(linePositionMode == PositionOnContainingLine);
+  DCHECK_EQ(linePositionMode, PositionOnContainingLine);
   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()) /
               2)
       .toInt();
 }
 
 LayoutSize LayoutInline::offsetForInFlowPositionedInline(
     const LayoutBox& child) const {
   // FIXME: This function isn't right with mixed writing modes.
 
-  ASSERT(isInFlowPositioned());
+  DCHECK(isInFlowPositioned());
   if (!isInFlowPositioned())
     return LayoutSize();
 
   // When we have an enclosing relpositioned inline, we need to add in the
   // offset of the first line box from the rest of the content, but only in the
   // cases where we know we're positioned relative to the inline itself.
 
   LayoutSize logicalOffset;
   LayoutUnit inlinePosition;
   LayoutUnit blockPosition;
@@ skipping 140 matching lines @@
     paintInvalidator.invalidateDisplayItemClient(*box, invalidationReason);
 }
 
 // TODO(lunalu): Not to just dump 0, 0 as the x and y here
 LayoutRect LayoutInline::debugRect() const {
   IntRect linesBox = enclosingIntRect(linesBoundingBox());
   return LayoutRect(IntRect(0, 0, linesBox.width(), linesBox.height()));
 }
 
 }  // namespace blink