cc: Clean up Layer and LayerTreeHost.

cc/layers/layer.h

 // 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.
 
 #ifndef CC_LAYERS_LAYER_H_
 #define CC_LAYERS_LAYER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <set>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/observer_list.h"
 #include "cc/animation/element_id.h"
 #include "cc/animation/target_property.h"
 #include "cc/base/cc_export.h"
 #include "cc/base/region.h"
 #include "cc/debug/micro_benchmark.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/layer_collections.h"
 #include "cc/layers/layer_position_constraint.h"
 #include "cc/layers/paint_properties.h"
 #include "cc/output/filter_operations.h"
+#include "cc/trees/mutator_host_client.h"
 #include "cc/trees/property_tree.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkPicture.h"
 #include "third_party/skia/include/core/SkXfermode.h"
 #include "ui/gfx/geometry/point3_f.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/scroll_offset.h"
 #include "ui/gfx/transform.h"
 
 namespace gfx {
 class BoxF;
 }
 
 namespace base {
 namespace trace_event {
 class ConvertableToTraceFormat;
 }
 }
 
 namespace cc {
 
+class AnimationHost;
 class CopyOutputRequest;
 class LayerAnimationEventObserver;
 class LayerClient;
 class LayerImpl;
 class LayerTreeHost;
 class LayerTreeHostCommon;
 class LayerTreeImpl;
 class LayerTreeSettings;
 class RenderingStatsInstrumentation;
 class ResourceUpdateQueue;
@@ skipping 64 matching lines @@
   void SetMaskLayer(Layer* mask_layer);
   Layer* mask_layer() { return inputs_.mask_layer.get(); }
   const Layer* mask_layer() const { return inputs_.mask_layer.get(); }
 
   virtual void SetNeedsDisplayRect(const gfx::Rect& dirty_rect);
   void SetNeedsDisplay() { SetNeedsDisplayRect(gfx::Rect(bounds())); }
 
   virtual void SetOpacity(float opacity);
   float opacity() const { return inputs_.opacity; }
   float EffectiveOpacity() const;
-  bool OpacityIsAnimating() const;
-  bool HasPotentiallyRunningOpacityAnimation() const;
   virtual bool OpacityCanAnimateOnImplThread() const;
 
   virtual bool AlwaysUseActiveTreeOpacity() const;
 
   void SetBlendMode(SkXfermode::Mode blend_mode);
   SkXfermode::Mode blend_mode() const { return inputs_.blend_mode; }
 
   void set_draw_blend_mode(SkXfermode::Mode blend_mode) {
     if (draw_blend_mode_ == blend_mode)
       return;
@@ skipping 10 matching lines @@
   // drawn over a black and fully transparent background, creating an isolated
   // group. It should be used along with SetBlendMode(), in order to restrict
   // layers within the group to blend with layers outside this group.
   void SetIsRootForIsolatedGroup(bool root);
   bool is_root_for_isolated_group() const {
     return inputs_.is_root_for_isolated_group;
   }
 
   void SetFilters(const FilterOperations& filters);
   const FilterOperations& filters() const { return inputs_.filters; }
-  bool FilterIsAnimating() const;
-  bool HasPotentiallyRunningFilterAnimation() const;
 
   // Background filters are filters applied to what is behind this layer, when
   // they are viewed through non-opaque regions in this layer. They are used
   // through the WebLayer interface, and are not exposed to HTML.
   void SetBackgroundFilters(const FilterOperations& filters);
   const FilterOperations& background_filters() const {
     return inputs_.background_filters;
   }
 
   virtual void SetContentsOpaque(bool opaque);
@@ skipping 11 matching lines @@
     return gfx::Vector2dF();
   }
 
   void SetPositionConstraint(const LayerPositionConstraint& constraint);
   const LayerPositionConstraint& position_constraint() const {
     return inputs_.position_constraint;
   }
 
   void SetTransform(const gfx::Transform& transform);
   const gfx::Transform& transform() const { return inputs_.transform; }
-  bool TransformIsAnimating() const;
-  bool HasPotentiallyRunningTransformAnimation() const;
-  bool HasOnlyTranslationTransforms() const;
-  bool AnimationsPreserveAxisAlignment() const;
-
-  bool MaximumTargetScale(float* max_scale) const;
-  bool AnimationStartScale(float* start_scale) const;
 
   void SetTransformOrigin(const gfx::Point3F&);
   gfx::Point3F transform_origin() const { return inputs_.transform_origin; }
 
-  bool HasAnyAnimationTargetingProperty(TargetProperty::Type property) const;
-
-  bool ScrollOffsetAnimationWasInterrupted() const;
-
   void SetScrollParent(Layer* parent);
 
   Layer* scroll_parent() { return inputs_.scroll_parent; }
   const Layer* scroll_parent() const { return inputs_.scroll_parent; }
 
-  void AddScrollChild(Layer* child);
-  void RemoveScrollChild(Layer* child);
-
   std::set<Layer*>* scroll_children() { return scroll_children_.get(); }
   const std::set<Layer*>* scroll_children() const {
     return scroll_children_.get();
   }
 
   void SetClipParent(Layer* ancestor);
 
   Layer* clip_parent() { return inputs_.clip_parent; }
   const Layer* clip_parent() const { return inputs_.clip_parent; }
 
-  void AddClipChild(Layer* child);
-  void RemoveClipChild(Layer* child);
-
   std::set<Layer*>* clip_children() { return clip_children_.get(); }
   const std::set<Layer*>* clip_children() const {
     return clip_children_.get();
   }
 
   // TODO(enne): Fix style here (and everywhere) once LayerImpl does the same.
   gfx::Transform screen_space_transform() const;
 
   void set_num_unclipped_descendants(size_t descendants) {
     num_unclipped_descendants_ = descendants;
@@ skipping 168 matching lines @@
   virtual ScrollbarLayerInterface* ToScrollbarLayer();
 
   virtual sk_sp<SkPicture> GetPicture() const;
 
   // Constructs a LayerImpl of the correct runtime type for this Layer type.
   virtual std::unique_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl);
 
   bool NeedsDisplayForTesting() const { return !inputs_.update_rect.IsEmpty(); }
   void ResetNeedsDisplayForTesting() { inputs_.update_rect = gfx::Rect(); }
 
-  RenderingStatsInstrumentation* rendering_stats_instrumentation() const;
-
   const PaintProperties& paint_properties() const {
     return paint_properties_;
   }
 
   void SetNeedsPushProperties();
   void ResetNeedsPushPropertiesForTesting();
 
   virtual void RunMicroBenchmark(MicroBenchmark* benchmark);
 
   void Set3dSortingContextId(int id);
@@ skipping 64 matching lines @@
   void SetMutableProperties(uint32_t properties);
   uint32_t mutable_properties() const { return inputs_.mutable_properties; }
 
   bool HasActiveAnimationForTesting() const;
 
   void SetHasWillChangeTransformHint(bool has_will_change);
   bool has_will_change_transform_hint() const {
     return inputs_.has_will_change_transform_hint;
   }
 
+  AnimationHost* GetAnimationHost() const;
+
+  ElementListType GetElementTypeForAnimation() const;
+
  protected:
   friend class LayerImpl;
   friend class TreeSynchronizer;
   virtual ~Layer();
   Layer();
 
   // These SetNeeds functions are in order of severity of update:
   //
   // Called when this layer has been modified in some way, but isn't sure
   // that it needs a commit yet.  It needs CalcDrawProperties and UpdateLayers
@@ skipping 53 matching lines @@
   gfx::ScrollOffset ScrollOffsetForAnimation() const;
   void OnFilterAnimated(const FilterOperations& filters);
   void OnOpacityAnimated(float opacity);
   void OnTransformAnimated(const gfx::Transform& transform);
   void OnScrollOffsetAnimated(const gfx::ScrollOffset& scroll_offset);
   void OnTransformIsCurrentlyAnimatingChanged(bool is_animating);
   void OnTransformIsPotentiallyAnimatingChanged(bool is_animating);
   void OnOpacityIsCurrentlyAnimatingChanged(bool is_currently_animating);
   void OnOpacityIsPotentiallyAnimatingChanged(bool has_potential_animation);
 
+  bool FilterIsAnimating() const;
+  bool TransformIsAnimating() const;
+  bool ScrollOffsetAnimationWasInterrupted() const;
+  bool HasOnlyTranslationTransforms() const;
+
+  void AddScrollChild(Layer* child);
+  void RemoveScrollChild(Layer* child);
+
+  void AddClipChild(Layer* child);
+  void RemoveClipChild(Layer* child);
+
   void SetParent(Layer* layer);
   bool DescendantIsFixedToContainerLayer() const;
 
   // This should only be called from RemoveFromParent().
   void RemoveChildOrDependent(Layer* child);
 
   // If this layer has a scroll parent, it removes |this| from its list of
   // scroll children.
   void RemoveFromScrollTree();
 
@@ skipping 130 matching lines @@
   // These all act like draw properties, so don't need push properties.
   gfx::Rect visible_layer_rect_;
   size_t num_unclipped_descendants_;
 
   DISALLOW_COPY_AND_ASSIGN(Layer);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYERS_LAYER_H_