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

third_party/WebKit/Source/core/svg/SVGAnimationElement.cpp

 /*
  * Copyright (C) 2004, 2005 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  * Copyright (C) 2009 Cameron McCormack <cam@mcc.id.au>
  * Copyright (C) Research In Motion Limited 2010. 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
@@ skipping 42 matching lines @@
   Vector<String> parseList;
   value.split(';', true, parseList);
   unsigned last = parseList.size() - 1;
   for (unsigned i = 0; i <= last; ++i) {
     if (parseList[i].isEmpty()) {
       // Tolerate trailing ';'
       if (i < last)
         goto fail;
     } else {
       parseList[i] = parseList[i].stripWhiteSpace();
-      result.append(parseList[i]);
+      result.push_back(parseList[i]);
     }
   }
 
   return true;
 fail:
   result.clear();
   return false;
 }
 
 static bool parseKeyTimes(const String& string,
                           Vector<float>& result,
                           bool verifyOrder) {
   result.clear();
   Vector<String> parseList;
   string.split(';', true, parseList);
   for (unsigned n = 0; n < parseList.size(); ++n) {
     String timeString = parseList[n].stripWhiteSpace();
     bool ok;
     float time = timeString.toFloat(&ok);
     if (!ok || time < 0 || time > 1)
       goto fail;
     if (verifyOrder) {
       if (!n) {
         if (time)
           goto fail;
       } else if (time < result.back()) {
         goto fail;
       }
     }
-    result.append(time);
+    result.push_back(time);
   }
   return true;
 fail:
   result.clear();
   return false;
 }
 
 template <typename CharType>
 static bool parseKeySplinesInternal(const String& string,
                                     Vector<gfx::CubicBezier>& result) {
@@ skipping 18 matching lines @@
     float posD = 0;
     if (!parseNumber(ptr, end, posD, DisallowWhitespace))
       return false;
 
     skipOptionalSVGSpaces(ptr, end);
 
     if (ptr < end && *ptr == ';')
       ptr++;
     skipOptionalSVGSpaces(ptr, end);
 
-    result.append(gfx::CubicBezier(posA, posB, posC, posD));
+    result.push_back(gfx::CubicBezier(posA, posB, posC, posD));
   }
 
   return ptr == end;
 }
 
 static bool parseKeySplines(const String& string,
                             Vector<gfx::CubicBezier>& result) {
   result.clear();
   if (string.isEmpty())
     return true;
@@ skipping 193 matching lines @@
   ASSERT(valuesCount >= 1);
   if (valuesCount == 1)
     return;
 
   // FIXME, webkit.org/b/109010: m_keyTimes should not be modified in this
   // function.
   m_keyTimes.clear();
 
   Vector<float> keyTimesForPaced;
   float totalDistance = 0;
-  keyTimesForPaced.append(0);
+  keyTimesForPaced.push_back(0);
   for (unsigned n = 0; n < valuesCount - 1; ++n) {
     // Distance in any units
     float distance = calculateDistance(m_values[n], m_values[n + 1]);
     if (distance < 0)
       return;
     totalDistance += distance;
-    keyTimesForPaced.append(distance);
+    keyTimesForPaced.push_back(distance);
   }
   if (!totalDistance)
     return;
 
   // Normalize.
   for (unsigned n = 1; n < keyTimesForPaced.size() - 1; ++n)
     keyTimesForPaced[n] =
         keyTimesForPaced[n - 1] + keyTimesForPaced[n] / totalDistance;
   keyTimesForPaced[keyTimesForPaced.size() - 1] = 1;
 
@@ skipping 250 matching lines @@
         calculatePercentForSpline(percent, calculateKeyTimesIndex(percent));
   else if (animationMode == FromToAnimation || animationMode == ToAnimation)
     effectivePercent = calculatePercentForFromTo(percent);
   else
     effectivePercent = percent;
 
   calculateAnimatedValue(effectivePercent, repeatCount, resultElement);
 }
 
 }  // namespace blink