CompositorWorkerProxyClientImpl to CompositorProxy cross thread reference is using WeakMember

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/CompositorWorkerProxyClient.h"
 #include "core/dom/DOMNodeIds.h"
@@ skipping 108 matching lines @@
 }
 
 CompositorProxy* CompositorProxy::create(ExecutionContext* context,
                                          uint64_t elementId,
                                          uint32_t compositorMutableProperties) {
   if (context->isCompositorWorkerGlobalScope()) {
     WorkerClients* clients = toWorkerGlobalScope(context)->clients();
     DCHECK(clients);
     CompositorWorkerProxyClient* client =
         CompositorWorkerProxyClient::from(clients);
-    return new CompositorProxy(elementId, compositorMutableProperties, client);
+    return new CompositorProxy(elementId, compositorMutableProperties,
+                               client->compositorProxyClient());
   }
 
   return new CompositorProxy(elementId, compositorMutableProperties);
 }
 
 CompositorProxy::CompositorProxy(uint64_t elementId,
                                  uint32_t compositorMutableProperties)
     : m_elementId(elementId),
       m_compositorMutableProperties(compositorMutableProperties),
       m_client(nullptr) {
@@ skipping 31 matching lines @@
 }
 
 CompositorProxy::~CompositorProxy() {
   // We do not explicitly unregister from client here. The client has a weak
   // reference to us which gets collected on its own. This way we avoid using
   // a pre-finalizer.
   disconnectInternal();
   DCHECK(!m_connected);
 }
 
+DEFINE_TRACE(CompositorProxy) {
+  visitor->trace(m_client);
+}
+
 bool CompositorProxy::supports(const String& attributeName) const {
   return m_compositorMutableProperties &
          compositorMutablePropertyForName(attributeName);
 }
 
 double CompositorProxy::opacity(ExceptionState& exceptionState) const {
   if (raiseExceptionIfMutationNotAllowed(exceptionState))
     return 0.0;
   if (raiseExceptionIfNotMutable(CompositorMutableProperty::kOpacity,
                                  exceptionState))
@@ skipping 108 matching lines @@
         m_elementId, m_compositorMutableProperties);
   } else {
     Platform::current()->mainThread()->getWebTaskRunner()->postTask(
         BLINK_FROM_HERE,
         crossThreadBind(&decrementCompositorProxiedPropertiesForElement,
                         m_elementId, m_compositorMutableProperties));
   }
 }
 
 }  // namespace blink