Remove unused cc::Animation RunStates

This removes cc::Animation::WaitingForNextTick and
cc::Animation::WaitingForStartTime. These run states are
not currently used.

BUG=None

Review URL: https://codereview.chromium.org/77283004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@236427 0039d316-1c4b-4281-b951-d872f2087c98

6 files changed, 16 insertions, 219 deletions

diff --git a/cc/animation/animation.cc b/cc/animation/animation.cc
index 6b5966b..78af70f 100644
--- a/cc/animation/animation.cc
+++ b/cc/animation/animation.cc
@@ -14,9 +14,7 @@ namespace {
 
 // This should match the RunState enum.
 static const char* const s_runStateNames[] = {
-  "WaitingForNextTick",
   "WaitingForTargetAvailability",
-  "WaitingForStartTime",
   "WaitingForDeletion",
   "Starting",
   "Running",
@@ -93,9 +91,7 @@ void Animation::SetRunState(RunState run_state, double monotonic_time) {
                  group_,
                  is_controlling_instance_ ? "(impl)" : "");
 
-  bool is_waiting_to_start = run_state_ == WaitingForNextTick ||
-                             run_state_ == WaitingForTargetAvailability ||
-                             run_state_ == WaitingForStartTime ||
+  bool is_waiting_to_start = run_state_ == WaitingForTargetAvailability ||
                              run_state_ == Starting;
 
   if (is_waiting_to_start && run_state == Running) {
diff --git a/cc/animation/animation.h b/cc/animation/animation.h
index f640318..4280bc8 100644
--- a/cc/animation/animation.h
+++ b/cc/animation/animation.h
@@ -13,26 +13,21 @@ namespace cc {
 
 class AnimationCurve;
 
-// An Animation, contains all the state required to play an AnimationCurve.
+// An Animation contains all the state required to play an AnimationCurve.
 // Specifically, the affected property, the run state (paused, finished, etc.),
 // loop count, last pause time, and the total time spent paused.
 class CC_EXPORT Animation {
  public:
-  // Animations begin in one of the 'waiting' states. Animations waiting for the
-  // next tick will start the next time the controller animates. Animations
-  // waiting for target availibility will run as soon as their target property
+  // Animations begin in the 'WaitingForTargetAvailability' state. An Animation
+  // waiting for target availibility will run as soon as its target property
   // is free (and all the animations animating with it are also able to run).
-  // Animations waiting for their start time to come have be scheduled to run at
-  // a particular point in time. When this time arrives, the controller will
-  // move the animations into the Starting state, and then into the Running
-  // state. Running animations may toggle between Running and Paused, and may be
-  // stopped by moving into either the Aborted or Finished states. A Finished
-  // animation was allowed to run to completion, but an Aborted animation was
-  // not.
+  // When this time arrives, the controller will move the animation into the
+  // Starting state, and then into the Running state. Running animations may
+  // toggle between Running and Paused, and may be stopped by moving into either
+  // the Aborted or Finished states. A Finished animation was allowed to run to
+  // completion, but an Aborted animation was not.
   enum RunState {
-    WaitingForNextTick = 0,
-    WaitingForTargetAvailability,
-    WaitingForStartTime,
+    WaitingForTargetAvailability = 0,
     WaitingForDeletion,
     Starting,
     Running,
diff --git a/cc/animation/animation_unittest.cc b/cc/animation/animation_unittest.cc
index 23d4169..d3ce8ac 100644
--- a/cc/animation/animation_unittest.cc
+++ b/cc/animation/animation_unittest.cc
@@ -177,12 +177,8 @@ TEST(AnimationTest, IsFinishedAtNotRunning) {
   EXPECT_TRUE(anim->IsFinishedAt(0.0));
   anim->SetRunState(Animation::Paused, 0.0);
   EXPECT_FALSE(anim->IsFinishedAt(0.0));
-  anim->SetRunState(Animation::WaitingForNextTick, 0.0);
-  EXPECT_FALSE(anim->IsFinishedAt(0.0));
   anim->SetRunState(Animation::WaitingForTargetAvailability, 0.0);
   EXPECT_FALSE(anim->IsFinishedAt(0.0));
-  anim->SetRunState(Animation::WaitingForStartTime, 0.0);
-  EXPECT_FALSE(anim->IsFinishedAt(0.0));
   anim->SetRunState(Animation::Finished, 0.0);
   EXPECT_TRUE(anim->IsFinishedAt(0.0));
   anim->SetRunState(Animation::Aborted, 0.0);
@@ -195,12 +191,8 @@ TEST(AnimationTest, IsFinished) {
   EXPECT_FALSE(anim->is_finished());
   anim->SetRunState(Animation::Paused, 0.0);
   EXPECT_FALSE(anim->is_finished());
-  anim->SetRunState(Animation::WaitingForNextTick, 0.0);
-  EXPECT_FALSE(anim->is_finished());
   anim->SetRunState(Animation::WaitingForTargetAvailability, 0.0);
   EXPECT_FALSE(anim->is_finished());
-  anim->SetRunState(Animation::WaitingForStartTime, 0.0);
-  EXPECT_FALSE(anim->is_finished());
   anim->SetRunState(Animation::Finished, 0.0);
   EXPECT_TRUE(anim->is_finished());
   anim->SetRunState(Animation::Aborted, 0.0);
@@ -213,12 +205,8 @@ TEST(AnimationTest, IsFinishedNeedsSynchronizedStartTime) {
   EXPECT_FALSE(anim->is_finished());
   anim->SetRunState(Animation::Paused, 2.0);
   EXPECT_FALSE(anim->is_finished());
-  anim->SetRunState(Animation::WaitingForNextTick, 2.0);
-  EXPECT_FALSE(anim->is_finished());
   anim->SetRunState(Animation::WaitingForTargetAvailability, 2.0);
   EXPECT_FALSE(anim->is_finished());
-  anim->SetRunState(Animation::WaitingForStartTime, 2.0);
-  EXPECT_FALSE(anim->is_finished());
   anim->SetRunState(Animation::Finished, 0.0);
   EXPECT_TRUE(anim->is_finished());
   anim->SetRunState(Animation::Aborted, 0.0);
diff --git a/cc/animation/layer_animation_controller.cc b/cc/animation/layer_animation_controller.cc
index 5279591..ea7436c 100644
--- a/cc/animation/layer_animation_controller.cc
+++ b/cc/animation/layer_animation_controller.cc
@@ -124,10 +124,7 @@ void LayerAnimationController::Animate(double monotonic_time) {
   if (!HasValueObserver())
     return;
 
-  StartAnimationsWaitingForNextTick(monotonic_time);
-  StartAnimationsWaitingForStartTime(monotonic_time);
-  StartAnimationsWaitingForTargetAvailability(monotonic_time);
-  ResolveConflicts(monotonic_time);
+  StartAnimations(monotonic_time);
   TickAnimations(monotonic_time);
   last_tick_time_ = monotonic_time;
 }
@@ -204,7 +201,7 @@ void LayerAnimationController::UpdateState(bool start_ready_animations,
   MarkAnimationsForDeletion(last_tick_time_, events);
 
   if (start_ready_animations) {
-    StartAnimationsWaitingForTargetAvailability(last_tick_time_);
+    StartAnimations(last_tick_time_);
     PromoteStartedAnimations(last_tick_time_, events);
   }
 
@@ -468,25 +465,7 @@ void LayerAnimationController::PushPropertiesToImplThread(
   }
 }
 
-void LayerAnimationController::StartAnimationsWaitingForNextTick(
-    double monotonic_time) {
-  for (size_t i = 0; i < active_animations_.size(); ++i) {
-    if (active_animations_[i]->run_state() == Animation::WaitingForNextTick)
-      active_animations_[i]->SetRunState(Animation::Starting, monotonic_time);
-  }
-}
-
-void LayerAnimationController::StartAnimationsWaitingForStartTime(
-    double monotonic_time) {
-  for (size_t i = 0; i < active_animations_.size(); ++i) {
-    if (active_animations_[i]->run_state() == Animation::WaitingForStartTime &&
-        active_animations_[i]->start_time() <= monotonic_time)
-      active_animations_[i]->SetRunState(Animation::Starting, monotonic_time);
-  }
-}
-
-void LayerAnimationController::StartAnimationsWaitingForTargetAvailability(
-    double monotonic_time) {
+void LayerAnimationController::StartAnimations(double monotonic_time) {
   // First collect running properties.
   TargetProperties blocked_properties;
   for (size_t i = 0; i < active_animations_.size(); ++i) {
@@ -567,34 +546,6 @@ void LayerAnimationController::MarkFinishedAnimations(double monotonic_time) {
   }
 }
 
-void LayerAnimationController::ResolveConflicts(double monotonic_time) {
-  // Find any animations that are animating the same property and resolve the
-  // confict. We could eventually blend, but for now we'll just abort the
-  // previous animation (where 'previous' means: (1) has a prior start time or
-  // (2) has an equal start time, but was added to the queue earlier, i.e.,
-  // has a lower index in active_animations_).
-  for (size_t i = 0; i < active_animations_.size(); ++i) {
-    if (active_animations_[i]->run_state() == Animation::Starting ||
-        active_animations_[i]->run_state() == Animation::Running) {
-      for (size_t j = i + 1; j < active_animations_.size(); ++j) {
-        if ((active_animations_[j]->run_state() == Animation::Starting ||
-             active_animations_[j]->run_state() == Animation::Running) &&
-            active_animations_[i]->target_property() ==
-            active_animations_[j]->target_property()) {
-          if (active_animations_[i]->start_time() >
-              active_animations_[j]->start_time()) {
-            active_animations_[j]->SetRunState(Animation::Aborted,
-                                               monotonic_time);
-          } else {
-            active_animations_[i]->SetRunState(Animation::Aborted,
-                                               monotonic_time);
-          }
-        }
-      }
-    }
-  }
-}
-
 void LayerAnimationController::MarkAnimationsForDeletion(
     double monotonic_time, AnimationEventsVector* events) {
   bool marked_animations_for_deletions = false;
diff --git a/cc/animation/layer_animation_controller.h b/cc/animation/layer_animation_controller.h
index 6df5c05..705fd7f 100644
--- a/cc/animation/layer_animation_controller.h
+++ b/cc/animation/layer_animation_controller.h
@@ -117,10 +117,7 @@ class CC_EXPORT LayerAnimationController
   void PushPropertiesToImplThread(
       LayerAnimationController* controller_impl) const;
 
-  void StartAnimationsWaitingForNextTick(double monotonic_time);
-  void StartAnimationsWaitingForStartTime(double monotonic_time);
-  void StartAnimationsWaitingForTargetAvailability(double monotonic_time);
-  void ResolveConflicts(double monotonic_time);
+  void StartAnimations(double monotonic_time);
   void PromoteStartedAnimations(double monotonic_time,
                                 AnimationEventsVector* events);
   void MarkFinishedAnimations(double monotonic_time);
diff --git a/cc/animation/layer_animation_controller_unittest.cc b/cc/animation/layer_animation_controller_unittest.cc
index 6b77cd2..9098e3e 100644
--- a/cc/animation/layer_animation_controller_unittest.cc
+++ b/cc/animation/layer_animation_controller_unittest.cc
@@ -730,10 +730,10 @@ TEST(LayerAnimationControllerTest, Interrupt) {
           new FakeFloatTransition(1.0, 1.f, 0.5f)).Pass(),
       2,
       Animation::Opacity));
-  to_add->SetRunState(Animation::WaitingForNextTick, 0);
+  controller->AbortAnimations(Animation::Opacity);
   controller->AddAnimation(to_add.Pass());
 
-  // Since the animation was in the WaitingForNextTick state, it should start
+  // Since the previous animation was aborted, the new animation should start
   // right in this call to animate.
   controller->Animate(0.5);
   controller->UpdateState(true, events.get());
@@ -831,136 +831,6 @@ TEST(LayerAnimationControllerTest, ScheduleTogetherWithAnAnimWaiting) {
   EXPECT_FALSE(controller->HasActiveAnimation());
 }
 
-// Tests scheduling an animation to start in the future.
-TEST(LayerAnimationControllerTest, ScheduleAnimation) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
-  FakeLayerAnimationValueObserver dummy;
-  scoped_refptr<LayerAnimationController> controller(
-      LayerAnimationController::Create(0));
-  controller->AddValueObserver(&dummy);
-
-  scoped_ptr<Animation> to_add(CreateAnimation(
-      scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)).Pass(),
-      1,
-      Animation::Opacity));
-  to_add->SetRunState(Animation::WaitingForStartTime, 0);
-  to_add->set_start_time(1.f);
-  controller->AddAnimation(to_add.Pass());
-
-  controller->Animate(0.0);
-  controller->UpdateState(true, events.get());
-  EXPECT_TRUE(controller->HasActiveAnimation());
-  EXPECT_EQ(0.f, dummy.opacity());
-  controller->Animate(1.0);
-  controller->UpdateState(true, events.get());
-  EXPECT_TRUE(controller->HasActiveAnimation());
-  EXPECT_EQ(0.f, dummy.opacity());
-  controller->Animate(2.0);
-  controller->UpdateState(true, events.get());
-  EXPECT_EQ(1.f, dummy.opacity());
-  EXPECT_FALSE(controller->HasActiveAnimation());
-}
-
-// Tests scheduling an animation to start in the future that's interrupting a
-// running animation.
-TEST(LayerAnimationControllerTest,
-     ScheduledAnimationInterruptsRunningAnimation) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
-  FakeLayerAnimationValueObserver dummy;
-  scoped_refptr<LayerAnimationController> controller(
-      LayerAnimationController::Create(0));
-  controller->AddValueObserver(&dummy);
-
-  controller->AddAnimation(CreateAnimation(
-      scoped_ptr<AnimationCurve>(new FakeFloatTransition(2.0, 0.f, 1.f)).Pass(),
-      1,
-      Animation::Opacity));
-
-  scoped_ptr<Animation> to_add(CreateAnimation(
-      scoped_ptr<AnimationCurve>(
-          new FakeFloatTransition(1.0, 0.5f, 0.f)).Pass(),
-      2,
-      Animation::Opacity));
-  to_add->SetRunState(Animation::WaitingForStartTime, 0);
-  to_add->set_start_time(1.f);
-  controller->AddAnimation(to_add.Pass());
-
-  // First 2s opacity transition should start immediately.
-  controller->Animate(0.0);
-  controller->UpdateState(true, events.get());
-  EXPECT_TRUE(controller->HasActiveAnimation());
-  EXPECT_EQ(0.f, dummy.opacity());
-  controller->Animate(0.5);
-  controller->UpdateState(true, events.get());
-  EXPECT_TRUE(controller->HasActiveAnimation());
-  EXPECT_EQ(0.25f, dummy.opacity());
-  controller->Animate(1.0);
-  controller->UpdateState(true, events.get());
-  EXPECT_TRUE(controller->HasActiveAnimation());
-  EXPECT_EQ(0.5f, dummy.opacity());
-  controller->Animate(2.0);
-  controller->UpdateState(true, events.get());
-  EXPECT_EQ(0.f, dummy.opacity());
-  EXPECT_FALSE(controller->HasActiveAnimation());
-}
-
-// Tests scheduling an animation to start in the future that interrupts a
-// running animation and there is yet another animation queued to start later.
-TEST(LayerAnimationControllerTest,
-     ScheduledAnimationInterruptsRunningAnimationWithAnimInQueue) {
-  scoped_ptr<AnimationEventsVector> events(
-      make_scoped_ptr(new AnimationEventsVector));
-  FakeLayerAnimationValueObserver dummy;
-  scoped_refptr<LayerAnimationController> controller(
-      LayerAnimationController::Create(0));
-  controller->AddValueObserver(&dummy);
-
-  controller->AddAnimation(CreateAnimation(
-      scoped_ptr<AnimationCurve>(new FakeFloatTransition(2.0, 0.f, 1.f)).Pass(),
-      1,
-      Animation::Opacity));
-
-  scoped_ptr<Animation> to_add(CreateAnimation(
-      scoped_ptr<AnimationCurve>(
-          new FakeFloatTransition(2.0, 0.5f, 0.f)).Pass(),
-      2,
-      Animation::Opacity));
-  to_add->SetRunState(Animation::WaitingForStartTime, 0);
-  to_add->set_start_time(1.f);
-  controller->AddAnimation(to_add.Pass());
-
-  controller->AddAnimation(CreateAnimation(
-      scoped_ptr<AnimationCurve>(
-          new FakeFloatTransition(1.0, 0.f, 0.75f)).Pass(),
-      3,
-      Animation::Opacity));
-
-  // First 2s opacity transition should start immediately.
-  controller->Animate(0.0);
-  controller->UpdateState(true, events.get());
-  EXPECT_TRUE(controller->HasActiveAnimation());
-  EXPECT_EQ(0.f, dummy.opacity());
-  controller->Animate(0.5);
-  controller->UpdateState(true, events.get());
-  EXPECT_TRUE(controller->HasActiveAnimation());
-  EXPECT_EQ(0.25f, dummy.opacity());
-  EXPECT_TRUE(controller->HasActiveAnimation());
-  controller->Animate(1.0);
-  controller->UpdateState(true, events.get());
-  EXPECT_TRUE(controller->HasActiveAnimation());
-  EXPECT_EQ(0.5f, dummy.opacity());
-  controller->Animate(3.0);
-  controller->UpdateState(true, events.get());
-  EXPECT_TRUE(controller->HasActiveAnimation());
-  EXPECT_EQ(0.f, dummy.opacity());
-  controller->Animate(4.0);
-  controller->UpdateState(true, events.get());
-  EXPECT_EQ(0.75f, dummy.opacity());
-  EXPECT_FALSE(controller->HasActiveAnimation());
-}
-
 // Test that a looping animation loops and for the correct number of iterations.
 TEST(LayerAnimationControllerTest, TrivialLooping) {
   scoped_ptr<AnimationEventsVector> events(