reland -- Disable animations during aura tests.

ui/gfx/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/gfx/compositor/layer_animator.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/time.h"
@@ skipping 115 matching lines @@
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
   animator->ScheduleAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 
-  base::TimeTicks start_time = animator->get_last_step_time_for_test();
+  base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
@@ skipping 27 matching lines @@
           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 
   animator->ScheduleAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBoundsElement(target_bounds, delta)));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
-  base::TimeTicks start_time = animator->get_last_step_time_for_test();
+  base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), middle_bounds);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_FALSE(animator->is_animating());
@@ skipping 22 matching lines @@
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 
   animator->ScheduleAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 
-  base::TimeTicks start_time = animator->get_last_step_time_for_test();
+  base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
@@ skipping 47 matching lines @@
   animator->ScheduleAnimation(bounds_and_opacity.release());
 
   animator->ScheduleAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateBoundsElement(start_bounds, delta)));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
-  base::TimeTicks start_time = animator->get_last_step_time_for_test();
+  base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
@@ skipping 51 matching lines @@
       LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
   sequences.push_back(new LayerAnimationSequence(
       LayerAnimationElement::CreateBoundsElement(target_bounds, delta)));
 
   animator->ScheduleTogether(sequences);
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
-  base::TimeTicks start_time = animator->get_last_step_time_for_test();
+  base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_FALSE(animator->is_animating());
@@ skipping 18 matching lines @@
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
 
-  base::TimeTicks start_time = animator->get_last_step_time_for_test();
+  base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
@@ skipping 43 matching lines @@
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
   animator->set_preemption_strategy(
       LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 
-  base::TimeTicks start_time = animator->get_last_step_time_for_test();
+  base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
 
@@ skipping 30 matching lines @@
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
   animator->set_preemption_strategy(LayerAnimator::ENQUEUE_NEW_ANIMATION);
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 
-  base::TimeTicks start_time = animator->get_last_step_time_for_test();
+  base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(start_opacity, delta)));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), middle_opacity);
 
@@ skipping 32 matching lines @@
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
   animator->set_preemption_strategy(LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 
-  base::TimeTicks start_time = animator->get_last_step_time_for_test();
+  base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(500));
 
   animator->StartAnimation(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(middle_opacity, delta)));
 
   // Queue should now have two animations. Starting a third should replace the
   // second.
   animator->StartAnimation(
@@ skipping 38 matching lines @@
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 
   sequence->AddElement(
       LayerAnimationElement::CreateOpacityElement(start_opacity, delta));
 
   sequence->set_is_cyclic(true);
 
   animator->StartAnimation(sequence.release());
 
-  base::TimeTicks start_time = animator->get_last_step_time_for_test();
+  base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), target_opacity);
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(2000));
 
   EXPECT_TRUE(animator->is_animating());
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
@@ skipping 36 matching lines @@
 
   delegate.SetOpacityFromAnimation(0.0f);
 
   LayerAnimationSequence* sequence = new LayerAnimationSequence(
       LayerAnimationElement::CreateOpacityElement(1.0f, delta));
 
   animator->StartAnimation(sequence);
 
   EXPECT_EQ(observer.last_scheduled_sequence(), sequence);
 
-  base::TimeTicks start_time = animator->get_last_step_time_for_test();
+  base::TimeTicks start_time = animator->last_step_time();
 
   element->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::CreateOpacityElement(1.0f, delta));
 
   animator->StartAnimation(sequence);
 
   animator.reset();
 
   EXPECT_EQ(observer.last_aborted_sequence(), sequence);
 }
 
