Make TopDocumentRootScrollerController store Page instead of FrameHost

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/frame/PageScaleConstraintsSet.h"
 #include "core/frame/VisualViewport.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/layout/LayoutView.h"
 #include "core/layout/compositing/PaintLayerCompositor.h"
 #include "core/page/ChromeClient.h"
 #include "core/page/Page.h"
 #include "core/page/scrolling/OverscrollController.h"
 #include "core/page/scrolling/RootScrollerUtil.h"
 #include "core/page/scrolling/ViewportScrollCallback.h"
 #include "core/paint/PaintLayer.h"
 #include "platform/scroll/ScrollableArea.h"
 
 namespace blink {
 
 // static
 TopDocumentRootScrollerController* TopDocumentRootScrollerController::create(
-    FrameHost& host) {
-  return new TopDocumentRootScrollerController(host);
+    Page& page) {
+  return new TopDocumentRootScrollerController(page);
 }
 
-TopDocumentRootScrollerController::TopDocumentRootScrollerController(
-    FrameHost& host)
-    : m_frameHost(&host) {}
+TopDocumentRootScrollerController::TopDocumentRootScrollerController(Page& page)
+    : m_page(&page) {}
 
 DEFINE_TRACE(TopDocumentRootScrollerController) {
   visitor->trace(m_viewportApplyScroll);
   visitor->trace(m_globalRootScroller);
-  visitor->trace(m_frameHost);
+  visitor->trace(m_page);
 }
 
 void TopDocumentRootScrollerController::didChangeRootScroller() {
   recomputeGlobalRootScroller();
 }
 
 void TopDocumentRootScrollerController::mainFrameViewResized() {
   Element* rootScroller = globalRootScroller();
 
   ScrollableArea* area =
@@ skipping 13 matching lines @@
 }
 
 ScrollableArea* TopDocumentRootScrollerController::rootScrollerArea() const {
   return RootScrollerUtil::scrollableAreaForRootScroller(globalRootScroller());
 }
 
 IntSize TopDocumentRootScrollerController::rootScrollerVisibleArea() const {
   if (!topDocument() || !topDocument()->view())
     return IntSize();
 
-  float minimumPageScale =
-      m_frameHost->pageScaleConstraintsSet().finalConstraints().minimumScale;
+  float minimumPageScale = m_page->frameHost()
+                               .pageScaleConstraintsSet()
+                               .finalConstraints()
+                               .minimumScale;
   int browserControlsAdjustment =
-      ceilf(m_frameHost->visualViewport().browserControlsAdjustment() /
+      ceilf(m_page->frameHost().visualViewport().browserControlsAdjustment() /
             minimumPageScale);
 
   return topDocument()->view()->visibleContentSize(ExcludeScrollbars) +
          IntSize(0, browserControlsAdjustment);
 }
 
 Element* TopDocumentRootScrollerController::findGlobalRootScrollerElement() {
   if (!topDocument())
     return nullptr;
 
@@ skipping 72 matching lines @@
 
   // The scrollers may need to stop using their own scrollbars as Android
   // Chrome's VisualViewport provides the scrollbars for the root scroller.
   if (oldRootScrollerArea)
     oldRootScrollerArea->didChangeGlobalRootScroller();
 
   targetScroller->didChangeGlobalRootScroller();
 }
 
 Document* TopDocumentRootScrollerController::topDocument() const {
-  if (!m_frameHost)
+  if (!m_page)
     return nullptr;
 
-  if (!m_frameHost->page().mainFrame() ||
-      !m_frameHost->page().mainFrame()->isLocalFrame())
+  if (!m_page->frameHost().page().mainFrame() ||
+      !m_page->frameHost().page().mainFrame()->isLocalFrame())
     return nullptr;
 
-  return toLocalFrame(m_frameHost->page().mainFrame())->document();
+  return toLocalFrame(m_page->frameHost().page().mainFrame())->document();

[joelhockey, 2017/03/08 04:36:00]

I think these references of m_page->frameHost.page() could just be m_page

From what I can see, m_page and m_page->frameHost.page() are always the same.
I see that Page constructs a FrameHost with this
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/core/page/Page...
And then within FrameHost, page is not modified
https://cs.chromium.org/chromium/src/third_party/WebKit/Source/core/frame/Fra...

Could the whole method be:

return m_page && m_page->mainFrame() && m_page->mainFrame().isLocalFrame()
  ? m_page->mainFrame()->document() : nullptr; 

[sashab, 2017/03/08 05:02:37]

Oh yeah, great catch! Fixed here and below, thanks.

 }
 
 void TopDocumentRootScrollerController::
     setNeedsCompositingInputsUpdateOnGlobalRootScroller() {
   if (!m_globalRootScroller)
     return;
 
   PaintLayer* layer = m_globalRootScroller->document()
                           .rootScrollerController()
                           .rootScrollerPaintLayer();
 
   if (layer)
     layer->setNeedsCompositingInputsUpdate();
 
   if (LayoutView* view = m_globalRootScroller->document().layoutView()) {
     view->compositor()->setNeedsCompositingUpdate(CompositingUpdateRebuildTree);
   }
 }
 
 void TopDocumentRootScrollerController::didUpdateCompositing() {
-  if (!m_frameHost)
+  if (!m_page)
     return;
 
   // Let the compositor-side counterpart know about this change.
-  m_frameHost->page().chromeClient().registerViewportLayers();
+  m_page->frameHost().page().chromeClient().registerViewportLayers();
 }
 
 void TopDocumentRootScrollerController::didDisposeScrollableArea(
     ScrollableArea& area) {
   if (!topDocument() || !topDocument()->view())
     return;
 
   // If the document is tearing down, we may no longer have a layoutViewport to
   // fallback to.
   if (topDocument()->lifecycle().state() >= DocumentLifecycle::Stopping)
     return;
 
   FrameView* frameView = topDocument()->view();
 
   RootFrameViewport* rfv = frameView->getRootFrameViewport();
 
   if (&area == &rfv->layoutViewport()) {
     DCHECK(frameView->layoutViewportScrollableArea());
     rfv->setLayoutViewport(*frameView->layoutViewportScrollableArea());
   }
 }
 
 void TopDocumentRootScrollerController::initializeViewportScrollCallback(
     RootFrameViewport& rootFrameViewport) {
-  DCHECK(m_frameHost);
+  DCHECK(m_page);
   m_viewportApplyScroll = ViewportScrollCallback::create(
-      &m_frameHost->browserControls(), &m_frameHost->overscrollController(),
-      rootFrameViewport);
+      &m_page->frameHost().browserControls(),
+      &m_page->frameHost().overscrollController(), rootFrameViewport);
 
   recomputeGlobalRootScroller();
 }
 
 bool TopDocumentRootScrollerController::isViewportScrollCallback(
     const ScrollStateCallback* callback) const {
   if (!callback)
     return false;
 
   return callback == m_viewportApplyScroll.get();
@@ skipping 17 matching lines @@
 
 PaintLayer* TopDocumentRootScrollerController::rootScrollerPaintLayer() const {
   return RootScrollerUtil::paintLayerForRootScroller(m_globalRootScroller);
 }
 
 Element* TopDocumentRootScrollerController::globalRootScroller() const {
   return m_globalRootScroller.get();
 }
 
 }  // namespace blink