[SPv2] Defer decision of raster invalidation after paint for changes z-index, transform, etc.

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 61 matching lines @@
         static_assert(WTF::IsSubclass<DisplayItemClass, DisplayItem>::value,
             "Can only createAndAppend subclasses of DisplayItem.");
         static_assert(sizeof(DisplayItemClass) <= kMaximumDisplayItemSize,
             "DisplayItem subclass is larger than kMaximumDisplayItemSize.");
 
         if (displayItemConstructionIsDisabled())
             return;
 
         ensureNewDisplayItemListInitialCapacity();
         DisplayItemClass& displayItem = m_newDisplayItemList.allocateAndConstruct<DisplayItemClass>(std::forward<Args>(args)...);
-        processNewItem(displayItem, NewPainting);
+        processNewItem(displayItem);
     }
 
     // Creates and appends an ending display item to pair with a preceding
     // beginning item iff the display item actually draws content. For no-op
     // items, rather than creating an ending item, the begin item will
     // instead be removed, thereby maintaining brevity of the list. If display
     // item construction is disabled, no list mutations will be performed.
     template <typename DisplayItemClass, typename... Args>
     void endItem(Args&&... args)
     {
@@ skipping 65 matching lines @@
 
 protected:
     PaintController()
         : m_newDisplayItemList(0)
         , m_constructionDisabled(false)
         , m_subsequenceCachingDisabled(false)
         , m_textPainted(false)
         , m_imagePainted(false)
         , m_skippingCacheCount(0)
         , m_numCachedNewItems(0)
-        , m_currentChunkIsFromCachedSubsequence(true)
+        , m_currentCachedSubsequenceBeginIndexInNewList(kNotFound)
 #ifndef NDEBUG
         , m_numSequentialMatches(0)
         , m_numOutOfOrderMatches(0)
         , m_numIndexedItems(0)
 #endif
     {
         resetCurrentListIndices();
     }
 
 private:
     friend class PaintControllerTestBase;
     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.
-    enum NewItemSource { FromCachedItem, FromCachedSubsequence, NewPainting };
-    void processNewItem(DisplayItem&, NewItemSource);
+    void processNewItem(DisplayItem&);
+    DisplayItem& moveItemFromCurrentListToNewList(size_t);
 
     String displayItemListAsDebugString(const DisplayItemList&) const;
 
     // Maps clients to indices of display items or chunks of each client.
     using IndicesByClientMap = HashMap<const DisplayItemClient*, Vector<size_t>>;
 
     static size_t findMatchingItemFromIndex(const DisplayItem::Id&, const IndicesByClientMap&, const DisplayItemList&);
     static void addItemToIndexIfNeeded(const DisplayItem&, size_t index, IndicesByClientMap&);
 
     size_t findCachedItem(const DisplayItem::Id&);
     size_t findOutOfOrderCachedItemForward(const DisplayItem::Id&);
     void copyCachedSubsequence(size_t&);
 
     // 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 indices to be invalid.
     void resetCurrentListIndices();
 
     void generateChunkRasterInvalidationRects(PaintChunk& newChunk);
     void generateChunkRasterInvalidationRectsComparingOldChunk(PaintChunk& newChunk, const PaintChunk& oldChunk);
+    void generateChunkRasterInvalidationRectsForReorderedItems(PaintChunk& newChunk, const PaintChunk& oldChunk,
+        Vector<size_t>::const_iterator, Vector<size_t>::const_iterator, Vector<size_t>::const_iterator, Vector<size_t>::const_iterator);
 
     // The following two methods are for checking under-invalidations
     // (when RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled).
     void showUnderInvalidationError(const char* reason, const DisplayItem& newItem, const DisplayItem* oldItem) const;
     void checkUnderInvalidation();
     bool isCheckingUnderInvalidation() const { return m_underInvalidationCheckingEnd - m_underInvalidationCheckingBegin > 0; }
 
     // The last complete paint artifact.
     // In SPv2, this includes paint chunks as well as display items.
     PaintArtifact m_currentPaintArtifact;
 
     // Data being used to build the next paint artifact.
     DisplayItemList m_newDisplayItemList;
     PaintChunker m_newPaintChunks;
 
+    // Stores indices into m_newDisplayItemList for display items that have been moved from
+    // m_currentPaintArtifact.getDisplayItemList(), indexed by the positions of the display
+    // items before move. The values are undefined for display items that are not moved.
+    Vector<size_t> m_itemsMovedIntoNewList;
+
     // Allow display item construction to be disabled to isolate the costs of construction
     // in performance metrics.
     bool m_constructionDisabled;
 
     // Allow subsequence caching to be disabled to test the cost of display item caching.
     bool m_subsequenceCachingDisabled;
 
     // Indicates this PaintController has ever had text. It is never reset to false.
     bool m_textPainted;
     bool m_imagePainted;
@@ skipping 15 matching lines @@
     size_t m_nextItemToMatch;
 
     // The next item in the current list to be indexed for out-of-order cache requests.
     size_t m_nextItemToIndex;
 
     // Similar to m_outOfOrderItemIndices but
     // - the indices are chunk indices in m_currentPaintArtifacts.paintChunks();
     // - chunks are matched not only for requests of cached display items, but also non-cached display items.
     IndicesByClientMap m_outOfOrderChunkIndices;
 
-    bool m_currentChunkIsFromCachedSubsequence;
+    size_t m_currentCachedSubsequenceBeginIndexInNewList;
     size_t m_nextChunkToMatch;
 
     DisplayItemClient::CacheGenerationOrInvalidationReason m_currentCacheGeneration;
 
 #ifndef NDEBUG
     int m_numSequentialMatches;
     int m_numOutOfOrderMatches;
     int m_numIndexedItems;
 #endif
 
@@ skipping 17 matching lines @@
 
 #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