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

third_party/WebKit/Source/core/animation/css/CSSAnimations.cpp

 /*
  * Copyright (C) 2013 Google 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 101 matching lines @@
         } else {
           DCHECK(value.isCSSWideKeyword());
           timingFunction = CSSTimingData::initialTimingFunction();
         }
         keyframe->setEasing(timingFunction.release());
       } else if (!CSSAnimations::isAnimationAffectingProperty(property)) {
         keyframe->setCSSPropertyValue(property,
                                       properties.propertyAt(j).value());
       }
     }
-    keyframes.append(keyframe);
+    keyframes.push_back(keyframe);
     // The last keyframe specified at a given offset is used.
     for (size_t j = 1; j < offsets.size(); ++j) {
-      keyframes.append(
+      keyframes.push_back(
           toStringKeyframe(keyframe->cloneWithOffset(offsets[j]).get()));
     }
   }
 
   DEFINE_STATIC_LOCAL(SparseHistogram, propertyHistogram,
                       ("WebCore.Animation.CSSProperties"));
   for (CSSPropertyID property : specifiedPropertiesForUseCounter) {
     DCHECK(isValidCSSPropertyID(property));
     propertyHistogram.sample(
         UseCounter::mapCSSPropertyIdToCSSSampleIdForHistogram(property));
@@ skipping 23 matching lines @@
     startKeyframe = StringKeyframe::create();
     startKeyframe->setOffset(0);
     startKeyframe->setEasing(defaultTimingFunction);
     keyframes.prepend(startKeyframe);
   }
   RefPtr<StringKeyframe> endKeyframe = keyframes[keyframes.size() - 1];
   if (endKeyframe->offset() != 1) {
     endKeyframe = StringKeyframe::create();
     endKeyframe->setOffset(1);
     endKeyframe->setEasing(defaultTimingFunction);
-    keyframes.append(endKeyframe);
+    keyframes.push_back(endKeyframe);
   }
   DCHECK_GE(keyframes.size(), 2U);
   DCHECK(!keyframes.front()->offset());
   DCHECK_EQ(keyframes.back()->offset(), 1);
 
   // This is used for use counting neutral keyframes running on the compositor.
   PropertySet allProperties;
   for (const auto& keyframe : keyframes) {
     for (const auto& property : keyframe->properties())
       allProperties.add(property.cssProperty());
@@ skipping 334 matching lines @@
         new AnimationEventDelegate(element, entry.name);
     KeyframeEffect* effect = KeyframeEffect::create(
         element, inertAnimation->model(), inertAnimation->specifiedTiming(),
         KeyframeEffectReadOnly::DefaultPriority, eventDelegate);
     Animation* animation = element->document().timeline().play(effect);
     animation->setId(entry.name);
     if (inertAnimation->paused())
       animation->pause();
     animation->update(TimingUpdateOnDemand);
 
-    m_runningAnimations.append(new RunningAnimation(animation, entry));
+    m_runningAnimations.push_back(new RunningAnimation(animation, entry));
   }
 
   // Transitions that are run on the compositor only update main-thread state
   // lazily. However, we need the new state to know what the from state shoud
   // be when transitions are retargeted. Instead of triggering complete style
   // recalculation, we find these cases by searching for new transitions that
   // have matching cancelled animation property IDs on the compositor.
   HeapHashMap<CSSPropertyID, std::pair<Member<KeyframeEffectReadOnly>, double>>
       retargetedCompositorTransitions;
   for (CSSPropertyID id : m_pendingUpdate.cancelledTransitions()) {
@@ skipping 56 matching lines @@
           isNull(oldStartTime)
               ? 0
               : element->document().timeline().currentTimeInternal() -
                     oldStartTime;
 
       AnimatableValueKeyframeEffectModel* oldEffect =
           toAnimatableValueKeyframeEffectModel(inertAnimation->model());
       const KeyframeVector& frames = oldEffect->getFrames();
 
       AnimatableValueKeyframeVector newFrames;
-      newFrames.append(toAnimatableValueKeyframe(frames[0]->clone().get()));
-      newFrames.append(toAnimatableValueKeyframe(frames[1]->clone().get()));
-      newFrames.append(toAnimatableValueKeyframe(frames[2]->clone().get()));
+      newFrames.push_back(toAnimatableValueKeyframe(frames[0]->clone().get()));
+      newFrames.push_back(toAnimatableValueKeyframe(frames[1]->clone().get()));
+      newFrames.push_back(toAnimatableValueKeyframe(frames[2]->clone().get()));
       newFrames[0]->clearPropertyValue(id);
       newFrames[1]->clearPropertyValue(id);
 
       InertEffect* inertAnimationForSampling = InertEffect::create(
           oldAnimation->model(), oldAnimation->specifiedTiming(), false,
           inheritedTime);
       Vector<RefPtr<Interpolation>> sample;
       inertAnimationForSampling->sample(sample);
       if (sample.size() == 1) {
         newFrames[0]->setPropertyValue(
@@ skipping 98 matching lines @@
   if (timing.startDelay > 0) {
     timing.iterationDuration += timing.startDelay;
     startKeyframeOffset = timing.startDelay / timing.iterationDuration;
     timing.startDelay = 0;
   }
 
   RefPtr<AnimatableValueKeyframe> delayKeyframe =
       AnimatableValueKeyframe::create();
   delayKeyframe->setPropertyValue(id, from.get());
   delayKeyframe->setOffset(0);
-  keyframes.append(delayKeyframe);
+  keyframes.push_back(delayKeyframe);
 
   RefPtr<AnimatableValueKeyframe> startKeyframe =
       AnimatableValueKeyframe::create();
   startKeyframe->setPropertyValue(id, from.get());
   startKeyframe->setOffset(startKeyframeOffset);
   startKeyframe->setEasing(timing.timingFunction.release());
   timing.timingFunction = LinearTimingFunction::shared();
-  keyframes.append(startKeyframe);
+  keyframes.push_back(startKeyframe);
 
   RefPtr<AnimatableValueKeyframe> endKeyframe =
       AnimatableValueKeyframe::create();
   endKeyframe->setPropertyValue(id, to.get());
   endKeyframe->setOffset(1);
-  keyframes.append(endKeyframe);
+  keyframes.push_back(endKeyframe);
 
   AnimatableValueKeyframeEffectModel* model =
       AnimatableValueKeyframeEffectModel::create(keyframes);
   update.startTransition(id, from.get(), to.get(), reversingAdjustedStartValue,
                          reversingShorteningFactor,
                          *InertEffect::create(model, timing, false, 0));
   DCHECK(!element->elementAnimations() ||
          !element->elementAnimations()->isAnimationStyleChange());
 }
 
@@ skipping 124 matching lines @@
         EffectStack::activeInterpolations(
             effectStack, nullptr, nullptr,
             KeyframeEffectReadOnly::DefaultPriority, isStylePropertyHandle));
     update.adoptActiveInterpolationsForAnimations(
         activeInterpolationsForAnimations);
     return;
   }
 
   HeapVector<Member<const InertEffect>> newEffects;
   for (const auto& newAnimation : update.newAnimations())
-    newEffects.append(newAnimation.effect);
+    newEffects.push_back(newAnimation.effect);
 
   // Animations with updates use a temporary InertEffect for the current frame.
   for (const auto& updatedAnimation : update.animationsWithUpdates())
-    newEffects.append(updatedAnimation.effect);
+    newEffects.push_back(updatedAnimation.effect);
 
   ActiveInterpolationsMap activeInterpolationsForAnimations(
       EffectStack::activeInterpolations(
           effectStack, &newEffects, &update.suppressedAnimations(),
           KeyframeEffectReadOnly::DefaultPriority, isStylePropertyHandle));
   update.adoptActiveInterpolationsForAnimations(
       activeInterpolationsForAnimations);
 }
 
 void CSSAnimations::calculateTransitionActiveInterpolations(
     CSSAnimationUpdate& update,
     const Element* animatingElement) {
   ElementAnimations* elementAnimations =
       animatingElement ? animatingElement->elementAnimations() : nullptr;
   EffectStack* effectStack =
       elementAnimations ? &elementAnimations->effectStack() : nullptr;
 
   ActiveInterpolationsMap activeInterpolationsForTransitions;
   if (update.newTransitions().isEmpty() &&
       update.cancelledTransitions().isEmpty()) {
     activeInterpolationsForTransitions = EffectStack::activeInterpolations(
         effectStack, nullptr, nullptr,
         KeyframeEffectReadOnly::TransitionPriority, isStylePropertyHandle);
   } else {
     HeapVector<Member<const InertEffect>> newTransitions;
     for (const auto& entry : update.newTransitions())
-      newTransitions.append(entry.value.effect.get());
+      newTransitions.push_back(entry.value.effect.get());
 
     HeapHashSet<Member<const Animation>> cancelledAnimations;
     if (!update.cancelledTransitions().isEmpty()) {
       DCHECK(elementAnimations);
       const TransitionMap& transitionMap =
           elementAnimations->cssAnimations().m_transitions;
       for (CSSPropertyID id : update.cancelledTransitions()) {
         DCHECK(transitionMap.contains(id));
         cancelledAnimations.add(transitionMap.get(id).animation.get());
       }
@@ skipping 119 matching lines @@
       CSSPropertyID id = convertToCSSPropertyID(i);
       // Avoid creating overlapping transitions with perspective-origin and
       // transition-origin.
       if (id == CSSPropertyWebkitPerspectiveOriginX ||
           id == CSSPropertyWebkitPerspectiveOriginY ||
           id == CSSPropertyWebkitTransformOriginX ||
           id == CSSPropertyWebkitTransformOriginY ||
           id == CSSPropertyWebkitTransformOriginZ)
         continue;
       if (CSSPropertyMetadata::isInterpolableProperty(id))
-        properties.append(id);
+        properties.push_back(id);
     }
     propertyShorthand = StylePropertyShorthand(
         CSSPropertyInvalid, properties.begin(), properties.size());
   }
   return propertyShorthand;
 }
 
 // Properties that affect animations are not allowed to be affected by
 // animations. http://w3c.github.io/web-animations/#not-animatable-section
 bool CSSAnimations::isAnimationAffectingProperty(CSSPropertyID property) {
@@ skipping 44 matching lines @@
              isCustomPropertyHandle);
 }
 
 DEFINE_TRACE(CSSAnimations) {
   visitor->trace(m_transitions);
   visitor->trace(m_pendingUpdate);
   visitor->trace(m_runningAnimations);
 }
 
 }  // namespace blink