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/DOMNodeIds.h"
+#include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 
 namespace blink {
 
 struct AttributeFlagMapping {
     const char* name;
     unsigned length;
     CompositorProxy::Attributes attribute;
 };
 
@@ skipping 18 matching lines @@
     const AttributeFlagMapping* start = allowedAttributes;
     const AttributeFlagMapping* end = allowedAttributes + WTF_ARRAY_LENGTH(allowedAttributes);
     if (attributeLower.impl()->is8Bit()) {
         const AttributeFlagMapping* match = std::lower_bound(start, end, attributeLower.impl(), CompareAttributeName);
         if (match != end)
             attributeFlag = match->attribute;
     }
     return attributeFlag;
 }
 
+static bool isControlThread()
+{
+    return !isMainThread();
+}
+
+static bool isCallingCompositorFrameCallback()
+{
+    // TODO(sad):

[esprehn, 2015/03/29 04:44:56]

TODO what?

[sadrul, 2015/03/30 16:07:45]

Oops. My bad. Done.

+    return true;
+}
+
+static bool raiseExceptionIfMutationNotAllowed(ExceptionState& exceptionState)
+{
+    if (!isControlThread()) {
+        exceptionState.throwDOMException(NoModificationAllowedError, "Cannot mutate a proxy attribute from the main page.");
+        return true;
+    }
+    if (!isCallingCompositorFrameCallback()) {
+        exceptionState.throwDOMException(NoModificationAllowedError, "Cannot mutate a proxy attribute outside of a requestCompositorFrame callback.");
+        return true;
+    }
+    return false;
+}
+
 static uint32_t attributesBitfieldFromNames(const Vector<String>& attributeArray)
 {
     uint32_t attributesBitfield = 0;
     for (const auto& attribute : attributeArray) {
         attributesBitfield |= static_cast<uint32_t>(attributeFlagForName(attribute));
     }
     return attributesBitfield;
 }
 
 #if ENABLE(ASSERT)
@@ skipping 19 matching lines @@
 }
 
 CompositorProxy* CompositorProxy::create(uint64_t elementId, uint32_t attributeFlags)
 {
     return new CompositorProxy(elementId, attributeFlags);
 }
 
 CompositorProxy::CompositorProxy(Element& element, const Vector<String>& attributeArray)
     : m_elementId(DOMNodeIds::idForNode(&element))
     , m_bitfieldsSupported(attributesBitfieldFromNames(attributeArray))
+    , m_mutatedAttributes(0)
 {
     ASSERT(isMainThread());
     ASSERT(m_bitfieldsSupported);
     ASSERT(sanityCheckAttributeFlags(m_bitfieldsSupported));
 }
 
 CompositorProxy::CompositorProxy(uint64_t elementId, uint32_t attributeFlags)
     : m_elementId(elementId)
     , m_bitfieldsSupported(attributeFlags)
+    , m_mutatedAttributes(0)
 {
-    ASSERT(!isMainThread());
+    ASSERT(isControlThread());
     ASSERT(sanityCheckAttributeFlags(m_bitfieldsSupported));
 }
 
 CompositorProxy::~CompositorProxy()
 {
 }
 
 bool CompositorProxy::supports(const String& attributeName) const
 {
     return !!(m_bitfieldsSupported & static_cast<uint32_t>(attributeFlagForName(attributeName)));
 }
 
+double CompositorProxy::opacity(ExceptionState& exceptionState) const
+{
+    if (raiseExceptionIfMutationNotAllowed(exceptionState))
+        return 0.0;
+    if (raiseExceptionIfNotMutable(Attributes::OPACITY, exceptionState))
+        return 0.0;
+    return m_opacity;
+}
+
+double CompositorProxy::scrollLeft(ExceptionState& exceptionState) const
+{
+    if (raiseExceptionIfMutationNotAllowed(exceptionState))
+        return 0.0;
+    if (raiseExceptionIfNotMutable(Attributes::SCROLL_LEFT, exceptionState))
+        return 0.0;
+    return m_scrollLeft;
+}
+
+double CompositorProxy::scrollTop(ExceptionState& exceptionState) const
+{
+    if (raiseExceptionIfMutationNotAllowed(exceptionState))
+        return 0.0;
+    if (raiseExceptionIfNotMutable(Attributes::SCROLL_TOP, exceptionState))
+        return 0.0;
+    return m_scrollTop;
+}
+
+DOMMatrix* CompositorProxy::transform(ExceptionState& exceptionState) const
+{
+    if (raiseExceptionIfMutationNotAllowed(exceptionState))
+        return nullptr;
+    if (raiseExceptionIfNotMutable(Attributes::TRANSFORM, exceptionState))
+        return nullptr;
+    return m_transform;
+}
+
+void CompositorProxy::setOpacity(double opacity, ExceptionState& exceptionState)
+{
+    if (raiseExceptionIfMutationNotAllowed(exceptionState))
+        return;
+    if (raiseExceptionIfNotMutable(Attributes::OPACITY, exceptionState))
+        return;
+    m_opacity = opacity;

[esprehn, 2015/03/29 04:44:56]

opacity must be positive, you probably want to just ignore negative values here
(or throw?)

[sadrul, 2015/03/30 16:07:45]

Looks like setting style.opacity on an element in the main-thread clamps the
value between [0, 1]. So I have done the same here.

+    m_mutatedAttributes |= static_cast<uint32_t>(Attributes::OPACITY);
+}
+
+void CompositorProxy::setScrollLeft(double scrollLeft, ExceptionState& exceptionState)
+{
+    if (raiseExceptionIfMutationNotAllowed(exceptionState))
+        return;
+    if (raiseExceptionIfNotMutable(Attributes::SCROLL_LEFT, exceptionState))
+        return;
+    m_scrollLeft = scrollLeft;
+    m_mutatedAttributes |= static_cast<uint32_t>(Attributes::SCROLL_LEFT);
+}
+
+void CompositorProxy::setScrollTop(double scrollTop, ExceptionState& exceptionState)
+{
+    if (raiseExceptionIfMutationNotAllowed(exceptionState))
+        return;
+    if (raiseExceptionIfNotMutable(Attributes::SCROLL_TOP, exceptionState))
+        return;
+    m_scrollTop = scrollTop;
+    m_mutatedAttributes |= static_cast<uint32_t>(Attributes::SCROLL_TOP);
+}
+
+void CompositorProxy::setTransform(DOMMatrix* transform, ExceptionState& exceptionState)
+{
+    if (raiseExceptionIfMutationNotAllowed(exceptionState))
+        return;
+    if (raiseExceptionIfNotMutable(Attributes::TRANSFORM, exceptionState))
+        return;
+    m_transform = transform;
+    m_mutatedAttributes |= static_cast<uint32_t>(Attributes::TRANSFORM);
+}
+
+bool CompositorProxy::raiseExceptionIfNotMutable(Attributes attribute, ExceptionState& exceptionState) const
+{
+    if (m_bitfieldsSupported & static_cast<uint32_t>(attribute))
+        return false;
+    exceptionState.throwDOMException(NoModificationAllowedError, "Attempted to mutate non-mutable attribute.");
+    return true;
+}
+
 } // namespace blink