Implement the ::backdrop pseudo-element for modal <dialog>.

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 33 matching lines @@
 #include "config.h"
 #include "core/rendering/RenderLayer.h"
 
 #include "CSSPropertyNames.h"
 #include "HTMLNames.h"
 #include "RuntimeEnabledFeatures.h"
 #include "SVGNames.h"
 #include "core/css/PseudoStyleRequest.h"
 #include "core/dom/Document.h"
 #include "core/dom/DocumentEventQueue.h"
+#include "core/dom/PseudoElement.h"
 #include "core/dom/WebCoreMemoryInstrumentation.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/editing/FrameSelection.h"
 #include "core/html/HTMLFrameElement.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/inspector/InspectorInstrumentation.h"
 #include "core/page/EventHandler.h"
 #include "core/page/FocusController.h"
 #include "core/page/Frame.h"
 #include "core/page/FrameView.h"
@@ skipping 4210 matching lines @@
     ASSERT_NOT_REACHED();
     return 0;
 }
 
 bool RenderLayer::isInTopLayer() const
 {
     Node* node = renderer()->node();
     return node && node->isElementNode() && toElement(node)->isInTopLayer();
 }
 
-bool RenderLayer::isInTopLayerSubtree() const
-{
-    for (const RenderLayer* layer = this; layer; layer = layer->parent()) {
-        if (layer->isInTopLayer())
-            return true;
-    }
-    return false;
-}
-
 // Compute the z-offset of the point in the transformState.
 // This is effectively projecting a ray normal to the plane of ancestor, finding where that
 // ray intersects target, and computing the z delta between those two points.
 static double computeZOffset(const HitTestingTransformState& transformState)
 {
     // We got an affine transform, so no z-offset
     if (transformState.m_accumulatedTransform.isAffine())
         return 0;
 
     // Flatten the point into the target plane
@@ skipping 1323 matching lines @@
     if (negZOrderList)
         std::stable_sort(negZOrderList->begin(), negZOrderList->end(), compareZIndex);
 
     // Append layers for top layer elements after normal layer collection, to ensure they are on top regardless of z-indexes.
     // The renderers of top layer elements are children of the view, sorted in top layer stacking order.
     if (isRootLayer()) {
         RenderObject* view = renderer()->view();
         for (RenderObject* child = view->firstChild(); child; child = child->nextSibling()) {
             Element* childElement = (child->node() && child->node()->isElementNode()) ? toElement(child->node()) : 0;
             if (childElement && childElement->isInTopLayer()) {
-                RenderLayer* layer = toRenderLayerModelObject(child)->layer();
-                posZOrderList->append(layer);
+                if (Element* backdrop = childElement->pseudoElement(BACKDROP))
+                    posZOrderList->append(toRenderLayerModelObject(backdrop->renderer())->layer());

[Julien - ping for review, 2013/06/27 22:49:00]

I haven't seen why it's a fine assumption to assume that ::backdrop will have a
RenderLayer.

[falken, 2013/06/28 08:06:52]

Done. ::backdrop gets a non-auto z-index now, like top layer elements. I was
relying on forcing ::backdrop to be out of flow positioned to ensure a
layer, but the non-auto z-index is the sure way.

+                posZOrderList->append(toRenderLayerModelObject(child)->layer());

[Julien - ping for review, 2013/06/27 22:49:00]

The ordering is wrong as |backdrop| should be *below* the element in the top
layer.

[falken, 2013/06/28 08:06:52]

It's correct. The layer list is ordered from bottom of the stack to top.

             }
         }
     }
 }
 
 void RenderLayer::updateNormalFlowList()
 {
     if (!m_normalFlowListDirty)
         return;
 
     ASSERT(m_layerListMutationAllowed);
 
     for (RenderLayer* child = firstChild(); child; child = child->nextSibling()) {
         // Ignore non-overflow layers and reflections.
         if (child->isNormalFlowOnly() && (!m_reflection || reflectionLayer() != child)) {
             if (!m_normalFlowList)
                 m_normalFlowList = adoptPtr(new Vector<RenderLayer*>);
             m_normalFlowList->append(child);
         }
     }
     
     m_normalFlowListDirty = false;
 }
 
 void RenderLayer::collectLayers(bool includeHiddenLayers, OwnPtr<Vector<RenderLayer*> >& posBuffer, OwnPtr<Vector<RenderLayer*> >& negBuffer, const RenderLayer* layerToForceAsStackingContainer, CollectLayersBehavior collectLayersBehavior)
 {
-    if (isInTopLayer())
+    if (isInTopLayer() || isBackdrop())
         return;
 
     updateDescendantDependentFlags();
 
     bool isStacking = false;
     bool isNormalFlow = false;
 
     switch (collectLayersBehavior) {
     case ForceLayerToStackingContainer:
         ASSERT(layerToForceAsStackingContainer);
@@ skipping 720 matching lines @@
     }
 }
 
 void showLayerTree(const WebCore::RenderObject* renderer)
 {
     if (!renderer)
         return;
     showLayerTree(renderer->enclosingLayer());
 }
 #endif