LayoutObject::invalidatePaintIfNeededForSynchronizedPainting() and plumbing

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/GraphicsLayer.h"
@@ skipping 84 matching lines @@
 }
 
 void DisplayItemList::endScope()
 {
     m_scopeStack.removeLast();
     endSkippingCache();
 }
 
 void DisplayItemList::invalidate(const DisplayItemClientWrapper& client, PaintInvalidationReason paintInvalidationReason, const IntRect& previousPaintInvalidationRect, const IntRect& newPaintInvalidationRect)
 {
-    invalidateUntracked(client.displayItemClient());
+    invalidateClient(client);
+
     if (RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled()) {
         Invalidation invalidation = { previousPaintInvalidationRect, paintInvalidationReason };
         if (!previousPaintInvalidationRect.isEmpty())
             m_invalidations.append(invalidation);
         if (newPaintInvalidationRect != previousPaintInvalidationRect && !newPaintInvalidationRect.isEmpty()) {
             invalidation.rect = newPaintInvalidationRect;
             m_invalidations.append(invalidation);
         }
     }
+}
 
+void DisplayItemList::invalidateClient(const DisplayItemClientWrapper& client)
+{
+    invalidateUntracked(client.displayItemClient());
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() && m_trackedPaintInvalidationObjects)
         m_trackedPaintInvalidationObjects->append(client.debugName());
 }
 
 void DisplayItemList::invalidateUntracked(DisplayItemClient client)
 {
-    // Can only be called during layout/paintInvalidation, not during painting.
-    ASSERT(m_newDisplayItems.isEmpty());
+    // This can be called during painting, but we can't invalidate already painted clients.
+    ASSERT(!m_newDisplayItemIndicesByClient.contains(client));
     updateValidlyCachedClientsIfNeeded();
     m_validlyCachedClients.remove(client);
 }
 
 void DisplayItemList::invalidateAll()
 {
     // Can only be called during layout/paintInvalidation, not during painting.
     ASSERT(m_newDisplayItems.isEmpty());
     m_currentDisplayItems.clear();
     m_validlyCachedClients.clear();
     m_validlyCachedClientsDirty = false;
 
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() && m_trackedPaintInvalidationObjects)
         m_trackedPaintInvalidationObjects->append("##ALL##");
 }
 
 bool DisplayItemList::clientCacheIsValid(DisplayItemClient client) const
 {
     if (skippingCache())
         return false;
     updateValidlyCachedClientsIfNeeded();
     return m_validlyCachedClients.contains(client);
 }
 
 void DisplayItemList::invalidatePaintOffset(const DisplayItemClientWrapper& client)
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintOffsetCachingEnabled());
-
-    updateValidlyCachedClientsIfNeeded();
-    m_validlyCachedClients.remove(client.displayItemClient());
-
-    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() && m_trackedPaintInvalidationObjects)
-        m_trackedPaintInvalidationObjects->append(client.debugName());
+    invalidateClient(client);
 
 #if ENABLE(ASSERT)
+    ASSERT(!paintOffsetWasInvalidated(client.displayItemClient()));
     m_clientsWithPaintOffsetInvalidations.add(client.displayItemClient());
-
-    // Ensure no phases slipped in using the old paint offset which would indicate
-    // different phases used different paint offsets, which should not happen.
-    for (const auto& item : m_newDisplayItems)
-        ASSERT(!item.isCached() || item.client() != client.displayItemClient());

[chrishtr, 2015/10/05 21:50:35]

Why remove these asserts?

[Xianzhu, 2015/10/05 22:04:16]

Now this method calls invalidateUntracked(). The assert in invalidateUntracked()
has the same purpose.

 #endif
 }
 
 #if ENABLE(ASSERT)
 bool DisplayItemList::paintOffsetWasInvalidated(DisplayItemClient client) const
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintOffsetCachingEnabled());
     return m_clientsWithPaintOffsetInvalidations.contains(client);
 }
 #endif
@@ skipping 88 matching lines @@
 //
 void DisplayItemList::commitNewDisplayItems(GraphicsLayer* graphicsLayer)
 {
     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);
 
     if (RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled()) {
         for (const auto& invalidation : m_invalidations)
             graphicsLayer->setNeedsDisplayInRect(invalidation.rect, invalidation.invalidationReason);
         m_invalidations.clear();
+        m_clientsCheckedPaintInvalidation.clear();
     }
 
     // These data structures are used during painting only.
     ASSERT(m_scopeStack.isEmpty());
     m_scopeStack.clear();
     m_nextScope = 1;
     ASSERT(!skippingCache());
 #if ENABLE(ASSERT)
     m_newDisplayItemIndicesByClient.clear();
+    m_clientsWithPaintOffsetInvalidations.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_validlyCachedClientsDirty = true;
         m_numCachedItems = 0;
@@ skipping 70 matching lines @@
 
 #if ENABLE(ASSERT)
     if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled())
         checkNoRemainingCachedDisplayItems();
 #endif // ENABLE(ASSERT)
 
     m_newDisplayItems.clear();
     m_validlyCachedClientsDirty = true;
     m_currentDisplayItems.swap(updatedList);
     m_numCachedItems = 0;
-
-#if ENABLE(ASSERT)
-    m_clientsWithPaintOffsetInvalidations.clear();
-#endif
 }
 
 size_t DisplayItemList::approximateUnsharedMemoryUsage() const
 {
     size_t memoryUsage = sizeof(*this);
 
     // Memory outside this class due to m_currentDisplayItems.
     memoryUsage += m_currentDisplayItems.memoryUsageInBytes();
 
     // TODO(jbroman): If display items begin to have significant external memory
@@ skipping 176 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