Introduce AnimationWorkletProxyClient and necessary plumbing to get it in worklet messaging proxy.

third_party/WebKit/Source/web/CompositorMutatorImpl.cpp

 // Copyright 2016 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 "web/CompositorMutatorImpl.h"
 
 #include "core/animation/CustomCompositorAnimationManager.h"
 #include "core/dom/CompositorProxy.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/WaitableEvent.h"
 #include "platform/graphics/CompositorMutationsTarget.h"
 #include "platform/graphics/CompositorMutatorClient.h"
 #include "platform/heap/Handle.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "public/platform/Platform.h"
-#include "web/CompositorProxyClientImpl.h"
+#include "web/CompositorAnimator.h"
 #include "wtf/PtrUtil.h"
 
 namespace blink {
 
 namespace {
 
 void createCompositorMutatorClient(
     std::unique_ptr<CompositorMutatorClient>* ptr,
     WaitableEvent* doneEvent) {
   CompositorMutatorImpl* mutator = CompositorMutatorImpl::create();
@@ skipping 13 matching lines @@
   WaitableEvent doneEvent;
   if (WebThread* compositorThread = Platform::current()->compositorThread()) {
     compositorThread->getWebTaskRunner()->postTask(
         BLINK_FROM_HERE, crossThreadBind(&createCompositorMutatorClient,
                                          crossThreadUnretained(&mutatorClient),
                                          crossThreadUnretained(&doneEvent)));
   } else {
     createCompositorMutatorClient(&mutatorClient, &doneEvent);
   }
   // TODO(flackr): Instead of waiting for this event, we may be able to just set
-  // the mutator on the CompositorProxyClient directly from the compositor
+  // the mutator on the CompositorWorkerProxyClient directly from the compositor
   // thread before it gets used there. We still need to make sure we only
   // create one mutator though.
   doneEvent.wait();
   return mutatorClient;
 }
 
 CompositorMutatorImpl* CompositorMutatorImpl::create() {
   return new CompositorMutatorImpl();
 }
 
 bool CompositorMutatorImpl::mutate(
     double monotonicTimeNow,
     CompositorMutableStateProvider* stateProvider) {
   TRACE_EVENT0("compositor-worker", "CompositorMutatorImpl::mutate");
   bool needToReinvoke = false;
   // TODO(vollick): we should avoid executing the animation frame
   // callbacks if none of the proxies in the global scope are affected by
   // m_mutations.
-  for (CompositorProxyClientImpl* client : m_proxyClients) {
-    if (client->mutate(monotonicTimeNow, stateProvider))
+  for (CompositorAnimator* animator : m_animators) {
+    if (animator->mutate(monotonicTimeNow, stateProvider))
       needToReinvoke = true;
   }
 
   return needToReinvoke;
 }
 
-void CompositorMutatorImpl::registerProxyClient(
-    CompositorProxyClientImpl* client) {
-  TRACE_EVENT0("compositor-worker", "CompositorMutatorImpl::registerClient");
-  DCHECK(!m_proxyClients.contains(client));
-  m_proxyClients.insert(client);
+void CompositorMutatorImpl::registerCompositorAnimator(
+    CompositorAnimator* animator) {
+  TRACE_EVENT0("compositor-worker",
+               "CompositorMutatorImpl::registerCompositorAnimator");
+  DCHECK(!m_animators.contains(animator));
+  m_animators.add(animator);
   setNeedsMutate();
 }
 
-void CompositorMutatorImpl::unregisterProxyClient(
-    CompositorProxyClientImpl* client) {
-  DCHECK(m_proxyClients.contains(client));
-  m_proxyClients.remove(client);
+void CompositorMutatorImpl::unregisterCompositorAnimator(
+    CompositorAnimator* animator) {
+  DCHECK(m_animators.contains(animator));
+  m_animators.remove(animator);
 }
 
 void CompositorMutatorImpl::setNeedsMutate() {
   TRACE_EVENT0("compositor-worker", "CompositorMutatorImpl::setNeedsMutate");
   m_client->setNeedsMutate();
 }
 
 }  // namespace blink