Changeset 16988 in webkit

Timestamp:

Oct 11, 2006 8:04:01 AM (18 years ago)

Author:

antti

Message:

LayoutTests:

Reviewed by Hyatt.

Test for ​http://bugs.webkit.org/show_bug.cgi?id=4377

• fast/layers/layer-visibility-expected.checksum: Added.
• fast/layers/layer-visibility-expected.png: Added.
• fast/layers/layer-visibility-expected.txt: Added.
• fast/layers/layer-visibility.html: Added.

WebCore:

Reviewed by Hyatt.

​http://bugs.webkit.org/show_bug.cgi?id=4377

Respect css visibility semantics for layers too

• rendering/RenderContainer.cpp: (WebCore::RenderContainer::removeChildNode): (WebCore::RenderContainer::appendChildNode): (WebCore::RenderContainer::insertChildNode):
• rendering/RenderLayer.cpp: (WebCore::RenderLayer::RenderLayer): (WebCore::RenderLayer::updateLayerPositions): (WebCore::RenderLayer::setHasVisibleContent): (WebCore::RenderLayer::dirtyVisibleContentStatus): (WebCore::RenderLayer::childVisibilityChanged): (WebCore::RenderLayer::dirtyVisibleDescendantStatus): (WebCore::RenderLayer::updateVisibilityStatus): (WebCore::RenderLayer::addChild): (WebCore::RenderLayer::removeChild): (WebCore::RenderLayer::updateZOrderLists): (WebCore::RenderLayer::collectLayers):
• rendering/RenderLayer.h: (WebCore::RenderLayer::hasVisibleContent):
• rendering/RenderObject.cpp: (WebCore::RenderObject::setStyle):

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/fast/layers/layer-visibility-expected.checksum (added)
• LayoutTests/fast/layers/layer-visibility-expected.png (added)
• LayoutTests/fast/layers/layer-visibility-expected.txt (added)
• LayoutTests/fast/layers/layer-visibility.html (added)
• WebCore/ChangeLog (modified) (1 diff)
• WebCore/rendering/RenderContainer.cpp (modified) (3 diffs)
• WebCore/rendering/RenderLayer.cpp (modified) (8 diffs)
• WebCore/rendering/RenderLayer.h (modified) (3 diffs)
• WebCore/rendering/RenderObject.cpp (modified) (1 diff)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2006-10-11  Antti Koivisto  <koivisto@iki.fi>
+
+        Reviewed by Hyatt.
+        
+        Test for http://bugs.webkit.org/show_bug.cgi?id=4377
+
+        * fast/layers/layer-visibility-expected.checksum: Added.
+        * fast/layers/layer-visibility-expected.png: Added.
+        * fast/layers/layer-visibility-expected.txt: Added.
+        * fast/layers/layer-visibility.html: Added.
+
 2006-10-10  Oliver Hunt  <ohunt@apple.com>
 

trunk/WebCore/ChangeLog

@@ +1 @@
+2006-10-11  Antti Koivisto  <koivisto@iki.fi>
+
+        Reviewed by Hyatt.
+        
+        http://bugs.webkit.org/show_bug.cgi?id=4377
+        
+        Respect css visibility semantics for layers too
+
+        * rendering/RenderContainer.cpp:
+        (WebCore::RenderContainer::removeChildNode):
+        (WebCore::RenderContainer::appendChildNode):
+        (WebCore::RenderContainer::insertChildNode):
+        * rendering/RenderLayer.cpp:
+        (WebCore::RenderLayer::RenderLayer):
+        (WebCore::RenderLayer::updateLayerPositions):
+        (WebCore::RenderLayer::setHasVisibleContent):
+        (WebCore::RenderLayer::dirtyVisibleContentStatus):
+        (WebCore::RenderLayer::childVisibilityChanged):
+        (WebCore::RenderLayer::dirtyVisibleDescendantStatus):
+        (WebCore::RenderLayer::updateVisibilityStatus):
+        (WebCore::RenderLayer::addChild):
+        (WebCore::RenderLayer::removeChild):
+        (WebCore::RenderLayer::updateZOrderLists):
+        (WebCore::RenderLayer::collectLayers):
+        * rendering/RenderLayer.h:
+        (WebCore::RenderLayer::hasVisibleContent):
+        * rendering/RenderObject.cpp:
+        (WebCore::RenderObject::setStyle):
+
 2006-10-10  Maciej Stachowiak  <mjs@apple.com>
 

trunk/WebCore/rendering/RenderContainer.cpp

