Revert of Revert of Temporarily let DocumentMakerController use invalidatePaintForWholeRenderer

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 217 matching lines @@
         if (toInsert.type() != DocumentMarker::TextMatch) {
             mergeOverlapping(list.get(), toInsert);
         } else {
             MarkerList::iterator pos = std::lower_bound(list->begin(), list->end(), &toInsert, startsFurther);
             list->insert(pos - list->begin(), RenderedDocumentMarker::create(toInsert));
         }
     }
 
     // repaint the affected node
     if (node->renderer())
-        node->renderer()->setShouldDoFullPaintInvalidation(true);
+        node->renderer()->doNotUseInvalidatePaintForWholeRendererSynchronously();
 }
 
 void DocumentMarkerController::mergeOverlapping(MarkerList* list, DocumentMarker& toInsert)
 {
     MarkerList::iterator firstOverlapping = std::lower_bound(list->begin(), list->end(), &toInsert, doesNotOverlap);
     size_t index = firstOverlapping - list->begin();
     list->insert(index, RenderedDocumentMarker::create(toInsert));
     MarkerList::iterator inserted = list->begin() + index;
     firstOverlapping = inserted + 1;
     for (MarkerList::iterator i = firstOverlapping; i != list->end() && (*i)->startOffset() <= (*inserted)->endOffset(); ) {
@@ skipping 40 matching lines @@
             if (marker->endOffset() > endOffset)
                 marker->setEndOffset(endOffset);
             marker->shiftOffsets(delta);
 
             addMarker(dstNode, *marker);
         }
     }
 
     // repaint the affected node
     if (docDirty && dstNode->renderer())
-        dstNode->renderer()->setShouldDoFullPaintInvalidation(true);
+        dstNode->renderer()->doNotUseInvalidatePaintForWholeRendererSynchronously();
 }
 
 void DocumentMarkerController::removeMarkers(Node* node, unsigned startOffset, int length, DocumentMarker::MarkerTypes markerTypes, RemovePartiallyOverlappingMarkerOrNot shouldRemovePartiallyOverlappingMarker)
 {
     if (length <= 0)
         return;
 
     if (!possiblyHasMarkers(markerTypes))
         return;
     ASSERT(!(m_markers.isEmpty()));
@@ skipping 60 matching lines @@
     }
 
     if (emptyListsCount == DocumentMarker::MarkerTypeIndexesCount) {
         m_markers.remove(node);
         if (m_markers.isEmpty())
             m_possiblyExistingMarkerTypes = 0;
     }
 
     // repaint the affected node
     if (docDirty && node->renderer())
-        node->renderer()->setShouldDoFullPaintInvalidation(true);
+        node->renderer()->doNotUseInvalidatePaintForWholeRendererSynchronously();
 }
 
 DocumentMarker* DocumentMarkerController::markerContainingPoint(const LayoutPoint& point, DocumentMarker::MarkerType markerType)
 {
     if (!possiblyHasMarkers(markerType))
         return 0;
     ASSERT(!(m_markers.isEmpty()));
 
     // outer loop: process each node that contains any markers
     MarkerMap::iterator end = m_markers.end();
@@ skipping 188 matching lines @@
                 ++emptyListsCount;
                 needsRepainting = true;
             }
         }
 
         nodeCanBeRemoved = emptyListsCount == DocumentMarker::MarkerTypeIndexesCount;
     }
 
     if (needsRepainting) {
         if (RenderObject* renderer = iterator->key->renderer())
-            renderer->setShouldDoFullPaintInvalidation(true);
+            renderer->doNotUseInvalidatePaintForWholeRendererSynchronously();
     }
 
     if (nodeCanBeRemoved) {
         m_markers.remove(iterator);
         if (m_markers.isEmpty())
             m_possiblyExistingMarkerTypes = 0;
     }
 }
 
 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();
     for (MarkerMap::iterator i = m_markers.begin(); i != end; ++i) {
         const Node* node = i->key;
 
         // inner loop: process each marker in the current node
         MarkerLists* markers = i->value.get();
         for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
             OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
             if (!list || list->isEmpty() || !markerTypes.contains((*list->begin())->type()))
                 continue;
 
             // cause the node to be redrawn
             if (RenderObject* renderer = node->renderer()) {
-                renderer->setShouldDoFullPaintInvalidation(true);
+                renderer->doNotUseInvalidatePaintForWholeRendererSynchronously();
                 break;
             }
         }
     }
 }
 
 void DocumentMarkerController::invalidateRenderedRectsForMarkersInRect(const LayoutRect& r)
 {
     // outer loop: process each markered node in the document
     MarkerMap::iterator end = m_markers.end();
@@ skipping 33 matching lines @@
             (*marker)->shiftOffsets(delta);
             docDirty = true;
 
             // Marker moved, so previously-computed rendered rectangle is now invalid
             (*marker)->invalidate();
         }
     }
 
     // repaint the affected node
     if (docDirty && node->renderer())
-        node->renderer()->setShouldDoFullPaintInvalidation(true);
+        node->renderer()->doNotUseInvalidatePaintForWholeRendererSynchronously();
 }
 
 void DocumentMarkerController::setMarkersActive(Range* range, bool active)
 {
     if (!possiblyHasMarkers(DocumentMarker::AllMarkers()))
         return;
     ASSERT(!m_markers.isEmpty());
 
     Node* startContainer = range->startContainer();
     Node* endContainer = range->endContainer();
@@ skipping 23 matching lines @@
         // Markers are returned in order, so stop if we are now past the specified range.
         if ((*marker)->startOffset() >= endOffset)
             break;
 
         (*marker)->setActiveMatch(active);
         docDirty = true;
     }
 
     // repaint the affected node
     if (docDirty && node->renderer())
-        node->renderer()->setShouldDoFullPaintInvalidation(true);
+        node->renderer()->doNotUseInvalidatePaintForWholeRendererSynchronously();
 }
 
 bool DocumentMarkerController::hasMarkers(Range* range, DocumentMarker::MarkerTypes markerTypes)
 {
     if (!possiblyHasMarkers(markerTypes))
         return false;
     ASSERT(!m_markers.isEmpty());
 
     Node* startContainer = range->startContainer();
     ASSERT(startContainer);
@@ skipping 42 matching lines @@
 
 } // namespace blink
 
 #ifndef NDEBUG
 void showDocumentMarkers(const blink::DocumentMarkerController* controller)
 {
     if (controller)
         controller->showMarkers();
 }
 #endif