Refactor PLSA scrollbar existence calculation.

third_party/WebKit/Source/core/paint/PaintLayerScrollableArea.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012 Apple Inc. All rights
  * reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@gmail.com>
@@ skipping 649 matching lines @@
   bool scrollbarsAreFrozen =
       m_inOverflowRelayout || FreezeScrollbarsScope::scrollbarsAreFrozen();
 
   if (needsScrollbarReconstruction()) {
     setHasHorizontalScrollbar(false);
     setHasVerticalScrollbar(false);
   }
 
   updateScrollDimensions();
 
-  bool hasHorizontalOverflow = this->hasHorizontalOverflow();
-  bool hasVerticalOverflow = this->hasVerticalOverflow();
+  bool hadHorizontalScrollbar = hasHorizontalScrollbar();
+  bool hadVerticalScrollbar = hasVerticalScrollbar();
 
-  // Don't add auto scrollbars if the box contents aren't visible.
-  bool shouldHaveAutoHorizontalScrollbar =
-      hasHorizontalOverflow && box().pixelSnappedClientHeight();
-  bool shouldHaveAutoVerticalScrollbar =
-      hasVerticalOverflow && box().pixelSnappedClientWidth();
+  bool needsHorizontalScrollbar;
+  bool needsVerticalScrollbar;
+  computeScrollbarExistence(needsHorizontalScrollbar, needsVerticalScrollbar);
 
-  {
-    // Hits in
-    // compositing/overflow/automatically-opt-into-composited-scrolling-after-style-change.html.
-    DisableCompositingQueryAsserts disabler;
+  bool horizontalScrollbarShouldChange =
+      needsHorizontalScrollbar != hadHorizontalScrollbar;
+  bool verticalScrollbarShouldChange =
+      needsVerticalScrollbar != hadVerticalScrollbar;
 
-    // overflow:scroll should just enable/disable.
-    if (box().style()->overflowX() == OverflowScroll && horizontalScrollbar())
-      horizontalScrollbar()->setEnabled(hasHorizontalOverflow);
-    if (box().style()->overflowY() == OverflowScroll && verticalScrollbar())
-      verticalScrollbar()->setEnabled(hasVerticalOverflow);
-  }
-
-  // We need to layout again if scrollbars are added or removed by
-  // overflow:auto, or by changing between native and custom.
-  DCHECK(box().frame()->settings());
-  bool horizontalScrollbarShouldChange =
-      ((box().hasAutoHorizontalScrollbar() &&
-        (hasHorizontalScrollbar() != shouldHaveAutoHorizontalScrollbar)) ||
-       (box().style()->overflowX() == OverflowScroll &&
-        !horizontalScrollbar())) &&
-      (!box().frame()->settings()->hideScrollbars() ||
-       hasHorizontalScrollbar());
-  bool verticalScrollbarShouldChange =
-      ((box().hasAutoVerticalScrollbar() &&
-        (hasVerticalScrollbar() != shouldHaveAutoVerticalScrollbar)) ||
-       (box().style()->overflowY() == OverflowScroll &&
-        !verticalScrollbar())) &&
-      (!box().frame()->settings()->hideScrollbars() || hasVerticalScrollbar());
   bool scrollbarsWillChange =
-      !scrollbarsAreFrozen && !visualViewportSuppliesScrollbars() &&
+      !scrollbarsAreFrozen &&
       (horizontalScrollbarShouldChange || verticalScrollbarShouldChange);
