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 105 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.
@@ skipping 18 matching lines @@
     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 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; }
 
     // The last complete paint artifact.
     // In SPv2, this includes paint chunks as well as display items.
     PaintArtifact m_currentPaintArtifact;
@@ skipping 36 matching lines @@
 
     // 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;
 
     size_t m_currentCachedSubsequenceBeginIndexInNewList;
+    bool m_isTrackingPaintInvalidations;

[Xianzhu, 2016/09/30 19:04:30]

Nit: This seems not used.

[chrishtr, 2016/09/30 21:04:16]

Fixed.

     size_t m_nextChunkToMatch;
 
     DisplayItemClient::CacheGenerationOrInvalidationReason m_currentCacheGeneration;
 
 #ifndef NDEBUG
     int m_numSequentialMatches;
     int m_numOutOfOrderMatches;
     int m_numIndexedItems;
 #endif
 
 #if DCHECK_IS_ON()
     // This is used to check duplicated ids during createAndAppend().
     IndicesByClientMap m_newDisplayItemIndicesByClient;
 #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;
     // 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