[compositor-worker] root scrolling layer is associated with document scrolling element

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 97 matching lines @@
 CompositorProxy* CompositorProxy::create(ExecutionContext* context,
                                          Element* element,
                                          const Vector<String>& attributeArray,
                                          ExceptionState& exceptionState) {
   if (!context->isDocument()) {
     exceptionState.throwTypeError(ExceptionMessages::failedToConstruct(
         "CompositorProxy", "Can only be created from the main context."));
     return nullptr;
   }
 
-  return new CompositorProxy(*element, attributeArray);
+  Document* document = toDocument(context);
+  Node* scrollingNode = element;
+  // The scrolling layer for the root scrolling element is attached to the
+  // document. So use document as scrolling node when creating a proxy to ensure
+  // we mutate the correct scroll layer.
+  // TODO(majidvp): Consider checking against
+  // |RootScrollerController::effectiveRootScroller| instead of
+  // |Document::scrollingElement|.
+  if (element->isSameNode(document->scrollingElement()))
+    scrollingNode = document;

[flackr, 2017/03/01 16:31:26]

It seems like the proper fix would be for cc to set the document scrolling layer
to be the body element's scrolling layer to reflect that this scrolling layer is
the scrolling element's scrolling layer. Then we wouldn't need to have a
separate id and it would match blink's concept of the scrolling element right?

I think this would mean changing the element id for the root scrolling contents
layer to be the document.scrollingElement's id in CompositedLayerMapping.cpp

+  return new CompositorProxy(*element, *scrollingNode, attributeArray);
 }
 
 CompositorProxy* CompositorProxy::create(ExecutionContext* context,
                                          uint64_t elementId,
+                                         uint64_t scrollingNodeId,
                                          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, scrollingNodeId,
+                               compositorMutableProperties, client);
   }
 
-  return new CompositorProxy(elementId, compositorMutableProperties);
+  return new CompositorProxy(elementId, scrollingNodeId,
+                             compositorMutableProperties);
 }
 
 CompositorProxy::CompositorProxy(uint64_t elementId,
+                                 uint64_t scrollingNodeId,
                                  uint32_t compositorMutableProperties)
     : m_elementId(elementId),
+      m_scrollingNodeId(scrollingNodeId),
       m_compositorMutableProperties(compositorMutableProperties),
       m_client(nullptr) {
   DCHECK(m_compositorMutableProperties);
 #if DCHECK_IS_ON()
   DCHECK(sanityCheckMutableProperties(m_compositorMutableProperties));
 #endif
 
   if (isMainThread()) {
     incrementCompositorProxiedPropertiesForElement(
         m_elementId, m_compositorMutableProperties);
   } else {
     Platform::current()->mainThread()->getWebTaskRunner()->postTask(
         BLINK_FROM_HERE,
         crossThreadBind(&incrementCompositorProxiedPropertiesForElement,
                         m_elementId, m_compositorMutableProperties));
   }
 }
 
 CompositorProxy::CompositorProxy(Element& element,
+                                 Node& scrollingNode,
                                  const Vector<String>& attributeArray)
     : CompositorProxy(DOMNodeIds::idForNode(&element),
+                      DOMNodeIds::idForNode(&scrollingNode),
                       compositorMutablePropertiesFromNames(attributeArray)) {
   DCHECK(isMainThread());
 }
 
 CompositorProxy::CompositorProxy(uint64_t elementId,
+                                 uint64_t scrollingNodeId,
                                  uint32_t compositorMutableProperties,
                                  CompositorProxyClient* client)
-    : CompositorProxy(elementId, compositorMutableProperties) {
+    : CompositorProxy(elementId, scrollingNodeId, compositorMutableProperties) {
   m_client = client;
   DCHECK(m_client);
   DCHECK(isControlThread());
   m_client->registerCompositorProxy(this);
 }
 
 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.
@@ skipping 122 matching lines @@
         m_elementId, m_compositorMutableProperties);
   } else {
     Platform::current()->mainThread()->getWebTaskRunner()->postTask(
         BLINK_FROM_HERE,
         crossThreadBind(&decrementCompositorProxiedPropertiesForElement,
                         m_elementId, m_compositorMutableProperties));
   }
 }
 
 }  // namespace blink