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

third_party/WebKit/Source/core/animation/CompositorAnimationsTest.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 130 matching lines @@
     return CompositorAnimations::getAnimatedBoundingBox(boundingBox, effect,
                                                         minValue, maxValue);
   }
 
   bool duplicateSingleKeyframeAndTestIsCandidateOnResult(
       AnimatableValueKeyframe* frame) {
     EXPECT_EQ(frame->offset(), 0);
     AnimatableValueKeyframeVector frames;
     RefPtr<Keyframe> second = frame->cloneWithOffset(1);
 
-    frames.append(frame);
-    frames.append(toAnimatableValueKeyframe(second.get()));
+    frames.push_back(frame);
+    frames.push_back(toAnimatableValueKeyframe(second.get()));
     return isCandidateForAnimationOnCompositor(
         m_timing, *AnimatableValueKeyframeEffectModel::create(frames));
   }
 
   // -------------------------------------------------------------------
 
   Timing createCompositableTiming() {
     Timing timing;
     timing.startDelay = 0;
     timing.fillMode = Timing::FillMode::NONE;
@@ skipping 32 matching lines @@
     RefPtr<AnimatableValueKeyframe> keyframe =
         createReplaceOpKeyframe(id, value.get(), offset);
     keyframe->setComposite(op);
     return keyframe;
   }
 
   std::unique_ptr<AnimatableValueKeyframeVector>
   createCompositableFloatKeyframeVector(size_t n) {
     Vector<double> values;
     for (size_t i = 0; i < n; i++) {
-      values.append(static_cast<double>(i));
+      values.push_back(static_cast<double>(i));
     }
     return createCompositableFloatKeyframeVector(values);
   }
 
   std::unique_ptr<AnimatableValueKeyframeVector>
   createCompositableFloatKeyframeVector(Vector<double>& values) {
     std::unique_ptr<AnimatableValueKeyframeVector> frames =
         WTF::wrapUnique(new AnimatableValueKeyframeVector);
     for (size_t i = 0; i < values.size(); i++) {
       double offset = 1.0 / (values.size() - 1) * i;
       RefPtr<AnimatableDouble> value = AnimatableDouble::create(values[i]);
-      frames->append(
+      frames->push_back(
           createReplaceOpKeyframe(CSSPropertyOpacity, value.get(), offset)
               .get());
     }
     return frames;
   }
 
   std::unique_ptr<AnimatableValueKeyframeVector>
   createCompositableTransformKeyframeVector(
       const Vector<TransformOperations>& values) {
     std::unique_ptr<AnimatableValueKeyframeVector> frames =
         WTF::wrapUnique(new AnimatableValueKeyframeVector);
     for (size_t i = 0; i < values.size(); ++i) {
       double offset = 1.0f / (values.size() - 1) * i;
       RefPtr<AnimatableTransform> value =
           AnimatableTransform::create(values[i], 1);
-      frames->append(
+      frames->push_back(
           createReplaceOpKeyframe(CSSPropertyTransform, value.get(), offset)
               .get());
     }
     return frames;
   }
 
   AnimatableValueKeyframeEffectModel* createKeyframeEffectModel(
       PassRefPtr<AnimatableValueKeyframe> prpFrom,
       PassRefPtr<AnimatableValueKeyframe> prpTo,
       PassRefPtr<AnimatableValueKeyframe> prpC = nullptr,
       PassRefPtr<AnimatableValueKeyframe> prpD = nullptr) {
     RefPtr<AnimatableValueKeyframe> from = prpFrom;
     RefPtr<AnimatableValueKeyframe> to = prpTo;
     RefPtr<AnimatableValueKeyframe> c = prpC;
     RefPtr<AnimatableValueKeyframe> d = prpD;
 
     EXPECT_EQ(from->offset(), 0);
     AnimatableValueKeyframeVector frames;
-    frames.append(from);
+    frames.push_back(from);
     EXPECT_LE(from->offset(), to->offset());
-    frames.append(to);
+    frames.push_back(to);
     if (c) {
       EXPECT_LE(to->offset(), c->offset());
-      frames.append(c);
+      frames.push_back(c);
     }
     if (d) {
-      frames.append(d);
+      frames.push_back(d);
       EXPECT_LE(c->offset(), d->offset());
       EXPECT_EQ(d->offset(), 1.0);
     } else {
       EXPECT_EQ(to->offset(), 1.0);
     }
     if (!HasFatalFailure()) {
       return AnimatableValueKeyframeEffectModel::create(frames);
     }
     return nullptr;
   }
@@ skipping 63 matching lines @@
       createDefaultKeyframe(CSSPropertyColor, EffectModel::CompositeReplace);
   keyframeBadMultipleID->setPropertyValue(CSSPropertyOpacity,
                                           AnimatableDouble::create(10.0).get());
   EXPECT_FALSE(duplicateSingleKeyframeAndTestIsCandidateOnResult(
       keyframeBadMultipleID.get()));
 }
 
 TEST_F(AnimationCompositorAnimationsTest,
        isNotCandidateForCompositorAnimationTransformDependsOnBoxSize) {
   TransformOperations ops;
-  ops.operations().append(TranslateTransformOperation::create(
+  ops.operations().push_back(TranslateTransformOperation::create(
       Length(2, Fixed), Length(2, Fixed), TransformOperation::TranslateX));
   RefPtr<AnimatableValueKeyframe> goodKeyframe = createReplaceOpKeyframe(
       CSSPropertyTransform, AnimatableTransform::create(ops, 1).get());
   EXPECT_TRUE(
       duplicateSingleKeyframeAndTestIsCandidateOnResult(goodKeyframe.get()));
 
-  ops.operations().append(TranslateTransformOperation::create(
+  ops.operations().push_back(TranslateTransformOperation::create(
       Length(50, Percent), Length(2, Fixed), TransformOperation::TranslateX));
   RefPtr<AnimatableValueKeyframe> badKeyframe = createReplaceOpKeyframe(
       CSSPropertyTransform, AnimatableTransform::create(ops, 1).get());
   EXPECT_FALSE(
       duplicateSingleKeyframeAndTestIsCandidateOnResult(badKeyframe.get()));
 
   TransformOperations ops2;
   Length calcLength =
       Length(100, Percent).blend(Length(100, Fixed), 0.5, ValueRangeAll);
-  ops2.operations().append(TranslateTransformOperation::create(
+  ops2.operations().push_back(TranslateTransformOperation::create(
       calcLength, Length(0, Fixed), TransformOperation::TranslateX));
   RefPtr<AnimatableValueKeyframe> badKeyframe2 = createReplaceOpKeyframe(
       CSSPropertyTransform, AnimatableTransform::create(ops2, 1).get());
   EXPECT_FALSE(
       duplicateSingleKeyframeAndTestIsCandidateOnResult(badKeyframe2.get()));
 }
 
 TEST_F(
     AnimationCompositorAnimationsTest,
     isCandidateForAnimationOnCompositorKeyframeEffectModelMultipleFramesOkay) {
   AnimatableValueKeyframeVector framesSame;
-  framesSame.append(createDefaultKeyframe(CSSPropertyOpacity,
-                                          EffectModel::CompositeReplace, 0.0)
-                        .get());
-  framesSame.append(createDefaultKeyframe(CSSPropertyOpacity,
-                                          EffectModel::CompositeReplace, 1.0)
-                        .get());
+  framesSame.push_back(createDefaultKeyframe(CSSPropertyOpacity,
+                                             EffectModel::CompositeReplace, 0.0)
+                           .get());
+  framesSame.push_back(createDefaultKeyframe(CSSPropertyOpacity,
+                                             EffectModel::CompositeReplace, 1.0)
+                           .get());
   EXPECT_TRUE(isCandidateForAnimationOnCompositor(
       m_timing, *AnimatableValueKeyframeEffectModel::create(framesSame)));
 
   AnimatableValueKeyframeVector framesMixed;
-  framesMixed.append(createDefaultKeyframe(CSSPropertyOpacity,
-                                           EffectModel::CompositeReplace, 0.0)
-                         .get());
-  framesMixed.append(createDefaultKeyframe(CSSPropertyTransform,
-                                           EffectModel::CompositeReplace, 1.0)
-                         .get());
+  framesMixed.push_back(createDefaultKeyframe(CSSPropertyOpacity,
+                                              EffectModel::CompositeReplace,
+                                              0.0)
+                            .get());
+  framesMixed.push_back(createDefaultKeyframe(CSSPropertyTransform,
+                                              EffectModel::CompositeReplace,
+                                              1.0)
+                            .get());
   EXPECT_FALSE(isCandidateForAnimationOnCompositor(
       m_timing, *AnimatableValueKeyframeEffectModel::create(framesMixed)));
 }
 
 TEST_F(AnimationCompositorAnimationsTest,
        isCandidateForAnimationOnCompositorKeyframeEffectModel) {
   AnimatableValueKeyframeVector framesSame;
-  framesSame.append(createDefaultKeyframe(CSSPropertyColor,
-                                          EffectModel::CompositeReplace, 0.0)
-                        .get());
-  framesSame.append(createDefaultKeyframe(CSSPropertyColor,
-                                          EffectModel::CompositeReplace, 1.0)
-                        .get());
+  framesSame.push_back(createDefaultKeyframe(CSSPropertyColor,
+                                             EffectModel::CompositeReplace, 0.0)
+                           .get());
+  framesSame.push_back(createDefaultKeyframe(CSSPropertyColor,
+                                             EffectModel::CompositeReplace, 1.0)
+                           .get());
   EXPECT_FALSE(isCandidateForAnimationOnCompositor(
       m_timing, *AnimatableValueKeyframeEffectModel::create(framesSame)));
 
   AnimatableValueKeyframeVector framesMixedProperties;
-  framesMixedProperties.append(
+  framesMixedProperties.push_back(
       createDefaultKeyframe(CSSPropertyOpacity, EffectModel::CompositeReplace,
                             0.0)
           .get());
-  framesMixedProperties.append(
+  framesMixedProperties.push_back(
       createDefaultKeyframe(CSSPropertyColor, EffectModel::CompositeReplace,
                             1.0)
           .get());
   EXPECT_FALSE(isCandidateForAnimationOnCompositor(
       m_timing,
       *AnimatableValueKeyframeEffectModel::create(framesMixedProperties)));
 }
 
 TEST_F(AnimationCompositorAnimationsTest, AnimatedBoundingBox) {
   Vector<TransformOperations> transformVector;
-  transformVector.append(TransformOperations());
-  transformVector.back().operations().append(
+  transformVector.push_back(TransformOperations());
+  transformVector.back().operations().push_back(
       TranslateTransformOperation::create(Length(0, Fixed), Length(0, Fixed),
                                           0.0,
                                           TransformOperation::Translate3D));
-  transformVector.append(TransformOperations());
-  transformVector.back().operations().append(
+  transformVector.push_back(TransformOperations());
+  transformVector.back().operations().push_back(
       TranslateTransformOperation::create(Length(200, Fixed),
                                           Length(200, Fixed), 0.0,
                                           TransformOperation::Translate3D));
   std::unique_ptr<AnimatableValueKeyframeVector> frames =
       createCompositableTransformKeyframeVector(transformVector);
   FloatBox bounds;
   EXPECT_TRUE(getAnimationBounds(
       bounds, *AnimatableValueKeyframeEffectModel::create(*frames), 0, 1));
   EXPECT_EQ(FloatBox(0.0f, 0.f, 0.0f, 200.0f, 200.0f, 0.0f), bounds);
   bounds = FloatBox();
   EXPECT_TRUE(getAnimationBounds(
       bounds, *AnimatableValueKeyframeEffectModel::create(*frames), -1, 1));
   EXPECT_EQ(FloatBox(-200.0f, -200.0, 0.0, 400.0f, 400.0f, 0.0f), bounds);
-  transformVector.append(TransformOperations());
-  transformVector.back().operations().append(
+  transformVector.push_back(TransformOperations());
+  transformVector.back().operations().push_back(
       TranslateTransformOperation::create(Length(-300, Fixed),
                                           Length(-400, Fixed), 1.0f,
                                           TransformOperation::Translate3D));
   bounds = FloatBox();
   frames = createCompositableTransformKeyframeVector(transformVector);
   EXPECT_TRUE(getAnimationBounds(
       bounds, *AnimatableValueKeyframeEffectModel::create(*frames), 0, 1));
   EXPECT_EQ(FloatBox(-300.0f, -400.f, 0.0f, 500.0f, 600.0f, 1.0f), bounds);
   bounds = FloatBox();
   EXPECT_TRUE(getAnimationBounds(
@@ skipping 272 matching lines @@
   (*m_keyframeVector5)[2]->setEasing(m_cubicEaseTimingFunction.get());
   (*m_keyframeVector5)[3]->setEasing(m_stepTimingFunction.get());
   m_keyframeAnimationEffect5 =
       AnimatableValueKeyframeEffectModel::create(*m_keyframeVector5);
   EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing,
                                                   *m_keyframeAnimationEffect5));
 }
 
 TEST_F(AnimationCompositorAnimationsTest, isCandidateForAnimationOnCompositor) {
   AnimatableValueKeyframeVector basicFramesVector;
-  basicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity,
-                                                 EffectModel::CompositeReplace,
-                                                 0.0)
-                               .get());
-  basicFramesVector.append(createDefaultKeyframe(CSSPropertyOpacity,
-                                                 EffectModel::CompositeReplace,
-                                                 1.0)
-                               .get());
-
-  AnimatableValueKeyframeVector nonBasicFramesVector;
-  nonBasicFramesVector.append(
+  basicFramesVector.push_back(
       createDefaultKeyframe(CSSPropertyOpacity, EffectModel::CompositeReplace,
                             0.0)
           .get());
-  nonBasicFramesVector.append(
+  basicFramesVector.push_back(
+      createDefaultKeyframe(CSSPropertyOpacity, EffectModel::CompositeReplace,
+                            1.0)
+          .get());
+
+  AnimatableValueKeyframeVector nonBasicFramesVector;
+  nonBasicFramesVector.push_back(
+      createDefaultKeyframe(CSSPropertyOpacity, EffectModel::CompositeReplace,
+                            0.0)
+          .get());
+  nonBasicFramesVector.push_back(
       createDefaultKeyframe(CSSPropertyOpacity, EffectModel::CompositeReplace,
                             0.5)
           .get());
-  nonBasicFramesVector.append(
+  nonBasicFramesVector.push_back(
       createDefaultKeyframe(CSSPropertyOpacity, EffectModel::CompositeReplace,
                             1.0)
           .get());
 
   basicFramesVector[0]->setEasing(m_linearTimingFunction.get());
   AnimatableValueKeyframeEffectModel* basicFrames =
       AnimatableValueKeyframeEffectModel::create(basicFramesVector);
   EXPECT_TRUE(isCandidateForAnimationOnCompositor(m_timing, *basicFrames));
 
   basicFramesVector[0]->setEasing(CubicBezierTimingFunction::preset(
@@ skipping 154 matching lines @@
   ASSERT_EQ(2UL, keyframes.size());
 
   EXPECT_EQ(1.75, keyframes[1]->time() * m_timing.iterationDuration);
   EXPECT_EQ(5.0f, keyframes[1]->value());
 }
 
 TEST_F(AnimationCompositorAnimationsTest,
        createMultipleKeyframeOpacityAnimationChained) {
   // KeyframeEffect to convert
   AnimatableValueKeyframeVector frames;
-  frames.append(createReplaceOpKeyframe(
+  frames.push_back(createReplaceOpKeyframe(
       CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0));
-  frames.append(createReplaceOpKeyframe(
+  frames.push_back(createReplaceOpKeyframe(
       CSSPropertyOpacity, AnimatableDouble::create(-1.0).get(), 0.25));
-  frames.append(createReplaceOpKeyframe(
+  frames.push_back(createReplaceOpKeyframe(
       CSSPropertyOpacity, AnimatableDouble::create(20.0).get(), 0.5));
-  frames.append(createReplaceOpKeyframe(
+  frames.push_back(createReplaceOpKeyframe(
       CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
   frames[0]->setEasing(m_cubicEaseTimingFunction.get());
   frames[1]->setEasing(m_linearTimingFunction.get());
   frames[2]->setEasing(m_cubicCustomTimingFunction.get());
   AnimatableValueKeyframeEffectModel* effect =
       AnimatableValueKeyframeEffectModel::create(frames);
 
   m_timing.timingFunction = m_linearTimingFunction.get();
   m_timing.iterationDuration = 2.0;
   m_timing.iterationCount = 10;
@@ skipping 35 matching lines @@
   EXPECT_EQ(TimingFunction::Type::LINEAR,
             keyframes[3]->getTimingFunctionForTesting()->getType());
 }
 
 TEST_F(AnimationCompositorAnimationsTest, createReversedOpacityAnimation) {
   RefPtr<TimingFunction> cubicEasyFlipTimingFunction =
       CubicBezierTimingFunction::create(0.0, 0.0, 0.0, 1.0);
 
   // KeyframeEffect to convert
   AnimatableValueKeyframeVector frames;
-  frames.append(createReplaceOpKeyframe(
+  frames.push_back(createReplaceOpKeyframe(
       CSSPropertyOpacity, AnimatableDouble::create(2.0).get(), 0));
-  frames.append(createReplaceOpKeyframe(
+  frames.push_back(createReplaceOpKeyframe(
       CSSPropertyOpacity, AnimatableDouble::create(-1.0).get(), 0.25));
-  frames.append(createReplaceOpKeyframe(
+  frames.push_back(createReplaceOpKeyframe(
       CSSPropertyOpacity, AnimatableDouble::create(20.0).get(), 0.5));
-  frames.append(createReplaceOpKeyframe(
+  frames.push_back(createReplaceOpKeyframe(
       CSSPropertyOpacity, AnimatableDouble::create(5.0).get(), 1.0));
   frames[0]->setEasing(CubicBezierTimingFunction::preset(
       CubicBezierTimingFunction::EaseType::EASE_IN));
   frames[1]->setEasing(m_linearTimingFunction.get());
   frames[2]->setEasing(cubicEasyFlipTimingFunction.get());
   AnimatableValueKeyframeEffectModel* effect =
       AnimatableValueKeyframeEffectModel::create(frames);
 
   m_timing.timingFunction = m_linearTimingFunction.get();
   m_timing.iterationCount = 10;
@@ skipping 183 matching lines @@
 }
 
 TEST_F(AnimationCompositorAnimationsTest,
        cancelIncompatibleCompositorAnimations) {
   Persistent<Element> element = m_document->createElement("shared");
 
   LayoutObjectProxy* layoutObject = LayoutObjectProxy::create(element.get());
   element->setLayoutObject(layoutObject);
 
   AnimatableValueKeyframeVector keyFrames;
-  keyFrames.append(createDefaultKeyframe(CSSPropertyOpacity,
-                                         EffectModel::CompositeReplace, 0.0)
-                       .get());
-  keyFrames.append(createDefaultKeyframe(CSSPropertyOpacity,
-                                         EffectModel::CompositeReplace, 1.0)
-                       .get());
+  keyFrames.push_back(createDefaultKeyframe(CSSPropertyOpacity,
+                                            EffectModel::CompositeReplace, 0.0)
+                          .get());
+  keyFrames.push_back(createDefaultKeyframe(CSSPropertyOpacity,
+                                            EffectModel::CompositeReplace, 1.0)
+                          .get());
   EffectModel* animationEffect1 =
       AnimatableValueKeyframeEffectModel::create(keyFrames);
   EffectModel* animationEffect2 =
       AnimatableValueKeyframeEffectModel::create(keyFrames);
 
   Timing timing;
   timing.iterationDuration = 1.f;
 
   // The first animation for opacity is ok to run on compositor.
   KeyframeEffect* keyframeEffect1 =
       KeyframeEffect::create(element.get(), animationEffect1, timing);
   Animation* animation1 = m_timeline->play(keyframeEffect1);
   EXPECT_TRUE(CompositorAnimations::isCandidateForAnimationOnCompositor(
       timing, *element.get(), animation1, *animationEffect1, 1));
 
   // simulate KeyframeEffect::maybeStartAnimationOnCompositor
   Vector<int> compositorAnimationIds;
-  compositorAnimationIds.append(1);
+  compositorAnimationIds.push_back(1);
   keyframeEffect1->setCompositorAnimationIdsForTesting(compositorAnimationIds);
   EXPECT_TRUE(animation1->hasActiveAnimationsOnCompositor());
 
   // The second animation for opacity is not ok to run on compositor.
   KeyframeEffect* keyframeEffect2 =
       KeyframeEffect::create(element.get(), animationEffect2, timing);
   Animation* animation2 = m_timeline->play(keyframeEffect2);
   EXPECT_FALSE(CompositorAnimations::isCandidateForAnimationOnCompositor(
       timing, *element.get(), animation2, *animationEffect2, 1));
   EXPECT_FALSE(animation2->hasActiveAnimationsOnCompositor());
@@ skipping 10 matching lines @@
   simulateFrame(1.);
 
   element->setLayoutObject(nullptr);
   LayoutObjectProxy::dispose(layoutObject);
 
   ThreadState::current()->collectAllGarbage();
   EXPECT_TRUE(element->elementAnimations()->animations().isEmpty());
 }
 
 }  // namespace blink