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

third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositor.cpp

 // Copyright 2015 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/compositing/PaintArtifactCompositor.h"
 
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/layer.h"
 #include "cc/layers/picture_layer.h"
 #include "cc/playback/compositing_display_item.h"
@@ skipping 65 matching lines @@
       : m_id(paintChunkId),
         m_debugName(paintChunkId.client.debugName()),
         m_ccPictureLayer(cc::PictureLayer::Create(this)) {}
 
   void SetDisplayList(scoped_refptr<cc::DisplayItemList> ccDisplayItemList) {
     m_ccDisplayItemList = std::move(ccDisplayItemList);
   }
   void SetPaintableRegion(gfx::Rect region) { m_paintableRegion = region; }
 
   void addPaintChunkDebugData(std::unique_ptr<JSONArray> json) {
-    m_paintChunkDebugData.append(std::move(json));
+    m_paintChunkDebugData.push_back(std::move(json));
   }
   void clearPaintChunkDebugData() { m_paintChunkDebugData.clear(); }
 
   // cc::ContentLayerClient
   gfx::Rect PaintableRegion() override { return m_paintableRegion; }
   scoped_refptr<cc::DisplayItemList> PaintContentsToDisplayList(
       PaintingControlSetting) override {
     return m_ccDisplayItemList;
   }
   bool FillsBoundsCompletely() const override { return false; }
@@ skipping 25 matching lines @@
   void setNeedsDisplayRect(const gfx::Rect& rect,
                            RasterInvalidationInfo* rasterInvalidationInfo) {
     m_ccPictureLayer->SetNeedsDisplayRect(rect);
 
     if (!rasterInvalidationInfo || rect.IsEmpty())
       return;
 
     RasterInvalidationTracking& tracking =
         ccLayersRasterInvalidationTrackingMap().add(m_ccPictureLayer.get());
 
-    tracking.trackedRasterInvalidations.append(*rasterInvalidationInfo);
+    tracking.trackedRasterInvalidations.push_back(*rasterInvalidationInfo);
 
     if (RuntimeEnabledFeatures::paintUnderInvalidationCheckingEnabled()) {
       // TODO(crbug.com/496260): Some antialiasing effects overflow the paint
       // invalidation rect.
       IntRect r = rasterInvalidationInfo->rect;
       r.inflate(1);
       tracking.rasterInvalidationRegionSinceLastPaint.unite(r);
     }
   }
 
@@ skipping 428 matching lines @@
       // Raster paintChunk.rasterInvalidationRects is in the space of the
       // containing transform node, so need to subtract off the layer offset.
       ccInvalidationRect.Offset(-ccCombinedBounds.OffsetFromOrigin());
       contentLayerClient->setNeedsDisplayRect(
           ccInvalidationRect,
           rasterTracking ? &rasterTracking->trackedRasterInvalidations[index]
                          : nullptr);
     }
   }
 
