Disable display item caching

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"
 #ifndef NDEBUG
 #include "platform/graphics/paint/DisplayItem.h"
 #include "wtf/text/StringBuilder.h"
 #include <stdio.h>
 #endif
 
 namespace blink {
 
+void DisplayItemList::beginNewPaints()
+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintEnabled());
+    ASSERT(!m_newPaints.size());
+    ASSERT(!m_doingNewPaints);
+    m_doingNewPaints = true;
+}
+
+void DisplayItemList::endNewPaints()
+{
+    ASSERT(RuntimeEnabledFeatures::slimmingPaintEnabled());
+    ASSERT(m_doingNewPaints);
+    m_doingNewPaints = false;
+    updatePaintList();
+}
+
 const PaintList& DisplayItemList::paintList()
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintEnabled());
-
-    updatePaintList();
+    ASSERT(!m_doingNewPaints);
     return m_paintList;
 }
 
 void DisplayItemList::add(WTF::PassOwnPtr<DisplayItem> displayItem)
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintEnabled());
     m_newPaints.append(displayItem);
 }
 
 void DisplayItemList::invalidate(DisplayItemClient client)
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintEnabled());
     m_cachedClients.remove(client);
 }
 
 void DisplayItemList::invalidateAll()
 {
     ASSERT(RuntimeEnabledFeatures::slimmingPaintEnabled());
     // Can only be called during layout/paintInvalidation, not during painting.
-    ASSERT(m_newPaints.isEmpty());
+    ASSERT(!m_doingNewPaints && m_newPaints.isEmpty());

[chrishtr, 2015/01/20 23:18:53]

Looks like m_doingNewPaints is only used in ASSERTs? Is it really necessary?

[Xianzhu, 2015/01/20 23:48:11]

It was to ensure beginNewPaints() and endNewPaints() are paired. beginNewPaints
and the flag seem not necessary. Removed them and keep endNewPaints() only.

     m_paintList.clear();
     m_cachedClients.clear();
 }
 
+bool DisplayItemList::clientCacheIsValid(DisplayItemClient client) const
+{
+    return RuntimeEnabledFeatures::slimmingPaintDisplayItemCacheEnabled() && m_cachedClients.contains(client);
+}
+
 PaintList::iterator DisplayItemList::findNextMatchingCachedItem(PaintList::iterator begin, const DisplayItem& displayItem)
 {
     PaintList::iterator end = m_paintList.end();
 
     if (!clientCacheIsValid(displayItem.client()))
         return end;
 
     for (PaintList::iterator it = begin; it != end; ++it) {
         DisplayItem& existing = **it;
         if (existing.idsEqual(displayItem))
@@ skipping 10 matching lines @@
     list.append(displayItem);
 }
 
 // Update the existing paintList by removing invalidated entries, updating
 // repainted ones, and appending new items.
 //
 // The algorithm is O(|existing paint list| + |newly painted list|): by using
 // the ordering implied by the existing paint list, extra treewalks are avoided.
 void DisplayItemList::updatePaintList()
 {
+    if (!RuntimeEnabledFeatures::slimmingPaintDisplayItemCacheEnabled()) {
+        m_paintList.clear();
+        m_paintList.swap(m_newPaints);
+        m_cachedClients.clear();
+        return;
+    }
+
     PaintList updatedList;
     HashSet<DisplayItemClient> newCachedClients;
 
     PaintList::iterator paintListIt = m_paintList.begin();
     PaintList::iterator paintListEnd = m_paintList.end();
 
     for (OwnPtr<DisplayItem>& newDisplayItem : m_newPaints) {
         PaintList::iterator cachedItemIt = findNextMatchingCachedItem(paintListIt, *newDisplayItem);
         if (cachedItemIt != paintListEnd) {
             // Copy all of the existing items over until we hit the matching cached item.
@@ skipping 56 matching lines @@
 #endif
 
 void DisplayItemList::replay(GraphicsContext* context)
 {
     updatePaintList();
     for (auto& displayItem : m_paintList)
         displayItem->replay(context);
 }
 
 } // namespace blink