Introduce NON_ZERO_DURATION for animation unit tests

ui/compositor/layer_animation_element.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_animation_element.h"
 
 #include "base/compiler_specific.h"
 #include "cc/animation/animation.h"
 #include "cc/animation/animation_id_provider.h"
 #include "ui/compositor/float_animation_curve_adapter.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_animator.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 #include "ui/compositor/transform_animation_curve_adapter.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/interpolated_transform.h"
 
 namespace ui {
 
 namespace {
 
-// The factor by which duration is scaled up or down when
-// ScopedAnimationDurationScaleMode::duration_scale_mode() is SLOW_DURATION or
-// FAST_DURATION.
-const int kSlowDurationScaleFactor = 4;
-const int kFastDurationScaleFactor = 4;
+// The factor by which duration is scaled up or down when using
+// ScopedAnimationDurationScaleMode.
+const int kSlowDurationScaleMultiplier = 4;
+const int kFastDurationScaleDivisor = 4;
+const int kTestDurationScaleDivisor = 100;
 
 // Pause -----------------------------------------------------------------------
 class Pause : public LayerAnimationElement {
  public:
   Pause(AnimatableProperties properties, base::TimeDelta duration)
       : LayerAnimationElement(properties, duration) {
   }
   virtual ~Pause() {}
 
  private:
@@ skipping 716 matching lines @@
   }
 }
 
 // static
 base::TimeDelta LayerAnimationElement::GetEffectiveDuration(
     const base::TimeDelta& duration) {
   switch (ScopedAnimationDurationScaleMode::duration_scale_mode()) {
     case ScopedAnimationDurationScaleMode::NORMAL_DURATION:
       return duration;
     case ScopedAnimationDurationScaleMode::FAST_DURATION:
-      return duration / kFastDurationScaleFactor;
+      return duration / kFastDurationScaleDivisor;
     case ScopedAnimationDurationScaleMode::SLOW_DURATION:
-      return duration * kSlowDurationScaleFactor;
+      return duration * kSlowDurationScaleMultiplier;
+    case ScopedAnimationDurationScaleMode::NON_ZERO_DURATION:
+      return duration / kTestDurationScaleDivisor;
     case ScopedAnimationDurationScaleMode::ZERO_DURATION:
       return base::TimeDelta();
     default:
       NOTREACHED();
       return base::TimeDelta();
   }
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateTransformElement(
@@ skipping 66 matching lines @@
 }
 
 // static
 LayerAnimationElement* LayerAnimationElement::CreateColorElement(
     SkColor color,
     base::TimeDelta duration) {
   return new ColorTransition(color, duration);
 }
 
 }  // namespace ui