Trigger spell check/remove markers if spell checker gets enabled/disabled.

Source/core/editing/Editor.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 403 matching lines @@
     applyCommand(ReplaceSelectionCommand::create(m_frame->document(), fragment, options, EditActionPaste));
     revealSelectionAfterEditingOperation();
 
     if (m_frame->selection()->isInPasswordField() || !isContinuousSpellCheckingEnabled())
         return;
     Node* nodeToCheck = m_frame->selection()->rootEditableElement();
     if (!nodeToCheck)
         return;
 
     RefPtr<Range> rangeToCheck = Range::create(m_frame->document(), firstPositionInNode(nodeToCheck), lastPositionInNode(nodeToCheck));
-    m_spellChecker->requestCheckingFor(SpellCheckRequest::create(resolveTextCheckingTypeMask(TextCheckingTypeSpelling | TextCheckingTypeGrammar), TextCheckingProcessBatch, rangeToCheck, rangeToCheck));
+    markAllMisspellingsAndBadGrammarInRanges(resolveTextCheckingTypeMask(TextCheckingTypeSpelling | TextCheckingTypeGrammar), rangeToCheck.get(), rangeToCheck.get());
 }
 
 void Editor::replaceSelectionWithText(const String& text, bool selectReplacement, bool smartReplace)
 {
     replaceSelectionWithFragment(createFragmentFromText(selectedRange().get(), text), selectReplacement, smartReplace, true);
 }
 
 PassRefPtr<Range> Editor::selectedRange()
 {
     if (!m_frame)
@@ skipping 1044 matching lines @@
 
 void Editor::markBadGrammar(const VisibleSelection& selection)
 {
     RefPtr<Range> firstMisspellingRange;
     markMisspellingsOrBadGrammar(selection, false, firstMisspellingRange);
 }
 
 void Editor::markAllMisspellingsAndBadGrammarInRanges(TextCheckingTypeMask textCheckingOptions, Range* spellingRange, Range* grammarRange)
 {
     ASSERT(m_frame);
-    ASSERT(unifiedTextCheckerEnabled());
 
-    bool shouldMarkGrammar = textCheckingOptions & TextCheckingTypeGrammar;
+    bool shouldMarkGrammar = (textCheckingOptions & TextCheckingTypeGrammar) && isGrammarCheckingEnabled();
+    bool shouldMarkSpellling = (textCheckingOptions & TextCheckingTypeSpelling) && isContinuousSpellCheckingEnabled();
+
+    if (!shouldMarkSpellling && !shouldMarkGrammar)
+        return;
 
     // This function is called with selections already expanded to word boundaries.
     if (!client() || !spellingRange || (shouldMarkGrammar && !grammarRange))
         return;
 
     // If we're not in an editable node, bail.
     Node* editableNode = spellingRange->startContainer();
     if (!editableNode || !editableNode->rendererIsEditable())
         return;
 
     if (!isSpellCheckingEnabledFor(editableNode))
         return;
 
     Range* rangeToCheck = shouldMarkGrammar ? grammarRange : spellingRange;
-    TextCheckingParagraph paragraphToCheck(rangeToCheck);
-    if (paragraphToCheck.isRangeEmpty() || paragraphToCheck.isEmpty())
+    TextCheckingParagraph fullParagraphToCheck(rangeToCheck);
+    if (fullParagraphToCheck.isRangeEmpty() || fullParagraphToCheck.isEmpty())
         return;
-    RefPtr<Range> paragraphRange = paragraphToCheck.paragraphRange();
 
-    bool asynchronous = m_frame && m_frame->settings() && m_frame->settings()->asynchronousSpellCheckingEnabled();
+    // 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 loopNum = (end - start + kChunkSize - 1) / (kChunkSize);

[please use gerrit instead, 2013/08/13 21:54:21]

Nit: rename loopNum to "numChunksToCheck". (Number of chunks to check).

+    int currentChunkStart = start;
+    for (int iter = 0; iter < loopNum; ++iter) {
+        RefPtr<Range> checkRange = fullParagraphToCheck.subrange(currentChunkStart, kChunkSize);
+        setStart(checkRange.get(), startOfSentence(checkRange->startPosition()));
+        setEnd(checkRange.get(), endOfSentence(checkRange->endPosition()));
+        TextCheckingParagraph sentenceToCheck(checkRange, checkRange);
 
-    // In asynchronous mode, we intentionally check paragraph-wide sentence.
-    RefPtr<SpellCheckRequest> request = SpellCheckRequest::create(resolveTextCheckingTypeMask(textCheckingOptions), TextCheckingProcessIncremental, asynchronous ? paragraphRange : rangeToCheck, paragraphRange);
+        currentChunkStart += sentenceToCheck.checkingLength();
 
-    if (asynchronous) {
-        m_spellChecker->requestCheckingFor(request);
+        bool asynchronous = m_frame && m_frame->settings() && m_frame->settings()->asynchronousSpellCheckingEnabled();

[please use gerrit instead, 2013/08/13 21:54:21]

The "asynchronous" variable can live outside of the for loop.

+
+        RefPtr<SpellCheckRequest> request = SpellCheckRequest::create(resolveTextCheckingTypeMask(textCheckingOptions), TextCheckingProcessBatch, checkRange, checkRange, iter);
+
+        if (asynchronous) {
+            m_spellChecker->requestCheckingFor(request);
+            continue;
+        }
+
+        Vector<TextCheckingResult> results;
+        checkTextOfParagraph(textChecker(), sentenceToCheck.text(), resolveTextCheckingTypeMask(textCheckingOptions), results);

[please use gerrit instead, 2013/08/13 21:54:21]

If you're splitting up the spellcheck requests for the synchronous case, too,
then please add a layout test with asynchronous spellchecking disabled. For
example, you could call it spelling-huge-text-sync.html and base it on the
existing spelling-huge-text.html that you wrote.

+        markAndReplaceFor(request, results);
         return;

[please use gerrit instead, 2013/08/13 21:54:21]

It's not clear from this code that you spellcheck only one chunk with
synchronous spellcheck. Perhaps you could do this instead:

  int loopNum = asynchronous ?
      (end - start + kChunkSize - 1) / (kChunkSize) : 1;

Then you don't need the "return" statement here.

     }
-
-    Vector<TextCheckingResult> results;
-    checkTextOfParagraph(textChecker(), paragraphToCheck.text(), resolveTextCheckingTypeMask(textCheckingOptions), results);
-    markAndReplaceFor(request, results);
 }
 
 void Editor::markAndReplaceFor(PassRefPtr<SpellCheckRequest> request, const Vector<TextCheckingResult>& results)
 {
     ASSERT(request);
 
     TextCheckingTypeMask textCheckingOptions = request->data().mask();
     TextCheckingParagraph paragraph(request->checkingRange(), request->paragraphRange());
 
     bool shouldMarkSpelling = textCheckingOptions & TextCheckingTypeSpelling;
@@ skipping 15 matching lines @@
             if (selectionOffset > 0 && (static_cast<unsigned>(selectionOffset) > paragraph.text().length() || paragraph.textCharAt(selectionOffset - 1) == newlineCharacter))
                 adjustSelectionForParagraphBoundaries = true;
             if (selectionOffset > 0 && static_cast<unsigned>(selectionOffset) <= paragraph.text().length() && isAmbiguousBoundaryCharacter(paragraph.textCharAt(selectionOffset - 1)))
                 ambiguousBoundaryOffset = selectionOffset - 1;
         }
     }
 
     for (unsigned i = 0; i < results.size(); i++) {
         int spellingRangeEndOffset = paragraph.checkingEnd();
         const TextCheckingResult* result = &results[i];
-        int resultLocation = result->location;
+        int resultLocation = result->location + paragraph.checkingStart();
         int resultLength = result->length;
         bool resultEndsAtAmbiguousBoundary = ambiguousBoundaryOffset >= 0 && resultLocation + resultLength == ambiguousBoundaryOffset;
 
         // Only mark misspelling if:
         // 1. Current text checking isn't done for autocorrection, in which case shouldMarkSpelling is false.
         // 2. Result falls within spellingRange.
         // 3. The word in question doesn't end at an ambiguous boundary. For instance, we would not mark
         //    "wouldn'" as misspelled right after apostrophe is typed.
         if (shouldMarkSpelling && result->type == TextCheckingTypeSpelling && resultLocation >= paragraph.checkingStart() && resultLocation + resultLength <= spellingRangeEndOffset && !resultEndsAtAmbiguousBoundary) {
             ASSERT(resultLength > 0 && resultLocation >= 0);
@@ skipping 608 matching lines @@
     return WebCore::unifiedTextCheckerEnabled(m_frame);
 }
 
 void Editor::toggleOverwriteModeEnabled()
 {
     m_overwriteModeEnabled = !m_overwriteModeEnabled;
     frame()->selection()->setShouldShowBlockCursor(m_overwriteModeEnabled);
 };
 
 } // namespace WebCore