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

third_party/WebKit/Source/platform/transforms/TransformOperations.cpp

 /*
  * Copyright (C) 1999 Antti Koivisto (koivisto@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 15 matching lines @@
 #include "platform/transforms/IdentityTransformOperation.h"
 #include "platform/transforms/InterpolatedTransformOperation.h"
 #include "platform/transforms/Matrix3DTransformOperation.h"
 #include "platform/transforms/RotateTransformOperation.h"
 #include <algorithm>
 
 namespace blink {
 
 TransformOperations::TransformOperations(bool makeIdentity) {
   if (makeIdentity)
-    m_operations.append(IdentityTransformOperation::create());
+    m_operations.push_back(IdentityTransformOperation::create());
 }
 
 bool TransformOperations::operator==(const TransformOperations& o) const {
   if (m_operations.size() != o.m_operations.size())
     return false;
 
   unsigned s = m_operations.size();
   for (unsigned i = 0; i < s; i++) {
     if (*m_operations[i] != *o.m_operations[i])
       return false;
@@ skipping 28 matching lines @@
   for (unsigned i = 0; i < size; i++) {
     RefPtr<TransformOperation> fromOperation =
         (i < fromSize) ? from.operations()[i].get() : 0;
     RefPtr<TransformOperation> toOperation =
         (i < toSize) ? operations()[i].get() : 0;
     RefPtr<TransformOperation> blendedOperation =
         toOperation ? toOperation->blend(fromOperation.get(), progress)
                     : (fromOperation ? fromOperation->blend(0, progress, true)
                                      : nullptr);
     if (blendedOperation)
-      result.operations().append(blendedOperation);
+      result.operations().push_back(blendedOperation);
     else {
       RefPtr<TransformOperation> identityOperation =
           IdentityTransformOperation::create();
       if (progress > 0.5)
-        result.operations().append(toOperation ? toOperation
-                                               : identityOperation);
+        result.operations().push_back(toOperation ? toOperation
+                                                  : identityOperation);
       else
-        result.operations().append(fromOperation ? fromOperation
-                                                 : identityOperation);
+        result.operations().push_back(fromOperation ? fromOperation
+                                                    : identityOperation);
     }
   }
 
   return result;
 }
 
 PassRefPtr<TransformOperation>
 TransformOperations::blendByUsingMatrixInterpolation(
     const TransformOperations& from,
     double progress) const {
@@ skipping 15 matching lines @@
                                                double progress) const {
   if (from == *this || (!from.size() && !size()))
     return *this;
 
   // If either list is empty, use blendByMatchingOperations which has special
   // logic for this case.
   if (!from.size() || !size() || from.operationsMatch(*this))
     return blendByMatchingOperations(from, progress);
 
   TransformOperations result;
-  result.operations().append(blendByUsingMatrixInterpolation(from, progress));
+  result.operations().push_back(
+      blendByUsingMatrixInterpolation(from, progress));
   return result;
 }
 
 static void findCandidatesInPlane(double px,
                                   double py,
                                   double nz,
                                   double* candidates,
                                   int* numCandidates) {
   // The angle that this point is rotated with respect to the plane nz
   double phi = atan2(px, py);
@@ skipping 283 matching lines @@
     const TransformOperations& addend) const {
   TransformOperations result;
   result.m_operations = operations();
   result.m_operations.appendVector(addend.operations());
   return result;
 }
 
 TransformOperations TransformOperations::zoom(double factor) const {
   TransformOperations result;
   for (auto& transformOperation : m_operations)
-    result.m_operations.append(transformOperation->zoom(factor));
+    result.m_operations.push_back(transformOperation->zoom(factor));
   return result;
 }
 
 }  // namespace blink