Calculate paint invalidation rect for scrollbars

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 364 matching lines @@
     setScrollbarsSuppressed(true);
 }
 
 bool FrameView::didFirstLayout() const
 {
     return !m_firstLayout;
 }
 
 void FrameView::invalidateRect(const IntRect& rect)
 {
-    // For querying PaintLayer::compositingState() when invalidating scrollbars.
-    // FIXME: do all scrollbar invalidations after layout of all frames is complete. It's currently not recursively true.
-    DisableCompositingQueryAsserts disabler;
     if (!parent()) {
         if (HostWindow* window = hostWindow())
             window->invalidateRect(rect);
         return;
     }
 
     LayoutPart* layoutObject = m_frame->ownerLayoutObject();
     if (!layoutObject)
         return;
 
     IntRect paintInvalidationRect = rect;
     paintInvalidationRect.move(layoutObject->borderLeft() + layoutObject->paddingLeft(),
         layoutObject->borderTop() + layoutObject->paddingTop());
     // FIXME: We should not allow paint invalidation out of paint invalidation state. crbug.com/457415
     DisablePaintInvalidationStateAsserts paintInvalidationAssertDisabler;
-    layoutObject->invalidatePaintRectangle(LayoutRect(paintInvalidationRect));
+    layoutObject->invalidatePaintRectangleNotInvalidatingDisplayItemClients(LayoutRect(paintInvalidationRect));
 }
 
 void FrameView::setFrameRect(const IntRect& newRect)
 {
     IntRect oldRect = frameRect();
     if (newRect == oldRect)
         return;
 
     Widget::setFrameRect(newRect);
 
@@ skipping 562 matching lines @@
                 m_lastZoomFactor = layoutView()->style()->zoom();
 
                 // Set the initial vMode to AlwaysOn if we're auto.
                 if (vMode == ScrollbarAuto)
                     setVerticalScrollbarMode(ScrollbarAlwaysOn); // This causes a vertical scrollbar to appear.
                 // Set the initial hMode to AlwaysOff if we're auto.
                 if (hMode == ScrollbarAuto)
                     setHorizontalScrollbarMode(ScrollbarAlwaysOff); // This causes a horizontal scrollbar to disappear.
 
                 setScrollbarModes(hMode, vMode);
-                setScrollbarsSuppressed(false, true);
+                setScrollbarsSuppressed(false);
             } else if (hMode != currentHMode || vMode != currentVMode) {
                 setScrollbarModes(hMode, vMode);
             }
 
             if (needsScrollbarReconstruction())
                 updateScrollbars(scrollOffsetDouble());
 
             LayoutSize oldSize = m_size;
 
             m_size = LayoutSize(layoutSize().width(), layoutSize().height());
@@ skipping 53 matching lines @@
         return;
 
 #if ENABLE(ASSERT)
     // Post-layout assert that nobody was re-marked as needing layout during layout.
     layoutView()->assertSubtreeIsLaidOut();
 #endif
 
     frame().document()->layoutUpdated();
 }
 
