void PaintController::checkUnderInvalidation(DisplayItemList::iterator& newIt, DisplayItemList::iterator& currentIt)
{
ASSERT(RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled());
ASSERT(newIt->isCached());
// When under-invalidation-checking is enabled, the forced painting is following the cached display item.
DisplayItem::Type nextItemType = DisplayItem::nonCachedType(newIt->type());
++newIt;
ASSERT(newIt->type() == nextItemType);
if (newIt->isDrawing()) {
checkCachedDisplayItemIsUnchanged("", *newIt, *currentIt);
return;
}
ASSERT(newIt->type() == DisplayItem::Subsequence);
#ifndef NDEBUG
CString messagePrefix = String::format("(In CachedSubsequence of %s)", newIt->clientDebugString().utf8().data()).utf8();
#else
CString messagePrefix = "(In CachedSubsequence)";
#endif
DisplayItem::Id endSubsequenceId(newIt->client(), DisplayItem::EndSubsequence, 0);
while (true) {
ASSERT(newIt != m_newDisplayItemList.end());
if (newIt->isCached())
checkUnderInvalidation(newIt, currentIt);
else
checkCachedDisplayItemIsUnchanged(messagePrefix.data(), *newIt, *currentIt);
if (endSubsequenceId.matches(*newIt))
break;
++newIt;
++currentIt;
}
}
// Update the existing display items by removing invalidated entries, updating
// repainted ones, and appending new items.
// - For CachedDisplayItem, copy the corresponding cached DrawingDisplayItem;
// - For SubtreeCachedDisplayItem, copy the cached display items between the
// corresponding BeginSubtreeDisplayItem and EndSubtreeDisplayItem (incl.);
// - Otherwise, copy the new display item.
//
// The algorithm is O(|m_currentDisplayItems| + |m_newDisplayItems|).
// Coefficients are related to the ratio of out-of-order [Subtree]CachedDisplayItems
// and the average number of (Drawing|BeginSubtree)DisplayItems per client.
//
// TODO(pdr): Implement the DisplayListDiff algorithm for SlimmingPaintV2.
void DisplayItemList::commitNewDisplayItems(DisplayListDiff*)
{
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);
// 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();
#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;
return;
}
updateValidlyCachedClientsIfNeeded();
// Stores indices to valid DrawingDisplayItems in m_currentDisplayItems that have not been matched
// by CachedDisplayItems during synchronized matching. The indexed items will be matched
// by later out-of-order CachedDisplayItems in m_newDisplayItems. This ensures that when
// out-of-order CachedDisplayItems occur, we only traverse at most once over m_currentDisplayItems
// looking for potential matches. Thus we can ensure that the algorithm runs in linear time.
OutOfOrderIndexContext outOfOrderIndexContext(m_currentDisplayItems.begin());
#if ENABLE(ASSERT)
if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled()) {
// Under-invalidation checking requires a full index of m_currentDisplayItems.
size_t i = 0;
for (const auto& item : m_currentDisplayItems) {
addItemToIndexIfNeeded(item, i, outOfOrderIndexContext.displayItemIndicesByClient);
++i;
}
}
#endif // ENABLE(ASSERT)
// TODO(jbroman): Consider revisiting this heuristic.
DisplayItems updatedList(
kMaximumDisplayItemSize,
std::max(m_currentDisplayItems.usedCapacityInBytes(), m_newDisplayItems.usedCapacityInBytes()));
DisplayItems::iterator currentIt = m_currentDisplayItems.begin();
DisplayItems::iterator currentEnd = m_currentDisplayItems.end();
for (DisplayItems::iterator newIt = m_newDisplayItems.begin(); newIt != m_newDisplayItems.end(); ++newIt) {
const DisplayItem& newDisplayItem = *newIt;
const DisplayItem::Id newDisplayItemId = newDisplayItem.nonCachedId();
bool newDisplayItemHasCachedType = newDisplayItem.type() != newDisplayItemId.type;
bool isSynchronized = currentIt != currentEnd && newDisplayItemId.matches(*currentIt);
if (newDisplayItemHasCachedType) {
ASSERT(!RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled());
ASSERT(newDisplayItem.isCached());
ASSERT(clientCacheIsValid(newDisplayItem.client()));
if (!isSynchronized) {
DisplayItems::iterator foundIt = findOutOfOrderCachedItem(currentIt, newDisplayItemId, outOfOrderIndexContext);
if (foundIt == currentEnd) {
#ifndef NDEBUG
showDebugData();
WTFLogAlways("%s not found in m_currentDisplayItems\n", newDisplayItem.asDebugString().utf8().data());
#endif
ASSERT_NOT_REACHED();
// If foundIt == currentEnd, it means that 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,
// attempt to recover rather than crashing or bailing on display of the rest of the display list.
continue;
}
ASSERT(foundIt != currentIt); // because we are in 'if (!isSynchronized)'
currentIt = foundIt;
}
if (newDisplayItem.isCachedDrawing()) {
updatedList.appendByMoving(*currentIt, currentIt->derivedSize());
++currentIt;
} else {
ASSERT(newDisplayItem.isCachedSubtree());
copyCachedSubtree(currentIt, updatedList);
ASSERT(updatedList.last().isEndSubtree());
}
} else {
#if ENABLE(ASSERT)
if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled())
checkCachedDisplayItemIsUnchanged(newDisplayItem, outOfOrderIndexContext.displayItemIndicesByClient);
else
ASSERT(!newDisplayItem.isDrawing() || newDisplayItem.skippedCache() || !clientCacheIsValid(newDisplayItem.client()));
#endif // ENABLE(ASSERT)
updatedList.appendByMoving(*newIt, newIt->derivedSize());
if (isSynchronized)
++currentIt;
}
}
#if ENABLE(ASSERT)
if (RuntimeEnabledFeatures::slimmingPaintUnderInvalidationCheckingEnabled())
checkNoRemainingCachedDisplayItems();
#endif // ENABLE(ASSERT)
m_newDisplayItems.clear();
m_validlyCachedClientsDirty = true;
m_currentDisplayItems.swap(updatedList);
m_numCachedItems = 0;
}
