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

cc/trees/layer_tree_host_unittest_animation.cc

 // Copyright 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 "cc/trees/layer_tree_host.h"
 
 #include <stdint.h>
 
 #include "cc/animation/animation_curve.h"
 #include "cc/animation/layer_animation_controller.h"
@@ skipping 118 matching lines @@
     PostAddInstantAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
   void UpdateAnimationState(LayerTreeHostImpl* host_impl,
                             bool has_unfinished_animation) override {
     EXPECT_FALSE(has_unfinished_animation);
     update_animation_state_was_called_ = true;
   }
 
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
-                              Animation::TargetProperty target_property,
+                              AnimationTargetProperty target_property,
                               int group) override {
     EXPECT_LT(base::TimeTicks(), monotonic_time);
 
     LayerAnimationController* controller =
         layer_tree_host()->root_layer()->layer_animation_controller();
-    Animation* animation = controller->GetAnimation(Animation::OPACITY);
+    Animation* animation =
+        controller->GetAnimation(AnimationTargetProperty::OPACITY);
     if (animation)
       controller->RemoveAnimation(animation->id());
 
     EndTest();
   }
 
   void AfterTest() override { EXPECT_TRUE(update_animation_state_was_called_); }
 
  private:
   bool update_animation_state_was_called_;
@@ skipping 57 matching lines @@
     if (!started_animating_ && have_animations) {
       started_animating_ = true;
       return;
     }
 
     if (started_animating_ && !have_animations)
       EndTest();
   }
 
   void NotifyAnimationFinished(base::TimeTicks monotonic_time,
-                               Animation::TargetProperty target_property,
+                               AnimationTargetProperty target_property,
                                int group) override {
     // Animations on the impl-side controller only get deleted during a commit,
     // so we need to schedule a commit.
     layer_tree_host()->SetNeedsCommit();
   }
 
   void AfterTest() override {}
 
  private:
   bool started_animating_;
@@ skipping 17 matching lines @@
 
   void AnimateLayers(LayerTreeHostImpl* host_impl,
                      base::TimeTicks monotonic_time) override {
     // TODO(ajuma): This test only checks the active tree. Add checks for
     // pending tree too.
     if (!host_impl->active_tree()->root_layer())
       return;
     LayerAnimationController* controller_impl =
         host_impl->active_tree()->root_layer()->children()[0]->
         layer_animation_controller();
-    Animation* animation = controller_impl->GetAnimation(Animation::OPACITY);
+    Animation* animation =
+        controller_impl->GetAnimation(AnimationTargetProperty::OPACITY);
     if (!animation)
       return;
 
     const FloatAnimationCurve* curve =
         animation->curve()->ToFloatAnimationCurve();
     float start_opacity = curve->GetValue(base::TimeDelta());
     float end_opacity = curve->GetValue(curve->Duration());
     float linearly_interpolated_opacity =
         0.25f * end_opacity + 0.75f * start_opacity;
     base::TimeDelta time = TimeUtil::Scale(curve->Duration(), 0.25f);
@@ skipping 24 matching lines @@
     picture_ = FakePictureLayer::Create(layer_settings(), &client_);
     picture_->SetBounds(gfx::Size(4, 4));
     client_.set_bounds(picture_->bounds());
     picture_->set_layer_animation_delegate(this);
     layer_tree_host()->root_layer()->AddChild(picture_);
   }
 
   void BeginTest() override { PostAddAnimationToMainThread(picture_.get()); }
 
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
-                              Animation::TargetProperty target_property,
+                              AnimationTargetProperty target_property,
                               int group) override {
     LayerAnimationController* controller =
         layer_tree_host()->root_layer()->children()[0]->
         layer_animation_controller();
-    Animation* animation = controller->GetAnimation(Animation::OPACITY);
+    Animation* animation =
+        controller->GetAnimation(AnimationTargetProperty::OPACITY);
     main_start_time_ = animation->start_time();
     controller->RemoveAnimation(animation->id());
     EndTest();
   }
 
   void UpdateAnimationState(LayerTreeHostImpl* impl_host,
                             bool has_unfinished_animation) override {
     LayerAnimationController* controller =
         impl_host->active_tree()->root_layer()->children()[0]->
         layer_animation_controller();
-    Animation* animation = controller->GetAnimation(Animation::OPACITY);
+    Animation* animation =
+        controller->GetAnimation(AnimationTargetProperty::OPACITY);
     if (!animation)
       return;
 
     impl_start_time_ = animation->start_time();
   }
 
   void AfterTest() override {
     EXPECT_EQ(impl_start_time_, main_start_time_);
     EXPECT_LT(base::TimeTicks(), impl_start_time_);
   }
