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

third_party/WebKit/Source/core/svg/animation/SVGSMILElement.cpp

 /*
  * Copyright (C) 2008 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 250 matching lines @@
   if (!owner)
     return InsertionDone;
 
   m_timeContainer = owner->timeContainer();
   ASSERT(m_timeContainer);
   m_timeContainer->setDocumentOrderIndexesDirty();
 
   // "If no attribute is present, the default begin value (an offset-value of 0)
   // must be evaluated."
   if (!fastHasAttribute(SVGNames::beginAttr))
-    m_beginTimes.append(SMILTimeWithOrigin());
+    m_beginTimes.push_back(SMILTimeWithOrigin());
 
   if (m_isWaitingForFirstInterval)
     resolveFirstInterval();
 
   if (m_timeContainer)
     m_timeContainer->notifyIntervalsChanged();
 
   buildPendingResource();
 
   return InsertionDone;
@@ skipping 123 matching lines @@
     UseCounter::count(&document(), UseCounter::SVGSMILBeginOrEndSyncbaseValue);
     type = Condition::Syncbase;
   } else if (nameString.startsWith("accesskey(")) {
     // FIXME: accesskey() support.
     type = Condition::AccessKey;
   } else {
     UseCounter::count(&document(), UseCounter::SVGSMILBeginOrEndEventValue);
     type = Condition::EventBase;
   }
 
-  m_conditions.append(
+  m_conditions.push_back(
       Condition::create(type, beginOrEnd, baseID, nameString, offset, repeat));
 
   if (type == Condition::EventBase && beginOrEnd == End)
     m_hasEndEventConditions = true;
 
   return true;
 }
 
 void SVGSMILElement::parseBeginOrEnd(const String& parseString,
                                      BeginOrEnd beginOrEnd) {
   Vector<SMILTimeWithOrigin>& timeList =
       beginOrEnd == Begin ? m_beginTimes : m_endTimes;
   if (beginOrEnd == End)
     m_hasEndEventConditions = false;
   HashSet<SMILTime> existing;
   for (unsigned n = 0; n < timeList.size(); ++n) {
     if (!timeList[n].time().isUnresolved())
       existing.add(timeList[n].time().value());
   }
   Vector<String> splitString;
   parseString.split(';', splitString);
   for (unsigned n = 0; n < splitString.size(); ++n) {
     SMILTime value = parseClockValue(splitString[n]);
     if (value.isUnresolved())
       parseCondition(splitString[n], beginOrEnd);
     else if (!existing.contains(value.value()))
-      timeList.append(
+      timeList.push_back(
           SMILTimeWithOrigin(value, SMILTimeWithOrigin::ParserOrigin));
   }
   sortTimeList(timeList);
 }
 
 void SVGSMILElement::parseAttribute(const QualifiedName& name,
                                     const AtomicString& oldValue,
                                     const AtomicString& value) {
   if (name == SVGNames::beginAttr) {
     if (!m_conditions.isEmpty()) {
@@ skipping 254 matching lines @@
   return m_cachedMin = (result.isUnresolved() || result < 0) ? 0 : result;
 }
 
 SMILTime SVGSMILElement::simpleDuration() const {
   return std::min(dur(), SMILTime::indefinite());
 }
 
 void SVGSMILElement::addBeginTime(SMILTime eventTime,
                                   SMILTime beginTime,
                                   SMILTimeWithOrigin::Origin origin) {
-  m_beginTimes.append(SMILTimeWithOrigin(beginTime, origin));
+  m_beginTimes.push_back(SMILTimeWithOrigin(beginTime, origin));
   sortTimeList(m_beginTimes);
   beginListChanged(eventTime);
 }
 
 void SVGSMILElement::addEndTime(SMILTime eventTime,
                                 SMILTime endTime,
                                 SMILTimeWithOrigin::Origin origin) {
-  m_endTimes.append(SMILTimeWithOrigin(endTime, origin));
+  m_endTimes.push_back(SMILTimeWithOrigin(endTime, origin));
   sortTimeList(m_endTimes);
   endListChanged(eventTime);
 }
 
 inline bool compareTimes(const SMILTimeWithOrigin& left,
                          const SMILTimeWithOrigin& right) {
   return left.time() < right.time();
 }
 
 SMILTime SVGSMILElement::findInstanceTime(BeginOrEnd beginOrEnd,
@@ skipping 507 matching lines @@
     return;
   addBeginTime(elapsed, elapsed);
 }
 
 void SVGSMILElement::endedActiveInterval() {
   clearTimesWithDynamicOrigins(m_beginTimes);
   clearTimesWithDynamicOrigins(m_endTimes);
 }
 
 void SVGSMILElement::scheduleRepeatEvents(unsigned count) {
-  m_repeatEventCountList.append(count);
+  m_repeatEventCountList.push_back(count);
   scheduleEvent(EventTypeNames::repeatEvent);
   scheduleEvent(AtomicString("repeatn"));
 }
 
 void SVGSMILElement::scheduleEvent(const AtomicString& eventType) {
   TaskRunnerHelper::get(TaskType::DOMManipulation, &document())
       ->postTask(BLINK_FROM_HERE,
                  WTF::bind(&SVGSMILElement::dispatchPendingEvent,
                            wrapPersistent(this), eventType));
 }
@@ skipping 45 matching lines @@
 DEFINE_TRACE(SVGSMILElement) {
   visitor->trace(m_targetElement);
   visitor->trace(m_timeContainer);
   visitor->trace(m_conditions);
   visitor->trace(m_syncBaseDependents);
   SVGElement::trace(visitor);
   SVGTests::trace(visitor);
 }
 
 }  // namespace blink