Replace ASSERT with DCHECK in core/layout/<sub dirs>

third_party/WebKit/Source/core/layout/svg/LayoutSVGText.cpp

 /*
  * Copyright (C) 2006 Apple Computer, Inc.
  * Copyright (C) 2006 Alexander Kellett <lypanov@kde.org>
  * Copyright (C) 2006 Oliver Hunt <ojh16@student.canterbury.ac.nz>
  * Copyright (C) 2007 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2008 Rob Buis <buis@kde.org>
  * Copyright (C) 2009 Dirk Schulze <krit@webkit.org>
  * Copyright (C) Research In Motion Limited 2010-2012. All rights reserved.
  * Copyright (C) 2012 Google Inc.
  *
@@ skipping 32 matching lines @@
 #include "core/paint/SVGTextPainter.h"
 #include "core/style/ShadowList.h"
 #include "core/svg/SVGTextElement.h"
 #include "platform/geometry/FloatQuad.h"
 
 namespace blink {
 
 namespace {
 
 const LayoutSVGText* findTextRoot(const LayoutObject* start) {
-  ASSERT(start);
+  DCHECK(start);
   for (; start; start = start->parent()) {
     if (start->isSVGText())
       return toLayoutSVGText(start);
   }
   return nullptr;
 }
 
 }  // namespace
 
 LayoutSVGText::LayoutSVGText(SVGTextElement* node)
     : LayoutSVGBlock(node),
       m_needsReordering(false),
       m_needsPositioningValuesUpdate(false),
       m_needsTransformUpdate(true),
       m_needsTextMetricsUpdate(false) {}
 
 LayoutSVGText::~LayoutSVGText() {
-  ASSERT(m_descendantTextNodes.isEmpty());
+  DCHECK(m_descendantTextNodes.isEmpty());
 }
 
 void LayoutSVGText::willBeDestroyed() {
   m_descendantTextNodes.clear();
 
   LayoutSVGBlock::willBeDestroyed();
 }
 
 bool LayoutSVGText::isChildAllowed(LayoutObject* child,
                                    const ComputedStyle&) const {
@@ skipping 22 matching lines @@
 
 void LayoutSVGText::invalidatePositioningValues(
     LayoutInvalidationReasonForTracing reason) {
   m_descendantTextNodes.clear();
   setNeedsPositioningValuesUpdate();
   setNeedsLayoutAndFullPaintInvalidation(reason);
 }
 
 void LayoutSVGText::subtreeChildWasAdded() {
   if (beingDestroyed() || !everHadLayout()) {
-    ASSERT(m_descendantTextNodes.isEmpty());
+    DCHECK(m_descendantTextNodes.isEmpty());
     return;
   }
   if (documentBeingDestroyed())
     return;
 
   // The positioning elements cache depends on the size of each text
   // layoutObject in the subtree. If this changes, clear the cache. It will be
   // rebuilt on the next layout.
   invalidatePositioningValues(LayoutInvalidationReason::ChildChanged);
   setNeedsTextMetricsUpdate();
 }
 
 void LayoutSVGText::subtreeChildWillBeRemoved() {
   if (beingDestroyed() || !everHadLayout()) {
-    ASSERT(m_descendantTextNodes.isEmpty());
+    DCHECK(m_descendantTextNodes.isEmpty());
     return;
   }
 
   // The positioning elements cache depends on the size of each text
   // layoutObject in the subtree. If this changes, clear the cache. It will be
   // rebuilt on the next layout.
   invalidatePositioningValues(LayoutInvalidationReason::ChildChanged);
   setNeedsTextMetricsUpdate();
 }
 
 void LayoutSVGText::subtreeTextDidChange() {
-  ASSERT(!beingDestroyed());
+  DCHECK(!beingDestroyed());
   if (!everHadLayout()) {
-    ASSERT(m_descendantTextNodes.isEmpty());
+    DCHECK(m_descendantTextNodes.isEmpty());
     return;
   }
 
   // The positioning elements cache depends on the size of each text object in
   // the subtree. If this changes, clear the cache and mark it for rebuilding
   // in the next layout.
   invalidatePositioningValues(LayoutInvalidationReason::TextChanged);
   setNeedsTextMetricsUpdate();
 }
 
 static inline void updateFontAndMetrics(LayoutSVGText& textRoot) {
   bool lastCharacterWasWhiteSpace = true;
   for (LayoutObject* descendant = textRoot.firstChild(); descendant;
        descendant = descendant->nextInPreOrder(&textRoot)) {
     if (!descendant->isSVGInlineText())
       continue;
     LayoutSVGInlineText& text = toLayoutSVGInlineText(*descendant);
     text.updateScaledFont();
     text.updateMetricsList(lastCharacterWasWhiteSpace);
   }
 }
 
 static inline void checkDescendantTextNodeConsistency(
     LayoutSVGText& text,
     Vector<LayoutSVGInlineText*>& expectedDescendantTextNodes) {
 #if DCHECK_IS_ON()
   Vector<LayoutSVGInlineText*> newDescendantTextNodes;
   collectDescendantTextNodes(text, newDescendantTextNodes);
-  ASSERT(newDescendantTextNodes == expectedDescendantTextNodes);
+  DCHECK(newDescendantTextNodes == expectedDescendantTextNodes);
 #endif
 }
 
 void LayoutSVGText::layout() {
-  ASSERT(needsLayout());
+  DCHECK(needsLayout());
   // This flag is set and reset as needed only within this function.
-  ASSERT(!m_needsReordering);
+  DCHECK(!m_needsReordering);
   LayoutAnalyzer::Scope analyzer(*this);
 
   bool updateParentBoundaries = false;
   if (m_needsTransformUpdate) {
     m_localTransform = toSVGTextElement(node())->calculateTransform(
         SVGElement::IncludeMotionTransform);
     m_needsTransformUpdate = false;
     updateParentBoundaries = true;
   }
 
@@ skipping 26 matching lines @@
     m_needsPositioningValuesUpdate = false;
     m_needsReordering = true;
     updateParentBoundaries = true;
   }
 
   checkDescendantTextNodeConsistency(*this, m_descendantTextNodes);
 
   // Reduced version of LayoutBlock::layoutBlock(), which only takes care of SVG
   // text. All if branches that could cause early exit in LayoutBlocks
   // layoutBlock() method are turned into assertions.
-  ASSERT(!isInline());
-  ASSERT(!simplifiedLayout());
-  ASSERT(!scrollsOverflow());
-  ASSERT(!hasControlClip());
-  ASSERT(!positionedObjects());
-  ASSERT(!isAnonymousBlock());
+  DCHECK(!isInline());
+  DCHECK(!simplifiedLayout());
+  DCHECK(!scrollsOverflow());
+  DCHECK(!hasControlClip());
+  DCHECK(!positionedObjects());
+  DCHECK(!isAnonymousBlock());
 
   if (!firstChild())
     setChildrenInline(true);
 
   // FIXME: We need to find a way to only layout the child boxes, if needed.
   FloatRect oldBoundaries = objectBoundingBox();
-  ASSERT(childrenInline());
+  DCHECK(childrenInline());
 
   rebuildFloatsFromIntruding();
 
   LayoutUnit beforeEdge = borderBefore() + paddingBefore();
   LayoutUnit afterEdge =
       borderAfter() + paddingAfter() + scrollbarLogicalHeight();
   setLogicalHeight(beforeEdge);
 
   LayoutState state(*this);
   layoutInlineChildren(true, afterEdge);
 
   m_needsReordering = false;
 
   FloatRect newBoundaries = objectBoundingBox();
   if (!updateParentBoundaries)
     updateParentBoundaries = oldBoundaries != newBoundaries;
 
   m_overflow.reset();
   addSelfVisualOverflow(LayoutRect(newBoundaries));
   addVisualEffectOverflow();
 
   // Invalidate all resources of this client if our layout changed.
   if (everHadLayout() && selfNeedsLayout())
     SVGResourcesCache::clientLayoutChanged(this);
 
   // If our bounds changed, notify the parents.
   if (updateParentBoundaries)
     LayoutSVGBlock::setNeedsBoundariesUpdate();
 
-  ASSERT(!m_needsReordering);
-  ASSERT(!m_needsTransformUpdate);
-  ASSERT(!m_needsTextMetricsUpdate);
-  ASSERT(!m_needsPositioningValuesUpdate);
+  DCHECK(!m_needsReordering);
+  DCHECK(!m_needsTransformUpdate);
+  DCHECK(!m_needsTextMetricsUpdate);
+  DCHECK(!m_needsPositioningValuesUpdate);
   clearNeedsLayout();
 }
 
 RootInlineBox* LayoutSVGText::createRootInlineBox() {
   RootInlineBox* box = new SVGRootInlineBox(LineLayoutItem(this));
   box->setHasVirtualLogicalHeight();
   return box;
 }
 
 bool LayoutSVGText::nodeAtFloatPoint(HitTestResult& result,
@@ skipping 42 matching lines @@
     const LayoutPoint& pointInContents) {
   RootInlineBox* rootBox = firstRootBox();
   if (!rootBox)
     return createPositionWithAffinity(0);
 
   LayoutPoint clippedPointInContents(pointInContents);
   clippedPointInContents.moveBy(-rootBox->location());
   clippedPointInContents.clampNegativeToZero();
   clippedPointInContents.moveBy(rootBox->location());
 
-  ASSERT(!rootBox->nextRootBox());
-  ASSERT(childrenInline());
+  DCHECK(!rootBox->nextRootBox());
+  DCHECK(childrenInline());
 
   InlineBox* closestBox =
       toSVGRootInlineBox(rootBox)->closestLeafChildForPosition(
           clippedPointInContents);
   if (!closestBox)
     return createPositionWithAffinity(0);
 
   return closestBox->getLineLayoutItem().positionForPoint(
       LayoutPoint(clippedPointInContents.x(), closestBox->y()));
 }
@@ skipping 13 matching lines @@
     return FloatRect(box->frameRect());
   return FloatRect();
 }
 
 FloatRect LayoutSVGText::strokeBoundingBox() const {
   FloatRect strokeBoundaries = objectBoundingBox();
   const SVGComputedStyle& svgStyle = style()->svgStyle();
   if (!svgStyle.hasStroke())
     return strokeBoundaries;
 
-  ASSERT(node());
-  ASSERT(node()->isSVGElement());
+  DCHECK(node());
+  DCHECK(node()->isSVGElement());
   SVGLengthContext lengthContext(toSVGElement(node()));
   strokeBoundaries.inflate(
       lengthContext.valueForLength(svgStyle.strokeWidth()));
   return strokeBoundaries;
 }
 
 FloatRect LayoutSVGText::visualRectInLocalSVGCoordinates() const {
   FloatRect visualRect = strokeBoundingBox();
   SVGLayoutSupport::adjustVisualRectWithResources(this, visualRect);
 
@@ skipping 30 matching lines @@
 
 void LayoutSVGText::invalidateTreeIfNeeded(
     const PaintInvalidationState& paintInvalidationState) {
   // TODO(wangxianzhu): Verify if the inherited
   // LayoutBoxModelObject::invalidateTreeIfNeeded()
   // is applicable here. If yes, remove this overriding method.
   LayoutObject::invalidateTreeIfNeeded(paintInvalidationState);
 }
 
 }  // namespace blink