compositor-worker: Introduce CompositorProxy::disconnect().

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"
+#include "public/platform/Platform.h"
+#include "public/platform/WebTraceLocation.h"
 
 namespace blink {
 
 struct AttributeFlagMapping {
     const char* name;
     unsigned length;
     CompositorProxy::Attributes attribute;
 };
 
 static AttributeFlagMapping allowedAttributes[] = {
@@ skipping 28 matching lines @@
 {
     return !isMainThread();
 }
 
 static bool isCallingCompositorFrameCallback()
 {
     // TODO(sad): Check that the requestCompositorFrame callbacks are currently being called.
     return true;
 }
 
+static void decrementCountForElement(uint64_t elementId)
+{
+    ASSERT(isMainThread());
+    Node* node = DOMNodeIds::nodeForId(elementId);
+    if (!node)
+        return;
+    Element* element = toElement(node);
+    element->decrementProxyCount();
+}
+
+static void incrementProxyCountForElement(uint64_t elementId)
+{
+    ASSERT(isMainThread());
+    Node* node = DOMNodeIds::nodeForId(elementId);
+    if (!node)
+        return;
+    Element* element = toElement(node);
+    element->incrementProxyCount();
+}
+
 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;
     }
@@ skipping 36 matching lines @@
     return new CompositorProxy(elementId, attributeFlags);
 }
 
 CompositorProxy::CompositorProxy(Element& element, const Vector<String>& attributeArray)
     : m_elementId(DOMNodeIds::idForNode(&element))
     , m_bitfieldsSupported(attributesBitfieldFromNames(attributeArray))
 {
     ASSERT(isMainThread());
     ASSERT(m_bitfieldsSupported);
     ASSERT(sanityCheckAttributeFlags(m_bitfieldsSupported));
+
+    incrementProxyCountForElement(m_elementId);
 }
 
 CompositorProxy::CompositorProxy(uint64_t elementId, uint32_t attributeFlags)
     : m_elementId(elementId)
     , m_bitfieldsSupported(attributeFlags)
 {
     ASSERT(isControlThread());
     ASSERT(sanityCheckAttributeFlags(m_bitfieldsSupported));
+    Platform::current()->mainThread()->postTask(FROM_HERE, bind(&incrementProxyCountForElement, m_elementId));
 }
 
 CompositorProxy::~CompositorProxy()
 {
+    if (m_connected)
+        disconnect();
 }
 
 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))
@@ skipping 65 matching lines @@
     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))
+    if (m_connected && (m_bitfieldsSupported & static_cast<uint32_t>(attribute)))
         return false;
-    exceptionState.throwDOMException(NoModificationAllowedError, "Attempted to mutate non-mutable attribute.");
+    exceptionState.throwDOMException(NoModificationAllowedError,
+        m_connected ? "Attempted to mutate non-mutable attribute." : "Attempted to mutate attribute on a disconnected proxy.");
     return true;
 }
 
+void CompositorProxy::disconnect()
+{
+    m_connected = false;
+    if (isMainThread())
+        decrementCountForElement(m_elementId);
+    else
+        Platform::current()->mainThread()->postTask(FROM_HERE, bind(&decrementCountForElement, m_elementId));
+}
+
 } // namespace blink