Client side display item cache flag

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"
 
@@ skipping 120 matching lines @@
 #endif
 
     invalidateUntracked(client);
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() && m_trackedPaintInvalidationObjects)
         m_trackedPaintInvalidationObjects->append(client.debugName());
 }
 
 void PaintController::invalidateUntracked(const DisplayItemClient& client)
 {
     // This can be called during painting, but we can't invalidate already painted clients.
+    client.setDisplayItemsCached(DisplayItemClient::kInvalidCacheGeneration);
     ASSERT(!m_newDisplayItemIndicesByClient.contains(&client));
-    updateValidlyCachedClientsIfNeeded();
-    m_validlyCachedClients.remove(&client);
 }
 
 void PaintController::invalidateAll()
 {
     // Can only be called during layout/paintInvalidation, not during painting.
     ASSERT(m_newDisplayItemList.isEmpty());
     m_currentPaintArtifact.reset();
-    m_validlyCachedClients.clear();
-    m_validlyCachedClientsDirty = false;
+    m_currentCacheGeneration = DisplayItemClient::kInvalidCacheGeneration;
 
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() && m_trackedPaintInvalidationObjects)
         m_trackedPaintInvalidationObjects->append("##ALL##");
 }
 
 bool PaintController::clientCacheIsValid(const DisplayItemClient& client) const
 {
-    if (skippingCache())
+    ASSERT(DisplayItemClient::isAlive(client));
+    return DisplayItemClient::s_cacheStatus;
+#if 0
+    if (!canUseClientCacheStatus() || skippingCache())
         return false;
-    updateValidlyCachedClientsIfNeeded();
-    return m_validlyCachedClients.contains(&client);
+    return client.displayItemsAreCached(m_currentCacheGeneration);
+#endif
 }
 
 void PaintController::invalidatePaintOffset(const DisplayItemClient& client)
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintInvalidationEnabled());
     invalidate(client);
 
 #if ENABLE(ASSERT)
     ASSERT(!paintOffsetWasInvalidated(client));
     m_clientsWithPaintOffsetInvalidations.add(&client);
@@ skipping 55 matching lines @@
     return findOutOfOrderCachedItemForward(id, context);
 }
 
 // Find forward for the item and index all skipped indexable items.
 DisplayItemList::iterator PaintController::findOutOfOrderCachedItemForward(const DisplayItem::Id& id, OutOfOrderIndexContext& context)
 {
     DisplayItemList::iterator currentEnd = m_currentPaintArtifact.getDisplayItemList().end();
     for (; context.nextItemToIndex != currentEnd; ++context.nextItemToIndex) {
         const DisplayItem& item = *context.nextItemToIndex;
         ASSERT(item.hasValidClient());
-        if (item.isCacheable() && clientCacheIsValid(item.client())) {
-            if (id.matches(item))
-                return context.nextItemToIndex++;
-
+        if (id.matches(item))
+            return context.nextItemToIndex++;
+        if (item.isCacheable())
             addItemToIndexIfNeeded(item, context.nextItemToIndex - m_currentPaintArtifact.getDisplayItemList().begin(), context.displayItemIndicesByClient);
-        }
     }
     return currentEnd;
 }
 
 void PaintController::copyCachedSubsequence(const DisplayItemList& currentList, DisplayItemList::iterator& currentIt, DisplayItemList& updatedList)
 {
     ASSERT(currentIt->getType() == DisplayItem::Subsequence);
     ASSERT(!currentIt->scope());
     DisplayItem::Id endSubsequenceId(currentIt->client(), DisplayItem::EndSubsequence, 0);
     do {
@@ skipping 34 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.getDisplayItemList().size(),
         "num_non_cached_new_items", (int)m_newDisplayItemList.size() - m_numCachedNewItems);
     m_numCachedNewItems = 0;
 
-    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
-        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();
 #endif
 
     if (m_currentPaintArtifact.isEmpty()) {
 #if ENABLE(ASSERT)
         for (const auto& item : m_newDisplayItemList)
             ASSERT(!item.isCached());
 #endif
         for (const auto& item : m_newDisplayItemList)
             m_newDisplayItemList.appendVisualRect(visualRectForDisplayItem(item, offsetFromLayoutObject));
 
         m_currentPaintArtifact = PaintArtifact(std::move(m_newDisplayItemList), m_newPaintChunks.releasePaintChunks());
         m_newDisplayItemList = DisplayItemList(kInitialDisplayItemListCapacityBytes);
-        m_validlyCachedClientsDirty = true;
+        updateCacheGeneration();
         return;
     }
 
-    updateValidlyCachedClientsIfNeeded();
-
     // Stores indices to valid DrawingDisplayItems in m_currentDisplayItems that have not been matched
     // by CachedDisplayItems during synchronized matching. The indexed items will be matched
     // by later out-of-order CachedDisplayItems in m_newDisplayItemList. This ensures that when
     // out-of-order CachedDisplayItems occur, we only traverse at most once over m_currentDisplayItems
     // looking for potential matches. Thus we can ensure that the algorithm runs in linear time.
     OutOfOrderIndexContext outOfOrderIndexContext(m_currentPaintArtifact.getDisplayItemList().begin());
 
     // TODO(jbroman): Consider revisiting this heuristic.
     DisplayItemList updatedList(std::max(m_currentPaintArtifact.getDisplayItemList().usedCapacityInBytes(), m_newDisplayItemList.usedCapacityInBytes()));
     Vector<PaintChunk> updatedPaintChunks;
@@ skipping 57 matching lines @@
 #if ENABLE(ASSERT)
     if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled())
         checkNoRemainingCachedDisplayItems();
 #endif // ENABLE(ASSERT)
 
     // TODO(jbroman): When subsequence caching applies to SPv2, we'll need to
     // merge the paint chunks as well.
     m_currentPaintArtifact = PaintArtifact(std::move(updatedList), m_newPaintChunks.releasePaintChunks());
 
     m_newDisplayItemList = DisplayItemList(kInitialDisplayItemListCapacityBytes);
