compositor: Tick the UI animations from cc, instead of from timer callbacks.

ui/compositor/layer_animator_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/compositor/layer_animator.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
 #include "base/time/time.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_animation_element.h"
 #include "ui/compositor/layer_animation_sequence.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/compositor/test/layer_animator_test_controller.h"
 #include "ui/compositor/test/test_layer_animation_delegate.h"
 #include "ui/compositor/test/test_layer_animation_observer.h"
 #include "ui/compositor/test/test_utils.h"
 #include "ui/gfx/frame_time.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
 
-using gfx::AnimationContainerElement;
-
 namespace ui {
 
 namespace {
 
 // Converts |color| to a string. Each component of the color is separated by a
 // space and the order if A R G B.
 std::string ColorToString(SkColor color) {
   return base::StringPrintf("%d %d %d %d", SkColorGetA(color),
                             SkColorGetR(color), SkColorGetG(color),
                             SkColorGetB(color));
@@ skipping 150 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TestLayerAnimationSequence);
 };
 
 } // namespace
 
 // Checks that setting a property on an implicit animator causes an animation to
 // happen.
 TEST(LayerAnimatorTest, ImplicitAnimation) {
   scoped_refptr<LayerAnimator> animator(
       LayerAnimator::CreateImplicitAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
   base::TimeTicks now = gfx::FrameTime::Now();
   animator->SetBrightness(0.5);
   EXPECT_TRUE(animator->is_animating());
-  element->Step(now + base::TimeDelta::FromSeconds(1));
+  animator->Step(now + base::TimeDelta::FromSeconds(1));
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), 0.5);
 }
 
 // Checks that if the animator is a default animator, that implicit animations
 // are not started.
 TEST(LayerAnimatorTest, NoImplicitAnimation) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
@@ skipping 61 matching lines @@
   animator->AbortAllAnimations();
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(initial_opacity, delegate.GetOpacityForAnimation());
   CheckApproximatelyEqual(initial_bounds, delegate.GetBoundsForAnimation());
 }
 
 // Schedule a non-threaded animation that can run immediately. This is the
 // trivial case and should result in the animation being started immediately.
 TEST(LayerAnimatorTest, ScheduleAnimationThatCanRunImmediately) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_brightness(0.0);
   double middle_brightness(0.5);
   double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->ScheduleAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBrightnessElement(target_brightness,
                                                          delta)));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 
   base::TimeTicks start_time = animator->last_step_time();
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 }
 
 // Schedule a threaded animation that can run immediately.
 TEST(LayerAnimatorTest, ScheduleThreadedAnimationThatCanRunImmediately) {
   double epsilon = 0.00001;
   LayerAnimatorTestController test_controller(
       LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = test_controller.animator();
+  LayerAnimator* animator = test_controller.animator();
   test_controller.animator()->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   test_controller.animator()->SetDelegate(&delegate);
 
   double start_opacity(0.0);
   double target_opacity(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
   test_controller.animator()->ScheduleAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 
   EXPECT_TRUE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 
   base::TimeTicks start_time = test_controller.animator()->last_step_time();
   base::TimeTicks effective_start = start_time + delta;
 
   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
       cc::AnimationEvent::Started,
       0,
       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)
           ->animation_group_id(),
       cc::Animation::Opacity,
       effective_start));
 
-  element->Step(effective_start + delta/2);
+  animator->Step(effective_start + delta / 2);
 
   EXPECT_TRUE(test_controller.animator()->is_animating());
   EXPECT_NEAR(
       0.5,
       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
           last_progressed_fraction(),
       epsilon);
 
-  element->Step(effective_start + delta);
+  animator->Step(effective_start + delta);
 
   EXPECT_FALSE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
 }
 
 // Schedule two non-threaded animations on separate properties. Both animations
 // should start immediately and should progress in lock step.
 TEST(LayerAnimatorTest, ScheduleTwoAnimationsThatCanRunImmediately) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_brightness(0.0);
   double middle_brightness(0.5);
   double target_brightness(1.0);
 
   gfx::Rect start_bounds, target_bounds, middle_bounds;
   start_bounds = target_bounds = middle_bounds = gfx::Rect(0, 0, 50, 50);
@@ skipping 13 matching lines @@
   animator->ScheduleAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBoundsElement(target_bounds, delta)));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
   base::TimeTicks start_time = animator->last_step_time();
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), middle_bounds);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 }
 
 // Schedule a threaded and a non-threaded animation on separate properties. Both
 // animations should progress in lock step.
 TEST(LayerAnimatorTest, ScheduleThreadedAndNonThreadedAnimations) {
   double epsilon = 0.00001;
   LayerAnimatorTestController test_controller(
       LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = test_controller.animator();
+  LayerAnimator* animator = test_controller.animator();
   test_controller.animator()->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   test_controller.animator()->SetDelegate(&delegate);
 
   double start_opacity(0.0);
   double target_opacity(1.0);
 
   gfx::Rect start_bounds, target_bounds, middle_bounds;
   start_bounds = target_bounds = middle_bounds = gfx::Rect(0, 0, 50, 50);
   start_bounds.set_x(-90);
@@ skipping 23 matching lines @@
   base::TimeTicks effective_start = start_time + delta;
 
   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
       cc::AnimationEvent::Started,
       0,
       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)
           ->animation_group_id(),
       cc::Animation::Opacity,
       effective_start));
 
