Optimizations to Spellchecking Chunk Generation

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 461 matching lines @@
     if (!editableNode || !editableNode->hasEditableStyle())
         return;
 
     if (!isSpellCheckingEnabledFor(editableNode))
         return;
 
     TextCheckingParagraph fullParagraphToCheck(shouldMarkGrammar ? grammarRange : spellingRange);
     chunkAndMarkAllMisspellingsAndBadGrammar(textCheckingOptions, fullParagraphToCheck);
 }
 
+static EphemeralRange expandEndToSentenceBoundary(const EphemeralRange& range)
+{
+    ASSERT(range.isNotNull());
+    const VisiblePosition& visibleEnd = createVisiblePosition(range.endPosition());
+    ASSERT(visibleEnd.isNotNull());
+    const Position& sentenceEnd = endOfSentence(visibleEnd).deepEquivalent();
+    return EphemeralRange(range.startPosition(), sentenceEnd.isNotNull() ? sentenceEnd : range.endPosition());
+}
+
+static EphemeralRange expandRangeToSentenceBoundary(const EphemeralRange& range)
+{
+    ASSERT(range.isNotNull());
+    const VisiblePosition& visibleStart = createVisiblePosition(range.startPosition());
+    ASSERT(visibleStart.isNotNull());
+    const Position& sentenceStart = startOfSentence(visibleStart).deepEquivalent();
+    return expandEndToSentenceBoundary(EphemeralRange(sentenceStart.isNull() ? range.startPosition() : sentenceStart, range.endPosition()));
+}
+
 void SpellChecker::chunkAndMarkAllMisspellingsAndBadGrammar(Node* node)
 {
     TRACE_EVENT0("blink", "SpellChecker::chunkAndMarkAllMisspellingsAndBadGrammar");
     if (!node)
         return;
     RefPtrWillBeRawPtr<Range> rangeToCheck = Range::create(*frame().document(), firstPositionInNode(node), lastPositionInNode(node));
     TextCheckingParagraph textToCheck(rangeToCheck, rangeToCheck);
     chunkAndMarkAllMisspellingsAndBadGrammar(resolveTextCheckingTypeMask(TextCheckingTypeSpelling | TextCheckingTypeGrammar), textToCheck);
 }
 
 void SpellChecker::chunkAndMarkAllMisspellingsAndBadGrammar(TextCheckingTypeMask textCheckingOptions, const TextCheckingParagraph& fullParagraphToCheck)
 {
     if (fullParagraphToCheck.isEmpty())
         return;
+    const EphemeralRange& paragraphRange = fullParagraphToCheck.paragraphRange();
 
     // Since the text may be quite big chunk it up and adjust to the sentence boundary.
     const int kChunkSize = 16 * 1024;
-    int start = fullParagraphToCheck.checkingStart();
-    int end = fullParagraphToCheck.checkingEnd();
-    start = std::min(start, end);
-    end = std::max(start, end);
-    const int kNumChunksToCheck = (end - start + kChunkSize - 1) / kChunkSize;
-    int currentChunkStart = start;
-    if (kNumChunksToCheck == 1) {
-        EphemeralRange checkRange = fullParagraphToCheck.checkingRange();
-        markAllMisspellingsAndBadGrammarInRanges(textCheckingOptions, checkRange, checkRange, 0);
-        return;
+    CharacterIterator checkRangeIterator(fullParagraphToCheck.checkingRange(), TextIteratorEmitsObjectReplacementCharacter);
+    for (int requestNum = 0; !checkRangeIterator.atEnd(); requestNum++) {
+        EphemeralRange chunkRange = checkRangeIterator.calculateCharacterSubrange(0, kChunkSize);
+        EphemeralRange checkRange = requestNum ? expandEndToSentenceBoundary(chunkRange) : expandRangeToSentenceBoundary(chunkRange);
+
+        RefPtrWillBeRawPtr<SpellCheckRequest> request = SpellCheckRequest::create(resolveTextCheckingTypeMask(textCheckingOptions), TextCheckingProcessBatch, checkRange, paragraphRange, requestNum);
+        if (request)
+            m_spellCheckRequester->requestCheckingFor(request);
+
+        if (!checkRangeIterator.atEnd()) {
+            checkRangeIterator.advance(1);
+            // The layout should be already update due to the initialization of checkRangeIterator,
+            // so comparePositions can be directly called.
+            if (comparePositions(chunkRange.endPosition(), checkRange.endPosition()) < 0)
+                checkRangeIterator.advance(TextIterator::rangeLength(chunkRange.endPosition(), checkRange.endPosition()));
+        }
     }
-
-    for (int iter = 0; iter < kNumChunksToCheck; ++iter) {
-        EphemeralRange checkRange = expandRangeToSentenceBoundary(fullParagraphToCheck.subrange(currentChunkStart, kChunkSize));
-        int checkingLength = 0;
-        markAllMisspellingsAndBadGrammarInRanges(textCheckingOptions, checkRange, checkRange, iter, &checkingLength);
-        currentChunkStart += checkingLength;
-    }
-}
-
-void SpellChecker::markAllMisspellingsAndBadGrammarInRanges(TextCheckingTypeMask textCheckingOptions, const EphemeralRange& checkRange, const EphemeralRange& paragraphRange, int requestNumber, int* checkingLength)
-{
-    TextCheckingParagraph sentenceToCheck(checkRange, paragraphRange);
-    if (checkingLength)
-        *checkingLength = sentenceToCheck.checkingLength();
-
-    RefPtrWillBeRawPtr<SpellCheckRequest> request = SpellCheckRequest::create(resolveTextCheckingTypeMask(textCheckingOptions), TextCheckingProcessBatch, checkRange, paragraphRange, requestNumber);
-    if (!request)
-        return;
-
-    m_spellCheckRequester->requestCheckingFor(request);
 }
 
 void SpellChecker::markAndReplaceFor(PassRefPtrWillBeRawPtr<SpellCheckRequest> request, const Vector<TextCheckingResult>& results)
 {
     TRACE_EVENT0("blink", "SpellChecker::markAndReplaceFor");
     ASSERT(request);
     if (!request->isValid())
         return;
 
     TextCheckingTypeMask textCheckingOptions = request->data().mask();
@@ skipping 363 matching lines @@
     m_spellCheckRequester->requestCheckingFor(SpellCheckRequest::create(TextCheckingTypeSpelling | TextCheckingTypeGrammar, TextCheckingProcessBatch, rangeToCheck, rangeToCheck));
 }
 
 DEFINE_TRACE(SpellChecker)
 {
     visitor->trace(m_frame);
     visitor->trace(m_spellCheckRequester);
 }
 
 } // namespace blink