-TEST(LayerAnimatorTest, AddObserverImplicit) {
-  scoped_ptr<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);
-
-  // Should end a sequence with the default animator.
-  EXPECT_TRUE(!observer.last_ended_sequence());
-  animator->SetOpacity(1.0f);
-  base::TimeTicks start_time = base::TimeTicks::Now();
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
-  EXPECT_TRUE(observer.last_ended_sequence());
-
-  TestLayerAnimationObserver scoped_observer;
-  {
-    ScopedLayerAnimationSettings settings(animator.get());
-    settings.AddObserver(&scoped_observer);
-    for (int i = 0; i < 2; ++i) {
-      // reset the observer
-      scoped_observer = TestLayerAnimationObserver();
-      EXPECT_TRUE(!scoped_observer.last_ended_sequence());
-      animator->SetOpacity(1.0f);
-      start_time = animator->get_last_step_time_for_test();
-      element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
-      EXPECT_FALSE(!scoped_observer.last_ended_sequence());
-    }
-  }
-
-  scoped_observer = TestLayerAnimationObserver();
-  EXPECT_TRUE(!scoped_observer.last_ended_sequence());
-  animator->SetOpacity(1.0f);
-  start_time = base::TimeTicks::Now();
-  element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
-  EXPECT_TRUE(!scoped_observer.last_ended_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_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   AnimationContainerElement* element = animator.get();
   animator->set_disable_timer_for_test(true);
   TestImplicitAnimationObserver observer;
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   EXPECT_FALSE(observer.animations_completed());
   animator->SetOpacity(1.0f);
 
   {
     ScopedLayerAnimationSettings settings(animator.get());
-    settings.AddImplicitObserver(&observer);
+    settings.AddObserver(&observer);
     animator->SetOpacity(0.0f);
   }
 
   EXPECT_FALSE(observer.animations_completed());
-  base::TimeTicks start_time = animator->get_last_step_time_for_test();
+  base::TimeTicks start_time = animator->last_step_time();
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
   EXPECT_TRUE(observer.animations_completed());
   EXPECT_FLOAT_EQ(0.0f, delegate.GetOpacityForAnimation());
 }
 
 // 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_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
   TestImplicitAnimationObserver observer;
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   EXPECT_FALSE(observer.animations_completed());
   animator->SetOpacity(1.0f);
 
   {
     ScopedLayerAnimationSettings settings(animator.get());
-    settings.AddImplicitObserver(&observer);
+    settings.AddObserver(&observer);
     animator->SetOpacity(0.0f);
   }
 
   EXPECT_FALSE(observer.animations_completed());
   // This should interrupt the implicit animation causing the observer to be
   // notified immediately.
   animator->SetOpacity(1.0f);
   EXPECT_TRUE(observer.animations_completed());
   EXPECT_FLOAT_EQ(1.0f, delegate.GetOpacityForAnimation());
 }
@@ skipping 18 matching lines @@
   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->get_last_step_time_for_test();
+  base::TimeTicks start_time = animator->last_step_time();
 
   element->Step(start_time + base::TimeDelta::FromMilliseconds(1000));
 
   EXPECT_EQ(observer.last_ended_sequence(), sequence);
   EXPECT_TRUE(!removed_observer.last_ended_sequence());
 }
 
 TEST(LayerAnimatorTest, ObserverReleasedBeforeAnimationSequenceEnds) {
   scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
@@ skipping 15 matching lines @@
   // |observer| should be attached to |sequence|.
   EXPECT_EQ(static_cast<size_t>(1), sequence->observers_.size());
 
   // Now, release |observer|
   observer.reset();
 
   // And |sequence| should no longer be attached to |observer|.
   EXPECT_EQ(static_cast<size_t>(0), sequence->observers_.size());
 }
 
+TEST(LayerAnimatorTest, ObserverAttachedAfterAnimationStarted) {
+  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  AnimationContainerElement* element = animator.get();
+  animator->set_disable_timer_for_test(true);
+
+  TestImplicitAnimationObserver observer;
+  TestLayerAnimationDelegate delegate;
+  animator->SetDelegate(&delegate);
+
+  delegate.SetOpacityFromAnimation(0.0f);
+
+  {
+    ScopedLayerAnimationSettings setter(animator.get());
+
+    base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
+    LayerAnimationSequence* sequence = new LayerAnimationSequence(
+        LayerAnimationElement::CreateOpacityElement(1.0f, delta));
+
+    animator->StartAnimation(sequence);
+    base::TimeTicks start_time = animator->last_step_time();
+    element->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));
+  }
+
+  EXPECT_TRUE(observer.animations_completed());
+}
+
+TEST(LayerAnimatorTest, ObserverDetachedBeforeAnimationFinished) {
+  scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
+  AnimationContainerElement* element = animator.get();
+  animator->set_disable_timer_for_test(true);
+
+  TestImplicitAnimationObserver observer;
+  TestLayerAnimationDelegate delegate;
+  animator->SetDelegate(&delegate);
+
+  delegate.SetOpacityFromAnimation(0.0f);
+  base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
+  LayerAnimationSequence* sequence = new LayerAnimationSequence(
+      LayerAnimationElement::CreateOpacityElement(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));
+  }
+
+  EXPECT_FALSE(observer.animations_completed());
+
+  // Stop observing an in-flight animation.
+  sequence->RemoveObserver(&observer);
+
+  EXPECT_TRUE(observer.animations_completed());
+}
+
 // Check that setting a property during an animation with a default animator
 // cancels the original animation.
 TEST(LayerAnimatorTest, SettingPropertyDuringAnAnimation) {
   scoped_ptr<LayerAnimator> animator(LayerAnimator::CreateDefaultAnimator());
   animator->set_disable_timer_for_test(true);
   TestLayerAnimationDelegate delegate;
   animator->SetDelegate(&delegate);
 
   double start_opacity(0.0);
   double target_opacity(1.0);
 
   base::TimeDelta delta = base::TimeDelta::FromSeconds(1);
 
   delegate.SetOpacityFromAnimation(start_opacity);
 
   scoped_ptr<LayerAnimationSequence> sequence(
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 
   animator->StartAnimation(sequence.release());
 
   animator->SetOpacity(0.5);
 
   EXPECT_FALSE(animator->is_animating());
   EXPECT_EQ(0.5, animator->GetTargetOpacity());
 }
 
 } // namespace ui