reland -- Disable animations during aura tests.

ui/gfx/compositor/layer_animator.h

 // 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.
 
 #ifndef UI_GFX_COMPOSITOR_LAYER_ANIMATOR_H_
 #define UI_GFX_COMPOSITOR_LAYER_ANIMATOR_H_
 #pragma once
 
 #include <deque>
 #include <vector>
@@ skipping 15 matching lines @@
 class Animation;
 class Layer;
 class LayerAnimationSequence;
 class LayerAnimationDelegate;
 class LayerAnimationObserver;
 class ScopedLayerAnimationSettings;
 class Transform;
 
 // When a property of layer needs to be changed it is set by way of
 // LayerAnimator. This enables LayerAnimator to animate property changes.
+// NB: during many tests, set_disable_animations_for_test is used and causes
+// all animations to complete immediately.
 class COMPOSITOR_EXPORT LayerAnimator : public AnimationContainerElement {
  public:
   enum PreemptionStrategy {
     IMMEDIATELY_SET_NEW_TARGET,
     IMMEDIATELY_ANIMATE_TO_NEW_TARGET,
     ENQUEUE_NEW_ANIMATION,
     REPLACE_QUEUED_ANIMATIONS,
     BLEND_WITH_CURRENT_ANIMATION
   };
 
@@ skipping 55 matching lines @@
 
   // Stops animating the given property. No effect if there is no running
   // animation for the given property. Skips to the final state of the
   // animation.
   void StopAnimatingProperty(
       LayerAnimationElement::AnimatableProperty property);
 
   // Stops all animation and clears any queued animations.
   void StopAnimating();
 
-  // For testing purposes only.
-  void set_disable_timer_for_test(bool enabled) {
-    disable_timer_for_test_ = enabled;
-  }
-  base::TimeTicks get_last_step_time_for_test() { return last_step_time_; }
-
   // These functions are used for adding or removing observers from the observer
   // list. The observers are notified when animations end.
   void AddObserver(LayerAnimationObserver* observer);
   void RemoveObserver(LayerAnimationObserver* observer);
 
+  // For testing purposes only.
+  void set_disable_timer_for_test(bool disable_timer) {
+    disable_timer_for_test_ = disable_timer;
+  }
+  base::TimeTicks last_step_time() const { return last_step_time_; }
+
+  // When set to true, all animations complete immediately.
+  static void set_disable_animations_for_test(bool disable_animations) {
+    disable_animations_for_test_ = disable_animations;
+  }
+
  protected:
   LayerAnimationDelegate* delegate() { return delegate_; }
   const LayerAnimationDelegate* delegate() const { return delegate_; }
 
  private:
   friend class ScopedLayerAnimationSettings;
 
   // We need to keep track of the start time of every running animation.
   struct RunningAnimation {
     RunningAnimation(LayerAnimationSequence* sequence,
@@ skipping 94 matching lines @@
   // Used for coordinating the starting of animations.
   base::TimeTicks last_step_time_;
 
   // True if we are being stepped by our container.
   bool is_started_;
 
   // This prevents the animator from automatically stepping through animations
   // and allows for manual stepping.
   bool disable_timer_for_test_;
 
+  // This causes all animations to complete immediately.
+  static bool disable_animations_for_test_;
+
   // Observers are notified when layer animations end, are scheduled or are
   // aborted.
   ObserverList<LayerAnimationObserver> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerAnimator);
 };
 
 }  // namespace ui
 
 #endif  // UI_GFX_COMPOSITOR_LAYER_ANIMATOR_H_