Not for review: Enable accelerated animations for orphaned layers

cc/layer_animation_controller.cc

 // 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.
 
 #include "cc/layer_animation_controller.h"
 
 #include <algorithm>
 
 #include "cc/animation.h"
 #include "cc/animation_registrar.h"
 #include "cc/keyframed_animation_curve.h"
 #include "cc/layer_animation_value_observer.h"
 #include "cc/scoped_ptr_algorithm.h"
 #include "ui/gfx/transform.h"
 
 namespace cc {
 
 LayerAnimationController::LayerAnimationController(int id)
     : m_forceSync(false)
     , m_id(id)
     , m_registrar(0)
     , m_isActive(false)
+    , m_orphanWaitStatus(NeverWaitedForLayout)
 {
 }
 
 LayerAnimationController::~LayerAnimationController()
 {
     if (m_registrar)
         m_registrar->UnregisterAnimationController(this);
 }
 
 scoped_refptr<LayerAnimationController> LayerAnimationController::create(int id)
@@ skipping 90 matching lines @@
     tickAnimations(monotonicTime);
     markAnimationsForDeletion(monotonicTime, events);
     startAnimationsWaitingForTargetAvailability(monotonicTime, events);
 
     updateActivation();
 }
 
 void LayerAnimationController::addAnimation(scoped_ptr<Animation> animation)
 {
     m_activeAnimations.push_back(animation.Pass());
+    if ((m_orphanWaitStatus == NeverWaitedForLayout) && !hasNonOrphanedObserver())
+        m_orphanWaitStatus = WaitingForLayout;
     updateActivation();
 }
 
 Animation* LayerAnimationController::getAnimation(int groupId, Animation::TargetProperty targetProperty) const
 {
     for (size_t i = 0; i < m_activeAnimations.size(); ++i)
         if (m_activeAnimations[i]->group() == groupId && m_activeAnimations[i]->targetProperty() == targetProperty)
             return m_activeAnimations[i];
     return 0;
 }
@@ skipping 57 matching lines @@
 {
     if (!m_observers.HasObserver(observer))
         m_observers.AddObserver(observer);
 }
 
 void LayerAnimationController::removeObserver(LayerAnimationValueObserver* observer)
 {
     m_observers.RemoveObserver(observer);
 }
 
+bool LayerAnimationController::hasNonOrphanedObserver()
+{
+    if (m_observers.might_have_observers()) {
+        ObserverListBase<LayerAnimationValueObserver>::Iterator it(m_observers);
+        LayerAnimationValueObserver* obs;
+        while ((obs = it.GetNext()) != NULL) {
+            if (!obs->IsOrphaned())
+                return true;
+        }
+    }
+    return false;
+}
+
 void LayerAnimationController::pushNewAnimationsToImplThread(LayerAnimationController* controllerImpl) const
 {
     // Any new animations owned by the main thread's controller are cloned and adde to the impl thread's controller.
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
         // If the animation is already running on the impl thread, there is no need to copy it over.
         if (controllerImpl->getAnimation(m_activeAnimations[i]->group(), m_activeAnimations[i]->targetProperty()))
             continue;
 
         // If the animation is not running on the impl thread, it does not necessarily mean that it needs
         // to be copied over and started; it may have already finished. In this case, the impl thread animation
@@ skipping 256 matching lines @@
         ObserverListBase<LayerAnimationValueObserver>::Iterator it(m_observers);
         LayerAnimationValueObserver* obs;
         while ((obs = it.GetNext()) != NULL)
             if (obs->IsActive())
                 return true;
     }
     return false;
 }
 
 }  // namespace cc