Not for review: Enable accelerated animations for orphaned layers

cc/layer_animation_controller.h

 // Copyright 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 CC_LAYER_ANIMATION_CONTROLLER_H_
 #define CC_LAYER_ANIMATION_CONTROLLER_H_
 
 #include "base/basictypes.h"
 #include "base/hash_tables.h"
 #include "base/memory/ref_counted.h"
@@ skipping 14 matching lines @@
 
 class Animation;
 class AnimationRegistrar;
 class KeyframeValueList;
 class LayerAnimationValueObserver;
 
 class CC_EXPORT LayerAnimationController
     : public base::RefCounted<LayerAnimationController>,
       public LayerAnimationEventObserver {
 public:
+    // Controllers belonging to orphan layers begin in the
+    // NeverWaitedForLayout state. Once an animation is added to such
+    // a controller, it moves into the WaitingForLayout state, and then moves
+    // into the WaitedForLayout state after the next layout.
+    enum OrphanWaitStatus {
+        NeverWaitedForLayout = 0,
+        WaitingForLayout,
+        WaitedForLayout
+    };
+
     static scoped_refptr<LayerAnimationController> create(int id);
 
     int id() const { return m_id; }
 
     // These methods are virtual for testing.
     virtual void addAnimation(scoped_ptr<Animation>);
     virtual void pauseAnimation(int animationId, double timeOffset);
     virtual void removeAnimation(int animationId);
     virtual void removeAnimation(int animationId, Animation::TargetProperty);
     virtual void suspendAnimations(double monotonicTime);
@@ skipping 25 matching lines @@
 
     // This is called in response to an animation being started on the impl thread. This
     // function updates the corresponding main thread animation's start time.
     virtual void OnAnimationStarted(const AnimationEvent&) OVERRIDE;
 
     // If a sync is forced, then the next time animation updates are pushed to the impl
     // thread, all animations will be transferred.
     void setForceSync() { m_forceSync = true; }
 
     void setAnimationRegistrar(AnimationRegistrar*);
+    AnimationRegistrar* animationRegistrar() { return m_registrar; }
 
     void addObserver(LayerAnimationValueObserver*);
     void removeObserver(LayerAnimationValueObserver*);
 
+    bool hasNonOrphanedObserver();
+
+    void setOrphanWaitStatus(OrphanWaitStatus status) { m_orphanWaitStatus = status; }
+    OrphanWaitStatus orphanWaitStatus() const { return m_orphanWaitStatus; }
+
 protected:
     friend class base::RefCounted<LayerAnimationController>;
 
     LayerAnimationController(int id);
     virtual ~LayerAnimationController();
 
 private:
     typedef base::hash_set<int> TargetProperties;
 
     void pushNewAnimationsToImplThread(LayerAnimationController*) const;
@@ skipping 22 matching lines @@
 
     AnimationRegistrar* m_registrar;
     int m_id;
     ScopedPtrVector<Animation> m_activeAnimations;
 
     // This is used to ensure that we don't spam the registrar.
     bool m_isActive;
 
     ObserverList<LayerAnimationValueObserver> m_observers;
 
+    OrphanWaitStatus m_orphanWaitStatus;
+
     DISALLOW_COPY_AND_ASSIGN(LayerAnimationController);
 };
 
 } // namespace cc
 
 #endif  // CC_LAYER_ANIMATION_CONTROLLER_H_