Move markerlists to Oilpan heap and remove finalizer from DocumentMarkerController

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 53 matching lines @@
 inline bool DocumentMarkerController::possiblyHasMarkers(DocumentMarker::MarkerTypes types)
 {
     return m_possiblyExistingMarkerTypes.intersects(types);
 }
 
 DocumentMarkerController::DocumentMarkerController()
     : m_possiblyExistingMarkerTypes(0)
 {
 }
 
-DocumentMarkerController::~DocumentMarkerController()
-{
-}
+DEFINE_EMPTY_DESTRUCTOR_WILL_BE_REMOVED(DocumentMarkerController);
 
 void DocumentMarkerController::clear()
 {
     m_markers.clear();
     m_possiblyExistingMarkerTypes = 0;
 }
 
 void DocumentMarkerController::addMarker(Range* range, DocumentMarker::MarkerType type, const String& description, uint32_t hash)
 {
     // Use a TextIterator to visit the potentially multiple nodes the range covers.
@@ skipping 29 matching lines @@
         RefPtrWillBeRawPtr<Range> textPiece = markedText.range();
         unsigned startOffset = textPiece->startOffset();
         unsigned endOffset = textPiece->endOffset();
         addMarker(textPiece->startContainer(), DocumentMarker(startOffset, endOffset, activeMatch));
         if (endOffset > startOffset) {
             // Rendered rects for markers in WebKit are not populated until each time
             // the markers are painted. However, we need it to happen sooner, because
             // the whole purpose of tickmarks on the scrollbar is to show where
             // matches off-screen are (that haven't been painted yet).
             Node* node = textPiece->startContainer();
-            Vector<DocumentMarker*> markers = markersFor(node);
+            WillBeHeapVector<DocumentMarker*> markers = markersFor(node);
             toRenderedDocumentMarker(markers[markers.size() - 1])->setRenderedRect(range->boundingBox());
         }
     }
 }
 
 void DocumentMarkerController::prepareForDestruction()
 {
     clear();
 }
 
@@ skipping 45 matching lines @@
 // 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<MarkerLists>& markers = m_markers.add(node, nullptr).storedValue->value;
+    OwnPtrWillBeMember<MarkerLists>& markers = m_markers.add(node, nullptr).storedValue->value;
     if (!markers) {
-        markers = adoptPtr(new MarkerLists);
+        markers = adoptPtrWillBeNoop(new MarkerLists);
         markers->grow(DocumentMarker::MarkerTypeIndexesCount);
     }
 
     DocumentMarker::MarkerTypeIndex markerListIndex = MarkerTypeToMarkerIndex(newMarker.type());
     if (!markers->at(markerListIndex)) {
-        markers->insert(markerListIndex, adoptPtr(new MarkerList));
+        markers->insert(markerListIndex, adoptPtrWillBeNoop(new MarkerList));
     }
 
-    OwnPtr<MarkerList>& list = markers->at(markerListIndex);
+    OwnPtrWillBeMember<MarkerList>& list = markers->at(markerListIndex);
     if (list->isEmpty() || list->last().endOffset() < newMarker.startOffset()) {
         list->append(RenderedDocumentMarker(newMarker));
     } else {
         RenderedDocumentMarker toInsert(newMarker);
         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(toInsert));
         }
@@ skipping 28 matching lines @@
     if (!possiblyHasMarkers(DocumentMarker::AllMarkers()))
         return;
     ASSERT(!m_markers.isEmpty());
 
     MarkerLists* markers = m_markers.get(srcNode);
     if (!markers)
         return;
 
     bool docDirty = false;
     for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
