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

third_party/WebKit/Source/platform/graphics/paint/PaintController.cpp

 // 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.
 
 #include "platform/graphics/paint/PaintController.h"
 
 #include "platform/TraceEvent.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/paint/DrawingDisplayItem.h"
 #include "third_party/skia/include/core/SkPictureAnalyzer.h"
 #include "wtf/AutoReset.h"
 #include "wtf/text/StringBuilder.h"
 
 #ifndef NDEBUG
 #include "platform/graphics/LoggingCanvas.h"
 #include <stdio.h>
 #endif
 
 namespace blink {
 
+void PaintController::setTracksRasterInvalidations(bool value)
+{
+    if (value)
+        m_paintChunksRasterInvalidationTrackingMap = wrapUnique(new RasterInvalidationTrackingMap<const PaintChunk>);
+    else
+        m_paintChunksRasterInvalidationTrackingMap = nullptr;
+}
+
+
 const PaintArtifact& PaintController::paintArtifact() const
 {
     DCHECK(m_newDisplayItemList.isEmpty());
     DCHECK(m_newPaintChunks.isInInitialState());
     return m_currentPaintArtifact;
 }
 
 bool PaintController::useCachedDrawingIfPossible(const DisplayItemClient& client, DisplayItem::Type type)
 {
     DCHECK(DisplayItem::isDrawingType(type));
@@ skipping 500 matching lines @@
     // TODO(wkorman): Only compute and append visual rect for drawings.
     m_currentPaintArtifact.getDisplayItemList().appendVisualRect(visualRectForDisplayItem(displayItem, offsetFromLayoutObject));
 }
 
 void PaintController::generateChunkRasterInvalidationRects(PaintChunk& newChunk)
 {
     DCHECK(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
     if (newChunk.beginIndex >= m_currentCachedSubsequenceBeginIndexInNewList)
         return;
 
+    static FloatRect infiniteFloatRect(LayoutRect::infiniteIntRect());
     if (!newChunk.id) {
-        newChunk.rasterInvalidationRects.append(FloatRect(LayoutRect::infiniteIntRect()));
+        addRasterInvalidationInfo(nullptr, newChunk, infiniteFloatRect);
         return;
     }
 
     // Try to match old chunk sequentially first.
     const auto& oldChunks = m_currentPaintArtifact.paintChunks();
     while (m_nextChunkToMatch < oldChunks.size()) {
         const PaintChunk& oldChunk = oldChunks[m_nextChunkToMatch];
         if (newChunk.matches(oldChunk)) {
             generateChunkRasterInvalidationRectsComparingOldChunk(newChunk, oldChunk);
             ++m_nextChunkToMatch;
@@ skipping 15 matching lines @@
     if (it != m_outOfOrderChunkIndices.end()) {
         for (size_t i : it->value) {
             if (newChunk.matches(oldChunks[i])) {
                 generateChunkRasterInvalidationRectsComparingOldChunk(newChunk, oldChunks[i]);
                 return;
             }
         }
     }
 
     // We reach here because the chunk is new.
-    newChunk.rasterInvalidationRects.append(FloatRect(LayoutRect::infiniteIntRect()));
+    addRasterInvalidationInfo(nullptr, newChunk, infiniteFloatRect);
+}
+
+void PaintController::addRasterInvalidationInfo(const DisplayItemClient* client, PaintChunk& chunk, const FloatRect& rect)
+{
+    chunk.rasterInvalidationRects.append(rect);
+    if (!m_paintChunksRasterInvalidationTrackingMap)
+        return;
+
+    RasterInvalidationInfo info;
+    info.rect = enclosingIntRect(rect);
+    info.client = client;
+    if (client) {
+        info.clientDebugName = client->debugName();
+        info.reason = client->getPaintInvalidationReason();
+    }
+
+    RasterInvalidationTracking& tracking = m_paintChunksRasterInvalidationTrackingMap->add(&chunk);
+    tracking.trackedRasterInvalidations.append(info);
 }
 
 void PaintController::generateChunkRasterInvalidationRectsComparingOldChunk(PaintChunk& newChunk, const PaintChunk& oldChunk)
 {
     DCHECK(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
     // TODO(wangxianzhu): Handle PaintInvalidationIncremental.
     // TODO(wangxianzhu): Optimize paint offset change.
 
     HashSet<const DisplayItemClient*> invalidatedClientsInOldChunk;
     size_t highestMovedToIndex = 0;
     for (size_t oldIndex = oldChunk.beginIndex; oldIndex < oldChunk.endIndex; ++oldIndex) {
         const DisplayItem& oldItem = m_currentPaintArtifact.getDisplayItemList()[oldIndex];
         const DisplayItemClient* clientToInvalidate = nullptr;
         if (!oldItem.hasValidClient()) {
             size_t movedToIndex = m_itemsMovedIntoNewList[oldIndex];
             if (m_newDisplayItemList[movedToIndex].drawsContent()) {
                 if (movedToIndex < newChunk.beginIndex || movedToIndex >= newChunk.endIndex) {
                     // The item has been moved into another chunk, so need to invalidate it in the old chunk.
                     clientToInvalidate = &m_newDisplayItemList[movedToIndex].client();
                     // And invalidate in the new chunk into which the item was moved.
                     PaintChunk& movedToChunk = m_newPaintChunks.findChunkByDisplayItemIndex(movedToIndex);
-                    movedToChunk.rasterInvalidationRects.append(clientToInvalidate->visualRect());
+
+                    addRasterInvalidationInfo(clientToInvalidate, movedToChunk, FloatRect(clientToInvalidate->visualRect()));
                 } else if (movedToIndex < highestMovedToIndex) {
                     // The item has been moved behind other cached items, so need to invalidate the area
                     // that is probably exposed by the item moved earlier.
                     clientToInvalidate = &m_newDisplayItemList[movedToIndex].client();
                 } else {
                     highestMovedToIndex = movedToIndex;
                 }
             }
         } else if (oldItem.drawsContent()) {
             clientToInvalidate = &oldItem.client();
         }
         if (clientToInvalidate && invalidatedClientsInOldChunk.add(clientToInvalidate).isNewEntry) {
-            newChunk.rasterInvalidationRects.append(m_currentPaintArtifact.getDisplayItemList().visualRect(oldIndex));
+            addRasterInvalidationInfo(clientToInvalidate, newChunk, FloatRect(m_currentPaintArtifact.getDisplayItemList().visualRect(oldIndex)));
+
         }
     }
 
     HashSet<const DisplayItemClient*> invalidatedClientsInNewChunk;
     for (size_t newIndex = newChunk.beginIndex; newIndex < newChunk.endIndex; ++newIndex) {
         const DisplayItem& newItem = m_newDisplayItemList[newIndex];
-        if (newItem.drawsContent() && !clientCacheIsValid(newItem.client()) && invalidatedClientsInNewChunk.add(&newItem.client()).isNewEntry)
-            newChunk.rasterInvalidationRects.append(newItem.client().visualRect());
+        if (newItem.drawsContent() && !clientCacheIsValid(newItem.client()) && invalidatedClientsInNewChunk.add(&newItem.client()).isNewEntry) {
+            addRasterInvalidationInfo(&newItem.client(), newChunk, FloatRect(newItem.client().visualRect()));
+        }
     }
 }
 
 void PaintController::showUnderInvalidationError(const char* reason, const DisplayItem& newItem, const DisplayItem* oldItem) const
 {
     LOG(ERROR) << m_underInvalidationMessagePrefix << " " << reason;
 #ifndef NDEBUG
     LOG(ERROR) << "New display item: " << newItem.asDebugString();
     LOG(ERROR) << "Old display item: " << (oldItem ? oldItem->asDebugString() : "None");
 #else
@@ skipping 106 matching lines @@
     return stringBuilder.toString();
 }
 
 void PaintController::showDebugDataInternal(bool showPictures) const
 {
     WTFLogAlways("current display item list: [%s]\n", displayItemListAsDebugString(m_currentPaintArtifact.getDisplayItemList(), showPictures).utf8().data());
     WTFLogAlways("new display item list: [%s]\n", displayItemListAsDebugString(m_newDisplayItemList, showPictures).utf8().data());
 }
 
 } // namespace blink