Rewrap comments to 80 columns in Source/platform/graphics/paint/.

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 28 matching lines @@
   DCHECK(DisplayItem::isDrawingType(type));
 
   if (displayItemConstructionIsDisabled())
     return false;
 
   if (!clientCacheIsValid(client))
     return false;
 
   if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled() &&
       isCheckingUnderInvalidation()) {
-    // We are checking under-invalidation of a subsequence enclosing this display item.
-    // Let the client continue to actually paint the display item.
+    // We are checking under-invalidation of a subsequence enclosing this
+    // display item. Let the client continue to actually paint the display item.
     return false;
   }
 
   size_t cachedItem = findCachedItem(DisplayItem::Id(client, type));
   if (cachedItem == kNotFound) {
     NOTREACHED();
     return false;
   }
 
   ++m_numCachedNewItems;
   ensureNewDisplayItemListInitialCapacity();
   if (!RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled())
     processNewItem(moveItemFromCurrentListToNewList(cachedItem));
 
   m_nextItemToMatch = cachedItem + 1;
-  // Items before m_nextItemToMatch have been copied so we don't need to index them.
+  // 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 (!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 to let the painter actually paint. We will check if the new
+    // painting is the same as the cached one.
     return false;
   }
 
   return true;
 }
 
 bool PaintController::useCachedSubsequenceIfPossible(
     const DisplayItemClient& client) {
   if (displayItemConstructionIsDisabled() || subsequenceCachingIsDisabled())
     return false;
 
   if (!clientCacheIsValid(client))
     return false;
 
   if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled() &&
       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".
+    // 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;
   }
 
   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.
