Initial implementation of WorkletAnimation

third_party/WebKit/Source/modules/compositorworker/WorkletAnimation.cpp

+// Copyright 2017 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 "modules/compositorworker/WorkletAnimation.h"
+
+#include "core/animation/DocumentTimeline.h"
+#include "core/animation/ElementAnimations.h"
+#include "core/animation/KeyframeEffectModel.h"
+#include "core/animation/ScrollTimeline.h"
+#include "core/animation/Timing.h"
+#include "core/dom/Node.h"
+#include "core/dom/NodeComputedStyle.h"
+#include "platform/animation/CompositorAnimationPlayer.h"
+#include "platform/wtf/text/WTFString.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebCompositorSupport.h"
+
+namespace blink {
+
+namespace {
+bool ValidateEffects(const HeapVector<Member<KeyframeEffectReadOnly>>& effects,
+                     String* error_string) {
+  if (effects.IsEmpty()) {
+    *error_string = "Effects array must be non-empty";
+    return false;
+  }
+
+  Document& target_document = effects.at(0)->Target()->GetDocument();
+  for (const auto& effect : effects) {
+    if (effect->Target()->GetDocument() != target_document) {
+      *error_string = "All effects must target elements in the same document";
+      return false;
+    }
+  }
+  return true;
+}
+
+bool ValidateTimelines(HeapVector<DocumentTimelineOrScrollTimeline>& timelines,
+                       String* error_string) {
+  if (timelines.IsEmpty()) {
+    *error_string = "Timelines array must be non-empty";
+    return false;
+  }
+
+  for (const auto& timeline : timelines) {
+    if (timeline.isScrollTimeline()) {
+      DoubleOrScrollTimelineAutoKeyword time_range;
+      timeline.getAsScrollTimeline()->timeRange(time_range);
+      if (time_range.isScrollTimelineAutoKeyword()) {
+        *error_string = "ScrollTimeline timeRange must have non-auto value";
+        return false;
+      }
+    }
+  }
+  return true;
+}
+}  // namespace
+
+WorkletAnimation* WorkletAnimation::Create(
+    String animator_name,
+    const HeapVector<Member<KeyframeEffectReadOnly>>& effects,
+    HeapVector<DocumentTimelineOrScrollTimeline>& timelines,
+    RefPtr<SerializedScriptValue> user_data,
+    ExceptionState& exception_state) {
+  String error_string;
+  if (!ValidateEffects(effects, &error_string)) {
+    exception_state.ThrowDOMException(kNotSupportedError, error_string);
+    return nullptr;
+  }
+
+  if (!ValidateTimelines(timelines, &error_string)) {
+    exception_state.ThrowDOMException(kNotSupportedError, error_string);
+    return nullptr;
+  }
+
+  // TODO(smcgruer): Document.
+  Document& document = effects.at(0)->Target()->GetDocument();
+  AnimationTimeline& main_document_timeline = document.Timeline();
+
+  WorkletAnimation* animation =
+      new WorkletAnimation(animator_name, effects, timelines,
+                           std::move(user_data), main_document_timeline);
+
+  document.RegisterWorkletAnimation(animation);
+  // TODO(smcgruer): Set needs compositing update?
+  animation->AttachCompositorTimeline();
+
+  return animation;
+}
+
+WorkletAnimation::WorkletAnimation(
+    String animator_name,
+    const HeapVector<Member<KeyframeEffectReadOnly>>& effects,
+    HeapVector<DocumentTimelineOrScrollTimeline>& timelines,
+    RefPtr<SerializedScriptValue> user_data,
+    AnimationTimeline& main_document_timeline)
+    : animator_name_(animator_name),
+      effects_(effects),
+      timelines_(timelines),
+      user_data_(std::move(user_data)),
+      main_document_timeline_(main_document_timeline),
+      on_compositor_(false) {
+  if (Platform::Current()->IsThreadedAnimationEnabled() &&

[flackr, 2017/06/05 19:08:39]

Eventually we'd have to support running without threaded animation right? But
for now I think it would be simpler to assume threaded animation is enabled
(i.e. assert it and/or throw an error if we don't have it enabled), and then we
don't need to have all of these nullptr checks right?

[smcgruer, 2017/06/06 13:22:11]

Sure, done. I vaguely wonder why we even have --disable-threaded-animation, but
*shrug*.

+      !compositor_player_) {
+    DCHECK(Platform::Current()->CompositorSupport());
+    compositor_player_ = CompositorAnimationPlayerHolder::Create(this);
+    DCHECK(compositor_player_);
+  }
+}
+
+void WorkletAnimation::Update() {
+  if (!on_compositor_) {
+    int group = 0;  // We don't know.
+    double start_time = 0;
+    double current_time = 0;
+    double animation_playback_rate = 1;
+    Element& target = *effects_.at(0)->Target();
+    static_cast<KeyframeEffectModelBase*>(effects_.at(0)->Model())
+        ->SnapshotAllCompositorKeyframes(target, target.ComputedStyleRef(),
+                                         target.ParentComputedStyle());
+    on_compositor_ = effects_.at(0)->MaybeStartAnimationOnCompositor(
+        group, start_time, current_time, animation_playback_rate,
+        compositor_player_->Player());
+  }
+}
+
+void WorkletAnimation::AttachCompositorTimeline() {
+  if (compositor_player_) {
+    CompositorAnimationTimeline* timeline =
+        main_document_timeline_ ? main_document_timeline_->CompositorTimeline()
+                                : nullptr;
+    if (timeline)
+      timeline->PlayerAttached(*this);
+  }
+}
+
+void WorkletAnimation::DetachCompositorTimeline() {
+  if (compositor_player_) {
+    CompositorAnimationTimeline* timeline =
+        main_document_timeline_ ? main_document_timeline_->CompositorTimeline()
+                                : nullptr;
+    if (timeline)
+      timeline->PlayerDestroyed(*this);
+  }
+}
+
+void WorkletAnimation::Dispose() {
+  if (compositor_player_) {
+    DetachCompositorTimeline();
+    compositor_player_->Detach();
+    compositor_player_ = nullptr;
+  }
+}
+
+void WorkletAnimation::SetEffectInheritedTimeForTesting(
+    Member<KeyframeEffectReadOnly> effect,
+    double inherited_time) {}
+
+DEFINE_TRACE(WorkletAnimation) {
+  visitor->Trace(effects_);
+  visitor->Trace(timelines_);
+  visitor->Trace(main_document_timeline_);
+  visitor->Trace(compositor_player_);
+  WorkletAnimationBase::Trace(visitor);
+}
+
+WorkletAnimation::CompositorAnimationPlayerHolder*
+WorkletAnimation::CompositorAnimationPlayerHolder::Create(
+    WorkletAnimation* animation) {
+  return new CompositorAnimationPlayerHolder(animation);
+}
+
+WorkletAnimation::CompositorAnimationPlayerHolder::
+    CompositorAnimationPlayerHolder(WorkletAnimation* animation)
+    : animation_(animation) {
+  compositor_player_ = CompositorAnimationPlayer::Create();
+  compositor_player_->SetAnimationDelegate(animation_);
+}
+
+void WorkletAnimation::CompositorAnimationPlayerHolder::Dispose() {
+  if (!animation_)
+    return;
+  animation_->Dispose();
+  DCHECK(!animation_);
+  DCHECK(!compositor_player_);
+}
+
+void WorkletAnimation::CompositorAnimationPlayerHolder::Detach() {
+  compositor_player_->SetAnimationDelegate(nullptr);
+  animation_ = nullptr;
+  compositor_player_.reset();
+}
+
+}  // namespace blink