-  element->Step(effective_start + delta/2);
+  animator->Step(effective_start + delta / 2);
 
   EXPECT_TRUE(test_controller.animator()->is_animating());
   EXPECT_NEAR(
       0.5,
       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
           last_progressed_fraction(),
       epsilon);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), middle_bounds);
 
-  element->Step(effective_start + delta);
+  animator->Step(effective_start + delta);
 
   EXPECT_FALSE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 }
 
 // Schedule two animations on the same property. In this case, the two
 // animations should run one after another.
 TEST(LayerAnimatorTest, ScheduleTwoAnimationsOnSameProperty) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_brightness(0.0);
   double middle_brightness(0.5);
   double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->ScheduleAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBrightnessElement(target_brightness,
                                                          delta)));
 
   animator->ScheduleAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBrightnessElement(start_brightness,
                                                          delta)));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 
   base::TimeTicks start_time = animator->last_step_time();
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 // Schedule [{g}, {g,b}, {b}] and ensure that {b} doesn't run right away. That
 // is, ensure that all animations targetting a particular property are run in
 // order.
 TEST(LayerAnimatorTest, ScheduleBlockedAnimation) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_grayscale(0.0);
   double middle_grayscale(0.5);
   double target_grayscale(1.0);
 
   gfx::Rect start_bounds, target_bounds, middle_bounds;
   start_bounds = target_bounds = middle_bounds = gfx::Rect(0, 0, 50, 50);
@@ skipping 23 matching lines @@
   animator->ScheduleAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBoundsElement(start_bounds, delta)));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
   base::TimeTicks start_time = animator->last_step_time();
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), middle_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), target_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(3000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(3000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(4000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(4000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 }
 
 // Schedule {g} and then schedule {g} and {b} together. In this case, since
 // ScheduleTogether is being used, the bounds animation should not start until
 // the second grayscale animation starts.
 TEST(LayerAnimatorTest, ScheduleTogether) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_grayscale(0.0);
   double target_grayscale(1.0);
 
   gfx::Rect start_bounds, target_bounds, middle_bounds;
   start_bounds = target_bounds = gfx::Rect(0, 0, 50, 50);
   start_bounds.set_x(-90);
@@ skipping 16 matching lines @@
       LayerAnimationElement::CreateBoundsElement(target_bounds, delta)));
 
   animator->ScheduleTogether(sequences);
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
   base::TimeTicks start_time = animator->last_step_time();
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), target_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), target_bounds);
 }
 
 // Start non-threaded animation (that can run immediately). This is the trivial
 // case (see the trival case for ScheduleAnimation).
 TEST(LayerAnimatorTest, StartAnimationThatCanRunImmediately) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_brightness(0.0);
   double middle_brightness(0.5);
   double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBrightnessElement(target_brightness,
                                                          delta)));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 
   base::TimeTicks start_time = animator->last_step_time();
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 }
 
 // Start threaded animation (that can run immediately).
 TEST(LayerAnimatorTest, StartThreadedAnimationThatCanRunImmediately) {
   double epsilon = 0.00001;
   LayerAnimatorTestController test_controller(
       LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = test_controller.animator();
+  LayerAnimator* animator = test_controller.animator();
   test_controller.animator()->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   test_controller.animator()->SetDelegate(&delegate);
 
   double start_opacity(0.0);
   double target_opacity(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
   test_controller.animator()->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 
   EXPECT_TRUE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 
   base::TimeTicks start_time = test_controller.animator()->last_step_time();
   base::TimeTicks effective_start = start_time + delta;
 
   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
       cc::AnimationEvent::Started,
       0,
       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)
           ->animation_group_id(),
       cc::Animation::Opacity,
       effective_start));
 
-  element->Step(effective_start + delta/2);
+  animator->Step(effective_start + delta / 2);
 
   EXPECT_TRUE(test_controller.animator()->is_animating());
   EXPECT_NEAR(
       0.5,
       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
           last_progressed_fraction(),
       epsilon);
 
-  element->Step(effective_start + delta);
+  animator->Step(effective_start + delta);
   EXPECT_FALSE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
 }
 
 // Preempt by immediately setting new target.
 TEST(LayerAnimatorTest, PreemptBySettingNewTarget) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
