Reland r107720 - Enable the new layer animation framework.

ui/gfx/compositor/layer.h

 // Copyright (c) 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 UI_GFX_COMPOSITOR_LAYER_H_
 #define UI_GFX_COMPOSITOR_LAYER_H_
 #pragma once
 
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
 #include "ui/gfx/compositor/compositor.h"
-#include "ui/gfx/compositor/layer_animation_manager.h"
-#include "ui/gfx/compositor/layer_animator_delegate.h"
+#include "ui/gfx/compositor/layer_animation_delegate.h"
 #include "ui/gfx/compositor/layer_delegate.h"
 
 class SkCanvas;
 
 namespace ui {
 
-class Animation;
 class Compositor;
+class LayerAnimator;
 class Texture;
 
 // 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.
 //
 // NOTE: unlike Views, each Layer does *not* own its children views. 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 LayerAnimatorDelegate {
+class COMPOSITOR_EXPORT Layer : public LayerAnimationDelegate {
  public:
   enum LayerType {
     LAYER_HAS_NO_TEXTURE = 0,
     LAYER_HAS_TEXTURE = 1
   };
 
   // |compositor| can be NULL, and will be set later when the Layer is added to
   // a Compositor.
   explicit Layer(Compositor* compositor);
   Layer(Compositor* compositor, LayerType type);
@@ skipping 22 matching lines @@
   // Returns the child Layers.
   const std::vector<Layer*>& children() const { return children_; }
 
   // The parent.
   const Layer* parent() const { return parent_; }
   Layer* parent() { return parent_; }
 
   // Returns true if this Layer contains |other| somewhere in its children.
   bool Contains(const Layer* other) const;
 
-  // Sets the animation to use for changes to opacity, position or transform.
-  // That is, if you invoke this with non-NULL |animation| is started and any
-  // changes to opacity, position or transform are animated between the current
-  // value and target value. If the current animation is NULL or completed,
-  // changes are immediate. If the opacity, transform or bounds are changed
-  // and the animation is part way through, the animation is canceled and
-  // the bounds, opacity and transfrom and set to the target value.
-  // Layer takes ownership of |animation| and installs it's own delegate on the
-  // animation.
-  void SetAnimation(Animation* animation);
+  // The layer's animator is responsible for causing automatic animations when
+  // properties are set. It also manages a queue of pending animations and
+  // handles blending of animations.
+  void SetAnimator(LayerAnimator* animator);
+
+  // Returns the layer's animator. Creates a default animator of one has not
+  // been set. Will not return NULL.
+  LayerAnimator* GetAnimator();
 
   // The transform, relative to the parent.
   void SetTransform(const ui::Transform& transform);
-  const ui::Transform& transform() const { return transform_; }
+  const Transform& transform() const { return transform_; }
+
+  // Return the target transform if animator is running, or the current
+  // transform otherwise.
+  Transform GetTargetTransform() const;
 
   // The bounds, relative to the parent.
   void SetBounds(const gfx::Rect& bounds);
   const gfx::Rect& bounds() const { return bounds_; }
 
   // Return the target bounds if animator is running, or the current bounds
   // otherwise.
   gfx::Rect GetTargetBounds() const;
 
   // The opacity of the layer. The opacity is applied to each pixel of the
   // texture (resulting alpha = opacity * alpha).
   float opacity() const { return opacity_; }
   void SetOpacity(float opacity);
 
+  // Return the target opacity if animator is running, or the current bounds
+  // otherwise.
+  float GetTargetOpacity() const;
+
   // Sets the visibility of the Layer. A Layer may be visible but not
   // drawn. This happens if any ancestor of a Layer is not visible.
   void SetVisible(bool visible);
   bool visible() const { return visible_; }
 
   // Returns true if this Layer is drawn. A Layer is drawn only if all ancestors
   // are visible.
   bool IsDrawn() const;
 
   // Returns true if this layer can have a texture (has_texture_ is true)
@@ skipping 97 matching lines @@
   bool ConvertPointFromAncestor(const Layer* ancestor, gfx::Point* point) const;
 
   bool GetTransformRelativeTo(const Layer* ancestor,
                               Transform* transform) const;
 
   // The only externally updated layers are ones that get their pixels from
   // WebKit and WebKit does not produce valid alpha values. All other layers
   // should have valid alpha.
   bool has_valid_alpha_channel() const { return !layer_updated_externally_; }
 
-  // If the animation is running and has progressed, it is stopped and all
-  // properties that are animated (except |property|) are immediately set to
-  // their target value.
-  void StopAnimatingIfNecessary(
-      LayerAnimationManager::AnimationProperty property);
-
   // Following are invoked from the animation or if no animation exists to
   // update the values immediately.
   void SetBoundsImmediately(const gfx::Rect& bounds);
   void SetTransformImmediately(const ui::Transform& transform);
   void SetOpacityImmediately(float opacity);
 
-  // LayerAnimatorDelegate overrides:
-  virtual void SetBoundsFromAnimator(const gfx::Rect& bounds) OVERRIDE;
-  virtual void SetTransformFromAnimator(const Transform& transform) OVERRIDE;
-  virtual void SetOpacityFromAnimator(float opacity) OVERRIDE;
+  // Implementation of LayerAnimationDelegate
+  virtual void SetBoundsFromAnimation(const gfx::Rect& bounds) OVERRIDE;
+  virtual void SetTransformFromAnimation(const Transform& transform) OVERRIDE;
+  virtual void SetOpacityFromAnimation(float opacity) OVERRIDE;
+  virtual void ScheduleDrawForAnimation() OVERRIDE;
+  virtual const gfx::Rect& GetBoundsForAnimation() const OVERRIDE;
+  virtual const Transform& GetTransformForAnimation() const OVERRIDE;
+  virtual float GetOpacityForAnimation() const OVERRIDE;
 
   const LayerType type_;
 
   Compositor* compositor_;
 
   scoped_refptr<ui::Texture> texture_;
 
   Layer* parent_;
 
   std::vector<Layer*> children_;
@@ skipping 11 matching lines @@
 
   gfx::Rect invalid_rect_;
 
   // If true the layer is always up to date.
   bool layer_updated_externally_;
 
   float opacity_;
 
   LayerDelegate* delegate_;
 
-  scoped_ptr<LayerAnimationManager> animator_;
+  scoped_ptr<LayerAnimator> animator_;
 
   DISALLOW_COPY_AND_ASSIGN(Layer);
 };
 
 }  // namespace ui
 
 #endif  // UI_GFX_COMPOSITOR_LAYER_H_