-  newContentLayerClients.append(std::move(contentLayerClient));
+  newContentLayerClients.push_back(std::move(contentLayerClient));
   return ccPictureLayer;
 }
 
 namespace {
 
 class PropertyTreeManager {
   WTF_MAKE_NONCOPYABLE(PropertyTreeManager);
 
  public:
   PropertyTreeManager(cc::PropertyTrees& propertyTrees, cc::Layer* rootLayer)
@@ skipping 151 matching lines @@
   cc::EffectNode& effectNode =
       *effectTree.Node(effectTree.Insert(cc::EffectNode(), kInvalidNodeId));
   DCHECK_EQ(effectNode.id, kSecondaryRootNodeId);
   effectNode.owning_layer_id = m_rootLayer->id();
   effectNode.transform_id = kRealRootNodeId;
   effectNode.clip_id = kSecondaryRootNodeId;
   effectNode.has_render_surface = true;
   m_propertyTrees.effect_id_to_index_map[effectNode.owning_layer_id] =
       effectNode.id;
 
-  m_effectStack.append(
+  m_effectStack.push_back(
       BlinkEffectAndCcIdPair{EffectPaintPropertyNode::root(), effectNode.id});
   m_rootLayer->SetEffectTreeIndex(effectNode.id);
 }
 
 void PropertyTreeManager::setupRootScrollNode() {
   cc::ScrollTree& scrollTree = m_propertyTrees.scroll_tree;
   scrollTree.clear();
   m_propertyTrees.scroll_id_to_index_map.clear();
   cc::ScrollNode& scrollNode =
       *scrollTree.Node(scrollTree.Insert(cc::ScrollNode(), kRealRootNodeId));
@@ skipping 259 matching lines @@
   // decision until later phase of the pipeline. Remove premature optimization
   // here once the work is ready.
   if (!nextEffect->filter().isEmpty() ||
       nextEffect->blendMode() != SkBlendMode::kSrcOver)
     effectNode.has_render_surface = true;
   effectNode.opacity = nextEffect->opacity();
   effectNode.filters = nextEffect->filter().asCcFilterOperations();
   effectNode.blend_mode = nextEffect->blendMode();
   m_propertyTrees.effect_id_to_index_map[effectNode.owning_layer_id] =
       effectNode.id;
-  m_effectStack.append(BlinkEffectAndCcIdPair{nextEffect, effectNode.id});
+  m_effectStack.push_back(BlinkEffectAndCcIdPair{nextEffect, effectNode.id});
 
   dummyLayer->set_property_tree_sequence_number(kPropertyTreeSequenceNumber);
   dummyLayer->SetTransformTreeIndex(kSecondaryRootNodeId);
   dummyLayer->SetClipTreeIndex(outputClipId);
   dummyLayer->SetEffectTreeIndex(effectNode.id);
   dummyLayer->SetScrollTreeIndex(kRealRootNodeId);
 }
 
 }  // namespace
 
@@ skipping 51 matching lines @@
 
   return paintChunkScreenVisualRect.intersects(pendingLayerScreenVisualRect);
 }
 
 PaintArtifactCompositor::PendingLayer::PendingLayer(
     const PaintChunk& firstPaintChunk)
     : bounds(firstPaintChunk.bounds),
       knownToBeOpaque(firstPaintChunk.knownToBeOpaque),
       backfaceHidden(firstPaintChunk.properties.backfaceHidden),
       propertyTreeState(firstPaintChunk.properties.propertyTreeState) {
-  paintChunks.append(&firstPaintChunk);
+  paintChunks.push_back(&firstPaintChunk);
 }
 
 void PaintArtifactCompositor::PendingLayer::add(
     const PaintChunk& paintChunk,
     GeometryMapper* geometryMapper) {
   DCHECK(paintChunk.properties.backfaceHidden == backfaceHidden);
-  paintChunks.append(&paintChunk);
+  paintChunks.push_back(&paintChunk);
   FloatRect mappedBounds = paintChunk.bounds;
   if (geometryMapper) {
     bool success = false;
     mappedBounds = geometryMapper->localToAncestorRect(
         mappedBounds, paintChunk.properties.propertyTreeState,
         propertyTreeState, success);
     DCHECK(success);
   }
   bounds.unite(mappedBounds);
   if (bounds.size() != paintChunks[0]->bounds.size()) {
@@ skipping 19 matching lines @@
       if (canMergeInto(paintArtifact, paintChunk, *candidatePendingLayer)) {
         candidatePendingLayer->add(paintChunk, &geometryMapper);
         createNew = false;
         break;
       }
       if (mightOverlap(paintChunk, *candidatePendingLayer, geometryMapper)) {
         break;
       }
     }
     if (createNew)
-      pendingLayers.append(PendingLayer(paintChunk));
+      pendingLayers.push_back(PendingLayer(paintChunk));
   }
 }
 
 void PaintArtifactCompositor::update(
     const PaintArtifact& paintArtifact,
     RasterInvalidationTrackingMap<const PaintChunk>* rasterChunkInvalidations,
     bool storeDebugInfo) {
 #ifndef NDEBUG
   storeDebugInfo = true;
 #endif
@@ skipping 50 matching lines @@
 
     // TODO(jbroman): This probably shouldn't be necessary, but it is still
     // queried by RenderSurfaceImpl.
     layer->Set3dSortingContextId(layerTree->property_trees()
                                      ->transform_tree.Node(transformId)
                                      ->sorting_context_id);
 
     layer->SetShouldCheckBackfaceVisibility(pendingLayer.backfaceHidden);
 
     if (m_extraDataForTestingEnabled)
-      m_extraDataForTesting->contentLayers.append(layer);
+      m_extraDataForTesting->contentLayers.push_back(layer);
   }
   m_contentLayerClients.clear();
   m_contentLayerClients.swap(newContentLayerClients);
 
   // Mark the property trees as having been rebuilt.
   layerTree->property_trees()->sequence_number = kPropertyTreeSequenceNumber;
   layerTree->property_trees()->needs_rebuild = false;
   layerTree->property_trees()->ResetCachedData();
 }
 
 #ifndef NDEBUG
 void PaintArtifactCompositor::showDebugData() {
   LOG(ERROR) << layersAsJSON(LayerTreeIncludesDebugInfo)
                     ->toPrettyJSONString()
                     .utf8()
                     .data();
 }
 #endif
 
 }  // namespace blink