Implement new AnimationTimeline superclass

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 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "core/animation/Animation.h"
 
 #include "core/animation/AnimationTimeline.h"
 #include "core/animation/CompositorPendingAnimations.h"
 #include "core/animation/DocumentTimeline.h"
 #include "core/animation/KeyframeEffectReadOnly.h"
+#include "core/animation/SuperAnimationTimeline.h"
 #include "core/animation/css/CSSAnimations.h"
 #include "core/dom/DOMNodeIds.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/dom/StyleChangeReason.h"
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/events/AnimationPlaybackEvent.h"
 #include "core/frame/UseCounter.h"
 #include "core/inspector/InspectorTraceEvents.h"
@@ skipping 14 matching lines @@
 
 namespace {
 
 static unsigned NextSequenceNumber() {
   static unsigned next = 0;
   return ++next;
 }
 }
 
 Animation* Animation::Create(AnimationEffectReadOnly* effect,
-                             AnimationTimeline* timeline) {
-  if (!timeline) {
+                             SuperAnimationTimeline* timeline) {
+  if (!timeline || !timeline->IsAnimationTimeline()) {
     // FIXME: Support creating animations without a timeline.
     NOTREACHED();
     return nullptr;
   }
 
+  AnimationTimeline* subtimeline = ToAnimationTimeline(timeline);

[alancutter (OOO until 2018), 2017/06/21 05:36:17]

Add TODO to remove the dependency on (future) DocumentTimeline.

+
   Animation* animation = new Animation(
-      timeline->GetDocument()->ContextDocument(), *timeline, effect);
+      subtimeline->GetDocument()->ContextDocument(), *subtimeline, effect);
 
-  if (timeline) {
-    timeline->AnimationAttached(*animation);
+  if (subtimeline) {
+    subtimeline->AnimationAttached(*animation);
     animation->AttachCompositorTimeline();
   }
 
   return animation;
 }
 
 Animation* Animation::Create(ExecutionContext* execution_context,
                              AnimationEffectReadOnly* effect,
                              ExceptionState& exception_state) {
   DCHECK(RuntimeEnabledFeatures::WebAnimationsAPIEnabled());
 
   Document* document = ToDocument(execution_context);
   return Create(effect, &document->Timeline());
 }
 
 Animation* Animation::Create(ExecutionContext* execution_context,
                              AnimationEffectReadOnly* effect,
-                             AnimationTimeline* timeline,
+                             SuperAnimationTimeline* timeline,
                              ExceptionState& exception_state) {
   DCHECK(RuntimeEnabledFeatures::WebAnimationsAPIEnabled());
 
   if (!timeline) {
     return Create(execution_context, effect, exception_state);
   }
 
   return Create(effect, timeline);
 }
 
@@ skipping 651 matching lines @@
              ->CanStartAnimationOnCompositor(playback_rate_);
 }
 
 bool Animation::CanStartAnimationOnCompositorInternal(
     const Optional<CompositorElementIdSet>& composited_element_ids) const {
   if (is_composited_animation_disabled_for_testing_ || EffectSuppressed())
     return false;
 
   // FIXME: Timeline playback rates should be compositable
   if (playback_rate_ == 0 || (std::isinf(EffectEnd()) && playback_rate_ < 0) ||
-      (timeline() && timeline()->PlaybackRate() != 1))
+      (TimelineInternal() && TimelineInternal()->PlaybackRate() != 1))
     return false;
 
   if (!timeline_ || !content_ || !content_->IsKeyframeEffectReadOnly())
     return false;
 
   // If the optional element id set has no value we must be in SPv1 mode in
   // which case we trust the compositing logic will create a layer if needed.
   if (composited_element_ids.has_value()) {
     DCHECK(RuntimeEnabledFeatures::SlimmingPaintV2Enabled());
     Element* target_element =
@@ skipping 21 matching lines @@
 
   return true;
 }
 
 void Animation::StartAnimationOnCompositor(
     const Optional<CompositorElementIdSet>& composited_element_ids) {
   DCHECK(CanStartAnimationOnCompositor(composited_element_ids));
 
   bool reversed = playback_rate_ < 0;
 
-  double start_time = timeline()->ZeroTime() + StartTimeInternal();
+  double start_time = TimelineInternal()->ZeroTime() + StartTimeInternal();
   if (reversed) {
     start_time -= EffectEnd() / fabs(playback_rate_);
   }
 
   double time_offset = 0;
   if (std::isnan(start_time)) {
     time_offset =
         reversed ? EffectEnd() - CurrentTimeInternal() : CurrentTimeInternal();
     time_offset = time_offset / fabs(playback_rate_);
   }
@@ skipping 12 matching lines @@
   if (effect_changed && compositor_state_) {
     compositor_state_->effect_changed = true;
   }
   if (compositor_pending_ || is_paused_for_testing_) {
     return;
   }
   if (!compositor_state_ || compositor_state_->effect_changed ||
       compositor_state_->playback_rate != playback_rate_ ||
       compositor_state_->start_time != start_time_) {
     compositor_pending_ = true;
-    timeline()->GetDocument()->GetCompositorPendingAnimations().Add(this);
+    TimelineInternal()->GetDocument()->GetCompositorPendingAnimations().Add(
+        this);
   }
 }
 
 void Animation::CancelAnimationOnCompositor() {
   if (HasActiveAnimationsOnCompositor())
     ToKeyframeEffectReadOnly(content_.Get())->CancelAnimationOnCompositor();
 
   DestroyCompositorPlayer();
 }
 
