Modified: branches/chromium/1364/Source/WebCore/rendering/RenderLayer.cpp (141261 => 141262)
--- branches/chromium/1364/Source/WebCore/rendering/RenderLayer.cpp 2013-01-30 14:31:51 UTC (rev 141261)
+++ branches/chromium/1364/Source/WebCore/rendering/RenderLayer.cpp 2013-01-30 14:36:50 UTC (rev 141262)
@@ -195,9 +195,9 @@
m_isNormalFlowOnly = shouldBeNormalFlowOnly();
m_isSelfPaintingLayer = shouldBeSelfPaintingLayer();
- // Non-stacking contexts should have empty z-order lists. As this is already the case,
+ // Non-stacking containers should have empty z-order lists. As this is already the case,
// there is no need to dirty / recompute these lists.
- m_zOrderListsDirty = isStackingContext();
+ m_zOrderListsDirty = isStackingContainer();
ScrollableArea::setConstrainsScrollingToContentEdge(false);
@@ -488,10 +488,10 @@
&& renderer()->frame()->page()->settings()->acceleratedCompositingForOverflowScrollEnabled();
}
-// If we are a stacking context, then this function will determine if our
+// If we are a stacking container, then this function will determine if our
// descendants for a contiguous block in stacking order. This is required in
-// order for an element to be safely promoted to a stacking context. It is safe
-// to become a stacking context if this change would not alter the stacking
+// order for an element to be safely promoted to a stacking container. It is safe
+// to become a stacking container if this change would not alter the stacking
// order of layers on the page. That can only happen if a non-descendant appear
// between us and our descendants in stacking order. Here's an example:
//
@@ -504,8 +504,8 @@
// 5
//
// I've labeled our normal flow descendants A, B, C, and D, our stacking
-// context descendants with their z indices, and us with 'this' (we're a
-// stacking context and our zIndex doesn't matter here). These nodes appear in
+// container descendants with their z indices, and us with 'this' (we're a
+// stacking container and our zIndex doesn't matter here). These nodes appear in
// three lists: posZOrder, negZOrder, and normal flow (keep in mind that normal
// flow layers don't overlap). So if we arrange these lists in order we get our
// stacking order:
@@ -521,10 +521,10 @@
//
// Note that the normal flow descendants can share an index because they don't
// stack/overlap. Now our problem becomes very simple: a layer can safely become
-// a stacking context if the stacking-order indices of it and its descendants
+// a stacking container if the stacking-order indices of it and its descendants
// appear in a contiguous block in the list of stacking indices. This problem
// can be solved very efficiently by calculating the min/max stacking indices in
-// the subtree, and the number stacking context descendants. Once we have this
+// the subtree, and the number stacking container descendants. Once we have this
// information, we know that the subtree's indices form a contiguous block if:
//
// maxStackIndex - minStackIndex == numSCDescendants
@@ -539,7 +539,7 @@
// ===> 1 - (-1) == 2
// ===> 2 == 2
//
-// Since this is true, A can safely become a stacking context.
+// Since this is true, A can safely become a stacking container.
// Now, for node C we have:
//
// maxStackIndex = 4
@@ -551,7 +551,7 @@
// ===> 4 - 0 == 2
// ===> 4 == 2
//
-// Since this is false, C cannot be safely promoted to a stacking context. This
+// Since this is false, C cannot be safely promoted to a stacking container. This
// happened because of the elements with z-index 5 and 0. Now if 5 had been a
// child of C rather than D, and A had no child with Z index 0, we would have had:
//
@@ -573,25 +573,29 @@
ASSERT(!m_normalFlowListDirty);
ASSERT(!m_zOrderListsDirty);
+ OwnPtr<Vector<RenderLayer*> > posZOrderList;
+ OwnPtr<Vector<RenderLayer*> > negZOrderList;
+ rebuildZOrderLists(StopAtStackingContexts, posZOrderList, negZOrderList);
+
// Create a reverse lookup.
HashMap<const RenderLayer*, int> lookup;
- if (m_negZOrderList) {
+ if (negZOrderList) {
int stackingOrderIndex = -1;
- size_t listSize = m_negZOrderList->size();
+ size_t listSize = negZOrderList->size();
for (size_t i = 0; i < listSize; ++i) {
- RenderLayer* currentLayer = m_negZOrderList->at(listSize - i - 1);
+ RenderLayer* currentLayer = negZOrderList->at(listSize - i - 1);
if (!currentLayer->isStackingContext())
continue;
lookup.set(currentLayer, stackingOrderIndex--);
}
}
- if (m_posZOrderList) {
- size_t listSize = m_posZOrderList->size();
+ if (posZOrderList) {
+ size_t listSize = posZOrderList->size();
int stackingOrderIndex = 1;
for (size_t i = 0; i < listSize; ++i) {
- RenderLayer* currentLayer = m_posZOrderList->at(i);
+ RenderLayer* currentLayer = posZOrderList->at(i);
if (!currentLayer->isStackingContext())
continue;
lookup.set(currentLayer, stackingOrderIndex++);
@@ -881,21 +885,21 @@
return;
}
- // If we're not normal flow, then we need to look for a multi-column object between us and our stacking context.
- RenderLayer* ancestorStackingContext = stackingContext();
+ // If we're not normal flow, then we need to look for a multi-column object between us and our stacking container.
+ RenderLayer* ancestorStackingContainer = stackingContainer();
for (RenderLayer* curr = parent(); curr; curr = curr->parent()) {
if (curr->renderer()->hasColumns()) {
m_isPaginated = checkContainingBlockChainForPagination(renderer(), curr->renderBox());
return;
}
- if (curr == ancestorStackingContext)
+ if (curr == ancestorStackingContainer)
return;
}
}
-bool RenderLayer::canSafelyEstablishAStackingContext() const
+bool RenderLayer::canBeStackingContainer() const
{
- if (isStackingContext() || !stackingContext())
+ if (isStackingContext() || !stackingContainer())
return true;
return m_descendantsAreContiguousInStackingOrder;
@@ -913,9 +917,9 @@
computeRepaintRects(renderer()->containerForRepaint());
if (!isNormalFlowOnly()) {
// We don't collect invisible layers in z-order lists if we are not in compositing mode.
- // As we became visible, we need to dirty our stacking contexts ancestors to be properly
+ // As we became visible, we need to dirty our stacking containers ancestors to be properly
// collected. FIXME: When compositing, we could skip this dirtying phase.
- for (RenderLayer* sc = stackingContext(); sc; sc = sc->stackingContext()) {
+ for (RenderLayer* sc = stackingContainer(); sc; sc = sc->stackingContainer()) {
sc->dirtyZOrderLists();
if (sc->hasVisibleContent())
break;
@@ -1034,15 +1038,15 @@
void RenderLayer::dirty3DTransformedDescendantStatus()
{
- RenderLayer* curr = stackingContext();
+ RenderLayer* curr = stackingContainer();
if (curr)
curr->m_3DTransformedDescendantStatusDirty = true;
// This propagates up through preserve-3d hierarchies to the enclosing flattening layer.
- // Note that preserves3D() creates stacking context, so we can just run up the stacking contexts.
+ // Note that preserves3D() creates stacking container, so we can just run up the stacking containers.
while (curr && curr->preserves3D()) {
curr->m_3DTransformedDescendantStatusDirty = true;
- curr = curr->stackingContext();
+ curr = curr->stackingContainer();
}
}
@@ -1201,13 +1205,13 @@
floatValueForLength(style->perspectiveOriginY(), borderBox.height()));
}
-RenderLayer* RenderLayer::stackingContext() const
+RenderLayer* RenderLayer::stackingContainer() const
{
RenderLayer* layer = parent();
- while (layer && !layer->isStackingContext())
+ while (layer && !layer->isStackingContainer())
layer = layer->parent();
- ASSERT(!layer || layer->isStackingContext());
+ ASSERT(!layer || layer->isStackingContainer());
return layer;
}
@@ -1257,7 +1261,7 @@
static inline const RenderLayer* compositingContainer(const RenderLayer* layer)
{
- return layer->isNormalFlowOnly() ? layer->parent() : layer->stackingContext();
+ return layer->isNormalFlowOnly() ? layer->parent() : layer->stackingContainer();
}
inline bool RenderLayer::shouldRepaintAfterLayout() const
@@ -1471,7 +1475,7 @@
// no need to examine child layers).
if (!layer->renderer()->hasMask()) {
// Note: we don't have to walk z-order lists since transparent elements always establish
- // a stacking context. This means we can just walk the layer tree directly.
+ // a stacking container. This means we can just walk the layer tree directly.
for (RenderLayer* curr = layer->firstChild(); curr; curr = curr->nextSibling()) {
if (!layer->reflection() || layer->reflectionLayer() != curr)
clipRect.unite(transparencyClipBox(curr, rootLayer, paintBehavior));
@@ -1586,10 +1590,10 @@
dirtyNormalFlowList();
if (!child->isNormalFlowOnly() || child->firstChild()) {
- // Dirty the z-order list in which we are contained. The stackingContext() can be null in the
+ // Dirty the z-order list in which we are contained. The stackingContainer() can be null in the
// case where we're building up generated content layers. This is ok, since the lists will start
// off dirty in that case anyway.
- child->dirtyStackingContextZOrderLists();
+ child->dirtyStackingContainerZOrderLists();
}
child->updateDescendantDependentFlags();
@@ -1630,8 +1634,8 @@
if (!oldChild->isNormalFlowOnly() || oldChild->firstChild()) {
// Dirty the z-order list in which we are contained. When called via the
// reattachment process in removeOnlyThisLayer, the layer may already be disconnected
- // from the main layer tree, so we need to null-check the |stackingContext| value.
- oldChild->dirtyStackingContextZOrderLists();
+ // from the main layer tree, so we need to null-check the |stackingContainer| value.
+ oldChild->dirtyStackingContainerZOrderLists();
}
if ((oldChild->renderer() && oldChild->renderer()->isOutOfFlowPositioned()) || oldChild->hasOutOfFlowPositionedDescendant())
@@ -1865,7 +1869,7 @@
m_needsCompositedScrolling = false;
else {
bool forceUseCompositedScrolling = acceleratedCompositingForOverflowScrollEnabled()
- && canSafelyEstablishAStackingContext()
+ && canBeStackingContainer()
&& !hasOutOfFlowPositionedDescendant();
#if ENABLE(ACCELERATED_OVERFLOW_SCROLLING)
@@ -1875,8 +1879,18 @@
#endif
}
- if (oldNeedsCompositedScrolling != m_needsCompositedScrolling)
+ if (oldNeedsCompositedScrolling != m_needsCompositedScrolling) {
updateSelfPaintingLayer();
+ if (isStackingContainer())
+ dirtyZOrderLists();
+ else
+ clearZOrderLists();
+
+ dirtyStackingContainerZOrderLists();
+
+ compositor()->setShouldReevaluateCompositingAfterLayout();
+ compositor()->setCompositingLayersNeedRebuild();
+ }
}
#endif
@@ -2171,9 +2185,9 @@
{
#if USE(ACCELERATED_COMPOSITING)
if (compositor()->inCompositingMode()) {
- // Our stacking context is guaranteed to contain all of our descendants that may need
+ // Our stacking container is guaranteed to contain all of our descendants that may need
// repositioning, so update compositing layers from there.
- if (RenderLayer* compositingAncestor = stackingContext()->enclosingCompositingLayer()) {
+ if (RenderLayer* compositingAncestor = stackingContainer()->enclosingCompositingLayer()) {
if (compositor()->compositingConsultsOverlap())
compositor()->updateCompositingLayers(CompositingUpdateOnScroll, compositingAncestor);
else
@@ -3786,7 +3800,7 @@
{
// We need to do multiple passes, breaking up our child layer into strips.
Vector<RenderLayer*> columnLayers;
- RenderLayer* ancestorLayer = isNormalFlowOnly() ? parent() : stackingContext();
+ RenderLayer* ancestorLayer = isNormalFlowOnly() ? parent() : stackingContainer();
for (RenderLayer* curr = childLayer->parent(); curr; curr = curr->parent()) {
if (curr->renderer()->hasColumns() && checkContainingBlockChainForPagination(childLayer->renderer(), curr->renderBox()))
columnLayers.append(curr);
@@ -4300,7 +4314,7 @@
const LayoutRect& hitTestRect, const HitTestLocation& hitTestLocation, const HitTestingTransformState* transformState, double* zOffset)
{
Vector<RenderLayer*> columnLayers;
- RenderLayer* ancestorLayer = isNormalFlowOnly() ? parent() : stackingContext();
+ RenderLayer* ancestorLayer = isNormalFlowOnly() ? parent() : stackingContainer();
for (RenderLayer* curr = childLayer->parent(); curr; curr = curr->parent()) {
if (curr->renderer()->hasColumns() && checkContainingBlockChainForPagination(childLayer->renderer(), curr->renderBox()))
columnLayers.append(curr);
@@ -4862,7 +4876,7 @@
}
}
- ASSERT(isStackingContext() || (!posZOrderList() || !posZOrderList()->size()));
+ ASSERT(isStackingContainer() || (!posZOrderList() || !posZOrderList()->size()));
#if !ASSERT_DISABLED
LayerListMutationDetector mutationChecker(const_cast<RenderLayer*>(this));
@@ -5043,7 +5057,7 @@
void RenderLayer::dirtyZOrderLists()
{
ASSERT(m_layerListMutationAllowed);
- ASSERT(isStackingContext());
+ ASSERT(isStackingContainer());
if (m_posZOrderList)
m_posZOrderList->clear();
@@ -5060,9 +5074,9 @@
#endif
}
-void RenderLayer::dirtyStackingContextZOrderLists()
+void RenderLayer::dirtyStackingContainerZOrderLists()
{
- RenderLayer* sc = stackingContext();
+ RenderLayer* sc = stackingContainer();
if (sc)
sc->dirtyZOrderLists();
}
@@ -5087,8 +5101,13 @@
void RenderLayer::rebuildZOrderLists()
{
ASSERT(m_layerListMutationAllowed);
- ASSERT(isDirtyStackingContext());
+ ASSERT(isDirtyStackingContainer());
+ rebuildZOrderLists(StopAtStackingContainers, m_posZOrderList, m_negZOrderList);
+ m_zOrderListsDirty = false;
+}
+void RenderLayer::rebuildZOrderLists(CollectLayersBehavior behavior, OwnPtr<Vector<RenderLayer*> >& posZOrderList, OwnPtr<Vector<RenderLayer*> >& negZOrderList)
+{
#if USE(ACCELERATED_COMPOSITING)
bool includeHiddenLayers = compositor()->inCompositingMode();
#else
@@ -5096,14 +5115,14 @@
#endif
for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
if (!m_reflection || reflectionLayer() != child)
- child->collectLayers(includeHiddenLayers, m_posZOrderList, m_negZOrderList);
+ child->collectLayers(includeHiddenLayers, behavior, posZOrderList, negZOrderList);
// Sort the two lists.
- if (m_posZOrderList)
- std::stable_sort(m_posZOrderList->begin(), m_posZOrderList->end(), compareZIndex);
+ if (posZOrderList)
+ std::stable_sort(posZOrderList->begin(), posZOrderList->end(), compareZIndex);
- if (m_negZOrderList)
- std::stable_sort(m_negZOrderList->begin(), m_negZOrderList->end(), compareZIndex);
+ if (negZOrderList)
+ std::stable_sort(negZOrderList->begin(), negZOrderList->end(), compareZIndex);
#if ENABLE(DIALOG_ELEMENT)
// Append layers for top layer elements after normal layer collection, to ensure they are on top regardless of z-indexes.
@@ -5114,13 +5133,11 @@
Element* childElement = child->node()->isElementNode() ? toElement(child->node()) : 0;
if (childElement && childElement->isInTopLayer()) {
RenderLayer* layer = toRenderLayerModelObject(child)->layer();
- m_posZOrderList->append(layer);
+ posZOrderList->append(layer);
}
}
}
#endif
-
- m_zOrderListsDirty = false;
}
void RenderLayer::updateNormalFlowList()
@@ -5142,7 +5159,7 @@
m_normalFlowListDirty = false;
}
-void RenderLayer::collectLayers(bool includeHiddenLayers, OwnPtr<Vector<RenderLayer*> >& posBuffer, OwnPtr<Vector<RenderLayer*> >& negBuffer)
+void RenderLayer::collectLayers(bool includeHiddenLayers, CollectLayersBehavior behavior, OwnPtr<Vector<RenderLayer*> >& posBuffer, OwnPtr<Vector<RenderLayer*> >& negBuffer)
{
#if ENABLE(DIALOG_ELEMENT)
if (isInTopLayer())
@@ -5152,7 +5169,8 @@
updateDescendantDependentFlags();
// Overflow layers are just painted by their enclosing layers, so they don't get put in zorder lists.
- bool includeHiddenLayer = includeHiddenLayers || (m_hasVisibleContent || (m_hasVisibleDescendant && isStackingContext()));
+ bool isStacking = behavior == StopAtStackingContexts ? isStackingContext() : isStackingContainer();
+ bool includeHiddenLayer = includeHiddenLayers || (m_hasVisibleContent || (m_hasVisibleDescendant && isStacking));
if (includeHiddenLayer && !isNormalFlowOnly() && !renderer()->isRenderFlowThread()) {
// Determine which buffer the child should be in.
OwnPtr<Vector<RenderLayer*> >& buffer = (zIndex() >= 0) ? posBuffer : negBuffer;
@@ -5166,12 +5184,12 @@
}
// Recur into our children to collect more layers, but only if we don't establish
- // a stacking context.
- if ((includeHiddenLayers || m_hasVisibleDescendant) && !isStackingContext()) {
+ // a stacking context/container.
+ if ((includeHiddenLayers || m_hasVisibleDescendant) && !isStacking) {
for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
// Ignore reflections.
if (!m_reflection || reflectionLayer() != child)
- child->collectLayers(includeHiddenLayers, posBuffer, negBuffer);
+ child->collectLayers(includeHiddenLayers, behavior, posBuffer, negBuffer);
}
}
}
@@ -5188,15 +5206,20 @@
reflectionLayer->updateNormalFlowList();
}
- if (shouldUpdateDescendantsAreContiguousInStackingOrder)
+ if (shouldUpdateDescendantsAreContiguousInStackingOrder) {
updateDescendantsAreContiguousInStackingOrder();
+ // The above function can cause us to update m_needsCompositedScrolling
+ // and dirty our layer lists. Refresh them if necessary.
+ updateZOrderLists();
+ updateNormalFlowList();
+ }
}
void RenderLayer::updateCompositingAndLayerListsIfNeeded()
{
#if USE(ACCELERATED_COMPOSITING)
if (compositor()->inCompositingMode()) {
- if (isDirtyStackingContext() || m_normalFlowListDirty)
+ if (isDirtyStackingContainer() || m_normalFlowListDirty)
compositor()->updateCompositingLayers(CompositingUpdateOnHitTest, this);
return;
}
@@ -5317,7 +5340,7 @@
bool wasStackingContext = isStackingContext(oldStyle);
bool isStackingContext = this->isStackingContext();
if (isStackingContext != wasStackingContext) {
- dirtyStackingContextZOrderLists();
+ dirtyStackingContainerZOrderLists();
if (isStackingContext)
dirtyZOrderLists();
else
@@ -5328,7 +5351,7 @@
// FIXME: RenderLayer already handles visibility changes through our visiblity dirty bits. This logic could
// likely be folded along with the rest.
if (oldStyle->zIndex() != renderer()->style()->zIndex() || oldStyle->visibility() != renderer()->style()->visibility()) {
- dirtyStackingContextZOrderLists();
+ dirtyStackingContainerZOrderLists();
if (isStackingContext)
dirtyZOrderLists();
}
@@ -5424,7 +5447,7 @@
RenderLayer* p = parent();
if (p)
p->dirtyNormalFlowList();
- dirtyStackingContextZOrderLists();
+ dirtyStackingContainerZOrderLists();
}
if (renderer()->style()->overflowX() == OMARQUEE && renderer()->style()->marqueeBehavior() != MNONE && renderer()->isBox()) {
@@ -5478,7 +5501,7 @@
else if (m_backing)
m_backing->updateGraphicsLayerGeometry();
else if (oldStyle && oldStyle->overflowX() != renderer()->style()->overflowX()) {
- if (stackingContext()->hasCompositingDescendant())
+ if (stackingContainer()->hasCompositingDescendant())
compositor()->setCompositingLayersNeedRebuild();
}
#endif
Modified: branches/chromium/1364/Source/WebCore/rendering/RenderLayer.h (141261 => 141262)
--- branches/chromium/1364/Source/WebCore/rendering/RenderLayer.h 2013-01-30 14:31:51 UTC (rev 141261)
+++ branches/chromium/1364/Source/WebCore/rendering/RenderLayer.h 2013-01-30 14:36:50 UTC (rev 141262)
@@ -426,18 +426,25 @@
void clearBlockSelectionGapsBounds();
void repaintBlockSelectionGaps();
- // Get the enclosing stacking context for this layer. A stacking context is a layer
- // that has a non-auto z-index.
- RenderLayer* stackingContext() const;
+ // A stacking context is a layer that has a non-auto z-index.
bool isStackingContext() const { return isStackingContext(renderer()->style()); }
+ // A stacking container can have z-order lists. All stacking contexts are
+ // stacking containers, but the converse is not true. Layers that use
+ // compositied 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.
+ RenderLayer* stackingContainer() const;
+
void dirtyZOrderLists();
- void dirtyStackingContextZOrderLists();
+ void dirtyStackingContainerZOrderLists();
Vector<RenderLayer*>* posZOrderList() const
{
ASSERT(!m_zOrderListsDirty);
- ASSERT(isStackingContext() || !m_posZOrderList);
+ ASSERT(isStackingContainer() || !m_posZOrderList);
return m_posZOrderList.get();
}
@@ -446,7 +453,7 @@
Vector<RenderLayer*>* negZOrderList() const
{
ASSERT(!m_zOrderListsDirty);
- ASSERT(isStackingContext() || !m_negZOrderList);
+ ASSERT(isStackingContainer() || !m_negZOrderList);
return m_negZOrderList.get();
}
@@ -738,15 +745,19 @@
#endif
private:
+ enum CollectLayersBehavior { StopAtStackingContexts, StopAtStackingContainers };
+
void updateZOrderLists();
void rebuildZOrderLists();
+ void rebuildZOrderLists(CollectLayersBehavior, OwnPtr<Vector<RenderLayer*> >&, OwnPtr<Vector<RenderLayer*> >&);
void clearZOrderLists();
void updateNormalFlowList();
bool isStackingContext(const RenderStyle* style) const { return !style->hasAutoZIndex() || isRootLayer(); }
- bool isDirtyStackingContext() const { return m_zOrderListsDirty && isStackingContext(); }
+ bool isDirtyStackingContainer() const { return m_zOrderListsDirty && isStackingContainer(); }
+
void setAncestorChainHasSelfPaintingLayerDescendant();
void dirtyAncestorChainHasSelfPaintingLayerDescendantStatus();
@@ -809,7 +820,7 @@
LayoutUnit renderBoxX() const { return renderBoxLocation().x(); }
LayoutUnit renderBoxY() const { return renderBoxLocation().y(); }
- void collectLayers(bool includeHiddenLayers, OwnPtr<Vector<RenderLayer*> >&, OwnPtr<Vector<RenderLayer*> >&);
+ void collectLayers(bool includeHiddenLayers, CollectLayersBehavior, OwnPtr<Vector<RenderLayer*> >&, OwnPtr<Vector<RenderLayer*> >&);
void updateCompositingAndLayerListsIfNeeded();
@@ -969,8 +980,8 @@
IndirectCompositingReason indirectCompositingReason() const { return static_cast<IndirectCompositingReason>(m_indirectCompositingReason); }
bool mustCompositeForIndirectReasons() const { return m_indirectCompositingReason; }
- // Returns true if z ordering would not change if this layer were to establish a stacking context.
- bool canSafelyEstablishAStackingContext() const;
+ // Returns true if z ordering would not change if this layer were to establish a stacking container.
+ bool canBeStackingContainer() const;
#endif
friend class RenderLayerBacking;
@@ -1138,7 +1149,7 @@
inline void RenderLayer::clearZOrderLists()
{
- ASSERT(!isStackingContext());
+ ASSERT(!isStackingContainer());
m_posZOrderList.clear();
m_negZOrderList.clear();
@@ -1149,7 +1160,7 @@
if (!m_zOrderListsDirty)
return;
- if (!isStackingContext()) {
+ if (!isStackingContainer()) {
clearZOrderLists();
m_zOrderListsDirty = false;
return;
Modified: branches/chromium/1364/Source/WebCore/rendering/RenderLayerCompositor.cpp (141261 => 141262)
--- branches/chromium/1364/Source/WebCore/rendering/RenderLayerCompositor.cpp 2013-01-30 14:31:51 UTC (rev 141261)
+++ branches/chromium/1364/Source/WebCore/rendering/RenderLayerCompositor.cpp 2013-01-30 14:36:50 UTC (rev 141262)
@@ -724,7 +724,7 @@
RenderLayer* RenderLayerCompositor::enclosingNonStackingClippingLayer(const RenderLayer* layer) const
{
for (RenderLayer* curr = layer->parent(); curr != 0; curr = curr->parent()) {
- if (curr->isStackingContext())
+ if (curr->isStackingContainer())
return 0;
if (curr->renderer()->hasClipOrOverflowClip())
@@ -769,7 +769,7 @@
LayerListMutationDetector mutationChecker(layer);
#endif
- if (layer->isStackingContext()) {
+ if (layer->isStackingContainer()) {
if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) {
size_t listSize = negZOrderList->size();
for (size_t i = 0; i < listSize; ++i) {
@@ -787,7 +787,7 @@
}
}
- if (layer->isStackingContext()) {
+ if (layer->isStackingContainer()) {
if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) {
size_t listSize = posZOrderList->size();
for (size_t i = 0; i < listSize; ++i) {
@@ -869,7 +869,7 @@
bool anyDescendantHas3DTransform = false;
- if (layer->isStackingContext()) {
+ if (layer->isStackingContainer()) {
if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) {
size_t listSize = negZOrderList->size();
for (size_t i = 0; i < listSize; ++i) {
@@ -898,7 +898,7 @@
}
}
- if (layer->isStackingContext()) {
+ if (layer->isStackingContainer()) {
if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) {
size_t listSize = posZOrderList->size();
for (size_t i = 0; i < listSize; ++i) {
@@ -1076,7 +1076,7 @@
LayerListMutationDetector mutationChecker(layer);
#endif
- if (layer->isStackingContext()) {
+ if (layer->isStackingContainer()) {
if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) {
size_t listSize = negZOrderList->size();
for (size_t i = 0; i < listSize; ++i) {
@@ -1098,7 +1098,7 @@
}
}
- if (layer->isStackingContext()) {
+ if (layer->isStackingContainer()) {
if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) {
size_t listSize = posZOrderList->size();
for (size_t i = 0; i < listSize; ++i) {
@@ -1293,7 +1293,7 @@
LayerListMutationDetector mutationChecker(layer);
#endif
- if (layer->isStackingContext()) {
+ if (layer->isStackingContainer()) {
if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) {
size_t listSize = negZOrderList->size();
for (size_t i = 0; i < listSize; ++i)
@@ -1307,7 +1307,7 @@
updateLayerTreeGeometry(normalFlowList->at(i), depth + 1);
}
- if (layer->isStackingContext()) {
+ if (layer->isStackingContainer()) {
if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) {
size_t listSize = posZOrderList->size();
for (size_t i = 0; i < listSize; ++i)
@@ -1344,7 +1344,7 @@
LayerListMutationDetector mutationChecker(layer);
#endif
- if (layer->isStackingContext()) {
+ if (layer->isStackingContainer()) {
if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) {
size_t listSize = negZOrderList->size();
for (size_t i = 0; i < listSize; ++i)
@@ -1358,7 +1358,7 @@
updateCompositingDescendantGeometry(compositingAncestor, normalFlowList->at(i), compositedChildrenOnly);
}
- if (layer->isStackingContext()) {
+ if (layer->isStackingContainer()) {
if (Vector<RenderLayer*>* posZOrderList = layer->posZOrderList()) {
size_t listSize = posZOrderList->size();
for (size_t i = 0; i < listSize; ++i)
@@ -1981,7 +1981,7 @@
// position:fixed elements that create their own stacking context (e.g. have an explicit z-index,
// opacity, transform) can get their own composited layer. A stacking context is required otherwise
// z-index and clipping will be broken.
- if (!(renderer->isOutOfFlowPositioned() && renderer->style()->position() == FixedPosition && layer->isStackingContext()))
+ if (!(renderer->isOutOfFlowPositioned() && renderer->style()->position() == FixedPosition && layer->isStackingContainer()))
return false;
if (Settings* settings = m_renderView->document()->settings())
@@ -2555,7 +2555,7 @@
LayerListMutationDetector mutationChecker(const_cast<RenderLayer*>(layer));
#endif
- if (layer->isStackingContext()) {
+ if (layer->isStackingContainer()) {
if (Vector<RenderLayer*>* negZOrderList = layer->negZOrderList()) {
size_t listSize = negZOrderList->size();
for (size_t i = 0; i < listSize; ++i) {
@@ -2605,8 +2605,8 @@
if (layer->renderer()->style()->position() != FixedPosition)
return false;
- for (RenderLayer* stackingContext = layer->stackingContext(); stackingContext; stackingContext = stackingContext->stackingContext()) {
- if (stackingContext->isComposited() && stackingContext->renderer()->style()->position() == FixedPosition)
+ for (RenderLayer* stackingContainer = layer->stackingContainer(); stackingContainer; stackingContainer = stackingContainer->stackingContainer()) {
+ if (stackingContainer->isComposited() && stackingContainer->renderer()->style()->position() == FixedPosition)
return false;
}
