Make RootScroller set the outer viewport scroll layer in the compositor

third_party/WebKit/Source/core/page/scrolling/RootScrollerController.cpp

 // Copyright 2016 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/page/scrolling/RootScrollerController.h"
 
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
 #include "core/frame/FrameHost.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/TopControls.h"
+#include "core/frame/VisualViewport.h"
 #include "core/layout/LayoutBox.h"
+#include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/OverscrollController.h"
 #include "core/page/scrolling/ViewportScrollCallback.h"
 #include "core/paint/PaintLayerScrollableArea.h"
+#include "platform/graphics/GraphicsLayer.h"
 #include "platform/scroll/ScrollableArea.h"
 
 namespace blink {
 
 namespace {
 
 ScrollableArea* scrollableAreaFor(const Element& element)
 {
     if (!element.layoutObject() || !element.layoutObject()->isBox())
         return nullptr;
@@ skipping 48 matching lines @@
 
 ViewportScrollCallback* RootScrollerController::createViewportApplyScroll(
     TopControls* topControls, OverscrollController* overscrollController)
 {
     return new ViewportScrollCallback(topControls, overscrollController);
 }
 
 RootScrollerController::RootScrollerController(Document& document, ViewportScrollCallback* applyScrollCallback)
     : m_document(&document)
     , m_viewportApplyScroll(applyScrollCallback)
+    , m_changedSinceLastCompositingUpdate(false)
 {
 }
 
 DEFINE_TRACE(RootScrollerController)
 {
     visitor->trace(m_document);
     visitor->trace(m_viewportApplyScroll);
     visitor->trace(m_rootScroller);
     visitor->trace(m_effectiveRootScroller);
 }
@@ skipping 26 matching lines @@
 
     Element* newEffectiveRootScroller = rootScrollerValid
         ? m_rootScroller.get()
         : defaultEffectiveRootScroller();
 
     if (m_effectiveRootScroller == newEffectiveRootScroller)
         return;
 
     moveViewportApplyScroll(newEffectiveRootScroller);
     m_effectiveRootScroller = newEffectiveRootScroller;
+
+    m_changedSinceLastCompositingUpdate = true;
 }
 
 void RootScrollerController::moveViewportApplyScroll(Element* target)
 {
     if (!m_viewportApplyScroll)
         return;
 
     if (m_effectiveRootScroller)
         m_effectiveRootScroller->removeApplyScroll();
 
     ScrollableArea* targetScroller =
         target ? scrollableAreaFor(*target) : nullptr;
 
     if (targetScroller) {
         // Use disable-native-scroll since the ViewportScrollCallback needs to
         // apply scroll actions both before (TopControls) and after (overscroll)
         // scrolling the element so it will apply scroll to the element itself.
         target->setApplyScroll(
             m_viewportApplyScroll,
             "disable-native-scroll");
     }
 
     // Ideally, scroll customization would pass the current element to scroll to
     // the apply scroll callback but this doesn't happen today so we set it
     // through a back door here.
     m_viewportApplyScroll->setScroller(targetScroller);
 }
 
+void RootScrollerController::didUpdateCompositing()
+{
+    if (!m_changedSinceLastCompositingUpdate
+        || !m_document
+        || !m_document->frameHost()
+        || !m_effectiveRootScroller)
+        return;
+
+    FrameHost& frameHost = *m_document->frameHost();
+
+    WebLayer* newRootScrollerLayer = nullptr;
+
+    if (m_effectiveRootScroller->layoutObject()
+        && m_effectiveRootScroller->layoutObject()->isBox()) {
+
+        LayoutBox* box = toLayoutBox(m_effectiveRootScroller->layoutObject());
+        GraphicsLayer* graphicsLayer = nullptr;
+
+        if (box->isDocumentElement())
+            graphicsLayer = frameHost.visualViewport().layerForScrolling();
+        else
+            graphicsLayer = box->getScrollableArea()->layerForScrolling();
+
+        // TODO(bokan): We should assert graphicsLayer here and
+        // RootScrollerController should do whatever needs to happen to ensure
+        // the root scroller gets composited.
+
+        if (graphicsLayer)
+            newRootScrollerLayer = graphicsLayer->platformLayer();
+    }
+
+    m_changedSinceLastCompositingUpdate = false;
+
+    // Let the compositor-side counterpart know about this change.
+    if (m_document->isInMainFrame())
+        frameHost.chromeClient().didUpdateRootScrollerLayer(newRootScrollerLayer);
+}
+
 Element* RootScrollerController::defaultEffectiveRootScroller()
 {
     DCHECK(m_document);
     return m_document->documentElement();
 }
 
 } // namespace blink