Merge TextCheckingHelper into SpellChecker Part 3

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

 /*
  * Copyright (C) 2006, 2007, 2008, 2011 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 233 matching lines @@
 
     if (spellingSearchStart == spellingSearchEnd)
         return; // nothing to search in
 
     // We go to the end of our first range instead of the start of it, just to be sure
     // we don't get foiled by any word boundary problems at the start. It means we might
     // do a tiny bit more searching.
     Node* searchEndNodeAfterWrap = spellingSearchEnd.computeContainerNode();
     int searchEndOffsetAfterWrap = spellingSearchEnd.offsetInContainerNode();
 
-    int misspellingOffset = 0;
-    String misspelledWord = findFirstMisspellingOrBadGrammar(spellingSearchStart, spellingSearchEnd, misspellingOffset);
+    std::pair<String, int> misspelledItem(String(), 0);
+    String& misspelledWord = misspelledItem.first;
+    int& misspellingOffset = misspelledItem.second;
+    misspelledItem = findFirstMisspelling(spellingSearchStart, spellingSearchEnd);
 
     // If we did not find a misspelled word, wrap and try again (but don't bother if we started at the beginning of the
     // block rather than at a selection).
     if (startedWithSelection && !misspelledWord) {
         spellingSearchStart = Position::editingPositionOf(topNode, 0);
         // going until the end of the very first chunk we tested is far enough
         spellingSearchEnd = Position::editingPositionOf(searchEndNodeAfterWrap, searchEndOffsetAfterWrap);
-        misspelledWord = findFirstMisspellingOrBadGrammar(spellingSearchStart, spellingSearchEnd, misspellingOffset);
+        misspelledItem = findFirstMisspelling(spellingSearchStart, spellingSearchEnd);
     }
 
     if (!misspelledWord.isEmpty()) {
         // We found a misspelling. Select the misspelling, update the spelling panel, and store
         // a marker so we draw the red squiggle later.
 
         const EphemeralRange misspellingRange = calculateCharacterSubrange(EphemeralRange(spellingSearchStart, spellingSearchEnd), misspellingOffset, misspelledWord.length());
         frame().selection().setSelection(VisibleSelection(misspellingRange));
         frame().selection().revealSelection();
         spellCheckerClient().updateSpellingUIWithMisspelledWord(misspelledWord);
@@ skipping 506 matching lines @@
 {
     visitor->trace(m_frame);
     visitor->trace(m_spellCheckRequester);
 }
 
 void SpellChecker::prepareForLeakDetection()
 {
     m_spellCheckRequester->prepareForLeakDetection();
 }
 
-void SpellChecker::findMisspellings(const String& text, Vector<TextCheckingResult>& results)
+Vector<TextCheckingResult> SpellChecker::findMisspellings(const String& text)
 {
     Vector<UChar> characters;
     text.appendTo(characters);
     unsigned length = text.length();
 
     TextBreakIterator* iterator = wordBreakIterator(characters.data(), length);
     if (!iterator)
-        return;
+        return Vector<TextCheckingResult>();
 
+    Vector<TextCheckingResult> results;
     int wordStart = iterator->current();
-    while (0 <= wordStart) {
+    while (wordStart >= 0) {
         int wordEnd = iterator->next();
         if (wordEnd < 0)
             break;
         int wordLength = wordEnd - wordStart;
         int misspellingLocation = -1;
         int misspellingLength = 0;
         textChecker().checkSpellingOfString(String(characters.data() + wordStart, wordLength), &misspellingLocation, &misspellingLength);
-        if (0 < misspellingLength) {
-            DCHECK_LE(0, misspellingLocation);
-            DCHECK_LE(misspellingLocation, wordLength);
-            DCHECK_LT(0, misspellingLength);
+        if (misspellingLength > 0) {
+            DCHECK_GE(misspellingLocation, 0);
             DCHECK_LE(misspellingLocation + misspellingLength, wordLength);
             TextCheckingResult misspelling;
             misspelling.decoration = TextDecorationTypeSpelling;
             misspelling.location = wordStart + misspellingLocation;
             misspelling.length = misspellingLength;
             results.append(misspelling);
         }
-
         wordStart = wordEnd;
     }
+    return results;
 }
 
-String SpellChecker::findFirstMisspellingOrBadGrammar(const Position& start, const Position& end, int& outFirstFoundOffset)
+std::pair<String, int> SpellChecker::findFirstMisspelling(const Position& start, const Position& end)
 {
-    String firstFoundItem;
     String misspelledWord;
 
-    // Initialize out parameter; it will be updated if we find something to return.
-    outFirstFoundOffset = 0;
+    // Initialize out parameters; they will be updated if we find something to return.
+    String firstFoundItem;
+    int firstFoundOffset = 0;
 
     // Expand the search range to encompass entire paragraphs, since text checking needs that much context.
     // Determine the character offset from the start of the paragraph to the start of the original search range,
     // since we will want to ignore results in this area.
     Position paragraphStart = startOfParagraph(createVisiblePosition(start)).toParentAnchoredPosition();
     Position paragraphEnd = end;
     int totalRangeLength = TextIterator::rangeLength(paragraphStart, paragraphEnd);
     paragraphEnd = endOfParagraph(createVisiblePosition(start)).toParentAnchoredPosition();
 
     int rangeStartOffset = TextIterator::rangeLength(paragraphStart, start);
@@ skipping 10 matching lines @@
             // Determine the character offset from the end of the original search range to the end of the paragraph,
             // since we will want to ignore results in this area.
             currentEndOffset = TextIterator::rangeLength(paragraphStart, end);
             lastIteration = true;
         }
         if (currentStartOffset < currentEndOffset) {
             String paragraphString = plainText(EphemeralRange(paragraphStart, paragraphEnd));
             if (paragraphString.length() > 0) {
                 int spellingLocation = 0;
 
-                Vector<TextCheckingResult> results;
-                findMisspellings(paragraphString, results);
+                Vector<TextCheckingResult> results = findMisspellings(paragraphString);
 
                 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) {
+                    if (result->location >= currentStartOffset && result->location + result->length <= currentEndOffset) {
                         DCHECK_GT(result->length, 0);
                         DCHECK_GE(result->location, 0);
                         spellingLocation = result->location;
                         misspelledWord = paragraphString.substring(result->location, result->length);
                         DCHECK(misspelledWord.length());
                         break;
                     }
                 }
 
                 if (!misspelledWord.isEmpty()) {
                     int spellingOffset = spellingLocation - currentStartOffset;
                     if (!firstIteration)
                         spellingOffset += TextIterator::rangeLength(start, paragraphStart);
-                    outFirstFoundOffset = spellingOffset;
+                    firstFoundOffset = spellingOffset;
                     firstFoundItem = misspelledWord;
                     break;
                 }
             }
         }
         if (lastIteration || totalLengthProcessed + currentLength >= totalRangeLength)
             break;
         VisiblePosition newParagraphStart = startOfNextParagraph(createVisiblePosition(paragraphEnd));
         paragraphStart = newParagraphStart.toParentAnchoredPosition();
         paragraphEnd = endOfParagraph(newParagraphStart).toParentAnchoredPosition();
         firstIteration = false;
         totalLengthProcessed += currentLength;
     }
-    return firstFoundItem;
+    return std::make_pair(firstFoundItem, firstFoundOffset);
 }
 
 } // namespace blink