Move TopDocumentRootScrollerController to a separate object on FrameHost

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/layout/LayoutBox.h"
 #include "core/layout/api/LayoutViewItem.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
+#include "core/page/scrolling/RootScrollerUtil.h"
+#include "core/page/scrolling/TopDocumentRootScrollerController.h"
 #include "core/paint/PaintLayer.h"
 #include "core/paint/PaintLayerScrollableArea.h"
 #include "platform/graphics/GraphicsLayer.h"
 #include "platform/scroll/ScrollableArea.h"
 
 namespace blink {
 
 class RootFrameViewport;
 
 namespace {
@@ skipping 55 matching lines @@
 Element* RootScrollerController::effectiveRootScroller() const
 {
     return m_effectiveRootScroller;
 }
 
 void RootScrollerController::didUpdateLayout()
 {
     recomputeEffectiveRootScroller();
 }
 
-void RootScrollerController::globalRootScrollerMayHaveChanged()
-{
-}
-
 void RootScrollerController::recomputeEffectiveRootScroller()
 {
     bool rootScrollerValid =
         m_rootScroller && isValidRootScroller(*m_rootScroller);
 
     Element* newEffectiveRootScroller = rootScrollerValid
         ? m_rootScroller.get()
         : defaultEffectiveRootScroller();
 
     if (m_effectiveRootScroller == newEffectiveRootScroller)
         return;
 
     PaintLayer* oldRootScrollerLayer = rootScrollerPaintLayer();
 
     m_effectiveRootScroller = newEffectiveRootScroller;
 
     // This change affects both the old and new layers.
     if (oldRootScrollerLayer)
         oldRootScrollerLayer->setNeedsCompositingInputsUpdate();
     if (rootScrollerPaintLayer())
         rootScrollerPaintLayer()->setNeedsCompositingInputsUpdate();
 
     // The above may not be enough as we need to update existing ancestor
     // GraphicsLayers. This will force us to rebuild the GraphicsLayer tree.
     if (LayoutView* layoutView = m_document->layoutView()) {
         layoutView->compositor()
             ->setNeedsCompositingUpdate(CompositingUpdateRebuildTree);
     }
 
-    m_document->topDocument().rootScrollerController()
-        ->globalRootScrollerMayHaveChanged();
-}
-
-ScrollableArea* RootScrollerController::scrollableAreaFor(
-    const Element& element) const
-{
-    if (!element.layoutObject() || !element.layoutObject()->isBox())
-        return nullptr;
-
-    LayoutBox* box = toLayoutBox(element.layoutObject());
-
-    // For a FrameView, we use the layoutViewport rather than the
-    // getScrollableArea() since that could be the RootFrameViewport. The
-    // rootScroller's ScrollableArea will be swapped in as the layout viewport
-    // in RootFrameViewport so we need to ensure we get the layout viewport.
-    if (box->isDocumentElement())
-        return element.document().view()->layoutViewportScrollableArea();
-
-    return static_cast<PaintInvalidationCapableScrollableArea*>(
-        box->getScrollableArea());
+    if (FrameHost* frameHost = m_document->frameHost())
+        frameHost->globalRootScrollerController().didChangeRootScroller();
 }
 
 bool RootScrollerController::isValidRootScroller(const Element& element) const
 {
     if (!element.layoutObject())
         return false;
 
-    if (!scrollableAreaFor(element))
+    if (!RootScrollerUtil::scrollableAreaFor(element))
         return false;
 
     if (!fillsViewport(element))
         return false;
 
     return true;
 }
 
-void RootScrollerController::didUpdateCompositing()
-{
-}
-
-void RootScrollerController::didAttachDocument()
-{
-}
-
-GraphicsLayer* RootScrollerController::rootScrollerLayer()
-{
-    NOTREACHED();
-    return nullptr;
-}
-
-bool RootScrollerController::isViewportScrollCallback(
-    const ScrollStateCallback* callback) const
-{
-    // TopDocumentRootScrollerController must override this method to actually
-    // do the comparison.
-    DCHECK(!m_document->isInMainFrame());
-
-    // If we don't have a local owner we must be in a remote iframe.
-    // RootScrollerController doesn't yet work in OOPIF and in any case we have
-    // no way to get at the ViewportScrollCallback so just return false.
-    // TODO(bokan): Make document.rootScroller work in OOPIF. crbug.com/642378.
-    if (!m_document->localOwner())
-        return false;
-
-    RootScrollerController* topDocumentController =
-        m_document->topDocument().rootScrollerController();
-    return topDocumentController->isViewportScrollCallback(callback);
-}
-
 PaintLayer* RootScrollerController::rootScrollerPaintLayer() const
 {
     if (!m_effectiveRootScroller
         || !m_effectiveRootScroller->layoutObject()
         || !m_effectiveRootScroller->layoutObject()->isBox())
         return nullptr;
 
     LayoutBox* box = toLayoutBox(m_effectiveRootScroller->layoutObject());
     PaintLayer* layer = box->layer();
 
     // If the root scroller is the <html> element we do a bit of a fake out because
     // while <html> has a PaintLayer, scrolling for it is handled by the #document's
     // PaintLayer (i.e. the PaintLayerCompositor's root layer). The reason the root
     // scroller is the <html> layer and not #document is because the latter is a Node
     // but not an Element.
     if (m_effectiveRootScroller->isSameNode(m_document->documentElement()))
         return layer->compositor()->rootLayer();
 
     return layer;
 }
 
 Element* RootScrollerController::defaultEffectiveRootScroller()
 {
     DCHECK(m_document);
     return m_document->documentElement();
 }
 
 } // namespace blink