@@ -178 +178 @@
 
     if (!documentBeingDestroyed()) {
-        // Keep our layer hierarchy updated.
-        oldChild->removeLayers(enclosingLayer());
+        // if we remove visible child from an invisible parent, we don't know the layer visibility any more
+        RenderLayer* layer = 0;
+        if (m_style->visibility() != VISIBLE && oldChild->style()->visibility() == VISIBLE && !oldChild->layer()) {
+            layer = enclosingLayer();
+            layer->dirtyVisibleContentStatus();
+        }
+
+         // Keep our layer hierarchy updated.
+        if (oldChild->firstChild() || oldChild->layer()) {
+            if (!layer) layer = enclosingLayer();            
+            oldChild->removeLayers(layer);
+        }
         
         // If oldChild is the start or end of the selection, then clear the selection to
@@ -386 +396 @@
     // Keep our layer hierarchy updated.  Optimize for the common case where we don't have any children
     // and don't have a layer attached to ourselves.
+    RenderLayer* layer = 0;
     if (newChild->firstChild() || newChild->layer()) {
-        RenderLayer* layer = enclosingLayer();
+        layer = enclosingLayer();
         newChild->addLayers(layer, newChild);
+    }
+
+    // if the new child is visible but this object was not, tell the layer it has some visible content
+    // that needs to be drawn and layer visibility optimization can't be used
+    if (style()->visibility() != VISIBLE && newChild->style()->visibility() == VISIBLE && !newChild->layer()) {
+        if (!layer) layer = enclosingLayer();
+        layer->setHasVisibleContent(true);
     }
     
@@ -427 +445 @@
     child->setParent(this);
     
-    // Keep our layer hierarchy updated.
-    RenderLayer* layer = enclosingLayer();
-    child->addLayers(layer, child);
+    // Keep our layer hierarchy updated.  Optimize for the common case where we don't have any children
+    // and don't have a layer attached to ourselves.
+    RenderLayer* layer = 0;
+    if (child->firstChild() || child->layer()) {
+        layer = enclosingLayer();
+        child->addLayers(layer, child);
+    }
+
+    // if the new child is visible but this object was not, tell the layer it has some visible content
+    // that needs to be drawn and layer visibility optimization can't be used
+    if (style()->visibility() != VISIBLE && child->style()->visibility() == VISIBLE && !child->layer()) {
+        if (!layer) layer = enclosingLayer();
+        layer->setHasVisibleContent(true);
+    }
 
     child->setNeedsLayoutAndMinMaxRecalc();

trunk/WebCore/rendering/RenderLayer.cpp

@@ -142 +142 @@
 m_repaintOverflowOnResize(false),
 m_overflowStatusDirty(true),
+m_visibleContentStatusDirty( true ),
+m_hasVisibleContent( false ),
+m_visibleDescendantStatusDirty( false ),
+m_hasVisibleDescendant( false ),
 m_marquee(0)
 {
+    if (!object->firstChild() && object->style()) {
+        m_visibleContentStatusDirty = false;
+        m_hasVisibleContent = object->style()->visibility() == VISIBLE;
+    }
 }
 
@@ -183 +191 @@
     positionOverflowControls();
 
-    // FIXME: Child object could override visibility.
-    if (m_object->style()->visibility() == VISIBLE) {
+    updateVisibilityStatus();
+        
+    if (m_hasVisibleContent) {
         int x, y;
         m_object->absolutePosition(x, y);
@@ -216 +225 @@
     if (m_marquee)
         m_marquee->updateMarqueePosition();
+}
+
+void RenderLayer::setHasVisibleContent(bool b) 
+{ 
+    if (m_hasVisibleContent == b && !m_visibleContentStatusDirty)
+        return;
+    m_visibleContentStatusDirty = false; 
+    m_hasVisibleContent = b;
+    if (parent())
+        parent()->childVisibilityChanged(m_hasVisibleContent);
+}
+
+void RenderLayer::dirtyVisibleContentStatus() 
+{ 
+    m_visibleContentStatusDirty = true; 
+    if (parent())
+        parent()->dirtyVisibleDescendantStatus();
+}
+
+void RenderLayer::childVisibilityChanged(bool newVisibility) 
+{ 
+    if (m_hasVisibleDescendant == newVisibility || m_visibleDescendantStatusDirty)
+        return;
+    if (newVisibility) {
+        RenderLayer* l = this;
+        while (l && !l->m_visibleDescendantStatusDirty && !l->m_hasVisibleDescendant) {
+            l->m_hasVisibleDescendant = true;
+            l = l->parent();
+        }
+    } else 
+        dirtyVisibleDescendantStatus();
+}
+
+void RenderLayer::dirtyVisibleDescendantStatus()
+{
+    RenderLayer* l = this;
+    while (l && !l->m_visibleDescendantStatusDirty) {
+        l->m_visibleDescendantStatusDirty = true;
+        l = l->parent();
+    }
+}
+
+void RenderLayer::updateVisibilityStatus()
+{
+    if (m_visibleDescendantStatusDirty) {
+        m_hasVisibleDescendant = false;
+        for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
+            child->updateVisibilityStatus();        
+            if (child->m_hasVisibleContent || child->m_hasVisibleDescendant) {
+                m_hasVisibleDescendant = true;
+                break;
+            }
+        }
+        m_visibleDescendantStatusDirty = false;
+    }
+
+    if (m_visibleContentStatusDirty) {
+        if (m_object->style()->visibility() == VISIBLE)
+            m_hasVisibleContent = true;
+        else {
+            // layer may be hidden but still have some visible content, check for this
+            m_hasVisibleContent = false;
+            RenderObject* r = m_object->firstChild();
+            while (r) {
+                if (r->style()->visibility() == VISIBLE) {
+                    m_hasVisibleContent = true;
+                    break;
+                }
+                if (r->firstChild() && !r->firstChild()->layer())
+                    r = r->firstChild();
+                else if (r->nextSibling() && !r->nextSibling()->layer())
+                    r = r->nextSibling();
+                else {
+                    while (r && (!r->nextSibling() || r->nextSibling()->layer())) {
+                        r = r->parent();
+                        if (r==m_object)
+                            r = 0;
+                    }
+                    if (r)
+                        r = r->nextSibling();
+                }
+            }
+        }    
+        m_visibleContentStatusDirty = false; 
+    }
 }
 
@@ -445 +539 @@
             stackingContext->dirtyZOrderLists();
     }
