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

Source/core/editing/SpellChecker.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 28 matching lines @@
 
 namespace WebCore {
 
 SpellCheckRequest::SpellCheckRequest(
         PassRefPtr<Range> checkingRange,
         PassRefPtr<Range> paragraphRange,
         const String& text,
         TextCheckingTypeMask mask,
         TextCheckingProcessType processType,
         const Vector<uint32_t>& documentMarkersInRange,
-        const Vector<unsigned>& documentMarkerOffsets)
+        const Vector<unsigned>& documentMarkerOffsets,
+        int requestNumber)
     : m_checker(0)
     , m_checkingRange(checkingRange)
     , m_paragraphRange(paragraphRange)
     , m_rootEditableElement(m_checkingRange->startContainer()->rootEditableElement())
     , m_requestData(unrequestedTextCheckingSequence, text, mask, processType, documentMarkersInRange, documentMarkerOffsets)
+    , m_requestNumber(requestNumber)
 {
 }
 
 SpellCheckRequest::~SpellCheckRequest()
 {
 }
 
 // static
-PassRefPtr<SpellCheckRequest> SpellCheckRequest::create(TextCheckingTypeMask textCheckingOptions, TextCheckingProcessType processType, PassRefPtr<Range> checkingRange, PassRefPtr<Range> paragraphRange)
+PassRefPtr<SpellCheckRequest> SpellCheckRequest::create(TextCheckingTypeMask textCheckingOptions, TextCheckingProcessType processType, PassRefPtr<Range> checkingRange, PassRefPtr<Range> paragraphRange, int requestNubmer)
 {
     ASSERT(checkingRange);
     ASSERT(paragraphRange);
 
     String text = checkingRange->text();
     if (!text.length())
         return PassRefPtr<SpellCheckRequest>();
 
     const Vector<DocumentMarker*>& markers = checkingRange->ownerDocument()->markers()->markersInRange(checkingRange.get(), DocumentMarker::Spelling | DocumentMarker::Grammar);
     Vector<uint32_t> hashes(markers.size());
     Vector<unsigned> offsets(markers.size());
     for (size_t i = 0; i < markers.size(); i++) {
         hashes[i] = markers[i]->hash();
         offsets[i] = markers[i]->startOffset();
     }
 
-    return adoptRef(new SpellCheckRequest(checkingRange, paragraphRange, text, textCheckingOptions, processType, hashes, offsets));
+    return adoptRef(new SpellCheckRequest(checkingRange, paragraphRange, text, textCheckingOptions, processType, hashes, offsets, requestNubmer));
 }
 
 const TextCheckingRequestData& SpellCheckRequest::data() const
 {
     return m_requestData;
 }
 
 void SpellCheckRequest::didSucceed(const Vector<TextCheckingResult>& results)
 {
     if (!m_checker)
@@ skipping 109 matching lines @@
     ASSERT(!m_processingRequest);
     if (!client())
         return;
     m_processingRequest = request;
     client()->requestCheckingOfString(m_processingRequest);
 }
 
 void SpellChecker::enqueueRequest(PassRefPtr<SpellCheckRequest> request)
 {
     ASSERT(request);
+    bool continuation = false;
+    if (m_requestQueue.size() > 0) {
+        RefPtr<SpellCheckRequest> lastRequest = m_requestQueue.last();
+        // It's a continuation if the number of the last request got incremented in the new one and
+        // both apply to the same editable.

[please use gerrit instead, 2013/08/14 17:30:28]

Ah, I see what this is doing now. Enqueueing a request used to overwrite the
request for the same element. You've made sure that spellcheck requests for
chunks of text for the same element do not overwrite each other. Good job! (No
action necessary.)

+        continuation = request->rootEditableElement() == lastRequest->rootEditableElement()
+            && request->requestNumber() == lastRequest->requestNumber() + 1;
+    }
 
-    for (RequestQueue::iterator it = m_requestQueue.begin(); it != m_requestQueue.end(); ++it) {
-        if (request->rootEditableElement() != (*it)->rootEditableElement())
-            continue;
+    if (!continuation) {

[please use gerrit instead, 2013/08/14 17:30:28]

Nit: Maybe add a comment here:

// Spellcheck requests for chunks of text in the same element should not
overwrite each other.

[pstanek, 2013/08/14 17:36:26]

Done.

+        for (RequestQueue::iterator it = m_requestQueue.begin(); it != m_requestQueue.end(); ++it) {
+            if (request->rootEditableElement() != (*it)->rootEditableElement())
+                continue;
 
-        *it = request;
-        return;
+            *it = request;
+            return;
+        }
     }
 
     m_requestQueue.append(request);
 }
 
 void SpellChecker::didCheck(int sequence, const Vector<TextCheckingResult>& results)
 {
     ASSERT(m_processingRequest);
     ASSERT(m_processingRequest->data().sequence() == sequence);
     if (m_processingRequest->data().sequence() != sequence) {
@@ skipping 26 matching lines @@
     didCheck(sequence, results);
 }
 
 void SpellChecker::didCheckCancel(int sequence)
 {
     Vector<TextCheckingResult> results;
     didCheck(sequence, results);
 }
 
 } // namespace WebCore