cc: Clean up Layer and LayerTreeHost.

cc/trees/layer_tree_host.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.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 1451 matching lines @@
   }
 }
 
 gfx::ScrollOffset LayerTreeHost::GetScrollOffsetForAnimation(
     ElementId element_id) const {
   Layer* layer = LayerByElementId(element_id);
   DCHECK(layer);
   return layer->ScrollOffsetForAnimation();
 }
 
-bool LayerTreeHost::ScrollOffsetAnimationWasInterrupted(
-    const Layer* layer) const {
-  return animation_host_->ScrollOffsetAnimationWasInterrupted(
-      layer->element_id());
-}
-
-bool LayerTreeHost::IsAnimatingFilterProperty(const Layer* layer) const {
-  return animation_host_->IsAnimatingFilterProperty(layer->element_id(),
-                                                    ElementListType::ACTIVE);
-}
-
-bool LayerTreeHost::IsAnimatingOpacityProperty(const Layer* layer) const {
-  return animation_host_->IsAnimatingOpacityProperty(layer->element_id(),
-                                                     ElementListType::ACTIVE);
-}
-
-bool LayerTreeHost::IsAnimatingTransformProperty(const Layer* layer) const {
-  return animation_host_->IsAnimatingTransformProperty(layer->element_id(),
-                                                       ElementListType::ACTIVE);
-}
-
-bool LayerTreeHost::HasPotentiallyRunningFilterAnimation(
-    const Layer* layer) const {
-  return animation_host_->HasPotentiallyRunningFilterAnimation(
-      layer->element_id(), ElementListType::ACTIVE);
-}
-
-bool LayerTreeHost::HasPotentiallyRunningOpacityAnimation(
-    const Layer* layer) const {
-  return animation_host_->HasPotentiallyRunningOpacityAnimation(
-      layer->element_id(), ElementListType::ACTIVE);
-}
-
-bool LayerTreeHost::HasPotentiallyRunningTransformAnimation(
-    const Layer* layer) const {
-  return animation_host_->HasPotentiallyRunningTransformAnimation(
-      layer->element_id(), ElementListType::ACTIVE);
-}
-
-bool LayerTreeHost::HasOnlyTranslationTransforms(const Layer* layer) const {
-  return animation_host_->HasOnlyTranslationTransforms(layer->element_id(),
-                                                       ElementListType::ACTIVE);
-}
-
-bool LayerTreeHost::MaximumTargetScale(const Layer* layer,
-                                       float* max_scale) const {
-  return animation_host_->MaximumTargetScale(
-      layer->element_id(), ElementListType::ACTIVE, max_scale);
-}
-
-bool LayerTreeHost::AnimationStartScale(const Layer* layer,
-                                        float* start_scale) const {
-  return animation_host_->AnimationStartScale(
-      layer->element_id(), ElementListType::ACTIVE, start_scale);
-}
-
-bool LayerTreeHost::HasAnyAnimationTargetingProperty(
-    const Layer* layer,
-    TargetProperty::Type property) const {
-  return animation_host_->HasAnyAnimationTargetingProperty(layer->element_id(),
-                                                           property);
-}
-
-bool LayerTreeHost::AnimationsPreserveAxisAlignment(const Layer* layer) const {
-  return animation_host_->AnimationsPreserveAxisAlignment(layer->element_id());
-}
-
-bool LayerTreeHost::HasAnyAnimation(const Layer* layer) const {
-  return animation_host_->HasAnyAnimation(layer->element_id());
-}
-
-bool LayerTreeHost::HasActiveAnimationForTesting(const Layer* layer) const {
-  return animation_host_->HasActiveAnimationForTesting(layer->element_id());
-}
-
 bool LayerTreeHost::IsSingleThreaded() const {
   DCHECK(compositor_mode_ != CompositorMode::SINGLE_THREADED ||
          !task_runner_provider_->HasImplThread());
   return compositor_mode_ == CompositorMode::SINGLE_THREADED;
 }
 
 bool LayerTreeHost::IsThreaded() const {
   DCHECK(compositor_mode_ != CompositorMode::THREADED ||
          task_runner_provider_->HasImplThread());
   return compositor_mode_ == CompositorMode::THREADED;
@@ skipping 205 matching lines @@
   int seq_num = property_trees_.sequence_number;
   LayerTreeHostCommon::CallFunctionForEveryLayer(this, [seq_num](Layer* layer) {
     layer->set_property_tree_sequence_number(seq_num);
   });
 
   surface_id_namespace_ = proto.surface_id_namespace();
   next_surface_sequence_ = proto.next_surface_sequence();
 }
 
 }  // namespace cc