Remove RenderLayerScrollableArea

sky/engine/core/rendering/RenderLayer.h

 /*
  * Copyright (C) 2003, 2009, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. 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>
@@ skipping 31 matching lines @@
  * version of this file under any of the LGPL, the MPL or the GPL.
  */
 
 #ifndef SKY_ENGINE_CORE_RENDERING_RENDERLAYER_H_
 #define SKY_ENGINE_CORE_RENDERING_RENDERLAYER_H_
 
 #include "sky/engine/core/rendering/LayerPaintingInfo.h"
 #include "sky/engine/core/rendering/RenderBox.h"
 #include "sky/engine/core/rendering/RenderLayerClipper.h"
 #include "sky/engine/core/rendering/RenderLayerFilterInfo.h"
-#include "sky/engine/core/rendering/RenderLayerScrollableArea.h"
 #include "sky/engine/core/rendering/RenderLayerStackingNode.h"
 #include "sky/engine/core/rendering/RenderLayerStackingNodeIterator.h"
 #include "sky/engine/public/platform/WebBlendMode.h"
 #include "sky/engine/wtf/OwnPtr.h"
 
 namespace blink {
 
 class FilterEffectRenderer;
 class FilterOperations;
 class HitTestRequest;
@@ skipping 145 matching lines @@
 
     // FIXME: reflections should force transform-style to be flat in the style: https://bugs.webkit.org/show_bug.cgi?id=106959
     bool shouldPreserve3D() const { return renderer()->style()->transformStyle3D() == TransformStyle3DPreserve3D; }
 
     bool hasFilter() const { return renderer()->hasFilter(); }
 
     void* operator new(size_t);
     // Only safe to call from RenderLayerModelObject::destroyLayer()
     void operator delete(void*);
 
-    bool needsCompositedScrolling() const { return m_scrollableArea && m_scrollableArea->needsCompositedScrolling(); }
-
     bool paintsWithTransform() const;
 
     bool containsDirtyOverlayScrollbars() const { return m_containsDirtyOverlayScrollbars; }
     void setContainsDirtyOverlayScrollbars(bool dirtyScrollbars) { m_containsDirtyOverlayScrollbars = dirtyScrollbars; }
 
     FilterOperations computeFilterOperations(const RenderStyle*);
     bool paintsWithFilters() const;
     bool requiresFullLayerImageForFilters() const;
     FilterEffectRenderer* filterRenderer() const
     {
@@ skipping 11 matching lines @@
 
     bool hasFilterInfo() const { return m_hasFilterInfo; }
     void setHasFilterInfo(bool hasFilterInfo) { m_hasFilterInfo = hasFilterInfo; }
 
     void updateFilters(const RenderStyle* oldStyle, const RenderStyle* newStyle);
 
     Node* enclosingElement() const;
 
     bool scrollsWithRespectTo(const RenderLayer*) const;
 
-    // FIXME: This should probably return a ScrollableArea but a lot of internal methods are mistakenly exposed.
-    RenderLayerScrollableArea* scrollableArea() const { return m_scrollableArea.get(); }
     RenderLayerClipper& clipper() { return m_clipper; }
     const RenderLayerClipper& clipper() const { return m_clipper; }
 
     inline bool isPositionedContainer() const
     {
         // FIXME: This is not in sync with containingBlock.
         RenderLayerModelObject* layerRenderer = renderer();
         return isRootLayer() || layerRenderer->isPositioned() || hasTransform();
     }
 
-    bool scrollsOverflow() const;
-
     class AncestorDependentCompositingInputs {
     public:
         AncestorDependentCompositingInputs()
             : opacityAncestor(0)
             , transformAncestor(0)
             , filterAncestor(0)
             , clippingContainer(0)
             , ancestorScrollingLayer(0)
             , scrollParent(0)
             , clipParent(0)
@@ skipping 81 matching lines @@
     bool hasCompositingDescendant() const { return m_hasCompositingDescendant; }
     void setHasCompositingDescendant(bool);
 
     void updateOrRemoveFilterEffectRenderer();
 
     void updateSelfPaintingLayer();
 
     RenderLayer* enclosingTransformedAncestor() const;
     LayoutPoint computeOffsetFromTransformedAncestor() const;
 
-    void didUpdateNeedsCompositedScrolling();
-
 private:
     // TODO(ojan): Get rid of this. These are basically layer-tree-only paint phases.
     enum PaintLayerFlags {
         PaintContent,
         PaintOverlayScrollbars,
     };
 
     // Bounding box in the coordinates of this layer.
     LayoutRect logicalBoundingBox() const;
 
-    bool hasOverflowControls() const;
-
     void setAncestorChainHasSelfPaintingLayerDescendant();
     void dirtyAncestorChainHasSelfPaintingLayerDescendantStatus();
 
     void clipToRect(const LayerPaintingInfo&, GraphicsContext*, const ClipRect&, BorderRadiusClippingRule = IncludeSelfForBorderRadius);
     void restoreClip(GraphicsContext*, const LayoutRect& paintDirtyRect, const ClipRect&);
 
     void setNextSibling(RenderLayer* next) { m_next = next; }
     void setPreviousSibling(RenderLayer* prev) { m_previous = prev; }
     void setFirstChild(RenderLayer* first) { m_first = first; }
     void setLastChild(RenderLayer* last) { m_last = last; }
@@ skipping 20 matching lines @@
 
     void paintChildren(unsigned childrenToVisit, GraphicsContext*, const LayerPaintingInfo&, PaintLayerFlags);
 
     void paintForeground(GraphicsContext*, GraphicsContext* transparencyLayerContext,
         const LayoutRect& transparencyPaintDirtyRect, bool haveTransparency, const LayerPaintingInfo&, RenderObject* paintingRootForRenderer,
         LayoutPoint& layerLocation, ClipRect& layerForegroundRect);
     void paintForegroundWithPhase(PaintPhase, GraphicsContext*, const LayerPaintingInfo&, RenderObject* paintingRootForRenderer,
         LayoutPoint& layerLocation, ClipRect& layerForegroundRect);
     void paintOutline(GraphicsContext*, const LayerPaintingInfo&, RenderObject* paintingRootForRenderer,
         LayoutPoint& layerLocation, ClipRect& layerOutlineRect);
-    void paintOverflowControls(GraphicsContext*, const LayerPaintingInfo&,
-        LayoutPoint& layerLocation, ClipRect& layerBackgroundRect);
     void paintMask(GraphicsContext*, const LayerPaintingInfo&, RenderObject* paintingRootForRenderer,
         LayoutPoint& layerLocation, ClipRect& layerBackgroundRect);
 
     RenderLayer* hitTestLayer(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest& request, HitTestResult& result,
                               const LayoutRect& hitTestRect, const HitTestLocation&, bool appliedTransform,
                               const HitTestingTransformState* transformState = 0, double* zOffset = 0);
     RenderLayer* hitTestLayerByApplyingTransform(RenderLayer* rootLayer, RenderLayer* containerLayer, const HitTestRequest&, HitTestResult&,
         const LayoutRect& hitTestRect, const HitTestLocation&, const HitTestingTransformState* = 0, double* zOffset = 0,
         const LayoutPoint& translationOffset = LayoutPoint());
     RenderLayer* hitTestChildren(ChildrenIteration, RenderLayer* rootLayer, const HitTestRequest&, HitTestResult&,
                              const LayoutRect& hitTestRect, const HitTestLocation&,
                              const HitTestingTransformState* transformState, double* zOffsetForDescendants, double* zOffset,
                              const HitTestingTransformState* unflattenedTransformState, bool depthSortDescendants);
 
     PassRefPtr<HitTestingTransformState> createLocalTransformState(RenderLayer* rootLayer, RenderLayer* containerLayer,
                             const LayoutRect& hitTestRect, const HitTestLocation&,
                             const HitTestingTransformState* containerTransformState,
                             const LayoutPoint& translationOffset = LayoutPoint()) const;
 
     bool hitTestContents(const HitTestRequest&, HitTestResult&, const LayoutRect& layerBounds, const HitTestLocation&, HitTestFilter) const;
 
     bool shouldBeSelfPaintingLayer() const;
 
     // FIXME: We should only create the stacking node if needed.
     bool requiresStackingNode() const { return true; }
     void updateStackingNode();
 
-    // FIXME: We could lazily allocate our ScrollableArea based on style properties ('overflow', ...)
-    // but for now, we are always allocating it for RenderBox as it's safer.
-    bool requiresScrollableArea() const { return renderBox(); }
-    void updateScrollableArea();
-
     void updateTransform(const RenderStyle* oldStyle, RenderStyle* newStyle);
 
     void dirty3DTransformedDescendantStatus();
     // Both updates the status, and returns true if descendants of this have 3d.
     bool update3DTransformedDescendantStatus();
 
     void updateOrRemoveFilterClients();
 
     LayoutRect paintingExtent(const RenderLayer* rootLayer, const LayoutRect& paintDirtyRect, const LayoutSize& subPixelAccumulation);
 
@@ skipping 44 matching lines @@
 
     // Cached normal flow values for absolute positioned elements with static left/top values.
     LayoutUnit m_staticInlinePosition;
     LayoutUnit m_staticBlockPosition;
 
     OwnPtr<TransformationMatrix> m_transform;
 
     DescendantDependentCompositingInputs m_descendantDependentCompositingInputs;
     AncestorDependentCompositingInputs m_ancestorDependentCompositingInputs;
 
-    OwnPtr<RenderLayerScrollableArea> m_scrollableArea;
-
     RenderLayerClipper m_clipper; // FIXME: Lazily allocate?
     OwnPtr<RenderLayerStackingNode> m_stackingNode;
 
     LayoutSize m_subpixelAccumulation; // The accumulated subpixel offset of a composited layer's composited bounds compared to absolute coordinates.
 };
 
 } // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void showLayerTree(const blink::RenderLayer*);
 void showLayerTree(const blink::RenderObject*);
 #endif
 
 #endif  // SKY_ENGINE_CORE_RENDERING_RENDERLAYER_H_