@@ skipping 15 matching lines @@
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 }
 
 // Preempt by animating to new target, with a non-threaded animation.
 TEST(LayerAnimatorTest, PreemptByImmediatelyAnimatingToNewTarget) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_brightness(0.0);
   double middle_brightness(0.5);
   double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->set_preemption_strategy(
       LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBrightnessElement(target_brightness,
                                                          delta)));
 
   base::TimeTicks start_time = animator->last_step_time();
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBrightnessElement(start_brightness,
                                                          delta)));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBrightnessElement(start_brightness,
                                                          delta)));
 
   EXPECT_TRUE(animator->is_animating());
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(),
                   0.5 * (start_brightness + middle_brightness));
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 // Preempt by animating to new target, with a threaded animation.
 TEST(LayerAnimatorTest, PreemptThreadedByImmediatelyAnimatingToNewTarget) {
   double epsilon = 0.00001;
   LayerAnimatorTestController test_controller(
       LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = test_controller.animator();
+  LayerAnimator* animator = test_controller.animator();
   test_controller.animator()->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   test_controller.animator()->SetDelegate(&delegate);
 
   double start_opacity(0.0);
   double middle_opacity(0.5);
   double target_opacity(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
@@ skipping 10 matching lines @@
   base::TimeTicks effective_start = start_time + delta;
 
   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
       cc::AnimationEvent::Started,
       0,
       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)
           ->animation_group_id(),
       cc::Animation::Opacity,
       effective_start));
 
-  element->Step(effective_start + delta/2);
+  animator->Step(effective_start + delta / 2);
 
   test_controller.animator()->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
 
   EXPECT_TRUE(test_controller.animator()->is_animating());
   EXPECT_NEAR(delegate.GetOpacityForAnimation(), middle_opacity, epsilon);
 
   test_controller.animator()->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
 
   EXPECT_TRUE(test_controller.animator()->is_animating());
 
   base::TimeTicks second_effective_start = effective_start + delta;
 
   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
       cc::AnimationEvent::Started,
       0,
       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)
           ->animation_group_id(),
       cc::Animation::Opacity,
       second_effective_start));
 
-  element->Step(second_effective_start + delta/2);
+  animator->Step(second_effective_start + delta / 2);
 
   EXPECT_TRUE(test_controller.animator()->is_animating());
   EXPECT_NEAR(
       0.5,
       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
           last_progressed_fraction(),
       epsilon);
 
-  element->Step(second_effective_start + delta);
+  animator->Step(second_effective_start + delta);
 
   EXPECT_FALSE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 }
 
 // Preempt by enqueuing the new animation.
 TEST(LayerAnimatorTest, PreemptEnqueueNewAnimation) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_brightness(0.0);
   double middle_brightness(0.5);
   double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBrightnessElement(target_brightness,
                                                           delta)));
 
   base::TimeTicks start_time = animator->last_step_time();
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBrightnessElement(start_brightness,
                                                          delta)));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
   EXPECT_TRUE(animator->is_animating());
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 // Start an animation when there are sequences waiting in the queue. In this
 // case, all pending and running animations should be finished, and the new
 // animation started.
 TEST(LayerAnimatorTest, PreemptyByReplacingQueuedAnimations) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_brightness(0.0);
   double middle_brightness(0.5);
   double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->set_preemption_strategy(LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBrightnessElement(target_brightness,
                                                          delta)));
 
   base::TimeTicks start_time = animator->last_step_time();
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBrightnessElement(middle_brightness,
                                                          delta)));
 
   // Queue should now have two animations. Starting a third should replace the
   // second.
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBrightnessElement(start_brightness,
                                                          delta)));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 TEST(LayerAnimatorTest, StartTogetherSetsLastStepTime) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
@@ skipping 64 matching lines @@
       ));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 // Preempt by animating to new target.
 TEST(LayerAnimatorTest, MultiPreemptByImmediatelyAnimatingToNewTarget) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_grayscale(0.0);
   double middle_grayscale(0.5);
   double target_grayscale(1.0);
 
   double start_brightness(0.1);
   double middle_brightness(0.2);
