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

cc/layers/layer.cc

 // Copyright 2010 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/layers/layer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 489 matching lines @@
   if (filters_ == filters)
     return;
   filters_ = filters;
   SetNeedsCommit();
 }
 
 bool Layer::FilterIsAnimating() const {
   DCHECK(layer_tree_host_);
   return layer_animation_controller_
              ? layer_animation_controller_->IsCurrentlyAnimatingProperty(
-                   Animation::FILTER,
+                   TargetProperty::FILTER,
                    LayerAnimationController::ObserverType::ACTIVE)
              : layer_tree_host_->IsAnimatingFilterProperty(this);
 }
 
 bool Layer::HasPotentiallyRunningFilterAnimation() const {
   if (layer_animation_controller_) {
     return layer_animation_controller_->IsPotentiallyAnimatingProperty(
-        Animation::FILTER, LayerAnimationController::ObserverType::ACTIVE);
+        TargetProperty::FILTER, LayerAnimationController::ObserverType::ACTIVE);
   }
   return layer_tree_host_->HasPotentiallyRunningFilterAnimation(this);
 }
 
 void Layer::SetBackgroundFilters(const FilterOperations& filters) {
   DCHECK(IsPropertyChangeAllowed());
   if (background_filters_ == filters)
     return;
   background_filters_ = filters;
   SetNeedsCommit();
 }
 
 void Layer::SetOpacity(float opacity) {
   DCHECK(IsPropertyChangeAllowed());
   if (opacity_ == opacity)
     return;
   opacity_ = opacity;
   SetNeedsCommit();
 }
 
 float Layer::EffectiveOpacity() const {
   return hide_layer_and_subtree_ ? 0.f : opacity_;
 }
 
 bool Layer::OpacityIsAnimating() const {
   DCHECK(layer_tree_host_);
   return layer_animation_controller_
              ? layer_animation_controller_->IsCurrentlyAnimatingProperty(
-                   Animation::OPACITY,
+                   TargetProperty::OPACITY,
                    LayerAnimationController::ObserverType::ACTIVE)
              : layer_tree_host_->IsAnimatingOpacityProperty(this);
 }
 
 bool Layer::HasPotentiallyRunningOpacityAnimation() const {
   if (layer_animation_controller_) {
     return layer_animation_controller_->IsPotentiallyAnimatingProperty(
-        Animation::OPACITY, LayerAnimationController::ObserverType::ACTIVE);
+        TargetProperty::OPACITY,
+        LayerAnimationController::ObserverType::ACTIVE);
   }
   return layer_tree_host_->HasPotentiallyRunningOpacityAnimation(this);
 }
 
 bool Layer::OpacityCanAnimateOnImplThread() const {
   return false;
 }
 
 void Layer::SetBlendMode(SkXfermode::Mode blend_mode) {
   DCHECK(IsPropertyChangeAllowed());
@@ skipping 183 matching lines @@
   DCHECK(layer_tree_host_);
   return layer_animation_controller_
              ? layer_animation_controller_->AnimationsPreserveAxisAlignment()
              : layer_tree_host_->AnimationsPreserveAxisAlignment(this);
 }
 
 bool Layer::TransformIsAnimating() const {
   DCHECK(layer_tree_host_);
   return layer_animation_controller_
              ? layer_animation_controller_->IsCurrentlyAnimatingProperty(
-                   Animation::TRANSFORM,
+                   TargetProperty::TRANSFORM,
                    LayerAnimationController::ObserverType::ACTIVE)
              : layer_tree_host_->IsAnimatingTransformProperty(this);
 }
 
 bool Layer::HasPotentiallyRunningTransformAnimation() const {
   if (layer_animation_controller_) {
     return layer_animation_controller_->IsPotentiallyAnimatingProperty(
-        Animation::TRANSFORM, LayerAnimationController::ObserverType::ACTIVE);
+        TargetProperty::TRANSFORM,
+        LayerAnimationController::ObserverType::ACTIVE);
   }
   return layer_tree_host_->HasPotentiallyRunningTransformAnimation(this);
 }
 
 bool Layer::HasOnlyTranslationTransforms() const {
   if (layer_animation_controller_) {
     return layer_animation_controller_->HasOnlyTranslationTransforms(
         LayerAnimationController::ObserverType::ACTIVE);
   }
   return layer_tree_host_->HasOnlyTranslationTransforms(this);
 }
 
 bool Layer::MaximumTargetScale(float* max_scale) const {
   if (layer_animation_controller_) {
     return layer_animation_controller_->MaximumTargetScale(
         LayerAnimationController::ObserverType::ACTIVE, max_scale);
   }
   return layer_tree_host_->MaximumTargetScale(this, max_scale);
 }
 
 bool Layer::AnimationStartScale(float* start_scale) const {
   if (layer_animation_controller_) {
     return layer_animation_controller_->AnimationStartScale(
         LayerAnimationController::ObserverType::ACTIVE, start_scale);
   }
   return layer_tree_host_->AnimationStartScale(this, start_scale);
 }
 
 bool Layer::HasAnyAnimationTargetingProperty(
-    Animation::TargetProperty property) const {
+    TargetProperty::Type property) const {
   if (layer_animation_controller_)
     return !!layer_animation_controller_->GetAnimation(property);
 
   return layer_tree_host_->HasAnyAnimationTargetingProperty(this, property);
 }
 
 bool Layer::ScrollOffsetAnimationWasInterrupted() const {
   DCHECK(layer_tree_host_);
   return layer_animation_controller_
              ? layer_animation_controller_
@@ skipping 1059 matching lines @@
 
 bool Layer::IsActive() const {
   return true;
 }
 
 bool Layer::AddAnimation(scoped_ptr <Animation> animation) {
   DCHECK(layer_animation_controller_);
   if (!layer_animation_controller_->animation_registrar())
     return false;
 
-  if (animation->target_property() == Animation::SCROLL_OFFSET &&
+  if (animation->target_property() == TargetProperty::SCROLL_OFFSET &&
       !layer_animation_controller_->animation_registrar()
            ->supports_scroll_animations())
     return false;
 
   UMA_HISTOGRAM_BOOLEAN("Renderer.AnimationAddedToOrphanLayer",
                         !layer_tree_host_);
   layer_animation_controller_->AddAnimation(std::move(animation));
   SetNeedsCommit();
   return true;
 }
@@ skipping 181 matching lines @@
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, -1);
   return ScreenSpaceTransformFromPropertyTrees(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc