(WIP) Invalidation during painting (for synchronized painting)

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/NotImplemented.h"
 #include "platform/TraceEvent.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/paint/DrawingDisplayItem.h"
@@ skipping 98 matching lines @@
     m_scopeStack.append(m_nextScope++);
     beginSkippingCache();
 }
 
 void PaintController::endScope()
 {
     m_scopeStack.removeLast();
     endSkippingCache();
 }
 
-void PaintController::invalidate(const DisplayItemClient& client)
+void PaintController::invalidate(const DisplayItemClient& client, PaintInvalidationReason paintInvalidationReason, const IntRect& previousPaintInvalidationRect, const IntRect& newPaintInvalidationRect)
 {
-#if ENABLE(ASSERT)
-    // Slimming paint v1 CompositedLayerMapping may invalidate client on extra layers.
-    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() || clientCacheIsValid(client))
-        m_invalidations.append(client.debugName());
-#endif
-
     invalidateUntracked(client);
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() && m_trackedPaintInvalidationObjects)
         m_trackedPaintInvalidationObjects->append(client.debugName());
+
+    fprintf(stderr, "###invalidate %p %s on %p(%s) %s old:%d,%d,%d,%d new:%d,%d,%d,%d\n",
+        &client, client.debugName().ascii().data(), this, m_debugName.ascii().data(),
+        paintInvalidationReasonToString(paintInvalidationReason),
+        previousPaintInvalidationRect.x(), previousPaintInvalidationRect.y(), previousPaintInvalidationRect.width(), previousPaintInvalidationRect.height(),
+        newPaintInvalidationRect.x(), newPaintInvalidationRect.y(), newPaintInvalidationRect.width(), newPaintInvalidationRect.height());
+
+    if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+        return;
+
+    Invalidation invalidation = { client, client.debugName(), previousPaintInvalidationRect, paintInvalidationReason };
+    if (paintInvalidationReason != PaintInvalidationIncremental) {
+        if (!previousPaintInvalidationRect.isEmpty())
+            m_invalidations.append(invalidation);
+        if (newPaintInvalidationRect != previousPaintInvalidationRect && !newPaintInvalidationRect.isEmpty()) {
+            invalidation.rect = newPaintInvalidationRect;
+            m_invalidations.append(invalidation);
+        }
+        return;
+    }
+
+    ASSERT(previousPaintInvalidationRect.location() == newPaintInvalidationRect.location());
+    if (LayoutUnit deltaRight = newPaintInvalidationRect.maxX() - previousPaintInvalidationRect.maxX()) {
+        if (deltaRight > 0)
+            invalidation.rect = IntRect(previousPaintInvalidationRect.maxX(), newPaintInvalidationRect.y(), deltaRight, newPaintInvalidationRect.height());
+        else
+            invalidation.rect = IntRect(newPaintInvalidationRect.maxX(), previousPaintInvalidationRect.y(), -deltaRight, previousPaintInvalidationRect.height());
+        if (!invalidation.rect.isEmpty())
+            m_invalidations.append(invalidation);
+    }
+    if (LayoutUnit deltaBottom = newPaintInvalidationRect.maxY() - previousPaintInvalidationRect.maxY()) {
+        if (deltaBottom > 0)
+            invalidation.rect = IntRect(newPaintInvalidationRect.x(), previousPaintInvalidationRect.maxY(), newPaintInvalidationRect.width(), deltaBottom);
+        else if (deltaBottom < 0)
+            invalidation.rect = IntRect(previousPaintInvalidationRect.x(), newPaintInvalidationRect.maxY(), previousPaintInvalidationRect.width(), -deltaBottom);
+        if (!invalidation.rect.isEmpty())
+            m_invalidations.append(invalidation);
+    }
 }
 
 void PaintController::invalidateUntracked(const DisplayItemClient& client)
 {
     // This can be called during painting, but we can't invalidate already painted clients.
     ASSERT(!m_newDisplayItemIndicesByClient.contains(&client));
     updateValidlyCachedClientsIfNeeded();
     m_validlyCachedClients.remove(&client);
 }
 
