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 395 matching lines @@
   if (!scrollbar)
     return;
 
   m_scrollableArea->willRemoveScrollbar(*scrollbar, orientation);
   m_scrollableArea->layoutBox()->document().view()->removeChild(
       scrollbar.get());
   scrollbar->disconnectFromScrollableArea();
   scrollbar = nullptr;
 }
 
+bool FrameView::ScrollbarManager::needScrollbar(
+    ScrollbarOrientation orientation,
+    const IntSize& docSize,
+    ComputeScrollbarExistenceOption option) const {
+  bool needScrollbar =
+      orientation == HorizontalScrollbar
+          ? docSize.width() > m_scrollableArea->visibleWidth()
+          : docSize.height() > m_scrollableArea->visibleHeight();
+
+  if (m_scrollableArea->hasOverlayScrollbars())
+    return needScrollbar;
+
+  // Will the content fit iff there are no scrollbars.
+  IntSize fullVisibleSize =
+      m_scrollableArea->visibleContentRect(IncludeScrollbars).size();
+  bool needNewScrollbar = orientation == HorizontalScrollbar
+                              ? docSize.width() <= fullVisibleSize.width()
+                              : docSize.height() <= fullVisibleSize.height();
+  if (option == FirstPass && needNewScrollbar)
+    needScrollbar = false;
+
+  return needScrollbar;
+}
+
+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 313 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 1580 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())
+    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 1119 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;
 
-  if (hScroll == ScrollbarAuto)
-    newHasHorizontalScrollbar = docSize.width() > visibleWidth();
-  if (vScroll == ScrollbarAuto)
-    newHasVerticalScrollbar = docSize.height() > visibleHeight();
-
-  if (hasOverlayScrollbars())
-    return;
-
-  IntSize fullVisibleSize = 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;
+  if (hScroll == ScrollbarAuto) {
+    newHasHorizontalScrollbar =
+        m_scrollbarManager.needScrollbar(HorizontalScrollbar, docSize, option);
+  }
+  if (vScroll == ScrollbarAuto) {
+    newHasVerticalScrollbar =
+        m_scrollbarManager.needScrollbar(VerticalScrollbar, docSize, option);
   }
 }
 
-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);
-    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);
-    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 668 matching lines @@
   DCHECK(m_frame->isMainFrame());
   return m_initialViewportSize.width();
 }
 
 int FrameView::initialViewportHeight() const {
   DCHECK(m_frame->isMainFrame());
   return m_initialViewportSize.height();
 }
 
 }  // namespace blink