@@ skipping 10 matching lines @@
   animator->StartTogether(
       CreateMultiSequence(
           LayerAnimationElement::CreateGrayscaleElement(target_grayscale,
                                                         delta),
           LayerAnimationElement::CreateBrightnessElement(target_brightness,
                                                          delta)
       ));
 
   base::TimeTicks start_time = animator->last_step_time();
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   animator->StartTogether(
       CreateMultiSequence(
           LayerAnimationElement::CreateGrayscaleElement(start_grayscale, delta),
           LayerAnimationElement::CreateBrightnessElement(start_brightness,
                                                          delta)));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), middle_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
   animator->StartTogether(
       CreateMultiSequence(
           LayerAnimationElement::CreateGrayscaleElement(start_grayscale, delta),
           LayerAnimationElement::CreateBrightnessElement(start_brightness,
                                                          delta)));
 
   EXPECT_TRUE(animator->is_animating());
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(),
                   0.5 * (start_grayscale + middle_grayscale));
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(),
                   0.5 * (start_brightness + middle_brightness));
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 // Preempt a threaded animation by animating to new target.
 TEST(LayerAnimatorTest, MultiPreemptThreadedByImmediatelyAnimatingToNewTarget) {
   double epsilon = 0.00001;
   LayerAnimatorTestController test_controller(
       LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = test_controller.animator();
+  LayerAnimator* animator = test_controller.animator();
   test_controller.animator()->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   test_controller.animator()->SetDelegate(&delegate);
 
   double start_opacity(0.0);
   double middle_opacity(0.5);
   double target_opacity(1.0);
 
   double start_brightness(0.1);
   double middle_brightness(0.2);
@@ skipping 18 matching lines @@
   base::TimeTicks effective_start = start_time + delta;
 
   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
       cc::AnimationEvent::Started,
       0,
       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)
           ->animation_group_id(),
       cc::Animation::Opacity,
       effective_start));
 
-  element->Step(effective_start + delta/2);
+  animator->Step(effective_start + delta / 2);
 
   test_controller.animator()->StartTogether(
       CreateMultiSequence(
           LayerAnimationElement::CreateOpacityElement(start_opacity, delta),
           LayerAnimationElement::CreateBrightnessElement(start_brightness,
                                                          delta)));
 
   EXPECT_TRUE(test_controller.animator()->is_animating());
   EXPECT_NEAR(delegate.GetOpacityForAnimation(), middle_opacity, epsilon);
   EXPECT_NEAR(delegate.GetBrightnessForAnimation(), middle_brightness, epsilon);
 
   test_controller.animator()->StartTogether(
       CreateMultiSequence(
           LayerAnimationElement::CreateOpacityElement(start_opacity, delta),
           LayerAnimationElement::CreateBrightnessElement(start_brightness,
                                                          delta)));
 
   EXPECT_TRUE(test_controller.animator()->is_animating());
 
   base::TimeTicks second_effective_start = effective_start + delta;
 
   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
       cc::AnimationEvent::Started,
       0,
       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)
           ->animation_group_id(),
       cc::Animation::Opacity,
       second_effective_start));
 
-  element->Step(second_effective_start + delta/2);
+  animator->Step(second_effective_start + delta / 2);
 
   EXPECT_TRUE(test_controller.animator()->is_animating());
   EXPECT_NEAR(
       0.5,
       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)->
           last_progressed_fraction(),
       epsilon);
   EXPECT_NEAR(delegate.GetBrightnessForAnimation(),
               0.5 * (start_brightness + middle_brightness),
               epsilon);
 
