Revert of Reland Compile under-invalidation checking in all builds

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"
@@ skipping 16 matching lines @@
 bool PaintController::useCachedDrawingIfPossible(const DisplayItemClient& client, DisplayItem::Type type)
 {
     DCHECK(DisplayItem::isDrawingType(type));
 
     if (displayItemConstructionIsDisabled())
         return false;
 
     if (!clientCacheIsValid(client))
         return false;
 
-    if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled() && isCheckingUnderInvalidation()) {
+#if DCHECK_IS_ON()
+    if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled() && isCheckingUnderInvalidation()) {
         // We are checking under-invalidation of a subsequence enclosing this display item.
         // Let the client continue to actually paint the display item.
         return false;
     }
+#endif
 
     size_t cachedItem = findCachedItem(DisplayItem::Id(client, type));
     if (cachedItem == kNotFound) {
         NOTREACHED();
         return false;
     }
 
     ++m_numCachedNewItems;
     ensureNewDisplayItemListInitialCapacity();
-    if (!RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled())
+    if (!DCHECK_IS_ON() || !RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled())
         processNewItem(m_newDisplayItemList.appendByMoving(m_currentPaintArtifact.getDisplayItemList()[cachedItem]), FromCachedItem);
 
     m_nextItemToMatch = cachedItem + 1;
     // Items before m_nextItemToMatch have been copied so we don't need to index them.
     if (m_nextItemToMatch > m_nextItemToIndex)
         m_nextItemToIndex = m_nextItemToMatch;
 
-    if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
+#if DCHECK_IS_ON()
+    if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled()) {
         if (!isCheckingUnderInvalidation()) {
             m_underInvalidationCheckingBegin = cachedItem;
             m_underInvalidationCheckingEnd = cachedItem + 1;
             m_underInvalidationMessagePrefix = "";
         }
         // Return false to let the painter actually paint, and we will check if the new painting
         // is the same as the cached.
         return false;
     }
+#endif
 
     return true;
 }
 
 bool PaintController::useCachedSubsequenceIfPossible(const DisplayItemClient& client)
 {
     if (displayItemConstructionIsDisabled() || subsequenceCachingIsDisabled())
         return false;
 
     if (!clientCacheIsValid(client))
         return false;
 
-    if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled() && isCheckingUnderInvalidation()) {
+#if DCHECK_IS_ON()
+    if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled() && isCheckingUnderInvalidation()) {
         // We are checking under-invalidation of an ancestor subsequence enclosing this one.
         // The ancestor subsequence is supposed to have already "copied", so we should let the
         // client continue to actually paint the descendant subsequences without "copying".
         return false;
     }
+#endif
 
     size_t cachedItem = findCachedItem(DisplayItem::Id(client, DisplayItem::kSubsequence));
     if (cachedItem == kNotFound) {
         NOTREACHED();
         return false;
     }
 
     // |cachedItem| will point to the first item after the subsequence or end of the current list.
     ensureNewDisplayItemListInitialCapacity();
     copyCachedSubsequence(cachedItem);
 
     m_nextItemToMatch = cachedItem;
     // Items before |cachedItem| have been copied so we don't need to index them.
     if (cachedItem > m_nextItemToIndex)
         m_nextItemToIndex = cachedItem;
 
-    if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
+#if DCHECK_IS_ON()
+    if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled()) {
         // Return false to let the painter actually paint, and we will check if the new painting
         // is the same as the cached.
         return false;
     }
+#endif
 
     return true;
 }
 
 bool PaintController::lastDisplayItemIsNoopBegin() const
 {
     if (m_newDisplayItemList.isEmpty())
         return false;
 
     const auto& lastDisplayItem = m_newDisplayItemList.last();
     return lastDisplayItem.isBegin() && !lastDisplayItem.drawsContent();
 }
 
 void PaintController::removeLastDisplayItem()
 {
     if (m_newDisplayItemList.isEmpty())
         return;
 
 #if DCHECK_IS_ON()
     // Also remove the index pointing to the removed display item.
     IndicesByClientMap::iterator it = m_newDisplayItemIndicesByClient.find(&m_newDisplayItemList.last().client());
     if (it != m_newDisplayItemIndicesByClient.end()) {
         Vector<size_t>& indices = it->value;
         if (!indices.isEmpty() && indices.last() == (m_newDisplayItemList.size() - 1))
             indices.removeLast();
     }
-#endif
 
-    if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled() && isCheckingUnderInvalidation()) {
+    if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled() && isCheckingUnderInvalidation()) {
         if (m_skippedProbableUnderInvalidationCount) {
             --m_skippedProbableUnderInvalidationCount;
         } else {
             DCHECK(m_underInvalidationCheckingBegin);
             --m_underInvalidationCheckingBegin;
         }
     }
