CC Animations: Establish AnimationHost, AnimationTimeline and AnimationPlayer

cc/trees/layer_tree_host.h

 // 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.
 
 #ifndef CC_TREES_LAYER_TREE_HOST_H_
 #define CC_TREES_LAYER_TREE_HOST_H_
 
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 18 matching lines @@
 #include "cc/input/layer_selection_bound.h"
 #include "cc/input/scrollbar.h"
 #include "cc/input/top_controls_state.h"
 #include "cc/layers/layer_lists.h"
 #include "cc/output/output_surface.h"
 #include "cc/resources/resource_format.h"
 #include "cc/resources/scoped_ui_resource.h"
 #include "cc/surfaces/surface_sequence.h"
 #include "cc/trees/layer_tree_host_client.h"
 #include "cc/trees/layer_tree_host_common.h"
+#include "cc/trees/layer_tree_mutators_client.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "cc/trees/proxy.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace gpu {
 class GpuMemoryBufferManager;
 }
 
 namespace cc {
 class AnimationRegistrar;
+class AnimationTimeline;
 class BeginFrameSource;
 class HeadsUpDisplayLayer;
 class Layer;
 class LayerTreeHostImpl;
 class LayerTreeHostImplClient;
 class LayerTreeHostSingleThreadClient;
 class PrioritizedResource;
 class PrioritizedResourceManager;
 class Region;
 class RenderingStatsInstrumentation;
@@ skipping 18 matching lines @@
   RendererCapabilities();
   ~RendererCapabilities();
 
   // Duplicate any modification to this list to RendererCapabilitiesImpl.
   ResourceFormat best_texture_format;
   bool allow_partial_texture_updates;
   int max_texture_size;
   bool using_shared_memory_resources;
 };
 
-class CC_EXPORT LayerTreeHost {
+class CC_EXPORT LayerTreeHost : public LayerTreeMutatorsClient {
  public:
   // The SharedBitmapManager will be used on the compositor thread.
   static scoped_ptr<LayerTreeHost> CreateThreaded(
       LayerTreeHostClient* client,
       SharedBitmapManager* shared_bitmap_manager,
       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
       const LayerTreeSettings& settings,
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
       scoped_ptr<BeginFrameSource> external_begin_frame_source);
@@ skipping 69 matching lines @@
   void SetNeedsRedraw();
   void SetNeedsRedrawRect(const gfx::Rect& damage_rect);
   bool CommitRequested() const;
   bool BeginMainFrameRequested() const;
 
   void SetNextCommitWaitsForActivation();
 
   void SetNextCommitForcesRedraw();
 
   void SetAnimationEvents(scoped_ptr<AnimationEventsVector> events);
+  void SetAnimationTimeline(scoped_refptr<AnimationTimeline> timeline);
 
   void SetRootLayer(scoped_refptr<Layer> root_layer);
   Layer* root_layer() { return root_layer_.get(); }
   const Layer* root_layer() const { return root_layer_.get(); }
   const Layer* overscroll_elasticity_layer() const {
     return overscroll_elasticity_layer_.get();
   }
   const Layer* page_scale_layer() const { return page_scale_layer_.get(); }
   void RegisterViewportLayers(scoped_refptr<Layer> overscroll_elasticity_layer,
                               scoped_refptr<Layer> page_scale_layer,
@@ skipping 76 matching lines @@
                               TopControlsState current,
                               bool animate);
 
   HeadsUpDisplayLayer* hud_layer() const { return hud_layer_.get(); }
 
   Proxy* proxy() const { return proxy_.get(); }
 
   AnimationRegistrar* animation_registrar() const {
     return animation_registrar_.get();
   }
+  AnimationTimeline* animation_timeline() const {
+    return animation_timeline_.get();
+  }
 
   // Obtains a thorough dump of the LayerTreeHost as a value.
   void AsValueInto(base::trace_event::TracedValue* value) const;
 
   bool in_paint_layer_contents() const { return in_paint_layer_contents_; }
 
   // CreateUIResource creates a resource given a bitmap.  The bitmap is
   // generated via an interface function, which is called when initializing the
   // resource and when the resource has been lost (due to lost context).  The
   // parameter of the interface is a single boolean, which indicates whether the
@@ skipping 32 matching lines @@
   void BreakSwapPromises(SwapPromise::DidNotSwapReason reason);
 
   size_t num_queued_swap_promises() const { return swap_promise_list_.size(); }
 
   void set_surface_id_namespace(uint32_t id_namespace);
   SurfaceSequence CreateSurfaceSequence();
 
   void SetChildrenNeedBeginFrames(bool children_need_begin_frames) const;
   void SendBeginFramesToChildren(const BeginFrameArgs& args) const;
 
+  Layer* LayerById(int id) const;
+  void RegisterLayer(Layer* layer);
+  void UnregisterLayer(Layer* layer);
+  // LayerTreeMutatorsClient implementation.
+  AnimationRegistrar* GetAnimationRegistrar() const override;
+  void SetMutatorsNeedCommit() override;
+  void SetLayerFilterMutated(int layer_id,
+                             bool active_tree,
+                             const FilterOperations& filters) override;
+  void SetLayerOpacityMutated(int layer_id,
+                              bool active_tree,
+                              float opacity) override;
+  void SetLayerTransformMutated(int layer_id,
+                                bool active_tree,
+                                const gfx::Transform& transform) override;
+
  protected:
   LayerTreeHost(LayerTreeHostClient* client,
                 SharedBitmapManager* shared_bitmap_manager,
                 gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
                 const LayerTreeSettings& settings);
   void InitializeThreaded(
       scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> impl_task_runner,
       scoped_ptr<BeginFrameSource> external_begin_frame_source);
   void InitializeSingleThreaded(
@@ skipping 95 matching lines @@
   bool content_is_suitable_for_gpu_rasterization_;
   bool gpu_rasterization_histogram_recorded_;
 
   SkColor background_color_;
   bool has_transparent_background_;
 
   typedef ScopedPtrVector<PrioritizedResource> TextureList;
   size_t partial_texture_update_requests_;
 
   scoped_ptr<AnimationRegistrar> animation_registrar_;
+  scoped_refptr<AnimationTimeline> animation_timeline_;
 
   scoped_ptr<PendingPageScaleAnimation> pending_page_scale_animation_;
 
   // If set, then page scale animation has completed, but the client hasn't been
   // notified about it yet.
   bool did_complete_scale_animation_;
 
   bool in_paint_layer_contents_;
 
   static const int kTotalFramesToUseForLCDTextMetrics = 50;
@@ skipping 20 matching lines @@
 
   LayerSelectionBound selection_start_;
   LayerSelectionBound selection_end_;
 
   SharedBitmapManager* shared_bitmap_manager_;
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
 
   ScopedPtrVector<SwapPromise> swap_promise_list_;
   std::set<SwapPromiseMonitor*> swap_promise_monitor_;
 
+  typedef base::hash_map<int, Layer*> LayerIdMap;
+  LayerIdMap layer_id_map_;
+
   uint32_t surface_id_namespace_;
   uint32_t next_surface_sequence_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHost);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_HOST_H_