Avoid exposing cc::Layer tree to CompositorProxy

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"
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/workers/WorkerClients.h"
 #include "core/workers/WorkerGlobalScope.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/graphics/CompositorMutableProperties.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebTraceLocation.h"
 #include <algorithm>
 
 namespace blink {
+namespace {
+// An identifier for CompositorProxy objects. Will be unique across all proxies
+// created in the same thread.
+uint64_t g_unique_id = 0;
+}  // namespace
 
 static const struct {
   const char* name;
   uint32_t property;
 } kAllowedProperties[] = {
     {"opacity", CompositorMutableProperty::kOpacity},
     {"scrollleft", CompositorMutableProperty::kScrollLeft},
     {"scrolltop", CompositorMutableProperty::kScrollTop},
     {"transform", CompositorMutableProperty::kTransform},
 };
@@ skipping 98 matching lines @@
         CompositorWorkerProxyClient::From(clients);
     return new CompositorProxy(element_id, compositor_mutable_properties,
                                client->GetCompositorProxyClient());
   }
 
   return new CompositorProxy(element_id, compositor_mutable_properties);
 }
 
 CompositorProxy::CompositorProxy(uint64_t element_id,
                                  uint32_t compositor_mutable_properties)
-    : element_id_(element_id),
+    : proxy_id_(g_unique_id++),
+      element_id_(element_id),
       compositor_mutable_properties_(compositor_mutable_properties),
       client_(nullptr) {
   DCHECK(compositor_mutable_properties_);
 #if DCHECK_IS_ON()
   DCHECK(SanityCheckMutableProperties(compositor_mutable_properties_));
 #endif
 
   if (IsMainThread()) {

[flackr, 2017/04/11 17:51:36]

This check implies that this constructor can be called on multiple threads, but
if it can than the proxy id increment will be racy. Also, is there not an
intention to match the proxy id selected by the main thread if we create a proxy
on the compositor thread?

[smcgruer, 2017/04/19 15:38:38]

Hrm, you are correct. I think the correct thing to do is to generate the proxy
ID on the main thread's Create() method, require it as a parameter to the
compositor side Create() method, and pass it over the wire during serialization
- does that sgty?

[flackr, 2017/04/20 06:54:14]

Yes, this SGTM

     IncrementCompositorProxiedPropertiesForElement(
         element_id_, compositor_mutable_properties_);
   } else {
     Platform::Current()->MainThread()->GetWebTaskRunner()->PostTask(
         BLINK_FROM_HERE,
         CrossThreadBind(&IncrementCompositorProxiedPropertiesForElement,
                         element_id_, compositor_mutable_properties_));
   }
 }
 
@@ skipping 146 matching lines @@
         element_id_, compositor_mutable_properties_);
   } else {
     Platform::Current()->MainThread()->GetWebTaskRunner()->PostTask(
         BLINK_FROM_HERE,
         CrossThreadBind(&DecrementCompositorProxiedPropertiesForElement,
                         element_id_, compositor_mutable_properties_));
   }
 }
 
 }  // namespace blink