@@ skipping 10 matching lines @@
 
 // Ensures that notify animation finished is called.
 class LayerTreeHostAnimationTestAnimationFinishedEvents
     : public LayerTreeHostAnimationTest {
  public:
   void BeginTest() override {
     PostAddInstantAnimationToMainThread(layer_tree_host()->root_layer());
   }
 
   void NotifyAnimationFinished(base::TimeTicks monotonic_time,
-                               Animation::TargetProperty target_property,
+                               AnimationTargetProperty target_property,
                                int group) override {
     LayerAnimationController* controller =
         layer_tree_host()->root_layer()->layer_animation_controller();
-    Animation* animation = controller->GetAnimation(Animation::OPACITY);
+    Animation* animation =
+        controller->GetAnimation(AnimationTargetProperty::OPACITY);
     if (animation)
       controller->RemoveAnimation(animation->id());
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestAnimationFinishedEvents);
@@ skipping 15 matching lines @@
   }
 
   void BeginTest() override {
     PostAddAnimationToMainThread(update_check_layer_.get());
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     LayerAnimationController* controller_impl =
         host_impl->active_tree()->root_layer()->layer_animation_controller();
     Animation* animation_impl =
-        controller_impl->GetAnimation(Animation::OPACITY);
+        controller_impl->GetAnimation(AnimationTargetProperty::OPACITY);
     controller_impl->RemoveAnimation(animation_impl->id());
     EndTest();
   }
 
   void AfterTest() override {
     // Update() should have been called once, proving that the layer was not
     // skipped.
     EXPECT_EQ(1, update_check_layer_->update_count());
 
     // clear update_check_layer_ so LayerTreeHost dies.
@@ skipping 15 matching lines @@
  public:
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     if (layer_tree_host()->source_frame_number() == 1) {
       scoped_refptr<Layer> layer = Layer::Create(layer_settings());
       layer->set_layer_animation_delegate(this);
 
       // Any valid AnimationCurve will do here.
       scoped_ptr<AnimationCurve> curve(new FakeFloatAnimationCurve());
-      scoped_ptr<Animation> animation(
-          Animation::Create(std::move(curve), 1, 1, Animation::OPACITY));
+      scoped_ptr<Animation> animation(Animation::Create(
+          std::move(curve), 1, 1, AnimationTargetProperty::OPACITY));
       layer->layer_animation_controller()->AddAnimation(std::move(animation));
 
       // We add the animation *before* attaching the layer to the tree.
       layer_tree_host()->root_layer()->AddChild(layer);
     }
   }
 
   void AnimateLayers(LayerTreeHostImpl* impl_host,
                      base::TimeTicks monotonic_time) override {
     EndTest();
@@ skipping 168 matching lines @@
         AddOpacityTransitionToLayer(picture_.get(), 0.1, 0.2f, 0.8f, false);
         break;
       case 2:
         // This second animation will not be drawn so it should not start.
         AddAnimatedTransformToLayer(picture_.get(), 0.1, 5, 5);
         break;
     }
   }
 
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
-                              Animation::TargetProperty target_property,
+                              AnimationTargetProperty target_property,
                               int group) override {
     if (TestEnded())
       return;
     started_times_++;
   }
 
   void AfterTest() override {
     // Make sure we tried to draw the second animation but failed.
     EXPECT_LT(0, prevented_draw_);
     // The first animation should be started, but the second should not because
@@ skipping 30 matching lines @@
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1: {
         scoped_ptr<ScrollOffsetAnimationCurve> curve(
             ScrollOffsetAnimationCurve::Create(
                 gfx::ScrollOffset(500.f, 550.f),
                 EaseInOutTimingFunction::Create()));
         scoped_ptr<Animation> animation(Animation::Create(
-            std::move(curve), 1, 0, Animation::SCROLL_OFFSET));
+            std::move(curve), 1, 0, AnimationTargetProperty::SCROLL_OFFSET));
         animation->set_needs_synchronized_start_time(true);
         bool animation_added =
             scroll_layer_->AddAnimation(std::move(animation));
         bool impl_scrolling_supported =
             layer_tree_host()->proxy()->SupportsImplScrolling();
         EXPECT_EQ(impl_scrolling_supported, animation_added);
         if (!impl_scrolling_supported)
           EndTest();
         break;
       }
