WebKit side of merge from r41149 to r41181.

WebCore/rendering/RenderLayer.cpp

Index: WebCore/rendering/RenderLayer.cpp
===================================================================
--- WebCore/rendering/RenderLayer.cpp	(revision 10232)
+++ WebCore/rendering/RenderLayer.cpp	(working copy)
@@ -147,15 +147,15 @@
     , m_inResizeMode(false)
     , m_posZOrderList(0)
     , m_negZOrderList(0)
-    , m_overflowList(0)
+    , m_normalFlowList(0)
     , m_clipRects(0) 
 #ifndef NDEBUG    
     , m_clipRectsRoot(0)
 #endif
     , m_scrollDimensionsDirty(true)
     , m_zOrderListsDirty(true)
-    , m_overflowListDirty(true)
-    , m_isOverflowOnly(shouldBeOverflowOnly())
+    , m_normalFlowListDirty(true)
+    , m_isNormalFlowOnly(shouldBeNormalFlowOnly())
     , m_usedTransparency(false)
     , m_paintingInsideReflection(false)
     , m_inOverflowRelayout(false)
@@ -196,7 +196,7 @@
 
     delete m_posZOrderList;
     delete m_negZOrderList;
-    delete m_overflowList;
+    delete m_normalFlowList;
     delete m_marquee;
 
 #if USE(ACCELERATED_COMPOSITING)
@@ -340,7 +340,7 @@
         RenderBoxModelObject* repaintContainer = renderer()->containerForRepaint();
         m_repaintRect = renderer()->clippedOverflowRectForRepaint(repaintContainer);
         m_outlineBox = renderer()->outlineBoundsForRepaint(repaintContainer);
-        if (!isOverflowOnly())
+        if (!isNormalFlowOnly())
             dirtyStackingContextZOrderLists();
     }
     if (parent())
@@ -560,12 +560,12 @@
     // Compositing layers are parented according to stacking order and overflow list,
     // so we have to check whether the parent is a stacking context, or whether 
     // the child is overflow-only.
-    bool inOverflowList = isOverflowOnly();
+    bool inNormalFlowList = isNormalFlowOnly();
     for (RenderLayer* curr = parent(); curr; curr = curr->parent()) {
-        if (curr->isComposited() && (inOverflowList || curr->isStackingContext()))
+        if (curr->isComposited() && (inNormalFlowList || curr->isStackingContext()))
             return curr;
         
-        inOverflowList = curr->isOverflowOnly();
+        inNormalFlowList = curr->isNormalFlowOnly();
     }
          
     return 0;
@@ -710,10 +710,10 @@
 
     child->setParent(this);
 
-    if (child->isOverflowOnly())
-        dirtyOverflowList();
+    if (child->isNormalFlowOnly())
+        dirtyNormalFlowList();
 
