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 65 matching lines @@
 
 } // namespace
 
 inline bool DocumentMarkerController::possiblyHasMarkers(DocumentMarker::MarkerTypes types)
 {
     return m_possiblyExistingMarkerTypes.intersects(types);
 }
 
 DocumentMarkerController::DocumentMarkerController()
     : m_possiblyExistingMarkerTypes(0)
+    , m_textMatchMarkersRemovedOrChanged(false)
 {
 }
 
 DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(DocumentMarkerController);
 
 void DocumentMarkerController::clear()
 {
     m_markers.clear();
     m_possiblyExistingMarkerTypes = 0;
 }
@@ skipping 74 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 287 matching lines @@
     return result;
 }
 
 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)
+                m_textMatchMarkersRemovedOrChanged = true;
         }
     }
 }
 
 DEFINE_TRACE(DocumentMarkerController)
 {
 #if ENABLE(OILPAN)
     visitor->trace(m_markers);
 #endif
 }
@@ skipping 15 matching lines @@
         MarkerLists* markers = i->value.get();
         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());
             }
 
+            if (markerListIndex == DocumentMarker::TextMatchMarkerIndex && !markersToBeRemoved.isEmpty())
+                m_textMatchMarkersRemovedOrChanged = true;

[chrishtr, 2015/04/17 23:21:42]

Why not just invalidate the tickmarks within each of these functions?

[Xianzhu, 2015/04/18 02:13:48]

Was concerned about multiple calls of these functions in a cycle during a big
document change. Realized that calls to FrameView::invalidatePaintForTickmarks()
should be cheap or if not we should optimize it.

Done.

+
             for (size_t j = 0; j < markersToBeRemoved.size(); ++j)
                 list->remove(list->find(markersToBeRemoved[j].get()));
         }
     }
 }
 
 void DocumentMarkerController::removeMarkers(DocumentMarker::MarkerTypes markerTypes)
 {
     if (!possiblyHasMarkers(markerTypes))
         return;
@@ skipping 45 matching lines @@
     if (needsRepainting) {
         if (LayoutObject* renderer = iterator->key->layoutObject())
             renderer->setShouldDoFullPaintInvalidation();
     }
 
     if (nodeCanBeRemoved) {
         m_markers.remove(iterator);
         if (m_markers.isEmpty())
             m_possiblyExistingMarkerTypes = 0;
     }
+
+    if (markerTypes.contains(DocumentMarker::TextMatch))
+        m_textMatchMarkersRemovedOrChanged = true;
 }
 
 void DocumentMarkerController::repaintMarkers(DocumentMarker::MarkerTypes markerTypes)
 {
     if (!possiblyHasMarkers(markerTypes))
         return;
     ASSERT(!m_markers.isEmpty());
 
     // outer loop: process each markered node in the document
     MarkerMap::iterator end = m_markers.end();
@@ skipping 117 matching lines @@
 
 } // namespace blink
 
 #ifndef NDEBUG
 void showDocumentMarkers(const blink::DocumentMarkerController* controller)
 {
     if (controller)
         controller->showMarkers();
 }
 #endif