@@ skipping 30 matching lines @@
     scroll_layer_ = FakePictureLayer::Create(layer_settings(), &client_);
     scroll_layer_->SetScrollClipLayerId(layer_tree_host()->root_layer()->id());
     scroll_layer_->SetBounds(gfx::Size(10000, 10000));
     client_.set_bounds(scroll_layer_->bounds());
     scroll_layer_->SetScrollOffset(gfx::ScrollOffset(100.0, 200.0));
     layer_tree_host()->root_layer()->AddChild(scroll_layer_);
 
     scoped_ptr<ScrollOffsetAnimationCurve> curve(
         ScrollOffsetAnimationCurve::Create(gfx::ScrollOffset(6500.f, 7500.f),
                                            EaseInOutTimingFunction::Create()));
-    scoped_ptr<Animation> animation(
-        Animation::Create(std::move(curve), 1, 0, Animation::SCROLL_OFFSET));
+    scoped_ptr<Animation> animation(Animation::Create(
+        std::move(curve), 1, 0, AnimationTargetProperty::SCROLL_OFFSET));
     animation->set_needs_synchronized_start_time(true);
     scroll_layer_->AddAnimation(std::move(animation));
   }
 
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void BeginMainFrame(const BeginFrameArgs& args) override {
     switch (layer_tree_host()->source_frame_number()) {
       case 0:
         break;
       case 1: {
         Animation* animation =
             scroll_layer_->layer_animation_controller()->GetAnimation(
-                Animation::SCROLL_OFFSET);
+                AnimationTargetProperty::SCROLL_OFFSET);
         scroll_layer_->layer_animation_controller()->RemoveAnimation(
             animation->id());
         scroll_layer_->SetScrollOffset(final_postion_);
         break;
       }
       default:
         EXPECT_EQ(final_postion_, scroll_layer_->scroll_offset());
     }
   }
 
   void BeginCommitOnThread(LayerTreeHostImpl* host_impl) override {
     host_impl->BlockNotifyReadyToActivateForTesting(true);
   }
 
   void WillBeginImplFrameOnThread(LayerTreeHostImpl* host_impl,
                                   const BeginFrameArgs& args) override {
     if (!host_impl->pending_tree())
       return;
 
     if (!host_impl->active_tree()->root_layer()) {
       host_impl->BlockNotifyReadyToActivateForTesting(false);
       return;
     }
 
     LayerImpl* scroll_layer_impl =
         host_impl->active_tree()->root_layer()->children()[0].get();
     Animation* animation =
         scroll_layer_impl->layer_animation_controller()->GetAnimation(
-            Animation::SCROLL_OFFSET);
+            AnimationTargetProperty::SCROLL_OFFSET);
 
     if (!animation || animation->run_state() != Animation::RUNNING) {
       host_impl->BlockNotifyReadyToActivateForTesting(false);
       return;
     }
 
     // Block activation until the running animation has a chance to produce a
     // scroll delta.
     gfx::Vector2dF scroll_delta = scroll_layer_impl->ScrollDelta();
     if (scroll_delta.x() < 1.f || scroll_delta.y() < 1.f)
