CC Animation: Expose TargetProperty enum to be aliased in Blink Platform.

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/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringprintf.h"
@@ skipping 357 matching lines @@
   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));
+      cc::TargetProperty::OPACITY, effective_start));
 
   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);
 
@@ skipping 88 matching lines @@
   EXPECT_FLOAT_EQ(delegate.GetOpacityForAnimation(), start_opacity);
   CheckApproximatelyEqual(delegate.GetBoundsForAnimation(), start_bounds);
 
   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));
+      cc::TargetProperty::OPACITY, effective_start));
 
   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);
@@ skipping 241 matching lines @@
   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));
+      cc::TargetProperty::OPACITY, effective_start));
 
   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);
 
@@ skipping 103 matching lines @@
       new LayerAnimationSequence(
           LayerAnimationElement::CreateOpacityElement(target_opacity, delta)));
 
   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));
+      cc::TargetProperty::OPACITY, effective_start));
 
   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));
+      cc::TargetProperty::OPACITY, second_effective_start));
 
   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);
 
@@ skipping 279 matching lines @@
                                                          delta)
       ));
 
   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));
+      cc::TargetProperty::OPACITY, effective_start));
 
   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));
+      cc::TargetProperty::OPACITY, second_effective_start));
 
   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(),
@@ skipping 223 matching lines @@
 
   test_controller.animator()->StartAnimation(sequence.release());
 
   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));
+      cc::TargetProperty::OPACITY, effective_start));
 
   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));
+      cc::TargetProperty::OPACITY, second_effective_start));
 
   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));
+      cc::TargetProperty::OPACITY, third_effective_start));
 
   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));
+      cc::TargetProperty::OPACITY, fourth_effective_start));
 
   // Skip ahead by a lot.
   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));
+      cc::TargetProperty::OPACITY, fifth_effective_start));
 
   // Skip ahead by a lot.
   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);
 
@@ skipping 1272 matching lines @@
   EXPECT_EQ(observer.last_ended_sequence(), nullptr);
   EXPECT_EQ(observer.last_detached_sequence(), first_sequence);
 
   EXPECT_TRUE(observer.AbortedEpochIsBeforeDetachedEpoch());
   EXPECT_TRUE(observer.AbortedEpochIsBeforeStartedEpoch());
   EXPECT_TRUE(observer.AttachedEpochIsBeforeScheduledEpoch());
   EXPECT_TRUE(observer.ScheduledEpochIsBeforeStartedEpoch());
 }
 
 }  // namespace ui