Resolve ready and finished promises asynchronously

third_party/WebKit/Source/core/animation/Animation.cpp

 /*
  * Copyright (C) 2013 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 19 matching lines @@
 
 #include "core/animation/Animation.h"
 
 #include "core/animation/AnimationTimeline.h"
 #include "core/animation/CompositorPendingAnimations.h"
 #include "core/animation/KeyframeEffectReadOnly.h"
 #include "core/animation/css/CSSAnimations.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/StyleChangeReason.h"
+#include "core/dom/TaskRunnerHelper.h"
 #include "core/events/AnimationPlaybackEvent.h"
 #include "core/frame/UseCounter.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/inspector/InspectorTraceEvents.h"
 #include "platform/RuntimeEnabledFeatures.h"
+#include "platform/WebTaskRunner.h"
 #include "platform/animation/CompositorAnimationPlayer.h"
+#include "platform/heap/Persistent.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCompositorSupport.h"
 #include "wtf/MathExtras.h"
 #include "wtf/PtrUtil.h"
 
 namespace blink {
 
 namespace {
 
@@ skipping 587 matching lines @@
 const AtomicString& Animation::interfaceName() const {
   return EventTargetNames::AnimationPlayer;
 }
 
 ExecutionContext* Animation::getExecutionContext() const {
   return ContextLifecycleObserver::getExecutionContext();
 }
 
 bool Animation::hasPendingActivity() const {
   bool hasPendingPromise =
-      !m_finished && m_finishedPromise &&
+      m_finishedPromise &&
       m_finishedPromise->getState() == ScriptPromisePropertyBase::Pending;
 
   return m_pendingFinishedEvent || hasPendingPromise ||
          (!m_finished && hasEventListeners(EventTypeNames::finish));
 }
 
 void Animation::contextDestroyed() {
   PlayStateUpdateScope updateScope(*this, TimingUpdateOnDemand);
 
   m_finished = true;
@@ skipping 341 matching lines @@
 
   // Ordering is important, the ready promise should resolve/reject before
   // the finished promise.
   if (m_animation->m_readyPromise && newPlayState != oldPlayState) {
     if (newPlayState == Idle) {
       if (m_animation->m_readyPromise->getState() ==
           AnimationPromise::Pending) {
         m_animation->m_readyPromise->reject(DOMException::create(AbortError));
       }
       m_animation->m_readyPromise->reset();
-      m_animation->m_readyPromise->resolve(m_animation);
+      m_animation->resolvePromiseAsync(m_animation->m_readyPromise.get());
     } else if (oldPlayState == Pending) {
-      m_animation->m_readyPromise->resolve(m_animation);
+      m_animation->resolvePromiseAsync(m_animation->m_readyPromise.get());
     } else if (newPlayState == Pending) {
       DCHECK_NE(m_animation->m_readyPromise->getState(),
                 AnimationPromise::Pending);
       m_animation->m_readyPromise->reset();
     }
   }
 
   if (m_animation->m_finishedPromise && newPlayState != oldPlayState) {
     if (newPlayState == Idle) {
       if (m_animation->m_finishedPromise->getState() ==
           AnimationPromise::Pending) {
         m_animation->m_finishedPromise->reject(
             DOMException::create(AbortError));
       }
       m_animation->m_finishedPromise->reset();
     } else if (newPlayState == Finished) {
-      m_animation->m_finishedPromise->resolve(m_animation);
+      m_animation->resolvePromiseAsync(m_animation->m_finishedPromise.get());
     } else if (oldPlayState == Finished) {
       m_animation->m_finishedPromise->reset();
     }
   }
 
   if (oldPlayState != newPlayState &&
       (oldPlayState == Idle || newPlayState == Idle)) {
     m_animation->setOutdated();
   }
 
@@ skipping 57 matching lines @@
     return;
 
   Element& target = *toKeyframeEffectReadOnly(m_content.get())->target();
 
   if (CSSAnimations::isAffectedByKeyframesFromScope(target, treeScope))
     target.setNeedsStyleRecalc(LocalStyleChange,
                                StyleChangeReasonForTracing::create(
                                    StyleChangeReason::StyleSheetChange));
 }
 
+void Animation::resolvePromiseAsync(AnimationPromise* promise) {
+  TaskRunnerHelper::get(TaskType::DOMManipulation, getExecutionContext())
+      ->postTask(BLINK_FROM_HERE,
+                 WTF::bind(&AnimationPromise::resolve<Animation*>,
+                           wrapPersistent(promise), wrapPersistent(this)));
+}
+
 DEFINE_TRACE(Animation) {
   visitor->trace(m_content);
   visitor->trace(m_timeline);
   visitor->trace(m_pendingFinishedEvent);
   visitor->trace(m_pendingCancelledEvent);
   visitor->trace(m_finishedPromise);
   visitor->trace(m_readyPromise);
   visitor->trace(m_compositorPlayer);
   EventTargetWithInlineData::trace(visitor);
   ContextLifecycleObserver::trace(visitor);
@@ skipping 19 matching lines @@
   DCHECK(!m_compositorPlayer);
 }
 
 void Animation::CompositorAnimationPlayerHolder::detach() {
   DCHECK(m_compositorPlayer);
   m_compositorPlayer->setAnimationDelegate(nullptr);
   m_animation = nullptr;
   m_compositorPlayer.reset();
 }
 }  // namespace blink