Factor PaintArtifact out of DisplayItemList.

third_party/WebKit/Source/platform/graphics/paint/DisplayItemList.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 "config.h"
 #include "platform/graphics/paint/DisplayItemList.h"
 
 #include "platform/NotImplemented.h"
 #include "platform/TraceEvent.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/graphics/paint/DrawingDisplayItem.h"
 
 #ifndef NDEBUG
 #include "platform/graphics/LoggingCanvas.h"
 #include "wtf/text/StringBuilder.h"
 #include <stdio.h>
 #endif
 
 namespace blink {
 
-const DisplayItems& DisplayItemList::displayItems() const
+const PaintArtifact& DisplayItemList::paintArtifact() const
 {
     ASSERT(m_newDisplayItems.isEmpty());
-    return m_currentDisplayItems;
-}
-
-const Vector<PaintChunk>& DisplayItemList::paintChunks() const
-{
     ASSERT(m_newPaintChunks.isInInitialState());
-    return m_currentPaintChunks;
+    return m_currentPaintArtifact;
 }
 
 bool DisplayItemList::lastDisplayItemIsNoopBegin() const
 {
     if (m_newDisplayItems.isEmpty())
         return false;
 
     const auto& lastDisplayItem = m_newDisplayItems.last();
     return lastDisplayItem.isBegin() && !lastDisplayItem.drawsContent();
 }
@@ skipping 103 matching lines @@
     // This can be called during painting, but we can't invalidate already painted clients.
     ASSERT(!m_newDisplayItemIndicesByClient.contains(client));
     updateValidlyCachedClientsIfNeeded();
     m_validlyCachedClients.remove(client);
 }
 
 void DisplayItemList::invalidateAll()
 {
     // Can only be called during layout/paintInvalidation, not during painting.
     ASSERT(m_newDisplayItems.isEmpty());
-    m_currentDisplayItems.clear();
+    m_currentPaintArtifact.reset();
     m_validlyCachedClients.clear();
     m_validlyCachedClientsDirty = false;
 
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() && m_trackedPaintInvalidationObjects)
         m_trackedPaintInvalidationObjects->append("##ALL##");
 }
 
 bool DisplayItemList::clientCacheIsValid(DisplayItemClient client) const
 {
     if (skippingCache())
@@ skipping 53 matching lines @@
     OutOfOrderIndexContext(DisplayItems::iterator begin) : nextItemToIndex(begin) { }
 
     DisplayItems::iterator nextItemToIndex;
     DisplayItemIndicesByClientMap displayItemIndicesByClient;
 };
 
 DisplayItems::iterator DisplayItemList::findOutOfOrderCachedItem(const DisplayItem::Id& id, OutOfOrderIndexContext& context)
 {
     ASSERT(clientCacheIsValid(id.client));
 
-    size_t foundIndex = findMatchingItemFromIndex(id, context.displayItemIndicesByClient, m_currentDisplayItems);
+    size_t foundIndex = findMatchingItemFromIndex(id, context.displayItemIndicesByClient, m_currentPaintArtifact.displayItems());
     if (foundIndex != kNotFound)
-        return m_currentDisplayItems.begin() + foundIndex;
+        return m_currentPaintArtifact.displayItems().begin() + foundIndex;
 
     return findOutOfOrderCachedItemForward(id, context);
 }
 
 // Find forward for the item and index all skipped indexable items.
 DisplayItems::iterator DisplayItemList::findOutOfOrderCachedItemForward(const DisplayItem::Id& id, OutOfOrderIndexContext& context)
 {
-    DisplayItems::iterator currentEnd = m_currentDisplayItems.end();
+    DisplayItems::iterator currentEnd = m_currentPaintArtifact.displayItems().end();
     for (; context.nextItemToIndex != currentEnd; ++context.nextItemToIndex) {
         const DisplayItem& item = *context.nextItemToIndex;
         ASSERT(item.isValid());
         if (item.isCacheable() && clientCacheIsValid(item.client())) {
             if (id.matches(item))
                 return context.nextItemToIndex++;
 
-            addItemToIndexIfNeeded(item, context.nextItemToIndex - m_currentDisplayItems.begin(), context.displayItemIndicesByClient);
+            addItemToIndexIfNeeded(item, context.nextItemToIndex - m_currentPaintArtifact.displayItems().begin(), context.displayItemIndicesByClient);
         }
     }
     return currentEnd;
 }
 
 void DisplayItemList::copyCachedSubsequence(DisplayItems::iterator& currentIt, DisplayItems& updatedList)
 {
     ASSERT(currentIt->isSubsequence());
     ASSERT(!currentIt->scope());
     DisplayItem::Id endSubsequenceId(currentIt->client(), DisplayItem::subsequenceTypeToEndSubsequenceType(currentIt->type()), 0);
     do {
         // We should always find the EndSubsequence display item.
-        ASSERT(currentIt != m_currentDisplayItems.end());
+        ASSERT(currentIt != m_currentPaintArtifact.displayItems().end());
         ASSERT(currentIt->isValid());
         updatedList.appendByMoving(*currentIt);
         ++currentIt;
     } while (!endSubsequenceId.matches(updatedList.last()));
 }
 
 // Update the existing display items by removing invalidated entries, updating
 // repainted ones, and appending new items.
 // - For cached drawing display item, copy the corresponding cached DrawingDisplayItem;
 // - For cached subsequence display item, copy the cached display items between the
 //   corresponding SubsequenceDisplayItem and EndSubsequenceDisplayItem (incl.);
 // - Otherwise, copy the new display item.
 //
 // The algorithm is O(|m_currentDisplayItems| + |m_newDisplayItems|).
 // Coefficients are related to the ratio of out-of-order CachedDisplayItems
 // and the average number of (Drawing|Subsequence)DisplayItems per client.
 //
 void DisplayItemList::commitNewDisplayItems(GraphicsLayer* graphicsLayer)
 {
-    TRACE_EVENT2("blink,benchmark", "DisplayItemList::commitNewDisplayItems", "current_display_list_size", (int)m_currentDisplayItems.size(),
+    TRACE_EVENT2("blink,benchmark", "DisplayItemList::commitNewDisplayItems",
+        "current_display_list_size", (int)m_currentPaintArtifact.displayItems().size(),
         "num_non_cached_new_items", (int)m_newDisplayItems.size() - m_numCachedItems);
 
     if (RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled()) {
         for (const auto& invalidation : m_invalidations)
             graphicsLayer->setNeedsDisplayInRect(invalidation.rect, invalidation.invalidationReason);
         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();
 #endif
 
-    if (m_currentDisplayItems.isEmpty()) {
+    if (m_currentPaintArtifact.isEmpty()) {
 #if ENABLE(ASSERT)
         for (const auto& item : m_newDisplayItems)
             ASSERT(!item.isCached());
 #endif
-        m_currentDisplayItems.swap(m_newDisplayItems);
-        m_currentPaintChunks = m_newPaintChunks.releasePaintChunks();
+        m_currentPaintArtifact.update(m_newDisplayItems, m_newPaintChunks.releasePaintChunks());
         m_validlyCachedClientsDirty = true;
         m_numCachedItems = 0;
         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_newDisplayItems. 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_currentDisplayItems.begin());
+    OutOfOrderIndexContext outOfOrderIndexContext(m_currentPaintArtifact.displayItems().begin());
 
     // TODO(jbroman): Consider revisiting this heuristic.
-    DisplayItems updatedList(std::max(m_currentDisplayItems.usedCapacityInBytes(), m_newDisplayItems.usedCapacityInBytes()));
+    DisplayItems updatedList(std::max(m_currentPaintArtifact.displayItems().usedCapacityInBytes(), m_newDisplayItems.usedCapacityInBytes()));
     Vector<PaintChunk> updatedPaintChunks;
-    DisplayItems::iterator currentIt = m_currentDisplayItems.begin();
-    DisplayItems::iterator currentEnd = m_currentDisplayItems.end();
+    DisplayItems::iterator currentIt = m_currentPaintArtifact.displayItems().begin();
+    DisplayItems::iterator currentEnd = m_currentPaintArtifact.displayItems().end();
     for (DisplayItems::iterator newIt = m_newDisplayItems.begin(); newIt != m_newDisplayItems.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())));
@@ skipping 40 matching lines @@
         // Items before currentIt should have been copied so we don't need to index them.
         if (currentIt - outOfOrderIndexContext.nextItemToIndex > 0)
             outOfOrderIndexContext.nextItemToIndex = currentIt;
     }
 
 #if ENABLE(ASSERT)
     if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled())
         checkNoRemainingCachedDisplayItems();
 #endif // ENABLE(ASSERT)
 
