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

third_party/WebKit/Source/core/layout/svg/SVGTextQuery.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 36 matching lines @@
   const SVGInlineTextBox* textBox;
 };
 
 static inline InlineFlowBox* flowBoxForLayoutObject(
     LayoutObject* layoutObject) {
   if (!layoutObject)
     return nullptr;
 
   if (layoutObject->isLayoutBlock()) {
     // If we're given a block element, it has to be a LayoutSVGText.
-    ASSERT(layoutObject->isSVGText());
+    DCHECK(layoutObject->isSVGText());
     LayoutBlockFlow* layoutBlockFlow = toLayoutBlockFlow(layoutObject);
 
     // LayoutSVGText only ever contains a single line box.
     InlineFlowBox* flowBox = layoutBlockFlow->firstLineBox();
-    ASSERT(flowBox == layoutBlockFlow->lastLineBox());
+    DCHECK_EQ(flowBox, layoutBlockFlow->lastLineBox());
     return flowBox;
   }
 
   if (layoutObject->isLayoutInline()) {
     // We're given a LayoutSVGInline or objects that derive from it
     // (LayoutSVGTSpan / LayoutSVGTextPath)
     LayoutInline* layoutInline = toLayoutInline(layoutObject);
 
     // LayoutSVGInline only ever contains a single line box.
     InlineFlowBox* flowBox = layoutInline->firstLineBox();
-    ASSERT(flowBox == layoutInline->lastLineBox());
+    DCHECK_EQ(flowBox, layoutInline->lastLineBox());
     return flowBox;
   }
 
   NOTREACHED();
   return nullptr;
 }
 
 static void collectTextBoxesInFlowBox(InlineFlowBox* flowBox,
                                       Vector<SVGInlineTextBox*>& textBoxes) {
   if (!flowBox)
@@ skipping 71 matching lines @@
   // Walk the layout tree in pre-order, starting at the specified root, and
   // run the query for each text node.
   Vector<SVGInlineTextBox*> textBoxes;
   for (LayoutObject* layoutObject = queryRoot->slowFirstChild(); layoutObject;
        layoutObject = layoutObject->nextInPreOrder(queryRoot)) {
     if (!layoutObject->isSVGInlineText())
       continue;
 
     LineLayoutSVGInlineText textLineLayout =
         LineLayoutSVGInlineText(toLayoutSVGInlineText(layoutObject));
-    ASSERT(textLineLayout.style());
+    DCHECK(textLineLayout.style());
 
     // TODO(fs): Allow filtering the search earlier, since we should be
     // able to trivially reject (prune) at least some of the queries.
     collectTextBoxesInLogicalOrder(textLineLayout, textBoxes);
 
     for (const SVGInlineTextBox* textBox : textBoxes) {
       if (queryTextBox(queryData, textBox, fragmentCallback))
         return;
       queryData->currentOffset += textBox->len();
     }
@@ skipping 60 matching lines @@
   // |startInFragment|.
   MetricsList::const_iterator metrics =
       metricsList.begin() + fragment.metricsListOffset;
   unsigned fragmentOffset = 0;
   while (fragmentOffset < fragment.length) {
     fragmentOffset += metrics->length();
     if (startInFragment < fragmentOffset)
       break;
     ++metrics;
   }
-  ASSERT(metrics <= metricsList.end());
+  DCHECK_LE(metrics, metricsList.end());
   return metrics;
 }
 
 static float calculateGlyphRange(const QueryData* queryData,
                                  const SVGTextFragment& fragment,
                                  unsigned start,
                                  unsigned end) {
   const MetricsList& metricsList = queryData->textLineLayout.metricsList();
   auto metrics = findMetricsForCharacter(metricsList, fragment, start);
   auto endMetrics = findMetricsForCharacter(metricsList, fragment, end);
@@ skipping 201 matching lines @@
       glyphExtents.move(-glyphExtents.width(), 0);
   }
   return glyphExtents;
 }
 
 static inline FloatRect calculateGlyphBoundaries(
     const QueryData* queryData,
     const SVGTextFragment& fragment,
     int startPosition) {
   const float scalingFactor = queryData->textLineLayout.scalingFactor();
-  ASSERT(scalingFactor);
+  DCHECK(scalingFactor);
   const SimpleFontData* fontData =
       queryData->textLineLayout.scaledFont().primaryFont();
   DCHECK(fontData);
   if (!fontData)
     return FloatRect();
 
   const float baseline =
       fontData->getFontMetrics().floatAscent() / scalingFactor;
   float glyphOffsetInDirection =
       calculateGlyphRange(queryData, fragment, 0, startPosition);
@@ skipping 45 matching lines @@
   LineLayoutItem hitLayoutItem;
   int offsetInTextNode;
 };
 
 int CharacterNumberAtPositionData::characterNumberWithin(
     const LayoutObject* queryRoot) const {
   // http://www.w3.org/TR/SVG/single-page.html#text-__svg__SVGTextContentElement__getCharNumAtPosition
   // "If no such character exists, a value of -1 is returned."
   if (!hitLayoutItem)
     return -1;
-  ASSERT(queryRoot);
+  DCHECK(queryRoot);
   int characterNumber = offsetInTextNode;
 
   // Accumulate the lengths of all the text nodes preceding the target layout
   // object within the queried root, to get the complete character number.
   for (LineLayoutItem layoutItem = hitLayoutItem.previousInPreOrder(queryRoot);
        layoutItem; layoutItem = layoutItem.previousInPreOrder(queryRoot)) {
     if (!layoutItem.isSVGInlineText())
       continue;
     characterNumber += LineLayoutSVGInlineText(layoutItem).resolvedTextLength();
   }
   return characterNumber;
 }
 
 static unsigned logicalOffsetInTextNode(LineLayoutSVGInlineText textLineLayout,
                                         const SVGInlineTextBox* startTextBox,
                                         unsigned fragmentOffset) {
   Vector<SVGInlineTextBox*> textBoxes;
   collectTextBoxesInLogicalOrder(textLineLayout, textBoxes);
 
-  ASSERT(startTextBox);
+  DCHECK(startTextBox);
   size_t index = textBoxes.find(startTextBox);
-  ASSERT(index != kNotFound);
+  DCHECK_NE(index, kNotFound);
 
   unsigned offset = fragmentOffset;
   while (index) {
     --index;
     offset += textBoxes[index]->len();
   }
   return offset;
 }
 
 static bool characterNumberAtPositionCallback(QueryData* queryData,
                                               const SVGTextFragment& fragment) {
   CharacterNumberAtPositionData* data =
       static_cast<CharacterNumberAtPositionData*>(queryData);
 
   const float scalingFactor = data->textLineLayout.scalingFactor();
-  ASSERT(scalingFactor);
+  DCHECK(scalingFactor);
 
   const SimpleFontData* fontData =
       data->textLineLayout.scaledFont().primaryFont();
   DCHECK(fontData);
   if (!fontData)
     return false;
 
   const float baseline =
       fontData->getFontMetrics().floatAscent() / scalingFactor;
 
@@ skipping 34 matching lines @@
 }
 
 int SVGTextQuery::characterNumberAtPosition(const FloatPoint& position) const {
   CharacterNumberAtPositionData data(position);
   spatialQuery(m_queryRootLayoutObject, &data,
                characterNumberAtPositionCallback);
   return data.characterNumberWithin(m_queryRootLayoutObject);
 }
 
 }  // namespace blink