Create PaintChunk and begin writing code to build paint chunks.

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/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
 {
     ASSERT(m_newDisplayItems.isEmpty());
     return m_currentDisplayItems;
 }
 
+const Vector<PaintChunk>& DisplayItemList::paintChunks() const
+{
+    ASSERT(m_newPaintChunks.isInInitialState());
+    return m_currentPaintChunks;
+}
+
 bool DisplayItemList::lastDisplayItemIsNoopBegin() const
 {
     if (m_newDisplayItems.isEmpty())
         return false;
 
     const auto& lastDisplayItem = m_newDisplayItems.last();
     return lastDisplayItem.isBegin() && !lastDisplayItem.drawsContent();
 }
 
 void DisplayItemList::removeLastDisplayItem()
 {
     if (m_newDisplayItems.isEmpty())
         return;
 
 #if ENABLE(ASSERT)
     // Also remove the index pointing to the removed display item.
     DisplayItemIndicesByClientMap::iterator it = m_newDisplayItemIndicesByClient.find(m_newDisplayItems.last().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();
+    m_newPaintChunks.decrementDisplayItemIndex();
 }
 
 void DisplayItemList::processNewItem(DisplayItem& displayItem)
 {
     ASSERT(!m_constructionDisabled);
     ASSERT(!skippingCache() || !displayItem.isCached());
 
     if (displayItem.isCached())
         ++m_numCachedItems;
 
@@ skipping 17 matching lines @@
         WTFLogAlways("DisplayItem %s has duplicated id with previous %s (index=%d)\n",
             displayItem.asDebugString().utf8().data(), m_newDisplayItems[index].asDebugString().utf8().data(), static_cast<int>(index));
 #endif
         ASSERT_NOT_REACHED();
     }
     addItemToIndexIfNeeded(displayItem, m_newDisplayItems.size() - 1, m_newDisplayItemIndicesByClient);
 #endif // ENABLE(ASSERT)
 
     if (skippingCache())
         displayItem.setSkippedCache();
+
+    m_newPaintChunks.incrementDisplayItemIndex();
+}
+
+void DisplayItemList::updateCurrentPaintProperties(const PaintProperties& newPaintProperties)
+{
+    m_newPaintChunks.updateCurrentPaintProperties(newPaintProperties);
 }
 
 void DisplayItemList::beginScope()
 {
     ASSERT_WITH_SECURITY_IMPLICATION(m_nextScope < UINT_MAX);
     m_scopeStack.append(m_nextScope++);
     beginSkippingCache();
 }
 
 void DisplayItemList::endScope()
@@ skipping 168 matching lines @@
 #if ENABLE(ASSERT)
     m_newDisplayItemIndicesByClient.clear();
 #endif
 
     if (m_currentDisplayItems.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_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());
 
     // TODO(jbroman): Consider revisiting this heuristic.
     DisplayItems updatedList(std::max(m_currentDisplayItems.usedCapacityInBytes(), m_newDisplayItems.usedCapacityInBytes()));
+    Vector<PaintChunk> updatedPaintChunks;
     DisplayItems::iterator currentIt = m_currentDisplayItems.begin();
     DisplayItems::iterator currentEnd = m_currentDisplayItems.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) {
@@ skipping 42 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)
 
+    // TODO(jbroman): When subsequence caching applies to SPv2, we'll need to
+    // merge the paint chunks as well.
+    m_currentPaintChunks = m_newPaintChunks.releasePaintChunks();
+
     m_newDisplayItems.clear();
     m_validlyCachedClientsDirty = true;
     m_currentDisplayItems.swap(updatedList);
     m_numCachedItems = 0;
 
 #if ENABLE(ASSERT)
     m_clientsWithPaintOffsetInvalidations.clear();
 #endif
 }
 
@@ skipping 184 matching lines @@
 
 void DisplayItemList::replay(GraphicsContext& context)
 {
     TRACE_EVENT0("blink,benchmark", "DisplayItemList::replay");
     ASSERT(m_newDisplayItems.isEmpty());
     for (DisplayItem& displayItem : m_currentDisplayItems)
         displayItem.replay(context);
 }
 
 } // namespace blink