Remove RenderLayerScrollableArea

sky/engine/core/rendering/RenderLayer.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@web.de>
  *   Randall Jesup <rjesup@wgate.com>
@@ skipping 88 matching lines @@
     , m_next(0)
     , m_first(0)
     , m_last(0)
     , m_staticInlinePosition(0)
     , m_staticBlockPosition(0)
     , m_clipper(*renderer)
 {
     updateStackingNode();
 
     m_isSelfPaintingLayer = shouldBeSelfPaintingLayer();
-
-    updateScrollableArea();
 }
 
 RenderLayer::~RenderLayer()
 {
     removeFilterInfoIfNeeded();
 }
 
 String RenderLayer::debugName() const
 {
     return renderer()->debugName();
@@ skipping 672 matching lines @@
         currLayer = accumulateOffsetTowardsAncestor(currLayer, ancestorLayer, location);
 }
 
 void RenderLayer::convertToLayerCoords(const RenderLayer* ancestorLayer, LayoutRect& rect) const
 {
     LayoutPoint delta;
     convertToLayerCoords(ancestorLayer, delta);
     rect.move(-delta.x(), -delta.y());
 }
 
-void RenderLayer::didUpdateNeedsCompositedScrolling()
-{
-    updateSelfPaintingLayer();
-}
-
 void RenderLayer::updateStackingNode()
 {
     if (requiresStackingNode())
         m_stackingNode = adoptPtr(new RenderLayerStackingNode(this));
     else
         m_stackingNode = nullptr;
 }
 
-void RenderLayer::updateScrollableArea()
-{
-    if (requiresScrollableArea())
-        m_scrollableArea = adoptPtr(new RenderLayerScrollableArea(*this));
-    else
-        m_scrollableArea = nullptr;
-}
-
-bool RenderLayer::hasOverflowControls() const
-{
-    return m_scrollableArea && m_scrollableArea->hasScrollbar();
-}
-
 void RenderLayer::paint(GraphicsContext* context, const LayoutRect& damageRect, RenderObject* paintingRoot)
 {
     TRACE_EVENT0("blink", "RenderLayer::paint");
     LayerPaintingInfo paintingInfo(this, enclosingIntRect(damageRect), LayoutSize(), paintingRoot);
     paintLayer(context, paintingInfo, PaintContent);
 }
 
 void RenderLayer::paintOverlayScrollbars(GraphicsContext* context, const LayoutRect& damageRect, RenderObject* paintingRoot)
 {
     if (!m_containsDirtyOverlayScrollbars)
@@ skipping 27 matching lines @@
     context->save();
     context->clip(pixelSnappedIntRect(clipRect.rect()));
 
     if (!clipRect.hasRadius())
         return;
 
     // If the clip rect has been tainted by a border radius, then we have to walk up our layer chain applying the clips from
     // any layers with overflow. The condition for being able to apply these clips is that the overflow object be in our
     // containing block chain so we check that also.
     for (RenderLayer* layer = rule == IncludeSelfForBorderRadius ? this : parent(); layer; layer = layer->parent()) {
-        // Composited scrolling layers handle border-radius clip in the compositor via a mask layer. We do not
-        // want to apply a border-radius clip to the layer contents itself, because that would require re-rastering
-        // every frame to update the clip. We only want to make sure that the mask layer is properly clipped so
-        // that it can in turn clip the scrolled contents in the compositor.
-        if (layer->needsCompositedScrolling())
-            break;
-
         if (layer->renderer()->hasOverflowClip() && layer->renderer()->style()->hasBorderRadius() && inContainingBlockChain(this, layer)) {
                 LayoutPoint delta;
                 layer->convertToLayerCoords(localPaintingInfo.rootLayer, delta);
                 context->clipRoundedRect(layer->renderer()->style()->getRoundedInnerBorderFor(LayoutRect(delta, layer->size())));
         }
 
         if (layer == localPaintingInfo.rootLayer)
             break;
     }
 }
@@ skipping 70 matching lines @@
     LayoutRect rootRelativeBounds;
     bool rootRelativeBoundsComputed = false;
 
     // Apply clip-path to context.
     GraphicsContextStateSaver clipStateSaver(*context, false);
     RenderStyle* style = renderer()->style();
 
     // Clip-path, like border radius, must not be applied to the contents of a composited-scrolling container.
     // It must, however, still be applied to the mask layer, so that the compositor can properly mask the
     // scrolling contents and scrollbars.