-        OwnPtr<MarkerList>& list = (*markers)[markerListIndex];
+        OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
         if (!list)
             continue;
 
         unsigned endOffset = startOffset + length - 1;
         MarkerList::iterator startPos = std::lower_bound(list->begin(), list->end(), startOffset, doesNotInclude);
         for (MarkerList::iterator i = startPos; i != list->end(); ++i) {
             DocumentMarker marker = *i;
 
             // stop if we are now past the specified range
             if (marker.startOffset() > endOffset)
@@ skipping 25 matching lines @@
         return;
     ASSERT(!(m_markers.isEmpty()));
 
     MarkerLists* markers = m_markers.get(node);
     if (!markers)
         return;
 
     bool docDirty = false;
     size_t emptyListsCount = 0;
     for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
-        OwnPtr<MarkerList>& list = (*markers)[markerListIndex];
+        OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
         if (!list || list->isEmpty()) {
             if (list.get() && list->isEmpty())
                 list.clear();
             ++emptyListsCount;
             continue;
         }
         if (!markerTypes.contains(list->begin()->type()))
             continue;
         unsigned endOffset = startOffset + length;
         MarkerList::iterator startPos = std::upper_bound(list->begin(), list->end(), startOffset, endsBefore);
@@ skipping 55 matching lines @@
 {
     if (!possiblyHasMarkers(markerType))
         return 0;
     ASSERT(!(m_markers.isEmpty()));
 
     // outer loop: process each node that contains any markers
     MarkerMap::iterator end = m_markers.end();
     for (MarkerMap::iterator nodeIterator = m_markers.begin(); nodeIterator != end; ++nodeIterator) {
         // inner loop; process each marker in this node
         MarkerLists* markers = nodeIterator->value.get();
-        OwnPtr<MarkerList>& list = (*markers)[MarkerTypeToMarkerIndex(markerType)];
+        OwnPtrWillBeMember<MarkerList>& list = (*markers)[MarkerTypeToMarkerIndex(markerType)];
         unsigned markerCount = list.get() ? list->size() : 0;
         for (unsigned markerIndex = 0; markerIndex < markerCount; ++markerIndex) {
             RenderedDocumentMarker& marker = list->at(markerIndex);
 
             if (marker.contains(point))
                 return &marker;
         }
     }
 
     return 0;
 }
 
-Vector<DocumentMarker*> DocumentMarkerController::markersFor(Node* node, DocumentMarker::MarkerTypes markerTypes)
+WillBeHeapVector<DocumentMarker*> DocumentMarkerController::markersFor(Node* node, DocumentMarker::MarkerTypes markerTypes)
 {
-    Vector<DocumentMarker*> result;
+    WillBeHeapVector<DocumentMarker*> result;
 
     MarkerLists* markers = m_markers.get(node);
     if (!markers)
         return result;
 
     for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
-        OwnPtr<MarkerList>& list = (*markers)[markerListIndex];
+        OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
         if (!list || list->isEmpty() || !markerTypes.contains(list->begin()->type()))
             continue;
 
         for (size_t i = 0; i < list->size(); ++i)
             result.append(&(list->at(i)));
     }
 
     std::sort(result.begin(), result.end(), compareByStart);
     return result;
 }
 
-Vector<DocumentMarker*> DocumentMarkerController::markers()
+WillBeHeapVector<DocumentMarker*> DocumentMarkerController::markers()
 {
-    Vector<DocumentMarker*> result;
+    WillBeHeapVector<DocumentMarker*> result;
     for (MarkerMap::iterator i = m_markers.begin(); i != m_markers.end(); ++i) {
         MarkerLists* markers = i->value.get();
         for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
-            OwnPtr<MarkerList>& list = (*markers)[markerListIndex];
+            OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
             for (size_t j = 0; list.get() && j < list->size(); ++j)
                 result.append(&(list->at(j)));
         }
     }
     std::sort(result.begin(), result.end(), compareByStart);
     return result;
 }
 
