PaintChunk::id

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"
 #include "third_party/skia/include/core/SkPictureAnalyzer.h"
 
 #ifndef NDEBUG
 #include "platform/graphics/LoggingCanvas.h"
 #include "wtf/text/StringBuilder.h"
 #include <stdio.h>
 #endif
 
 namespace blink {
 
-static PaintChunker::ItemBehavior behaviorOfItemType(DisplayItem::Type type)
-{
-    if (DisplayItem::isForeignLayerType(type))
-        return PaintChunker::RequiresSeparateChunk;
-    return PaintChunker::DefaultBehavior;
-}
-
 const PaintArtifact& PaintController::paintArtifact() const
 {
     DCHECK(m_newDisplayItemList.isEmpty());
     DCHECK(m_newPaintChunks.isInInitialState());
     return m_currentPaintArtifact;
 }
 
 bool PaintController::useCachedDrawingIfPossible(const DisplayItemClient& client, DisplayItem::Type type)
 {
     DCHECK(DisplayItem::isDrawingType(type));
@@ skipping 96 matching lines @@
 
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
         m_newPaintChunks.decrementDisplayItemIndex();
 }
 
 void PaintController::processNewItem(DisplayItem& displayItem)
 {
     DCHECK(!m_constructionDisabled);
 
 #if CHECK_DISPLAY_ITEM_CLIENT_ALIVENESS
-    if (!skippingCache()) {
+    if (!isSkippingCache()) {
         if (displayItem.isCacheable()) {
             // Mark the client shouldKeepAlive under this PaintController.
             // The status will end after the new display items are committed.
             displayItem.client().beginShouldKeepAlive(this);
 
             if (!m_currentSubsequenceClients.isEmpty()) {
                 // Mark the client shouldKeepAlive under the current subsequence.
                 // The status will end when the subsequence owner is invalidated or deleted.
                 displayItem.client().beginShouldKeepAlive(m_currentSubsequenceClients.last());
             }
@@ skipping 10 matching lines @@
 
 #if DCHECK_IS_ON()
     // Verify noop begin/end pairs have been removed.
     if (m_newDisplayItemList.size() >= 2 && displayItem.isEnd()) {
         const auto& beginDisplayItem = m_newDisplayItemList[m_newDisplayItemList.size() - 2];
         if (beginDisplayItem.isBegin() && beginDisplayItem.getType() != DisplayItem::Subsequence && !beginDisplayItem.drawsContent())
             DCHECK(!displayItem.isEndAndPairedWith(beginDisplayItem.getType()));
     }
 #endif
 
-    if (skippingCache())
+    if (isSkippingCache())
         displayItem.setSkippedCache();
 
 #if DCHECK_IS_ON()
     size_t index = findMatchingItemFromIndex(displayItem.getId(), m_newDisplayItemIndicesByClient, m_newDisplayItemList);
     if (index != kNotFound) {
 #ifndef NDEBUG
         showDebugData();
         WTFLogAlways("DisplayItem %s has duplicated id with previous %s (index=%d)\n",
             displayItem.asDebugString().utf8().data(), m_newDisplayItemList[index].asDebugString().utf8().data(), static_cast<int>(index));
 #endif
         NOTREACHED();
     }
     addItemToIndexIfNeeded(displayItem, m_newDisplayItemList.size() - 1, m_newDisplayItemIndicesByClient);
 #endif // DCHECK_IS_ON()
 
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
-        m_newPaintChunks.incrementDisplayItemIndex(behaviorOfItemType(displayItem.getType()));
+        m_newPaintChunks.incrementDisplayItemIndex(displayItem);
 }
 
-void PaintController::updateCurrentPaintChunkProperties(const PaintChunkProperties& newProperties)
+void PaintController::updateCurrentPaintChunkProperties(const DisplayItem::Id* id, const PaintChunkProperties& newProperties)
 {
-    m_newPaintChunks.updateCurrentPaintChunkProperties(newProperties);
+    m_newPaintChunks.updateCurrentPaintChunkProperties(id, newProperties);
 }
 
 const PaintChunkProperties& PaintController::currentPaintChunkProperties() const
 {
     return m_newPaintChunks.currentPaintChunkProperties();
 }
 
 void PaintController::invalidateAll()
 {
     // Can only be called during layout/paintInvalidation, not during painting.
     DCHECK(m_newDisplayItemList.isEmpty());
     m_currentPaintArtifact.reset();
     m_currentCacheGeneration.invalidate();
 }
 
 bool PaintController::clientCacheIsValid(const DisplayItemClient& client) const
 {
 #if CHECK_DISPLAY_ITEM_CLIENT_ALIVENESS
     CHECK(client.isAlive());
 #endif
-    if (skippingCache())
+    if (isSkippingCache())
         return false;
     return client.displayItemsAreCached(m_currentCacheGeneration);
 }
 
 size_t PaintController::findMatchingItemFromIndex(const DisplayItem::Id& id, const DisplayItemIndicesByClientMap& displayItemIndicesByClient, const DisplayItemList& list)
 {
     DisplayItemIndicesByClientMap::const_iterator it = displayItemIndicesByClient.find(&id.client);
     if (it == displayItemIndicesByClient.end())
         return kNotFound;
 
@@ skipping 117 matching lines @@
 }
 
 void PaintController::commitNewDisplayItems(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;
 
     // These data structures are used during painting only.
-    DCHECK(!skippingCache());
+    DCHECK(!isSkippingCache());
 #if DCHECK_IS_ON()
     m_newDisplayItemIndicesByClient.clear();
 #endif
 
     SkPictureGpuAnalyzer gpuAnalyzer;
 
     m_currentCacheGeneration = DisplayItemClient::CacheGenerationOrInvalidationReason::next();
     for (const auto& item : m_newDisplayItemList) {
         // No reason to continue the analysis once we have a veto.
         if (gpuAnalyzer.suitableForGpuRasterization())
@@ skipping 178 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