@@ skipping 81 matching lines @@
     if (frame_count_with_pending_tree_ == 2) {
       host_impl->BlockNotifyReadyToActivateForTesting(false);
     }
   }
 
   void UpdateAnimationState(LayerTreeHostImpl* host_impl,
                             bool has_unfinished_animation) override {
     LayerAnimationController* root_controller_impl =
         host_impl->active_tree()->root_layer()->layer_animation_controller();
     Animation* root_animation =
-        root_controller_impl->GetAnimation(Animation::OPACITY);
+        root_controller_impl->GetAnimation(AnimationTargetProperty::OPACITY);
     if (!root_animation || root_animation->run_state() != Animation::RUNNING)
       return;
 
     LayerAnimationController* child_controller_impl =
         host_impl->active_tree()->root_layer()->children()
             [0]->layer_animation_controller();
     Animation* child_animation =
-        child_controller_impl->GetAnimation(Animation::OPACITY);
+        child_controller_impl->GetAnimation(AnimationTargetProperty::OPACITY);
     EXPECT_EQ(Animation::RUNNING, child_animation->run_state());
     EXPECT_EQ(root_animation->start_time(), child_animation->start_time());
-    root_controller_impl->AbortAnimations(Animation::OPACITY);
-    root_controller_impl->AbortAnimations(Animation::TRANSFORM);
-    child_controller_impl->AbortAnimations(Animation::OPACITY);
+    root_controller_impl->AbortAnimations(AnimationTargetProperty::OPACITY);
+    root_controller_impl->AbortAnimations(AnimationTargetProperty::TRANSFORM);
+    child_controller_impl->AbortAnimations(AnimationTargetProperty::OPACITY);
     EndTest();
   }
 
   void AfterTest() override {}
 
  private:
   int frame_count_with_pending_tree_;
 };
 
 // This test blocks activation which is not supported for single thread mode.
@@ skipping 34 matching lines @@
 
     // After checking this on the sync tree, we will activate, which will cause
     // PrepareTiles to happen again (which races with the test exiting).
     if (TestEnded())
       return;
 
     LayerImpl* root = host_impl->sync_tree()->root_layer();
     LayerImpl* child = root->children()[0].get();
     LayerAnimationController* controller_impl =
         child->layer_animation_controller();
-    Animation* animation = controller_impl->GetAnimation(Animation::TRANSFORM);
+    Animation* animation =
+        controller_impl->GetAnimation(AnimationTargetProperty::TRANSFORM);
 
     // The animation should be starting for the first frame.
     EXPECT_EQ(Animation::STARTING, animation->run_state());
 
     // And the transform should be propogated to the sync tree layer, at its
     // starting state which is 6,7.
     gfx::Transform expected_transform;
     expected_transform.Translate(6.0, 7.0);
     EXPECT_EQ(expected_transform, child->DrawTransform());
     // And the sync tree layer should know it is animating.
     EXPECT_TRUE(child->screen_space_transform_is_animating());
 
-    controller_impl->AbortAnimations(Animation::TRANSFORM);
+    controller_impl->AbortAnimations(AnimationTargetProperty::TRANSFORM);
     EndTest();
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient client_;
   scoped_refptr<Layer> layer_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
