Slimming Paint phase 2 compositing algorithm plumbing & skeleton display list API.

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/RuntimeEnabledFeatures.h"
 #include "platform/TraceEvent.h"
@@ skipping 14 matching lines @@
 
 namespace blink {
 
 const DisplayItems& DisplayItemList::displayItems() const
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintEnabled());
     ASSERT(m_newDisplayItems.empty());
     return m_currentDisplayItems;
 }
 
+const WebVector<WebDisplayItem>& DisplayItemList::webDisplayItems() const
+{
+    return m_webDisplayItems;
+}
+
+const skia::DiscardablePixelRefList& DisplayItemList::pixelRefs() const
+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintCompositorLayerizationEnabled());
+    ASSERT(m_newPixelRefs.empty());
+    return m_currentPixelRefs;
+}
+
+
 bool DisplayItemList::lastDisplayItemIsNoopBegin() const
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintEnabled());
     if (m_newDisplayItems.empty())
         return false;
 
     const auto& lastDisplayItem = *m_newDisplayItems.back();
     return lastDisplayItem.isBegin() && !lastDisplayItem.drawsContent();
 }
 
 void DisplayItemList::removeLastDisplayItem()
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintEnabled());
     if (m_newDisplayItems.empty())
         return;
 
 #if ENABLE(ASSERT)
     // Also remove the index pointing to the removed display item.
     DisplayItemIndicesByClientMap::iterator it = m_newDisplayItemIndicesByClient.find(m_newDisplayItems.back()->client());
     if (it != m_newDisplayItemIndicesByClient.end()) {
         Vector<size_t>& indices = it->value;
         if (!indices.isEmpty() && indices.last() == (m_newDisplayItems.size() - 1))
             indices.removeLast();
     }
 #endif
     m_newDisplayItems.removeLast();
 }
 
+void DisplayItemList::addPixelRef(const skia::PixelRefUtils::PositionPixelRef& pixelRef)
+{
+    m_newPixelRefs.push_back(pixelRef);
+}
+
 void DisplayItemList::processNewItem(DisplayItem* displayItem)
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintEnabled());
     ASSERT(!m_constructionDisabled);
     ASSERT(!skippingCache() || !displayItem->isCached());
 
     if (DisplayItem::isCachedType(displayItem->type()))
         ++m_numCachedItems;
 
 #if ENABLE(ASSERT)
@@ skipping 136 matching lines @@
 // repainted ones, and appending new items.
 // - For CachedDisplayItem, copy the corresponding cached DrawingDisplayItem;
 // - FIXME: Re-enable SubtreeCachedDisplayItem:
 //   For SubtreeCachedDisplayItem, copy the cached display items between the
 //   corresponding BeginSubtreeDisplayItem and EndSubtreeDisplayItem (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 [Subtree]CachedDisplayItems
 // and the average number of (Drawing|BeginSubtree)DisplayItems per client.
-void DisplayItemList::commitNewDisplayItems()
+// TODO(chrishtr); implement filling of displayListDiff.
+void DisplayItemList::commitNewDisplayItems(WebDisplayListDiff* displayListDiff)
 {
     TRACE_EVENT2("blink,benchmark", "DisplayItemList::commitNewDisplayItems", "current_display_list_size", (int)m_currentDisplayItems.size(),
         "num_non_cached_new_items", (int)m_newDisplayItems.size() - m_numCachedItems);
 
     // These data structures are used during painting only.
     m_clientScopeIdMap.clear();
     ASSERT(m_scopeStack.isEmpty());
     m_scopeStack.clear();
     ASSERT(!skippingCache());
 #if ENABLE(ASSERT)
     m_newDisplayItemIndicesByClient.clear();
 #endif
 
     if (m_currentDisplayItems.empty()) {
 #if ENABLE(ASSERT)
         for (const auto& item : m_newDisplayItems) {
             ASSERT(!DisplayItem::isCachedType(item->type())
                 && !DisplayItem::isSubtreeCachedType(item->type()));
         }
 #endif
         m_currentDisplayItems.swap(m_newDisplayItems);
         m_validlyCachedClientsDirty = true;
         m_numCachedItems = 0;
+        m_currentPixelRefs.swap(m_newPixelRefs);
         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.
@@ skipping 65 matching lines @@
     }
 
 #if ENABLE(ASSERT)
     if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled())
         checkNoRemainingCachedDisplayItems();
 #endif // ENABLE(ASSERT)
 
     m_newDisplayItems.clear();
     m_validlyCachedClientsDirty = true;
     m_currentDisplayItems.swap(updatedList);
+    m_currentPixelRefs.swap(m_newPixelRefs);
     m_numCachedItems = 0;
 }
 
 size_t DisplayItemList::approximateUnsharedMemoryUsage() const
 {
     size_t memoryUsage = sizeof(*this);
 
     // Memory outside this class due to m_currentDisplayItems.
     memoryUsage += m_currentDisplayItems.getCapacityInBytes();
 
@@ skipping 183 matching lines @@
 
 void DisplayItemList::replay(GraphicsContext& context)
 {
     TRACE_EVENT0("blink,benchmark", "DisplayItemList::replay");
     ASSERT(m_newDisplayItems.empty());
     for (auto displayItem : m_currentDisplayItems)
         displayItem->replay(context);
 }
 
 } // namespace blink