-  element->Step(second_effective_start + delta);
+  animator->Step(second_effective_start + delta);
 
   EXPECT_FALSE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 // Preempt by enqueuing the new animation.
 TEST(LayerAnimatorTest, MultiPreemptEnqueueNewAnimation) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_grayscale(0.0);
   double middle_grayscale(0.5);
   double target_grayscale(1.0);
 
   double start_brightness(0.1);
   double middle_brightness(0.2);
   double target_brightness(0.3);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetGrayscaleFromAnimation(start_grayscale);
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
 
   animator->StartTogether(
       CreateMultiSequence(
           LayerAnimationElement::CreateGrayscaleElement(target_grayscale,
                                                         delta),
           LayerAnimationElement::CreateBrightnessElement(target_brightness,
                                                          delta)));
 
   base::TimeTicks start_time = animator->last_step_time();
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   animator->StartTogether(
       CreateMultiSequence(
           LayerAnimationElement::CreateGrayscaleElement(start_grayscale, delta),
           LayerAnimationElement::CreateBrightnessElement(start_brightness,
                                                          delta)));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), middle_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
   EXPECT_TRUE(animator->is_animating());
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), target_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), middle_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 
 // Start an animation when there are sequences waiting in the queue. In this
 // case, all pending and running animations should be finished, and the new
 // animation started.
 TEST(LayerAnimatorTest, MultiPreemptByReplacingQueuedAnimations) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_grayscale(0.0);
   double middle_grayscale(0.5);
   double target_grayscale(1.0);
 
   double start_brightness(0.1);
   double middle_brightness(0.2);
   double target_brightness(0.3);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetGrayscaleFromAnimation(start_grayscale);
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   animator->set_preemption_strategy(LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
 
   animator->StartTogether(
       CreateMultiSequence(
           LayerAnimationElement::CreateGrayscaleElement(target_grayscale,
                                                         delta),
           LayerAnimationElement::CreateBrightnessElement(target_brightness,
                                                          delta)));
 
   base::TimeTicks start_time = animator->last_step_time();
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   animator->StartTogether(
       CreateMultiSequence(
           LayerAnimationElement::CreateGrayscaleElement(middle_grayscale,
                                                         delta),
           LayerAnimationElement::CreateBrightnessElement(middle_brightness,
                                                          delta)));
 
   // Queue should now have two animations. Starting a third should replace the
   // second.
   animator->StartTogether(
       CreateMultiSequence(
           LayerAnimationElement::CreateGrayscaleElement(start_grayscale, delta),
           LayerAnimationElement::CreateBrightnessElement(start_brightness,
                                                          delta)));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), middle_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), target_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), middle_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), middle_brightness);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetGrayscaleForAnimation(), start_grayscale);
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 }
 //-------------------------------------------------------
 // Test that non-threaded cyclic sequences continue to animate.
 TEST(LayerAnimatorTest, CyclicSequences) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_brightness(0.0);
   double target_brightness(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetBrightnessFromAnimation(start_brightness);
 
   scoped_ptr<LayerAnimationSequence> sequence(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBrightnessElement(target_brightness,
                                                          delta)));
 
   sequence->AddElement(
       LayerAnimationElement::CreateBrightnessElement(start_brightness, delta));
 
   sequence->set_is_cyclic(true);
 
   animator->StartAnimation(sequence.release());
 
   base::TimeTicks start_time = animator->last_step_time();
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(3000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(3000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 
   // Skip ahead by a lot.
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000000000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000000000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), start_brightness);
 
   // Skip ahead by a lot.
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000001000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000001000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetBrightnessForAnimation(), target_brightness);
 
   animator->StopAnimatingProperty(LayerAnimationElement::BRIGHTNESS);
 
   EXPECT_FALSE(animator->is_animating());
 }
 
 // Test that threaded cyclic sequences continue to animate.
 TEST(LayerAnimatorTest, ThreadedCyclicSequences) {
   LayerAnimatorTestController test_controller(
       LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = test_controller.animator();
+  LayerAnimator* animator = test_controller.animator();
   test_controller.animator()->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   test_controller.animator()->SetDelegate(&delegate);
 
   double start_opacity(0.0);
   double target_opacity(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetOpacityFromAnimation(start_opacity);
@@ skipping 13 matching lines @@
   base::TimeTicks effective_start = start_time + delta;
 
   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
       cc::AnimationEvent::Started,
       0,
       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)
           ->animation_group_id(),
       cc::Animation::Opacity,
       effective_start));
 
-  element->Step(effective_start + delta);
+  animator->Step(effective_start + delta);
   EXPECT_TRUE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
 
   base::TimeTicks second_effective_start = effective_start + 2 * delta;
   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
       cc::AnimationEvent::Started,
       0,
       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)
           ->animation_group_id(),
       cc::Animation::Opacity,
       second_effective_start));
 
-  element->Step(second_effective_start + delta);
+  animator->Step(second_effective_start + delta);
 
   EXPECT_TRUE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 
   base::TimeTicks third_effective_start = second_effective_start + 2 * delta;
   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
       cc::AnimationEvent::Started,
       0,
       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)
           ->animation_group_id(),
       cc::Animation::Opacity,
       third_effective_start));
 
-  element->Step(third_effective_start + delta);
+  animator->Step(third_effective_start + delta);
   EXPECT_TRUE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
 
   base::TimeTicks fourth_effective_start = third_effective_start + 2 * delta;
   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
       cc::AnimationEvent::Started,
       0,
       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)
           ->animation_group_id(),
       cc::Animation::Opacity,
       fourth_effective_start));
 
   // Skip ahead by a lot.
-  element->Step(fourth_effective_start + 1000 * delta);
+  animator->Step(fourth_effective_start + 1000 * delta);
 
   EXPECT_TRUE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
 
   base::TimeTicks fifth_effective_start = fourth_effective_start + 1001 * delta;
   test_controller.animator()->OnThreadedAnimationStarted(cc::AnimationEvent(
       cc::AnimationEvent::Started,
       0,
       test_controller.GetRunningSequence(LayerAnimationElement::OPACITY)
           ->animation_group_id(),
       cc::Animation::Opacity,
       fifth_effective_start));
 
   // Skip ahead by a lot.
