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

third_party/WebKit/Source/core/dom/CompositorProxy.h

 // 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.
 
 #ifndef CompositorProxy_h
 #define CompositorProxy_h
 
 #include "bindings/core/v8/ScriptWrappable.h"
 #include "core/CoreExport.h"
 #include "core/dom/CompositorProxyClient.h"
@@ skipping 13 matching lines @@
     : public GarbageCollectedFinalized<CompositorProxy>,
       public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
   static CompositorProxy* create(ExecutionContext*,
                                  Element*,
                                  const Vector<String>& attributeArray,
                                  ExceptionState&);
   static CompositorProxy* create(ExecutionContext*,
-                                 uint64_t element,
+                                 uint64_t elementId,
+                                 uint64_t scrollingNodeId,
                                  uint32_t compositorMutableProperties);
   virtual ~CompositorProxy();
 
   DEFINE_INLINE_TRACE() {}
 
   uint64_t elementId() const { return m_elementId; }
+  uint64_t scrollingNodeId() const { return m_scrollingNodeId; }
   uint32_t compositorMutableProperties() const {
     return m_compositorMutableProperties;
   }
   bool supports(const String& attribute) const;
 
   bool initialized() const { return m_connected && m_state.get(); }
   bool connected() const { return m_connected; }
   void disconnect();
 
   double opacity(ExceptionState&) const;
   double scrollLeft(ExceptionState&) const;
   double scrollTop(ExceptionState&) const;
   DOMMatrix* transform(ExceptionState&) const;
 
   void setOpacity(double, ExceptionState&);
   void setScrollLeft(double, ExceptionState&);
   void setScrollTop(double, ExceptionState&);
   void setTransform(DOMMatrix*, ExceptionState&);
 
   void takeCompositorMutableState(std::unique_ptr<CompositorMutableState>);
 
  protected:
-  CompositorProxy(uint64_t elementId, uint32_t compositorMutableProperties);
-  CompositorProxy(Element&, const Vector<String>& attributeArray);
+  CompositorProxy(uint64_t elementId,
+                  uint64_t scrollingNodeId,
+                  uint32_t compositorMutableProperties);
+  CompositorProxy(Element&,
+                  Node& scrollingNode,
+                  const Vector<String>& attributeArray);
   CompositorProxy(uint64_t element,
+                  uint64_t scrollingNodeId,
                   uint32_t compositorMutableProperties,
                   CompositorProxyClient*);
 
  private:
   bool raiseExceptionIfNotMutable(uint32_t compositorMutableProperty,
                                   ExceptionState&) const;
   void disconnectInternal();
 
   const uint64_t m_elementId = 0;
+  const uint64_t m_scrollingNodeId = 0;
   const uint32_t m_compositorMutableProperties = 0;
 
   bool m_connected = true;
   CrossThreadPersistent<CompositorProxyClient> m_client;
   std::unique_ptr<CompositorMutableState> m_state;
 };
 
 }  // namespace blink
 
 #endif  // CompositorProxy_h