+#endif
     m_newDisplayItemList.removeLast();
 
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
         m_newPaintChunks.decrementDisplayItemIndex();
 }
 
 const DisplayItem* PaintController::lastDisplayItem(unsigned offset)
 {
     if (offset < m_newDisplayItemList.size())
         return &m_newDisplayItemList[m_newDisplayItemList.size() - offset - 1];
@@ skipping 56 matching lines @@
     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);
+
+    if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled())
+        checkUnderInvalidation();
 #endif // DCHECK_IS_ON()
-
-    if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled())
-        checkUnderInvalidation();
 }
 
 void PaintController::updateCurrentPaintChunkProperties(const PaintChunk::Id* id, const PaintChunkProperties& newProperties)
 {
     m_newPaintChunks.updateCurrentPaintChunkProperties(id, newProperties);
 }
 
 const PaintChunkProperties& PaintController::currentPaintChunkProperties() const
 {
     return m_newPaintChunks.currentPaintChunkProperties();
@@ skipping 50 matching lines @@
     DCHECK(clientCacheIsValid(id.client));
 
     // Try to find the item sequentially first. This is fast if the current list and the new list are in
     // the same order around the new item. If found, we don't need to update and lookup the index.
     for (size_t i = m_nextItemToMatch; i < m_currentPaintArtifact.getDisplayItemList().size(); ++i) {
         // We encounter an item that has already been copied which indicates we can't do sequential matching.
         const DisplayItem& item = m_currentPaintArtifact.getDisplayItemList()[i];
         if (!item.hasValidClient())
             break;
         if (id == item.getId()) {
-#ifndef NDEBUG
+#if DCHECK_IS_ON()
             ++m_numSequentialMatches;
 #endif
             return i;
         }
         // We encounter a different cacheable item which also indicates we can't do sequential matching.
         if (item.isCacheable())
             break;
     }
 
     size_t foundIndex = findMatchingItemFromIndex(id, m_outOfOrderItemIndices, m_currentPaintArtifact.getDisplayItemList());
     if (foundIndex != kNotFound) {
-#ifndef NDEBUG
+#if DCHECK_IS_ON()
         ++m_numOutOfOrderMatches;
 #endif
         return foundIndex;
     }
 
     return findOutOfOrderCachedItemForward(id);
 }
 
 // Find forward for the item and index all skipped indexable items.
 size_t PaintController::findOutOfOrderCachedItemForward(const DisplayItem::Id& id)
 {
     for (size_t i = m_nextItemToIndex; i < m_currentPaintArtifact.getDisplayItemList().size(); ++i) {
         const DisplayItem& item = m_currentPaintArtifact.getDisplayItemList()[i];
         DCHECK(item.hasValidClient());
         if (id == item.getId()) {
-#ifndef NDEBUG
+#if DCHECK_IS_ON()
             ++m_numSequentialMatches;
 #endif
             return i;
         }
         if (item.isCacheable()) {
-#ifndef NDEBUG
+#if DCHECK_IS_ON()
             ++m_numIndexedItems;
 #endif
             addItemToIndexIfNeeded(item, i, m_outOfOrderItemIndices);
         }
     }
 
 #ifndef NDEBUG
     showDebugData();
     LOG(ERROR) << id.client.debugName() << ":" << DisplayItem::typeAsDebugString(id.type);
 #endif
-
-    if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled())
-        CHECK(false) << "Can't find cached display item";
-
+    NOTREACHED() << "Can't find cached display item";
     // We did not find the cached display item. This should be impossible, but may occur if there is a bug
     // in the system, such as under-invalidation, incorrect cache checking or duplicate display ids.
     // In this case, the caller should fall back to repaint the display item.
     return kNotFound;
 }
 
 // Copies a cached subsequence from current list to the new list. On return,
 // |cachedItemIndex| points to the item after the EndSubsequence item of the subsequence.
 // When paintUnderInvaldiationCheckingEnabled() we'll not actually copy the subsequence,
 // but mark the begin and end of the subsequence for under-invalidation checking.
 void PaintController::copyCachedSubsequence(size_t& cachedItemIndex)
 {
     DisplayItem* cachedItem = &m_currentPaintArtifact.getDisplayItemList()[cachedItemIndex];
+#if DCHECK_IS_ON()
     DCHECK(cachedItem->getType() == DisplayItem::kSubsequence);
-
-    if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
+    if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled()) {
         DCHECK(!isCheckingUnderInvalidation());
         m_underInvalidationCheckingBegin = cachedItemIndex;
         m_underInvalidationMessagePrefix = "(In cached subsequence of " + cachedItem->client().debugName() + ")";
     }
+#endif
 
     DisplayItem::Id endSubsequenceId(cachedItem->client(), DisplayItem::kEndSubsequence);
     Vector<PaintChunk>::const_iterator cachedChunk;
     if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
         cachedChunk = m_currentPaintArtifact.findChunkByDisplayItemIndex(cachedItemIndex);
         updateCurrentPaintChunkProperties(cachedChunk->id ? &*cachedChunk->id : nullptr, cachedChunk->properties);
     } else {
         // This is to avoid compilation error about uninitialized variable on Windows.
         cachedChunk = m_currentPaintArtifact.paintChunks().begin();
     }
 
     while (true) {
         DCHECK(cachedItem->hasValidClient());
 #if CHECK_DISPLAY_ITEM_CLIENT_ALIVENESS
         CHECK(cachedItem->client().isAlive());
 #endif
         ++m_numCachedNewItems;
         bool metEndSubsequence = cachedItem->getId() == endSubsequenceId;
-        if (!RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
+        if (!DCHECK_IS_ON() || !RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled()) {
             if (RuntimeEnabledFeatures::slimmingPaintV2Enabled() && cachedItemIndex == cachedChunk->endIndex) {
                 ++cachedChunk;
                 updateCurrentPaintChunkProperties(cachedChunk->id ? &*cachedChunk->id : nullptr, cachedChunk->properties);
             }
             processNewItem(m_newDisplayItemList.appendByMoving(*cachedItem), FromCachedSubsequence);
             if (RuntimeEnabledFeatures::slimmingPaintV2Enabled())
                 DCHECK((!m_newPaintChunks.lastChunk().id && !cachedChunk->id) || m_newPaintChunks.lastChunk().matches(*cachedChunk));
         }
 
         ++cachedItemIndex;
         if (metEndSubsequence)
             break;
 
         // We should always be able to find the EndSubsequence display item.
         DCHECK(cachedItemIndex < m_currentPaintArtifact.getDisplayItemList().size());
         cachedItem = &m_currentPaintArtifact.getDisplayItemList()[cachedItemIndex];
     }
 
-    if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
+#if DCHECK_IS_ON()
+    if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled()) {
         m_underInvalidationCheckingEnd = cachedItemIndex;
         DCHECK(isCheckingUnderInvalidation());
     }
+#endif
 }
 
 static IntRect visualRectForDisplayItem(const DisplayItem& displayItem, const LayoutSize& offsetFromLayoutObject)
 {
     LayoutRect visualRect = displayItem.client().visualRect();
     visualRect.move(-offsetFromLayoutObject);
     return enclosingIntRect(visualRect);
 }
 
 void PaintController::resetCurrentListIndices()
 {
     m_nextItemToMatch = 0;
     m_nextItemToIndex = 0;
     m_nextChunkToMatch = 0;
+#if DCHECK_IS_ON()
     m_underInvalidationCheckingBegin = 0;
     m_underInvalidationCheckingEnd = 0;
     m_skippedProbableUnderInvalidationCount = 0;
+#endif
 }
 
 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.
@@ skipping 45 matching lines @@
     }
 
     // We'll allocate the initial buffer when we start the next paint.
     m_newDisplayItemList = DisplayItemList(0);
 
 #if CHECK_DISPLAY_ITEM_CLIENT_ALIVENESS
     CHECK(m_currentSubsequenceClients.isEmpty());
     DisplayItemClient::endShouldKeepAliveAllClients(this);
 #endif
 
