Migrate WTF::Vector::append() to ::push_back() [part 14 of N]

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/graphics/GraphicsLayer.h"
 #include "platform/graphics/paint/DrawingDisplayItem.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "third_party/skia/include/core/SkPictureAnalyzer.h"
@@ skipping 172 matching lines @@
       if (!m_currentSubsequenceClients.isEmpty()) {
         // Mark the client shouldKeepAlive under the current subsequence.
         // The status will end when the subsequence owner is invalidated or
         // deleted.
         displayItem.client().beginShouldKeepAlive(
             m_currentSubsequenceClients.back());
       }
     }
 
     if (displayItem.getType() == DisplayItem::kSubsequence) {
-      m_currentSubsequenceClients.append(&displayItem.client());
+      m_currentSubsequenceClients.push_back(&displayItem.client());
     } else if (displayItem.getType() == DisplayItem::kEndSubsequence) {
       CHECK(m_currentSubsequenceClients.back() == &displayItem.client());
       m_currentSubsequenceClients.pop_back();
     }
   }
 #endif
 
   if (isSkippingCache())
     displayItem.setSkippedCache();
 
@@ skipping 105 matching lines @@
     return;
 
   IndicesByClientMap::iterator it =
       displayItemIndicesByClient.find(&displayItem.client());
   Vector<size_t>& indices =
       it == displayItemIndicesByClient.end()
           ? displayItemIndicesByClient
                 .add(&displayItem.client(), Vector<size_t>())
                 .storedValue->value
           : it->value;
-  indices.append(index);
+  indices.push_back(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.
   for (size_t i = m_nextItemToMatch;
        i < m_currentPaintArtifact.getDisplayItemList().size(); ++i) {
@@ skipping 186 matching lines @@
     // TODO(wkorman): Only compute and append visual rect for drawings.
     m_newDisplayItemList.appendVisualRect(
         visualRectForDisplayItem(item, offsetFromLayoutObject));
 
     if (item.isCacheable()) {
       item.client().setDisplayItemsCached(m_currentCacheGeneration);
     } else {
       if (item.client().isJustCreated())
         item.client().clearIsJustCreated();
       if (item.skippedCache())
-        skippedCacheClients.append(&item.client());
+        skippedCacheClients.push_back(&item.client());
     }
   }
 
   for (auto* client : skippedCacheClients)
     client->setDisplayItemsUncached();
 
   // The new list will not be appended to again so we can release unused memory.
   m_newDisplayItemList.shrinkToFit();
   m_currentPaintArtifact = PaintArtifact(
       std::move(m_newDisplayItemList), m_newPaintChunks.releasePaintChunks(),
@@ skipping 90 matching lines @@
 
     // Add skipped old chunks into the index.
     if (oldChunk.id) {
       auto it = m_outOfOrderChunkIndices.find(&oldChunk.id->client);
       Vector<size_t>& indices =
           it == m_outOfOrderChunkIndices.end()
               ? m_outOfOrderChunkIndices
                     .add(&oldChunk.id->client, Vector<size_t>())
                     .storedValue->value
               : it->value;
-      indices.append(m_nextChunkToMatch);
+      indices.push_back(m_nextChunkToMatch);
     }
     ++m_nextChunkToMatch;
   }
 
   // Sequential matching reaches the end. Find from the out-of-order index.
   auto it = m_outOfOrderChunkIndices.find(&newChunk.id->client);
   if (it != m_outOfOrderChunkIndices.end()) {
     for (size_t i : it->value) {
       if (newChunk.matches(oldChunks[i])) {
         generateChunkRasterInvalidationRectsComparingOldChunk(newChunk,
                                                               oldChunks[i]);
         return;
       }
     }
   }
 
   // We reach here because the chunk is new.
   addRasterInvalidationInfo(nullptr, newChunk, infiniteFloatRect);
 }
 
 void PaintController::addRasterInvalidationInfo(const DisplayItemClient* client,
                                                 PaintChunk& chunk,
                                                 const FloatRect& rect) {
-  chunk.rasterInvalidationRects.append(rect);
+  chunk.rasterInvalidationRects.push_back(rect);
   if (!m_paintChunksRasterInvalidationTrackingMap)
     return;
   RasterInvalidationInfo info;
   info.rect = enclosingIntRect(rect);
   info.client = client;
   if (client) {
     info.clientDebugName = client->debugName();
     info.reason = client->getPaintInvalidationReason();
   }
   RasterInvalidationTracking& tracking =
       m_paintChunksRasterInvalidationTrackingMap->add(&chunk);
-  tracking.trackedRasterInvalidations.append(info);
+  tracking.trackedRasterInvalidations.push_back(info);
 }
 
 void PaintController::generateChunkRasterInvalidationRectsComparingOldChunk(
     PaintChunk& newChunk,
     const PaintChunk& oldChunk) {
   DCHECK(RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
   // TODO(wangxianzhu): Handle PaintInvalidationIncremental.
   // TODO(wangxianzhu): Optimize paint offset change.
 
@@ skipping 162 matching lines @@
               0, m_newDisplayItemList.size(),
               showPictures ? (DisplayItemList::JsonOptions::ShowPictures |
                               DisplayItemList::JsonOptions::ShowClientDebugName)
                            : DisplayItemList::JsonOptions::ShowClientDebugName)
           ->toPrettyJSONString()
           .utf8()
           .data());
 }
 
 }  // namespace blink