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

third_party/WebKit/Source/core/animation/PathInterpolationFunctions.cpp

 // Copyright 2016 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 "core/animation/PathInterpolationFunctions.h"
 
 #include "core/animation/InterpolatedSVGPathSource.h"
 #include "core/animation/InterpolationEnvironment.h"
 #include "core/animation/SVGPathSegInterpolationFunctions.h"
 #include "core/css/CSSPathValue.h"
@@ skipping 39 matching lines @@
 InterpolationValue PathInterpolationFunctions::convertValue(
     const SVGPathByteStream& byteStream) {
   SVGPathByteStreamSource pathSource(byteStream);
   size_t length = 0;
   PathCoordinates currentCoordinates;
   Vector<std::unique_ptr<InterpolableValue>> interpolablePathSegs;
   Vector<SVGPathSegType> pathSegTypes;
 
   while (pathSource.hasMoreData()) {
     const PathSegmentData segment = pathSource.parseSegment();
-    interpolablePathSegs.append(
+    interpolablePathSegs.push_back(
         SVGPathSegInterpolationFunctions::consumePathSeg(segment,
                                                          currentCoordinates));
-    pathSegTypes.append(segment.command);
+    pathSegTypes.push_back(segment.command);
     length++;
   }
 
   std::unique_ptr<InterpolableList> pathArgs = InterpolableList::create(length);
   for (size_t i = 0; i < interpolablePathSegs.size(); i++)
     pathArgs->set(i, std::move(interpolablePathSegs[i]));
 
   std::unique_ptr<InterpolableList> result =
       InterpolableList::create(PathComponentIndexCount);
   result->set(PathArgsIndex, std::move(pathArgs));
@@ skipping 37 matching lines @@
                const InterpolationValue& underlying) const final {
     return m_pathSegTypes == getPathSegTypes(underlying);
   }
 
   Vector<SVGPathSegType> m_pathSegTypes;
 };
 
 InterpolationValue PathInterpolationFunctions::maybeConvertNeutral(
     const InterpolationValue& underlying,
     InterpolationType::ConversionCheckers& conversionCheckers) {
-  conversionCheckers.append(UnderlyingPathSegTypesChecker::create(underlying));
+  conversionCheckers.push_back(
+      UnderlyingPathSegTypesChecker::create(underlying));
   std::unique_ptr<InterpolableList> result =
       InterpolableList::create(PathComponentIndexCount);
   result->set(PathArgsIndex, toInterpolableList(*underlying.interpolableValue)
                                  .get(PathArgsIndex)
                                  ->cloneAndZero());
   result->set(PathNeutralIndex, InterpolableNumber::create(1));
   return InterpolationValue(std::move(result),
                             underlying.nonInterpolableValue.get());
 }
 
@@ skipping 59 matching lines @@
   InterpolatedSVGPathSource source(
       toInterpolableList(
           *toInterpolableList(interpolableValue).get(PathArgsIndex)),
       toSVGPathNonInterpolableValue(nonInterpolableValue)->pathSegTypes());
   SVGPathByteStreamBuilder builder(*pathByteStream);
   SVGPathParser::parsePath(source, builder);
   return pathByteStream;
 }
 
 }  // namespace blink