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 551 matching lines @@
   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 20 matching lines @@
     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;
+    bool isPotentiallyInvalidClient = false;
     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()) {
+      isPotentiallyInvalidClient = true;
       clientToInvalidate = &oldItem.client();
     }
     if (clientToInvalidate &&
         invalidatedClientsInOldChunk.add(clientToInvalidate).isNewEntry) {
-      newChunk.rasterInvalidationRects.append(
-          m_currentPaintArtifact.getDisplayItemList().visualRect(oldIndex));
+      addRasterInvalidationInfo(
+          isPotentiallyInvalidClient ? nullptr : 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());
+        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();
@@ skipping 135 matching lines @@
                    m_currentPaintArtifact.getDisplayItemList(), showPictures)
                    .utf8()
                    .data());
   WTFLogAlways("new display item list: [%s]\n",
                displayItemListAsDebugString(m_newDisplayItemList, showPictures)
                    .utf8()
                    .data());
 }
 
 }  // namespace blink