compositor-worker: blink->cc plumbing

third_party/WebKit/Source/web/CompositorProxyClientImpl.cpp

Index: third_party/WebKit/Source/web/CompositorProxyClientImpl.cpp
diff --git a/third_party/WebKit/Source/web/CompositorProxyClientImpl.cpp b/third_party/WebKit/Source/web/CompositorProxyClientImpl.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..b44d4b6a391f5757a3fc5a16b2089eab83595374
--- /dev/null
+++ b/third_party/WebKit/Source/web/CompositorProxyClientImpl.cpp
@@ -0,0 +1,126 @@
+// 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 "web/CompositorProxyClientImpl.h"
+
+#include "core/dom/CompositorProxy.h"
+#include "modules/compositorworker/CompositorWorkerGlobalScope.h"
+#include "platform/TraceEvent.h"
+#include "platform/graphics/CompositorMutableState.h"
+#include "platform/graphics/CompositorMutableStateProvider.h"
+#include "web/CompositorMutatorImpl.h"
+
+namespace blink {
+
+CompositorProxyClientImpl::CompositorProxyClientImpl(CompositorMutatorImpl* mutator)
+    : m_mutator(mutator)
+    , m_globalScope(nullptr)
+    , m_executingAnimationFrameCallbacks(false)
+{
+}
+
+CompositorProxyClientImpl::~CompositorProxyClientImpl()
+{
+    m_mutator->unregisterClient(this);
+    for (auto& iter : m_proxies) {
+        for (CompositorProxy* proxy : iter.second)
+            proxy->clearClient();
+    }
+}
+
+void CompositorProxyClientImpl::registerCompositorProxy(CompositorProxy* proxy)
+{
+    uint64_t elementId = proxy->elementId();
+
+    TRACE_EVENT2("compositor-worker,compositor-proxy",
+        "CompositorProxyClientImpl::registerCompositorProxy",
+        "elementId", static_cast<int>(elementId),
+        "proxy", proxy);
+
+    if (!m_proxies.count(elementId)) {
+        m_proxies[elementId] = ProxyVector();
+    }
+    m_proxies[elementId].push_back(proxy);
+}
+
+void CompositorProxyClientImpl::unregisterCompositorProxy(CompositorProxy* proxy)
+{
+    uint64_t elementId = proxy->elementId();
+    if (!m_proxies.count(elementId))
+        return;
+
+    TRACE_EVENT2("compositor-worker,compositor-proxy",
+        "CompositorProxyClientImpl::unregisterCompositorProxy",
+        "elementId", static_cast<int>(elementId),
+        "proxy", proxy);
+
+    ProxyVector& proxies = m_proxies[elementId];
+    proxies.erase(std::find(proxies.begin(), proxies.end(), proxy));
+    if (proxies.size() == 0)
+        m_proxies.erase(elementId);
+}
+
+void CompositorProxyClientImpl::requestSync(CompositorProxy* proxy)
+{
+    TRACE_EVENT0("compositor-worker", "CompositorProxyClientImpl::requestSync");
+    ASSERT(m_executingAnimationFrameCallbacks);
+    m_requiresSync.add(proxy->elementId());
+}
+
+void CompositorProxyClientImpl::setGlobalScope(WorkerGlobalScope* scope)
+{
+    TRACE_EVENT0("compositor-worker", "CompositorProxyClientImpl::setGlobalScope");
+    m_globalScope = static_cast<CompositorWorkerGlobalScope*>(scope);
+    m_mutator->registerClient(this);
+}
+
+void CompositorProxyClientImpl::requestMutation()
+{
+    TRACE_EVENT0("compositor-worker", "CompositorProxyClientImpl::requestMutation");
+    m_requestedAnimationFrameCallbacks = true;
+    m_mutator->setNeedsMutate();
+}
+
+bool CompositorProxyClientImpl::mutate(double timeNow, CompositorMutableStateProvider* stateProvider)
+{
+    if (!m_globalScope)
+        return false;
+
+    TRACE_EVENT0("compositor-worker", "CompositorProxyClientImpl::mutate");
+    willStartCompositorFrameCallbacks(stateProvider);
+
+    if (!m_requestedAnimationFrameCallbacks)
+        return false;
+
+    m_requestedAnimationFrameCallbacks = false;
+    {
+        TemporaryChange<bool> temporary(m_executingAnimationFrameCallbacks, true);
+        m_requestedAnimationFrameCallbacks = executeAnimationFrameCallbacks(timeNow);
+    }
+
+    return m_requestedAnimationFrameCallbacks;
+}
+
+void CompositorProxyClientImpl::willStartCompositorFrameCallbacks(CompositorMutableStateProvider* stateProvider)
+{
+    TRACE_EVENT0("compositor-worker", "CompositorProxyClientImpl::willStartCompositorFrameCallbacks");
+    ASSERT(m_requiresSync.isEmpty());
+    for (auto iter : m_proxies) {
+        for (CompositorProxy* proxy : iter.second)
+            proxy->takeCompositorMutableState(stateProvider->getMutableStateFor(iter.first));
+    }
+}
+
+bool CompositorProxyClientImpl::executeAnimationFrameCallbacks(double time)
+{
+    TRACE_EVENT0("compositor-worker", "CompositorProxyClientImpl::executeAnimationFrameCallbacks");
+    const bool shouldReinvoke = m_globalScope->executeAnimationFrameCallbacks(time);
+    for (auto iter : m_proxies) {
+        for (CompositorProxy* proxy : iter.second)
+            proxy->takeCompositorMutableState(nullptr);
+    }
+    return shouldReinvoke;
+}
+
+} // namespace blink