Thread ui opacity animations

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 <string>
 #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 "cc/animation_events.h"
 #include "cc/content_layer_client.h"
+#include "cc/layer_animation_event_observer.h"
 #include "cc/texture_layer_client.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_type.h"
 #include "ui/gfx/rect.h"
 #include "ui/gfx/transform.h"
 
@@ skipping 19 matching lines @@
 // 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 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 LayerAnimationDelegate,
       NON_EXPORTED_BASE(public cc::ContentLayerClient),
-      NON_EXPORTED_BASE(public cc::TextureLayerClient) {
+      NON_EXPORTED_BASE(public cc::TextureLayerClient),
+      NON_EXPORTED_BASE(public cc::LayerAnimationEventObserver) {
  public:
   Layer();
   explicit Layer(LayerType type);
   virtual ~Layer();
 
   // 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();
 
   // Called by the compositor when the Layer is set as its root Layer. This can
@@ skipping 61 matching lines @@
   // otherwise.
   gfx::Rect GetTargetBounds() const;
 
   // Sets/gets whether or not drawing of child layers should be clipped to the
   // bounds of this layer.
   void SetMasksToBounds(bool masks_to_bounds);
   bool GetMasksToBounds() 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_; }
+  float opacity() const;
   void SetOpacity(float opacity);
 
   // Returns the actual opacity, which the opacity of this layer multipled by
   // the combined opacity of the parent.
   float GetCombinedOpacity() const;
 
   // Blur pixels by this amount in anything below the layer and visible through
   // the layer.
   int background_blur() const { return background_blur_radius_; }
   void SetBackgroundBlur(int blur_radius);
@@ skipping 132 matching lines @@
   virtual unsigned prepareTexture(cc::ResourceUpdateQueue&) OVERRIDE;
   virtual WebKit::WebGraphicsContext3D* context() OVERRIDE;
 
   float device_scale_factor() const { return device_scale_factor_; }
 
   // Forces a render surface to be used on this layer. This has no positive
   // impact, and is only used for benchmarking/testing purpose.
   void SetForceRenderSurface(bool force);
   bool force_render_surface() const { return force_render_surface_; }
 
+  // LayerAnimationEventObserver
+  virtual void OnAnimationStarted(const cc::AnimationEvent& event) OVERRIDE;
+
  private:
   // Stacks |child| above or below |other|.  Helper method for StackAbove() and
   // StackBelow().
   void StackRelativeTo(Layer* child, Layer* other, bool above);
 
   bool ConvertPointForAncestor(const Layer* ancestor, gfx::Point* point) const;
   bool ConvertPointFromAncestor(const Layer* ancestor, gfx::Point* point) const;
 
   bool GetTargetTransformRelativeTo(const Layer* ancestor,
                                     gfx::Transform* transform) const;
@@ skipping 23 matching lines @@
   virtual void SetGrayscaleFromAnimation(float grayscale) OVERRIDE;
   virtual void SetColorFromAnimation(SkColor color) OVERRIDE;
   virtual void ScheduleDrawForAnimation() OVERRIDE;
   virtual const gfx::Rect& GetBoundsForAnimation() const OVERRIDE;
   virtual const gfx::Transform& GetTransformForAnimation() const OVERRIDE;
   virtual float GetOpacityForAnimation() const OVERRIDE;
   virtual bool GetVisibilityForAnimation() const OVERRIDE;
   virtual float GetBrightnessForAnimation() const OVERRIDE;
   virtual float GetGrayscaleForAnimation() const OVERRIDE;
   virtual SkColor GetColorForAnimation() const OVERRIDE;
+  virtual void AddThreadedAnimation(
+      scoped_ptr<cc::Animation> animation) OVERRIDE;
+  virtual void RemoveThreadedAnimation(int animation_id) OVERRIDE;

[sky, 2013/02/19 17:06:56]

Seems weird that Add and Remove take different things.

[ajuma, 2013/02/20 16:09:10]

This is consistent with cc::Layer::addAnimation and cc::Layer::removeAnimation.
Since AddThreadedAnimation takes ownership of the animation (and passes
ownership on to cc::Layer::addAnimation), it's not possible to make
RemoveThreadedAnimation take an animation rather than an id, since the caller
doesn't actually have the animation (but it can easily keep a copy of the id).

 
   void CreateWebLayer();
   void RecomputeTransform();
   void RecomputeDrawsContentAndUVRect();
 
   // Set all filters which got applied to the layer.
   void SetLayerFilters();
 
   // Set all filters which got applied to the layer background.
   void SetLayerBackgroundFilters();
@@ skipping 25 matching lines @@
 
   bool fills_bounds_opaquely_;
 
   // If true the layer is always up to date.
   bool layer_updated_externally_;
 
   // Union of damaged rects, in pixel coordinates, to be used when
   // compositor is ready to paint the content.
   SkRegion damaged_region_;
 
-  float opacity_;
   int background_blur_radius_;
 
   // Several variables which will change the visible representation of
   // the layer.
   float layer_saturation_;
   float layer_brightness_;
   float layer_grayscale_;
   bool layer_inverted_;
 
   // The associated mask layer with this layer.
@@ skipping 35 matching lines @@
 
   // A cached copy of |Compositor::device_scale_factor()|.
   float device_scale_factor_;
 
   DISALLOW_COPY_AND_ASSIGN(Layer);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_H_