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

third_party/WebKit/Source/core/paint/PaintLayer.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights
  * reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
@@ skipping 1528 matching lines @@
     const LayoutSize& subPixelAccumulation) {
   PaintLayerFragment fragment;
   ClipRectsContext clipRectsContext(rootLayer, clipRectsCacheSlot,
                                     overlayScrollbarClipBehavior,
                                     subPixelAccumulation);
   if (respectOverflowClip == IgnoreOverflowClip)
     clipRectsContext.setIgnoreOverflowClip();
   clipper().calculateRects(clipRectsContext, dirtyRect, fragment.layerBounds,
                            fragment.backgroundRect, fragment.foregroundRect,
                            offsetFromRoot);
-  fragments.append(fragment);
+  fragments.push_back(fragment);
 }
 
 bool PaintLayer::shouldFragmentCompositedBounds(
     const PaintLayer* compositingLayer) const {
   // Composited layers may not be fragmented.
   return enclosingPaginationLayer() &&
          !compositingLayer->enclosingPaginationLayer();
 }
 
 void PaintLayer::collectFragments(
@@ skipping 125 matching lines @@
 
     // Now intersect with our pagination clip. This will typically mean we're
     // just intersecting the dirty rect with the column clip, so the column clip
     // ends up being all we apply.
     fragment.intersect(fragment.paginationClip);
 
     // TODO(mstensho): Don't add empty fragments. We've always done that in some
     // cases, but there should be no reason to do so. Either filter them out
     // here, or, even better: pass a better clip rectangle to the fragmentainer
     // iterator, so that we won't end up with empty fragments here.
-    fragments.append(fragment);
+    fragments.push_back(fragment);
   }
 }
 
 static inline LayoutRect frameVisibleRect(LayoutObject* layoutObject) {
   FrameView* frameView = layoutObject->document().view();
   if (!frameView)
     return LayoutRect();
 
   return LayoutRect(frameView->visibleContentRect());
 }
@@ skipping 1270 matching lines @@
     return scrollableArea->scrollsOverflow();
 
   return false;
 }
 
 FilterOperations PaintLayer::addReflectionToFilterOperations(
     const ComputedStyle& style) const {
   FilterOperations filterOperations = style.filter();
   if (layoutObject()->hasReflection() && layoutObject()->isBox()) {
     BoxReflection reflection = boxReflectionForPaintLayer(*this, style);
-    filterOperations.operations().append(
+    filterOperations.operations().push_back(
         BoxReflectFilterOperation::create(reflection));
   }
   return filterOperations;
 }
 
 CompositorFilterOperations
 PaintLayer::createCompositorFilterOperationsForFilter(
     const ComputedStyle& style) {
   FloatRect zoomedReferenceBox;
   if (style.filter().hasReferenceFilter())
@@ skipping 105 matching lines @@
     Vector<LayoutRect> rect;
 
     if (layoutBox() && layoutBox()->scrollsOverflow()) {
       // For scrolling layers, rects are taken to be in the space of the
       // contents.  We need to include the bounding box of the layer in the
       // space of its parent (eg. for border / scroll bars) and if it's
       // composited then the entire contents as well as they may be on another
       // composited layer. Skip reporting contents for non-composited layers as
       // they'll get projected to the same layer as the bounding box.
       if (compositingState() != NotComposited)
-        rect.append(m_scrollableArea->overflowRect());
+        rect.push_back(m_scrollableArea->overflowRect());
 
       rects.set(this, rect);
       if (const PaintLayer* parentLayer = parent()) {
         LayerHitTestRects::iterator iter = rects.find(parentLayer);
         if (iter == rects.end()) {
           rects.add(parentLayer, Vector<LayoutRect>())
-              .storedValue->value.append(physicalBoundingBox(parentLayer));
+              .storedValue->value.push_back(physicalBoundingBox(parentLayer));
         } else {
-          iter->value.append(physicalBoundingBox(parentLayer));
+          iter->value.push_back(physicalBoundingBox(parentLayer));
         }
       }
     } else {
-      rect.append(logicalBoundingBox());
+      rect.push_back(logicalBoundingBox());
       rects.set(this, rect);
     }
   }
 }
 
 void PaintLayer::setNeedsRepaint() {
   setNeedsRepaintInternal();
 
   // Do this unconditionally to ensure container chain is marked when
   // compositing status of the layer changes.
@@ skipping 87 matching lines @@
 }
 
 void showLayerTree(const blink::LayoutObject* layoutObject) {
   if (!layoutObject) {
     LOG(INFO) << "Cannot showLayerTree. Root is (nil)";
     return;
   }
   showLayerTree(layoutObject->enclosingLayer());
 }
 #endif