Don't cache reflection drawings

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 18 matching lines @@
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintEnabled());
     ASSERT(m_newDisplayItems.isEmpty());
     return m_currentDisplayItems;
 }
 
 void DisplayItemList::add(WTF::PassOwnPtr<DisplayItem> displayItem)
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintEnabled());
     ASSERT(!m_constructionDisabled);
+    ASSERT(!skippingCache() || !displayItem->isCached());
 
     if (displayItem->isEnd()) {
         ASSERT(!m_newDisplayItems.isEmpty());
         if (m_newDisplayItems.last()->isBegin() && !m_newDisplayItems.last()->drawsContent()) {
             ASSERT(displayItem->isEndAndPairedWith(*m_newDisplayItems.last()));
             // Remove the beginning display item of this empty pair.
             m_newDisplayItems.removeLast();
 #if ENABLE(ASSERT)
             // Also remove the index pointing to the removed display item.
             DisplayItemIndicesByClientMap::iterator it = m_newDisplayItemIndicesByClient.find(displayItem->client());
@@ skipping 14 matching lines @@
     size_t index = findMatchingItemFromIndex(*displayItem, displayItem->type(), m_newDisplayItemIndicesByClient, m_newDisplayItems);
     if (index != kNotFound) {
 #ifndef NDEBUG
         showDebugData();
         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();
     }
     addItemToIndex(*displayItem, m_newDisplayItems.size(), m_newDisplayItemIndicesByClient);
-#endif
+#endif // ENABLE(ASSERT)
+

[chrishtr, 2015/06/02 20:58:37]

ASSERT(!displayItem.skippedCache());  // random code should not be setting this
bit, only DisplayItemList. ?

[Xianzhu, 2015/06/02 21:10:32]

Added the assert. It's reasonable to allow only DisplayItemList to access the
bit. Painters use DisplayItemCacheSkipper instead.

+    if (skippingCache())
+        displayItem->setSkippedCache();
 
     m_newDisplayItems.append(displayItem);
 }
 
 void DisplayItemList::beginScope(DisplayItemClient client)
 {
     ClientScopeIdMap::iterator it = m_clientScopeIdMap.find(client);
     int scopeId;
     if (it == m_clientScopeIdMap.end()) {
         m_clientScopeIdMap.add(client, 0);
@@ skipping 23 matching lines @@
     ASSERT(RuntimeEnabledFeatures::slimmingPaintEnabled());
     // Can only be called during layout/paintInvalidation, not during painting.
     ASSERT(m_newDisplayItems.isEmpty());
     m_currentDisplayItems.clear();
     m_validlyCachedClients.clear();
     m_validlyCachedClientsDirty = false;
 }
 
 bool DisplayItemList::clientCacheIsValid(DisplayItemClient client) const
 {
+    if (skippingCache())
+        return false;
     updateValidlyCachedClientsIfNeeded();
     return m_validlyCachedClients.contains(client);
 }
 
 size_t DisplayItemList::findMatchingItemFromIndex(const DisplayItem& displayItem, DisplayItem::Type matchingType, const DisplayItemIndicesByClientMap& displayItemIndicesByClient, const DisplayItems& list)
 {
     DisplayItemIndicesByClientMap::const_iterator it = displayItemIndicesByClient.find(displayItem.client());
     if (it == displayItemIndicesByClient.end())
         return kNotFound;
 
@@ skipping 61 matching lines @@
 // and the average number of (Drawing|BeginSubtree)DisplayItems per client.
 void DisplayItemList::commitNewDisplayItems()
 {
     showDebugData();
     TRACE_EVENT0("blink,benchmark", "DisplayItemList::commitNewDisplayItems");
 
     // 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.isEmpty()) {
 #if ENABLE(ASSERT)
         for (auto& item : m_newDisplayItems)
             ASSERT(!item->isCached() && !item->isSubtreeCached());
 #endif
         m_currentDisplayItems.swap(m_newDisplayItems);
@@ skipping 39 matching lines @@
                     isSynchronized = (foundIndex == currentDisplayItemsIndex);
                     updatedList.append(m_currentDisplayItems[foundIndex].release());
                 }
                 // else: do nothing because previously the client generated a empty picture which is not stored in the cache.
             }
         } else {
 #if ENABLE(ASSERT)
             if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled())
                 checkCachedDisplayItemIsUnchanged(*newDisplayItem, displayItemIndicesByClient);
             else
-                ASSERT(!newDisplayItem->isDrawing() || !clientCacheIsValid(newDisplayItem->client()));
+                ASSERT(!newDisplayItem->isDrawing() || newDisplayItem->skippedCache() || !clientCacheIsValid(newDisplayItem->client()));
 #endif // ENABLE(ASSERT)
             updatedList.append(newDisplayItem.release());
         }
 
         if (isSynchronized)
             ++currentDisplayItemsIndex;
     }
 
 #if ENABLE(ASSERT)
     if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled())
