Remove begin/end subseq. display items, and store on PaintController instead.

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 91 matching lines @@
   // Tries to find the cached drawing display item corresponding to the given
   // parameters. If found, appends the cached display item to the new display
   // list and returns true. Otherwise returns false.
   bool useCachedDrawingIfPossible(const DisplayItemClient&, DisplayItem::Type);
 
   // Tries to find the cached subsequence corresponding to the given parameters.
   // If found, copies the cache subsequence to the new display list and returns
   // true. Otherwise returns false.
   bool useCachedSubsequenceIfPossible(const DisplayItemClient&);
 
+  void addCachedSubsequence(const DisplayItemClient&,
+                            unsigned start,
+                            unsigned end);
+
   // True if the last display item is a begin that doesn't draw content.
-  bool lastDisplayItemIsNoopBegin() const;
   void removeLastDisplayItem();
   const DisplayItem* lastDisplayItem(unsigned offset);
 
   void beginSkippingCache() { ++m_skippingCacheCount; }
   void endSkippingCache() {
     DCHECK(m_skippingCacheCount > 0);
     --m_skippingCacheCount;
   }
   bool isSkippingCache() const { return m_skippingCacheCount; }
 
@@ skipping 80 matching lines @@
         m_imagePainted(false),
         m_skippingCacheCount(0),
         m_numCachedNewItems(0),
         m_currentCachedSubsequenceBeginIndexInNewList(kNotFound)
 #ifndef NDEBUG
         ,
         m_numSequentialMatches(0),
         m_numOutOfOrderMatches(0),
         m_numIndexedItems(0)
 #endif
-  {
+        ,
+        m_underInvalidationCheckingBegin(0),
+        m_underInvalidationCheckingEnd(0),
+        m_isCheckingSubsequenceUnderInvalidation(false) {
     resetCurrentListIndices();
     setTracksRasterInvalidations(
         RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled());
   }
 
  private:
   friend class PaintControllerTestBase;
   friend class PaintControllerPaintTestBase;
 
+  bool lastDisplayItemIsNoopBegin() const;
+
   void ensureNewDisplayItemListInitialCapacity() {
     if (m_newDisplayItemList.isEmpty()) {
       // TODO(wangxianzhu): Consider revisiting this heuristic.
       m_newDisplayItemList =
           DisplayItemList(m_currentPaintArtifact.getDisplayItemList().isEmpty()
                               ? kInitialDisplayItemListCapacityBytes
                               : m_currentPaintArtifact.getDisplayItemList()
                                     .usedCapacityInBytes());
     }
   }
@@ skipping 11 matching lines @@
 
   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&);
+  void copyCachedSubsequence(size_t beginIndex, size_t endIndex);
 
   // 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 addRasterInvalidationInfo(const DisplayItemClient*,
                                  PaintChunk&,
                                  const FloatRect&);
 
   // 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 showSequenceUnderInvalidationError(const char* reason,
+                                          const DisplayItemClient&,
+                                          int start,
+                                          int end);
+
   void checkUnderInvalidation();
   bool isCheckingUnderInvalidation() const {
     return m_underInvalidationCheckingEnd - m_underInvalidationCheckingBegin >
            0;
   }
 
+  struct SubsequenceMarkers {
+    SubsequenceMarkers() : start(0), end(0) {}
+    SubsequenceMarkers(size_t startArg, size_t endArg)
+        : start(startArg), end(endArg) {}
+    // The start and end index within m_currentPaintArtifact of this
+    // subsequence.
+    size_t start;
+    size_t end;
+  };
+
+  SubsequenceMarkers* getSubsequenceMarkers(const DisplayItemClient&);
+
   // 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
@@ skipping 65 matching lines @@
 #endif
 
   // 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.
   size_t m_underInvalidationCheckingBegin;
   size_t m_underInvalidationCheckingEnd;
+  bool m_isCheckingSubsequenceUnderInvalidation;
 
   // Number of probable under-invalidations that have been skipped temporarily
   // because the mismatching display items may be removed in the future because
   // of no-op pairs or compositing folding.
   int m_skippedProbableUnderInvalidationCount;
   String m_underInvalidationMessagePrefix;
 
   std::unique_ptr<RasterInvalidationTrackingMap<const PaintChunk>>
       m_paintChunksRasterInvalidationTrackingMap;
 
-#if CHECK_DISPLAY_ITEM_CLIENT_ALIVENESS
-  // A stack recording subsequence clients that are currently painting.
-  Vector<const DisplayItemClient*> m_currentSubsequenceClients;
-#endif
+  typedef HashMap<const DisplayItemClient*, SubsequenceMarkers>
+      CachedSubsequenceMap;
+  CachedSubsequenceMap m_currentCachedSubsequences;
+  CachedSubsequenceMap m_newCachedSubsequences;
+
+  FRIEND_TEST_ALL_PREFIXES(PaintControllerTest, CachedSubsequenceSwapOrder);
+  FRIEND_TEST_ALL_PREFIXES(PaintControllerTest, CachedNestedSubsequenceUpdate);
 };
 
 }  // namespace blink
 
 #endif  // PaintController_h