Replace ASSERT with DCHECK in core/layout/ excluding subdirs

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

 /*
  * (C) 1999 Lars Knoll (knoll@kde.org)
  * (C) 2000 Dirk Mueller (mueller@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)
  * Copyright (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *
  * 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
@@ skipping 74 matching lines @@
     if (Settings* settings = m_layoutText->document().settings()) {
       startOneShot(settings->getPasswordEchoDurationInSeconds(),
                    BLINK_FROM_HERE);
     }
   }
   void invalidate() { m_lastTypedCharacterOffset = -1; }
   unsigned lastTypedCharacterOffset() { return m_lastTypedCharacterOffset; }
 
  private:
   void fired() override {
-    ASSERT(gSecureTextTimers->contains(m_layoutText));
+    DCHECK(gSecureTextTimers->contains(m_layoutText));
     m_layoutText->setText(
         m_layoutText->text().impl(),
         true /* forcing setting text as it may be masked later */);
   }
 
   LayoutText* m_layoutText;
   int m_lastTypedCharacterOffset;
 };
 
 static void makeCapitalized(String* string, UChar previous) {
@@ skipping 49 matching lines @@
       m_linesDirty(false),
       m_containsReversedText(false),
       m_knownToHaveNoOverflowAndNoFallbackFonts(false),
       m_minWidth(-1),
       m_maxWidth(-1),
       m_firstLineMinWidth(0),
       m_lastLineLineMinWidth(0),
       m_text(std::move(str)),
       m_firstTextBox(nullptr),
       m_lastTextBox(nullptr) {
-  ASSERT(m_text);
+  DCHECK(m_text);
   DCHECK(!node || !node->isDocumentNode());
 
   setIsText();
 
   if (node)
     frameView()->incrementVisuallyNonEmptyCharacterCount(m_text.length());
 }
 
 #if DCHECK_IS_ON()
 
 LayoutText::~LayoutText() {
-  ASSERT(!m_firstTextBox);
-  ASSERT(!m_lastTextBox);
+  DCHECK(!m_firstTextBox);
+  DCHECK(!m_lastTextBox);
 }
 
 #endif
 
 LayoutText* LayoutText::createEmptyAnonymous(Document& doc) {
   LayoutText* text = new LayoutText(nullptr, StringImpl::empty);
   text->setDocumentForAnonymous(&doc);
   return text;
 }
 
@@ skipping 179 matching lines @@
                                        unsigned start,
                                        unsigned end,
                                        bool useSelectionHeight) {
   // Work around signed/unsigned issues. This function takes unsigneds, and is
   // often passed UINT_MAX to mean "all the way to the end". InlineTextBox
   // coordinates are unsigneds, so changing this function to take ints causes
   // various internal mismatches. But selectionRect takes ints, and passing
   // UINT_MAX to it causes trouble. Ideally we'd change selectionRect to take
   // unsigneds, but that would cause many ripple effects, so for now we'll just
   // clamp our unsigned parameters to INT_MAX.
-  ASSERT(end == UINT_MAX || end <= INT_MAX);
-  ASSERT(start <= INT_MAX);
+  DCHECK(end == UINT_MAX || end <= INT_MAX);
+  DCHECK_LE(start, static_cast<unsigned>(INT_MAX));
   start = std::min(start, static_cast<unsigned>(INT_MAX));
   end = std::min(end, static_cast<unsigned>(INT_MAX));
 
   bool hasCheckedBoxInRange = false;
 
   for (InlineTextBox* box = firstTextBox(); box; box = box->nextTextBox()) {
     // Note: box->end() returns the index of the last character, not the index
     // past it
     if (start <= box->start() && box->end() < end) {
       FloatRect r(box->frameRect());
@@ skipping 93 matching lines @@
                                        unsigned start,
                                        unsigned end,
                                        bool useSelectionHeight) {
   // Work around signed/unsigned issues. This function takes unsigneds, and is
   // often passed UINT_MAX to mean "all the way to the end". InlineTextBox
   // coordinates are unsigneds, so changing this function to take ints causes
   // various internal mismatches. But selectionRect takes ints, and passing
   // UINT_MAX to it causes trouble. Ideally we'd change selectionRect to take
   // unsigneds, but that would cause many ripple effects, so for now we'll just
   // clamp our unsigned parameters to INT_MAX.
-  ASSERT(end == UINT_MAX || end <= INT_MAX);
-  ASSERT(start <= INT_MAX);
+  DCHECK(end == UINT_MAX || end <= INT_MAX);
+  DCHECK_LE(start, static_cast<unsigned>(INT_MAX));
   start = std::min(start, static_cast<unsigned>(INT_MAX));
   end = std::min(end, static_cast<unsigned>(INT_MAX));
 
   const unsigned caretMinOffset = static_cast<unsigned>(this->caretMinOffset());
   const unsigned caretMaxOffset = static_cast<unsigned>(this->caretMaxOffset());
 
   // Narrows |start| and |end| into |caretMinOffset| and |careMaxOffset|
   // to ignore unrendered leading and trailing whitespaces.
   start = std::min(std::max(caretMinOffset, start), caretMaxOffset);
   end = std::min(std::max(caretMinOffset, end), caretMaxOffset);
@@ skipping 118 matching lines @@
           : 0;
   return box->getLineLayoutItem().createPositionWithAffinity(
       offset + textStartOffset, affinity);
 }
 
 static PositionWithAffinity
 createPositionWithAffinityForBoxAfterAdjustingOffsetForBiDi(
     const InlineTextBox* box,
     int offset,
     ShouldAffinityBeDownstream shouldAffinityBeDownstream) {
-  ASSERT(box);
-  ASSERT(offset >= 0);
+  DCHECK(box);
+  DCHECK_GE(offset, 0);
 
   if (offset && static_cast<unsigned>(offset) < box->len())
     return createPositionWithAffinityForBox(box, box->start() + offset,
                                             shouldAffinityBeDownstream);
 
   bool positionIsAtStartOfBox = !offset;
   if (positionIsAtStartOfBox == box->isLeftToRightDirection()) {
     // offset is on the left edge
 
     const InlineBox* prevBox = box->prevLeafChildIgnoringLineBreak();
@@ skipping 121 matching lines @@
   }
   return createPositionWithAffinity(0);
 }
 
 LayoutRect LayoutText::localCaretRect(InlineBox* inlineBox,
                                       int caretOffset,
                                       LayoutUnit* extraWidthToEndOfLine) {
   if (!inlineBox)
     return LayoutRect();
 
-  ASSERT(inlineBox->isInlineTextBox());
+  DCHECK(inlineBox->isInlineTextBox());
   if (!inlineBox->isInlineTextBox())
     return LayoutRect();
 
   InlineTextBox* box = toInlineTextBox(inlineBox);
   // Find an InlineBox before caret position, which is used to get caret height.
   InlineBox* caretBox = box;
   if (box->getLineLayoutItem().style(box->isFirstLineStyle())->direction() ==
       TextDirection::kLtr) {
     if (box->prevLeafChild() && caretOffset == 0)
       caretBox = box->prevLeafChild();
@@ skipping 91 matching lines @@
     FloatRect* glyphBoundsAccumulation) const {
   if (style()->hasTextCombine() && isCombineText()) {
     const LayoutTextCombine* combineText = toLayoutTextCombine(this);
     if (combineText->isCombined())
       return combineText->combinedTextWidth(f);
   }
 
   TextRun run =
       constructTextRun(f, this, start, len, styleRef(), textDirection);
   run.setCharactersLength(textLength() - start);
-  ASSERT(run.charactersLength() >= run.length());
+  DCHECK_GE(run.charactersLength(), run.length());
   run.setTabSize(!style()->collapseWhiteSpace(), style()->getTabSize());
   run.setXPos(leadWidth + textWidthSoFar);
 
   FloatRect newGlyphBounds;
   float result = f.width(run, fallbackFonts,
                          glyphBoundsAccumulation ? &newGlyphBounds : nullptr);
   if (glyphBoundsAccumulation) {
     newGlyphBounds.move(textWidthSoFar, 0);
     glyphBoundsAccumulation->unite(newGlyphBounds);
   }
@@ skipping 44 matching lines @@
 
   floatMinWidth = m_minWidth;
   floatMaxWidth = m_maxWidth;
 
   firstLineMinWidth = LayoutUnit(m_firstLineMinWidth);
   lastLineMinWidth = LayoutUnit(m_lastLineLineMinWidth);
 
   hasBreakableChar = m_hasBreakableChar;
   hasBreak = m_hasBreak;
 
-  ASSERT(m_text);
+  DCHECK(m_text);
   StringImpl& text = *m_text.impl();
   if (text[0] == spaceCharacter ||
       (text[0] == newlineCharacter && !style()->preserveNewline()) ||
       text[0] == tabulationCharacter) {
     const Font& font = style()->font();  // FIXME: This ignores first-line.
     if (stripFrontSpaces) {
       const UChar spaceChar = spaceCharacter;
       TextRun run =
           constructTextRun(font, &spaceChar, 1, styleRef(), direction);
       float spaceWidth = font.width(run);
@@ skipping 165 matching lines @@
   }
   if (const LayoutLocale* locale = style.getFontDescription().locale())
     return locale->localeWithBreakKeyword(mode);
   return style.locale();
 }
 
 void LayoutText::computePreferredLogicalWidths(
     float leadWidth,
     HashSet<const SimpleFontData*>& fallbackFonts,
     FloatRect& glyphBounds) {
-  ASSERT(m_hasTab || preferredLogicalWidthsDirty() ||
+  DCHECK(m_hasTab || preferredLogicalWidthsDirty() ||
          !m_knownToHaveNoOverflowAndNoFallbackFonts);
 
   m_minWidth = 0;
   m_maxWidth = 0;
   m_firstLineMinWidth = 0;
   m_lastLineLineMinWidth = 0;
 
   if (isBR())
     return;
 
@@ skipping 64 matching lines @@
     UChar c = uncheckedCharacterAt(i);
 
     if (run) {
       // Treat adjacent runs with the same resolved directionality
       // (TextDirection as opposed to WTF::Unicode::Direction) as belonging
       // to the same run to avoid breaking unnecessarily.
       while (i >= run->stop() ||
              (run->next() && run->next()->direction() == run->direction()))
         run = run->next();
 
-      ASSERT(run);
-      ASSERT(i <= run->stop());
+      DCHECK(run);
+      DCHECK_LE(i, run->stop());
       textDirection = run->direction();
     }
 
     bool previousCharacterIsSpace = isSpace;
     bool isNewline = false;
     if (c == newlineCharacter) {
       if (styleToUse.preserveNewline()) {
         m_hasBreak = true;
         isNewline = true;
         isSpace = false;
@@ skipping 21 matching lines @@
 
     if (!ignoringSpaces && styleToUse.collapseWhiteSpace() &&
         previousCharacterIsSpace && isSpace)
       ignoringSpaces = true;
 
     if (ignoringSpaces && !isSpace)
       ignoringSpaces = false;
 
     // Ignore spaces and soft hyphens
     if (ignoringSpaces) {
-      ASSERT(lastWordBoundary == i);
+      DCHECK_EQ(lastWordBoundary, i);
       lastWordBoundary++;
       continue;
     }
     if (c == softHyphenCharacter && !disableSoftHyphen) {
       currMaxWidth += widthFromFont(f, lastWordBoundary, i - lastWordBoundary,
                                     leadWidth, currMaxWidth, textDirection,
                                     &fallbackFonts, &glyphBounds);
       lastWordBoundary = i + 1;
       continue;
     }
@@ skipping 145 matching lines @@
             m_firstLineMinWidth = currMaxWidth;
         }
 
         if (currMaxWidth > m_maxWidth)
           m_maxWidth = currMaxWidth;
         currMaxWidth = 0;
       } else {
         TextRun run =
             constructTextRun(f, this, i, 1, styleToUse, textDirection);
         run.setCharactersLength(len - i);
-        ASSERT(run.charactersLength() >= run.length());
+        DCHECK_GE(run.charactersLength(), run.length());
         run.setTabSize(!style()->collapseWhiteSpace(), style()->getTabSize());
         run.setXPos(leadWidth + currMaxWidth);
 
         currMaxWidth += f.width(run);
         needsWordSpacing = isSpace && !previousCharacterIsSpace && i == len - 1;
       }
-      ASSERT(lastWordBoundary == i);
+      DCHECK_EQ(lastWordBoundary, i);
       lastWordBoundary++;
     }
   }
   if (run)
     bidiResolver.runs().deleteRuns();
 
   if ((needsWordSpacing && len > 1) || (ignoringSpaces && !firstWord))
     currMaxWidth += wordSpacing;
 
   m_minWidth = std::max(currMinWidth, m_minWidth);
@@ skipping 11 matching lines @@
   const SimpleFontData* fontData = f.primaryFont();
   DCHECK(fontData);
 
   GlyphOverflow glyphOverflow;
   if (fontData) {
     glyphOverflow.setFromBounds(
         glyphBounds, fontData->getFontMetrics().floatAscent(),
         fontData->getFontMetrics().floatDescent(), m_maxWidth);
   }
   // We shouldn't change our mind once we "know".
-  ASSERT(!m_knownToHaveNoOverflowAndNoFallbackFonts ||
+  DCHECK(!m_knownToHaveNoOverflowAndNoFallbackFonts ||
          (fallbackFonts.isEmpty() && glyphOverflow.isApproximatelyZero()));
   m_knownToHaveNoOverflowAndNoFallbackFonts =
       fallbackFonts.isEmpty() && glyphOverflow.isApproximatelyZero();
 
   clearPreferredLogicalWidthsDirty();
 }
 
 bool LayoutText::isAllCollapsibleWhitespace() const {
   unsigned length = textLength();
   if (is8Bit()) {
@@ skipping 20 matching lines @@
     }
     if (offsetInNode >= static_cast<int>(box->start()) &&
         offsetInNode < static_cast<int>(box->start() + box->len()))
       return true;
   }
 
   return false;
 }
 
 bool LayoutText::containsOnlyWhitespace(unsigned from, unsigned len) const {
-  ASSERT(m_text);
+  DCHECK(m_text);
   StringImpl& text = *m_text.impl();
   unsigned currPos;
   for (currPos = from;
        currPos < from + len &&
        (text[currPos] == newlineCharacter || text[currPos] == spaceCharacter ||
         text[currPos] == tabulationCharacter);
        currPos++) {
   }
   return currPos >= (from + len);
 }
@@ skipping 101 matching lines @@
 
   // Now we have to walk all of the clean lines and adjust their cached line
   // break information to reflect our updated offsets.
   if (lastRootBox)
     lastRootBox = lastRootBox->nextRootBox();
   if (firstRootBox) {
     RootInlineBox* prev = firstRootBox->prevRootBox();
     if (prev)
       firstRootBox = prev;
   } else if (lastTextBox()) {
-    ASSERT(!lastRootBox);
+    DCHECK(!lastRootBox);
     firstRootBox = &lastTextBox()->root();
     firstRootBox->markDirty();
     dirtiedLines = true;
   }
   for (RootInlineBox* curr = firstRootBox; curr && curr != lastRootBox;
        curr = curr->nextRootBox()) {
     if (curr->lineBreakObj().isEqual(this) && curr->lineBreakPos() > end)
       curr->setLineBreakPos(clampTo<int>(curr->lineBreakPos() + delta));
   }
 
@@ skipping 57 matching lines @@
     case ETextTransform::kUppercase:
       text = text.upper(style->locale());
       break;
     case ETextTransform::kLowercase:
       text = text.lower(style->locale());
       break;
   }
 }
 
 void LayoutText::setTextInternal(PassRefPtr<StringImpl> text) {
-  ASSERT(text);
+  DCHECK(text);
   m_text = std::move(text);
 
   if (style()) {
     applyTextTransform(style(), m_text, previousCharacter());
 
     // We use the same characters here as for list markers.
     // See the listMarkerText function in LayoutListMarker.cpp.
     switch (style()->textSecurity()) {
       case TSNONE:
         break;
       case TSCIRCLE:
         secureText(whiteBulletCharacter);
         break;
       case TSDISC:
         secureText(bulletCharacter);
         break;
       case TSSQUARE:
         secureText(blackSquareCharacter);
     }
   }
 
-  ASSERT(m_text);
-  ASSERT(!isBR() || (textLength() == 1 && m_text[0] == newlineCharacter));
+  DCHECK(m_text);
+  DCHECK(!isBR() || (textLength() == 1 && m_text[0] == newlineCharacter));
 }
 
 void LayoutText::secureText(UChar mask) {
   if (!m_text.length())
     return;
 
   int lastTypedCharacterOffsetToReveal = -1;
   UChar revealedText;
   SecureTextTimer* secureTextTimer =
       gSecureTextTimers ? gSecureTextTimers->at(this) : 0;
   if (secureTextTimer && secureTextTimer->isActive()) {
     lastTypedCharacterOffsetToReveal =
         secureTextTimer->lastTypedCharacterOffset();
     if (lastTypedCharacterOffsetToReveal >= 0)
       revealedText = m_text[lastTypedCharacterOffsetToReveal];
   }
 
   m_text.fill(mask);
   if (lastTypedCharacterOffsetToReveal >= 0) {
     m_text.replace(lastTypedCharacterOffsetToReveal, 1,
                    String(&revealedText, 1));
     // m_text may be updated later before timer fires. We invalidate the
     // lastTypedCharacterOffset to avoid inconsistency.
     secureTextTimer->invalidate();
   }
 }
 
 void LayoutText::setText(PassRefPtr<StringImpl> text, bool force) {
-  ASSERT(text);
+  DCHECK(text);
 
   if (!force && equal(m_text.impl(), text.get()))
     return;
 
   setTextInternal(std::move(text));
   // If preferredLogicalWidthsDirty() of an orphan child is true,
   // LayoutObjectChildList::insertChildNode() fails to set true to owner.
   // To avoid that, we call setNeedsLayoutAndPrefWidthsRecalc() only if this
   // LayoutText has parent.
   if (parent())
@@ skipping 79 matching lines @@
                fallbackFonts, glyphBounds);
 }
 
 float LayoutText::width(unsigned from,
                         unsigned len,
                         const Font& f,
                         LayoutUnit xPos,
                         TextDirection textDirection,
                         HashSet<const SimpleFontData*>* fallbackFonts,
                         FloatRect* glyphBounds) const {
-  ASSERT(from + len <= textLength());
+  DCHECK_LE(from + len, textLength());
   if (!textLength())
     return 0;
 
   const SimpleFontData* fontData = f.primaryFont();
   DCHECK(fontData);
   if (!fontData)
     return 0;
 
   float w;
   if (&f == &style()->font()) {
     if (!style()->preserveNewline() && !from && len == textLength()) {
       if (fallbackFonts) {
-        ASSERT(glyphBounds);
+        DCHECK(glyphBounds);
         if (preferredLogicalWidthsDirty() ||
             !m_knownToHaveNoOverflowAndNoFallbackFonts)
           const_cast<LayoutText*>(this)->computePreferredLogicalWidths(
               0, *fallbackFonts, *glyphBounds);
         else
           *glyphBounds =
               FloatRect(0, -fontData->getFontMetrics().floatAscent(),
                         m_maxWidth, fontData->getFontMetrics().floatHeight());
         w = m_maxWidth;
       } else {
         w = maxLogicalWidth();
       }
     } else {
       w = widthFromFont(f, from, len, xPos.toFloat(), 0, textDirection,
                         fallbackFonts, glyphBounds);
     }
   } else {
     TextRun run =
         constructTextRun(f, this, from, len, styleRef(), textDirection);
     run.setCharactersLength(textLength() - from);
-    ASSERT(run.charactersLength() >= run.length());
+    DCHECK_GE(run.charactersLength(), run.length());
 
     run.setTabSize(!style()->collapseWhiteSpace(), style()->getTabSize());
     run.setXPos(xPos.toFloat());
     w = f.width(run, fallbackFonts, glyphBounds);
   }
 
   return w;
 }
 
 LayoutRect LayoutText::linesBoundingBox() const {
   LayoutRect result;
 
-  ASSERT(!firstTextBox() ==
-         !lastTextBox());  // Either both are null or both exist.
+  DCHECK_EQ(!firstTextBox(),
+            !lastTextBox());  // Either both are null or both exist.
   if (firstTextBox() && lastTextBox()) {
     // Return the width of the minimal left side and the maximal right side.
     float logicalLeftSide = 0;
     float logicalRightSide = 0;
     for (InlineTextBox* curr = firstTextBox(); curr;
          curr = curr->nextTextBox()) {
       if (curr == firstTextBox() || curr->logicalLeft() < logicalLeftSide)
         logicalLeftSide = curr->logicalLeft().toFloat();
       if (curr == firstTextBox() || curr->logicalRight() > logicalRightSide)
         logicalRightSide = curr->logicalRight().toFloat();
@@ skipping 38 matching lines @@
 }
 
 LayoutRect LayoutText::localVisualRect() const {
   if (style()->visibility() != EVisibility::kVisible)
     return LayoutRect();
 
   return unionRect(visualOverflowRect(), localSelectionRect());
 }
 
 LayoutRect LayoutText::localSelectionRect() const {
-  ASSERT(!needsLayout());
+  DCHECK(!needsLayout());
 
   if (getSelectionState() == SelectionNone)
     return LayoutRect();
   LayoutBlock* cb = containingBlock();
   if (!cb)
     return LayoutRect();
 
   // Now calculate startPos and endPos for painting selection.
   // We include a selection while endPos > 0
   int startPos, endPos;
@@ skipping 50 matching lines @@
   return len;
 }
 
 #if DCHECK_IS_ON()
 
 void LayoutText::checkConsistency() const {
 #ifdef CHECK_CONSISTENCY
   const InlineTextBox* prev = nullptr;
   for (const InlineTextBox* child = m_firstTextBox; child;
        child = child->nextTextBox()) {
-    ASSERT(child->getLineLayoutItem().isEqual(this));
-    ASSERT(child->prevTextBox() == prev);
+    DCHECK(child->getLineLayoutItem().isEqual(this));
+    DCHECK_EQ(child->prevTextBox(), prev);
     prev = child;
   }
-  ASSERT(prev == m_lastTextBox);
+  DCHECK_EQ(prev, m_lastTextBox);
 #endif
 }
 
 #endif
 
 void LayoutText::momentarilyRevealLastTypedCharacter(
     unsigned lastTypedCharacterOffset) {
   if (!gSecureTextTimers)
     gSecureTextTimers = new SecureTextTimerMap;
 
@@ skipping 32 matching lines @@
   LayoutRect rect = LayoutRect(
       IntRect(firstRunX(), firstRunY(), linesBox.width(), linesBox.height()));
   LayoutBlock* block = containingBlock();
   if (block && hasTextBoxes())
     block->adjustChildDebugRect(rect);
 
   return rect;
 }
 
 }  // namespace blink