compositor-worker: Add CompositorProxyClient worker client of CompositorWorker.

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

 // Copyright 2015 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/CompositorWorkerGlobalScope.h"
 
 #include "bindings/core/v8/SerializedScriptValue.h"
 #include "core/workers/InProcessWorkerObjectProxy.h"
 #include "core/workers/WorkerThreadStartupData.h"
 #include "modules/EventTargetModules.h"
 #include "modules/compositorworker/CompositorWorkerThread.h"
 
 namespace blink {
 
 CompositorWorkerGlobalScope* CompositorWorkerGlobalScope::create(CompositorWorkerThread* thread, PassOwnPtr<WorkerThreadStartupData> startupData, double timeOrigin)
 {
     // Note: startupData is finalized on return. After the relevant parts has been
     // passed along to the created 'context'.
     CompositorWorkerGlobalScope* context = new CompositorWorkerGlobalScope(startupData->m_scriptURL, startupData->m_userAgent, thread, timeOrigin, startupData->m_starterOriginPrivilegeData.release(), startupData->m_workerClients.release());
     context->applyContentSecurityPolicyFromVector(*startupData->m_contentSecurityPolicyHeaders);
     context->setAddressSpace(startupData->m_addressSpace);
     return context;
 }
 
 CompositorWorkerGlobalScope::CompositorWorkerGlobalScope(const KURL& url, const String& userAgent, CompositorWorkerThread* thread, double timeOrigin, PassOwnPtr<SecurityOrigin::PrivilegeData> starterOriginPrivilegeData, WorkerClients* workerClients)
     : WorkerGlobalScope(url, userAgent, thread, timeOrigin, std::move(starterOriginPrivilegeData), workerClients)
+    , m_executingAnimationFrameCallbacks(false)
     , m_callbackCollection(this)
 {
+    CompositorProxyClient::from(clients())->setGlobalScope(this);
 }
 
 CompositorWorkerGlobalScope::~CompositorWorkerGlobalScope()
 {
 }
 
 DEFINE_TRACE(CompositorWorkerGlobalScope)
 {
     visitor->trace(m_callbackCollection);
     WorkerGlobalScope::trace(visitor);
 }
 
 const AtomicString& CompositorWorkerGlobalScope::interfaceName() const
 {
     return EventTargetNames::CompositorWorkerGlobalScope;
 }
 
 void CompositorWorkerGlobalScope::postMessage(ExecutionContext* executionContext, PassRefPtr<SerializedScriptValue> message, const MessagePortArray& ports, ExceptionState& exceptionState)
 {
     // Disentangle the port in preparation for sending it to the remote context.
     OwnPtr<MessagePortChannelArray> channels = MessagePort::disentanglePorts(executionContext, ports, exceptionState);
     if (exceptionState.hadException())
         return;
     thread()->workerObjectProxy().postMessageToWorkerObject(message, channels.release());
 }
 
 int CompositorWorkerGlobalScope::requestAnimationFrame(FrameRequestCallback* callback)
 {
+    // For now, just post a task to call mutate on the compositor proxy client.

[jbroman, 2016/05/09 18:44:18]

Please leave a more strongly-worded TODO here so it's obvious this is a super
temporary measure. Something like:

// TODO(flackr): Remove this when ____________________.

[flackr, 2016/05/10 20:56:13]

Done.

+    thread()->postTask(BLINK_FROM_HERE, createSameThreadTask(&CompositorProxyClient::triggerMutationForTest,

[kinuko, 2016/05/09 02:41:26]

invoking test-only method from web-facing API and having all these code in
production code looks weird to me...

[flackr, 2016/05/10 20:56:13]

You're right, let's just remove the ForTest and call this something more
meaningful. This is our workaround for being able to test this path when we're
not able to actually request frames from the compositor. Done.

+        CompositorProxyClient::from(clients())));
+    // TODO(flackr): Signal the compositor to call mutate on the next compositor frame.
     return m_callbackCollection.registerCallback(callback);
 }
 
 void CompositorWorkerGlobalScope::cancelAnimationFrame(int id)
 {
     m_callbackCollection.cancelCallback(id);
 }
 
-void CompositorWorkerGlobalScope::executeAnimationFrameCallbacks(double highResTimeNow)
+bool CompositorWorkerGlobalScope::executeAnimationFrameCallbacks(double highResTimeMs)
 {
-    m_callbackCollection.executeCallbacks(highResTimeNow, highResTimeNow);
+    TemporaryChange<bool> temporaryChange(m_executingAnimationFrameCallbacks, true);
+    m_callbackCollection.executeCallbacks(highResTimeMs, highResTimeMs);
+    return !m_callbackCollection.isEmpty();
 }
 
 CompositorWorkerThread* CompositorWorkerGlobalScope::thread() const
 {
     return static_cast<CompositorWorkerThread*>(WorkerGlobalScope::thread());
 }
 
 } // namespace blink