@@ skipping 35 matching lines @@
       inherited_time = -1;
     content_->UpdateInheritedTime(inherited_time, reason);
   }
 
   if ((idle || Limited()) && !finished_) {
     if (reason == kTimingUpdateForAnimationFrame && (idle || HasStartTime())) {
       if (idle) {
         const AtomicString& event_type = EventTypeNames::cancel;
         if (GetExecutionContext() && HasEventListeners(event_type)) {
           double event_current_time = NullValue();
-          pending_cancelled_event_ = AnimationPlaybackEvent::Create(
-              event_type, event_current_time, timeline()->currentTime());
+          pending_cancelled_event_ =
+              AnimationPlaybackEvent::Create(event_type, event_current_time,
+                                             TimelineInternal()->currentTime());
           pending_cancelled_event_->SetTarget(this);
           pending_cancelled_event_->SetCurrentTarget(this);
           timeline_->GetDocument()->EnqueueAnimationFrameEvent(
               pending_cancelled_event_);
         }
       } else {
         const AtomicString& event_type = EventTypeNames::finish;
         if (GetExecutionContext() && HasEventListeners(event_type)) {
           double event_current_time = CurrentTimeInternal() * 1000;
-          pending_finished_event_ = AnimationPlaybackEvent::Create(
-              event_type, event_current_time, timeline()->currentTime());
+          pending_finished_event_ =
+              AnimationPlaybackEvent::Create(event_type, event_current_time,
+                                             TimelineInternal()->currentTime());
           pending_finished_event_->SetTarget(this);
           pending_finished_event_->SetCurrentTarget(this);
           timeline_->GetDocument()->EnqueueAnimationFrameEvent(
               pending_finished_event_);
         }
       }
       finished_ = true;
     }
   }
   DCHECK(!outdated_);
@@ skipping 91 matching lines @@
 
   ToKeyframeEffectReadOnly(content_.Get())->AttachCompositedLayers();
 }
 
 void Animation::DetachCompositedLayers() {
   if (compositor_player_ && compositor_player_->Player()->IsElementAttached())
     compositor_player_->Player()->DetachElement();
 }
 
 void Animation::NotifyAnimationStarted(double monotonic_time, int group) {
-  timeline()
+  TimelineInternal()
       ->GetDocument()
       ->GetCompositorPendingAnimations()
       .NotifyCompositorAnimationStarted(monotonic_time, group);
 }
 
 Animation::PlayStateUpdateScope::PlayStateUpdateScope(
     Animation& animation,
     TimingUpdateReason reason,
     CompositorPendingChange compositor_pending_change)
     : animation_(animation),
@@ skipping 83 matching lines @@
       break;
     case kDoNotSetCompositorPending:
       break;
     default:
       NOTREACHED();
       break;
   }
   animation_->EndUpdatingState();
 
   if (old_play_state != new_play_state) {
-    probe::animationPlayStateChanged(animation_->timeline()->GetDocument(),
-                                     animation_, old_play_state,
-                                     new_play_state);
+    probe::animationPlayStateChanged(
+        animation_->TimelineInternal()->GetDocument(), animation_,
+        old_play_state, new_play_state);
   }
 }
 
 void Animation::AddedEventListener(
     const AtomicString& event_type,
     RegisteredEventListener& registered_listener) {
   EventTargetWithInlineData::AddedEventListener(event_type,
                                                 registered_listener);
   if (event_type == EventTypeNames::finish)
     UseCounter::Count(GetExecutionContext(), WebFeature::kAnimationFinishEvent);
@@ skipping 90 matching lines @@
   DCHECK(!compositor_player_);
 }
 
 void Animation::CompositorAnimationPlayerHolder::Detach() {
   DCHECK(compositor_player_);
   compositor_player_->SetAnimationDelegate(nullptr);
   animation_ = nullptr;
   compositor_player_.reset();
 }
 }  // namespace blink