+  // |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()) {
-    // Return false to let the painter actually paint, and we will check if the new painting
-    // is the same as the cached.
+    // Return false to let the painter actually paint. We will check if the new
+    // painting is the same as the cached one.
     return false;
   }
 
   return true;
 }
 
 bool PaintController::lastDisplayItemIsNoopBegin() const {
   if (m_newDisplayItemList.isEmpty())
     return false;
 
@@ skipping 43 matching lines @@
 
 #if CHECK_DISPLAY_ITEM_CLIENT_ALIVENESS
   if (!isSkippingCache()) {
     if (displayItem.isCacheable()) {
       // Mark the client shouldKeepAlive under this PaintController.
       // The status will end after the new display items are committed.
       displayItem.client().beginShouldKeepAlive(this);
 
       if (!m_currentSubsequenceClients.isEmpty()) {
         // Mark the client shouldKeepAlive under the current subsequence.
-        // The status will end when the subsequence owner is invalidated or deleted.
+        // The status will end when the subsequence owner is invalidated or
+        // deleted.
         displayItem.client().beginShouldKeepAlive(
             m_currentSubsequenceClients.last());
       }
     }
 
     if (displayItem.getType() == DisplayItem::kSubsequence) {
       m_currentSubsequenceClients.append(&displayItem.client());
     } else if (displayItem.getType() == DisplayItem::kEndSubsequence) {
       CHECK(m_currentSubsequenceClients.last() == &displayItem.client());
       m_currentSubsequenceClients.removeLast();
@@ skipping 118 matching lines @@
           ? displayItemIndicesByClient
                 .add(&displayItem.client(), Vector<size_t>())
                 .storedValue->value
           : it->value;
   indices.append(index);
 }
 
 size_t PaintController::findCachedItem(const DisplayItem::Id& id) {
   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.
+  // 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.
+    // 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
       ++m_numSequentialMatches;
 #endif
       return i;
     }
-    // We encounter a different cacheable item which also indicates we can't do sequential matching.
+    // 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
     ++m_numOutOfOrderMatches;
 #endif
@@ skipping 26 matching lines @@
 
 #ifndef NDEBUG
   showDebugData();
   LOG(ERROR) << id.client.debugName() << ":"
              << DisplayItem::typeAsDebugString(id.type);
 #endif
 
   if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled())
     CHECK(false) << "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.
+  // 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.
+// |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) {
   AutoReset<size_t> subsequenceBeginIndex(
       &m_currentCachedSubsequenceBeginIndexInNewList,
       m_newDisplayItemList.size());
   DisplayItem* cachedItem =
       &m_currentPaintArtifact.getDisplayItemList()[cachedItemIndex];
   DCHECK(cachedItem->getType() == DisplayItem::kSubsequence);
 
   if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
     DCHECK(!isCheckingUnderInvalidation());
     m_underInvalidationCheckingBegin = cachedItemIndex;
     m_underInvalidationMessagePrefix =
         "(In cached subsequence of " + cachedItem->client().debugName() + ")";
   }
 
   DisplayItem::Id endSubsequenceId(cachedItem->client(),
                                    DisplayItem::kEndSubsequence);
   Vector<PaintChunk>::const_iterator cachedChunk;
   if (RuntimeEnabledFeatures::slimmingPaintV2Enabled()) {
     cachedChunk =
         m_currentPaintArtifact.findChunkByDisplayItemIndex(cachedItemIndex);
     DCHECK(cachedChunk != m_currentPaintArtifact.paintChunks().end());
     updateCurrentPaintChunkProperties(
         cachedChunk->id ? &*cachedChunk->id : nullptr, cachedChunk->properties);
   } else {
-    // This is to avoid compilation error about uninitialized variable on Windows.
+    // Avoid uninitialized variable error 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;
@@ skipping 248 matching lines @@
        ++oldIndex) {
     const DisplayItem& oldItem =
         m_currentPaintArtifact.getDisplayItemList()[oldIndex];
     const DisplayItemClient* clientToInvalidate = nullptr;
     bool isPotentiallyInvalidClient = false;
     if (!oldItem.hasValidClient()) {
       size_t movedToIndex = m_itemsMovedIntoNewList[oldIndex];
       if (m_newDisplayItemList[movedToIndex].drawsContent()) {
         if (movedToIndex < newChunk.beginIndex ||
             movedToIndex >= newChunk.endIndex) {
-          // The item has been moved into another chunk, so need to invalidate it in the old chunk.
+          // The item has been moved into another chunk, so need to invalidate
+          // it in the old chunk.
           clientToInvalidate = &m_newDisplayItemList[movedToIndex].client();
           // And invalidate in the new chunk into which the item was moved.
           PaintChunk& movedToChunk =
               m_newPaintChunks.findChunkByDisplayItemIndex(movedToIndex);
           addRasterInvalidationInfo(
               clientToInvalidate, movedToChunk,
               FloatRect(clientToInvalidate->visualRect()));
         } else if (movedToIndex < highestMovedToIndex) {
-          // The item has been moved behind other cached items, so need to invalidate the area
-          // that is probably exposed by the item moved earlier.
+          // The item has been moved behind other cached items, so need to
+          // invalidate the area that is probably exposed by the item moved
+          // earlier.
           clientToInvalidate = &m_newDisplayItemList[movedToIndex].client();
         } else {
           highestMovedToIndex = movedToIndex;
         }
       }
     } else if (oldItem.drawsContent()) {
       isPotentiallyInvalidClient = true;
       clientToInvalidate = &oldItem.client();
     }
     if (clientToInvalidate &&
@@ skipping 59 matching lines @@
   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) {
     if (newItem.isBegin()) {
-      // Temporarily skip mismatching begin display item which may be removed when we remove a no-op pair.
+      // Temporarily skip mismatching begin display item which may be removed
+      // when we remove a no-op pair.
       ++m_skippedProbableUnderInvalidationCount;
       return;
     }
     if (newItem.isDrawing() && m_skippedProbableUnderInvalidationCount == 1) {
       DCHECK_GE(m_newDisplayItemList.size(), 2u);
       if (m_newDisplayItemList[m_newDisplayItemList.size() - 2].getType() ==
           DisplayItem::kBeginCompositing) {
-        // This might be a drawing item between a pair of begin/end compositing display items that will be folded
-        // into a single drawing display item.
+        // This might be a drawing item between a pair of begin/end compositing
+        // display items that will be folded into a single drawing display item.
         ++m_skippedProbableUnderInvalidationCount;
         return;
       }
     }
   }
 
   if (m_skippedProbableUnderInvalidationCount || !oldAndNewEqual) {
-    // If we ever skipped reporting any under-invalidations, report the earliest one.
+    // 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);
   }
 
-  // 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.
+  // 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();
   moveItemFromCurrentListToNewList(oldItemIndex);
 
   ++m_underInvalidationCheckingBegin;
 }
 
 String PaintController::displayItemListAsDebugString(
     const DisplayItemList& list,
     bool showPictures) 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: %zu, ", i));
 #ifndef NDEBUG
     displayItem.dumpPropertiesAsDebugString(stringBuilder);
 #endif
 
     if (displayItem.hasValidClient()) {
 #if CHECK_DISPLAY_ITEM_CLIENT_ALIVENESS
       if (!displayItem.client().isAlive()) {
         stringBuilder.append(", clientIsAlive: false");
       } else {
 #else
-      // debugName() and clientCacheIsValid() can only be called on alive client, so only output it for
-      // m_newDisplayItemList in which we are sure the clients are all alive.
+      // debugName() and clientCacheIsValid() can only be called on a live
+      // client, so only output it for m_newDisplayItemList, in which we are
+      // sure the clients are all alive.
       if (&list == &m_newDisplayItemList) {
 #endif
 #ifdef NDEBUG
         stringBuilder.append(
             String::format("clientDebugName: \"%s\"",
                            displayItem.client().debugName().ascii().data()));
 #endif
         stringBuilder.append(", cacheIsValid: ");
         stringBuilder.append(
             clientCacheIsValid(displayItem.client()) ? "true" : "false");
@@ skipping 25 matching lines @@
                    m_currentPaintArtifact.getDisplayItemList(), showPictures)
                    .utf8()
                    .data());
   WTFLogAlways("new display item list: [%s]\n",
                displayItemListAsDebugString(m_newDisplayItemList, showPictures)
                    .utf8()
                    .data());
 }
 
 }  // namespace blink