SPv2: Add support for tracking raster paint invalidations in testing.

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"
 #include "platform/geometry/LayoutPoint.h"
 #include "platform/graphics/ContiguousContainer.h"
 #include "platform/graphics/paint/DisplayItem.h"
 #include "platform/graphics/paint/DisplayItemList.h"
 #include "platform/graphics/paint/PaintArtifact.h"
 #include "platform/graphics/paint/PaintChunk.h"
 #include "platform/graphics/paint/PaintChunker.h"
+#include "platform/graphics/paint/RasterInvalidationTracking.h"
 #include "platform/graphics/paint/Transform3DDisplayItem.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "wtf/Alignment.h"
 #include "wtf/Assertions.h"
 #include "wtf/HashMap.h"
 #include "wtf/HashSet.h"
 #include "wtf/PtrUtil.h"
 #include "wtf/Vector.h"
 #include <memory>
 #include <utility>
 
 class SkPicture;
 
 namespace blink {
 
 class GraphicsContext;
 
 static const size_t kInitialDisplayItemListCapacityBytes = 512;
 
+template class RasterInvalidationTrackingMap<const PaintChunk>;
+
 // Responsible for processing display items as they are produced, and producing
 // a final paint artifact when complete. This class includes logic for caching,
 // cache invalidation, and merging.
 class PLATFORM_EXPORT PaintController {
   WTF_MAKE_NONCOPYABLE(PaintController);
   USING_FAST_MALLOC(PaintController);
 
  public:
   static std::unique_ptr<PaintController> create() {
     return wrapUnique(new PaintController());
@@ skipping 124 matching lines @@
 
   void showDebugData() const { showDebugDataInternal(false); }
 #ifndef NDEBUG
   void showDebugDataWithPictures() const { showDebugDataInternal(true); }
 #endif
 
 #if DCHECK_IS_ON()
   void assertDisplayItemClientsAreLive();
 #endif
 
+  void setTracksRasterInvalidations(bool value);
+  RasterInvalidationTrackingMap<const PaintChunk>*
+  paintChunksRasterInvalidationTrackingMap() {
+    return m_paintChunksRasterInvalidationTrackingMap.get();
+  }
+
  protected:
   PaintController()
       : m_newDisplayItemList(0),
         m_constructionDisabled(false),
         m_subsequenceCachingDisabled(false),
         m_textPainted(false),
         m_imagePainted(false),
         m_skippingCacheCount(0),
         m_numCachedNewItems(0),
         m_currentCachedSubsequenceBeginIndexInNewList(kNotFound)
 #ifndef NDEBUG
         ,
         m_numSequentialMatches(0),
         m_numOutOfOrderMatches(0),
         m_numIndexedItems(0)
 #endif
   {
     resetCurrentListIndices();
+    setTracksRasterInvalidations(
+        RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled());
   }
 
  private:
   friend class PaintControllerTestBase;
   friend class PaintControllerPaintTestBase;
 
   void ensureNewDisplayItemListInitialCapacity() {
     if (m_newDisplayItemList.isEmpty()) {
       // TODO(wangxianzhu): Consider revisiting this heuristic.
       m_newDisplayItemList =
@@ skipping 28 matching lines @@
 
   // 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 checkUnderInvalidation();
   bool isCheckingUnderInvalidation() const {
     return m_underInvalidationCheckingEnd - m_underInvalidationCheckingBegin >
            0;
@@ skipping 70 matching lines @@
   // 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;
   // 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
 };
 
 }  // namespace blink
 
 #endif  // PaintController_h