-    if (!child->isOverflowOnly() || child->firstChild()) {
+    if (!child->isNormalFlowOnly() || child->firstChild()) {
         // Dirty the z-order list in which we are contained.  The stackingContext() 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.
@@ -747,9 +747,9 @@
     if (m_last == oldChild)
         m_last = oldChild->previousSibling();
 
-    if (oldChild->isOverflowOnly())
-        dirtyOverflowList();
-    if (!oldChild->isOverflowOnly() || oldChild->firstChild()) { 
+    if (oldChild->isNormalFlowOnly())
+        dirtyNormalFlowList();
+    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.
@@ -1986,8 +1986,8 @@
     }
     
     // Paint any child layers that have overflow.
-    if (m_overflowList)
-        for (Vector<RenderLayer*>::iterator it = m_overflowList->begin(); it != m_overflowList->end(); ++it)
+    if (m_normalFlowList)
+        for (Vector<RenderLayer*>::iterator it = m_normalFlowList->begin(); it != m_normalFlowList->end(); ++it)
             it[0]->paintLayer(rootLayer, p, paintDirtyRect, haveTransparency, paintRestriction, paintingRoot, false, temporaryClipRects);
     
     // Now walk the sorted list of children with positive z-indices.
@@ -2118,9 +2118,9 @@
     }
 
     // Now check our overflow objects.
-    if (m_overflowList) {
-        for (int i = m_overflowList->size() - 1; i >= 0; --i) {
-            insideLayer = m_overflowList->at(i)->hitTestLayer(rootLayer, request, result, hitTestRect, hitTestPoint);
+    if (m_normalFlowList) {
+        for (int i = m_normalFlowList->size() - 1; i >= 0; --i) {
+            insideLayer = m_normalFlowList->at(i)->hitTestLayer(rootLayer, request, result, hitTestRect, hitTestPoint);
             if (insideLayer)
                 return insideLayer;
         }
@@ -2610,11 +2610,11 @@
         sc->dirtyZOrderLists();
 }
 
-void RenderLayer::dirtyOverflowList()
+void RenderLayer::dirtyNormalFlowList()
 {
-    if (m_overflowList)
-        m_overflowList->clear();
-    m_overflowListDirty = true;
+    if (m_normalFlowList)
+        m_normalFlowList->clear();
+    m_normalFlowListDirty = true;
 
 #if USE(ACCELERATED_COMPOSITING)
     if (!renderer()->documentBeingDestroyed())
@@ -2641,21 +2641,21 @@
     m_zOrderListsDirty = false;
 }
 
-void RenderLayer::updateOverflowList()
+void RenderLayer::updateNormalFlowList()
 {
-    if (!m_overflowListDirty)
+    if (!m_normalFlowListDirty)
         return;
         
     for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
         // Ignore non-overflow layers and reflections.
-        if (child->isOverflowOnly() && (!m_reflection || reflectionLayer() != child)) {
-            if (!m_overflowList)
-                m_overflowList = new Vector<RenderLayer*>;
-            m_overflowList->append(child);
+        if (child->isNormalFlowOnly() && (!m_reflection || reflectionLayer() != child)) {
+            if (!m_normalFlowList)
+                m_normalFlowList = new Vector<RenderLayer*>;
+            m_normalFlowList->append(child);
         }
     }
     
-    m_overflowListDirty = false;
+    m_normalFlowListDirty = false;
 }
 
 void RenderLayer::collectLayers(Vector<RenderLayer*>*& posBuffer, Vector<RenderLayer*>*& negBuffer)
@@ -2663,7 +2663,7 @@
     updateVisibilityStatus();
 
     // Overflow layers are just painted by their enclosing layers, so they don't get put in zorder lists.
-    if ((m_hasVisibleContent || (m_hasVisibleDescendant && isStackingContext())) && !isOverflowOnly()) {
+    if ((m_hasVisibleContent || (m_hasVisibleDescendant && isStackingContext())) && !isNormalFlowOnly()) {
         // Determine which buffer the child should be in.
         Vector<RenderLayer*>*& buffer = (zIndex() >= 0) ? posBuffer : negBuffer;
 
@@ -2690,13 +2690,13 @@
 {
 #if USE(ACCELERATED_COMPOSITING)
     if (compositor()->inCompositingMode()) {
-        if ((isStackingContext() && m_zOrderListsDirty) || m_overflowListDirty)
+        if ((isStackingContext() && m_zOrderListsDirty) || m_normalFlowListDirty)
             compositor()->updateCompositingLayers(this);
         return;
     }
 #endif
     updateZOrderLists();
-    updateOverflowList();
+    updateNormalFlowList();
 }
 
 void RenderLayer::repaintIncludingDescendants()
@@ -2740,7 +2740,7 @@
 }
 #endif
 
-bool RenderLayer::shouldBeOverflowOnly() const
+bool RenderLayer::shouldBeNormalFlowOnly() const
 {
     return (renderer()->hasOverflowClip() || renderer()->hasReflection()) && 
            !renderer()->isPositioned() &&
@@ -2751,12 +2751,12 @@
 
 void RenderLayer::styleChanged(StyleDifference diff, const RenderStyle*)
 {
-    bool isOverflowOnly = shouldBeOverflowOnly();
-    if (isOverflowOnly != m_isOverflowOnly) {
-        m_isOverflowOnly = isOverflowOnly;
+    bool isNormalFlowOnly = shouldBeNormalFlowOnly();
+    if (isNormalFlowOnly != m_isNormalFlowOnly) {
+        m_isNormalFlowOnly = isNormalFlowOnly;
         RenderLayer* p = parent();
         if (p)
-            p->dirtyOverflowList();
+            p->dirtyNormalFlowList();
         dirtyStackingContextZOrderLists();
     }