CC Animation: Erase old animation system in UI Compositor.

ui/compositor/layer.h

 // Copyright (c) 2012 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 UI_COMPOSITOR_LAYER_H_
 #define UI_COMPOSITOR_LAYER_H_
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "cc/base/region.h"
 #include "cc/layers/content_layer_client.h"
 #include "cc/layers/layer_client.h"
 #include "cc/layers/surface_layer.h"
 #include "cc/layers/texture_layer_client.h"
 #include "cc/resources/texture_mailbox.h"
 #include "cc/surfaces/surface_id.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_delegate.h"
-#include "ui/compositor/layer_threaded_animation_delegate.h"
 #include "ui/compositor/layer_type.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/transform.h"
 
 class SkCanvas;
 
 namespace cc {
 class ContentLayer;
 class CopyOutputRequest;
 class Layer;
 class NinePatchLayer;
 class ResourceUpdateQueue;
 class SolidColorLayer;
 class SurfaceLayer;
 class TextureLayer;
 struct ReturnedResource;
 typedef std::vector<ReturnedResource> ReturnedResourceArray;
 }
 
 namespace ui {
 
 class Compositor;
 class LayerAnimator;
 class LayerOwner;
+class LayerThreadedAnimationDelegate;
 
 // Layer manages a texture, transform and a set of child Layers. Any View that
 // has enabled layers ends up creating a Layer to manage the texture.
 // A Layer can also be created without a texture, in which case it renders
 // nothing and is simply used as a node in a hierarchy of layers.
 // Coordinate system used in layers is DIP (Density Independent Pixel)
 // coordinates unless explicitly mentioned as pixel coordinates.
 //
 // NOTE: Unlike Views, each Layer does *not* own its child Layers. If you
 // delete a Layer and it has children, the parent of each child Layer is set to
 // NULL, but the children are not deleted.
 class COMPOSITOR_EXPORT Layer
     : public LayerAnimationDelegate,
-      public LayerThreadedAnimationDelegate,
       NON_EXPORTED_BASE(public cc::ContentLayerClient),
       NON_EXPORTED_BASE(public cc::TextureLayerClient),
       NON_EXPORTED_BASE(public cc::LayerClient) {
  public:
   Layer();
   explicit Layer(LayerType type);
   ~Layer() override;
 
-  static const cc::LayerSettings& UILayerSettings();
-  static void InitializeUILayerSettings();
-
   // Retrieves the Layer's compositor. The Layer will walk up its parent chain
   // to locate it. Returns NULL if the Layer is not attached to a compositor.
   Compositor* GetCompositor() {
     return const_cast<Compositor*>(
         const_cast<const Layer*>(this)->GetCompositor());
   }
   const Compositor* GetCompositor() const;
 
   // Called by the compositor when the Layer is set as its root Layer. This can
   // only ever be called on the root layer.
@@ skipping 308 matching lines @@
   float GetOpacityForAnimation() const override;
   bool GetVisibilityForAnimation() const override;
   float GetBrightnessForAnimation() const override;
   float GetGrayscaleForAnimation() const override;
   SkColor GetColorForAnimation() const override;
   float GetDeviceScaleFactor() const override;
   cc::Layer* GetCcLayer() const override;
   LayerThreadedAnimationDelegate* GetThreadedAnimationDelegate() override;
   LayerAnimatorCollection* GetLayerAnimatorCollection() override;
 
-  // Implementation of LayerThreadedAnimationDelegate.
-  void AddThreadedAnimation(scoped_ptr<cc::Animation> animation) override;
-  void RemoveThreadedAnimation(int animation_id) override;
-
   // Creates a corresponding composited layer for |type_|.
   void CreateCcLayer();
 
   // Recomputes and sets to |cc_layer_|.
   void RecomputeDrawsContentAndUVRect();
   void RecomputePosition();
 
   // Set all filters which got applied to the layer.
   void SetLayerFilters();
 
   // Set all filters which got applied to the layer background.
   void SetLayerBackgroundFilters();
 
   // Cleanup |cc_layer_| and replaces it with |new_layer|.
   void SwitchToLayer(scoped_refptr<cc::Layer> new_layer);
 
-  // We cannot send animations to our cc_layer_ until we have been added to a
-  // layer tree. Instead, we hold on to these animations in
-  // pending_threaded_animations_, and expect SendPendingThreadedAnimations to
-  // be called once we have been added to a tree.
-  void SendPendingThreadedAnimations();
-
   void SetCompositorForAnimatorsInTree(Compositor* compositor);
   void ResetCompositorForAnimatorsInTree(Compositor* compositor);
 
   const LayerType type_;
 
   Compositor* compositor_;
 
   Layer* parent_;
 
   // This layer's children, in bottom-to-top stacking order.
@@ skipping 41 matching lines @@
   scoped_ptr<SkRegion> alpha_shape_;
 
   std::string name_;
 
   LayerDelegate* delegate_;
 
   LayerOwner* owner_;
 
   scoped_refptr<LayerAnimator> animator_;
 
-  // Animations that are passed to AddThreadedAnimation before this layer is
-  // added to a tree.
-  std::vector<scoped_ptr<cc::Animation>> pending_threaded_animations_;
-
   // Ownership of the layer is held through one of the strongly typed layer
   // pointers, depending on which sort of layer this is.
   scoped_refptr<cc::Layer> content_layer_;
   scoped_refptr<cc::NinePatchLayer> nine_patch_layer_;
   scoped_refptr<cc::TextureLayer> texture_layer_;
   scoped_refptr<cc::SolidColorLayer> solid_color_layer_;
   scoped_refptr<cc::SurfaceLayer> surface_layer_;
   cc::Layer* cc_layer_;
 
   // A cached copy of |Compositor::device_scale_factor()|.
@@ skipping 14 matching lines @@
   // The size of the frame or texture in DIP, set when SetShowDelegatedContent
   // or SetTextureMailbox was called.
   gfx::Size frame_size_in_dip_;
 
   DISALLOW_COPY_AND_ASSIGN(Layer);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_H_