Remove RenderLayer::m_hasUnclippedDescendant

Source/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 93 matching lines @@
 } // namespace
 
 using namespace HTMLNames;
 
 RenderLayer::RenderLayer(RenderLayerModelObject* renderer, LayerType type)
     : m_layerType(type)
     , m_hasSelfPaintingLayerDescendant(false)
     , m_hasSelfPaintingLayerDescendantDirty(false)
     , m_hasOutOfFlowPositionedDescendant(false)
     , m_hasOutOfFlowPositionedDescendantDirty(true)
-    , m_hasUnclippedDescendant(false)
     , m_isUnclippedDescendant(false)
     , m_isRootLayer(renderer->isRenderView())
     , m_usedTransparency(false)
     , m_visibleContentStatusDirty(true)
     , m_hasVisibleContent(false)
     , m_visibleDescendantStatusDirty(false)
     , m_hasVisibleDescendant(false)
     , m_hasVisibleNonLayerContent(false)
     , m_isPaginated(false)
     , m_3DTransformedDescendantStatusDirty(true)
@@ skipping 237 matching lines @@
         layer->setHasOutOfFlowPositionedDescendantDirty(false);
         layer->setHasOutOfFlowPositionedDescendant(true);
     }
 }
 
 void RenderLayer::dirtyAncestorChainHasOutOfFlowPositionedDescendantStatus()
 {
     for (RenderLayer* layer = this; layer; layer = layer->parent()) {
         layer->setHasOutOfFlowPositionedDescendantDirty(true);
 
-        // We may or may not have an unclipped descendant. If we do, we'll reset
-        // this to true the next time composited scrolling state is updated.
-        layer->setHasUnclippedDescendant(false);
-
         // If we have reached an out of flow positioned layer, we know our parent should have an out-of-flow positioned descendant.
         // In this case, there is no need to dirty our ancestors further.
         if (layer->renderer()->isOutOfFlowPositioned()) {
             ASSERT(!parent() || parent()->m_hasOutOfFlowPositionedDescendantDirty || parent()->hasOutOfFlowPositionedDescendant());
             break;
         }
     }
 }
 
 bool RenderLayer::scrollsWithRespectTo(const RenderLayer* other) const
@@ skipping 414 matching lines @@
 {
     for (RenderLayer* layer = this; layer; layer = layer->parent()) {
         if (!layer->m_visibleDescendantStatusDirty && layer->hasVisibleDescendant())
             break;
 
         layer->m_hasVisibleDescendant = true;
         layer->m_visibleDescendantStatusDirty = false;
     }
 }
 
-void RenderLayer::updateHasUnclippedDescendant()
+void RenderLayer::updateIsUnclippedDescendant()
 {
-    TRACE_EVENT0("blink_rendering", "RenderLayer::updateHasUnclippedDescendant");
+    TRACE_EVENT0("blink_rendering", "RenderLayer::updateIsUnclippedDescendant");
     ASSERT(renderer()->isOutOfFlowPositioned());
     if (!m_hasVisibleContent && !m_hasVisibleDescendant)
         return;
 
     FrameView* frameView = renderer()->view()->frameView();
     if (!frameView)
         return;
 
+    setIsUnclippedDescendant(false);
+
     const RenderObject* containingBlock = renderer()->containingBlock();
-    setIsUnclippedDescendant(false);
     for (RenderLayer* ancestor = parent(); ancestor && ancestor->renderer() != containingBlock; ancestor = ancestor->parent()) {
         // TODO(vollick): This isn't quite right. Whenever ancestor is composited and clips
         // overflow, we're technically unclipped. However, this will currently cause a huge
         // number of layers to report that they are unclipped. Eventually, when we've formally
         // separated the clipping, transform, opacity, and stacking trees here and in the
         // compositor, we will be able to relax this restriction without it being prohibitively
         // expensive (currently, we have to do a lot of work in the compositor to honor a
         // clip child/parent relationship).
-        if (ancestor->scrollsOverflow())
+        if (ancestor->scrollsOverflow()) {
             setIsUnclippedDescendant(true);
-        ancestor->setHasUnclippedDescendant(true);
+            return;
+        }
     }
 }
 
 // FIXME: this is quite brute-force. We could be more efficient if we were to
 // track state and update it as appropriate as changes are made in the Render tree.
 void RenderLayer::updateScrollingStateAfterCompositingChange()
 {
     TRACE_EVENT0("blink_rendering", "RenderLayer::updateScrollingStateAfterCompositingChange");
     m_hasVisibleNonLayerContent = false;
     for (RenderObject* r = renderer()->slowFirstChild(); r; r = r->nextSibling()) {
@@ skipping 2898 matching lines @@
 
 void RenderLayer::updateOutOfFlowPositioned(const RenderStyle* oldStyle)
 {
     ASSERT(!oldStyle || renderer()->style()->position() != oldStyle->position());
 
     bool wasOutOfFlowPositioned = oldStyle && (oldStyle->position() == AbsolutePosition || oldStyle->position() == FixedPosition);
     bool isOutOfFlowPositioned = renderer()->isOutOfFlowPositioned();
     if (!wasOutOfFlowPositioned && !isOutOfFlowPositioned)
         return;
 
-    // Even if the layer remains out-of-flow, a change to this property
-    // will likely change its containing block. We must clear these bits
-    // so that they can be set properly by the RenderLayerCompositor.
-    for (RenderLayer* ancestor = parent(); ancestor; ancestor = ancestor->parent())
-        ancestor->setHasUnclippedDescendant(false);
-
     // Ensures that we reset the above bits correctly.
     compositor()->setNeedsUpdateCompositingRequirementsState();
 
     if (wasOutOfFlowPositioned && isOutOfFlowPositioned)
         return;
 
     if (isOutOfFlowPositioned) {
         setAncestorChainHasOutOfFlowPositionedDescendant();
         compositor()->addOutOfFlowPositionedLayer(this);
     } else {
@@ skipping 295 matching lines @@
     }
 }
 
 void showLayerTree(const WebCore::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif