compositor-worker: Add mutable attributes to CompositorProxy.

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 "config.h"
 #include "core/dom/CompositorProxy.h"
 
 #include "bindings/core/v8/ExceptionMessages.h"
 #include "bindings/core/v8/ExceptionState.h"
 #include "core/dom/ExecutionContext.h"
@@ skipping 13 matching lines @@
 }
 
 static uint64_t compositorProxyIdForElement(Element* element)
 {
     ASSERT(gElementIdMap);
     if (!gElementIdMap->contains(element))
         gElementIdMap->add(element, nextCompositorProxyId());
     return gElementIdMap->get(element);
 }
 
+static bool isControlThread()
+{
+    return !isMainThread();
+}
+
+static bool isCallingCompositorFrameCallback()
+{
+    // TODO(sad):
+    return true;
+}
+
+static bool raiseExceptionIfMutationNotAllowed(ExceptionState& exceptionState)
+{
+    if (!isControlThread()) {
+        exceptionState.throwTypeError("Cannot mutate a proxy attribute from the main page.");
+        return true;
+    }
+    if (!isCallingCompositorFrameCallback()) {
+        exceptionState.throwTypeError("Cannot mutate a proxy attribute outside of a requestCompositorFrame callback.");
+        return true;
+    }
+    return false;
+}
+
 static struct {
     const char* name;
     CompositorProxy::Attributes attribute;
 } allowedAttributes[] = {
     { "opacity", CompositorProxy::Attributes::OPACITY },
     { "scrolltop", CompositorProxy::Attributes::SCROLL_TOP },
     { "touch", CompositorProxy::Attributes::TOUCH },
     { "transform", CompositorProxy::Attributes::TRANSFORM },
 };
 
@@ skipping 27 matching lines @@
         gElementMap = new ElementMap;
         gElementIdMap = new ElementIdMap;
     } else {
         ASSERT(gElementIdMap);
     }
     return new CompositorProxy(element, attributeFlags);
 }
 
 CompositorProxy* CompositorProxy::create(uint64_t elementId, uint32_t attributeFlags)
 {
-    ASSERT(!isMainThread());
+    ASSERT(isControlThread());
 #ifndef NDEBUG
     uint32_t sanityCheckAttributes = attributeFlags;
     for (unsigned i = 0; i < arraysize(allowedAttributes); ++i) {
         sanityCheckAttributes &= ~static_cast<uint32_t>(allowedAttributes[i].attribute);
     }
     ASSERT(!sanityCheckAttributes);
 #endif
     return new CompositorProxy(elementId, attributeFlags);
 }
 
 CompositorProxy::CompositorProxy(Element* element, uint32_t attributeFlags)
     : m_elementId(compositorProxyIdForElement(element))
-    , m_attributes(attributeFlags)
+    , m_mutableAttributes(attributeFlags)
+    , m_mutatedAttributes(0)
 {
     ASSERT(isMainThread());
     ASSERT(gElementMap);
     gElementMap->add(m_elementId, element);
 }
 
 CompositorProxy::CompositorProxy(uint64_t elementId, uint32_t attributeFlags)
     : m_elementId(elementId)
-    , m_attributes(attributeFlags)
+    , m_mutableAttributes(attributeFlags)
+    , m_mutatedAttributes(0)
 {
 }
 
 CompositorProxy::~CompositorProxy()
 {
 }
 
 void CompositorProxy::notifyElementGone(Element* element)
 {
     ASSERT(isMainThread());
     if (!gElementMap)
         return;
 
     gElementMap->remove(gElementIdMap->take(element));
 }
 
+double CompositorProxy::opacity(ExceptionState& exceptionState) const
+{
+    if (UNLIKELY(raiseExceptionIfMutationNotAllowed(exceptionState)))
+        return 0.0;
+    return m_opacity;
+}
+
+double CompositorProxy::scrollTop(ExceptionState& exceptionState) const
+{
+    if (UNLIKELY(raiseExceptionIfMutationNotAllowed(exceptionState)))
+        return 0.0;
+    return m_scrollTop;
+}
+
+Vector<double> CompositorProxy::transform(ExceptionState& exceptionState) const
+{
+    if (UNLIKELY(raiseExceptionIfMutationNotAllowed(exceptionState)))
+        return Vector<double>();
+    return Vector<double>(m_transform);
+}
+
+void CompositorProxy::setOpacity(double opacity, ExceptionState& exceptionState)
+{
+    if (UNLIKELY(raiseExceptionIfMutationNotAllowed(exceptionState)))
+        return;
+    if (UNLIKELY(raiseExceptionIfNotMutable(Attributes::OPACITY, exceptionState)))
+        return;
+    m_opacity = opacity;
+    m_mutatedAttributes |= static_cast<uint32_t>(Attributes::OPACITY);
+}
+
+void CompositorProxy::setScrollTop(double scrollTop, ExceptionState& exceptionState)
+{
+    if (UNLIKELY(raiseExceptionIfMutationNotAllowed(exceptionState)))
+        return;
+    if (UNLIKELY(raiseExceptionIfNotMutable(Attributes::SCROLL_TOP, exceptionState)))
+        return;
+    m_scrollTop = scrollTop;
+    m_mutatedAttributes |= static_cast<uint32_t>(Attributes::SCROLL_TOP);
+}
+
+void CompositorProxy::setTransform(const Vector<double>& transform, ExceptionState& exceptionState)
+{
+    if (UNLIKELY(raiseExceptionIfMutationNotAllowed(exceptionState)))
+        return;
+    if (UNLIKELY(raiseExceptionIfNotMutable(Attributes::TRANSFORM, exceptionState)))
+        return;
+    if (UNLIKELY(transform.size() != m_transform.size())) {
+        exceptionState.throwTypeError("Incorrect size of the transform array.");
+        return;
+    }
+    m_transform = transform;
+    m_mutatedAttributes |= static_cast<uint32_t>(Attributes::TRANSFORM);
+}
+
+bool CompositorProxy::raiseExceptionIfNotMutable(Attributes attribute, ExceptionState& exceptionState) const
+{
+    if (m_mutableAttributes & static_cast<uint32_t>(attribute))
+        return false;
+    exceptionState.throwTypeError("Attempted to mutate non-mutable attribute.");
+    return true;
+}
+
 } // namespace blink