+    
+    child->updateVisibilityStatus();
+    if (child->m_hasVisibleContent || child->m_hasVisibleDescendant)
+        childVisibilityChanged(true);
 }
 
@@ -474 +572 @@
     oldChild->setNextSibling(0);
     oldChild->setParent(0);
+    
+    oldChild->updateVisibilityStatus();
+    if (oldChild->m_hasVisibleContent || oldChild->m_hasVisibleDescendant)
+        childVisibilityChanged(false);
     
     return oldChild;
@@ -1813 +1915 @@
     if (!isStackingContext() || !m_zOrderListsDirty)
         return;
-    
+        
     for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
         child->collectLayers(m_posZOrderList, m_negZOrderList);
@@ -1844 +1946 @@
 void RenderLayer::collectLayers(Vector<RenderLayer*>*& posBuffer, Vector<RenderLayer*>*& negBuffer)
 {
-    // FIXME: A child render object or layer could override visibility.  Don't remove this
-    // optimization though until RenderObject's nodeAtPoint is patched to understand what to do
-    // when visibility is overridden by a child.
-    if (renderer()->style()->visibility() != VISIBLE)
-        return;
-
+    updateVisibilityStatus();
+        
     // Overflow layers are just painted by their enclosing layers, so they don't get put in zorder lists.
-    if (!isOverflowOnly()) {
+    if (m_hasVisibleContent && !isOverflowOnly()) {
         // Determine which buffer the child should be in.
         Vector<RenderLayer*>*& buffer = (zIndex() >= 0) ? posBuffer : negBuffer;
@@ -1865 +1963 @@
     // Recur into our children to collect more layers, but only if we don't establish
     // a stacking context.
-    if (!isStackingContext())
+    if (m_hasVisibleDescendant && !isStackingContext())
         for (RenderLayer* child = firstChild(); child; child = child->nextSibling())
             child->collectLayers(posBuffer, negBuffer);

trunk/WebCore/rendering/RenderLayer.h

@@ -273 +273 @@
     void updateOverflowList();
     Vector<RenderLayer*>* overflowList() const { return m_overflowList; }
+    
+    bool hasVisibleContent() const { return m_hasVisibleContent; }
+    void setHasVisibleContent(bool b);
+    void dirtyVisibleContentStatus();
 
     // Gets the nearest enclosing positioned ancestor layer (also includes
@@ -340 +344 @@
 
     void updateOverflowStatus(bool horizontalOverflow, bool verticalOverflow);
+    
+    void childVisibilityChanged(bool newVisibility);
+    void dirtyVisibleDescendantStatus();
+    void updateVisibilityStatus();
+        
 protected:   
     RenderObject* m_object;
@@ -410 +419 @@
     bool m_horizontalOverflow : 1;
     bool m_verticalOverflow : 1;
+    bool m_visibleContentStatusDirty : 1;
+    bool m_hasVisibleContent : 1;
+    bool m_visibleDescendantStatusDirty : 1;
+    bool m_hasVisibleDescendant : 1;
     
     Marquee* m_marquee; // Used by layers with overflow:marquee

trunk/WebCore/rendering/RenderObject.cpp

@@ -2085 +2085 @@
                     layer()->dirtyZOrderLists();
             }
+            // keep layer hierarchy visibility bits up to date if visibility changes
+            if (m_style->visibility() != style->visibility()) {
+                RenderLayer* l = enclosingLayer(); 
+                if (style->visibility() == VISIBLE && l)
+                    l->setHasVisibleContent(true);
+                else if (l && l->hasVisibleContent() && 
+                    (this == l->renderer() || l->renderer()->style()->visibility() != VISIBLE))
+                    l->dirtyVisibleContentStatus();
+            }            
         }