-Vector<DocumentMarker*> DocumentMarkerController::markersInRange(Range* range, DocumentMarker::MarkerTypes markerTypes)
+WillBeHeapVector<DocumentMarker*> DocumentMarkerController::markersInRange(Range* range, DocumentMarker::MarkerTypes markerTypes)
 {
     if (!possiblyHasMarkers(markerTypes))
-        return Vector<DocumentMarker*>();
+        return WillBeHeapVector<DocumentMarker*>();
 
-    Vector<DocumentMarker*> foundMarkers;
+    WillBeHeapVector<DocumentMarker*> foundMarkers;
 
     Node* startContainer = range->startContainer();
     ASSERT(startContainer);
     Node* endContainer = range->endContainer();
     ASSERT(endContainer);
 
     Node* pastLastNode = range->pastLastNode();
     for (Node* node = range->firstNode(); node != pastLastNode; node = NodeTraversal::next(*node)) {
-        Vector<DocumentMarker*> markers = markersFor(node);
-        Vector<DocumentMarker*>::const_iterator end = markers.end();
-        for (Vector<DocumentMarker*>::const_iterator it = markers.begin(); it != end; ++it) {
+        WillBeHeapVector<DocumentMarker*> markers = markersFor(node);
+        WillBeHeapVector<DocumentMarker*>::const_iterator end = markers.end();
+        for (WillBeHeapVector<DocumentMarker*>::const_iterator it = markers.begin(); it != end; ++it) {
             DocumentMarker* marker = *it;
             if (!markerTypes.contains(marker->type()))
                 continue;
             if (node == startContainer && marker->endOffset() <= static_cast<unsigned>(range->startOffset()))
                 continue;
             if (node == endContainer && marker->startOffset() >= static_cast<unsigned>(range->endOffset()))
                 continue;
             foundMarkers.append(marker);
         }
     }
     return foundMarkers;
 }
 
 Vector<IntRect> DocumentMarkerController::renderedRectsForMarkers(DocumentMarker::MarkerType markerType)
 {
     Vector<IntRect> result;
 
     if (!possiblyHasMarkers(markerType))
         return result;
     ASSERT(!(m_markers.isEmpty()));
 
     // outer loop: process each node
     MarkerMap::iterator end = m_markers.end();
     for (MarkerMap::iterator nodeIterator = m_markers.begin(); nodeIterator != end; ++nodeIterator) {
         // inner loop; process each marker in this node
         MarkerLists* markers = nodeIterator->value.get();
         for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
-            OwnPtr<MarkerList>& list = (*markers)[markerListIndex];
+            OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
             if (!list || list->isEmpty() || list->begin()->type() != markerType)
                 continue;
             for (unsigned markerIndex = 0; markerIndex < list->size(); ++markerIndex) {
                 const RenderedDocumentMarker& marker = list->at(markerIndex);
 
                 if (!marker.isRendered())
                     continue;
 
                 result.append(marker.renderedRect());
             }
@@ skipping 43 matching lines @@
     bool nodeCanBeRemoved;
 
     size_t emptyListsCount = 0;
     if (markerTypes == DocumentMarker::AllMarkers()) {
         needsRepainting = true;
         nodeCanBeRemoved = true;
     } else {
         MarkerLists* markers = iterator->value.get();
 
         for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
-            OwnPtr<MarkerList>& list = (*markers)[markerListIndex];
+            OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
             if (!list || list->isEmpty()) {
                 if (list.get() && list->isEmpty())
                     list.clear();
                 ++emptyListsCount;
                 continue;
             }
             if (markerTypes.contains(list->begin()->type())) {
                 list->clear();
                 list.clear();
                 ++emptyListsCount;
@@ skipping 23 matching lines @@
     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) {
-            OwnPtr<MarkerList>& list = (*markers)[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->repaint();
                 break;
             }
         }
     }
 }
 
 void DocumentMarkerController::invalidateRenderedRectsForMarkersInRect(const LayoutRect& r)
 {
     // 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) {
 
         // inner loop: process each rect in the current node
         MarkerLists* markers = i->value.get();
         for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
-            OwnPtr<MarkerList>& list = (*markers)[markerListIndex];
+            OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
             for (size_t markerIndex = 0; list.get() && markerIndex < list->size(); ++markerIndex)
                 list->at(markerIndex).invalidate(r);
         }
     }
 }
 
 void DocumentMarkerController::shiftMarkers(Node* node, unsigned startOffset, int delta)
 {
     if (!possiblyHasMarkers(DocumentMarker::AllMarkers()))
         return;
     ASSERT(!m_markers.isEmpty());
 
     MarkerLists* markers = m_markers.get(node);
     if (!markers)
         return;
 
     bool docDirty = false;
     for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
-        OwnPtr<MarkerList>& list = (*markers)[markerListIndex];
+        OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
         if (!list)
             continue;
         MarkerList::iterator startPos = std::lower_bound(list->begin(), list->end(), startOffset, startsAfter);
         for (MarkerList::iterator marker = startPos; marker != list->end(); ++marker) {
             ASSERT((int)marker->startOffset() + delta >= 0);
             marker->shiftOffsets(delta);
             docDirty = true;
 
             // Marker moved, so previously-computed rendered rectangle is now invalid
             marker->invalidate();
@@ skipping 23 matching lines @@
     }
 }
 
 void DocumentMarkerController::setMarkersActive(Node* node, unsigned startOffset, unsigned endOffset, bool active)
 {
     MarkerLists* markers = m_markers.get(node);
     if (!markers)
         return;
 
     bool docDirty = false;
-    OwnPtr<MarkerList>& list = (*markers)[MarkerTypeToMarkerIndex(DocumentMarker::TextMatch)];
+    OwnPtrWillBeMember<MarkerList>& list = (*markers)[MarkerTypeToMarkerIndex(DocumentMarker::TextMatch)];
     if (!list)
         return;
     MarkerList::iterator startPos = std::upper_bound(list->begin(), list->end(), startOffset, endsBefore);
     for (MarkerList::iterator marker = startPos; marker != list->end(); ++marker) {
 
         // Markers are returned in order, so stop if we are now past the specified range.
         if (marker->startOffset() >= endOffset)
             break;
 
         marker->setActiveMatch(active);
@@ skipping 11 matching lines @@
         return false;
     ASSERT(!m_markers.isEmpty());
 
     Node* startContainer = range->startContainer();
     ASSERT(startContainer);
     Node* endContainer = range->endContainer();
     ASSERT(endContainer);
 
     Node* pastLastNode = range->pastLastNode();
     for (Node* node = range->firstNode(); node != pastLastNode; node = NodeTraversal::next(*node)) {
-        Vector<DocumentMarker*> markers = markersFor(node);
-        Vector<DocumentMarker*>::const_iterator end = markers.end();
-        for (Vector<DocumentMarker*>::const_iterator it = markers.begin(); it != end; ++it) {
+        WillBeHeapVector<DocumentMarker*> markers = markersFor(node);
+        WillBeHeapVector<DocumentMarker*>::const_iterator end = markers.end();
+        for (WillBeHeapVector<DocumentMarker*>::const_iterator it = markers.begin(); it != end; ++it) {
             DocumentMarker* marker = *it;
             if (!markerTypes.contains(marker->type()))
                 continue;
             if (node == startContainer && marker->endOffset() <= static_cast<unsigned>(range->startOffset()))
                 continue;
             if (node == endContainer && marker->startOffset() >= static_cast<unsigned>(range->endOffset()))
                 continue;
             return true;
         }
     }
     return false;
 }
 
 #ifndef NDEBUG
 void DocumentMarkerController::showMarkers() const
 {
     fprintf(stderr, "%d nodes have markers:\n", m_markers.size());
     MarkerMap::const_iterator end = m_markers.end();
     for (MarkerMap::const_iterator nodeIterator = m_markers.begin(); nodeIterator != end; ++nodeIterator) {
         const Node* node = nodeIterator->key;
         fprintf(stderr, "%p", node);
         MarkerLists* markers = m_markers.get(node);
         for (size_t markerListIndex = 0; markerListIndex < DocumentMarker::MarkerTypeIndexesCount; ++markerListIndex) {
-            OwnPtr<MarkerList>& list = (*markers)[markerListIndex];
+            OwnPtrWillBeMember<MarkerList>& list = (*markers)[markerListIndex];
             for (unsigned markerIndex = 0; list.get() && markerIndex < list->size(); ++markerIndex) {
                 const DocumentMarker& marker = list->at(markerIndex);
                 fprintf(stderr, " %d:[%d:%d](%d)", marker.type(), marker.startOffset(), marker.endOffset(), marker.activeMatch());
             }
         }
 
         fprintf(stderr, "\n");
     }
 }
 #endif
 
 } // namespace WebCore
 
 #ifndef NDEBUG
 void showDocumentMarkers(const WebCore::DocumentMarkerController* controller)
 {
     if (controller)
         controller->showMarkers();
 }
 #endif