Revert 98735 - Source/WebCore: The HTML5 video element in Safari does not respect "visibility:hid...

Source/WebCore/rendering/RenderLayerBacking.cpp

 /*
  * Copyright (C) 2009, 2010, 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 343 matching lines @@
 
     // Set transform property, if it is not animating. We have to do this here because the transform
     // is affected by the layer dimensions.
     if (!renderer()->animation()->isRunningAcceleratedAnimationOnRenderer(renderer(), CSSPropertyWebkitTransform))
         updateLayerTransform(renderer()->style());
 
     // Set opacity, if it is not animating.
     if (!renderer()->animation()->isRunningAcceleratedAnimationOnRenderer(renderer(), CSSPropertyOpacity))
         updateLayerOpacity(renderer()->style());
     
-    m_owningLayer->updateVisibilityStatus();
-    m_graphicsLayer->setContentsVisible(m_owningLayer->hasVisibleContent());
-    
     RenderStyle* style = renderer()->style();
     m_graphicsLayer->setPreserves3D(style->transformStyle3D() == TransformStyle3DPreserve3D && !renderer()->hasReflection());
     m_graphicsLayer->setBackfaceVisibility(style->backfaceVisibility() == BackfaceVisibilityVisible);
 
     RenderLayer* compAncestor = m_owningLayer->ancestorCompositingLayer();
     
     // We compute everything relative to the enclosing compositing layer.
     LayoutRect ancestorCompositingBounds;
     if (compAncestor) {
         ASSERT(compAncestor->backing());
@@ skipping 408 matching lines @@
 // It may have no children, or all its children may be themselves composited.
 // This is a useful optimization, because it allows us to avoid allocating backing store.
 bool RenderLayerBacking::isSimpleContainerCompositingLayer() const
 {
     RenderObject* renderObject = renderer();
     if (renderObject->isReplaced() ||       // replaced objects are not containers
         renderObject->hasMask())            // masks require special treatment
         return false;
 
     RenderStyle* style = renderObject->style();
-    bool isVisible = m_owningLayer->hasVisibleContent();
 
     // Reject anything that has a border, a border-radius or outline,
     // or any background (color or image).
     // FIXME: we could optimize layers for simple backgrounds.
-    if (isVisible && hasBoxDecorationsOrBackground(renderObject))
+    if (hasBoxDecorationsOrBackground(renderObject))
         return false;
 
-    if (isVisible && m_owningLayer->hasOverflowControls())
+    if (m_owningLayer->hasOverflowControls())
         return false;
 
     // If we have got this far and the renderer has no children, then we're ok.
     if (!renderObject->firstChild())
         return true;
     
     if (renderObject->node() && renderObject->node()->isDocumentNode()) {
         // Look to see if the root object has a non-simple backgound
         RenderObject* rootObject = renderObject->document()->documentElement()->renderer();
         if (!rootObject)
@@ skipping 11 matching lines @@
         RenderObject* bodyObject = (body && body->hasLocalName(bodyTag)) ? body->renderer() : 0;
         if (!bodyObject)
             return false;
         
         style = bodyObject->style();
         
         if (hasBoxDecorationsOrBackgroundImage(style))
             return false;
 
         // Check to see if all the body's children are compositing layers.
-        if (hasVisibleNonCompositingDescendants())
+        if (hasNonCompositingDescendants())
             return false;
         
         return true;
     }
 
     // Check to see if all the renderer's children are compositing layers.
-    if (isVisible && hasVisibleNonCompositingDescendants())
+    if (hasNonCompositingDescendants())
         return false;
     
     return true;
 }
 
 // Conservative test for having no rendered children.
-bool RenderLayerBacking::hasVisibleNonCompositingDescendants() const
+bool RenderLayerBacking::hasNonCompositingDescendants() const
 {
     // Some HTML can cause whitespace text nodes to have renderers, like:
     // <div>
     // <img src=...>
     // </div>
     // so test for 0x0 RenderTexts here
     for (RenderObject* child = renderer()->firstChild(); child; child = child->nextSibling()) {
         if (!child->hasLayer()) {
             if (child->isRenderInline() || !child->isBox())
                 return true;
             
             if (toRenderBox(child)->width() > 0 || toRenderBox(child)->height() > 0)
                 return true;
         }
     }
 
-    if (Vector<RenderLayer*>* normalFlowList = m_owningLayer->normalFlowList()) {
-        size_t listSize = normalFlowList->size();
-        for (size_t i = 0; i < listSize; ++i) {
-            RenderLayer* curLayer = normalFlowList->at(i);
-            if (!curLayer->isComposited() && curLayer->hasVisibleContent())
-                return true;
-        }
-    }
-
     if (m_owningLayer->isStackingContext()) {
-        if (!m_owningLayer->hasVisibleDescendant())
-            return false;
-
         // Use the m_hasCompositingDescendant bit to optimize?
         if (Vector<RenderLayer*>* negZOrderList = m_owningLayer->negZOrderList()) {
             size_t listSize = negZOrderList->size();
             for (size_t i = 0; i < listSize; ++i) {
                 RenderLayer* curLayer = negZOrderList->at(i);
-                if (!curLayer->isComposited() && curLayer->hasVisibleContent())
+                if (!curLayer->isComposited())
                     return true;
             }
         }
 
         if (Vector<RenderLayer*>* posZOrderList = m_owningLayer->posZOrderList()) {
             size_t listSize = posZOrderList->size();
             for (size_t i = 0; i < listSize; ++i) {
                 RenderLayer* curLayer = posZOrderList->at(i);
-                if (!curLayer->isComposited() && curLayer->hasVisibleContent())
+                if (!curLayer->isComposited())
                     return true;
             }
         }
     }
 
+    if (Vector<RenderLayer*>* normalFlowList = m_owningLayer->normalFlowList()) {
+        size_t listSize = normalFlowList->size();
+        for (size_t i = 0; i < listSize; ++i) {
+            RenderLayer* curLayer = normalFlowList->at(i);
+            if (!curLayer->isComposited())
+                return true;
+        }
+    }
+
     return false;
 }
 
 bool RenderLayerBacking::containsPaintedContent() const
 {
     if (isSimpleContainerCompositingLayer() || paintingGoesToWindow() || m_artificiallyInflatedBounds || m_owningLayer->isReflection())
         return false;
 
     if (isDirectlyCompositedImage())
         return false;
@@ skipping 556 matching lines @@
 
     if (m_graphicsLayer->drawsContent())
         return m_graphicsLayer->usingTiledLayer() ? TiledCompositingLayer : NormalCompositingLayer;
     
     return ContainerCompositingLayer;
 }
 
 } // namespace WebCore
 
 #endif // USE(ACCELERATED_COMPOSITING)