-    m_validlyCachedClientsDirty = true;
+    updateCacheGeneration();
 }
 
 size_t PaintController::approximateUnsharedMemoryUsage() const
 {
     size_t memoryUsage = sizeof(*this);
 
     // Memory outside this class due to m_currentPaintArtifact.
     memoryUsage += m_currentPaintArtifact.approximateUnsharedMemoryUsage() - sizeof(m_currentPaintArtifact);
 
     // TODO(jbroman): If display items begin to have significant external memory
     // usage that's not shared with the embedder, we should account for it here.
     //
     // External objects, shared with the embedder, such as SkPicture, should be
     // excluded to avoid double counting. It is the embedder's responsibility to
     // count such objects.
     //
     // At time of writing, the only known case of unshared external memory was
     // the rounded clips vector in ClipDisplayItem, which is not expected to
     // contribute significantly to memory usage.
 
     // Memory outside this class due to m_newDisplayItemList.
     ASSERT(m_newDisplayItemList.isEmpty());
     memoryUsage += m_newDisplayItemList.memoryUsageInBytes();
 
     return memoryUsage;
 }
 
-void PaintController::updateValidlyCachedClientsIfNeeded() const
+unsigned PaintController::nextCacheGeneration()
 {
-    if (!m_validlyCachedClientsDirty)
+    static unsigned cacheGeneration = DisplayItemClient::kInvalidCacheGeneration;
+    ++cacheGeneration;
+    if (cacheGeneration == DisplayItemClient::kInvalidCacheGeneration) {
+        // TODO(wangxianzhu): We'll reuse an old cache generation. Should invalidate all
+        // clients that are still using the old generation.
+        ++cacheGeneration;
+    }
+    return cacheGeneration;
+}
+
+void PaintController::updateCacheGeneration()
+{
+    if (!canUseClientCacheStatus())
         return;
 
-    m_validlyCachedClients.clear();
-    m_validlyCachedClientsDirty = false;
-
-    const DisplayItemClient* lastAddedClient = nullptr;
+    m_currentCacheGeneration = nextCacheGeneration();
     for (const DisplayItem& displayItem : m_currentPaintArtifact.getDisplayItemList()) {
-        if (&displayItem.client() == lastAddedClient)
-            continue;
-        if (displayItem.isCacheable()) {
-            lastAddedClient = &displayItem.client();
-            m_validlyCachedClients.add(lastAddedClient);
-        }
+        if (displayItem.isCacheable())
+            displayItem.client().setDisplayItemsCached(m_currentCacheGeneration);
     }
 }
 
 #if ENABLE(ASSERT)
 
 void PaintController::checkUnderInvalidation(DisplayItemList::iterator& newIt, DisplayItemList::iterator& currentIt)
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled());
     ASSERT(newIt->isCached());
 
@@ skipping 46 matching lines @@
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled());
     ASSERT(!newItem.isCached());
     ASSERT(!oldItem.isCached());
 
     if (newItem.skippedCache()) {
         showUnderInvalidationError(messagePrefix, "ERROR: under-invalidation: skipped-cache in cached subsequence", &newItem, &oldItem);
         ASSERT_NOT_REACHED();
     }
 
-    if (newItem.isCacheable() && !m_validlyCachedClients.contains(&newItem.client())) {
+    if (newItem.isCacheable() && !clientCacheIsValid(newItem.client())) {
         showUnderInvalidationError(messagePrefix, "ERROR: under-invalidation: invalidated in cached subsequence", &newItem, &oldItem);
         ASSERT_NOT_REACHED();
     }
 
     if (newItem.equals(oldItem))
         return;
 
     showUnderInvalidationError(messagePrefix, "ERROR: under-invalidation: display item changed", &newItem, &oldItem);
 
 #ifndef NDEBUG
@@ skipping 46 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