Conditionally create PaintLayer's scrollable area object

third_party/WebKit/Source/core/layout/LayoutBox.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  *           (C) 1999 Antti Koivisto (koivisto@kde.org)
  *           (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
  *           (C) 2005, 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Adobe Systems Incorporated. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
@@ skipping 237 matching lines @@
                 markOrthogonalWritingModeRoot();
             else
                 unmarkOrthogonalWritingModeRoot();
         }
 
         clearPercentHeightDescendants();
     }
 
     // If our zoom factor changes and we have a defined scrollLeft/Top, we need to adjust that value into the
     // new zoomed coordinate space.
-    if (hasOverflowClip() && oldStyle && oldStyle->effectiveZoom() != newStyle.effectiveZoom() && layer()) {
-        if (int left = layer()->scrollableArea()->scrollXOffset()) {
+    if (hasOverflowClip() && oldStyle && oldStyle->effectiveZoom() != newStyle.effectiveZoom()) {
+        PaintLayerScrollableArea* scrollableArea = this->scrollableArea();
+        ASSERT(scrollableArea);
+        if (int left = scrollableArea->scrollXOffset()) {
             left = (left / oldStyle->effectiveZoom()) * newStyle.effectiveZoom();
-            layer()->scrollableArea()->scrollToXOffset(left);
+            scrollableArea->scrollToXOffset(left);
         }
-        if (int top = layer()->scrollableArea()->scrollYOffset()) {
+        if (int top = scrollableArea->scrollYOffset()) {
             top = (top / oldStyle->effectiveZoom()) * newStyle.effectiveZoom();
-            layer()->scrollableArea()->scrollToYOffset(top);
+            scrollableArea->scrollToYOffset(top);
         }
     }
 
     // Our opaqueness might have changed without triggering layout.
     if (diff.needsPaintInvalidation()) {
         LayoutObject* parentToInvalidate = parent();
         for (unsigned i = 0; i < backgroundObscurationTestMaxDepth && parentToInvalidate; ++i) {
             parentToInvalidate->invalidateBackgroundObscurationStatus();
             parentToInvalidate = parentToInvalidate->parent();
         }
@@ skipping 93 matching lines @@
     // It should be possible to not dirty the grid in some cases (like moving an explicitly placed grid item).
     // For now, it's more simple to just always recompute the grid.
     toLayoutGrid(parent())->dirtyGrid();
 }
 
 void LayoutBox::updateFromStyle()
 {
     LayoutBoxModelObject::updateFromStyle();
 
     const ComputedStyle& styleToUse = styleRef();
-    bool isViewObject = isLayoutView();
-    bool rootLayerScrolls = document().settings() && document().settings()->rootLayerScrolls();
-
-    // LayoutView of the main frame is resposible from painting base background.
-    if (isViewObject && !document().ownerElement())
-        setHasBoxDecorationBackground(true);

[Xianzhu, 2016/02/26 20:12:57]

BTW the above three lines are moved into LayoutView::updateFromStyle().

-
     setFloating(!isOutOfFlowPositioned() && styleToUse.isFloating());
-
-    bool boxHasOverflowClip = false;
-    if (!styleToUse.isOverflowVisible() && isLayoutBlock() && (rootLayerScrolls || !isViewObject)) {
-        // If overflow has been propagated to the viewport, it has no effect here.
-        if (node() != document().viewportDefiningElement())
-            boxHasOverflowClip = true;
-    }
-
-    if (boxHasOverflowClip != hasOverflowClip()) {
-        // FIXME: This shouldn't be required if we tracked the visual overflow
-        // generated by positioned children or self painting layers. crbug.com/345403
-        for (LayoutObject* child = slowFirstChild(); child; child = child->nextSibling())
-            child->setMayNeedPaintInvalidation();
-    }
-
-    setHasOverflowClip(boxHasOverflowClip);
-
     setHasTransformRelatedProperty(styleToUse.hasTransformRelatedProperty());
     setHasReflection(styleToUse.boxReflect());
 }
 
 void LayoutBox::layout()
 {
     ASSERT(needsLayout());
     LayoutAnalyzer::Scope analyzer(*this);
 
     LayoutObject* child = slowFirstChild();
@@ skipping 40 matching lines @@
 }
 
 int LayoutBox::pixelSnappedOffsetHeight() const
 {
     return snapSizeToPixel(offsetHeight(), location().y() + clientTop());
 }
 
 LayoutUnit LayoutBox::scrollWidth() const
 {
     if (hasOverflowClip())
-        return layer()->scrollableArea()->scrollWidth();
+        return scrollableArea()->scrollWidth();
     // For objects with visible overflow, this matches IE.
     // FIXME: Need to work right with writing modes.
     if (style()->isLeftToRightDirection())
         return std::max(clientWidth(), layoutOverflowRect().maxX() - borderLeft());
     return clientWidth() - std::min(LayoutUnit(), layoutOverflowRect().x() - borderLeft());
 }
 
 LayoutUnit LayoutBox::scrollHeight() const
 {
     if (hasOverflowClip())
-        return layer()->scrollableArea()->scrollHeight();
+        return scrollableArea()->scrollHeight();
     // For objects with visible overflow, this matches IE.
     // FIXME: Need to work right with writing modes.
     return std::max(clientHeight(), layoutOverflowRect().maxY() - borderTop());
 }
 
 LayoutUnit LayoutBox::scrollLeft() const
 {
-    return hasOverflowClip() ? LayoutUnit(layer()->scrollableArea()->scrollXOffset()) : LayoutUnit();
+    return hasOverflowClip() ? LayoutUnit(scrollableArea()->scrollXOffset()) : LayoutUnit();
 }
 
 LayoutUnit LayoutBox::scrollTop() const
 {
-    return hasOverflowClip() ? LayoutUnit(layer()->scrollableArea()->scrollYOffset()) : LayoutUnit();
+    return hasOverflowClip() ? LayoutUnit(scrollableArea()->scrollYOffset()) : LayoutUnit();
 }
 
 int LayoutBox::pixelSnappedScrollWidth() const
 {
     return snapSizeToPixel(scrollWidth(), location().x() + clientLeft());
 }
 
 int LayoutBox::pixelSnappedScrollHeight() const
 {
     if (hasOverflowClip())
-        return snapSizeToPixel(layer()->scrollableArea()->scrollHeight(), location().y() + clientTop());
+        return snapSizeToPixel(scrollableArea()->scrollHeight(), location().y() + clientTop());
     // For objects with visible overflow, this matches IE.
     // FIXME: Need to work right with writing modes.
     return snapSizeToPixel(scrollHeight(), location().y() + clientTop());
 }
 
 void LayoutBox::setScrollLeft(LayoutUnit newLeft)
 {
     // This doesn't hit in any tests, but since the equivalent code in setScrollTop
     // does, presumably this code does as well.
     DisableCompositingQueryAsserts disabler;
 
     if (hasOverflowClip())
-        layer()->scrollableArea()->scrollToXOffset(newLeft, ScrollOffsetClamped, ScrollBehaviorAuto);
+        scrollableArea()->scrollToXOffset(newLeft, ScrollOffsetClamped, ScrollBehaviorAuto);
 }
 
 void LayoutBox::setScrollTop(LayoutUnit newTop)
 {
     // Hits in compositing/overflow/do-not-assert-on-invisible-composited-layers.html
     DisableCompositingQueryAsserts disabler;
 
     if (hasOverflowClip())
-        layer()->scrollableArea()->scrollToYOffset(newTop, ScrollOffsetClamped, ScrollBehaviorAuto);
+        scrollableArea()->scrollToYOffset(newTop, ScrollOffsetClamped, ScrollBehaviorAuto);
 }
 
 void LayoutBox::scrollToOffset(const DoubleSize& offset, ScrollBehavior scrollBehavior)
 {
     // This doesn't hit in any tests, but since the equivalent code in setScrollTop
     // does, presumably this code does as well.
     DisableCompositingQueryAsserts disabler;
 
     if (hasOverflowClip())
-        layer()->scrollableArea()->scrollToOffset(offset, ScrollOffsetClamped, scrollBehavior);
+        scrollableArea()->scrollToOffset(offset, ScrollOffsetClamped, scrollBehavior);
 }
 
 // Returns true iff we are attempting an autoscroll inside an iframe with scrolling="no".
 static bool isDisallowedAutoscroll(HTMLFrameOwnerElement* ownerElement, FrameView* frameView)
 {
     if (ownerElement && isHTMLFrameElementBase(*ownerElement)) {
         HTMLFrameElementBase* frameElementBase = toHTMLFrameElementBase(ownerElement);
         if (Page* page = frameView->frame().page()) {
             return page->autoscrollController().autoscrollInProgress()
                 && frameElementBase->scrollingMode() == ScrollbarAlwaysOff;
@@ skipping 13 matching lines @@
 
     bool restrictedByLineClamp = false;
     if (parent()) {
         parentBox = parent()->enclosingBox();
         restrictedByLineClamp = !parent()->style()->lineClamp().isNone();
     }
 
     if (hasOverflowClip() && !restrictedByLineClamp) {
         // Don't scroll to reveal an overflow layer that is restricted by the -webkit-line-clamp property.
         // This will prevent us from revealing text hidden by the slider in Safari RSS.
-        newRect = layer()->scrollableArea()->scrollIntoView(rect, alignX, alignY, scrollType);
+        newRect = scrollableArea()->scrollIntoView(rect, alignX, alignY, scrollType);
     } else if (!parentBox && canBeProgramaticallyScrolled()) {
         if (FrameView* frameView = this->frameView()) {
             HTMLFrameOwnerElement* ownerElement = document().ownerElement();
             if (!isDisallowedAutoscroll(ownerElement, frameView)) {
                 if (makeVisibleInVisualViewport) {
                     frameView->scrollableArea()->scrollIntoView(rect, alignX, alignY, scrollType);
                 } else {
                     frameView->layoutViewportScrollableArea()->scrollIntoView(rect, alignX, alignY, scrollType);
                 }
                 if (ownerElement && ownerElement->layoutObject()) {
@@ skipping 176 matching lines @@
         break;
     }
     return result;
 }
 
 int LayoutBox::verticalScrollbarWidth() const
 {
     if (!hasOverflowClip() || style()->overflowY() == OOVERLAY)
         return 0;
 
-    return layer()->scrollableArea()->verticalScrollbarWidth();
+    return scrollableArea()->verticalScrollbarWidth();
 }
 
 int LayoutBox::horizontalScrollbarHeight() const
 {
     if (!hasOverflowClip() || style()->overflowX() == OOVERLAY)
         return 0;
 
-    return layer()->scrollableArea()->horizontalScrollbarHeight();
+    return scrollableArea()->horizontalScrollbarHeight();
 }
 
 int LayoutBox::intrinsicScrollbarLogicalWidth() const
 {
     if (!hasOverflowClip())
         return 0;
 
+    ASSERT(scrollableArea());
+
     if (isHorizontalWritingMode() && style()->overflowY() == OSCROLL) {
-        ASSERT(layer()->scrollableArea());
         // Even with OSCROLL, the scrollbar may not exist (crbug.com/415031).
-        return layer()->scrollableArea()->hasVerticalScrollbar() ? verticalScrollbarWidth() : 0;
+        return scrollableArea()->hasVerticalScrollbar() ? verticalScrollbarWidth() : 0;
     }
 
     if (!isHorizontalWritingMode() && style()->overflowX() == OSCROLL) {
-        ASSERT(layer()->scrollableArea());
         // Even with OSCROLL, the scrollbar may not exist (crbug.com/415031).
-        return layer()->scrollableArea()->hasHorizontalScrollbar() ? horizontalScrollbarHeight() : 0;
+        return scrollableArea()->hasHorizontalScrollbar() ? horizontalScrollbarHeight() : 0;
     }
 
     return 0;
 }
 
 ScrollResultOneDimensional LayoutBox::scroll(ScrollDirectionPhysical direction, ScrollGranularity granularity, float delta)
 {
     // Presumably the same issue as in setScrollTop. See crbug.com/343132.
     DisableCompositingQueryAsserts disabler;
 
-    if (!layer() || !layer()->scrollableArea())
+    if (!scrollableArea())
         return ScrollResultOneDimensional(false);
 
-    return layer()->scrollableArea()->userScroll(direction, granularity, delta);
+    return scrollableArea()->userScroll(direction, granularity, delta);
 }
 
 bool LayoutBox::canBeScrolledAndHasScrollableArea() const
 {
     return canBeProgramaticallyScrolled() && (pixelSnappedScrollHeight() != pixelSnappedClientHeight() || pixelSnappedScrollWidth() != pixelSnappedClientWidth());
 }
 
 bool LayoutBox::canBeProgramaticallyScrolled() const
 {
     Node* node = this->node();
@@ skipping 123 matching lines @@
 void LayoutBox::scrollByRecursively(const DoubleSize& delta, ScrollOffsetClamping clamp)
 {
     if (delta.isZero())
         return;
 
     bool restrictedByLineClamp = false;
     if (parent())
         restrictedByLineClamp = !parent()->style()->lineClamp().isNone();
 
     if (hasOverflowClip() && !restrictedByLineClamp) {
-        DoubleSize newScrollOffset = layer()->scrollableArea()->adjustedScrollOffset() + delta;
-        layer()->scrollableArea()->scrollToOffset(newScrollOffset, clamp);
+        PaintLayerScrollableArea* scrollableArea = this->scrollableArea();
+        ASSERT(scrollableArea);
+
+        DoubleSize newScrollOffset = scrollableArea->adjustedScrollOffset() + delta;
+        scrollableArea->scrollToOffset(newScrollOffset, clamp);
 
         // If this layer can't do the scroll we ask the next layer up that can scroll to try
-        DoubleSize remainingScrollOffset = newScrollOffset - layer()->scrollableArea()->adjustedScrollOffset();
+        DoubleSize remainingScrollOffset = newScrollOffset - scrollableArea->adjustedScrollOffset();
         if (!remainingScrollOffset.isZero() && parent()) {
             if (LayoutBox* scrollableBox = enclosingScrollableBox())
                 scrollableBox->scrollByRecursively(remainingScrollOffset, clamp);
 
             LocalFrame* frame = this->frame();
             if (frame && frame->page())
                 frame->page()->autoscrollController().updateAutoscrollLayoutObject();
         }
     } else if (view()->frameView()) {
         // If we are here, we were called on a layoutObject that can be programmatically scrolled, but doesn't
         // have an overflow clip. Which means that it is a document node that can be scrolled.
         // FIXME: Pass in DoubleSize. crbug.com/414283.
         view()->frameView()->scrollBy(flooredIntSize(delta), UserScroll);
 
         // FIXME: If we didn't scroll the whole way, do we want to try looking at the frames ownerElement?
         // https://bugs.webkit.org/show_bug.cgi?id=28237
     }
 }
 
 bool LayoutBox::needsPreferredWidthsRecalculation() const
 {
     return style()->paddingStart().hasPercent() || style()->paddingEnd().hasPercent();
 }
 
 IntSize LayoutBox::scrolledContentOffset() const
 {
     ASSERT(hasOverflowClip());
     ASSERT(hasLayer());
     // FIXME: Return DoubleSize here. crbug.com/414283.
-    return flooredIntSize(layer()->scrollableArea()->scrollOffset());
+    return flooredIntSize(scrollableArea()->scrollOffset());
 }
 
 void LayoutBox::mapScrollingContentsRectToBoxSpace(LayoutRect& rect) const
 {
     ASSERT(hasLayer());
     ASSERT(hasOverflowClip());
 
     LayoutSize offset = LayoutSize(-scrolledContentOffset());
     if (UNLIKELY(hasFlippedBlocksWritingMode())) {
         if (isHorizontalWritingMode())
@@ skipping 565 matching lines @@
     clipRect.setLocation(location + clipRect.location() + LayoutSize(borderLeft(), borderTop()));
     clipRect.setSize(clipRect.size() - LayoutSize(borderLeft() + borderRight(), borderTop() + borderBottom()));
 
     if (hasOverflowClip())
         excludeScrollbars(clipRect, relevancy);
     return clipRect;
 }
 
 void LayoutBox::excludeScrollbars(LayoutRect& rect, OverlayScrollbarSizeRelevancy relevancy) const
 {
-    if (shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
-        rect.move(layer()->scrollableArea()->verticalScrollbarWidth(relevancy), 0);
-    rect.contract(layer()->scrollableArea()->verticalScrollbarWidth(relevancy), layer()->scrollableArea()->horizontalScrollbarHeight(relevancy));
+    if (PaintLayerScrollableArea* scrollableArea = this->scrollableArea()) {
+        if (shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
+            rect.move(scrollableArea->verticalScrollbarWidth(relevancy), 0);
+        rect.contract(scrollableArea->verticalScrollbarWidth(relevancy), scrollableArea->horizontalScrollbarHeight(relevancy));
+    }
 }
 
 LayoutRect LayoutBox::clipRect(const LayoutPoint& location) const
 {
     LayoutRect borderBoxRect = this->borderBoxRect();
     LayoutRect clipRect = LayoutRect(borderBoxRect.location() + location, borderBoxRect.size());
 
     if (!style()->clipLeft().isAuto()) {
         LayoutUnit c = valueForLength(style()->clipLeft(), borderBoxRect.width());
         clipRect.move(c, LayoutUnit());
@@ skipping 2176 matching lines @@
     return node && node->isElementNode() && (toElement(node)->isFormControlElement() || isHTMLImageElement(toElement(node)));
 }
 
 bool LayoutBox::avoidsFloats() const
 {
     return isAtomicInlineLevel() || shouldBeConsideredAsReplaced(node()) || hasOverflowClip() || isHR() || isLegend() || isWritingModeRoot() || isFlexItemIncludingDeprecated() || style()->containsPaint();
 }
 
 bool LayoutBox::hasNonCompositedScrollbars() const
 {
-    if (PaintLayer* layer = this->layer()) {
-        if (PaintLayerScrollableArea* scrollableArea = layer->scrollableArea()) {
-            if (scrollableArea->hasHorizontalScrollbar() && !scrollableArea->layerForHorizontalScrollbar())
-                return true;
-            if (scrollableArea->hasVerticalScrollbar() && !scrollableArea->layerForVerticalScrollbar())
-                return true;
-        }
+    if (PaintLayerScrollableArea* scrollableArea = this->scrollableArea()) {
+        if (scrollableArea->hasHorizontalScrollbar() && !scrollableArea->layerForHorizontalScrollbar())
+            return true;
+        if (scrollableArea->hasVerticalScrollbar() && !scrollableArea->layerForVerticalScrollbar())
+            return true;
     }
     return false;
 }
 
 PaintInvalidationReason LayoutBox::paintInvalidationReason(const LayoutBoxModelObject& paintInvalidationContainer,
     const LayoutRect& oldBounds, const LayoutPoint& oldLocation, const LayoutRect& newBounds, const LayoutPoint& newLocation) const
 {
     PaintInvalidationReason invalidationReason = LayoutBoxModelObject::paintInvalidationReason(paintInvalidationContainer, oldBounds, oldLocation, newBounds, newLocation);
     if (isFullPaintInvalidationReason(invalidationReason))
         return invalidationReason;
@@ skipping 901 matching lines @@
 }
 
 void LayoutBox::IntrinsicSizingInfo::transpose()
 {
     size = size.transposedSize();
     aspectRatio = aspectRatio.transposedSize();
     std::swap(hasWidth, hasHeight);
 }
 
 } // namespace blink