Avoid conditional Animation prefinalizers.

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 81 matching lines @@
       m_timeline(&timeline),
       m_paused(false),
       m_held(false),
       m_isPausedForTesting(false),
       m_isCompositedAnimationDisabledForTesting(false),
       m_outdated(false),
       m_finished(true),
       m_compositorState(nullptr),
       m_compositorPending(false),
       m_compositorGroup(0),
-      m_preFinalizerRegistered(false),
       m_currentTimePending(false),
       m_stateIsBeingUpdated(false),
       m_effectSuppressed(false) {
   if (m_content) {
     if (m_content->animation()) {
       m_content->animation()->cancel();
       m_content->animation()->setEffect(0);
     }
     m_content->attach(this);
   }
   InspectorInstrumentation::didCreateAnimation(m_timeline->document(),
                                                m_sequenceNumber);
 }
 
 Animation::~Animation() {
-  destroyCompositorPlayer();
+  // Verify that m_compositorPlayer has been disposed of.
+  DCHECK(!m_compositorPlayer);
 }
 
 void Animation::dispose() {
   destroyCompositorPlayer();
   // If the AnimationTimeline and its Animation objects are
   // finalized by the same GC, we have to eagerly clear out
   // this Animation object's compositor player registration.
   DCHECK(!m_compositorPlayer);
 }
 
@@ skipping 774 matching lines @@
 }
 
 void Animation::endUpdatingState() {
   DCHECK(m_stateIsBeingUpdated);
   m_stateIsBeingUpdated = false;
 }
 
 void Animation::createCompositorPlayer() {
   if (Platform::current()->isThreadedAnimationEnabled() &&
       !m_compositorPlayer) {
-    // We only need to pre-finalize if we are running animations on the
-    // compositor.
-    if (!m_preFinalizerRegistered) {
-      ThreadState::current()->registerPreFinalizer(this);
-      m_preFinalizerRegistered = true;
-    }
-
     DCHECK(Platform::current()->compositorSupport());
-    m_compositorPlayer = CompositorAnimationPlayer::create();
+    m_compositorPlayer = CompositorAnimationPlayerHolder::create(this);
     DCHECK(m_compositorPlayer);
-    m_compositorPlayer->setAnimationDelegate(this);
     attachCompositorTimeline();
   }
 
   attachCompositedLayers();
 }
 
 void Animation::destroyCompositorPlayer() {
   detachCompositedLayers();
 
   if (m_compositorPlayer) {
     detachCompositorTimeline();
-    m_compositorPlayer->setAnimationDelegate(nullptr);
-    m_compositorPlayer.reset();
+    m_compositorPlayer->detach();
+    m_compositorPlayer = nullptr;
   }
 }
 
 void Animation::attachCompositorTimeline() {
   if (m_compositorPlayer) {
     CompositorAnimationTimeline* timeline =
         m_timeline ? m_timeline->compositorTimeline() : nullptr;
     if (timeline)
       timeline->playerAttached(*this);
   }
@@ skipping 12 matching lines @@
   if (!m_compositorPlayer)
     return;
 
   DCHECK(m_content);
   DCHECK(m_content->isKeyframeEffectReadOnly());
 
   toKeyframeEffectReadOnly(m_content.get())->attachCompositedLayers();
 }
 
 void Animation::detachCompositedLayers() {
-  if (m_compositorPlayer && m_compositorPlayer->isElementAttached())
-    m_compositorPlayer->detachElement();
+  if (m_compositorPlayer && m_compositorPlayer->player()->isElementAttached())
+    m_compositorPlayer->player()->detachElement();
 }
 
 void Animation::notifyAnimationStarted(double monotonicTime, int group) {
   timeline()
       ->document()
       ->compositorPendingAnimations()
       .notifyCompositorAnimationStarted(monotonicTime, group);
 }
 
 Animation::PlayStateUpdateScope::PlayStateUpdateScope(
@@ skipping 138 matching lines @@
                                    StyleChangeReason::StyleSheetChange));
 }
 
 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);
   SuspendableObject::trace(visitor);
 }
 
+Animation::CompositorAnimationPlayerHolder*
+Animation::CompositorAnimationPlayerHolder::create(Animation* animation) {
+  return new CompositorAnimationPlayerHolder(animation);
+}
+
+Animation::CompositorAnimationPlayerHolder::CompositorAnimationPlayerHolder(
+    Animation* animation)
+    : m_animation(animation) {
+  ThreadState::current()->registerPreFinalizer(this);
+  m_compositorPlayer = CompositorAnimationPlayer::create();
+  m_compositorPlayer->setAnimationDelegate(m_animation);
+}
+
+void Animation::CompositorAnimationPlayerHolder::dispose() {
+  if (!m_animation)
+    return;
+  m_animation->dispose();
+  DCHECK(!m_animation);
+  DCHECK(!m_compositorPlayer);
+}
+
+void Animation::CompositorAnimationPlayerHolder::detach() {
+  DCHECK(m_compositorPlayer);
+  m_compositorPlayer->setAnimationDelegate(nullptr);
+  m_animation = nullptr;
+  m_compositorPlayer.reset();
+}
 }  // namespace blink