MainFrame scrollbars should work with RFV instead of FV

third_party/WebKit/Source/core/frame/FrameView.cpp

 /*
  * Copyright (C) 1998, 1999 Torben Weis <weis@kde.org>
  *                     1999 Lars Knoll <knoll@kde.org>
  *                     1999 Antti Koivisto <koivisto@kde.org>
  *                     2000 Dirk Mueller <mueller@kde.org>
  * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
  *           (C) 2006 Graham Dennis (graham.dennis@gmail.com)
  *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)
  * Copyright (C) 2009 Google Inc. All rights reserved.
  *
@@ skipping 413 matching lines @@
   if (!scrollbar)
     return;
 
   m_scrollableArea->willRemoveScrollbar(*scrollbar, orientation);
   m_scrollableArea->layoutBox()->document().view()->removeChild(
       scrollbar.get());
   scrollbar->disconnectFromScrollableArea();
   scrollbar = nullptr;
 }
 
+ScrollableArea* FrameView::ScrollbarManager::scrollableArea() const {
+  return m_scrollableArea.get();
+}
+
+void FrameView::ScrollbarManager::updateScrollbarGeometry(IntSize viewSize) {
+  if (!hasHorizontalScrollbar() && !hasVerticalScrollbar())
+    return;
+
+  bool scrollbarOnLeft = m_scrollableArea->shouldPlaceVerticalScrollbarOnLeft();
+
+  if (hasHorizontalScrollbar()) {
+    int thickness = m_hBar->scrollbarThickness();
+    IntRect oldRect(m_hBar->frameRect());
+    IntRect hBarRect(
+        (scrollbarOnLeft && hasVerticalScrollbar()) ? m_vBar->width() : 0,
+        viewSize.height() - thickness,
+        viewSize.width() - (hasVerticalScrollbar() ? m_vBar->width() : 0),
+        thickness);
+    m_hBar->setFrameRect(hBarRect);
+    if (oldRect != m_hBar->frameRect())
+      m_scrollableArea->setScrollbarNeedsPaintInvalidation(HorizontalScrollbar);
+
+    int visibleWidth = m_scrollableArea->visibleWidth();
+    int contentsWidth = m_scrollableArea->contentsSize().width();
+    m_hBar->setEnabled(contentsWidth > visibleWidth &&
+                       !m_scrollableArea->scrollbarsHidden());
+    m_hBar->setProportion(visibleWidth, contentsWidth);
+    m_hBar->offsetDidChange();
+  }
+
+  if (hasVerticalScrollbar()) {
+    int thickness = m_vBar->scrollbarThickness();
+    IntRect oldRect(m_vBar->frameRect());
+    IntRect vBarRect(
+        scrollbarOnLeft ? 0 : (viewSize.width() - thickness), 0, thickness,
+        viewSize.height() - (hasHorizontalScrollbar() ? m_hBar->height() : 0));
+    m_vBar->setFrameRect(vBarRect);
+    if (oldRect != m_vBar->frameRect())
+      m_scrollableArea->setScrollbarNeedsPaintInvalidation(VerticalScrollbar);
+
+    int clientHeight = m_scrollableArea->visibleHeight();
+    int contentsHeight = m_scrollableArea->contentsSize().height();
+    m_vBar->setEnabled(contentsHeight > clientHeight &&
+                       !m_scrollableArea->scrollbarsHidden());
+    m_vBar->setProportion(clientHeight, contentsHeight);
+    m_vBar->offsetDidChange();
+  }
+}
+
 void FrameView::recalculateCustomScrollbarStyle() {
   bool didStyleChange = false;
   if (horizontalScrollbar() && horizontalScrollbar()->isCustomScrollbar()) {
     horizontalScrollbar()->styleChanged();
     didStyleChange = true;
   }
   if (verticalScrollbar() && verticalScrollbar()->isCustomScrollbar()) {
     verticalScrollbar()->styleChanged();
     didStyleChange = true;
   }
   if (didStyleChange) {
-    updateScrollbarGeometry();
+    m_scrollbarManager.updateScrollbarGeometry(size());
     updateScrollCorner();
     positionScrollbarLayers();
   }
 }
 
 void FrameView::invalidateAllCustomScrollbarsOnActiveChanged() {
   bool usesWindowInactiveSelector =
       m_frame->document()->styleEngine().usesWindowInactiveSelector();
 
   const ChildrenWidgetSet* viewChildren = children();
@@ skipping 326 matching lines @@
 
   bool hasHorizontalScrollbar = horizontalScrollbar();
   bool hasVerticalScrollbar = verticalScrollbar();
   if (hasHorizontalScrollbar != shouldHaveHorizontalScrollbar ||
       hasVerticalScrollbar != shouldHaveVerticalScrollbar) {
     setNeedsLayout();
     return;
   }
 
   adjustViewSize();
-  updateScrollbarGeometry();
+  m_scrollbarManager.updateScrollbarGeometry(size());
 
   if (scrollOriginChanged())
     setNeedsLayout();
 }
 
 bool FrameView::usesCompositedScrolling() const {
   LayoutViewItem layoutView = this->layoutViewItem();
   if (layoutView.isNull())
     return false;
   if (m_frame->settings() &&
@@ skipping 1595 matching lines @@
 
   return ScrollableArea::shouldUseIntegerScrollOffset();
 }
 
 bool FrameView::isActive() const {
   Page* page = frame().page();
   return page && page->focusController().isActive();
 }
 
 void FrameView::invalidatePaintForTickmarks() {
-  if (Scrollbar* scrollbar = verticalScrollbar())
+  if (Scrollbar* scrollbar = getScrollableArea()->verticalScrollbar())
     scrollbar->setNeedsPaintInvalidation(
         static_cast<ScrollbarPart>(~ThumbPart));
 }
 
+void FrameView::setTickmarks(const Vector<IntRect>& tickmarks) {
+  // Tickmarks for main frame are stored in RFV.

[skobes, 2016/11/09 23:18:25]

Why do we need to store tickmarks in RFV?  Tickmarks aren't really a
ScrollableArea concept, it seems like we can leave them on FrameView.

[ymalik, 2016/11/10 17:58:04]

I had to do this to make a test pass with root layer scrolling, but we don't
actually need it.

Why I had it: 

setTickmarks has callers that only call it on FV (frameView->setStickmarks)

getTickmarks is currently only called from Scrollbar.cpp (it does
m_scroller->getTickmarks()).

In this CL, m_scroller can be RFV. Calling layoutViewport().getTickmarks() from
RFV didn't work for root layer scrolling (and causes test failures). This is
because setTickmarks would set it on FV, and getTickmarks would get called on
RFV which would in turn call it on PLSA. So I had to store the tickmarks in RFV.

I guess for now, calling FV's getTickmarks from PLSA makes the test pass. I have
a todo there to figure out tickmarks for root layer scrolling.

[skobes, 2016/11/10 18:41:28]

Why can't RFV call getTickmarks() on the FV?

[ymalik, 2016/11/10 21:05:21]

I believe RFV doesn't have access to FV. It relays all the calls through
layoutViewport (so doesn't work for root layer scrolling).

We can pass in FV, but I got rid of this bit and it looks cleaner now.

+  if (m_frame->isMainFrame())
+    m_viewportScrollableArea->setTickmarks(tickmarks);
+  else
+    m_tickmarks = tickmarks;
+
+  invalidatePaintForTickmarks();
+}
+
 void FrameView::getTickmarks(Vector<IntRect>& tickmarks) const {
   if (!m_tickmarks.isEmpty())
     tickmarks = m_tickmarks;
   else
     tickmarks = frame().document()->markers().renderedRectsForMarkers(
         DocumentMarker::TextMatch);
 }
 
 void FrameView::setInputEventsTransformForEmulation(const IntSize& offset,
                                                     float contentScaleFactor) {
@@ skipping 12 matching lines @@
 
 bool FrameView::scrollbarsCanBeActive() const {
   if (m_frame->view() != this)
     return false;
 
   return !!m_frame->document();
 }
 
 void FrameView::scrollbarVisibilityChanged() {
   // Scrollbar enabled state is set from updateScrollbarGeometry.
-  updateScrollbarGeometry();
+  m_scrollbarManager.updateScrollbarGeometry(size());
   LayoutViewItem viewItem = layoutViewItem();
   if (!viewItem.isNull())
     viewItem.clearHitTestCache();
 }
 
 IntRect FrameView::scrollableAreaBoundingBox() const {
   LayoutPartItem ownerLayoutItem = frame().ownerLayoutItem();
   if (ownerLayoutItem.isNull())
     return frameRect();
 
@@ skipping 112 matching lines @@
 
   if (m_frame->isMainFrame()) {
     ScrollableArea& visualViewport = frameHost->visualViewport();
     ScrollableArea* layoutViewport = layoutViewportScrollableArea();
     DCHECK(layoutViewport);
 
     RootFrameViewport* rootFrameViewport =
         RootFrameViewport::create(visualViewport, *layoutViewport);
     m_viewportScrollableArea = rootFrameViewport;
 
+    // TODO(crbug.com/661236): Currently for the main frame, the scroller that
+    // the scrollbar manager works with is RootFrameViewport which is needed so
+    // that the visual viewport is taken into account when determining scrollbar
+    // extent and existence. Eventually, each scroller should have its own
+    // scrollbar manager and we shouldn't set the scroller here.
+    m_scrollbarManager.setScroller(rootFrameViewport);
+
     frameHost->globalRootScrollerController().initializeViewportScrollCallback(
         *rootFrameViewport);
   }
 }
 
 void FrameView::updateScrollCorner() {
   RefPtr<ComputedStyle> cornerStyle;
   IntRect cornerRect = scrollCornerRect();
   Document* doc = m_frame->document();
 
@@ skipping 1113 matching lines @@
   if (frame().isMainFrame())
     frame().host()->chromeClient().mainFrameScrollOffsetChanged();
 }
 
 void FrameView::clearScrollAnchor() {
   if (!RuntimeEnabledFeatures::scrollAnchoringEnabled())
     return;
   m_scrollAnchor.clear();
 }
 
-bool FrameView::hasOverlayScrollbars() const {
-  return (horizontalScrollbar() &&
-          horizontalScrollbar()->isOverlayScrollbar()) ||
-         (verticalScrollbar() && verticalScrollbar()->isOverlayScrollbar());
-}
-
 void FrameView::computeScrollbarExistence(
     bool& newHasHorizontalScrollbar,
     bool& newHasVerticalScrollbar,
     const IntSize& docSize,
     ComputeScrollbarExistenceOption option) const {
   if (m_frame->settings() && m_frame->settings()->hideScrollbars()) {
     newHasHorizontalScrollbar = false;
     newHasVerticalScrollbar = false;
     return;
   }
@@ skipping 12 matching lines @@
 
   if (hScroll != ScrollbarAuto)
     newHasHorizontalScrollbar = (hScroll == ScrollbarAlwaysOn);
   if (vScroll != ScrollbarAuto)
     newHasVerticalScrollbar = (vScroll == ScrollbarAlwaysOn);
 
   if (m_scrollbarsSuppressed ||
       (hScroll != ScrollbarAuto && vScroll != ScrollbarAuto))
     return;
 
+  ScrollableArea* scroller = m_scrollbarManager.scrollableArea();
   if (hScroll == ScrollbarAuto)
-    newHasHorizontalScrollbar = docSize.width() > visibleWidth();
+    newHasHorizontalScrollbar = docSize.width() > scroller->visibleWidth();
   if (vScroll == ScrollbarAuto)
-    newHasVerticalScrollbar = docSize.height() > visibleHeight();
+    newHasVerticalScrollbar = docSize.height() > scroller->visibleHeight();
 
   if (hasOverlayScrollbars())
     return;
 
-  IntSize fullVisibleSize = visibleContentRect(IncludeScrollbars).size();
+  IntSize fullVisibleSize =
+      scroller->visibleContentRect(IncludeScrollbars).size();
 
   bool attemptToRemoveScrollbars =
       (option == FirstPass && docSize.width() <= fullVisibleSize.width() &&
        docSize.height() <= fullVisibleSize.height());
   if (attemptToRemoveScrollbars) {
     if (hScroll == ScrollbarAuto)
       newHasHorizontalScrollbar = false;
     if (vScroll == ScrollbarAuto)
       newHasVerticalScrollbar = false;
   }
 }
 
-void FrameView::updateScrollbarGeometry() {
-  if (horizontalScrollbar()) {
-    int thickness = horizontalScrollbar()->scrollbarThickness();
-    int clientWidth = visibleWidth();
-    IntRect oldRect(horizontalScrollbar()->frameRect());
-    IntRect hBarRect(
-        (shouldPlaceVerticalScrollbarOnLeft() && verticalScrollbar())
-            ? verticalScrollbar()->width()
-            : 0,
-        height() - thickness,
-        width() - (verticalScrollbar() ? verticalScrollbar()->width() : 0),
-        thickness);
-    horizontalScrollbar()->setFrameRect(hBarRect);
-    if (oldRect != horizontalScrollbar()->frameRect())
-      setScrollbarNeedsPaintInvalidation(HorizontalScrollbar);
-
-    horizontalScrollbar()->setEnabled(contentsWidth() > clientWidth &&
-                                      !scrollbarsHidden());
-    horizontalScrollbar()->setProportion(clientWidth, contentsWidth());
-    horizontalScrollbar()->offsetDidChange();
-  }
-
-  if (verticalScrollbar()) {
-    int thickness = verticalScrollbar()->scrollbarThickness();
-    int clientHeight = visibleHeight();
-    IntRect oldRect(verticalScrollbar()->frameRect());
-    IntRect vBarRect(
-        shouldPlaceVerticalScrollbarOnLeft() ? 0 : (width() - thickness), 0,
-        thickness,
-        height() -
-            (horizontalScrollbar() ? horizontalScrollbar()->height() : 0));
-    verticalScrollbar()->setFrameRect(vBarRect);
-    if (oldRect != verticalScrollbar()->frameRect())
-      setScrollbarNeedsPaintInvalidation(VerticalScrollbar);
-
-    verticalScrollbar()->setEnabled(contentsHeight() > clientHeight &&
-                                    !scrollbarsHidden());
-    verticalScrollbar()->setProportion(clientHeight, contentsHeight());
-    verticalScrollbar()->offsetDidChange();
-  }
-}
-
 bool FrameView::adjustScrollbarExistence(
     ComputeScrollbarExistenceOption option) {
   ASSERT(m_inUpdateScrollbars);
 
   // If we came in here with the view already needing a layout, then go ahead
   // and do that first.  (This will be the common case, e.g., when the page
   // changes due to window resizing for example).  This layout will not re-enter
   // updateScrollbars and does not count towards our max layout pass total.
   if (!m_scrollbarsSuppressed)
     scrollbarExistenceDidChange();
@@ skipping 78 matching lines @@
   int maxUpdateScrollbarsPass =
       hasOverlayScrollbars() || m_scrollbarsSuppressed ? 1 : 3;
   for (int updateScrollbarsPass = 0;
        updateScrollbarsPass < maxUpdateScrollbarsPass; updateScrollbarsPass++) {
     if (!adjustScrollbarExistence(updateScrollbarsPass ? Incremental
                                                        : FirstPass))
       break;
     scrollbarExistenceChanged = true;
   }
 
-  updateScrollbarGeometry();
+  m_scrollbarManager.updateScrollbarGeometry(size());
 
   if (scrollbarExistenceChanged) {
     // FIXME: Is frameRectsChanged really necessary here? Have any frame rects
     // changed?
     frameRectsChanged();
     positionScrollbarLayers();
     updateScrollCorner();
   }
 
   adjustScrollOffsetFromUpdateScrollbars();
@@ skipping 616 matching lines @@
   DCHECK(m_frame->isMainFrame());
   return m_initialViewportSize.width();
 }
 
 int FrameView::initialViewportHeight() const {
   DCHECK(m_frame->isMainFrame());
   return m_initialViewportSize.height();
 }
 
 }  // namespace blink