-
   if (scrollbarsWillChange) {
-    bool hadHorizontalScrollbar = hasHorizontalScrollbar();
-    bool hadVerticalScrollbar = hasVerticalScrollbar();
-    if (box().hasAutoHorizontalScrollbar())
-      setHasHorizontalScrollbar(shouldHaveAutoHorizontalScrollbar);
-    else if (box().style()->overflowX() == OverflowScroll)
-      setHasHorizontalScrollbar(true);
-    if (box().hasAutoVerticalScrollbar())
-      setHasVerticalScrollbar(shouldHaveAutoVerticalScrollbar);
-    else if (box().style()->overflowY() == OverflowScroll)
-      setHasVerticalScrollbar(true);
+    setHasHorizontalScrollbar(needsHorizontalScrollbar);
+    setHasVerticalScrollbar(needsVerticalScrollbar);
 
     if (hasScrollbar())
       updateScrollCornerStyle();
 
     layer()->updateSelfPaintingLayer();
 
     // Force an update since we know the scrollbars have changed things.
     if (box().document().hasAnnotatedRegions())
       box().document().setAnnotatedRegionsDirty(true);
 
@@ skipping 34 matching lines @@
       if (parent && parent->isFlexibleBox())
         toLayoutFlexibleBox(parent)->clearCachedMainSizeForChild(box());
     }
   }
 
   {
     // Hits in
     // compositing/overflow/automatically-opt-into-composited-scrolling-after-style-change.html.
     DisableCompositingQueryAsserts disabler;
 
+    // overflow:scroll should just enable/disable.
+    if (box().style()->overflowX() == OverflowScroll && horizontalScrollbar())
+      horizontalScrollbar()->setEnabled(hasHorizontalOverflow());
+    if (box().style()->overflowY() == OverflowScroll && verticalScrollbar())
+      verticalScrollbar()->setEnabled(hasVerticalOverflow());
+
     // Set up the range (and page step/line step).
     if (Scrollbar* horizontalScrollbar = this->horizontalScrollbar()) {
       int clientWidth = box().pixelSnappedClientWidth();
       horizontalScrollbar->setProportion(clientWidth,
                                          overflowRect().width().toInt());
     }
     if (Scrollbar* verticalScrollbar = this->verticalScrollbar()) {
       int clientHeight = box().pixelSnappedClientHeight();
       verticalScrollbar->setProportion(clientHeight,
                                        overflowRect().height().toInt());
     }
   }
 
   if (!scrollbarsAreFrozen && hasOverlayScrollbars()) {
     if (!scrollSize(HorizontalScrollbar))
       setHasHorizontalScrollbar(false);
     if (!scrollSize(VerticalScrollbar))
       setHasVerticalScrollbar(false);
   }
 
   clampScrollOffsetsAfterLayout();
 
   if (!scrollbarsAreFrozen) {
-    bool hasOverflow =
-        hasScrollableHorizontalOverflow() || hasScrollableVerticalOverflow();
-    updateScrollableAreaSet(hasOverflow);
+    updateScrollableAreaSet(hasScrollableHorizontalOverflow() ||
+                            hasScrollableVerticalOverflow());
   }
 
   DisableCompositingQueryAsserts disabler;
   positionOverflowControls();
 }
 
 void PaintLayerScrollableArea::clampScrollOffsetsAfterLayout() {
   // If a vertical scrollbar was removed, the min/max scroll offsets may have
   // changed, so the scroll offsets needs to be clamped.  If the scroll offset
   // did not change, but the scroll origin *did* change, we still need to notify
@@ skipping 49 matching lines @@
 }
 
 bool PaintLayerScrollableArea::hasScrollableHorizontalOverflow() const {
   return hasHorizontalOverflow() && box().scrollsOverflowX();
 }
 
 bool PaintLayerScrollableArea::hasScrollableVerticalOverflow() const {
   return hasVerticalOverflow() && box().scrollsOverflowY();
 }
 
