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 412 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_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_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 1581 matching lines @@
   Page* page = frame().page();
   return page && page->focusController().isActive();
 }
 
 void FrameView::invalidatePaintForTickmarks() {
   if (Scrollbar* scrollbar = verticalScrollbar())
     scrollbar->setNeedsPaintInvalidation(
         static_cast<ScrollbarPart>(~ThumbPart));
 }
 
+void FrameView::setTickmarks(const Vector<IntRect>& tickmarks) {
+  // Tickmarks for main frame are stored in RFV.
+  if (m_frame->isMainFrame())

[bokan, 2016/11/03 19:59:59]

You'll need a similar check in getTickmarks.

[ymalik, 2016/11/04 18:54:17]

So RFV::getTickmarks calls layoutViewport().getTickmarks(). If we do the main
frame check here, we will be stuck in an infinite loop. getTickmarks is only
called from Scrollbar.cpp and this should just work since the scrollbar has the
correct ScrollableArea. 

The reason we have to call layoutViewport().getTickmarks from RFV is because RFV
doesn't have a reference to frame().document() and we can't return the default
markers from it.

The reason we have to save tickmarks in RFV (instead of just calling
layoutViewport().getTickmarks()) is because root layer scrolls has PLSA as its
layoutViewport.

+    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 143 matching lines @@
 
   if (m_frame->isMainFrame()) {
     ScrollableArea& visualViewport = frameHost->visualViewport();
     ScrollableArea* layoutViewport = layoutViewportScrollableArea();
     DCHECK(layoutViewport);
 
     RootFrameViewport* rootFrameViewport =
         RootFrameViewport::create(visualViewport, *layoutViewport);
     m_viewportScrollableArea = rootFrameViewport;
 
+    m_scrollbarManager.setScroller(rootFrameViewport);
+
     frameHost->globalRootScrollerController().initializeViewportScrollCallback(
         *rootFrameViewport);
   }
 }
 
 void FrameView::updateScrollCorner() {
   RefPtr<ComputedStyle> cornerStyle;
   IntRect cornerRect = scrollCornerRect();
   Document* doc = m_frame->document();
 
@@ skipping 1124 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 82 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