-#ifndef NDEBUG
+#if DCHECK_IS_ON()
     m_numSequentialMatches = 0;
     m_numOutOfOrderMatches = 0;
     m_numIndexedItems = 0;
 #endif
 }
 
 size_t PaintController::approximateUnsharedMemoryUsage() const
 {
     size_t memoryUsage = sizeof(*this);
 
@@ skipping 100 matching lines @@
                 if (newChunkClients.add(&newItem.client()).isNewEntry)
                     newChunk.rasterInvalidationRects.append(newItem.client().visualRect());
             } else {
                 // The cached item was moved from the old chunk which should not contain any item of the client now.
                 DCHECK(!oldChunkClients.contains(&newItem.client()));
             }
         }
     }
 }
 
+#if DCHECK_IS_ON()
+
 void PaintController::showUnderInvalidationError(const char* reason, const DisplayItem& newItem, const DisplayItem* oldItem) const
 {
     LOG(ERROR) << m_underInvalidationMessagePrefix << " " << reason;
 #ifndef NDEBUG
     LOG(ERROR) << "New display item: " << newItem.asDebugString();
     LOG(ERROR) << "Old display item: " << (oldItem ? oldItem->asDebugString() : "None");
 #else
     LOG(ERROR) << "Run debug build to get more details.";
 #endif
     LOG(ERROR) << "See http://crbug.com/619103.";
 
 #ifndef NDEBUG
     const SkPicture* newPicture = newItem.isDrawing() ? static_cast<const DrawingDisplayItem&>(newItem).picture() : nullptr;
     const SkPicture* oldPicture = oldItem && oldItem->isDrawing() ? static_cast<const DrawingDisplayItem*>(oldItem)->picture() : nullptr;
     LOG(INFO) << "new picture:\n" << (newPicture ? pictureAsDebugString(newPicture) : "None");
     LOG(INFO) << "old picture:\n" << (oldPicture ? pictureAsDebugString(oldPicture) : "None");
 
     showDebugData();
 #endif // NDEBUG
 }
 
 void PaintController::checkUnderInvalidation()
 {
-    DCHECK(RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled());
+    DCHECK(RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled());
 
     if (!isCheckingUnderInvalidation())
         return;
 
     const DisplayItem& newItem = m_newDisplayItemList.last();
     size_t oldItemIndex = m_underInvalidationCheckingBegin + m_skippedProbableUnderInvalidationCount;
     DisplayItem* oldItem = oldItemIndex < m_currentPaintArtifact.getDisplayItemList().size() ? &m_currentPaintArtifact.getDisplayItemList()[oldItemIndex] : nullptr;
 
     bool oldAndNewEqual = oldItem && newItem.equals(*oldItem);
     if (!oldAndNewEqual) {
@@ skipping 11 matching lines @@
                 return;
             }
         }
     }
 
     if (m_skippedProbableUnderInvalidationCount || !oldAndNewEqual) {
         // If we ever skipped reporting any under-invalidations, report the earliest one.
         showUnderInvalidationError("under-invalidation: display item changed",
             m_newDisplayItemList[m_newDisplayItemList.size() - m_skippedProbableUnderInvalidationCount - 1],
             &m_currentPaintArtifact.getDisplayItemList()[m_underInvalidationCheckingBegin]);
-        CHECK(false);
+        NOTREACHED();
     }
 
     // Discard the forced repainted display item and move the cached item into m_newDisplayItemList.
     // This is to align with the non-under-invalidation-checking path to empty the original cached slot,
     // leaving only disappeared or invalidated display items in the old list after painting.
     m_newDisplayItemList.removeLast();
     m_newDisplayItemList.appendByMoving(*oldItem);
 
     ++m_underInvalidationCheckingBegin;
 }
 
+#endif // DCHECK_IS_ON()
+
 String PaintController::displayItemListAsDebugString(const DisplayItemList& list) const
 {
     StringBuilder stringBuilder;
     size_t i = 0;
     for (auto it = list.begin(); it != list.end(); ++it, ++i) {
         const DisplayItem& displayItem = *it;
         if (i)
             stringBuilder.append(",\n");
         stringBuilder.append(String::format("{index: %d, ", (int)i));
 #ifndef NDEBUG
@@ skipping 24 matching lines @@
     return stringBuilder.toString();
 }
 
 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());
 }
 
 } // namespace blink