+

[pdr., 2015/10/09 03:57:50]

Nit

     // TODO(jbroman): When subsequence caching applies to SPv2, we'll need to
     // merge the paint chunks as well.
-    m_currentPaintChunks = m_newPaintChunks.releasePaintChunks();
+    m_currentPaintArtifact.update(updatedList, m_newPaintChunks.releasePaintChunks());
 
     m_newDisplayItems.clear();
     m_validlyCachedClientsDirty = true;
-    m_currentDisplayItems.swap(updatedList);
     m_numCachedItems = 0;
 }
 
 size_t DisplayItemList::approximateUnsharedMemoryUsage() const
 {
     size_t memoryUsage = sizeof(*this);
 
-    // Memory outside this class due to m_currentDisplayItems.
-    memoryUsage += m_currentDisplayItems.memoryUsageInBytes();
+    // 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_newDisplayItems.
     ASSERT(m_newDisplayItems.isEmpty());
     memoryUsage += m_newDisplayItems.memoryUsageInBytes();
 
     return memoryUsage;
 }
 
 void DisplayItemList::updateValidlyCachedClientsIfNeeded() const
 {
     if (!m_validlyCachedClientsDirty)
         return;
 
     m_validlyCachedClients.clear();
     m_validlyCachedClientsDirty = false;
 
     DisplayItemClient lastAddedClient = nullptr;
-    for (const DisplayItem& displayItem : m_currentDisplayItems) {
+    for (const DisplayItem& displayItem : m_currentPaintArtifact.displayItems()) {
         if (displayItem.client() == lastAddedClient)
             continue;
         if (displayItem.isCacheable()) {
             lastAddedClient = displayItem.client();
             m_validlyCachedClients.add(lastAddedClient);
         }
     }
 }
 
-void DisplayItemList::appendToWebDisplayItemList(WebDisplayItemList* list)
-{
-    for (const DisplayItem& item : m_currentDisplayItems)
-        item.appendToWebDisplayItemList(list);
-}
-
-void DisplayItemList::commitNewDisplayItemsAndAppendToWebDisplayItemList(WebDisplayItemList* list)
-{
-    commitNewDisplayItems();
-    appendToWebDisplayItemList(list);
-}
-
 #if ENABLE(ASSERT)
 
 void DisplayItemList::checkUnderInvalidation(DisplayItems::iterator& newIt, DisplayItems::iterator& currentIt)
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled());
     ASSERT(newIt->isCached());
 
     // When under-invalidation-checking is enabled, the forced painting is following the cached display item.
     DisplayItem::Type nextItemType = DisplayItem::nonCachedType(newIt->type());
     ++newIt;