@@ skipping 12 matching lines @@
         return;
 
     m_validlyCachedClients.clear();
     m_validlyCachedClientsDirty = false;
 
     DisplayItemClient lastClient = nullptr;
     for (const auto& displayItem : m_currentDisplayItems) {
         if (displayItem->client() == lastClient)
             continue;
         lastClient = displayItem->client();
-        m_validlyCachedClients.add(lastClient);
+        if (!displayItem->skippedCache())
+            m_validlyCachedClients.add(lastClient);
     }
 }
 
 #if ENABLE(ASSERT)
 
 static void showUnderInvalidationError(const char* reason, const DisplayItem& displayItem)
 {
 #ifndef NDEBUG
     WTFLogAlways("%s: %s\nSee http://crbug.com/450725.", reason, displayItem.asDebugString().utf8().data());
 #else
@@ skipping 15 matching lines @@
     return result;
 }
 
 void DisplayItemList::checkCachedDisplayItemIsUnchanged(const DisplayItem& displayItem, DisplayItemIndicesByClientMap& displayItemIndicesByClient)
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled());
 
     if (!displayItem.isDrawing() || !clientCacheIsValid(displayItem.client()))
         return;
 
-    DrawingDisplayItem::UnderInvalidationCheckingMode mode = static_cast<const DrawingDisplayItem&>(displayItem).underInvalidationCheckingMode();
+    const DrawingDisplayItem& drawingDisplayItem = static_cast<const DrawingDisplayItem&>(displayItem);
+    if (drawingDisplayItem.skippedCache())
+        return;
+
+    DrawingDisplayItem::UnderInvalidationCheckingMode mode = drawingDisplayItem.underInvalidationCheckingMode();
     if (mode == DrawingDisplayItem::DontCheck)
         return;
 
     // If checking under-invalidation, we always generate new display item even if the client is not invalidated.
     // Checks if the new picture is the same as the cached old picture. If the new picture is different but
     // the client is not invalidated, issue error about under-invalidation.
     size_t index = findMatchingItemFromIndex(displayItem, displayItem.type(), displayItemIndicesByClient, m_currentDisplayItems);
     if (index == kNotFound) {
         showUnderInvalidationError("ERROR: under-invalidation: no cached display item", displayItem);
         ASSERT_NOT_REACHED();
         return;
     }
 
-    RefPtr<const SkPicture> newPicture = static_cast<const DrawingDisplayItem&>(displayItem).picture();
+    RefPtr<const SkPicture> newPicture = drawingDisplayItem.picture();
     RefPtr<const SkPicture> oldPicture = static_cast<const DrawingDisplayItem&>(*m_currentDisplayItems[index]).picture();
     // Remove the display item from cache so that we can check if there are any remaining cached display items after merging.
     m_currentDisplayItems[index] = nullptr;
 
     if (!newPicture && !oldPicture)
         return;
     if (newPicture && oldPicture) {
         switch (mode) {
         case DrawingDisplayItem::CheckPicture:
             if (newPicture->approximateOpCount() == oldPicture->approximateOpCount()) {
@@ skipping 85 matching lines @@
 
 void DisplayItemList::replay(GraphicsContext& context) const
 {
     TRACE_EVENT0("blink,benchmark", "DisplayItemList::replay");
     ASSERT(m_newDisplayItems.isEmpty());
     for (auto& displayItem : m_currentDisplayItems)
         displayItem->replay(context);
 }
 
 } // namespace blink