Split RootScrollerController into top-document and child-document classes

Work on making RootScrollerController work across iframes revealed that there's
two responsibilities that need management. All frames need a
RootScrollerController to manage the Element currently set as root scroller and
determine which Element should eventually become the effective root scroller.
In addition, we need the RootScrollerController to manage the
ViewportApplyScroll and set it on the appropriate element. Since only one
Element on the whole page needs this callback set, it makes sense that only the
top document should have this responsibility. Experience with classes like
FrameView and EventHandler shows that this may be better served by subclassing
the top level object rather than having isMainFrame() checks intermingled with
the other code.

BUG=505516

Review-Url: https://codereview.chromium.org/2280453002
Cr-Commit-Position: refs/heads/master@{#414796}

third_party/WebKit/Source/core/core.gypi

@@ -2061,6 +2061,8 @@
             'page/scrolling/ScrollStateCallback.h',
             'page/scrolling/StickyPositionScrollingConstraints.cpp',
             'page/scrolling/StickyPositionScrollingConstraints.h',
+            'page/scrolling/TopDocumentRootScrollerController.cpp',
+            'page/scrolling/TopDocumentRootScrollerController.h',
             'page/scrolling/ViewportScrollCallback.cpp',
             'page/scrolling/ViewportScrollCallback.h',
             'paint/BackgroundImageGeometry.cpp',

third_party/WebKit/Source/core/dom/Document.cpp

@@ -207,7 +207,7 @@
 #include "core/page/scrolling/ScrollStateCallback.h"
 #include "core/page/scrolling/ScrollingCoordinator.h"
 #include "core/page/scrolling/SnapCoordinator.h"
-#include "core/page/scrolling/ViewportScrollCallback.h"
+#include "core/page/scrolling/TopDocumentRootScrollerController.h"
 #include "core/svg/SVGDocumentExtensions.h"
 #include "core/svg/SVGScriptElement.h"
 #include "core/svg/SVGTitleElement.h"
@@ -473,7 +473,11 @@ Document::Document(const DocumentInit& initializer, DocumentClassFlags documentC
         m_fetcher = ResourceFetcher::create(nullptr);
     }
 
-    m_rootScrollerController = RootScrollerController::create(*this);
+    // TODO(bokan): This will probably blow up if we don't have an m_frame here
+    // since we'll assume a child RootScrollerController. crbug.com/505516.
+    m_rootScrollerController = isInMainFrame()
+        ? TopDocumentRootScrollerController::create(*this)
+        : RootScrollerController::create(*this);
 
     // We depend on the url getting immediately set in subframes, but we
     // also depend on the url NOT getting immediately set in opened windows.

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

@@ -8,13 +8,7 @@
 #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"
@@ -25,24 +19,6 @@ class RootFrameViewport;
 
 namespace {
 
-ScrollableArea* scrollableAreaFor(const Element& element)
-{
-    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());
-}
-
 bool fillsViewport(const Element& element)
 {
     DCHECK(element.layoutObject());
@@ -66,22 +42,14 @@ bool fillsViewport(const Element& element)
         && boundingBox.size() == topDocument.layoutViewItem().size();
 }
 
-bool isValidRootScroller(const Element& element)
-{
-    if (!element.layoutObject())
-        return false;
-
-    if (!scrollableAreaFor(element))
-        return false;
-
-    if (!fillsViewport(element))
-        return false;
+} // namespace
 
-    return true;
+// static
+RootScrollerController* RootScrollerController::create(Document& document)
+{
+    return new RootScrollerController(document);
 }
 
-} // namespace
-
 RootScrollerController::RootScrollerController(Document& document)
     : m_document(&document)
 {
@@ -90,10 +58,8 @@ RootScrollerController::RootScrollerController(Document& document)
 DEFINE_TRACE(RootScrollerController)
 {
     visitor->trace(m_document);
-    visitor->trace(m_viewportApplyScroll);
     visitor->trace(m_rootScroller);
     visitor->trace(m_effectiveRootScroller);
-    visitor->trace(m_currentViewportApplyScrollHost);
 }
 
 void RootScrollerController::set(Element* newRootScroller)
@@ -130,72 +96,47 @@ void RootScrollerController::updateEffectiveRootScroller()
         return;
 
     m_effectiveRootScroller = newEffectiveRootScroller;
-
-    if (m_document->isInMainFrame())
-        setViewportApplyScrollOnRootScroller();
 }
 