-// The plan is to move to compositor-queried paint invalidation, in which case this
-// method would setNeedsRedraw on the GraphicsLayers with invalidations and
-// let the compositor pick which to actually draw.
-// See http://crbug.com/306706
 void FrameView::invalidateTreeIfNeeded(PaintInvalidationState& paintInvalidationState)
 {
     if (shouldThrottleRendering())
         return;
 
     lifecycle().advanceTo(DocumentLifecycle::InPaintInvalidation);
 
     ASSERT(layoutView());
     LayoutView& rootForPaintInvalidation = *layoutView();
     ASSERT(!rootForPaintInvalidation.needsLayout());
 
     TRACE_EVENT1("blink", "FrameView::invalidateTree", "root", rootForPaintInvalidation.debugName().ascii());
 
     rootForPaintInvalidation.invalidateTreeIfNeeded(paintInvalidationState);
 
-    // Invalidate the paint of the frameviews scrollbars if needed
-    if (hasVerticalBarDamage())
-        invalidateRect(verticalBarDamage());
-    if (hasHorizontalBarDamage())
-        invalidateRect(horizontalBarDamage());
-    resetScrollbarDamage();
+
+    if (!m_frame->settings() || !m_frame->settings()->rootLayerScrolls()) {
+        paintInvalidationState.setViewClippingAndScrollOffsetDisabled(true);
+        invalidatePaintOfScrollControlsIfNeeded(rootForPaintInvalidation, paintInvalidationState, paintInvalidationState.paintInvalidationContainer(), m_scrollCorner, nullptr);

[chrishtr, 2015/11/17 00:35:47]

How about just passing a null pointer for PaintInvalidationState here instead of
adding a parameter to it? I don't think keeping it has an efficiency gain if I'm
reading correctly, because it it is nulled out when recursing from LayoutView
into the parent frame.

[Xianzhu, 2015/11/17 00:56:05]

For now the only purpose of the paintInvalidationState here is to let
LayoutView::mapRectToPaintInvalidationBacking() not clip and scroll the rect.

+        paintInvalidationState.setViewClippingAndScrollOffsetDisabled(false);
+    }
 
 #if ENABLE(ASSERT)
     layoutView()->assertSubtreeClearedPaintInvalidationState();
 #endif
 
     if (m_frame->selection().isCaretBoundsDirty())
         m_frame->selection().invalidateCaretRect();
 
     m_doFullPaintInvalidation = false;
     lifecycle().advanceTo(DocumentLifecycle::PaintInvalidationClean);
@@ skipping 401 matching lines @@
 {
     Page* page = frame().page();
     if (!page)
         return;
     FloatSize elasticOverscroll = page->chromeClient().elasticOverscroll();
     if (m_horizontalScrollbar) {
         float delta = elasticOverscroll.width() - m_horizontalScrollbar->elasticOverscroll();
         if (delta != 0) {
             m_horizontalScrollbar->setElasticOverscroll(elasticOverscroll.width());
             scrollAnimator()->notifyContentAreaScrolled(FloatSize(delta, 0));
-            if (!m_scrollbarsSuppressed)
-                m_horizontalScrollbar->invalidate();
+            setScrollbarNeedsPaintInvalidation(m_horizontalScrollbar.get());
         }
     }
     if (m_verticalScrollbar) {
         float delta = elasticOverscroll.height() - m_verticalScrollbar->elasticOverscroll();
         if (delta != 0) {
             m_verticalScrollbar->setElasticOverscroll(elasticOverscroll.height());
             scrollAnimator()->notifyContentAreaScrolled(FloatSize(0, delta));
-            if (!m_scrollbarsSuppressed)
-                m_verticalScrollbar->invalidate();
+            setScrollbarNeedsPaintInvalidation(m_verticalScrollbar.get());
         }
     }
 }
 
 IntSize FrameView::layoutSize(IncludeScrollbarsInRect scrollbarInclusion) const
 {
     return scrollbarInclusion == ExcludeScrollbars ? excludeScrollbars(m_layoutSize) : m_layoutSize;
 }
 
 void FrameView::setLayoutSize(const IntSize& size)
@@ skipping 543 matching lines @@
 
     if (!scrollbarsSuppressed())
         m_pendingScrollDelta += scrollDelta;
 
     clearScrollAnchor();
     updateLayersAndCompositingAfterScrollIfNeeded();
     scrollPositionChanged();
     frame().loader().client()->didChangeScrollOffset();
 }
 
-void FrameView::invalidatePaintForTickmarks() const
+void FrameView::invalidatePaintForTickmarks()
 {
     if (Scrollbar* scrollbar = verticalScrollbar())
-        scrollbar->invalidate();
-}
-
-void FrameView::invalidateScrollbarRect(Scrollbar* scrollbar, const IntRect& rect)
-{
-    // Add in our offset within the FrameView.
-    IntRect dirtyRect = rect;
-    dirtyRect.moveBy(scrollbar->location());
-
-    layoutView()->invalidateDisplayItemClient(*scrollbar);
-
-    if (isInPerformLayout())
-        addScrollbarDamage(scrollbar, rect);
-    else
-        invalidateRect(dirtyRect);
+        setScrollbarNeedsPaintInvalidation(scrollbar);
 }
 
 void FrameView::getTickmarks(Vector<IntRect>& tickmarks) const
 {
     if (!m_tickmarks.isEmpty())
         tickmarks = m_tickmarks;
     else
         tickmarks = frame().document()->markers().renderedRectsForMarkers(DocumentMarker::TextMatch);
 }
 