-  element->Step(fifth_effective_start + 999 * delta);
+  animator->Step(fifth_effective_start + 999 * delta);
 
   EXPECT_TRUE(test_controller.animator()->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 
   test_controller.animator()->StopAnimatingProperty(
       LayerAnimationElement::OPACITY);
 
   EXPECT_FALSE(test_controller.animator()->is_animating());
 }
 
 TEST(LayerAnimatorTest, AddObserverExplicit) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationObserver observer;
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
   animator->AddObserver(&observer);
   observer.set_requires_notification_when_animator_destroyed(true);
 
   EXPECT_TRUE(!observer.last_ended_sequence());
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetBrightnessFromAnimation(0.0f);
 
   LayerAnimationSequence* sequence = new LayerAnimationSequence(
       LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
 
   animator->StartAnimation(sequence);
 
   EXPECT_EQ(observer.last_scheduled_sequence(), sequence);
 
   base::TimeTicks start_time = animator->last_step_time();
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_EQ(observer.last_ended_sequence(), sequence);
 
   // |sequence| has been destroyed. Recreate it to test abort.
   sequence = new LayerAnimationSequence(
       LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
 
   animator->StartAnimation(sequence);
 
   animator = NULL;
 
   EXPECT_EQ(observer.last_aborted_sequence(), sequence);
 }
 
 // Tests that an observer added to a scoped settings object is still notified
 // when the object goes out of scope.
 TEST(LayerAnimatorTest, ImplicitAnimationObservers) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestImplicitAnimationObserver observer(false);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   EXPECT_FALSE(observer.animations_completed());
   animator->SetBrightness(1.0f);
 
   {
     ScopedLayerAnimationSettings settings(animator.get());
     settings.AddObserver(&observer);
     animator->SetBrightness(0.0f);
   }
 
   EXPECT_FALSE(observer.animations_completed());
   base::TimeTicks start_time = animator->last_step_time();
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
   EXPECT_TRUE(observer.animations_completed());
   EXPECT_TRUE(observer.WasAnimationCompletedForProperty(
       LayerAnimationElement::BRIGHTNESS));
   EXPECT_FLOAT_EQ(0.0f, delegate.GetBrightnessForAnimation());
 }
 
 // Tests that an observer added to a scoped settings object is still notified
 // when the object goes out of scope due to the animation being interrupted.
 TEST(LayerAnimatorTest, InterruptedImplicitAnimationObservers) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
@@ skipping 21 matching lines @@
   EXPECT_FLOAT_EQ(1.0f, delegate.GetBrightnessForAnimation());
 }
 
 // Tests that LayerAnimator is not deleted after the animation completes as long
 // as there is a live ScopedLayerAnimationSettings object wrapped around it.
 TEST(LayerAnimatorTest, AnimatorKeptAliveBySettings) {
   // Note we are using a raw pointer unlike in other tests.
   TestLayerAnimator* animator = new TestLayerAnimator();
   LayerAnimatorDestructionObserver destruction_observer;
   animator->SetDestructionObserver(&destruction_observer);
-  AnimationContainerElement* element = animator;
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
   {
     // ScopedLayerAnimationSettings should keep the Animator alive as long as
     // it is alive, even beyond the end of the animation.
     ScopedLayerAnimationSettings settings(animator);
     base::TimeTicks now = gfx::FrameTime::Now();
     animator->SetBrightness(0.5);
-    element->Step(now + base::TimeDelta::FromSeconds(1));
+    animator->Step(now + base::TimeDelta::FromSeconds(1));
     EXPECT_FALSE(destruction_observer.IsAnimatorDeleted());
   }
   // ScopedLayerAnimationSettings was destroyed, so Animator should be deleted.
   EXPECT_TRUE(destruction_observer.IsAnimatorDeleted());
 }
 
 // Tests that an observer added to a scoped settings object is not notified
 // when the animator is destroyed unless explicitly requested.
 TEST(LayerAnimatorTest, ImplicitObserversAtAnimatorDestruction) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