@@ skipping 80 matching lines @@
     // start times.
     if (host_impl->active_tree()->source_frame_number() < 2)
       return;
     AnimationRegistrar::AnimationControllerMap controllers_copy =
         host_impl->animation_registrar()
             ->active_animation_controllers_for_testing();
     EXPECT_EQ(2u, controllers_copy.size());
     for (auto& it : controllers_copy) {
       int id = it.first;
       if (id == host_impl->RootLayer()->id()) {
-        Animation* anim = it.second->GetAnimation(Animation::TRANSFORM);
+        Animation* anim =
+            it.second->GetAnimation(AnimationTargetProperty::TRANSFORM);
         EXPECT_GT((anim->start_time() - base::TimeTicks()).InSecondsF(), 0);
       } else if (id == host_impl->RootLayer()->children()[0]->id()) {
-        Animation* anim = it.second->GetAnimation(Animation::OPACITY);
+        Animation* anim =
+            it.second->GetAnimation(AnimationTargetProperty::OPACITY);
         EXPECT_GT((anim->start_time() - base::TimeTicks()).InSecondsF(), 0);
       }
       EndTest();
     }
   }
 
   void AfterTest() override {}
 
  private:
   scoped_refptr<Layer> layer_;
@@ skipping 16 matching lines @@
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         AddAnimatedTransformToLayer(layer_.get(), 1.0, 5, 5);
         break;
       case 2:
         LayerAnimationController* controller =
             layer_->layer_animation_controller();
-        Animation* animation = controller->GetAnimation(Animation::TRANSFORM);
+        Animation* animation =
+            controller->GetAnimation(AnimationTargetProperty::TRANSFORM);
         layer_->RemoveAnimation(animation->id());
         gfx::Transform transform;
         transform.Translate(10.f, 10.f);
         layer_->SetTransform(transform);
 
         // Do something that causes property trees to get rebuilt. This is
         // intended to simulate the conditions that caused the bug whose fix
         // this is testing (the test will pass without it but won't test what
         // we want it to). We were updating the wrong transform node at the end
         // of an animation (we were assuming the layer with the finished
@@ skipping 55 matching lines @@
   void BeginTest() override { PostSetNeedsCommitToMainThread(); }
 
   void DidCommit() override {
     switch (layer_tree_host()->source_frame_number()) {
       case 1:
         AddAnimatedTransformToLayer(layer_.get(), 1.0, 5, 5);
         break;
       case 2:
         LayerAnimationController* controller =
             layer_->layer_animation_controller();
-        Animation* animation = controller->GetAnimation(Animation::TRANSFORM);
+        Animation* animation =
+            controller->GetAnimation(AnimationTargetProperty::TRANSFORM);
         layer_->RemoveAnimation(animation->id());
         break;
     }
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     LayerImpl* root = host_impl->sync_tree()->root_layer();
     LayerImpl* child = root->children()[0].get();
     switch (host_impl->sync_tree()->source_frame_number()) {
       case 0:
@@ skipping 127 matching lines @@
     client_.set_bounds(picture_->bounds());
     picture_->set_layer_animation_delegate(this);
     layer_tree_host()->root_layer()->AddChild(picture_);
   }
 
   void BeginTest() override {
     PostAddLongAnimationToMainThread(picture_.get());
   }
 
   void NotifyAnimationStarted(base::TimeTicks monotonic_time,
-                              Animation::TargetProperty target_property,
+                              AnimationTargetProperty target_property,
                               int group) override {
     called_animation_started_ = true;
     layer_tree_host()->AnimateLayers(base::TimeTicks::FromInternalValue(
         std::numeric_limits<int64_t>::max()));
     PostSetNeedsCommitToMainThread();
   }
 
   void NotifyAnimationFinished(base::TimeTicks monotonic_time,
-                               Animation::TargetProperty target_property,
+                               AnimationTargetProperty target_property,
                                int group) override {
     called_animation_finished_ = true;
     EndTest();
   }
 
   void AfterTest() override {
     EXPECT_TRUE(called_animation_started_);
     EXPECT_TRUE(called_animation_finished_);
   }
 
  private:
   bool called_animation_started_;
   bool called_animation_finished_;
   FakeContentLayerClient client_;
   scoped_refptr<FakePictureLayer> picture_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostAnimationTestNotifyAnimationFinished);
 
 }  // namespace
 }  // namespace cc