@@ skipping 12 matching lines @@
 bool PaintController::clientCacheIsValid(const DisplayItemClient& client) const
 {
     if (skippingCache())
         return false;
     updateValidlyCachedClientsIfNeeded();
     return m_validlyCachedClients.contains(&client);
 }
 
 void PaintController::invalidatePaintOffset(const DisplayItemClient& client)
 {
-    ASSERT(RuntimeEnabledFeatures::slimmingPaintOffsetCachingEnabled());
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
     invalidate(client);
 
 #if ENABLE(ASSERT)
     ASSERT(!paintOffsetWasInvalidated(client));
     m_clientsWithPaintOffsetInvalidations.add(&client);
 #endif
 }
 
 #if ENABLE(ASSERT)
 bool PaintController::paintOffsetWasInvalidated(const DisplayItemClient& client) const
 {
-    ASSERT(RuntimeEnabledFeatures::slimmingPaintOffsetCachingEnabled());
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
     return m_clientsWithPaintOffsetInvalidations.contains(&client);
 }
 #endif
 
 size_t PaintController::findMatchingItemFromIndex(const DisplayItem::Id& id, const DisplayItemIndicesByClientMap& displayItemIndicesByClient, const DisplayItemList& list)
 {
     DisplayItemIndicesByClientMap::const_iterator it = displayItemIndicesByClient.find(&id.client);
     if (it == displayItemIndicesByClient.end())
         return kNotFound;
 
@@ skipping 98 matching lines @@
 // Coefficients are related to the ratio of out-of-order CachedDisplayItems
 // and the average number of (Drawing|Subsequence)DisplayItems per client.
 //
 void PaintController::commitNewDisplayItemsInternal(const LayoutSize& offsetFromLayoutObject)
 {
     TRACE_EVENT2("blink,benchmark", "PaintController::commitNewDisplayItems",
         "current_display_list_size", (int)m_currentPaintArtifact.displayItemList().size(),
         "num_non_cached_new_items", (int)m_newDisplayItemList.size() - m_numCachedNewItems);
     m_numCachedNewItems = 0;
 
-    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
+        for (const auto& invalidation : m_invalidations)
+            graphicsLayer->setNeedsDisplayInRect(invalidation.rect, invalidation.invalidationReason);
+        fprintf(stderr, "PaintController graphicsLayer %p %p(%s) clear invalidations\n", graphicsLayer, this, m_debugName.ascii().data());
+        m_invalidations.clear();
         m_clientsCheckedPaintInvalidation.clear();
+    }
 
     // These data structures are used during painting only.
     ASSERT(m_scopeStack.isEmpty());
     m_scopeStack.clear();
     m_nextScope = 1;
     ASSERT(!skippingCache());
 #if ENABLE(ASSERT)
     m_newDisplayItemIndicesByClient.clear();
     m_clientsWithPaintOffsetInvalidations.clear();
     m_invalidations.clear();
@@ skipping 29 matching lines @@
     DisplayItemList::iterator currentEnd = m_currentPaintArtifact.displayItemList().end();
     for (DisplayItemList::iterator newIt = m_newDisplayItemList.begin(); newIt != m_newDisplayItemList.end(); ++newIt) {
         const DisplayItem& newDisplayItem = *newIt;
         const DisplayItem::Id newDisplayItemId = newDisplayItem.nonCachedId();
         bool newDisplayItemHasCachedType = newDisplayItem.type() != newDisplayItemId.type;
 
         bool isSynchronized = currentIt != currentEnd && newDisplayItemId.matches(*currentIt);
 
         if (newDisplayItemHasCachedType) {
             ASSERT(newDisplayItem.isCached());
-            ASSERT(clientCacheIsValid(newDisplayItem.client()) || (RuntimeEnabledFeatures::slimmingPaintOffsetCachingEnabled() && !paintOffsetWasInvalidated(newDisplayItem.client())));
+            ASSERT(clientCacheIsValid(newDisplayItem.client()) || (RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled() && !paintOffsetWasInvalidated(newDisplayItem.client())));
             if (!isSynchronized) {
                 currentIt = findOutOfOrderCachedItem(newDisplayItemId, outOfOrderIndexContext);
 
                 if (currentIt == currentEnd) {
 #ifndef NDEBUG
                     showDebugData();
                     WTFLogAlways("%s not found in m_currentDisplayItemList\n", newDisplayItem.asDebugString().utf8().data());
 #endif
                     ASSERT_NOT_REACHED();
                     // We did not find the cached display item. This should be impossible, but may occur if there is a bug
@@ skipping 13 matching lines @@
                 ++currentIt;
             } else {
                 ASSERT(newDisplayItem.type() == DisplayItem::CachedSubsequence);
                 copyCachedSubsequence(m_currentPaintArtifact.displayItemList(), currentIt, updatedList);
                 ASSERT(updatedList.last().type() == DisplayItem::EndSubsequence);
             }
         } else {
             ASSERT(!newDisplayItem.isDrawing()
                 || newDisplayItem.skippedCache()
                 || !clientCacheIsValid(newDisplayItem.client())
-                || (RuntimeEnabledFeatures::slimmingPaintOffsetCachingEnabled() && paintOffsetWasInvalidated(newDisplayItem.client())));
+                || (RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled() && paintOffsetWasInvalidated(newDisplayItem.client())));
 
             updatedList.appendByMoving(*newIt, visualRectForDisplayItem(*newIt, offsetFromLayoutObject));
 
             if (isSynchronized)
                 ++currentIt;
         }
         // Items before currentIt should have been copied so we don't need to index them.
         if (currentIt - outOfOrderIndexContext.nextItemToIndex > 0)
             outOfOrderIndexContext.nextItemToIndex = currentIt;
     }
@@ skipping 163 matching lines @@
     size_t i = 0;
     for (auto it = list.begin(); it != list.end(); ++it, ++i) {
         const DisplayItem& displayItem = *it;
         if (i)
             stringBuilder.append(",\n");
         stringBuilder.append(String::format("{index: %d, ", (int)i));
         displayItem.dumpPropertiesAsDebugString(stringBuilder);
         stringBuilder.append(", cacheIsValid: ");
         stringBuilder.append(clientCacheIsValid(displayItem.client()) ? "true" : "false");
         stringBuilder.append('}');
+        if (DisplayItem::isDrawingType(displayItem.type())) {
+            if (const SkPicture* picture = static_cast<const DrawingDisplayItem&>(displayItem).picture()) {
+                stringBuilder.append(", picture: ");
+                stringBuilder.append(pictureAsDebugString(picture));
+            }
+        }
     }
     return stringBuilder.toString();
 }
 
 void PaintController::showDebugData() const
 {
     WTFLogAlways("current display item list: [%s]\n", displayItemListAsDebugString(m_currentPaintArtifact.displayItemList()).utf8().data());
     WTFLogAlways("new display item list: [%s]\n", displayItemListAsDebugString(m_newDisplayItemList).utf8().data());
 }
 
 #endif // ifndef NDEBUG
 
 } // namespace blink