-    if (renderer()->hasClipPath() && style && !needsCompositedScrolling()) {
+    if (renderer()->hasClipPath() && style) {
         ASSERT(style->clipPath());
         if (style->clipPath()->type() == ClipPathOperation::SHAPE) {
             ShapeClipPathOperation* clipPath = toShapeClipPathOperation(style->clipPath());
             if (clipPath->isValid()) {
                 clipStateSaver.save();
 
                 if (!rootRelativeBoundsComputed) {
                     rootRelativeBounds = physicalBoundingBoxIncludingReflectionAndStackingChildren(paintingInfo.rootLayer, offsetFromRoot);
                     rootRelativeBoundsComputed = true;
                 }
@@ skipping 60 matching lines @@
     LayoutPoint layerLocation = toPoint(layerBounds.location() - renderBoxLocation() + localPaintingInfo.subPixelAccumulation);
 
     if (shouldPaintContent) {
         paintForeground(context, transparencyLayerContext, paintingInfo.paintDirtyRect, haveTransparency,
             localPaintingInfo, paintingRootForRenderer, layerLocation, foregroundRect);
     }
 
     paintOutline(context, localPaintingInfo, paintingRootForRenderer, layerLocation, outlineRect);
     paintChildren(NormalFlowChildren | PositiveZOrderChildren, context, paintingInfo, paintFlags);
 
-    if (isPaintingOverlayScrollbars)
-        paintOverflowControls(context, localPaintingInfo, layerLocation, backgroundRect);
-
     if (filterPainter.hasStartedFilterEffect()) {
         context = filterPainter.applyFilterEffect();
         restoreClip(transparencyLayerContext, localPaintingInfo.paintDirtyRect, backgroundRect);
     }
 
     // Make sure that we now use the original transparency context.
     ASSERT(transparencyLayerContext == context);
 
     if (shouldPaintContent && renderer()->hasMask())
         paintMask(context, localPaintingInfo, paintingRootForRenderer, layerLocation, backgroundRect);
@@ skipping 104 matching lines @@
 
     // Paint the mask.
     // FIXME: Eventually we will collect the region from the fragment itself instead of just from the paint info.
     PaintInfo paintInfo(context, pixelSnappedIntRect(layerBackgroundRect.rect()), PaintPhaseMask, paintingRootForRenderer, localPaintingInfo.rootLayer->renderer());
     renderer()->paint(paintInfo, layerLocation);
 
     if (localPaintingInfo.clipToDirtyRect)
         restoreClip(context, localPaintingInfo.paintDirtyRect, layerBackgroundRect);
 }
 
-void RenderLayer::paintOverflowControls(GraphicsContext* context, const LayerPaintingInfo& localPaintingInfo, LayoutPoint& layerLocation, ClipRect& layerBackgroundRect)
-{
-    clipToRect(localPaintingInfo, context, layerBackgroundRect);
-    if (RenderLayerScrollableArea* scrollableArea = this->scrollableArea())
-        scrollableArea->paintOverflowControls(context, roundedIntPoint(layerLocation), pixelSnappedIntRect(layerBackgroundRect.rect()), true);
-    restoreClip(context, localPaintingInfo.paintDirtyRect, layerBackgroundRect);
-}
-
 static inline LayoutRect frameVisibleRect(RenderObject* renderer)
 {
     FrameView* frameView = renderer->document().view();
     if (!frameView)
         return LayoutRect();
 
     return frameView->visibleContentRect();
 }
 
 bool RenderLayer::hitTest(const HitTestRequest& request, HitTestResult& result)
@@ skipping 487 matching lines @@
 }
 
 bool RenderLayer::paintsWithTransform() const
 {
     // FIXME(sky): Remove
     return transform();
 }
 
 bool RenderLayer::shouldBeSelfPaintingLayer() const
 {
-    return m_layerType == NormalLayer
-        || (m_scrollableArea && m_scrollableArea->hasOverlayScrollbars())
-        || needsCompositedScrolling();
+    return m_layerType == NormalLayer;
 }
 
 void RenderLayer::updateSelfPaintingLayer()
 {
     bool isSelfPaintingLayer = shouldBeSelfPaintingLayer();
     if (this->isSelfPaintingLayer() == isSelfPaintingLayer)
         return;
 
     m_isSelfPaintingLayer = isSelfPaintingLayer;
 
@@ skipping 20 matching lines @@
     return false;
 }
 
 bool RenderLayer::hasBoxDecorationsOrBackground() const
 {
     return renderer()->style()->hasBoxDecorations() || renderer()->style()->hasBackground();
 }
 
 bool RenderLayer::hasVisibleBoxDecorations() const
 {
-    return hasBoxDecorationsOrBackground() || hasOverflowControls();
+    return hasBoxDecorationsOrBackground();
 }
 
 bool RenderLayer::isVisuallyNonEmpty() const
 {
     if (hasNonEmptyChildRenderers())
         return true;
 
     if (renderer()->isReplaced() || renderer()->hasMask())
         return true;
 
@@ skipping 10 matching lines @@
 
     updateOrRemoveFilterClients();
     updateOrRemoveFilterEffectRenderer();
 }
 
 void RenderLayer::styleChanged(StyleDifference diff, const RenderStyle* oldStyle)
 {
     m_stackingNode->updateIsNormalFlowOnly();
     m_stackingNode->updateStackingNodesAfterStyleChange(oldStyle);
 
-    if (m_scrollableArea)
-        m_scrollableArea->updateAfterStyleChange(oldStyle);
-
     // Overlay scrollbars can make this layer self-painting so we need
     // to recompute the bit once scrollbars have been updated.
     updateSelfPaintingLayer();
 
     updateTransform(oldStyle, renderer()->style());
     updateFilters(oldStyle, renderer()->style());
 }
 
-bool RenderLayer::scrollsOverflow() const
-{
-    if (RenderLayerScrollableArea* scrollableArea = this->scrollableArea())
-        return scrollableArea->scrollsOverflow();
-
-    return false;
-}
-
 FilterOperations RenderLayer::computeFilterOperations(const RenderStyle* style)
 {
     return style->filter();
 }
 
 void RenderLayer::updateOrRemoveFilterClients()
 {
     if (!hasFilter()) {
         removeFilterInfoIfNeeded();
         return;
@@ skipping 48 matching lines @@
     }
 }
 
 void showLayerTree(const blink::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif