Use index instead of iterator into DisplayItemList in PaintController

third_party/WebKit/Source/platform/graphics/paint/PaintController.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef PaintController_h
 #define PaintController_h
 
 #include "platform/PlatformExport.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/geometry/IntRect.h"
@@ skipping 153 matching lines @@
         , m_textPainted(false)
         , m_imagePainted(false)
         , m_skippingCacheCount(0)
         , m_numCachedNewItems(0)
 #if DCHECK_IS_ON()
         , m_numSequentialMatches(0)
         , m_numOutOfOrderMatches(0)
         , m_numIndexedItems(0)
 #endif
     {
-        resetCurrentListIterators();
+        resetCurrentListIndices();
     }
 
 private:
     friend class PaintControllerTest;
     friend class PaintControllerPaintTestBase;
 
     void ensureNewDisplayItemListInitialCapacity()
     {
         if (m_newDisplayItemList.isEmpty()) {
             // TODO(wangxianzhu): Consider revisiting this heuristic.
             m_newDisplayItemList = DisplayItemList(m_currentPaintArtifact.getDisplayItemList().isEmpty() ? kInitialDisplayItemListCapacityBytes : m_currentPaintArtifact.getDisplayItemList().usedCapacityInBytes());
         }
     }
 
     // Set new item state (cache skipping, etc) for a new item.
     void processNewItem(DisplayItem&);
 
 #ifndef NDEBUG
     WTF::String displayItemListAsDebugString(const DisplayItemList&) const;
 #endif
 
     // Indices into PaintList of all DrawingDisplayItems and BeginSubsequenceDisplayItems of each client.
     // Temporarily used during merge to find out-of-order display items.
     using DisplayItemIndicesByClientMap = HashMap<const DisplayItemClient*, Vector<size_t>>;
 
     static size_t findMatchingItemFromIndex(const DisplayItem::Id&, const DisplayItemIndicesByClientMap&, const DisplayItemList&);
     static void addItemToIndexIfNeeded(const DisplayItem&, size_t index, DisplayItemIndicesByClientMap&);
 
-    DisplayItemList::iterator findCachedItem(const DisplayItem::Id&);
-    DisplayItemList::iterator findOutOfOrderCachedItemForward(const DisplayItem::Id&);
-    void copyCachedSubsequence(DisplayItemList::iterator&);
+    size_t findCachedItem(const DisplayItem::Id&);
+    size_t findOutOfOrderCachedItemForward(const DisplayItem::Id&);
+    void copyCachedSubsequence(size_t&);
 
-    // Resets the iterators (e.g. m_nextItemToMatch) of m_currentPaintArtifact.getDisplayItemList()
+    // Resets the indices (e.g. m_nextItemToMatch) of m_currentPaintArtifact.getDisplayItemList()
     // to their initial values. This should be called when the DisplayItemList in m_currentPaintArtifact
-    // is newly created, or is changed causing the previous iterators to be invalid.
-    void resetCurrentListIterators();
+    // is newly created, or is changed causing the previous indices to be invalid.
+    void resetCurrentListIndices();
 
 #if DCHECK_IS_ON()
     // The following two methods are for checking under-invalidations
     // (when RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled).
     void showUnderInvalidationError(const char* reason, const DisplayItem& newItem, const DisplayItem& oldItem) const;
     void checkUnderInvalidation();
     bool isCheckingUnderInvalidation() const { return m_underInvalidationCheckingEnd - m_underInvalidationCheckingBegin > 0; }
 #endif
 
     // The last complete paint artifact.
@@ skipping 21 matching lines @@
 
     // Stores indices to valid DrawingDisplayItems in current display list that have not been
     // matched by CachedDisplayItems during sequential matching. The indexed items will be
     // matched by later out-of-order requests of cached display items. This ensures that when
     // out-of-order cached display items are requested, we only traverse at most once over
     // the current display list looking for potential matches. Thus we can ensure that the
     // algorithm runs in linear time.
     DisplayItemIndicesByClientMap m_outOfOrderItemIndices;
 
     // The next item in the current list for sequential match.
-    DisplayItemList::iterator m_nextItemToMatch;
+    size_t m_nextItemToMatch;
 
     // The next item in the current list to be indexed for out-of-order cache requests.
-    DisplayItemList::iterator m_nextItemToIndex;
+    size_t m_nextItemToIndex;
 
     DisplayItemClient::CacheGenerationOrInvalidationReason m_currentCacheGeneration;
 
 #if DCHECK_IS_ON()
     int m_numSequentialMatches;
     int m_numOutOfOrderMatches;
     int m_numIndexedItems;
 
     // This is used to check duplicated ids during createAndAppend().
     DisplayItemIndicesByClientMap m_newDisplayItemIndicesByClient;
 
     // These are set in useCachedDrawingIfPossible() and useCachedSubsequenceIfPossible()
     // when we could use cached drawing or subsequence and under-invalidation checking is on,
     // indicating the begin and end of the cached drawing or subsequence in the current list.
     // The functions return false to let the client do actual painting, and PaintController
     // will check if the actual painting results are the same as the cached.
-    DisplayItemList::iterator m_underInvalidationCheckingBegin;
-    DisplayItemList::iterator m_underInvalidationCheckingEnd;
+    size_t m_underInvalidationCheckingBegin;
+    size_t m_underInvalidationCheckingEnd;
     String m_underInvalidationMessagePrefix;
 #endif
 
 #if CHECK_DISPLAY_ITEM_CLIENT_ALIVENESS
     // A stack recording subsequence clients that are currently painting.
     Vector<const DisplayItemClient*> m_currentSubsequenceClients;
 #endif
 };
 
 } // namespace blink
 
 #endif // PaintController_h