Merge 116786 - [chromium] Ensure that animations continue to run when transform-style is changed

Source/WebCore/platform/graphics/chromium/cc/CCLayerAnimationController.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 98 matching lines @@
 
     // If timeOffset > 0, then the animation has started in the past.
     anim->setTimeOffset(timeOffset);
 
     return anim.release();
 }
 
 } // namepace
 
 CCLayerAnimationController::CCLayerAnimationController(CCLayerAnimationControllerClient* client)
-    : m_client(client)
+    : m_forceSync(false)
+    , m_client(client)
 {
 }
 
 CCLayerAnimationController::~CCLayerAnimationController()
 {
 }
 
 PassOwnPtr<CCLayerAnimationController> CCLayerAnimationController::create(CCLayerAnimationControllerClient* client)
 {
     return adoptPtr(new CCLayerAnimationController(client));
@@ skipping 58 matching lines @@
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
         if (m_activeAnimations[i]->runState() == CCActiveAnimation::Paused)
             m_activeAnimations[i]->setRunState(CCActiveAnimation::Running, monotonicTime);
     }
 }
 
 // Ensures that the list of active animations on the main thread and the impl thread
 // are kept in sync.
 void CCLayerAnimationController::pushAnimationUpdatesTo(CCLayerAnimationController* controllerImpl)
 {
-    pushNewAnimationsToImplThread(controllerImpl);
-    removeAnimationsCompletedOnMainThread(controllerImpl);
-    pushPropertiesToImplThread(controllerImpl);
+    if (m_forceSync) {
+        replaceImplThreadAnimations(controllerImpl);
+        m_forceSync = false;
+    } else {
+        pushNewAnimationsToImplThread(controllerImpl);
+        removeAnimationsCompletedOnMainThread(controllerImpl);
+        pushPropertiesToImplThread(controllerImpl);
+    }
 }
 
 void CCLayerAnimationController::animate(double monotonicTime, CCAnimationEventsVector* events)
 {
     startAnimationsWaitingForNextTick(monotonicTime, events);
     startAnimationsWaitingForStartTime(monotonicTime, events);
     startAnimationsWaitingForTargetAvailability(monotonicTime, events);
     resolveConflicts(monotonicTime);
     tickAnimations(monotonicTime);
     purgeFinishedAnimations(monotonicTime, events);
@@ skipping 27 matching lines @@
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
         if (m_activeAnimations[i]->runState() != CCActiveAnimation::Finished && m_activeAnimations[i]->runState() != CCActiveAnimation::Aborted && m_activeAnimations[i]->targetProperty() == targetProperty)
             return true;
     }
     return false;
 }
 
 void CCLayerAnimationController::notifyAnimationStarted(const CCAnimationEvent& event)
 {
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
-        if (m_activeAnimations[i]->group() == event.groupId && m_activeAnimations[i]->targetProperty() == event.targetProperty) {
-            ASSERT(m_activeAnimations[i]->needsSynchronizedStartTime());
+        if (m_activeAnimations[i]->group() == event.groupId && m_activeAnimations[i]->targetProperty() == event.targetProperty && m_activeAnimations[i]->needsSynchronizedStartTime()) {
             m_activeAnimations[i]->setNeedsSynchronizedStartTime(false);
             m_activeAnimations[i]->setStartTime(event.monotonicTime);
             return;
         }
     }
 }
 
+void CCLayerAnimationController::setClient(CCLayerAnimationControllerClient* client)
+{
+    m_client = client;
+}
+
 void CCLayerAnimationController::pushNewAnimationsToImplThread(CCLayerAnimationController* 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->getActiveAnimation(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
         // will have already notified that it has started and the main thread animation will no longer need
         // a synchronized start time.
         if (!m_activeAnimations[i]->needsSynchronizedStartTime())
             continue;
 
         OwnPtr<CCActiveAnimation> toAdd(m_activeAnimations[i]->cloneForImplThread());
         ASSERT(!toAdd->needsSynchronizedStartTime());
         // The new animation should be set to run as soon as possible.
         toAdd->setRunState(CCActiveAnimation::WaitingForTargetAvailability, 0);
+        toAdd->setStartTime(0);
         controllerImpl->add(toAdd.release());
     }
 }
 
 void CCLayerAnimationController::removeAnimationsCompletedOnMainThread(CCLayerAnimationController* controllerImpl) const
 {
     // Delete all impl thread animations for which there is no corresponding main thread animation.
     // Each iteration, controller->m_activeAnimations.size() is decremented or i is incremented
     // guaranteeing progress towards loop termination.
     for (size_t i = 0; i < controllerImpl->m_activeAnimations.size();) {
@@ skipping 136 matching lines @@
                     if (events)
                         events->append(CCAnimationEvent(CCAnimationEvent::Finished, m_client->id(), m_activeAnimations[j]->group(), m_activeAnimations[j]->targetProperty(), monotonicTime));
                     m_activeAnimations.remove(j);
                 }
             }
         } else
             i++;
     }
 }
 
+void CCLayerAnimationController::replaceImplThreadAnimations(CCLayerAnimationController* controllerImpl) const
+{
+    controllerImpl->m_activeAnimations.clear();
+    for (size_t i = 0; i < m_activeAnimations.size(); ++i)
+        controllerImpl->add(m_activeAnimations[i]->cloneForImplThread());
+}
+
 void CCLayerAnimationController::tickAnimations(double monotonicTime)
 {
     for (size_t i = 0; i < m_activeAnimations.size(); ++i) {
         if (m_activeAnimations[i]->runState() == CCActiveAnimation::Running || m_activeAnimations[i]->runState() == CCActiveAnimation::Paused) {
             double trimmed = m_activeAnimations[i]->trimTimeToCurrentIteration(monotonicTime);
 
             // Animation assumes its initial value until it gets the synchronized start time
             // from the impl thread and can start ticking.
             if (m_activeAnimations[i]->needsSynchronizedStartTime())
                 trimmed = 0;
@@ skipping 19 matching lines @@
                 m_client->setOpacityFromAnimation(opacity);
                 break;
             }
 
             }
         }
     }
 }
 
 } // namespace WebCore