Let synchronized painting generate correct paint invalidation rects

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 "config.h"
 #include "platform/graphics/paint/PaintController.h"
 
 #include "platform/NotImplemented.h"
 #include "platform/TraceEvent.h"
 #include "platform/graphics/GraphicsLayer.h"
@@ skipping 94 matching lines @@
     m_scopeStack.append(m_nextScope++);
     beginSkippingCache();
 }
 
 void PaintController::endScope()
 {
     m_scopeStack.removeLast();
     endSkippingCache();
 }
 
-void PaintController::invalidate(const DisplayItemClientWrapper& client, PaintInvalidationReason paintInvalidationReason, const IntRect& previousPaintInvalidationRect, const IntRect& newPaintInvalidationRect)
+void PaintController::invalidate(const DisplayItemClientWrapper& client, PaintInvalidationReason paintInvalidationReason, const IntRect* visualRect)
 {
     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);
-        }
+    if (visualRect) {
+        // TODO(wkorman): cache visualRect for the client.
     }
 }
 
 void PaintController::invalidateClient(const DisplayItemClientWrapper& client)
 {
+#if ENABLE(ASSERT)
+    m_invalidations.append(client.debugName());
+#endif
+
     invalidateUntracked(client.displayItemClient());
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() && m_trackedPaintInvalidationObjects)
         m_trackedPaintInvalidationObjects->append(client.debugName());
 }
 
 void PaintController::invalidateUntracked(DisplayItemClient client)
 {
     // This can be called during painting, but we can't invalidate already painted clients.
     ASSERT(!m_newDisplayItemIndicesByClient.contains(client));
     updateValidlyCachedClientsIfNeeded();
@@ skipping 120 matching lines @@
 // repainted ones, and appending new items.
 // - For cached drawing display item, copy the corresponding cached DrawingDisplayItem;
 // - For cached subsequence display item, copy the cached display items between the
 //   corresponding SubsequenceDisplayItem and EndSubsequenceDisplayItem (incl.);
 // - Otherwise, copy the new display item.
 //
 // The algorithm is O(|m_currentDisplayItemList| + |m_newDisplayItemList|).
 // Coefficients are related to the ratio of out-of-order CachedDisplayItems
 // and the average number of (Drawing|Subsequence)DisplayItems per client.
 //
-void PaintController::commitNewDisplayItems(GraphicsLayer* graphicsLayer)
+void PaintController::commitNewDisplayItems()
 {
     TRACE_EVENT2("blink,benchmark", "PaintController::commitNewDisplayItems",
         "current_display_list_size", (int)m_currentPaintArtifact.displayItemList().size(),
         "num_non_cached_new_items", (int)m_newDisplayItemList.size() - m_numCachedItems);
 
-    if (RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled()) {
-        if (!m_newDisplayItemList.isEmpty() && m_newDisplayItemList.last().type() == DisplayItem::CachedDisplayItemList) {
-            // The whole display item list is cached.
-            ASSERT(m_newDisplayItemList.size() == 1
-                || (m_newDisplayItemList.size() == 2 && m_newDisplayItemList[0].type() == DisplayItem::DebugRedFill));
-            ASSERT(m_invalidations.isEmpty());
-            ASSERT(m_clientsCheckedPaintInvalidation.isEmpty());
-            m_newDisplayItemList.clear();
-            m_newPaintChunks.clear();
-            return;
-        }
-        for (const auto& invalidation : m_invalidations)
-            graphicsLayer->setNeedsDisplayInRect(invalidation.rect, invalidation.invalidationReason);
-        m_invalidations.clear();
+    if (RuntimeEnabledFeatures::slimmingPaintSynchronizedPaintingEnabled()
+        && !m_newDisplayItemList.isEmpty()
+        && m_newDisplayItemList.last().type() == DisplayItem::CachedDisplayItemList) {
+        // The whole display item list is cached.
+        ASSERT(m_newDisplayItemList.size() == 1
+            || (m_newDisplayItemList.size() == 2 && m_newDisplayItemList[0].type() == DisplayItem::DebugRedFill));
+        ASSERT(m_invalidations.isEmpty());
+        ASSERT(m_clientsCheckedPaintInvalidation.isEmpty());
+        m_newDisplayItemList.clear();
+        m_newPaintChunks.clear();
+        return;
+    }
+    if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
         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();
+    m_invalidations.clear();
 #endif
 
     if (m_currentPaintArtifact.isEmpty()) {
 #if ENABLE(ASSERT)
         for (const auto& item : m_newDisplayItemList)
             ASSERT(!item.isCached());
 #endif
         m_currentPaintArtifact.displayItemList().swap(m_newDisplayItemList);
         m_currentPaintArtifact.paintChunks() = m_newPaintChunks.releasePaintChunks();
         m_validlyCachedClientsDirty = true;
@@ skipping 252 matching lines @@
 
 void PaintController::showDebugData() const
 {
     WTFLogAlways("current display item list: [%s]\n", displayItemListAsDebugString(m_currentPaintArtifact.displayItemList()).utf8().data());
     WTFLogAlways("new display item list: [%s]\n", displayItemListAsDebugString(m_newDisplayItemList).utf8().data());
 }
 
 #endif // ifndef NDEBUG
 
 } // namespace blink