cc: Clean up Layer and LayerTreeHost.

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 144 matching lines @@
 
   for (size_t i = 0; i < inputs_.children.size(); ++i)
     inputs_.children[i]->SetLayerTreeHost(host);
 
   if (inputs_.mask_layer.get())
     inputs_.mask_layer->SetLayerTreeHost(host);
   if (inputs_.replica_layer.get())
     inputs_.replica_layer->SetLayerTreeHost(host);
 
   const bool has_any_animation =
-      layer_tree_host_ ? layer_tree_host_->HasAnyAnimation(this) : false;
+      layer_tree_host_ ? GetAnimationHost()->HasAnyAnimation(element_id())
+                       : false;
 
   if (host && has_any_animation)
     host->SetNeedsCommit();
 }
 
 void Layer::SetNeedsUpdate() {
   if (layer_tree_host_ && !ignore_set_needs_commit_)
     layer_tree_host_->SetNeedsUpdateLayers();
 }
 
@@ skipping 282 matching lines @@
 
 void Layer::SetFilters(const FilterOperations& filters) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.filters == filters)
     return;
   inputs_.filters = filters;
   SetSubtreePropertyChanged();
   SetNeedsCommit();
 }
 
-bool Layer::FilterIsAnimating() const {
-  DCHECK(layer_tree_host_);
-  return layer_tree_host_->IsAnimatingFilterProperty(this);
-}
-
-bool Layer::HasPotentiallyRunningFilterAnimation() const {
-  return layer_tree_host_->HasPotentiallyRunningFilterAnimation(this);
-}
-
 void Layer::SetBackgroundFilters(const FilterOperations& filters) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.background_filters == filters)
     return;
   inputs_.background_filters = filters;
   SetLayerPropertyChanged();
   SetNeedsCommit();
 }
 
 void Layer::SetOpacity(float opacity) {
@@ skipping 21 matching lines @@
       return;
     }
   }
   SetNeedsCommit();
 }
 
 float Layer::EffectiveOpacity() const {
   return inputs_.hide_layer_and_subtree ? 0.f : inputs_.opacity;
 }
 
-bool Layer::OpacityIsAnimating() const {
-  DCHECK(layer_tree_host_);
-  return layer_tree_host_->IsAnimatingOpacityProperty(this);
-}
-
-bool Layer::HasPotentiallyRunningOpacityAnimation() const {
-  return layer_tree_host_->HasPotentiallyRunningOpacityAnimation(this);
-}
-
 bool Layer::OpacityCanAnimateOnImplThread() const {
   return false;
 }
 
 bool Layer::AlwaysUseActiveTreeOpacity() const {
   return false;
 }
 
 void Layer::SetBlendMode(SkXfermode::Mode blend_mode) {
   DCHECK(IsPropertyChangeAllowed());
@@ skipping 173 matching lines @@
     transform_node->needs_local_transform_update = true;
     transform_node->transform_changed = true;
     layer_tree_host_->property_trees()->transform_tree.set_needs_update(true);
     SetNeedsCommitNoRebuild();
     return;
   }
 
   SetNeedsCommit();
 }
 
