Implement asynchronous mutation of animation worklets.

* Adds MutateAynchronously method to the mutator dispatcher.
* Adds tests for ansynchronous mutation.
* Stubs in API for notification of mutation state (pending/complete).

Note async mutations are not used outside of testing with the patch pending completion of the notification plumbing in a separate CL.

Bug: 791280
Change-Id: I91545306c71899945f797a641831257247849b86
Reviewed-on: https://chromium-review.googlesource.com/c/1409600Reviewed-by: Robert Flack <flackr@chromium.org>
Reviewed-by: Majid Valipour <majidvp@chromium.org>
Commit-Queue: Kevin Ellis <kevers@chromium.org>
Cr-Commit-Position: refs/heads/master@{#625199}

third_party/blink/renderer/core/animation/worklet_animation_controller.cc

@@ -139,7 +139,8 @@ void WorkletAnimationController::MutateAnimations() {
   if (!main_thread_mutator_client_)
     return;
 
-  main_thread_mutator_client_->Mutator()->Mutate(CollectAnimationStates());
+  main_thread_mutator_client_->Mutator()->MutateSynchronously(
+      CollectAnimationStates());
 }
 
 std::unique_ptr<AnimationWorkletDispatcherInput>

third_party/blink/renderer/core/animation/worklet_animation_controller.h

@@ -58,6 +58,8 @@ class CORE_EXPORT WorkletAnimationController
 
   void SetMutationUpdate(
       std::unique_ptr<AnimationWorkletOutput> output) override;
+  void NotifyAnimationsPending() override {}
+  void NotifyAnimationsReady() override {}
 
   void SynchronizeAnimatorName(const String& animator_name) override;
   // Returns true if the animator with given name is registered in

third_party/blink/renderer/platform/graphics/animation_worklet_mutator_dispatcher.h

@@ -15,7 +15,11 @@ class PLATFORM_EXPORT AnimationWorkletMutatorDispatcher {
   virtual ~AnimationWorkletMutatorDispatcher() = default;
 
   // Run the animation frame callbacks from all connected AnimationWorklets.
-  virtual void Mutate(std::unique_ptr<AnimationWorkletDispatcherInput>) = 0;
+  virtual void MutateSynchronously(
+      std::unique_ptr<AnimationWorkletDispatcherInput>) = 0;
+  virtual void MutateAsynchronously(
+      std::unique_ptr<AnimationWorkletDispatcherInput>) = 0;
+
   // Returns true if Mutate may do something if called 'now'.
   virtual bool HasMutators() = 0;
 };

third_party/blink/renderer/platform/graphics/animation_worklet_mutator_dispatcher_impl.cc

@@ -19,6 +19,15 @@
 
 namespace blink {
 
+namespace {
+
+int next_async_mutation_id = 0;
+int GetNextAsyncMutationId() {
+  return next_async_mutation_id++;
+}
+
+}  // end namespace
+
 // Wrap output vector in a thread safe and ref-counted object since it is
 // accessed from animation worklet threads and its lifetime must be guaranteed
 // to outlive the mutation update cycle.
@@ -84,13 +93,14 @@ AnimationWorkletMutatorDispatcherImpl::CreateMainThreadClient(
   return CreateClient<MainThreadMutatorClient>(weak_interface, queue, true);
 }
 
-void AnimationWorkletMutatorDispatcherImpl::Mutate(
+void AnimationWorkletMutatorDispatcherImpl::MutateSynchronously(
     std::unique_ptr<AnimationWorkletDispatcherInput> mutator_input) {
   TRACE_EVENT0("cc", "AnimationWorkletMutatorDispatcherImpl::mutate");
   if (mutator_map_.IsEmpty() || !mutator_input)
     return;
   base::ElapsedTimer timer;
   DCHECK(client_);
+  DCHECK(host_queue_->BelongsToCurrentThread());
   DCHECK(mutator_input_map_.IsEmpty());
   DCHECK(outputs_->get().IsEmpty());
 
@@ -104,15 +114,7 @@ void AnimationWorkletMutatorDispatcherImpl::Mutate(
   RequestMutations(std::move(on_done));
   event.Wait();
 
-  for (auto& output : outputs_->get()) {
-    // Animator that has no input does not produce any output.
-    if (!output)
-      continue;
-    client_->SetMutationUpdate(std::move(output));
-  }
-
-  mutator_input_map_.clear();
-  outputs_->get().clear();
+  ApplyMutationsOnHostThread();
 
   UMA_HISTOGRAM_CUSTOM_MICROSECONDS_TIMES(
       "Animation.AnimationWorklet.Dispatcher.SynchronousMutateDuration",
@@ -120,6 +122,58 @@ void AnimationWorkletMutatorDispatcherImpl::Mutate(
       base::TimeDelta::FromMilliseconds(100), 50);
 }
 
+void AnimationWorkletMutatorDispatcherImpl::MutateAsynchronously(
+    std::unique_ptr<AnimationWorkletDispatcherInput> mutator_input) {
+  if (mutator_map_.IsEmpty() || !mutator_input)
+    return;
+  DCHECK(client_);
+  DCHECK(host_queue_->BelongsToCurrentThread());
+  if (!mutator_input_map_.IsEmpty()) {
+    // Still running mutations from a previous frame. Skip this frame to avoid
+    // lagging behind.
+    // TODO(kevers): Consider queuing pending mutation cycle. A pending tree
+    // mutation should likely be queued an active tree mutation cycle is still
+    // running.
+    return;
+  }
+
+  mutator_input_map_ = CreateInputMap(*mutator_input);
+  if (mutator_input_map_.IsEmpty())
+    return;
+
+  int next_async_mutation_id = GetNextAsyncMutationId();
+  TRACE_EVENT_ASYNC_BEGIN0("cc",
+                           "AnimationWorkletMutatorDispatcherImpl::MutateAsync",
+                           next_async_mutation_id);
+
+  WTF::CrossThreadClosure on_done = CrossThreadBind(
+      [](scoped_refptr<base::SingleThreadTaskRunner> host_queue,
+         base::WeakPtr<AnimationWorkletMutatorDispatcherImpl> dispatcher,
+         int next_async_mutation_id) {
+        PostCrossThreadTask(
+            *host_queue, FROM_HERE,
+            CrossThreadBind(
+                &AnimationWorkletMutatorDispatcherImpl::AsyncMutationsDone,
+                dispatcher, next_async_mutation_id));
+      },
+      host_queue_, weak_factory_.GetWeakPtr(), next_async_mutation_id);
+
+  client_->NotifyAnimationsPending();
+  RequestMutations(std::move(on_done));
+}
+
+void AnimationWorkletMutatorDispatcherImpl::AsyncMutationsDone(
+    int async_mutation_id) {
+  DCHECK(client_);
+  DCHECK(host_queue_->BelongsToCurrentThread());
+  ApplyMutationsOnHostThread();
+  client_->NotifyAnimationsReady();
+  TRACE_EVENT_ASYNC_END0("cc",
+                         "AnimationWorkletMutatorDispatcherImpl::MutateAsync",
+                         async_mutation_id);
+  // TODO(kevers): Add UMA metric to track the asynchronous mutate duration.
+}
+
 void AnimationWorkletMutatorDispatcherImpl::RegisterAnimationWorkletMutator(
     CrossThreadPersistent<AnimationWorkletMutator> mutator,
     scoped_refptr<base::SingleThreadTaskRunner> mutator_runner) {
@@ -171,6 +225,7 @@ AnimationWorkletMutatorDispatcherImpl::CreateInputMap(
 
 void AnimationWorkletMutatorDispatcherImpl::RequestMutations(
     WTF::CrossThreadClosure done_callback) {
+  DCHECK(client_);
   DCHECK(outputs_->get().IsEmpty());
 
   int num_requests = mutator_map_.size();
@@ -214,4 +269,15 @@ void AnimationWorkletMutatorDispatcherImpl::RequestMutations(
   }
 }
 
+void AnimationWorkletMutatorDispatcherImpl::ApplyMutationsOnHostThread() {
+  DCHECK(client_);
+  DCHECK(host_queue_->BelongsToCurrentThread());
+  for (auto& output : outputs_->get()) {
+    if (output)
+      client_->SetMutationUpdate(std::move(output));
+  }
+  mutator_input_map_.clear();
+  outputs_->get().clear();
+}
+
 }  // namespace blink

third_party/blink/renderer/platform/graphics/animation_worklet_mutator_dispatcher_impl.h

@@ -48,7 +48,12 @@ class PLATFORM_EXPORT AnimationWorkletMutatorDispatcherImpl final
   ~AnimationWorkletMutatorDispatcherImpl() override;
 
   // AnimationWorkletMutatorDispatcher implementation.
-  void Mutate(std::unique_ptr<AnimationWorkletDispatcherInput>) override;
+  void MutateSynchronously(
+      std::unique_ptr<AnimationWorkletDispatcherInput>) override;
+
+  void MutateAsynchronously(
+      std::unique_ptr<AnimationWorkletDispatcherInput>) override;
+
   // TODO(majidvp): Remove when timeline inputs are known.
   bool HasMutators() override;
 
@@ -65,6 +70,8 @@ class PLATFORM_EXPORT AnimationWorkletMutatorDispatcherImpl final
 
   void SynchronizeAnimatorName(const String& animator_name);
 
+  MutatorClient* client() { return client_; }
+
  private:
   class OutputVectorRef;
 
@@ -81,6 +88,10 @@ class PLATFORM_EXPORT AnimationWorkletMutatorDispatcherImpl final
   // associated with the last mutation to complete.
   void RequestMutations(WTF::CrossThreadClosure done_callback);
 
+  void AsyncMutationsDone(int async_mutation_id);
+
+  void ApplyMutationsOnHostThread();
+
   // The AnimationWorkletProxyClients are also owned by the WorkerClients
   // dictionary.
   AnimationWorkletMutatorToTaskRunnerMap mutator_map_;

third_party/blink/renderer/platform/graphics/compositor_mutator_client.cc

@@ -26,7 +26,9 @@ CompositorMutatorClient::~CompositorMutatorClient() {
 void CompositorMutatorClient::Mutate(
     std::unique_ptr<cc::MutatorInputState> input_state) {
   TRACE_EVENT0("cc", "CompositorMutatorClient::Mutate");
-  mutator_->Mutate(std::move(input_state));
+  // TODO(http://crbug.com/791280): Switch to asynchronous once plumbing is
+  // complete.
+  mutator_->MutateSynchronously(std::move(input_state));
 }
 
 void CompositorMutatorClient::SetMutationUpdate(

third_party/blink/renderer/platform/graphics/compositor_mutator_client.h

@@ -23,6 +23,9 @@ class PLATFORM_EXPORT CompositorMutatorClient : public cc::LayerTreeMutator,
 
   void SynchronizeAnimatorName(const String& animator_name) override {}
   void SetMutationUpdate(std::unique_ptr<cc::MutatorOutputState>) override;
+  // TODO(http://crbug.com/791280): Plumb notifications through to cc scheduler.
+  void NotifyAnimationsPending() override {}
+  void NotifyAnimationsReady() override {}
 
   // cc::LayerTreeMutator
   void SetClient(cc::LayerTreeMutatorClient*) override;

third_party/blink/renderer/platform/graphics/main_thread_mutator_client.h

@@ -22,6 +22,8 @@ class PLATFORM_EXPORT MainThreadMutatorClient : public MutatorClient {
 
   void SynchronizeAnimatorName(const String& animator_name) override;
   void SetMutationUpdate(std::unique_ptr<AnimationWorkletOutput>) override;
+  void NotifyAnimationsPending() override {}
+  void NotifyAnimationsReady() override {}
   void SetDelegate(MutatorClient* client);
   AnimationWorkletMutatorDispatcherImpl* Mutator() { return mutator_.get(); }
 

third_party/blink/renderer/platform/graphics/mutator_client.h

@@ -17,6 +17,10 @@ class PLATFORM_EXPORT MutatorClient {
 
   virtual void SynchronizeAnimatorName(const String& animator_name) = 0;
   virtual void SetMutationUpdate(std::unique_ptr<AnimationWorkletOutput>) = 0;
+
+  virtual void NotifyAnimationsPending() = 0;
+
+  virtual void NotifyAnimationsReady() = 0;
 };
 
 }  // namespace blink