Chunk up the text to spell check also when the text is pasted.

Source/core/dom/DocumentMarkerController.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2001 Dirk Mueller (mueller@kde.org)
  *           (C) 2006 Alexey Proskuryakov (ap@webkit.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2008, 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
@@ skipping 115 matching lines @@
             return;
         ASSERT(!m_markers.isEmpty());
 
         RefPtr<Range> textPiece = markedText.range();
         int startOffset = textPiece->startOffset();
         int endOffset = textPiece->endOffset();
         removeMarkers(textPiece->startContainer(), startOffset, endOffset - startOffset, markerTypes, shouldRemovePartiallyOverlappingMarker);
     }
 }
 
+static bool startsFurther(const DocumentMarker& lhv, const DocumentMarker& rhv)
+{
+    return lhv.startOffset() < rhv.startOffset();
+}
+
+static bool notOverlaps(const DocumentMarker& lhv, const DocumentMarker& rhv)

[tony, 2013/08/29 22:44:45]

Nit: doesNotOverlap sounds better to me than notOverlaps.

+{
+    return lhv.endOffset() < rhv.startOffset();
+}
+
 // Markers are stored in order sorted by their start offset.
 // Markers of the same type do not overlap each other.
 
 void DocumentMarkerController::addMarker(Node* node, const DocumentMarker& newMarker)
 {
     ASSERT(newMarker.endOffset() >= newMarker.startOffset());
     if (newMarker.endOffset() == newMarker.startOffset())
         return;
 
     m_possiblyExistingMarkerTypes.add(newMarker.type());
 
     OwnPtr<MarkerList>& list = m_markers.add(node, nullptr).iterator->value;
 
     if (!list) {
         list = adoptPtr(new MarkerList);
         list->append(RenderedDocumentMarker(newMarker));
     } else {
         RenderedDocumentMarker toInsert(newMarker);
-        size_t numMarkers = list->size();
-        size_t i;
-        // Iterate over all markers whose start offset is less than or equal to the new marker's.
-        // If one of them is of the same type as the new marker and touches it or intersects with it
-        // (there is at most one), remove it and adjust the new marker's start offset to encompass it.
-        for (i = 0; i < numMarkers; ++i) {
-            DocumentMarker marker = list->at(i);
-            if (marker.startOffset() > toInsert.startOffset())
-                break;
-            if (marker.type() == toInsert.type() && marker.type() != DocumentMarker::TextMatch && marker.endOffset() >= toInsert.startOffset()) {
-                toInsert.setStartOffset(marker.startOffset());
-                list->remove(i);
-                numMarkers--;
-                break;
+        if (list->last().endOffset() <= newMarker.startOffset()) {
+            if (toInsert.type() != DocumentMarker::TextMatch) {

[tony, 2013/08/29 22:44:45]

Can we move this block into a helper function?  The name of the function should
help describe what it's doing so you don't have to write.

+                // Iterate over all markers whose start offset is less than or equal to the new marker's.
+                // If one of them is of the same type as the new marker and touches it or intersects with it
+                // (there is at most one), remove it and adjust the new marker's start offset to encompass it.
+                size_t numMarkers = list->size();
+                MarkerList::iterator end = std::upper_bound(list->begin(), list->end(), toInsert, startsFurther);
+                MarkerList::iterator overlapping = list->begin();
+                do {
+                    overlapping = std::lower_bound(overlapping, end, toInsert, notOverlaps);
+                } while (overlapping != end && overlapping->type() != toInsert.type() && ++overlapping != end);
+
+                size_t i;

[tony, 2013/08/29 22:44:45]

Please use a more descriptive variable than 'i'.  Maybe overlappingIndex?

+                if (overlapping != end) {
+                    toInsert.setStartOffset(overlapping->startOffset());
+                    i = overlapping - list->begin();
+                    list->remove(i);
+                    numMarkers--;

[tony, 2013/08/29 22:44:45]

Nit: --numMarkers

+                } else {
+                    i = numMarkers;

[tony, 2013/08/29 22:44:45]

Set i = numMarkers when initializing and you can get rid of the else block.

+                }
+                size_t j = i;
+                // Iterate over all markers whose end offset is less than or equal to the new marker's,
+                // removing markers of the same type as the new marker which touch it or intersect with it,
+                // adjusting the new marker's end offset to cover them if necessary.
+                while (j < numMarkers) {

[tony, 2013/08/29 22:44:45]

Looks like you could use a for loop here so that j (which you could now rename
to i) is scoped within the loop.

+                    DocumentMarker marker = list->at(j);
+                    if (marker.startOffset() > toInsert.endOffset())
+                        break;
+                    if (marker.type() == toInsert.type()) {
+                        list->remove(j);
+                        if (toInsert.endOffset() <= marker.endOffset()) {
+                            toInsert.setEndOffset(marker.endOffset());
+                            break;
+                        }
+                        numMarkers--;

[tony, 2013/08/29 22:44:45]

Nit: --numMarkers

+                    } else {
+                        j++;

[tony, 2013/08/29 22:44:45]

Nit: ++j

+                    }
+                }
+                // At this point i points to the node before which we want to insert.
+                list->insert(i, RenderedDocumentMarker(toInsert));
+            } else {
+                MarkerList::iterator pos = std::lower_bound(list->begin(), list->end(), toInsert, startsFurther);
+                if (pos != list->end())
+                    list->insert(pos - list->begin(), RenderedDocumentMarker(toInsert));
+                else
+                    list->append(RenderedDocumentMarker(toInsert));
             }
+        } else {
+            list->append(RenderedDocumentMarker(toInsert));
         }
-        size_t j = i;
-        // Iterate over all markers whose end offset is less than or equal to the new marker's,
-        // removing markers of the same type as the new marker which touch it or intersect with it,
-        // adjusting the new marker's end offset to cover them if necessary.
-        while (j < numMarkers) {
-            DocumentMarker marker = list->at(j);
-            if (marker.startOffset() > toInsert.endOffset())
-                break;
-            if (marker.type() == toInsert.type() && marker.type() != DocumentMarker::TextMatch) {
-                list->remove(j);
-                if (toInsert.endOffset() <= marker.endOffset()) {
-                    toInsert.setEndOffset(marker.endOffset());
-                    break;
-                }
-                numMarkers--;
-            } else
-                j++;
-        }
-        // At this point i points to the node before which we want to insert.
-        list->insert(i, RenderedDocumentMarker(toInsert));
     }
 
     // repaint the affected node
     if (node->renderer())
         node->renderer()->repaint();
 }
 
 // copies markers from srcNode to dstNode, applying the specified shift delta to the copies.  The shift is
 // useful if, e.g., the caller has created the dstNode from a non-prefix substring of the srcNode.
 void DocumentMarkerController::copyMarkers(Node* srcNode, unsigned startOffset, int length, Node* dstNode, int delta)
@@ skipping 470 matching lines @@
 
 } // namespace WebCore
 
 #ifndef NDEBUG
 void showDocumentMarkers(const WebCore::DocumentMarkerController* controller)
 {
     if (controller)
         controller->showMarkers();
 }
 #endif