-bool Layer::AnimationsPreserveAxisAlignment() const {
-  DCHECK(layer_tree_host_);
-  return layer_tree_host_->AnimationsPreserveAxisAlignment(this);
-}
-
-bool Layer::TransformIsAnimating() const {
-  DCHECK(layer_tree_host_);
-  return layer_tree_host_->IsAnimatingTransformProperty(this);
-}
-
-bool Layer::HasPotentiallyRunningTransformAnimation() const {
-  return layer_tree_host_->HasPotentiallyRunningTransformAnimation(this);
+bool Layer::ScrollOffsetAnimationWasInterrupted() const {
+  return GetAnimationHost()->ScrollOffsetAnimationWasInterrupted(element_id());
 }
 
 bool Layer::HasOnlyTranslationTransforms() const {
-  return layer_tree_host_->HasOnlyTranslationTransforms(this);
-}
-
-bool Layer::MaximumTargetScale(float* max_scale) const {
-  return layer_tree_host_->MaximumTargetScale(this, max_scale);
-}
-
-bool Layer::AnimationStartScale(float* start_scale) const {
-  return layer_tree_host_->AnimationStartScale(this, start_scale);
-}
-
-bool Layer::HasAnyAnimationTargetingProperty(
-    TargetProperty::Type property) const {
-  return layer_tree_host_->HasAnyAnimationTargetingProperty(this, property);
-}
-
-bool Layer::ScrollOffsetAnimationWasInterrupted() const {
-  DCHECK(layer_tree_host_);
-  return layer_tree_host_->ScrollOffsetAnimationWasInterrupted(this);
+  return GetAnimationHost()->HasOnlyTranslationTransforms(
+      element_id(), GetElementTypeForAnimation());
 }
 
 void Layer::SetScrollParent(Layer* parent) {
   DCHECK(IsPropertyChangeAllowed());
   if (inputs_.scroll_parent == parent)
     return;
 
   if (inputs_.scroll_parent)
     inputs_.scroll_parent->RemoveScrollChild(this);
 
@@ skipping 866 matching lines @@
   SetNeedsPushProperties();
 }
 
 void Layer::SetLayerPropertyChanged() {
   if (layer_property_changed_)
     return;
   layer_property_changed_ = true;
   SetNeedsPushProperties();
 }
 
+bool Layer::FilterIsAnimating() const {
+  return GetAnimationHost()->IsAnimatingFilterProperty(
+      element_id(), GetElementTypeForAnimation());
+}
+
+bool Layer::TransformIsAnimating() const {
+  return GetAnimationHost()->IsAnimatingTransformProperty(
+      element_id(), GetElementTypeForAnimation());
+}
+
 gfx::ScrollOffset Layer::ScrollOffsetForAnimation() const {
   return CurrentScrollOffset();
 }
 
 // On<Property>Animated is called due to an ongoing accelerated animation.
 // Since this animation is also being run on the compositor thread, there
 // is no need to request a commit to push this value over, so the value is
 // set directly rather than by calling Set<Property>.
 void Layer::OnFilterAnimated(const FilterOperations& filters) {
   inputs_.filters = filters;
@@ skipping 104 matching lines @@
   if (!property_trees->IsInIdToIndexMap(PropertyTrees::TreeType::EFFECT, id()))
     return;
   DCHECK_EQ(effect_tree_index(), property_trees->effect_id_to_index_map[id()]);
   EffectNode* node = property_trees->effect_tree.Node(effect_tree_index());
   node->has_potential_opacity_animation =
       has_potential_animation || OpacityCanAnimateOnImplThread();
   property_trees->effect_tree.set_needs_update(true);
 }
 
 bool Layer::HasActiveAnimationForTesting() const {
-  return layer_tree_host_ ? layer_tree_host_->HasActiveAnimationForTesting(this)
-                          : false;
+  return layer_tree_host_
+             ? GetAnimationHost()->HasActiveAnimationForTesting(element_id())
+             : false;
 }
 
 void Layer::SetHasWillChangeTransformHint(bool has_will_change) {
   if (inputs_.has_will_change_transform_hint == has_will_change)
     return;
   inputs_.has_will_change_transform_hint = has_will_change;
   SetNeedsCommit();
 }
 
+AnimationHost* Layer::GetAnimationHost() const {
+  return layer_tree_host_ ? layer_tree_host_->animation_host() : nullptr;
+}
+
+ElementListType Layer::GetElementTypeForAnimation() const {
+  return ElementListType::ACTIVE;
+}
+
 ScrollbarLayerInterface* Layer::ToScrollbarLayer() {
   return nullptr;
 }
 
-RenderingStatsInstrumentation* Layer::rendering_stats_instrumentation() const {
-  return layer_tree_host_->rendering_stats_instrumentation();
-}
-
 void Layer::RemoveFromScrollTree() {
   if (scroll_children_.get()) {
     std::set<Layer*> copy = *scroll_children_;
     for (std::set<Layer*>::iterator it = copy.begin(); it != copy.end(); ++it)
       (*it)->SetScrollParent(nullptr);
   }
 
   DCHECK(!scroll_children_);
   SetScrollParent(nullptr);
 }
@@ skipping 72 matching lines @@
       ->num_copy_requests_in_subtree;
 }
 
 gfx::Transform Layer::screen_space_transform() const {
   DCHECK_NE(transform_tree_index_, -1);
   return draw_property_utils::ScreenSpaceTransform(
       this, layer_tree_host_->property_trees()->transform_tree);
 }
 
 }  // namespace cc