Invalidate paint of tickmarks on document change

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 15 matching lines @@
 
 #include "config.h"
 #include "core/dom/DocumentMarkerController.h"
 
 #include "core/dom/Node.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/Range.h"
 #include "core/dom/RenderedDocumentMarker.h"
 #include "core/dom/Text.h"
 #include "core/editing/iterators/TextIterator.h"
+#include "core/frame/FrameView.h"
 #include "core/layout/LayoutObject.h"
 
 #ifndef NDEBUG
 #include <stdio.h>
 #endif
 
 namespace blink {
 
 MarkerRemoverPredicate::MarkerRemoverPredicate(const Vector<String>& words)
     : m_words(words)
@@ skipping 62 matching lines @@
     for (TextIterator markedText(start, end); !markedText.atEnd(); markedText.advance()) {
         addMarker(markedText.currentContainer(), DocumentMarker(type, markedText.startOffsetInCurrentContainer(), markedText.endOffsetInCurrentContainer(), description, hash));
     }
 }
 
 void DocumentMarkerController::addTextMatchMarker(const Range* range, bool activeMatch)
 {
     // Use a TextIterator to visit the potentially multiple nodes the range covers.
     for (TextIterator markedText(range->startPosition(), range->endPosition()); !markedText.atEnd(); markedText.advance())
         addMarker(markedText.currentContainer(), DocumentMarker(markedText.startOffsetInCurrentContainer(), markedText.endOffsetInCurrentContainer(), activeMatch));
+    // Don't invalidate tickmarks here. TextFinder invalidates tickmarks using a throttling algorithm. crbug.com/6819.
 }
 
 void DocumentMarkerController::prepareForDestruction()
 {
     clear();
 }
 
 void DocumentMarkerController::removeMarkers(TextIterator& markedText, DocumentMarker::MarkerTypes markerTypes, RemovePartiallyOverlappingMarkerOrNot shouldRemovePartiallyOverlappingMarker)
 {
     for (; !markedText.atEnd(); markedText.advance()) {
@@ skipping 42 matching lines @@
 static bool doesNotOverlap(const OwnPtrWillBeMember<RenderedDocumentMarker>& lhv, const DocumentMarker* rhv)
 {
     return lhv->endOffset() < rhv->startOffset();
 }
 
 static bool doesNotInclude(const OwnPtrWillBeMember<RenderedDocumentMarker>& marker, size_t startOffset)
 {
     return marker->endOffset() < startOffset;
 }
 
-static void updateMarkerRenderedRect(Node* node, RenderedDocumentMarker& marker)
+static bool updateMarkerRenderedRect(Node* node, RenderedDocumentMarker& marker)
 {
     RefPtrWillBeRawPtr<Range> range = Range::create(node->document());
     // The offsets of the marker may be out-dated, so check for exceptions.
     TrackExceptionState exceptionState;
     range->setStart(node, marker.startOffset(), exceptionState);
     if (!exceptionState.hadException())
         range->setEnd(node, marker.endOffset(), IGNORE_EXCEPTION);
-    if (exceptionState.hadException()) {
-        marker.invalidateRenderedRect();
-        return;
-    }
-
-    marker.setRenderedRect(LayoutRect(range->boundingBox()));
+    if (exceptionState.hadException())
+        return marker.invalidateRenderedRect();
+    return marker.setRenderedRect(LayoutRect(range->boundingBox()));
 }
 
 // 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;
@@ skipping 280 matching lines @@
                 if (!marker->isRendered())
                     continue;
                 result.append(marker->renderedRect());
             }
         }
     }
 
     return result;
 }
 
+static void invalidatePaintForTickmarks(const Node& node)
+{
+    if (FrameView* frameView = node.document().view())
+        frameView->invalidatePaintForTickmarks();
+}
+
 void DocumentMarkerController::updateRenderedRectsForMarkers()
 {
     for (auto& nodeMarkers : m_markers) {
         const Node* node = nodeMarkers.key;
         for (auto& markerList : *nodeMarkers.value) {
             if (!markerList)
                 continue;
+            bool markersChanged = false;
             for (auto& marker : *markerList)
-                updateMarkerRenderedRect(const_cast<Node*>(node), *marker);
+                markersChanged |= updateMarkerRenderedRect(const_cast<Node*>(node), *marker);
+
+            if (markersChanged && markerList->first()->type() == DocumentMarker::TextMatch)
+                invalidatePaintForTickmarks(*node);
         }
     }
 }
 
 DEFINE_TRACE(DocumentMarkerController)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_markers);
 #endif
 }
 
 void DocumentMarkerController::removeMarkers(Node* node, DocumentMarker::MarkerTypes markerTypes)
 {
     if (!possiblyHasMarkers(markerTypes))
         return;
     ASSERT(!m_markers.isEmpty());
 
     MarkerMap::iterator iterator = m_markers.find(node);
     if (iterator != m_markers.end())
         removeMarkersFromList(iterator, markerTypes);
 }
 
 void DocumentMarkerController::removeMarkers(const MarkerRemoverPredicate& shouldRemoveMarker)
 {
-    for (MarkerMap::iterator i = m_markers.begin(); i != m_markers.end(); ++i) {
-        MarkerLists* markers = i->value.get();
+    for (auto& nodeMarkers : m_markers) {
+        const Node& node = *nodeMarkers.key;
+        if (!node.isTextNode()) // MarkerRemoverPredicate requires a Text node.
+            continue;
+        MarkerLists& markers = *nodeMarkers.value;
         for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
-            OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
-
-            WillBeHeapVector<RawPtrWillBeMember<RenderedDocumentMarker>> markersToBeRemoved;
-            for (size_t j = 0; list.get() && j < list->size(); ++j) {
-                if (i->key->isTextNode() && shouldRemoveMarker(*list->at(j).get(), static_cast<const Text&>(*i->key)))
-                    markersToBeRemoved.append(list->at(j).get());
+            OwnPtrWillBeMember<MarkerList>& list = markers[markerListIndex];
+            if (!list)
+                continue;
+            bool removedMarkers = false;
+            for (size_t j = list->size(); j > 0; --j) {
+                if (shouldRemoveMarker(*list->at(j - 1), static_cast<const Text&>(node))) {
+                    list->remove(j - 1);
+                    removedMarkers = true;
+                }
             }
-
-            for (size_t j = 0; j < markersToBeRemoved.size(); ++j)
-                list->remove(list->find(markersToBeRemoved[j].get()));
+            if (removedMarkers && markerListIndex == DocumentMarker::TextMatchMarkerIndex)
+                invalidatePaintForTickmarks(node);
         }
     }
 }
 
 void DocumentMarkerController::removeMarkers(DocumentMarker::MarkerTypes markerTypes)
 {
     if (!possiblyHasMarkers(markerTypes))
         return;
     ASSERT(!m_markers.isEmpty());
 
@@ skipping 34 matching lines @@
                 list.clear();
                 ++emptyListsCount;
                 needsRepainting = true;
             }
         }
 
         nodeCanBeRemoved = emptyListsCount == DocumentMarker::MarkerTypeIndexesCount;
     }
 
     if (needsRepainting) {
-        if (LayoutObject* renderer = iterator->key->layoutObject())
+        const Node& node = *iterator->key;
+        if (LayoutObject* renderer = node.layoutObject())
             renderer->setShouldDoFullPaintInvalidation();
+        invalidatePaintForTickmarks(node);
     }
 
     if (nodeCanBeRemoved) {
         m_markers.remove(iterator);
         if (m_markers.isEmpty())
             m_possiblyExistingMarkerTypes = 0;
     }
 }
 
 void DocumentMarkerController::repaintMarkers(DocumentMarker::MarkerTypes markerTypes)
@@ skipping 124 matching lines @@
 
 } // namespace blink
 
 #ifndef NDEBUG
 void showDocumentMarkers(const blink::DocumentMarkerController* controller)
 {
     if (controller)
         controller->showMarkers();
 }
 #endif