ASSERT -> DCHECK in core/editing.

third_party/WebKit/Source/core/editing/spellcheck/TextCheckingHelper.cpp

 /*
  * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 35 matching lines @@
     int checkLocation = start;
     int checkLength = length;
 
     while (0 < checkLength) {
         int badGrammarLocation = -1;
         int badGrammarLength = 0;
         Vector<GrammarDetail> badGrammarDetails;
         client.checkGrammarOfString(String(text + checkLocation, checkLength), badGrammarDetails, &badGrammarLocation, &badGrammarLength);
         if (!badGrammarLength)
             break;
-        ASSERT(0 <= badGrammarLocation && badGrammarLocation <= checkLength);
-        ASSERT(0 < badGrammarLength && badGrammarLocation + badGrammarLength <= checkLength);
+        DCHECK_LE(0, badGrammarLocation);
+        DCHECK_LE(badGrammarLocation, checkLength);
+        DCHECK_LT(0, badGrammarLength);
+        DCHECK_LE(badGrammarLocation + badGrammarLength, checkLength);
         TextCheckingResult badGrammar;
         badGrammar.decoration = TextDecorationTypeGrammar;
         badGrammar.location = checkLocation + badGrammarLocation;
         badGrammar.length = badGrammarLength;
         badGrammar.details.swap(badGrammarDetails);
         results.append(badGrammar);
 
         checkLocation += (badGrammarLocation + badGrammarLength);
         checkLength -= (badGrammarLocation + badGrammarLength);
     }
 }
 
 static void findMisspellings(TextCheckerClient& client, const UChar* text, int start, int length, Vector<TextCheckingResult>& results)
 {
     TextBreakIterator* iterator = wordBreakIterator(text + start, length);
     if (!iterator)
         return;
     int wordStart = iterator->current();
     while (0 <= wordStart) {
         int wordEnd = iterator->next();
         if (wordEnd < 0)
             break;
         int wordLength = wordEnd - wordStart;
         int misspellingLocation = -1;
         int misspellingLength = 0;
         client.checkSpellingOfString(String(text + start + wordStart, wordLength), &misspellingLocation, &misspellingLength);
         if (0 < misspellingLength) {
-            ASSERT(0 <= misspellingLocation && misspellingLocation <= wordLength);
-            ASSERT(0 < misspellingLength && misspellingLocation + misspellingLength <= wordLength);
+            DCHECK_LE(0, misspellingLocation);
+            DCHECK_LE(misspellingLocation, wordLength);
+            DCHECK_LT(0, misspellingLength);
+            DCHECK_LE(misspellingLocation + misspellingLength, wordLength);
             TextCheckingResult misspelling;
             misspelling.decoration = TextDecorationTypeSpelling;
             misspelling.location = start + wordStart + misspellingLocation;
             misspelling.length = misspellingLength;
             results.append(misspelling);
         }
 
         wordStart = wordEnd;
     }
 }
@@ skipping 38 matching lines @@
     , m_checkingLength(-1)
 {
 }
 
 TextCheckingParagraph::~TextCheckingParagraph()
 {
 }
 
 void TextCheckingParagraph::expandRangeToNextEnd()
 {
-    ASSERT(m_checkingRange.isNotNull());
+    DCHECK(m_checkingRange.isNotNull());
     setParagraphRange(EphemeralRange(paragraphRange().startPosition(), endOfParagraph(startOfNextParagraph(createVisiblePosition(paragraphRange().startPosition()))).deepEquivalent()));
     invalidateParagraphRangeValues();
 }
 
 void TextCheckingParagraph::invalidateParagraphRangeValues()
 {
     m_checkingStart = m_checkingEnd = -1;
     m_offsetAsRange = EphemeralRange();
     m_text = String();
 }
 
 int TextCheckingParagraph::rangeLength() const
 {
-    ASSERT(m_checkingRange.isNotNull());
+    DCHECK(m_checkingRange.isNotNull());
     return TextIterator::rangeLength(paragraphRange().startPosition(), paragraphRange().endPosition());
 }
 
 EphemeralRange TextCheckingParagraph::paragraphRange() const
 {
-    ASSERT(m_checkingRange.isNotNull());
+    DCHECK(m_checkingRange.isNotNull());
     if (m_paragraphRange.isNull())
         m_paragraphRange = expandToParagraphBoundary(checkingRange());
     return m_paragraphRange;
 }
 
 void TextCheckingParagraph::setParagraphRange(const EphemeralRange& range)
 {
     m_paragraphRange = range;
 }
 
 EphemeralRange TextCheckingParagraph::subrange(int characterOffset, int characterCount) const
 {
-    ASSERT(m_checkingRange.isNotNull());
+    DCHECK(m_checkingRange.isNotNull());
     return calculateCharacterSubrange(paragraphRange(), characterOffset, characterCount);
 }
 
 int TextCheckingParagraph::offsetTo(const Position& position) const
 {
-    ASSERT(m_checkingRange.isNotNull());
+    DCHECK(m_checkingRange.isNotNull());
     return TextIterator::rangeLength(offsetAsRange().startPosition(), position);
 }
 
 bool TextCheckingParagraph::isEmpty() const
 {
     // Both predicates should have same result, but we check both just to be sure.
     // We need to investigate to remove this redundancy.
     return isRangeEmpty() || isTextEmpty();
 }
 
 EphemeralRange TextCheckingParagraph::offsetAsRange() const
 {
-    ASSERT(m_checkingRange.isNotNull());
+    DCHECK(m_checkingRange.isNotNull());
     if (m_offsetAsRange.isNull())
         m_offsetAsRange = EphemeralRange(paragraphRange().startPosition(), checkingRange().startPosition());
 
     return m_offsetAsRange;
 }
 
 const String& TextCheckingParagraph::text() const
 {
-    ASSERT(m_checkingRange.isNotNull());
+    DCHECK(m_checkingRange.isNotNull());
     if (m_text.isEmpty())
         m_text = plainText(paragraphRange());
     return m_text;
 }
 
 int TextCheckingParagraph::checkingStart() const
 {
-    ASSERT(m_checkingRange.isNotNull());
+    DCHECK(m_checkingRange.isNotNull());
     if (m_checkingStart == -1)
         m_checkingStart = TextIterator::rangeLength(offsetAsRange().startPosition(), offsetAsRange().endPosition());
     return m_checkingStart;
 }
 
 int TextCheckingParagraph::checkingEnd() const
 {
-    ASSERT(m_checkingRange.isNotNull());
+    DCHECK(m_checkingRange.isNotNull());
     if (m_checkingEnd == -1)
         m_checkingEnd = checkingStart() + TextIterator::rangeLength(checkingRange().startPosition(), checkingRange().endPosition());
     return m_checkingEnd;
 }
 
 int TextCheckingParagraph::checkingLength() const
 {
-    ASSERT(m_checkingRange.isNotNull());
+    DCHECK(m_checkingRange.isNotNull());
     if (-1 == m_checkingLength)
         m_checkingLength = TextIterator::rangeLength(checkingRange().startPosition(), checkingRange().endPosition());
     return m_checkingLength;
 }
 
 TextCheckingHelper::TextCheckingHelper(SpellCheckerClient& client, const Position& start, const Position& end)
     : m_client(&client)
     , m_start(start)
     , m_end(end)
 {
@@ skipping 17 matching lines @@
         // Skip some work for one-space-char hunks
         if (!(length == 1 && it.characterAt(0) == ' ')) {
 
             int misspellingLocation = -1;
             int misspellingLength = 0;
             m_client->textChecker().checkSpellingOfString(it.substring(0, length), &misspellingLocation, &misspellingLength);
 
             // 5490627 shows that there was some code path here where the String constructor below crashes.
             // We don't know exactly what combination of bad input caused this, so we're making this much
             // more robust against bad input on release builds.
-            ASSERT(misspellingLength >= 0);
-            ASSERT(misspellingLocation >= -1);
-            ASSERT(!misspellingLength || misspellingLocation >= 0);
-            ASSERT(misspellingLocation < length);
-            ASSERT(misspellingLength <= length);
-            ASSERT(misspellingLocation + misspellingLength <= length);
+            DCHECK_GE(misspellingLength, 0);
+            DCHECK_GE(misspellingLocation, -1);
+            DCHECK(!misspellingLength || misspellingLocation >= 0);
+            DCHECK_LT(misspellingLocation, length);
+            DCHECK_LE(misspellingLength, length);
+            DCHECK_LE(misspellingLocation + misspellingLength, length);
 
             if (misspellingLocation >= 0 && misspellingLength > 0 && misspellingLocation < length && misspellingLength <= length && misspellingLocation + misspellingLength <= length) {
 
                 // Compute range of misspelled word
                 const EphemeralRange misspellingRange = calculateCharacterSubrange(EphemeralRange(m_start, m_end), currentChunkOffset + misspellingLocation, misspellingLength);
 
                 // Remember first-encountered misspelling and its offset.
                 if (!firstMisspelling) {
                     firstMisspellingOffset = currentChunkOffset + misspellingLocation;
                     firstMisspelling = it.substring(misspellingLocation, misspellingLength);
@@ skipping 65 matching lines @@
                 int grammarDetailLocation = 0;
                 unsigned grammarDetailIndex = 0;
 
                 Vector<TextCheckingResult> results;
                 TextCheckingTypeMask checkingTypes = TextCheckingTypeSpelling | TextCheckingTypeGrammar;
                 checkTextOfParagraph(m_client->textChecker(), paragraphString, checkingTypes, results);
 
                 for (unsigned i = 0; i < results.size(); i++) {
                     const TextCheckingResult* result = &results[i];
                     if (result->decoration == TextDecorationTypeSpelling && result->location >= currentStartOffset && result->location + result->length <= currentEndOffset) {
-                        ASSERT(result->length > 0 && result->location >= 0);
+                        DCHECK_GT(result->length, 0);
+                        DCHECK_GE(result->location, 0);
                         spellingLocation = result->location;
                         misspelledWord = paragraphString.substring(result->location, result->length);
-                        ASSERT(misspelledWord.length());
+                        DCHECK(misspelledWord.length());
                         break;
                     }
                     if (result->decoration == TextDecorationTypeGrammar && result->location < currentEndOffset && result->location + result->length > currentStartOffset) {
-                        ASSERT(result->length > 0 && result->location >= 0);
+                        DCHECK_GT(result->length, 0);
+                        DCHECK_GE(result->location, 0);
                         // We can't stop after the first grammar result, since there might still be a spelling result after
                         // it begins but before the first detail in it, but we can stop if we find a second grammar result.
                         if (foundGrammar)
                             break;
                         for (unsigned j = 0; j < result->details.size(); j++) {
                             const GrammarDetail* detail = &result->details[j];
-                            ASSERT(detail->length > 0 && detail->location >= 0);
+                            DCHECK_GT(detail->length, 0);
+                            DCHECK_GE(detail->location, 0);
                             if (result->location + detail->location >= currentStartOffset && result->location + detail->location + detail->length <= currentEndOffset && (!foundGrammar || result->location + detail->location < grammarDetailLocation)) {
                                 grammarDetailIndex = j;
                                 grammarDetailLocation = result->location + detail->location;
                                 foundGrammar = true;
                             }
                         }
                         if (foundGrammar) {
                             grammarPhraseLocation = result->location;
                             outGrammarDetail = result->details[grammarDetailIndex];
                             badGrammarPhrase = paragraphString.substring(result->location, result->length);
-                            ASSERT(badGrammarPhrase.length());
+                            DCHECK(badGrammarPhrase.length());
                         }
                     }
                 }
 
                 if (!misspelledWord.isEmpty() && (badGrammarPhrase.isEmpty() || spellingLocation <= grammarDetailLocation)) {
                     int spellingOffset = spellingLocation - currentStartOffset;
                     if (!firstIteration)
                         spellingOffset += TextIterator::rangeLength(m_start, paragraphStart);
                     outIsSpelling = true;
                     outFirstFoundOffset = spellingOffset;
@@ skipping 23 matching lines @@
 }
 
 int TextCheckingHelper::findFirstGrammarDetail(const Vector<GrammarDetail>& grammarDetails, int badGrammarPhraseLocation, int startOffset, int endOffset, bool markAll) const
 {
     // Found some bad grammar. Find the earliest detail range that starts in our search range (if any).
     // Optionally add a DocumentMarker for each detail in the range.
     int earliestDetailLocationSoFar = -1;
     int earliestDetailIndex = -1;
     for (unsigned i = 0; i < grammarDetails.size(); i++) {
         const GrammarDetail* detail = &grammarDetails[i];
-        ASSERT(detail->length > 0 && detail->location >= 0);
+        DCHECK_GT(detail->length, 0);
+        DCHECK_GE(detail->location, 0);
 
         int detailStartOffsetInParagraph = badGrammarPhraseLocation + detail->location;
 
         // Skip this detail if it starts before the original search range
         if (detailStartOffsetInParagraph < startOffset)
             continue;
 
         // Skip this detail if it starts after the original search range
         if (detailStartOffsetInParagraph >= endOffset)
             continue;
@@ skipping 31 matching lines @@
 
     // Start checking from beginning of paragraph, but skip past results that occur before the start of the original search range.
     int startOffset = 0;
     while (startOffset < paragraph.checkingEnd()) {
         Vector<GrammarDetail> grammarDetails;
         int badGrammarPhraseLocation = -1;
         int badGrammarPhraseLength = 0;
         m_client->textChecker().checkGrammarOfString(paragraph.textSubstring(startOffset), grammarDetails, &badGrammarPhraseLocation, &badGrammarPhraseLength);
 
         if (!badGrammarPhraseLength) {
-            ASSERT(badGrammarPhraseLocation == -1);
+            DCHECK_EQ(badGrammarPhraseLocation, -1);
             return String();
         }
 
-        ASSERT(badGrammarPhraseLocation >= 0);
+        DCHECK_GE(badGrammarPhraseLocation, 0);
         badGrammarPhraseLocation += startOffset;
 
 
         // Found some bad grammar. Find the earliest detail range that starts in our search range (if any).
         int badGrammarIndex = findFirstGrammarDetail(grammarDetails, badGrammarPhraseLocation, paragraph.checkingStart(), paragraph.checkingEnd(), markAll);
         if (badGrammarIndex >= 0) {
-            ASSERT(static_cast<unsigned>(badGrammarIndex) < grammarDetails.size());
+            DCHECK_LT(static_cast<unsigned>(badGrammarIndex), grammarDetails.size());
             outGrammarDetail = grammarDetails[badGrammarIndex];
         }
 
         // If we found a detail in range, then we have found the first bad phrase (unless we found one earlier but
         // kept going so we could mark all instances).
         if (badGrammarIndex >= 0 && firstBadGrammarPhrase.isEmpty()) {
             outGrammarPhraseOffset = badGrammarPhraseLocation - paragraph.checkingStart();
             firstBadGrammarPhrase = paragraph.textSubstring(badGrammarPhraseLocation, badGrammarPhraseLength);
 
             // Found one. We're done now, unless we're marking each instance.
@@ skipping 21 matching lines @@
 {
     // Use the "markAll" feature of findFirstBadGrammar. Ignore the return value and "out parameters"; all we need to
     // do is mark every instance.
     GrammarDetail ignoredGrammarDetail;
     int ignoredOffset;
     findFirstBadGrammar(ignoredGrammarDetail, ignoredOffset, true);
 }
 
 bool TextCheckingHelper::unifiedTextCheckerEnabled() const
 {
-    ASSERT(m_start.isNotNull());
+    DCHECK(m_start.isNotNull());
     Document& doc = m_start.computeContainerNode()->document();
     return blink::unifiedTextCheckerEnabled(doc.frame());
 }
 
 void checkTextOfParagraph(TextCheckerClient& client, const String& text, TextCheckingTypeMask checkingTypes, Vector<TextCheckingResult>& results)
 {
     Vector<UChar> characters;
     text.appendTo(characters);
     unsigned length = text.length();
 
@@ skipping 30 matching lines @@
         return false;
 
     const Settings* settings = frame->settings();
     if (!settings)
         return false;
 
     return settings->unifiedTextCheckerEnabled();
 }
 
 } // namespace blink