@@ skipping 59 matching lines @@
   animator->AbortAllAnimations();
   EXPECT_TRUE(observer.animations_completed());
   EXPECT_TRUE(observer.WasAnimationAbortedForProperty(
       LayerAnimationElement::BRIGHTNESS));
   EXPECT_TRUE(observer.WasAnimationAbortedForProperty(
       LayerAnimationElement::OPACITY));
 }
 
 TEST(LayerAnimatorTest, RemoveObserverShouldRemoveFromSequences) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationObserver observer;
   TestLayerAnimationObserver removed_observer;
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   LayerAnimationSequence* sequence = new LayerAnimationSequence(
       LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
 
   sequence->AddObserver(&observer);
   sequence->AddObserver(&removed_observer);
 
   animator->StartAnimation(sequence);
 
   EXPECT_EQ(observer.last_scheduled_sequence(), sequence);
   EXPECT_TRUE(!observer.last_ended_sequence());
   EXPECT_EQ(removed_observer.last_scheduled_sequence(), sequence);
   EXPECT_TRUE(!removed_observer.last_ended_sequence());
 
   // This should stop the observer from observing sequence.
   animator->RemoveObserver(&removed_observer);
 
   base::TimeTicks start_time = animator->last_step_time();
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_EQ(observer.last_ended_sequence(), sequence);
   EXPECT_TRUE(!removed_observer.last_ended_sequence());
 }
 
 TEST(LayerAnimatorTest, ObserverReleasedBeforeAnimationSequenceEnds) {
   TestLayerAnimationDelegate delegate;
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
 
@@ skipping 15 matching lines @@
 
   // Now, release |observer|
   observer.reset();
 
   // And |sequence| should no longer be attached to |observer|.
   EXPECT_FALSE(sequence->observers_.might_have_observers());
 }
 
 TEST(LayerAnimatorTest, ObserverAttachedAfterAnimationStarted) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
 
   TestImplicitAnimationObserver observer(false);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   delegate.SetBrightnessFromAnimation(0.0f);
 
   {
     ScopedLayerAnimationSettings setter(animator.get());
 
     base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
     LayerAnimationSequence* sequence = new LayerAnimationSequence(
         LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
 
     animator->StartAnimation(sequence);
     base::TimeTicks start_time = animator->last_step_time();
-    element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
+    animator->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
     setter.AddObserver(&observer);
 
     // Start observing an in-flight animation.
     sequence->AddObserver(&observer);
 
-    element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+    animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
   }
 
   EXPECT_TRUE(observer.animations_completed());
   EXPECT_TRUE(observer.WasAnimationCompletedForProperty(
                   LayerAnimationElement::BRIGHTNESS));
 }
 
 TEST(LayerAnimatorTest, ObserverDetachedBeforeAnimationFinished) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
 
   TestImplicitAnimationObserver observer(false);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   delegate.SetBrightnessFromAnimation(0.0f);
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
   LayerAnimationSequence* sequence = new LayerAnimationSequence(
       LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
 
   {
     ScopedLayerAnimationSettings setter(animator.get());
     setter.AddObserver(&observer);
 
     animator->StartAnimation(sequence);
     base::TimeTicks start_time = animator->last_step_time();
-    element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
+    animator->Step(start_time + base::TimeDelta::FromMilliseconds(500));
   }
 
   EXPECT_FALSE(observer.animations_completed());
 
   // Stop observing an in-flight animation.
   sequence->RemoveObserver(&observer);
 
   EXPECT_TRUE(observer.animations_completed());
 
   // The animation didn't complete, and neither was it aborted.
   EXPECT_FALSE(observer.WasAnimationCompletedForProperty(
                   LayerAnimationElement::BRIGHTNESS));
   EXPECT_FALSE(observer.WasAnimationAbortedForProperty(
                   LayerAnimationElement::BRIGHTNESS));
 }
 
 // This checks that if an animation is deleted due to a callback, that the
 // animator does not try to use the deleted animation. For example, if we have
 // two running animations, and the first finishes and the resulting callback
 // causes the second to be deleted, we should not attempt to animate the second
 // animation.
 TEST(LayerAnimatorTest, ObserverDeletesAnimationsOnEnd) {
   ScopedAnimationDurationScaleMode normal_duration_mode(
       ScopedAnimationDurationScaleMode::NORMAL_DURATION);
   scoped_refptr<LayerAnimator> animator(new TestLayerAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_brightness(0.0);
   double target_brightness(1.0);
 
   gfx::Rect start_bounds(0, 0, 50, 50);
   gfx::Rect target_bounds(5, 5, 5, 5);
 
@@ skipping 13 matching lines @@
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBrightnessElement(
               target_brightness, brightness_delta)));
 
   animator->StartAnimation(new LayerAnimationSequence(
       LayerAnimationElement::CreateBoundsElement(
           target_bounds, bounds_delta)));
   ASSERT_TRUE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
 
   base::TimeTicks start_time = animator->last_step_time();
-  element->Step(start_time + halfway_delta);
+  animator->Step(start_time + halfway_delta);
 
   // Completing the brightness animation should have stopped the bounds
   // animation.
   ASSERT_FALSE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
 
   animator->RemoveObserver(observer.get());
 }
 
 // Ensure that stopping animation in a bounds change does not crash and that
 // animation gets stopped correctly.
