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"
@@ skipping 521 matching lines @@
     m_currentPaintArtifact.getDisplayItemList().appendVisualRect(visualRectForDisplayItem(displayItem, offsetFromLayoutObject));
 }
 
 void PaintController::generateChunkRasterInvalidationRects(PaintChunk& newChunk)
 {
     DCHECK(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
     if (newChunk.beginIndex >= m_currentCachedSubsequenceBeginIndexInNewList)
         return;
 
     if (!newChunk.id) {
-        newChunk.rasterInvalidationRects.append(FloatRect(LayoutRect::infiniteIntRect()));
+        PaintInvalidationInfo info;
+        info.rect = LayoutRect::infiniteIntRect();
+        newChunk.rasterInvalidationRects.append(info);
         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()));
+    PaintInvalidationInfo info;
+    info.rect = LayoutRect::infiniteIntRect();
+    newChunk.rasterInvalidationRects.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());
+
+                    PaintInvalidationInfo info;
+                    info.rect = enclosingIntRect(clientToInvalidate->visualRect());
+                    if (m_isTrackingPaintInvalidations) {
+                        info.client = clientToInvalidate;
+                        info.clientDebugName = clientToInvalidate->debugName();
+                        info.reason = PaintInvalidationFull;
+                    }

[Xianzhu, 2016/09/30 00:47:01]

Can you extract this as a function?

We can get the paintInvalidationReason from the
client.getPaintInvalidationReason() (for clients in the new display list, and
clients in old chunks matching new chunks). 

[chrishtr, 2016/09/30 18:19:10]

Done.

+                    movedToChunk.rasterInvalidationRects.append(info);
                 } 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));
+            PaintInvalidationInfo info;
+            info.rect = enclosingIntRect(m_currentPaintArtifact.getDisplayItemList().visualRect(oldIndex));
+            if (m_isTrackingPaintInvalidations) {
+                info.client = clientToInvalidate;
+                info.clientDebugName = clientToInvalidate->debugName();
+                info.reason = PaintInvalidationFull;
+            }
+            newChunk.rasterInvalidationRects.append(info);
         }
     }
 
     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) {
+            PaintInvalidationInfo info;
+            info.rect = enclosingIntRect(newItem.client().visualRect());
+            if (m_isTrackingPaintInvalidations) {
+                info.client = &newItem.client();
+                info.clientDebugName = newItem.client().debugName();
+                info.reason = PaintInvalidationFull;
+            }
+            newChunk.rasterInvalidationRects.append(info);
+        }
     }
 }
 
 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