[compositorworker] compositor proxy mutation updates underlying layers

third_party/WebKit/Source/core/dom/CompositorProxy.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 "core/dom/CompositorProxy.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/DOMNodeIds.h"
 #include "core/dom/ExceptionCode.h"
@@ skipping 160 matching lines @@
 {
     return m_compositorMutableProperties & compositorMutablePropertyForName(attributeName);
 }
 
 double CompositorProxy::opacity(ExceptionState& exceptionState) const
 {
     if (raiseExceptionIfMutationNotAllowed(exceptionState))
         return 0.0;
     if (raiseExceptionIfNotMutable(CompositorMutableProperty::kOpacity, exceptionState))
         return 0.0;
-    return m_opacity;
+    if (!m_state.get())

[jbroman, 2016/06/13 19:45:17]

Should these be returning zero? What does it mean for the proxy to be queried
when it has no state? Should an exception be thrown in this case instead? How
could clients distinguish missing state from something actually having zero
opacity, zero scroll offset, etc.?

[majidvp, 2016/06/13 21:52:51]

Not having a state is equivalent to the underlying layer not being present in
the tree. At the moment, any mutation of the proxy is a no-op as you see.

vollick@: do you have any preference on the failure mode when a proxy in not
initialized?

I believed, our past discussion lead to the conclusion that eventually we should
just hold onto those mutations even when disconnected and apply them once the
layer is activated. So I think not throwing is the right approach even though 
we don't do the correct thing here yet.

This means that modifying an uninitialized proxy is *not* illegal, only that 
those modifications will not be seen in the the composited result.

Or should we just throw until the correct behaviour is implemented?

[Ian Vollick, 2016/06/14 11:24:28]

There's no harm in throwing in the getter and I think we should probably do
that.

As for the setter, I would indeed like it to be legal to write while
disconnected, but I think that throwing until it works correctly is a good idea.

[majidvp, 2016/06/14 17:25:58]

Done.

+        return 0.0;
+    return m_state->opacity();
 }
 
 double CompositorProxy::scrollLeft(ExceptionState& exceptionState) const
 {
     if (raiseExceptionIfMutationNotAllowed(exceptionState))
         return 0.0;
     if (raiseExceptionIfNotMutable(CompositorMutableProperty::kScrollLeft, exceptionState))
         return 0.0;
-    return m_scrollLeft;
+    if (!m_state.get())
+        return 0.0;
+    return m_state->scrollLeft();
 }
 
 double CompositorProxy::scrollTop(ExceptionState& exceptionState) const
 {
     if (raiseExceptionIfMutationNotAllowed(exceptionState))
         return 0.0;
     if (raiseExceptionIfNotMutable(CompositorMutableProperty::kScrollTop, exceptionState))
         return 0.0;
-    return m_scrollTop;
+    if (!m_state.get())
+        return 0.0;
+    return m_state->scrollTop();
 }
 
 DOMMatrix* CompositorProxy::transform(ExceptionState& exceptionState) const
 {
     if (raiseExceptionIfMutationNotAllowed(exceptionState))
         return nullptr;
     if (raiseExceptionIfNotMutable(CompositorMutableProperty::kTransform, exceptionState))
         return nullptr;
-    return m_transform;
+    if (!m_state.get())
+        return DOMMatrix::create();
+    return DOMMatrix::create(m_state->transform());
 }
 
 void CompositorProxy::setOpacity(double opacity, ExceptionState& exceptionState)
 {
     if (raiseExceptionIfMutationNotAllowed(exceptionState))
         return;
     if (raiseExceptionIfNotMutable(CompositorMutableProperty::kOpacity, exceptionState))
         return;
-    m_opacity = std::min(1., std::max(0., opacity));
-    m_mutatedProperties |= CompositorMutableProperty::kTransform;
+    if (!m_state.get())
+        return;
+
+    m_state->setOpacity(std::min(1., std::max(0., opacity)));
 }
 
 void CompositorProxy::setScrollLeft(double scrollLeft, ExceptionState& exceptionState)
 {
     if (raiseExceptionIfMutationNotAllowed(exceptionState))
         return;
     if (raiseExceptionIfNotMutable(CompositorMutableProperty::kScrollLeft, exceptionState))
         return;
-    m_scrollLeft = scrollLeft;
-    m_mutatedProperties |= CompositorMutableProperty::kScrollLeft;
+    if (!m_state.get())
+        return;
+    m_state->setScrollLeft(scrollLeft);
 }
 
 void CompositorProxy::setScrollTop(double scrollTop, ExceptionState& exceptionState)
 {
     if (raiseExceptionIfMutationNotAllowed(exceptionState))
         return;
     if (raiseExceptionIfNotMutable(CompositorMutableProperty::kScrollTop, exceptionState))
         return;
-    m_scrollTop = scrollTop;
-    m_mutatedProperties |= CompositorMutableProperty::kScrollTop;
+    if (!m_state.get())
+        return;
+    m_state->setScrollTop(scrollTop);
 }
 
 void CompositorProxy::setTransform(DOMMatrix* transform, ExceptionState& exceptionState)
 {
     if (raiseExceptionIfMutationNotAllowed(exceptionState))
         return;
     if (raiseExceptionIfNotMutable(CompositorMutableProperty::kTransform, exceptionState))
         return;
-    m_transform = transform;
-    m_mutatedProperties |= CompositorMutableProperty::kTransform;
+    if (!m_state.get())
+        return;
+    m_state->setTransform(TransformationMatrix::toSkMatrix44(transform->matrix()));
+}
+
+void CompositorProxy::takeCompositorMutableState(std::unique_ptr<CompositorMutableState> state)
+{
+    m_state = std::move(state);
 }
 
 bool CompositorProxy::raiseExceptionIfNotMutable(uint32_t property, ExceptionState& exceptionState) const
 {
     if (m_connected && (m_compositorMutableProperties & property))
         return false;
     exceptionState.throwDOMException(NoModificationAllowedError,
         m_connected ? "Attempted to mutate non-mutable attribute." : "Attempted to mutate attribute on a disconnected proxy.");
     return true;
 }
@@ skipping 11 matching lines @@
         return;
     m_connected = false;
     if (isMainThread()) {
         decrementCompositorProxiedPropertiesForElement(m_elementId, m_compositorMutableProperties);
     } else {
         Platform::current()->mainThread()->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(&decrementCompositorProxiedPropertiesForElement, m_elementId, m_compositorMutableProperties));
     }
 }
 
 } // namespace blink