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

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

 /*
  * Copyright (C) Research In Motion Limited 2010-2012. 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.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 30 matching lines @@
       m_logicalCharacterOffset(0),
       m_logicalMetricsListOffset(0),
       m_isVerticalText(false),
       m_inPathLayout(false),
       m_textLengthSpacingInEffect(false),
       m_textPath(nullptr),
       m_textPathCurrentOffset(0),
       m_textPathDisplacement(0),
       m_textPathSpacing(0),
       m_textPathScaling(1) {
-  ASSERT(!m_descendantTextNodes.isEmpty());
+  DCHECK(!m_descendantTextNodes.isEmpty());
 }
 
 SVGTextLayoutEngine::~SVGTextLayoutEngine() = default;
 
 bool SVGTextLayoutEngine::setCurrentTextPosition(const SVGCharacterData& data) {
   bool hasX = data.hasX();
   if (hasX)
     m_textPosition.setX(data.x);
 
   bool hasY = data.hasY();
@@ skipping 52 matching lines @@
 }
 
 void SVGTextLayoutEngine::computeCurrentFragmentMetrics(
     SVGInlineTextBox* textBox) {
   LineLayoutSVGInlineText textLineLayout =
       LineLayoutSVGInlineText(textBox->getLineLayoutItem());
   TextRun run = textBox->constructTextRun(textLineLayout.styleRef(),
                                           m_currentTextFragment);
 
   float scalingFactor = textLineLayout.scalingFactor();
-  ASSERT(scalingFactor);
+  DCHECK(scalingFactor);
   const Font& scaledFont = textLineLayout.scaledFont();
   FloatRect glyphOverflowBounds;
 
   const SimpleFontData* fontData = scaledFont.primaryFont();
   DCHECK(fontData);
   if (!fontData)
     return;
 
   float width = scaledFont.width(run, nullptr, &glyphOverflowBounds);
   float ascent = fontData->getFontMetrics().floatAscent();
   float descent = fontData->getFontMetrics().floatDescent();
   m_currentTextFragment.glyphOverflow.setFromBounds(glyphOverflowBounds, ascent,
                                                     descent, width);
   m_currentTextFragment.glyphOverflow.top /= scalingFactor;
   m_currentTextFragment.glyphOverflow.left /= scalingFactor;
   m_currentTextFragment.glyphOverflow.right /= scalingFactor;
   m_currentTextFragment.glyphOverflow.bottom /= scalingFactor;
 
   float height = fontData->getFontMetrics().floatHeight();
   m_currentTextFragment.height = height / scalingFactor;
   m_currentTextFragment.width = width / scalingFactor;
 }
 
 void SVGTextLayoutEngine::recordTextFragment(SVGInlineTextBox* textBox) {
-  ASSERT(!m_currentTextFragment.length);
+  DCHECK(!m_currentTextFragment.length);
 
   // Figure out length of fragment.
   m_currentTextFragment.length = m_visualMetricsIterator.characterOffset() -
                                  m_currentTextFragment.characterOffset;
 
   // Figure out fragment metrics.
   computeCurrentFragmentMetrics(textBox);
 
   textBox->textFragments().push_back(m_currentTextFragment);
   m_currentTextFragment = SVGTextFragment();
@@ skipping 53 matching lines @@
 void SVGTextLayoutEngine::endTextPathLayout() {
   m_inPathLayout = false;
   m_textPath = nullptr;
   m_textPathStartOffset = 0;
   m_textPathCurrentOffset = 0;
   m_textPathSpacing = 0;
   m_textPathScaling = 1;
 }
 
 void SVGTextLayoutEngine::layoutInlineTextBox(SVGInlineTextBox* textBox) {
-  ASSERT(textBox);
+  DCHECK(textBox);
 
   LineLayoutSVGInlineText textLineLayout =
       LineLayoutSVGInlineText(textBox->getLineLayoutItem());
-  ASSERT(textLineLayout.parent());
-  ASSERT(textLineLayout.parent().node());
-  ASSERT(textLineLayout.parent().node()->isSVGElement());
+  DCHECK(textLineLayout.parent());
+  DCHECK(textLineLayout.parent().node());
+  DCHECK(textLineLayout.parent().node()->isSVGElement());
 
   const ComputedStyle& style = textLineLayout.styleRef();
 
   textBox->clearTextFragments();
   m_isVerticalText = !style.isHorizontalWritingMode();
   layoutTextOnLineOrPath(textBox, textLineLayout, style);
 
   if (m_inPathLayout)
     return;
 
@@ skipping 12 matching lines @@
 
 void SVGTextLayoutEngine::layoutCharactersInTextBoxes(InlineFlowBox* start) {
   bool textLengthSpacingInEffect =
       m_textLengthSpacingInEffect || definesTextLengthWithSpacing(start);
   AutoReset<bool> textLengthSpacingScope(&m_textLengthSpacingInEffect,
                                          textLengthSpacingInEffect);
 
   for (InlineBox* child = start->firstChild(); child;
        child = child->nextOnLine()) {
     if (child->isSVGInlineTextBox()) {
-      ASSERT(child->getLineLayoutItem().isSVGInlineText());
+      DCHECK(child->getLineLayoutItem().isSVGInlineText());
       layoutInlineTextBox(toSVGInlineTextBox(child));
     } else {
       // Skip generated content.
       Node* node = child->getLineLayoutItem().node();
       if (!node)
         continue;
 
       SVGInlineFlowBox* flowBox = toSVGInlineFlowBox(child);
       bool isTextPath = isSVGTextPathElement(*node);
       if (isTextPath)
@@ skipping 14 matching lines @@
   // SVGInlineTextBoxes, we can layout individual text chunks.
   // Chunk layouting is only performed for line layout boxes, not for path
   // layout, where it has already been done.
   SVGTextChunkBuilder chunkLayoutBuilder;
   chunkLayoutBuilder.processTextChunks(m_lineLayoutBoxes);
 
   m_lineLayoutBoxes.clear();
 }
 
 const LayoutSVGInlineText* SVGTextLayoutEngine::nextLogicalTextNode() {
-  ASSERT(m_currentLogicalTextNodeIndex < m_descendantTextNodes.size());
+  DCHECK_LT(m_currentLogicalTextNodeIndex, m_descendantTextNodes.size());
   ++m_currentLogicalTextNodeIndex;
   if (m_currentLogicalTextNodeIndex == m_descendantTextNodes.size())
     return nullptr;
 
   m_logicalMetricsListOffset = 0;
   m_logicalCharacterOffset = 0;
   return m_descendantTextNodes[m_currentLogicalTextNodeIndex];
 }
 
 const LayoutSVGInlineText* SVGTextLayoutEngine::currentLogicalCharacterMetrics(
     SVGTextMetrics& logicalMetrics) {
   // If we've consumed all text nodes, there can be no more metrics.
   if (m_currentLogicalTextNodeIndex == m_descendantTextNodes.size())
     return nullptr;
 
   const LayoutSVGInlineText* logicalTextNode =
       m_descendantTextNodes[m_currentLogicalTextNodeIndex];
   const Vector<SVGTextMetrics>* metricsList = &logicalTextNode->metricsList();
   unsigned metricsListSize = metricsList->size();
-  ASSERT(m_logicalMetricsListOffset <= metricsListSize);
+  DCHECK(m_logicalMetricsListOffset <= metricsListSize);
 
   // Find the next non-collapsed text metrics cell.
   while (true) {
     // If we run out of metrics, move to the next set of non-empty layout
     // attributes.
     if (m_logicalMetricsListOffset == metricsListSize) {
       logicalTextNode = nextLogicalTextNode();
       if (!logicalTextNode)
         return nullptr;
       metricsList = &logicalTextNode->metricsList();
       metricsListSize = metricsList->size();
       // Return to the while so that we check if the new metrics list is
       // non-empty before using it.
       continue;
     }
 
-    ASSERT(metricsListSize);
+    DCHECK(metricsListSize);
     logicalMetrics = metricsList->at(m_logicalMetricsListOffset);
     // Stop if we found the next valid logical text metrics object.
     if (!logicalMetrics.isEmpty())
       break;
 
     advanceToNextLogicalCharacter(logicalMetrics);
   }
 
   return logicalTextNode;
 }
@@ skipping 137 matching lines @@
         angle != lastAngle || applySpacingToNextCharacter;
 
     // If we already started a fragment, close it now.
     if (didStartTextFragment && shouldStartNewFragment) {
       applySpacingToNextCharacter = false;
       recordTextFragment(textBox);
     }
 
     // Eventually start a new fragment, if not yet done.
     if (!didStartTextFragment || shouldStartNewFragment) {
-      ASSERT(!m_currentTextFragment.characterOffset);
-      ASSERT(!m_currentTextFragment.length);
+      DCHECK(!m_currentTextFragment.characterOffset);
+      DCHECK(!m_currentTextFragment.length);
 
       didStartTextFragment = true;
       m_currentTextFragment.characterOffset =
           m_visualMetricsIterator.characterOffset();
       m_currentTextFragment.metricsListOffset =
           m_visualMetricsIterator.metricsListOffset();
       m_currentTextFragment.x = position.x();
       m_currentTextFragment.y = position.y();
 
       // Build fragment transformation.
@@ skipping 32 matching lines @@
   }
 
   if (!didStartTextFragment)
     return;
 
   // Close last open fragment, if needed.
   recordTextFragment(textBox);
 }
 
 }  // namespace blink