Revert of 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 <memory>
 #include <utility>
 #include "platform/PlatformExport.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 63 matching lines @@
     return m_usage == ForPaintRecordBuilder;
   }
 #endif
 
   void setTracksRasterInvalidations(bool value);
   RasterInvalidationTrackingMap<const PaintChunk>*
   paintChunksRasterInvalidationTrackingMap() {
     return m_paintChunksRasterInvalidationTrackingMap.get();
   }
 
-#if CHECK_DISPLAY_ITEM_CLIENT_ALIVENESS
-  void beginShouldKeepAlive(const DisplayItemClient&);
-
-  void beginSubsequence(const DisplayItemClient& client) {
-    m_currentSubsequenceClients.push_back(&client);
-    beginShouldKeepAlive(client);
-  }
-
-  void endSubsequence() { m_currentSubsequenceClients.pop_back(); }
-#endif
-
  protected:
   PaintController()
       : m_newDisplayItemList(0),
         m_constructionDisabled(false),
         m_subsequenceCachingDisabled(false),
         m_firstPainted(false),
         m_textPainted(false),
         m_imagePainted(false),
         m_skippingCacheCount(0),
         m_numCachedNewItems(0),
-        m_currentCachedSubsequenceBeginIndexInNewList(kNotFound),
+        m_currentCachedSubsequenceBeginIndexInNewList(kNotFound)
 #ifndef NDEBUG
+        ,
         m_numSequentialMatches(0),
         m_numOutOfOrderMatches(0),
-        m_numIndexedItems(0),
+        m_numIndexedItems(0)
 #endif
-        m_underInvalidationCheckingBegin(0),
-        m_underInvalidationCheckingEnd(0) {
+  {
     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 beginIndex, size_t endIndex);
+  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 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 79 matching lines @@
   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