[compositorworker] compositor proxy mutation updates underlying layers

third_party/WebKit/Source/web/CompositorProxyClientImpl.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 "web/CompositorProxyClientImpl.h"
 
 #include "core/dom/CompositorProxy.h"
 #include "modules/compositorworker/CompositorWorkerGlobalScope.h"
 #include "platform/TraceEvent.h"
+#include "platform/graphics/CompositorMutableStateProvider.h"
 #include "web/CompositorMutatorImpl.h"
 #include "wtf/CurrentTime.h"
 
 namespace blink {
 
 CompositorProxyClientImpl::CompositorProxyClientImpl(CompositorMutatorImpl* mutator)
     : m_mutator(mutator)
     , m_globalScope(nullptr)
 {
 }
@@ skipping 15 matching lines @@
     m_mutator->registerProxyClient(this);
 }
 
 void CompositorProxyClientImpl::requestAnimationFrame()
 {
     TRACE_EVENT0("compositor-worker", "CompositorProxyClientImpl::requestAnimationFrame");
     m_requestedAnimationFrameCallbacks = true;
     m_mutator->setNeedsMutate();
 }
 
-bool CompositorProxyClientImpl::mutate(double monotonicTimeNow)
+bool CompositorProxyClientImpl::mutate(double monotonicTimeNow, CompositorMutableStateProvider* stateProvider)
 {
     if (!m_globalScope)
         return false;
 
     TRACE_EVENT0("compositor-worker", "CompositorProxyClientImpl::mutate");
     if (!m_requestedAnimationFrameCallbacks)
         return false;
 
+    // Update proxies mutable state for this frame and reset it after rAF
+    // callback as no mutation is allowed outside rAF.
+    updateMutableStateForCompositorProxies(stateProvider);
     m_requestedAnimationFrameCallbacks = executeAnimationFrameCallbacks(monotonicTimeNow);
+    updateMutableStateForCompositorProxies(nullptr);
 
     return m_requestedAnimationFrameCallbacks;
 }
 
 bool CompositorProxyClientImpl::executeAnimationFrameCallbacks(double monotonicTimeNow)
 {
     TRACE_EVENT0("compositor-worker", "CompositorProxyClientImpl::executeAnimationFrameCallbacks");
+
     // Convert to zero based document time in milliseconds consistent with requestAnimationFrame.
     double highResTimeMs = 1000.0 * (monotonicTimeNow - m_globalScope->timeOrigin());
-    const bool shouldReinvoke = m_globalScope->executeAnimationFrameCallbacks(highResTimeMs);
-    return shouldReinvoke;
+    return m_globalScope->executeAnimationFrameCallbacks(highResTimeMs);
+}
+
+void CompositorProxyClientImpl::updateMutableStateForCompositorProxies(CompositorMutableStateProvider* stateProvider)
+{
+    for (CompositorProxy* proxy : m_proxies)
+        proxy->takeCompositorMutableState(stateProvider ? stateProvider->getMutableStateFor(proxy->elementId()) : nullptr);

[jbroman, 2016/06/15 08:55:50]

By the way, what happens if there are multiple CompositorWorkers with proxies to
the same element (or one worker with multiple proxies)? This _looks_ like one of
them will "win" (i.e. read the original values, and have its values take
effect). Is this intentional?

(Or am I guessing wrong what the behaviour will be? Is there a layout test for
this?)

[majidvp, 2016/06/15 15:46:53]

Yes this is the current design. It is similar to mutating the same
property in multiple rAF callback. The last callback mutation wins.

The only difference is that unlike regular rAF callbacks there is no
specified order among callbacks that belong to different workers. 

No layout test covering this but we should add one.

 }
 
 void CompositorProxyClientImpl::registerCompositorProxy(CompositorProxy* proxy)
 {
     m_proxies.add(proxy);
 }
 
 void CompositorProxyClientImpl::unregisterCompositorProxy(CompositorProxy* proxy)
 {
     m_proxies.remove(proxy);
 }
 
 } // namespace blink