Make composited scrolling codepaths co-operate.

Source/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 457 matching lines @@
 
     CompositedLayerMapping* compositedLayerMapping() const
     {
         // NOTE: Checking whether backing exists is equivalent to asking if you are in one of these two compositing states.
         //       If this is why you are using compositedLayerMapping(), consider using compositingState() instead.
         return m_compositedLayerMapping.get();
     }
 
     CompositedLayerMapping* ensureCompositedLayerMapping();
     void clearCompositedLayerMapping(bool layerBeingDestroyed = false);
+    bool adjustForForceCompositedScrollingMode(bool) const;
 
     bool hasCompositedMask() const;
     bool hasCompositedClippingMask() const;
     bool needsCompositedScrolling() const;
     bool needsToBeStackingContainer() const;
 
     RenderLayer* scrollParent() const;
     RenderLayer* clipParent() const;
 
     bool needsCompositingLayersRebuiltForClip(const RenderStyle* oldStyle, const RenderStyle* newStyle) const;
@@ skipping 104 matching lines @@
     void setAncestorChainHasSelfPaintingLayerDescendant();
     void dirtyAncestorChainHasSelfPaintingLayerDescendantStatus();
 
     void setAncestorChainHasOutOfFlowPositionedDescendant();
     void dirtyAncestorChainHasOutOfFlowPositionedDescendantStatus();
 
     bool acceleratedCompositingForOverflowScrollEnabled() const;
     // FIXME: This is a temporary flag and should be removed once accelerated
     // overflow scroll is ready (crbug.com/254111).
     bool compositorDrivenAcceleratedScrollingEnabled() const;
-    void updateCanBeStackingContainer();
+    void updateDescendantsAreContiguousInStackingOrder();
     void collectBeforePromotionZOrderList(RenderLayer* ancestorStackingContext, OwnPtr<Vector<RenderLayer*> >& posZOrderListBeforePromote, OwnPtr<Vector<RenderLayer*> >& negZOrderListBeforePromote);
     void collectAfterPromotionZOrderList(RenderLayer* ancestorStackingContext, OwnPtr<Vector<RenderLayer*> >& posZOrderListAfterPromote, OwnPtr<Vector<RenderLayer*> >& negZOrderListAfterPromote);
 
     void dirtyNormalFlowListCanBePromotedToStackingContainer();
     void dirtySiblingStackingContextCanBePromotedToStackingContainer();
 
     void clipToRect(RenderLayer* rootLayer, GraphicsContext*, const LayoutRect& paintDirtyRect, const ClipRect&,
                     BorderRadiusClippingRule = IncludeSelfForBorderRadius);
     void restoreClip(GraphicsContext*, const LayoutRect& paintDirtyRect, const ClipRect&);
 
     void updateSelfPaintingLayer();
     void updateIsNormalFlowOnly();
     void updateVisibilityAfterStyleChange(const RenderStyle* oldStyle);
     void updateStackingContextsAfterStyleChange(const RenderStyle* oldStyle);
 
     void updateOutOfFlowPositioned(const RenderStyle* oldStyle);
 
-    void setNeedsCompositedScrolling(bool);
+    bool setNeedsCompositedScrolling(bool);
+    bool setNeedsToBeStackingContainer(bool);
     void didUpdateNeedsCompositedScrolling();
 
     // Returns true if the position changed.
     bool updateLayerPosition();
 
     void updateLayerPositions(RenderGeometryMap* = 0, UpdateLayerPositionsFlags = defaultFlags);
 
     enum UpdateLayerPositionsAfterScrollFlag {
         NoFlag = 0,
         IsOverflowScroll = 1 << 0,
@@ skipping 183 matching lines @@
     // FIXME: Temporary. Remove when new columns come online.
     bool useRegionBasedColumns() const;
 
     bool hasCompositingDescendant() const { return m_compositingProperties.hasCompositingDescendant; }
     void setHasCompositingDescendant(bool b)  { m_compositingProperties.hasCompositingDescendant = b; }
 
     void setCompositingReasons(CompositingReasons reasons) { m_compositingProperties.compositingReasons = reasons; }
     CompositingReasons compositingReasons() const { return m_compositingProperties.compositingReasons; }
 
     // Returns true if z ordering would not change if this layer were a stacking container.
-    bool canBeStackingContainer() const;
+    bool descendantsAreContiguousInStackingOrder() const;
 
     friend class CompositedLayerMapping;
     friend class RenderLayerCompositor;
     friend class RenderLayerModelObject;
 
     bool overflowControlsIntersectRect(const IntRect& localRect) const;
 
 protected:
     unsigned m_zOrderListsDirty : 1;
     unsigned m_normalFlowListDirty: 1;
@@ skipping 11 matching lines @@
 
     // This is true if we have an out-of-flow positioned descendant whose
     // containing block is our ancestor. If this is the case, the descendant
     // may fall outside of our clip preventing things like opting into
     // composited scrolling (which causes clipping of all descendants).
     unsigned m_hasUnclippedDescendant : 1;
 
     unsigned m_isUnclippedDescendant : 1;
 
     unsigned m_needsCompositedScrolling : 1;
-    unsigned m_needsCompositedScrollingHasBeenRecorded : 1;
+    unsigned m_needsToBeStackingContainerHasBeenRecorded : 1;
     unsigned m_willUseCompositedScrollingHasBeenRecorded : 1;
 
     unsigned m_isScrollableAreaHasBeenRecorded : 1;
 
+    unsigned m_needsToBeStackingContainer : 1;
+
     // If this is true, then no non-descendant appears between any of our
     // descendants in stacking order. This is one of the requirements of being
     // able to safely become a stacking context.
-    unsigned m_canBePromotedToStackingContainer : 1;
-    unsigned m_canBePromotedToStackingContainerDirty : 1;
+    unsigned m_descendantsAreContiguousInStackingOrder : 1;
+    unsigned m_descendantsAreContiguousInStackingOrderDirty : 1;
 
     const unsigned m_isRootLayer : 1;
 
     unsigned m_usedTransparency : 1; // Tracks whether we need to close a transparent layer, i.e., whether
                                  // we ended up painting this layer or any descendants (and therefore need to
                                  // blend).
 
     unsigned m_childLayerHasBlendMode : 1;
     unsigned m_childLayerHasBlendModeStatusDirty : 1;
     unsigned m_paintingInsideReflection : 1; // A state bit tracking if we are painting inside a replica.
@@ skipping 144 matching lines @@
 
 } // namespace WebCore
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void showLayerTree(const WebCore::RenderLayer*);
 void showLayerTree(const WebCore::RenderObject*);
 #endif
 
 #endif // RenderLayer_h