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

cc/test/animation_timelines_test_common.cc

 // Copyright 2015 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/test/animation_timelines_test_common.h"
 
 #include "cc/animation/animation_events.h"
 #include "cc/animation/animation_id_provider.h"
 #include "cc/animation/animation_player.h"
 #include "cc/animation/animation_registrar.h"
@@ skipping 13 matching lines @@
   ClearMutatedProperties();
 }
 
 void TestLayer::ClearMutatedProperties() {
   transform_x_ = 0;
   transform_y_ = 0;
 
   opacity_ = 0;
   brightness_ = 0;
 
-  for (int i = 0; i <= Animation::LAST_TARGET_PROPERTY; ++i)
+  for (int i = 0; i <= kLastTargetProperty; ++i)
     mutated_properties_[i] = false;
 }
 
 TestHostClient::TestHostClient(ThreadInstance thread_instance)
     : host_(AnimationHost::Create(thread_instance)),
       mutators_need_commit_(false) {
   host_->SetMutatorHostClient(this);
   host_->SetSupportsScrollAnimations(true);
 }
 
@@ skipping 77 matching lines @@
   host_->UnregisterLayer(layer_id, tree_type);
 
   LayerIdToTestLayer& layers_in_tree = tree_type == LayerTreeType::ACTIVE
                                            ? layers_in_active_tree_
                                            : layers_in_pending_tree_;
   auto kv = layers_in_tree.find(layer_id);
   DCHECK(kv != layers_in_tree.end());
   layers_in_tree.erase(kv);
 }
 
-bool TestHostClient::IsPropertyMutated(
-    int layer_id,
-    LayerTreeType tree_type,
-    Animation::TargetProperty property) const {
+bool TestHostClient::IsPropertyMutated(int layer_id,
+                                       LayerTreeType tree_type,
+                                       AnimationTargetProperty property) const {
   TestLayer* layer = FindTestLayer(layer_id, tree_type);
   return layer->is_property_mutated(property);
 }
 
 void TestHostClient::ExpectFilterPropertyMutated(int layer_id,
                                                  LayerTreeType tree_type,
                                                  float brightness) const {
   TestLayer* layer = FindTestLayer(layer_id, tree_type);
-  EXPECT_TRUE(layer->is_property_mutated(Animation::OPACITY));
+  EXPECT_TRUE(layer->is_property_mutated(AnimationTargetProperty::OPACITY));
   EXPECT_EQ(brightness, layer->brightness());
 }
 
 void TestHostClient::ExpectOpacityPropertyMutated(int layer_id,
                                                   LayerTreeType tree_type,
                                                   float opacity) const {
   TestLayer* layer = FindTestLayer(layer_id, tree_type);
-  EXPECT_TRUE(layer->is_property_mutated(Animation::OPACITY));
+  EXPECT_TRUE(layer->is_property_mutated(AnimationTargetProperty::OPACITY));
   EXPECT_EQ(opacity, layer->opacity());
 }
 
 void TestHostClient::ExpectTransformPropertyMutated(int layer_id,
                                                     LayerTreeType tree_type,
                                                     int transform_x,
                                                     int transform_y) const {
   TestLayer* layer = FindTestLayer(layer_id, tree_type);
-  EXPECT_TRUE(layer->is_property_mutated(Animation::OPACITY));
+  EXPECT_TRUE(layer->is_property_mutated(AnimationTargetProperty::OPACITY));
   EXPECT_EQ(transform_x, layer->transform_x());
   EXPECT_EQ(transform_y, layer->transform_y());
 }
 
 TestLayer* TestHostClient::FindTestLayer(int layer_id,
                                          LayerTreeType tree_type) const {
   const LayerIdToTestLayer& layers_in_tree = tree_type == LayerTreeType::ACTIVE
                                                  ? layers_in_active_tree_
                                                  : layers_in_pending_tree_;
   auto kv = layers_in_tree.find(layer_id);
   DCHECK(kv != layers_in_tree.end());
   DCHECK(kv->second);
   return kv->second.get();
 }
 
 TestAnimationDelegate::TestAnimationDelegate()
     : started_(false), finished_(false) {
 }
 
 void TestAnimationDelegate::NotifyAnimationStarted(
     base::TimeTicks monotonic_time,
-    Animation::TargetProperty target_property,
+    AnimationTargetProperty target_property,
     int group) {
   started_ = true;
 }
 void TestAnimationDelegate::NotifyAnimationFinished(
     base::TimeTicks monotonic_time,
-    Animation::TargetProperty target_property,
+    AnimationTargetProperty target_property,
     int group) {
   finished_ = true;
 }
 
 AnimationTimelinesTest::AnimationTimelinesTest()
     : client_(ThreadInstance::MAIN),
       client_impl_(ThreadInstance::IMPL),
       host_(nullptr),
       host_impl_(nullptr),
       timeline_id_(AnimationIdProvider::NextTimelineId()),
@@ skipping 60 matching lines @@
   return element_animations ? element_animations->players_list().head()->value()
                             : nullptr;
 }
 
 int AnimationTimelinesTest::NextTestLayerId() {
   next_test_layer_id_++;
   return next_test_layer_id_;
 }
 
 }  // namespace cc