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.

[flackr, 2017/06/07 17:21:33]

What do you mean by Document? This should maybe check that all of the effects
have the same document, right?

[smcgruer, 2017/06/07 18:23:25]

It was a reminder to myself to document this code, mostly leftover from when we
did more here. Irrelevant in new PS anyway.`

+  Document& document = effects.at(0)->Target()->GetDocument();
+  AnimationTimeline& main_document_timeline = document.Timeline();

[majidvp, 2017/06/06 16:04:28]

nit: s/main_document_timeline/document_timeline/. I don't see why it needs to be
prefixed with "main".

[smcgruer, 2017/06/07 18:23:25]

Done.

+
+  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) {
+  DCHECK(Platform::Current()->IsThreadedAnimationEnabled());
+  DCHECK(Platform::Current()->CompositorSupport());
+  compositor_player_ = CompositorAnimationPlayerHolder::Create(this);
+  DCHECK(compositor_player_);
+}
+
+void WorkletAnimation::Update() {
+  if (!on_compositor_) {

[majidvp, 2017/06/06 16:04:27]

The current logic keeps trying to start the animation on compositor even if it
fails every time.
The main problem IMHO is that it fails silently to start animations without any
indication to
the user.


I suggest the following:
A) Rather than trying again, we should just fail and report an error
   with a TODO to support falling back to running on main thread.

B) Check if the pre-conditions are met for the animation to run on compositor:
  1) Check if effect targets are composited e.g.,
CompositorAnimations::CanStartAnimationOnCompositor
  2) Check if the effects are eligible e.g.,
CompositorAnimations::IsCandidateForAnimationOnCompositor

I dont think you need to have (B) for this patch at this point but having (A)
will be 
a nice addition.

[smcgruer, 2017/06/07 18:23:25]

Any thoughts on how to actually report an error from here? 

+    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(

[flackr, 2017/06/07 17:21:33]

Why do we just start the first effect? Does that start the whole animation? If
so, please document.

[smcgruer, 2017/06/07 18:23:25]

Well the CL doesn't really *do* anything currently, so this is mostly testing
code. It does end up making it to CompositorAnimationPlayer::AddAnimation, but
not much beyond. As far as I understand, we're going to be introducing
WorkletAnimationPlayer or similar anyway which will replace that class, so it
didn't seem useful to get it moving further.

+        group, start_time, current_time, animation_playback_rate,
+        compositor_player_->Player());
+  }
+}
+
+void WorkletAnimation::AttachCompositorTimeline() {
+  if (compositor_player_) {

[majidvp, 2017/06/06 16:04:28]

I agree with flackr@ that we should for now assume that we always
create the compositor_player_.
Even if you decide otherwise, I suggest turning these checks into
early exists e.g.,

if (!compositor_player_)
  return;

[flackr, 2017/06/07 17:21:33]

I would suggest just removing them. When we add main thread support maybe we
won't call AttachCompositorTimeline if we're not composited?

[smcgruer, 2017/06/07 18:23:25]

Done.

+    CompositorAnimationTimeline* timeline =
+        main_document_timeline_ ? main_document_timeline_->CompositorTimeline()
+                                : nullptr;
+    if (timeline)

[flackr, 2017/06/07 17:21:32]

It looks like this should always be set as long as threaded animations are
enabled.

[smcgruer, 2017/06/07 18:23:25]

Done.

+      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