@@ skipping 179 matching lines @@
             // If we have an owning ipage/LocalFrame element, then it can set the custom scrollbar also.
             if (LayoutPart* layoutObject = m_frame->ownerLayoutObject())
                 cornerStyle = layoutObject->getUncachedPseudoStyle(PseudoStyleRequest(SCROLLBAR_CORNER), layoutObject->style());
         }
     }
 
     if (cornerStyle) {
         if (!m_scrollCorner)
             m_scrollCorner = LayoutScrollbarPart::createAnonymous(doc);
         m_scrollCorner->setStyle(cornerStyle.release());
-        invalidateScrollCorner(cornerRect);
+        setScrollCornerNeedsPaintInvalidation();
     } else if (m_scrollCorner) {
         m_scrollCorner->destroy();
         m_scrollCorner = nullptr;
     }
 }
 
 Color FrameView::documentBackgroundColor() const
 {
     // <https://bugs.webkit.org/show_bug.cgi?id=59540> We blend the background color of
     // the document and the body against the base background color of the frame view.
@@ skipping 690 matching lines @@
 {
     if (hasBar == !!m_horizontalScrollbar)
         return;
 
     if (hasBar) {
         m_horizontalScrollbar = createScrollbar(HorizontalScrollbar);
         addChild(m_horizontalScrollbar.get());
         didAddScrollbar(m_horizontalScrollbar.get(), HorizontalScrollbar);
         m_horizontalScrollbar->styleChanged();
     } else {
-        willRemoveScrollbar(m_horizontalScrollbar.get(), HorizontalScrollbar);
+        willRemoveScrollbar(*layoutView(), m_horizontalScrollbar.get(), HorizontalScrollbar);
         if (AXObjectCache* cache = axObjectCache())
             cache->remove(m_horizontalScrollbar.get());
         // If the scrollbar has been marked as overlapping the window resizer,
         // then its removal should reduce the count.
         if (m_horizontalScrollbar->overlapsResizer())
             adjustScrollbarsAvoidingResizerCount(-1);
         removeChild(m_horizontalScrollbar.get());
         m_horizontalScrollbar->disconnectFromScrollableArea();
         m_horizontalScrollbar = nullptr;
         if (AXObjectCache* cache = axObjectCache())
             cache->handleScrollbarUpdate(this);
     }
 
-    invalidateScrollCorner(scrollCornerRect());
+    setScrollCornerNeedsPaintInvalidation();
 }
 
 void FrameView::setHasVerticalScrollbar(bool hasBar)
 {
     if (hasBar == !!m_verticalScrollbar)
         return;
 
     if (hasBar) {
         m_verticalScrollbar = createScrollbar(VerticalScrollbar);
         addChild(m_verticalScrollbar.get());
         didAddScrollbar(m_verticalScrollbar.get(), VerticalScrollbar);
         m_verticalScrollbar->styleChanged();
     } else {
-        willRemoveScrollbar(m_verticalScrollbar.get(), VerticalScrollbar);
+        willRemoveScrollbar(*layoutView(), m_verticalScrollbar.get(), VerticalScrollbar);
         if (AXObjectCache* cache = axObjectCache())
             cache->remove(m_verticalScrollbar.get());
         // If the scrollbar has been marked as overlapping the window resizer,
         // then its removal should reduce the count.
         if (m_verticalScrollbar->overlapsResizer())
             adjustScrollbarsAvoidingResizerCount(-1);
         removeChild(m_verticalScrollbar.get());
         m_verticalScrollbar->disconnectFromScrollableArea();
         m_verticalScrollbar = nullptr;
         if (AXObjectCache* cache = axObjectCache())
             cache->handleScrollbarUpdate(this);
     }
 
-    invalidateScrollCorner(scrollCornerRect());
+    setScrollCornerNeedsPaintInvalidation();
 }
 
 void FrameView::setScrollbarModes(ScrollbarMode horizontalMode, ScrollbarMode verticalMode,
     bool horizontalLock, bool verticalLock)
 {
     bool needsUpdate = false;
 
     // If the page's overflow setting has disabled scrolling, do not allow anything to override that setting.
     // http://crbug.com/426447
     LayoutObject* viewport = viewportLayoutObject();
@@ skipping 146 matching lines @@
 void FrameView::updateScrollbarGeometry()
 {
     if (m_horizontalScrollbar) {
         int clientWidth = visibleWidth();
         IntRect oldRect(m_horizontalScrollbar->frameRect());
         IntRect hBarRect((shouldPlaceVerticalScrollbarOnLeft() && m_verticalScrollbar) ? m_verticalScrollbar->width() : 0,
             height() - m_horizontalScrollbar->height(),
             width() - (m_verticalScrollbar ? m_verticalScrollbar->width() : 0),
             m_horizontalScrollbar->height());
         m_horizontalScrollbar->setFrameRect(adjustScrollbarRectForResizer(hBarRect, m_horizontalScrollbar.get()));
-        if (!m_scrollbarsSuppressed && oldRect != m_horizontalScrollbar->frameRect())
-            m_horizontalScrollbar->invalidate();
+        if (oldRect != m_horizontalScrollbar->frameRect())
+            setScrollbarNeedsPaintInvalidation(m_horizontalScrollbar.get());
 
-        if (m_scrollbarsSuppressed)
-            m_horizontalScrollbar->setSuppressInvalidation(true);
         m_horizontalScrollbar->setEnabled(contentsWidth() > clientWidth);
         m_horizontalScrollbar->setProportion(clientWidth, contentsWidth());
         m_horizontalScrollbar->offsetDidChange();
-        if (m_scrollbarsSuppressed)
-            m_horizontalScrollbar->setSuppressInvalidation(false);
     }
 
     if (m_verticalScrollbar) {
         int clientHeight = visibleHeight();
         IntRect oldRect(m_verticalScrollbar->frameRect());
         IntRect vBarRect(shouldPlaceVerticalScrollbarOnLeft() ? 0 : (width() - m_verticalScrollbar->width()),
             0,
             m_verticalScrollbar->width(),
             height() - (m_horizontalScrollbar ? m_horizontalScrollbar->height() : 0));
         m_verticalScrollbar->setFrameRect(adjustScrollbarRectForResizer(vBarRect, m_verticalScrollbar.get()));
-        if (!m_scrollbarsSuppressed && oldRect != m_verticalScrollbar->frameRect())
-            m_verticalScrollbar->invalidate();
+        if (oldRect != m_verticalScrollbar->frameRect())
+            setScrollbarNeedsPaintInvalidation(m_verticalScrollbar.get());
 
-        if (m_scrollbarsSuppressed)
-            m_verticalScrollbar->setSuppressInvalidation(true);
         m_verticalScrollbar->setEnabled(contentsHeight() > clientHeight);
         m_verticalScrollbar->setProportion(clientHeight, contentsHeight());
         m_verticalScrollbar->offsetDidChange();
-        if (m_scrollbarsSuppressed)
-            m_verticalScrollbar->setSuppressInvalidation(false);
     }
 }
 
 IntRect FrameView::adjustScrollbarRectForResizer(const IntRect& rect, Scrollbar* scrollbar)
 {
     // Get our window resizer rect and see if we overlap. Adjust to avoid the overlap
     // if necessary.
     IntRect adjustedRect(rect);
     bool overlapsResizer = false;
     if (!rect.isEmpty() && !windowResizerRect().isEmpty()) {
@@ skipping 82 matching lines @@
         setHasHorizontalScrollbar(false);
         setHasVerticalScrollbar(false);
         setScrollOffsetFromUpdateScrollbars(desiredOffset);
         return;
     }
 
     if (m_inUpdateScrollbars)
         return;
     InUpdateScrollbarsScope inUpdateScrollbarsScope(this);
 
-    IntSize oldVisibleSize = visibleContentSize();
-
     bool scrollbarExistenceChanged = false;
 
     if (needsScrollbarReconstruction()) {
         setHasHorizontalScrollbar(false);
         setHasVerticalScrollbar(false);
         scrollbarExistenceChanged = true;
     }
 
     int maxUpdateScrollbarsPass = hasOverlayScrollbars() || m_scrollbarsSuppressed ? 1 : 3;
     for (int updateScrollbarsPass = 0; updateScrollbarsPass < maxUpdateScrollbarsPass; updateScrollbarsPass++) {
         if (!adjustScrollbarExistence(updateScrollbarsPass ? Incremental : FirstPass))
             break;
         scrollbarExistenceChanged = true;
     }
 
     updateScrollbarGeometry();
 
     if (scrollbarExistenceChanged) {
         // FIXME: Is frameRectsChanged really necessary here? Have any frame rects changed?
         frameRectsChanged();
         positionScrollbarLayers();
         updateScrollCorner();
     }
 
-    // FIXME: We don't need to do this if we are composited.
-    IntSize newVisibleSize = visibleContentSize();
-    if (newVisibleSize.width() > oldVisibleSize.width()) {
-        if (shouldPlaceVerticalScrollbarOnLeft())
-            invalidateRect(IntRect(0, 0, newVisibleSize.width() - oldVisibleSize.width(), newVisibleSize.height()));
-        else
-            invalidateRect(IntRect(oldVisibleSize.width(), 0, newVisibleSize.width() - oldVisibleSize.width(), newVisibleSize.height()));
-    }
-    if (newVisibleSize.height() > oldVisibleSize.height())
-        invalidateRect(IntRect(0, oldVisibleSize.height(), newVisibleSize.width(), newVisibleSize.height() - oldVisibleSize.height()));
-
     setScrollOffsetFromUpdateScrollbars(desiredOffset);
 }
 
 void FrameView::setScrollOffsetFromUpdateScrollbars(const DoubleSize& offset)
 {
     DoublePoint adjustedScrollPosition = clampScrollPosition(DoublePoint(offset));
 
     if (adjustedScrollPosition != scrollPositionDouble() || scrollOriginChanged()) {
         ScrollableArea::setScrollPosition(adjustedScrollPosition, ProgrammaticScroll);
         resetScrollOriginChanged();
@@ skipping 160 matching lines @@
     } else if (!scrollbarsSuppressed()) {
         // If we went from n to 0 or from 0 to n and we're the outermost view,
         // we need to invalidate the windowResizerRect(), since it will now need to paint
         // differently.
         if ((oldCount > 0 && m_scrollbarsAvoidingResizer == 0)
             || (oldCount == 0 && m_scrollbarsAvoidingResizer > 0))
             invalidateRect(windowResizerRect());
     }
 }
 
-void FrameView::setScrollbarsSuppressed(bool suppressed, bool repaintOnUnsuppress)
-{
-    if (suppressed == m_scrollbarsSuppressed)
-        return;
-
-    m_scrollbarsSuppressed = suppressed;
-
-    if (repaintOnUnsuppress && !suppressed) {
-        if (m_horizontalScrollbar)
-            m_horizontalScrollbar->invalidate();
-        if (m_verticalScrollbar)
-            m_verticalScrollbar->invalidate();
-
-        // Invalidate the scroll corner too on unsuppress.
-        invalidateScrollCorner(scrollCornerRect());
-    }
-}
-
 Scrollbar* FrameView::scrollbarAtRootFramePoint(const IntPoint& pointInRootFrame)
 {
     IntPoint pointInFrame = convertFromContainingWindow(pointInRootFrame);
     return scrollbarAtFramePoint(pointInFrame);
 }
 
 Scrollbar* FrameView::scrollbarAtFramePoint(const IntPoint& pointInFrame)
 {
     if (m_horizontalScrollbar && m_horizontalScrollbar->shouldParticipateInHitTesting() && m_horizontalScrollbar->frameRect().contains(pointInFrame))
         return m_horizontalScrollbar.get();
@@ skipping 99 matching lines @@
     }
 
     return cornerRect;
 }
 
 bool FrameView::isScrollCornerVisible() const
 {
     return !scrollCornerRect().isEmpty();
 }
 
-void FrameView::invalidateScrollCornerRect(const IntRect& rect)
-{
-    invalidateRect(rect);
-    if (m_scrollCorner)
-        layoutView()->invalidateDisplayItemClientForNonCompositingDescendantsOf(*m_scrollCorner);
-}
-
 ScrollBehavior FrameView::scrollBehaviorStyle() const
 {
     Element* scrollElement = m_frame->document()->scrollingElement();
     LayoutObject* layoutObject = scrollElement ? scrollElement->layoutObject() : nullptr;
     if (layoutObject && layoutObject->style()->scrollBehavior() == ScrollBehaviorSmooth)
         return ScrollBehaviorSmooth;
 
     return ScrollBehaviorInstant;
 }
 
@@ skipping 315 matching lines @@
 }
 
 bool FrameView::canThrottleRendering() const
 {
     if (!RuntimeEnabledFeatures::renderingPipelineThrottlingEnabled())
         return false;
     return m_hiddenForThrottling && m_crossOriginForThrottling;
 }
 
 } // namespace blink