-static bool overflowRequiresScrollbar(EOverflow overflow) {
-  return overflow == OverflowScroll;
-}
-
-static bool overflowDefinesAutomaticScrollbar(EOverflow overflow) {
-  return overflow == OverflowAuto || overflow == OverflowOverlay;
-}
-
 // This function returns true if the given box requires overflow scrollbars (as
 // opposed to the 'viewport' scrollbars managed by the PaintLayerCompositor).
 // FIXME: we should use the same scrolling machinery for both the viewport and
 // overflow. Currently, we need to avoid producing scrollbars here if they'll be
 // handled externally in the RLC.
 static bool canHaveOverflowScrollbars(const LayoutBox& box) {
   return (RuntimeEnabledFeatures::rootLayerScrollingEnabled() ||
           !box.isLayoutView()) &&
          box.document().viewportDefiningElement() != box.node();
 }
 
 void PaintLayerScrollableArea::updateAfterStyleChange(
     const ComputedStyle* oldStyle) {
   // Don't do this on first style recalc, before layout has ever happened.
-  if (!overflowRect().size().isZero())
+  if (!overflowRect().size().isZero()) {
     updateScrollableAreaSet(hasScrollableHorizontalOverflow() ||
                             hasScrollableVerticalOverflow());
-
-  if (!canHaveOverflowScrollbars(box()))
-    return;
-
-  // Avoid drawing two sets of scrollbars when one is provided by the visual
-  // viewport.
-  if (visualViewportSuppliesScrollbars()) {
-    setHasHorizontalScrollbar(false);
-    setHasVerticalScrollbar(false);
-    return;
   }
 
-  EOverflow overflowX = box().style()->overflowX();
-  EOverflow overflowY = box().style()->overflowY();
+  bool needsHorizontalScrollbar;
+  bool needsVerticalScrollbar;
+  // We add auto scrollbars only during layout to prevent spurious activations.
+  computeScrollbarExistence(needsHorizontalScrollbar, needsVerticalScrollbar,
+                            ForbidAddingAutoBars);
 
-  bool needsHorizontalScrollbar =
-      (hasHorizontalScrollbar() &&
-       overflowDefinesAutomaticScrollbar(overflowX)) ||
-      overflowRequiresScrollbar(overflowX);
-  bool needsVerticalScrollbar =
-      (hasVerticalScrollbar() &&
-       overflowDefinesAutomaticScrollbar(overflowY)) ||
-      overflowRequiresScrollbar(overflowY);
-
-  // Look for the scrollbarModes and reset the needs Horizontal & vertical
-  // Scrollbar values based on scrollbarModes, as during force style change
-  // StyleResolver::styleForDocument returns documentStyle with  no overflow
-  // values, due to which we are destorying the scrollbars that was already
-  // present.
-  if (box().isLayoutView()) {
-    if (LocalFrame* frame = box().frame()) {
-      if (FrameView* frameView = frame->view()) {
-        ScrollbarMode hMode;
-        ScrollbarMode vMode;
-        frameView->calculateScrollbarModes(hMode, vMode);
-        if (hMode == ScrollbarAlwaysOn && !needsHorizontalScrollbar)
-          needsHorizontalScrollbar = true;
-        if (vMode == ScrollbarAlwaysOn && !needsVerticalScrollbar)
-          needsVerticalScrollbar = true;
-      }
-    }
-  }
+  // Avoid some unnecessary computation if there were and will be no scrollbars.
+  if (!hasScrollbar() && !needsHorizontalScrollbar && !needsVerticalScrollbar)
+    return;
 
   setHasHorizontalScrollbar(needsHorizontalScrollbar);
   setHasVerticalScrollbar(needsVerticalScrollbar);
 
   // With overflow: scroll, scrollbars are always visible but may be disabled.
   // When switching to another value, we need to re-enable them (see bug 11985).
   if (hasHorizontalScrollbar() && oldStyle &&
-      oldStyle->overflowX() == OverflowScroll && overflowX != OverflowScroll) {
+      oldStyle->overflowX() == OverflowScroll &&
+      box().style()->overflowX() != OverflowScroll) {
     horizontalScrollbar()->setEnabled(true);
   }
 
   if (hasVerticalScrollbar() && oldStyle &&
-      oldStyle->overflowY() == OverflowScroll && overflowY != OverflowScroll) {
+      oldStyle->overflowY() == OverflowScroll &&
+      box().style()->overflowY() != OverflowScroll) {
     verticalScrollbar()->setEnabled(true);
   }
 
   // FIXME: Need to detect a swap from custom to native scrollbars (and vice
   // versa).
   if (horizontalScrollbar())
     horizontalScrollbar()->styleChanged();
   if (verticalScrollbar())
     verticalScrollbar()->styleChanged();
 
@@ skipping 30 matching lines @@
     int clientWidth = box().pixelSnappedClientWidth();
     horizontalScrollbar->setProportion(clientWidth,
                                        overflowRect().width().toInt());
   }
   if (Scrollbar* verticalScrollbar = this->verticalScrollbar()) {
     int clientHeight = box().pixelSnappedClientHeight();
     verticalScrollbar->setProportion(clientHeight,
                                      overflowRect().height().toInt());
   }
 
-  bool hasHorizontalOverflow = this->hasHorizontalOverflow();
-  bool hasVerticalOverflow = this->hasVerticalOverflow();
-  bool autoHorizontalScrollbarChanged =
-      box().hasAutoHorizontalScrollbar() &&
-      (hasHorizontalScrollbar() != hasHorizontalOverflow);
-  bool autoVerticalScrollbarChanged =
-      box().hasAutoVerticalScrollbar() &&
-      (hasVerticalScrollbar() != hasVerticalOverflow);
-  if (autoHorizontalScrollbarChanged || autoVerticalScrollbarChanged)
+  bool needsHorizontalScrollbar;
+  bool needsVerticalScrollbar;
+  computeScrollbarExistence(needsHorizontalScrollbar, needsVerticalScrollbar);
+
+  bool horizontalScrollbarShouldChange =
+      needsHorizontalScrollbar != hasHorizontalScrollbar();
+  bool verticalScrollbarShouldChange =
+      needsVerticalScrollbar != hasVerticalScrollbar();
+
+  if ((box().hasAutoHorizontalScrollbar() && horizontalScrollbarShouldChange) ||
+      (box().hasAutoVerticalScrollbar() && verticalScrollbarShouldChange)) {
     box().setNeedsLayoutAndFullPaintInvalidation(
         LayoutInvalidationReason::Unknown);
+  }
 }
 
 IntRect PaintLayerScrollableArea::rectForHorizontalScrollbar(
     const IntRect& borderBoxRect) const {
   if (!hasHorizontalScrollbar())
     return IntRect();
 
   const IntRect& scrollCorner = scrollCornerRect();
 
   return IntRect(horizontalScrollbarStart(borderBoxRect.x()),
@@ skipping 112 matching lines @@
     if (actualLayoutObject !=
         toLayoutScrollbar(verticalScrollbar())->owningLayoutObject())
       didCustomScrollbarOwnerChanged = true;
   }
 
   return hasAnyScrollbar &&
          ((shouldUseCustom != hasCustom) ||
           (shouldUseCustom && didCustomScrollbarOwnerChanged));
 }
 
