PaintChunk::id

third_party/WebKit/Source/platform/graphics/paint/PaintChunker.cpp

 // Copyright 2015 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/PaintChunker.h"
 
 #include "platform/RuntimeEnabledFeatures.h"
 
 namespace blink {
 
 PaintChunker::PaintChunker()
 {
 }
 
 PaintChunker::~PaintChunker()
 {
 }
 
-void PaintChunker::updateCurrentPaintChunkProperties(const PaintChunkProperties& properties)
+void PaintChunker::updateCurrentPaintChunkProperties(const DisplayItem::Id* chunkId, const PaintChunkProperties& properties)
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
+    m_currentChunkId = WTF::nullopt;
+    if (chunkId)
+        m_currentChunkId.emplace(*chunkId);
     m_currentProperties = properties;
 }
 
-void PaintChunker::incrementDisplayItemIndex(ItemBehavior behavior)
+void PaintChunker::incrementDisplayItemIndex(const DisplayItem& item)
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
+    ItemBehavior behavior;
+    Optional<DisplayItem::Id> newChunkId;
+    if (DisplayItem::isForeignLayerType(item.getType())) {
+        behavior = RequiresSeparateChunk;
+        // Use null chunkId if we are skipping cache, so that the chunk will not
+        // match any old chunk and will be treated as brand new.
+        if (!item.skippedCache())
+            newChunkId.emplace(item.getId());
+
+        // Clear m_currentChunkId so that any display items after the foreign layer
+        // without a new chunk id will be treated as having no id to avoid the chunk
+        // from using the same id as the chunk before the foreign layer chunk.
+        m_currentChunkId = WTF::nullopt;

[pdr., 2016/07/14 22:22:06]

For items following a foreign layer, will this lead to one PaintChunk per
display item?

[Xianzhu, 2016/07/14 23:03:24]

No. This will cause the chunk following the foreign layer not to match any
cached chunk. The chunk will be always treated as new (that is, will create a
new composited layer, and need full re-rasterization).

+    } else {
+        behavior = DefaultBehavior;
+        if (!item.skippedCache() && m_currentChunkId)

[pdr., 2016/07/14 22:22:06]

Does this mean that skipping the cache causes one PaintChunk per display item?

[Xianzhu, 2016/07/14 23:03:24]

No. Chunks will be created just as before, but they will have null id so won't
match any cached chunk. The chunk will be always treated as new (that is, will
create a new composited layer, and need full re-rasterization).

+            newChunkId.emplace(*m_currentChunkId);
+    }
+
     if (m_chunks.isEmpty()) {
-        PaintChunk newChunk(0, 1, m_currentProperties);
+        PaintChunk newChunk(0, 1, newChunkId ? &*newChunkId : nullptr, m_currentProperties);
         m_chunks.append(newChunk);
         m_chunkBehavior.append(behavior);
         return;
     }
 
     auto& lastChunk = m_chunks.last();
     bool canContinueChunk = m_currentProperties == lastChunk.properties
         && behavior != RequiresSeparateChunk
         && m_chunkBehavior.last() != RequiresSeparateChunk;
     if (canContinueChunk) {
         lastChunk.endIndex++;
         return;
     }
 
-    PaintChunk newChunk(lastChunk.endIndex, lastChunk.endIndex + 1, m_currentProperties);
+    PaintChunk newChunk(lastChunk.endIndex, lastChunk.endIndex + 1, newChunkId ? &*newChunkId : nullptr, m_currentProperties);
     m_chunks.append(newChunk);
     m_chunkBehavior.append(behavior);
 }
 
 void PaintChunker::decrementDisplayItemIndex()
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
     ASSERT(!m_chunks.isEmpty());
 
     auto& lastChunk = m_chunks.last();
     if ((lastChunk.endIndex - lastChunk.beginIndex) > 1) {
         lastChunk.endIndex--;
     } else {
         m_chunks.removeLast();
         m_chunkBehavior.removeLast();
     }
 }
 
 void PaintChunker::clear()
 {
     m_chunks.clear();
     m_chunkBehavior.clear();
+    m_currentChunkId = WTF::nullopt;
     m_currentProperties = PaintChunkProperties();
 }
 
 Vector<PaintChunk> PaintChunker::releasePaintChunks()
 {
     Vector<PaintChunk> chunks;
     chunks.swap(m_chunks);
     m_chunkBehavior.clear();
+    m_currentChunkId = WTF::nullopt;
     m_currentProperties = PaintChunkProperties();
     return chunks;
 }
 
 } // namespace blink