Only update composited scrolling state when necessary

Source/WebCore/rendering/RenderLayer.h

 /*
  * Copyright (C) 2003, 2009, 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 297 matching lines @@
     // Also unique to paginated fragments. An additional clip that applies to the layer. It is in layer-local
     // (physical) coordinates.
     LayoutRect paginationClip;
 };
 
 typedef Vector<LayerFragment, 1> LayerFragments;
 
 class RenderLayer : public ScrollableArea {
 public:
     friend class RenderReplica;
+    friend struct ScopedCompositedScrollingUpdater;
 
     RenderLayer(RenderLayerModelObject*);
     ~RenderLayer();
 
     String name() const;
 
     RenderLayerModelObject* renderer() const { return m_renderer; }
     RenderBox* renderBox() const { return m_renderer && m_renderer->isBox() ? toRenderBox(m_renderer) : 0; }
     RenderLayer* parent() const { return m_parent; }
     RenderLayer* previousSibling() const { return m_previous; }
@@ skipping 162 matching lines @@
     // A stacking container can have z-order lists. All stacking contexts are
     // stacking containers, but the converse is not true. Layers that use
     // composited scrolling are stacking containers, but they may not
     // necessarily be stacking contexts.
     bool isStackingContainer() const { return isStackingContext() || needsCompositedScrolling(); }
 
     // Gets the enclosing stacking container for this layer, excluding this
     // layer itself.
     RenderLayer* stackingContainer() const;
 
+    // Gets the enclosing stacking context for this layer, excluding this
+    // layer itself.
+    RenderLayer* stackingContext() const;
+
     // Gets the enclosing stacking container for this layer, possibly the layer
     // itself, if it is a stacking container.
     RenderLayer* enclosingStackingContainer() { return isStackingContainer() ? this : stackingContainer(); }
 
+    // Gets the enclosing stacking context for this layer, possibly the layer
+    // itself, if it is a stacking context.
+    RenderLayer* enclosingStackingContext() { return isStackingContext() ? this : stackingContext(); }
+
     void dirtyZOrderLists();
     void dirtyStackingContainerZOrderLists();
 
     Vector<RenderLayer*>* posZOrderList() const
     {
         ASSERT(!m_zOrderListsDirty);
         ASSERT(isStackingContainer() || !m_posZOrderList);
         return m_posZOrderList.get();
     }
 
@@ skipping 345 matching lines @@
     void computeRepaintRectsIncludingDescendants();
     void clearRepaintRects();
 
     void clipToRect(RenderLayer* rootLayer, GraphicsContext*, const LayoutRect& paintDirtyRect, const ClipRect&,
                     BorderRadiusClippingRule = IncludeSelfForBorderRadius);
     void restoreClip(GraphicsContext*, const LayoutRect& paintDirtyRect, const ClipRect&);
 
     bool shouldRepaintAfterLayout() const;
 
     void updateSelfPaintingLayer();
+    void updateIsNormalFlowOnly();
+    void updateVisibilityAfterStyleChange(const RenderStyle* oldStyle);
     void updateStackingContextsAfterStyleChange(const RenderStyle* oldStyle);
 
     void updateScrollbarsAfterStyleChange(const RenderStyle* oldStyle);
     void updateScrollbarsAfterLayout();
 
     void setAncestorChainHasOutOfFlowPositionedDescendant(RenderObject* containingBlock);
     void dirtyAncestorChainHasOutOfFlowPositionedDescendantStatus();
     void updateOutOfFlowPositioned(const RenderStyle* oldStyle);
 
     void updateNeedsCompositedScrolling();
+    void setNeedsCompositedScrolling(bool);
+
+    void requestNeedsCompositedScrollingUpdate();
+    void requestDescendantsAreContiguousInStackingOrderUpdate();
+    void cancelScheduledCompositedScrollingUpdates() const;
 
     // Returns true if the position changed.
     bool updateLayerPosition();
 
     void updateLayerPositions(RenderGeometryMap* = 0, UpdateLayerPositionsFlags = defaultFlags);
 
     enum UpdateLayerPositionsAfterScrollFlag {
         NoFlag = 0,
         IsOverflowScroll = 1 << 0,
         HasSeenViewportConstrainedAncestor = 1 << 1,
@@ skipping 255 matching lines @@
     // stacking context.
     bool m_hasOutOfFlowPositionedDescendant : 1;
     bool m_hasOutOfFlowPositionedDescendantDirty : 1;
 
     bool m_needsCompositedScrolling : 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.
     bool m_descendantsAreContiguousInStackingOrder : 1;
+    bool m_descendantsAreContiguousInStackingOrderDirty : 1;
 
     const bool m_isRootLayer : 1;
 
     bool 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).
     bool m_paintingInsideReflection : 1;  // A state bit tracking if we are painting inside a replica.
     bool m_inOverflowRelayout : 1;
     unsigned m_repaintStatus : 2; // RepaintStatus
 
@@ skipping 101 matching lines @@
 };
 
 inline void RenderLayer::clearZOrderLists()
 {
     ASSERT(!isStackingContainer());
 
     m_posZOrderList.clear();
     m_negZOrderList.clear();
 }
 
-inline void RenderLayer::updateZOrderLists()
-{
-    if (!m_zOrderListsDirty)
-        return;
-
-    if (!isStackingContainer()) {
-        clearZOrderLists();
-        m_zOrderListsDirty = false;
-        return;
-    }
-
-    rebuildZOrderLists();
-}
-
 #if !ASSERT_DISABLED
 class LayerListMutationDetector {
 public:
     LayerListMutationDetector(RenderLayer* layer)
         : m_layer(layer)
         , m_previousMutationAllowedState(layer->layerListMutationAllowed())
     {
         m_layer->setLayerListMutationAllowed(false);
     }
     
@@ skipping 11 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