-void RootScrollerController::setViewportApplyScrollOnRootScroller()
+ScrollableArea* RootScrollerController::scrollableAreaFor(
+    const Element& element) const
 {
-    DCHECK(m_document->isInMainFrame());
+    if (!element.layoutObject() || !element.layoutObject()->isBox())
+        return nullptr;
 
-    if (!m_viewportApplyScroll || !m_effectiveRootScroller)
-        return;
+    LayoutBox* box = toLayoutBox(element.layoutObject());
 
-    ScrollableArea* targetScroller =
-        scrollableAreaFor(*m_effectiveRootScroller);
+    // 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();
 
-    if (!targetScroller)
-        return;
+    return static_cast<PaintInvalidationCapableScrollableArea*>(
+        box->getScrollableArea());
+}
 
-    if (m_currentViewportApplyScrollHost)
-        m_currentViewportApplyScrollHost->removeApplyScroll();
+bool RootScrollerController::isValidRootScroller(const Element& element) const
+{
+    if (!element.layoutObject())
+        return false;
 
-    // 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.
-    m_effectiveRootScroller->setApplyScroll(
-        m_viewportApplyScroll, "disable-native-scroll");
+    if (!scrollableAreaFor(element))
+        return false;
 
-    m_currentViewportApplyScrollHost = m_effectiveRootScroller;
+    if (!fillsViewport(element))
+        return false;
 
-    // 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. This is also needed by the
-    // ViewportScrollCallback to swap the target into the layout viewport
-    // in RootFrameViewport.
-    m_viewportApplyScroll->setScroller(targetScroller);
+    return true;
 }
 
 void RootScrollerController::didUpdateCompositing()
 {
-    FrameHost* frameHost = m_document->frameHost();
-
-    // Let the compositor-side counterpart know about this change.
-    if (frameHost && m_document->isInMainFrame())
-        frameHost->chromeClient().registerViewportLayers();
 }
 
 void RootScrollerController::didAttachDocument()
 {
-    if (!m_document->isInMainFrame())
-        return;
-
-    FrameHost* frameHost = m_document->frameHost();
-    FrameView* frameView = m_document->view();
-
-    if (!frameHost || !frameView)
-        return;
-
-    RootFrameViewport* rootFrameViewport = frameView->getRootFrameViewport();
-    DCHECK(rootFrameViewport);
-
-    m_viewportApplyScroll = ViewportScrollCallback::create(
-        &frameHost->topControls(),
-        &frameHost->overscrollController(),
-        *rootFrameViewport);
-
-    updateEffectiveRootScroller();
 }
 
 GraphicsLayer* RootScrollerController::rootScrollerLayer()
@@ -220,10 +161,13 @@ GraphicsLayer* RootScrollerController::rootScrollerLayer()
 bool RootScrollerController::isViewportScrollCallback(
     const ScrollStateCallback* callback) const
 {
-    if (!callback)
-        return false;
+    // TopDocumentRootScrollerController must override this method to actually
+    // do the comparison.
+    DCHECK(!m_document->isInMainFrame());
 
-    return callback == m_viewportApplyScroll.get();
+    RootScrollerController* topDocumentController =
+        m_document->topDocument().rootScrollerController();
+    return topDocumentController->isViewportScrollCallback(callback);
 }
 
 Element* RootScrollerController::defaultEffectiveRootScroller()

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