+void PaintLayerScrollableArea::computeScrollbarExistence(
+    bool& needsHorizontalScrollbar,
+    bool& needsVerticalScrollbar,
+    ComputeScrollbarExistenceOption option) const {
+  // Scrollbars may be hidden or provided by visual viewport or frame instead.
+  DCHECK(box().frame()->settings());
+  if (visualViewportSuppliesScrollbars() || !canHaveOverflowScrollbars(box()) ||
+      box().frame()->settings()->hideScrollbars()) {
+    needsHorizontalScrollbar = false;
+    needsVerticalScrollbar = false;
+    return;
+  }
+
+  needsHorizontalScrollbar = box().scrollsOverflowX();
+  needsVerticalScrollbar = box().scrollsOverflowY();
+
+  // Don't add auto scrollbars if the box contents aren't visible.
+  if (box().hasAutoHorizontalScrollbar()) {
+    if (option == ForbidAddingAutoBars)
+      needsHorizontalScrollbar &= hasHorizontalScrollbar();
+    needsHorizontalScrollbar &= box().isRooted() &&
+                                this->hasHorizontalOverflow() &&
+                                box().pixelSnappedClientHeight();
+  }
+
+  if (box().hasAutoVerticalScrollbar()) {
+    if (option == ForbidAddingAutoBars)
+      needsVerticalScrollbar &= hasVerticalScrollbar();
+    needsVerticalScrollbar &= box().isRooted() && this->hasVerticalOverflow() &&
+                              box().pixelSnappedClientWidth();
+  }
+
+  // Look for the scrollbarModes and reset the needs Horizontal & vertical
+  // Scrollbar values based on scrollbarModes, as during force style change
+  // StyleResolver::styleForDocument returns documentStyle with no overflow
+  // values, due to which we are destroying the scrollbars that were already
+  // present.
+  if (box().isLayoutView()) {
+    if (LocalFrame* frame = box().frame()) {
+      if (FrameView* frameView = frame->view()) {
+        ScrollbarMode hMode;
+        ScrollbarMode vMode;
+        frameView->calculateScrollbarModes(hMode, vMode);
+        if (hMode == ScrollbarAlwaysOn)
+          needsHorizontalScrollbar = true;
+        if (vMode == ScrollbarAlwaysOn)
+          needsVerticalScrollbar = true;
+      }
+    }
+  }
+}
+
 void PaintLayerScrollableArea::setHasHorizontalScrollbar(bool hasScrollbar) {
   if (FreezeScrollbarsScope::scrollbarsAreFrozen())
     return;
 
-  DCHECK(box().frame()->settings());
-  if (box().frame()->settings()->hideScrollbars())
-    hasScrollbar = false;
-
   if (hasScrollbar == hasHorizontalScrollbar())
     return;
 
   setScrollbarNeedsPaintInvalidation(HorizontalScrollbar);
 
   m_scrollbarManager.setHasHorizontalScrollbar(hasScrollbar);
 
   updateScrollOrigin();
 
   // Destroying or creating one bar can cause our scrollbar corner to come and
   // go. We need to update the opposite scrollbar's style.
   if (hasHorizontalScrollbar())
     horizontalScrollbar()->styleChanged();
   if (hasVerticalScrollbar())
     verticalScrollbar()->styleChanged();
 
   setScrollCornerNeedsPaintInvalidation();
 
   // Force an update since we know the scrollbars have changed things.
   if (box().document().hasAnnotatedRegions())
     box().document().setAnnotatedRegionsDirty(true);
 }
 
 void PaintLayerScrollableArea::setHasVerticalScrollbar(bool hasScrollbar) {
   if (FreezeScrollbarsScope::scrollbarsAreFrozen())
     return;
 
-  DCHECK(box().frame()->settings());
-  if (box().frame()->settings()->hideScrollbars())
-    hasScrollbar = false;
-
   if (hasScrollbar == hasVerticalScrollbar())
     return;
 
   setScrollbarNeedsPaintInvalidation(VerticalScrollbar);
 
   m_scrollbarManager.setHasVerticalScrollbar(hasScrollbar);
 
   updateScrollOrigin();
 
   // Destroying or creating one bar can cause our scrollbar corner to come and
@@ skipping 790 matching lines @@
 
 void PaintLayerScrollableArea::DelayScrollOffsetClampScope::
     clampScrollableAreas() {
   for (auto& scrollableArea : *s_needsClamp)
     scrollableArea->clampScrollOffsetsAfterLayout();
   delete s_needsClamp;
   s_needsClamp = nullptr;
 }
 
 }  // namespace blink