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

cc/trees/layer_tree_host_common_unittest.cc

 // Copyright 2011 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_common.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <set>
@@ skipping 2608 matching lines @@
   SetLayerPropertiesForTesting(grand_child, identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
   SetLayerPropertiesForTesting(great_grand_child, identity, gfx::Point3F(),
                                gfx::PointF(), gfx::Size(10, 10), true, false,
                                false);
 
   // Add a transform animation with a start delay to |grand_child|.
   scoped_ptr<Animation> animation = Animation::Create(
       scoped_ptr<AnimationCurve>(new FakeTransformTransition(1.0)), 0, 1,
-      Animation::TRANSFORM);
+      TargetProperty::TRANSFORM);
   animation->set_fill_mode(Animation::FILL_MODE_NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
   if (layer_settings().use_compositor_animation_timelines) {
     AddAnimationToLayerWithPlayer(grand_child->id(), timeline_impl(),
                                   std::move(animation));
   } else {
     grand_child->layer_animation_controller()->AddAnimation(
         std::move(animation));
   }
   ExecuteCalculateDrawProperties(parent);
@@ skipping 4906 matching lines @@
   EXPECT_EQ(0.f,
             parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(0.f,
             child_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(
       0.f,
       grand_child_raw->draw_properties().starting_animation_contents_scale);
 
   if (layer_settings().use_compositor_animation_timelines) {
     AbortAnimationsOnLayerWithPlayer(grand_parent->id(), timeline,
-                                     Animation::TRANSFORM);
+                                     TargetProperty::TRANSFORM);
     AbortAnimationsOnLayerWithPlayer(parent_raw->id(), timeline,
-                                     Animation::TRANSFORM);
+                                     TargetProperty::TRANSFORM);
     AbortAnimationsOnLayerWithPlayer(child_raw->id(), timeline,
-                                     Animation::TRANSFORM);
+                                     TargetProperty::TRANSFORM);
   } else {
     grand_parent->layer_animation_controller()->AbortAnimations(
-        Animation::TRANSFORM);
+        TargetProperty::TRANSFORM);
     parent_raw->layer_animation_controller()->AbortAnimations(
-        Animation::TRANSFORM);
+        TargetProperty::TRANSFORM);
     child_raw->layer_animation_controller()->AbortAnimations(
-        Animation::TRANSFORM);
+        TargetProperty::TRANSFORM);
   }
 
   TransformOperations perspective;
   perspective.AppendPerspective(10.f);
 
   if (layer_settings().use_compositor_animation_timelines) {
     AddAnimatedTransformToLayerWithPlayer(child_raw->id(), timeline, 1.0,
                                           TransformOperations(), perspective);
   } else {
     AddAnimatedTransformToLayer(child_raw, 1.0, TransformOperations(),
@@ skipping 17 matching lines @@
   EXPECT_EQ(0.f,
             parent_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(0.f,
             child_raw->draw_properties().starting_animation_contents_scale);
   EXPECT_EQ(
       0.f,
       grand_child_raw->draw_properties().starting_animation_contents_scale);
 
   if (layer_settings().use_compositor_animation_timelines) {
     AbortAnimationsOnLayerWithPlayer(child_raw->id(), timeline,
-                                     Animation::TRANSFORM);
+                                     TargetProperty::TRANSFORM);
   } else {
     child_raw->layer_animation_controller()->AbortAnimations(
-        Animation::TRANSFORM);
+        TargetProperty::TRANSFORM);
   }
   gfx::Transform scale_matrix;
   scale_matrix.Scale(1.f, 2.f);
   grand_parent->SetTransform(scale_matrix);
   parent_raw->SetTransform(scale_matrix);
   grand_parent->layer_tree_impl()->property_trees()->needs_rebuild = true;
 
   if (layer_settings().use_compositor_animation_timelines) {
     AddAnimatedTransformToLayerWithPlayer(parent_raw->id(), timeline, 1.0,
                                           TransformOperations(), scale);
@@ skipping 896 matching lines @@
       KeyframedFilterAnimationCurve::Create());
   FilterOperations start_filters;
   start_filters.Append(FilterOperation::CreateBrightnessFilter(0.1f));
   FilterOperations end_filters;
   end_filters.Append(FilterOperation::CreateBrightnessFilter(0.3f));
   curve->AddKeyframe(
       FilterKeyframe::Create(base::TimeDelta(), start_filters, nullptr));
   curve->AddKeyframe(FilterKeyframe::Create(
       base::TimeDelta::FromMilliseconds(100), end_filters, nullptr));
   scoped_ptr<Animation> animation =
-      Animation::Create(std::move(curve), 0, 1, Animation::FILTER);
+      Animation::Create(std::move(curve), 0, 1, TargetProperty::FILTER);
   animation->set_fill_mode(Animation::FILL_MODE_NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
 
   if (layer_settings().use_compositor_animation_timelines) {
     AddAnimationToLayerWithPlayer(child->id(), timeline(),
                                   std::move(animation));
   } else {
     child->layer_animation_controller()->AddAnimation(std::move(animation));
   }
   ExecuteCalculateDrawProperties(root.get());
@@ skipping 460 matching lines @@
 
   gfx::Transform zero_z_scale;
   zero_z_scale.Scale3d(1, 1, 0);
   child->SetTransform(zero_z_scale);
 
   // Add a transform animation with a start delay. Now, even though |child| has
   // a singular transform, the subtree should still get processed.
   int animation_id = 0;
   scoped_ptr<Animation> animation = Animation::Create(
       scoped_ptr<AnimationCurve>(new FakeTransformTransition(1.0)),
-      animation_id, 1, Animation::TRANSFORM);
+      animation_id, 1, TargetProperty::TRANSFORM);
   animation->set_fill_mode(Animation::FILL_MODE_NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
   if (layer_settings().use_compositor_animation_timelines) {
     AddAnimationToLayerWithPlayer(child->id(), timeline(),
                                   std::move(animation));
   } else {
     child->AddAnimation(std::move(animation));
   }
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), grandchild->visible_rect_from_property_trees());
@@ skipping 16 matching lines @@
   grandchild->RequestCopyOfOutput(
       CopyOutputRequest::CreateBitmapRequest(base::Bind(&CopyOutputCallback)));
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), grandchild->visible_rect_from_property_trees());
   greatgrandchild->set_visible_rect_from_property_trees(gfx::Rect());
 
   // Add an opacity animation with a start delay.
   animation_id = 1;
   animation = Animation::Create(
       scoped_ptr<AnimationCurve>(new FakeFloatTransition(1.0, 0.f, 1.f)),
-      animation_id, 1, Animation::OPACITY);
+      animation_id, 1, TargetProperty::OPACITY);
   animation->set_fill_mode(Animation::FILL_MODE_NONE);
   animation->set_time_offset(base::TimeDelta::FromMilliseconds(-1000));
   if (layer_settings().use_compositor_animation_timelines) {
     AddAnimationToLayerWithExistingPlayer(child->id(), timeline(),
                                           std::move(animation));
   } else {
     child->AddAnimation(std::move(animation));
   }
   ExecuteCalculateDrawPropertiesWithPropertyTrees(root.get());
   EXPECT_EQ(gfx::Rect(10, 10), grandchild->visible_rect_from_property_trees());
@@ skipping 1105 matching lines @@
   EXPECT_EQ(scroll_child6.id, grand_child10->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent3->scroll_tree_index());
   EXPECT_EQ(scroll_child7.id, child8->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, parent4->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, child9->scroll_tree_index());
   EXPECT_EQ(scroll_root1.id, grand_child12->scroll_tree_index());
 }
 
 }  // namespace
 }  // namespace cc