@@ -13,41 +13,36 @@ namespace blink {
 class Document;
 class Element;
 class GraphicsLayer;
+class ScrollableArea;
 class ScrollStateCallback;
-class ViewportScrollCallback;
 
-// Manages the root scroller associated with a given document. The root scroller
-// causes top controls movement, overscroll effects and prevents chaining
-// scrolls up further in the DOM. It can be set from script using
+// Manages the root scroller associated with a given document. The root
+// scroller causes top controls movement, overscroll effects and prevents
+// chaining scrolls up further in the DOM. It can be set from script using
 // document.setRootScroller.
 //
 // There are two notions of a root scroller in this class: m_rootScroller and
 // m_effectiveRootScroller. The former is the Element that was set as the root
 // scroller using document.setRootScroller. If the page didn't set a root
 // scroller this will be nullptr. The "effective" root scroller is the current
-// element we're using internally to apply viewport scroll actions. i.e It's the
-// element with the ViewportScrollCallback set as its apply-scroll callback.
-// The effective root scroller will only be null during document initialization.
+// element we're using internally to apply viewport scrolling actions.  The
+// effective root scroller will only be null during document initialization.
 //
-// If the root scroller element is a valid element to become the root scroller,
-// it will be promoted to the effective root scroller. If it is not valid, the
-// effective root scroller will fall back to a default Element (see
+// If the currently set m_rootScroller is a valid element to become the root
+// scroller, it will be promoted to the effective root scroller. If it is not
+// valid, the effective root scroller will fall back to a default Element (see
 // defaultEffectiveRootScroller()). The rules for what makes an element a valid
 // root scroller are set in isValidRootScroller(). The validity of the current
 // root scroller is re-checked after each layout.
 class CORE_EXPORT RootScrollerController
     : public GarbageCollected<RootScrollerController> {
 public:
-    // Creates a RootScrollerController for the given document. You should use
-    // setViewportScrollCallback to provide this class with a scroll callback
-    // that RootScrollerController will keep applied to the current RootScroller
-    // so that special actions can occur on scrolling.
-    static RootScrollerController* create(Document& document)
-    {
-        return new RootScrollerController(document);
-    }
+    // Creates a RootScrollerController for the given document. Note, instances
+    // of this class need to be made aware of lifecycle events, see the
+    // didUpdateLayout, didUpdateCompositing, etc. type methods below.
+    static RootScrollerController* create(Document&);
 
-    DECLARE_TRACE();
+    DECLARE_VIRTUAL_TRACE();
 
     // Sets the element that will be used as the root scroller. This can be
     // nullptr, in which case we'll use the default element (documentElement) as
@@ -74,36 +69,50 @@ public:
 
     // This class needs to be informed of changes to compositing so that it can
     // update the compositor when the effective root scroller changes.
-    void didUpdateCompositing();
+    virtual void didUpdateCompositing();
 
     // This class needs to be informed when the document has been attached to a
     // FrameView so that we can initialize the viewport scroll callback.
-    void didAttachDocument();
+    virtual void didAttachDocument();
 
+    // Returns the GraphicsLayer for the current effective root scroller
+    // element.
     GraphicsLayer* rootScrollerLayer();
 
+    // Returns true if the given ScrollStateCallback is the ViewportScrollCallback managed
+    // by this class.
     // TODO(bokan): Temporarily needed to allow ScrollCustomization to
     // differentiate between real custom callback and the built-in viewport
-    // apply scroll.
-    bool isViewportScrollCallback(const ScrollStateCallback*) const;
+    // apply scroll. crbug.com/623079.
+    virtual bool isViewportScrollCallback(const ScrollStateCallback*) const;
 
-private:
+protected:
     RootScrollerController(Document&);
 
-    Element* defaultEffectiveRootScroller();
-
     // Ensures the effective root scroller is currently valid and replaces it
     // with the default if not.
-    void updateEffectiveRootScroller();
+    virtual void updateEffectiveRootScroller();
 
-    // Called only from the top Document's RootScrollerController. Ensures that
-    // the element that should be used as the root scroller on the page has the
-    // m_viewportApplyScroll callback set on it.
-    void setViewportApplyScrollOnRootScroller();
+    // Returns the ScrollableArea to use to scroll the given Element.
+    ScrollableArea* scrollableAreaFor(const Element&) const;
 
+    // The owning Document whose root scroller this object manages.
     WeakMember<Document> m_document;
-    Member<ViewportScrollCallback> m_viewportApplyScroll;
 
+private:
+
+    // Determines whether the given element meets the criteria to become the
+    // effective root scroller.
+    bool isValidRootScroller(const Element&) const;
+
+    // Returns the Element that should be used if the currently set
+    // m_rootScroller isn't valid to be a root scroller.
+    Element* defaultEffectiveRootScroller();
+
+    // The Element that was set from script as rootScroller. Depending on its
+    // validity to be the root scroller (e.g. a display: none element isn't a
+    // valid root scroller), this may not actually be the Element being used as
+    // the root scroller.
     WeakMember<Element> m_rootScroller;
 
     // The element currently being used as the root scroller. If
@@ -112,10 +121,6 @@ private:
     // initialization and will not be set until m_viewportApplyScroll is
     // provided.
     WeakMember<Element> m_effectiveRootScroller;
-
-    // Tracks which element currently has the m_viewportApplyScroll set to it.
-    // This will only ever be set on the top Document's RootScrollerController.
-    WeakMember<Element> m_currentViewportApplyScrollHost;
 };
 
 } // namespace blink

third_party/WebKit/Source/core/page/scrolling/TopDocumentRootScrollerController.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/TopDocumentRootScrollerController.h"
+
+#include "core/dom/Document.h"
+#include "core/dom/Element.h"
+#include "core/frame/FrameHost.h"
+#include "core/frame/FrameView.h"
+#include "core/page/ChromeClient.h"
+#include "core/page/scrolling/OverscrollController.h"
+#include "core/page/scrolling/ViewportScrollCallback.h"
+#include "platform/scroll/ScrollableArea.h"
+
+namespace blink {
+
+// static
+TopDocumentRootScrollerController* TopDocumentRootScrollerController::create(
+    Document& document)
+{
+    return new TopDocumentRootScrollerController(document);
+}
+
+TopDocumentRootScrollerController::TopDocumentRootScrollerController(
+    Document& document)
+    : RootScrollerController(document)
+{
+}
+
+DEFINE_TRACE(TopDocumentRootScrollerController)
+{
+    visitor->trace(m_viewportApplyScroll);
+    visitor->trace(m_currentViewportApplyScrollHost);
+    RootScrollerController::trace(visitor);
+}
+
+void TopDocumentRootScrollerController::updateEffectiveRootScroller()
+{
+    RootScrollerController::updateEffectiveRootScroller();
+    setViewportApplyScrollOnRootScroller();
+}
+
+void TopDocumentRootScrollerController::setViewportApplyScrollOnRootScroller()
+{
+    if (!m_viewportApplyScroll || !effectiveRootScroller())
+        return;
+
+    ScrollableArea* targetScroller =
+        scrollableAreaFor(*effectiveRootScroller());
+
+    if (!targetScroller)
+        return;
+
+    if (m_currentViewportApplyScrollHost)
+        m_currentViewportApplyScrollHost->removeApplyScroll();
+
+    // 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.
+    effectiveRootScroller()->setApplyScroll(
+        m_viewportApplyScroll, "disable-native-scroll");
+
+    m_currentViewportApplyScrollHost = effectiveRootScroller();
+
+    // 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. This is also needed by the
+    // ViewportScrollCallback to swap the target into the layout viewport
+    // in RootFrameViewport.
+    m_viewportApplyScroll->setScroller(targetScroller);
+}
+
+void TopDocumentRootScrollerController::didUpdateCompositing()
+{
+    FrameHost* frameHost = m_document->frameHost();
+
+    // Let the compositor-side counterpart know about this change.
+    if (frameHost)
+        frameHost->chromeClient().registerViewportLayers();
+}
+
+void TopDocumentRootScrollerController::didAttachDocument()
+{
+    FrameHost* frameHost = m_document->frameHost();
+    FrameView* frameView = m_document->view();
+
+    if (!frameHost || !frameView)
+        return;
+
+    RootFrameViewport* rootFrameViewport = frameView->getRootFrameViewport();
+    DCHECK(rootFrameViewport);
+
+    m_viewportApplyScroll = ViewportScrollCallback::create(
+        &frameHost->topControls(),
+        &frameHost->overscrollController(),
+        *rootFrameViewport);
+
+    updateEffectiveRootScroller();
+}
+
+bool TopDocumentRootScrollerController::isViewportScrollCallback(
+    const ScrollStateCallback* callback) const
+{
+    if (!callback)
+        return false;
+
+    return callback == m_viewportApplyScroll.get();
+}
+
+} // namespace blink

third_party/WebKit/Source/core/page/scrolling/TopDocumentRootScrollerController.h

+// 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.
+
+#ifndef TopDocumentRootScrollerController_h
+#define TopDocumentRootScrollerController_h
+
+#include "core/CoreExport.h"
+#include "core/page/scrolling/RootScrollerController.h"
+#include "platform/heap/Handle.h"
+
+namespace blink {
+
+class Document;
+class Element;
+class GraphicsLayer;
+class ScrollStateCallback;
+class ViewportScrollCallback;
+
+// The RootScrollerController used to manage the root scroller for the top
+// level Document on a page. In addition to the regular RootScroller duties
+// such as keeping track of which Element is set as root scroller and which is
+// the effective root scroller, this class is also responsible for setting the
+// ViewportApplyScroll on the one Element on a page that should apply viewport
+// scrolling actions.
+class CORE_EXPORT TopDocumentRootScrollerController
+    : public RootScrollerController {
+public:
+    static TopDocumentRootScrollerController* create(Document&);
+
+    DECLARE_VIRTUAL_TRACE();
+
+    // This class needs to be informed of changes to compositing so that it can
+    // update the compositor when the effective root scroller changes.
+    void didUpdateCompositing() override;
+
+    // This class needs to be informed when the document has been attached to a
+    // FrameView so that we can initialize the viewport scroll callback.
+    void didAttachDocument() override;
+
+    // Returns true if the given ScrollStateCallback is the ViewportScrollCallback managed
+    // by this class.
+    // TODO(bokan): Temporarily needed to allow ScrollCustomization to
+    // differentiate between real custom callback and the built-in viewport
+    // apply scroll. crbug.com/623079.
+    bool isViewportScrollCallback(
+        const ScrollStateCallback*) const override;
+
+protected:
+    TopDocumentRootScrollerController(Document&);
+
+    // Ensures the effective root scroller is currently valid and replaces it
+    // with the default if not.
+    void updateEffectiveRootScroller() override;
+
+private:
+    // Ensures that the element that should be used as the root scroller on the
+    // page has the m_viewportApplyScroll callback set on it.
+    void setViewportApplyScrollOnRootScroller();
+
+    // The apply-scroll callback that moves top controls and produces
+    // overscroll effects. This class makes sure this callback is set on the
+    // appropriate root scroller element.
+    Member<ViewportScrollCallback> m_viewportApplyScroll;
+
+    // Tracks which element currently has the m_viewportApplyScroll set to it.
+    WeakMember<Element> m_currentViewportApplyScrollHost;
+};
+
+} // namespace blink
+
+#endif // RootScrollerController_h