@@ skipping 71 matching lines @@
     }
 #endif // NDEBUG
 
     ASSERT_NOT_REACHED();
 }
 
 void DisplayItemList::checkNoRemainingCachedDisplayItems()
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled());
 
-    for (const auto& displayItem : m_currentDisplayItems) {
+    for (const auto& displayItem : m_currentPaintArtifact.displayItems()) {
         if (!displayItem.isValid() || !displayItem.isCacheable() || !clientCacheIsValid(displayItem.client()))
             continue;
         showUnderInvalidationError("", "May be under-invalidation: no new display item", nullptr, &displayItem);
     }
 }
 
 #endif // ENABLE(ASSERT)
 
 #ifndef NDEBUG
 
@@ skipping 11 matching lines @@
             stringBuilder.append(", cacheIsValid: ");
             stringBuilder.append(clientCacheIsValid(displayItem.client()) ? "true" : "false");
         }
         stringBuilder.append('}');
     }
     return stringBuilder.toString();
 }
 
 void DisplayItemList::showDebugData() const
 {
-    WTFLogAlways("current display items: [%s]\n", displayItemsAsDebugString(m_currentDisplayItems).utf8().data());
+    WTFLogAlways("current display items: [%s]\n", displayItemsAsDebugString(m_currentPaintArtifact.displayItems()).utf8().data());
     WTFLogAlways("new display items: [%s]\n", displayItemsAsDebugString(m_newDisplayItems).utf8().data());
 }
 
 #endif // ifndef NDEBUG
 
-void DisplayItemList::replay(GraphicsContext& context) const
-{
-    TRACE_EVENT0("blink,benchmark", "DisplayItemList::replay");
-    ASSERT(m_newDisplayItems.isEmpty());
-    for (const DisplayItem& displayItem : m_currentDisplayItems)
-        displayItem.replay(context);
-}
-
 } // namespace blink