@@ skipping 15 matching lines @@
     }
    private:
     LayerAnimator* animator_;
     int max_width_;
     // Allow copy and assign.
   };
 
   ScopedAnimationDurationScaleMode normal_duration_mode(
       ScopedAnimationDurationScaleMode::NORMAL_DURATION);
   scoped_refptr<LayerAnimator> animator(new TestLayerAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDeletingDelegate delegate(animator.get(), 30);
   animator->SetDelegate(&delegate);
 
   gfx::Rect start_bounds(0, 0, 0, 0);
   gfx::Rect target_bounds(5, 5, 50, 50);
 
   delegate.SetBoundsFromAnimation(start_bounds);
 
   base::TimeDelta bounds_delta1 = base::TimeDelta::FromMilliseconds(333);
   base::TimeDelta bounds_delta2 = base::TimeDelta::FromMilliseconds(666);
   base::TimeDelta bounds_delta = base::TimeDelta::FromMilliseconds(1000);
   base::TimeDelta final_delta = base::TimeDelta::FromMilliseconds(1500);
 
   animator->StartAnimation(new LayerAnimationSequence(
       LayerAnimationElement::CreateBoundsElement(
           target_bounds, bounds_delta)));
   ASSERT_TRUE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
 
   base::TimeTicks start_time = animator->last_step_time();
-  ASSERT_NO_FATAL_FAILURE(element->Step(start_time + bounds_delta1));
+  ASSERT_NO_FATAL_FAILURE(animator->Step(start_time + bounds_delta1));
   ASSERT_TRUE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
 
   // The next step should change the animated bounds past the threshold and
   // cause the animaton to stop.
-  ASSERT_NO_FATAL_FAILURE(element->Step(start_time + bounds_delta2));
+  ASSERT_NO_FATAL_FAILURE(animator->Step(start_time + bounds_delta2));
   ASSERT_FALSE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
-  ASSERT_NO_FATAL_FAILURE(element->Step(start_time + final_delta));
+  ASSERT_NO_FATAL_FAILURE(animator->Step(start_time + final_delta));
 
   // Completing the animation should have stopped the bounds
   // animation.
   ASSERT_FALSE(animator->IsAnimatingProperty(LayerAnimationElement::BOUNDS));
 }
 
 // Similar to the ObserverDeletesAnimationsOnEnd test above except that it
 // tests the behavior when the OnLayerAnimationAborted() callback causes
 // all of the animator's other animations to be deleted.
 TEST(LayerAnimatorTest, ObserverDeletesAnimationsOnAbort) {
@@ skipping 169 matching lines @@
 
     // Because the strategy is ENQUEUE_NEW_ANIMATION the target should now be 1.
     animator->SetGrayscale(1.0);
     EXPECT_EQ(1.0, animator->GetTargetGrayscale());
   }
 }
 
 // Verifies color property is modified appropriately.
 TEST(LayerAnimatorTest, Color) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
-  AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   SkColor start_color  = SkColorSetARGB( 64, 20, 40,  60);
   SkColor middle_color = SkColorSetARGB(128, 35, 70, 120);
   SkColor target_color = SkColorSetARGB(192, 40, 80, 140);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetColorFromAnimation(start_color);
 
   animator->ScheduleAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateColorElement(target_color, delta)));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_EQ(ColorToString(start_color),
             ColorToString(delegate.GetColorForAnimation()));
 
   base::TimeTicks start_time = animator->last_step_time();
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_EQ(ColorToString(middle_color),
             ColorToString(delegate.GetColorForAnimation()));
 
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_EQ(ColorToString(target_color),
             ColorToString(delegate.GetColorForAnimation()));
 }
 
 // Verifies SchedulePauseForProperties().
 TEST(LayerAnimatorTest, SchedulePauseForProperties) {
   scoped_refptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
@@ skipping 87 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(DeletingObserver);
 };
 
 TEST(LayerAnimatorTest, ObserverDeletesAnimatorAfterFinishingAnimation) {
   bool observer_was_deleted = false;
   DeletingObserver* observer = new DeletingObserver(&observer_was_deleted);
   observer->set_delete_on_animation_ended(true);
   observer->set_delete_on_animation_aborted(true);
   LayerAnimator* animator = observer->animator();
-  AnimationContainerElement* element = observer->animator();
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   delegate.SetBrightnessFromAnimation(0.0f);
 
   gfx::Rect start_bounds(0, 0, 50, 50);
   gfx::Rect target_bounds(10, 10, 100, 100);
 
   delegate.SetBoundsFromAnimation(start_bounds);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
   LayerAnimationSequence* brightness_sequence = new LayerAnimationSequence(
       LayerAnimationElement::CreateBrightnessElement(1.0f, delta));
   animator->StartAnimation(brightness_sequence);
 
   delta = base::TimeDelta::FromSeconds(2);
   LayerAnimationSequence* bounds_sequence = new LayerAnimationSequence(
       LayerAnimationElement::CreateBoundsElement(target_bounds, delta));
   animator->StartAnimation(bounds_sequence);
 
   base::TimeTicks start_time = animator->last_step_time();
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
+  animator->Step(start_time + base::TimeDelta::FromMilliseconds(1500));
 
   EXPECT_TRUE(observer_was_deleted);
 }
 
 TEST(LayerAnimatorTest, ObserverDeletesAnimatorAfterStoppingAnimating) {
   bool observer_was_deleted = false;
   DeletingObserver* observer = new DeletingObserver(&observer_was_deleted);
   observer->set_delete_on_animation_ended(true);
   observer->set_delete_on_animation_aborted(true);
   LayerAnimator* animator = observer->animator();
@@ skipping 145 matching lines @@
 
   parent.SetTransform(parent_end);
 
   EXPECT_TRUE(child.GetAnimator()->is_animating());
   EXPECT_TRUE(child.GetTargetTransform().IsIdentity())
     << child.GetTargetTransform().ToString();
 
 }
 
 }  // namespace ui