Revert of Let FrameView track object paint invalidations

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 94 matching lines @@
 void PaintController::updateCurrentPaintChunkProperties(const PaintChunkProperties& newProperties)
 {
     m_newPaintChunks.updateCurrentPaintChunkProperties(newProperties);
 }
 
 const PaintChunkProperties& PaintController::currentPaintChunkProperties() const
 {
     return m_newPaintChunks.currentPaintChunkProperties();
 }
 
+void PaintController::displayItemClientWasInvalidated(const DisplayItemClient& client)
+{
+#if DCHECK_IS_ON()
+    // Slimming paint v1 CompositedLayerMapping may invalidate client on extra layers.
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() || clientCacheIsValid(client))
+        m_invalidations.append(client.debugName());
+
+    // Should not invalidate already painted clients.
+    DCHECK(!m_newDisplayItemIndicesByClient.contains(&client));
+#endif
+}
+
 void PaintController::invalidateAll()
 {
     // Can only be called during layout/paintInvalidation, not during painting.
     DCHECK(m_newDisplayItemList.isEmpty());
     m_currentPaintArtifact.reset();
     m_currentCacheGeneration.invalidate();
 }
 
 bool PaintController::clientCacheIsValid(const DisplayItemClient& client) const
 {
 #if CHECK_DISPLAY_ITEM_CLIENT_ALIVENESS
     CHECK(client.isAlive());
 #endif
     if (skippingCache())
         return false;
     return client.displayItemsAreCached(m_currentCacheGeneration);
 }
 
+void PaintController::invalidatePaintOffset(const DisplayItemClient& client)
+{
+    DCHECK(RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
+    displayItemClientWasInvalidated(client);
+    client.setDisplayItemsUncached();
+
+#if DCHECK_IS_ON()
+    DCHECK(!paintOffsetWasInvalidated(client));
+    m_clientsWithPaintOffsetInvalidations.add(&client);
+#endif
+}
+
+#if DCHECK_IS_ON()
+bool PaintController::paintOffsetWasInvalidated(const DisplayItemClient& client) const
+{
+    DCHECK(RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
+    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;
 
     const Vector<size_t>& indices = it->value;
     for (size_t index : indices) {
         const DisplayItem& existingItem = list[index];
         DCHECK(!existingItem.hasValidClient() || existingItem.client() == id.client);
@@ skipping 87 matching lines @@
 {
     TRACE_EVENT2("blink,benchmark", "PaintController::commitNewDisplayItems",
         "current_display_list_size", (int)m_currentPaintArtifact.getDisplayItemList().size(),
         "num_non_cached_new_items", (int)m_newDisplayItemList.size() - m_numCachedNewItems);
     m_numCachedNewItems = 0;
 
     // These data structures are used during painting only.
     DCHECK(!skippingCache());
 #if DCHECK_IS_ON()
     m_newDisplayItemIndicesByClient.clear();
+    m_clientsWithPaintOffsetInvalidations.clear();
+    m_invalidations.clear();
 #endif
 
     SkPictureGpuAnalyzer gpuAnalyzer;
 
     if (m_currentPaintArtifact.isEmpty()) {
 #if DCHECK_IS_ON()
         for (const auto& item : m_newDisplayItemList)
             DCHECK(!item.isCached());
 #endif
 
@@ skipping 22 matching lines @@
     DisplayItemList::iterator currentIt = m_currentPaintArtifact.getDisplayItemList().begin();
     DisplayItemList::iterator currentEnd = m_currentPaintArtifact.getDisplayItemList().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.getType() != newDisplayItemId.type;
 
         bool isSynchronized = currentIt != currentEnd && newDisplayItemId.matches(*currentIt);
 
         if (newDisplayItemHasCachedType) {
+#if DCHECK_IS_ON()
             DCHECK(newDisplayItem.isCached());
-            DCHECK(clientCacheIsValid(newDisplayItem.client()));
+            DCHECK(clientCacheIsValid(newDisplayItem.client()) || (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() && !paintOffsetWasInvalidated(newDisplayItem.client())));
+#endif
             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
                     NOTREACHED();
                     // We did not find the cached display item. This should be impossible, but may occur if there is a bug
@@ skipping 11 matching lines @@
             if (newDisplayItem.isCachedDrawing()) {
                 updatedList.appendByMoving(*currentIt, m_currentPaintArtifact.getDisplayItemList().visualRect(currentIt - m_currentPaintArtifact.getDisplayItemList().begin()),
                     gpuAnalyzer);
                 ++currentIt;
             } else {
                 DCHECK(newDisplayItem.getType() == DisplayItem::CachedSubsequence);
                 copyCachedSubsequence(m_currentPaintArtifact.getDisplayItemList(), currentIt, updatedList, gpuAnalyzer);
                 DCHECK(updatedList.last().getType() == DisplayItem::EndSubsequence);
             }
         } else {
+#if DCHECK_IS_ON()
             DCHECK(!newDisplayItem.isDrawing()
                 || newDisplayItem.skippedCache()
-                || !clientCacheIsValid(newDisplayItem.client()));
+                || !clientCacheIsValid(newDisplayItem.client())
+                || (RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled() && paintOffsetWasInvalidated(newDisplayItem.client())));
+#endif
 
             updatedList.appendByMoving(*newIt, visualRectForDisplayItem(*newIt, offsetFromLayoutObject), gpuAnalyzer);
 
             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 164 matching lines @@
 
 void PaintController::showDebugData() const
 {
     WTFLogAlways("current display item list: [%s]\n", displayItemListAsDebugString(m_currentPaintArtifact.getDisplayItemList()).utf8().data());
     WTFLogAlways("new display item list: [%s]\n", displayItemListAsDebugString(m_newDisplayItemList).utf8().data());
 }
 
 #endif // ifndef NDEBUG
 
 } // namespace blink