Remove the HashMap in RenderLayerCompositor's overlap map

Source/core/rendering/compositing/RenderLayerCompositor.cpp

 /*
  * Copyright (C) 2009, 2010 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 101 matching lines @@
 public:
     OverlapMap()
         : m_geometryMap(UseTransforms)
     {
         // Begin by assuming the root layer will be composited so that there
         // is something on the stack. The root layer should also never get a
         // finishCurrentOverlapTestingContext() call.
         beginNewOverlapTestingContext();
     }
 
-    void add(const RenderLayer* layer, const IntRect& bounds)
+    void add(const IntRect& bounds)
     {
         // Layers do not contribute to overlap immediately--instead, they will
         // contribute to overlap as soon as they have been recursively processed
         // and popped off the stack.
         ASSERT(m_overlapStack.size() >= 2);
         m_overlapStack[m_overlapStack.size() - 2].add(bounds);
-        m_layers.add(layer);
-    }
-
-    bool contains(const RenderLayer* layer)
-    {
-        return m_layers.contains(layer);
     }
 
     bool overlapsLayers(const IntRect& bounds) const
     {
         return m_overlapStack.last().overlapsLayers(bounds);
     }
 
-    bool isEmpty()
-    {
-        return m_layers.isEmpty();
-    }
-
     void beginNewOverlapTestingContext()
     {
         // This effectively creates a new "clean slate" for overlap state.
         // This is used when we know that a subtree or remaining set of
         // siblings does not need to check overlap with things behind it.
         m_overlapStack.append(OverlapMapContainer());
     }
 
     void finishCurrentOverlapTestingContext()
     {
         // The overlap information on the top of the stack is still necessary
         // for checking overlap of any layers outside this context that may
         // overlap things from inside this context. Therefore, we must merge
         // the information from the top of the stack before popping the stack.
         //
         // FIXME: we may be able to avoid this deep copy by rearranging how
         //        overlapMap state is managed.
         m_overlapStack[m_overlapStack.size() - 2].unite(m_overlapStack.last());
         m_overlapStack.removeLast();
     }
 
     RenderGeometryMap& geometryMap() { return m_geometryMap; }
 
 private:
     Vector<OverlapMapContainer> m_overlapStack;
-    HashSet<const RenderLayer*> m_layers;
     RenderGeometryMap m_geometryMap;
 };
 
 struct CompositingRecursionData {
     CompositingRecursionData(RenderLayer* compAncestor, RenderLayer* mostRecentCompositedLayer, bool testOverlap)
         : m_compositingAncestor(compAncestor)
         , m_mostRecentCompositedLayer(mostRecentCompositedLayer)
         , m_subtreeIsCompositing(false)
         , m_hasUnisolatedCompositedBlendingDescendant(false)
         , m_testingOverlap(testOverlap)
@@ skipping 265 matching lines @@
             // Turn off the overlap map test if bleeding edge features are on.
             OverlapMap* overlapMap = 0;
             if (!RuntimeEnabledFeatures::bleedingEdgeFastPathsEnabled())
                 overlapMap = &overlapTestRequestMap;
 
             // FIXME: Passing these unclippedDescendants down and keeping track
             // of them dynamically, we are requiring a full tree walk. This
             // should be removed as soon as proper overlap testing based on
             // scrolling and animation bounds is implemented (crbug.com/252472).
             Vector<RenderLayer*> unclippedDescendants;
-            computeCompositingRequirements(0, updateRoot, overlapMap, recursionData, saw3DTransform, unclippedDescendants);
+            IntRect absoluteDecendantBoundingBox;
+            computeCompositingRequirements(0, updateRoot, overlapMap, recursionData, saw3DTransform, unclippedDescendants, absoluteDecendantBoundingBox);
         }
 
         {
             TRACE_EVENT0("blink_rendering", "RenderLayerCompositor::assignLayersToBackings");
             assignLayersToBackings(updateRoot, layersChanged);
         }
 
         {
             TRACE_EVENT0("blink_rendering", "RenderLayerCompositor::updateHasVisibleNonLayerContentLoop");
             const FrameView::ScrollableAreaSet* scrollableAreas = m_renderView->frameView()->scrollableAreas();
@@ skipping 390 matching lines @@
     for (RenderLayer* curr = layer->parent(); curr != 0; curr = curr->parent()) {
         if (curr->stackingNode()->isStackingContainer())
             return 0;
 
         if (curr->renderer()->hasClipOrOverflowClip())
             return curr;
     }
     return 0;
 }
 
-void RenderLayerCompositor::addToOverlapMap(OverlapMap& overlapMap, RenderLayer* layer, IntRect& layerBounds, bool& boundsComputed)
+void RenderLayerCompositor::addToOverlapMap(OverlapMap& overlapMap, RenderLayer* layer, IntRect& layerBounds)
 {
     if (layer->isRootLayer())
         return;
 
-    if (!boundsComputed) {
-        // FIXME: If this layer's overlap bounds include its children, we don't need to add its
-        // children's bounds to the overlap map.
-        layerBounds = enclosingIntRect(overlapMap.geometryMap().absoluteRect(layer->overlapBounds()));
-        // Empty rects never intersect, but we need them to for the purposes of overlap testing.
-        if (layerBounds.isEmpty())
-            layerBounds.setSize(IntSize(1, 1));
-        boundsComputed = true;
-    }
-
     IntRect clipRect = pixelSnappedIntRect(layer->clipper().backgroundClipRect(ClipRectsContext(rootRenderLayer(), AbsoluteClipRects)).rect());
     clipRect.intersect(layerBounds);
-    overlapMap.add(layer, clipRect);
-}
-
-void RenderLayerCompositor::addToOverlapMapRecursive(OverlapMap& overlapMap, RenderLayer* layer, RenderLayer* ancestorLayer)
-{
-    if (!canBeComposited(layer) || overlapMap.contains(layer))
-        return;
-
-    // A null ancestorLayer is an indication that 'layer' has already been pushed.
-    if (ancestorLayer)
-        overlapMap.geometryMap().pushMappingsToAncestor(layer, ancestorLayer);
-
-    IntRect bounds;
-    bool haveComputedBounds = false;
-    addToOverlapMap(overlapMap, layer, bounds, haveComputedBounds);
-
-#if !ASSERT_DISABLED
-    LayerListMutationDetector mutationChecker(layer->stackingNode());
-#endif
-
-    RenderLayerStackingNodeIterator iterator(*layer->stackingNode(), AllChildren);
-    while (RenderLayerStackingNode* curNode = iterator.next())
-        addToOverlapMapRecursive(overlapMap, curNode->layer(), layer);
-
-    if (ancestorLayer)
-        overlapMap.geometryMap().popMappingsToAncestor(ancestorLayer);
+    overlapMap.add(clipRect);
 }
 
 //  Recurse through the layers in z-index and overflow order (which is equivalent to painting order)
 //  For the z-order children of a compositing layer:
 //      If a child layers has a compositing layer, then all subsequent layers must
 //      be compositing in order to render above that layer.
 //
 //      If a child in the negative z-order list is compositing, then the layer itself
 //      must be compositing so that its contents render over that child.
 //      This implies that its positive z-index children must also be compositing.
 //
-void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestorLayer, RenderLayer* layer, OverlapMap* overlapMap, CompositingRecursionData& currentRecursionData, bool& descendantHas3DTransform, Vector<RenderLayer*>& unclippedDescendants)
+void RenderLayerCompositor::computeCompositingRequirements(RenderLayer* ancestorLayer, RenderLayer* layer, OverlapMap* overlapMap, CompositingRecursionData& currentRecursionData, bool& descendantHas3DTransform, Vector<RenderLayer*>& unclippedDescendants, IntRect& absoluteDecendantBoundingBox)
 {
     layer->stackingNode()->updateLayerListsIfNeeded();
 
     if (overlapMap)
         overlapMap->geometryMap().pushMappingsToAncestor(layer, ancestorLayer);
 
     // Clear the flag
     layer->setHasCompositingDescendant(false);
     layer->setHasNonCompositedChild(false);
 
@@ skipping 36 matching lines @@
 
         // Remove irrelevant unclipped descendants in reverse order so our stored
         // indices remain valid.
         for (size_t i = 0; i < unclippedDescendantsToRemove.size(); i++)
             unclippedDescendants.remove(unclippedDescendantsToRemove.at(unclippedDescendantsToRemove.size() - i - 1));
 
         if (reasonsToComposite & CompositingReasonOutOfFlowClipping)
             unclippedDescendants.append(layer);
     }
 
-    bool haveComputedBounds = false;
     IntRect absBounds;
-    // If we know for sure the layer is going to be composited, don't bother looking it up in the overlap map.
-    if (overlapMap && !overlapMap->isEmpty() && currentRecursionData.m_testingOverlap && !requiresCompositingOrSquashing(directReasons)) {
-        // If we're testing for overlap, we only need to composite if we overlap something that is already composited.
+    if (overlapMap && !layer->isRootLayer()) {
         absBounds = enclosingIntRect(overlapMap->geometryMap().absoluteRect(layer->overlapBounds()));
-
-        // Empty rects never intersect, but we need them to for the purposes of overlap testing.
+        // Setting the absBounds to 1x1 instead of 0x0 makes very little sense,
+        // but removing this code will make JSGameBench sad.
+        // See https://codereview.chromium.org/13912020/
         if (absBounds.isEmpty())
             absBounds.setSize(IntSize(1, 1));
-        haveComputedBounds = true;
+    }
+    absoluteDecendantBoundingBox = absBounds;
+
+    if (overlapMap && currentRecursionData.m_testingOverlap && !requiresCompositingOrSquashing(directReasons))
         overlapCompositingReason = overlapMap->overlapsLayers(absBounds) ? CompositingReasonOverlap : CompositingReasonNone;
-    }
 
     reasonsToComposite |= overlapCompositingReason;
 
     // If the layer is squashable, but would scroll differently than the
     // most recent backing that it would squash onto, then don't squash it.
     // Note that this happens before we know all possible compositing reasons
     // for this layer, but it's OK because we're just forcing the layer conservatively
     // to be separately composited rather than squashed, anyway.
     if (currentRecursionData.m_mostRecentCompositedLayer && requiresSquashing(reasonsToComposite)
         && layer->scrollsWithRespectTo(currentRecursionData.m_mostRecentCompositedLayer))
@@ skipping 25 matching lines @@
 #if !ASSERT_DISABLED
     LayerListMutationDetector mutationChecker(layer->stackingNode());
 #endif
 
     bool anyDescendantHas3DTransform = false;
     bool willHaveForegroundLayer = false;
 
     if (layer->stackingNode()->isStackingContainer()) {
         RenderLayerStackingNodeIterator iterator(*layer->stackingNode(), NegativeZOrderChildren);
         while (RenderLayerStackingNode* curNode = iterator.next()) {
-            computeCompositingRequirements(layer, curNode->layer(), overlapMap, childRecursionData, anyDescendantHas3DTransform, unclippedDescendants);
+            IntRect absoluteChildDecendantBoundingBox;
+            computeCompositingRequirements(layer, curNode->layer(), overlapMap, childRecursionData, anyDescendantHas3DTransform, unclippedDescendants, absoluteChildDecendantBoundingBox);
+            absoluteDecendantBoundingBox.unite(absoluteChildDecendantBoundingBox);
 
             // If we have to make a layer for this child, make one now so we can have a contents layer
             // (since we need to ensure that the -ve z-order child renders underneath our contents).
             if (childRecursionData.m_subtreeIsCompositing) {
                 reasonsToComposite |= CompositingReasonNegativeZIndexChildren;
 
                 if (!willBeCompositedOrSquashed) {
                     // make layer compositing
                     childRecursionData.m_compositingAncestor = layer;
                     if (overlapMap)
                         overlapMap->beginNewOverlapTestingContext();
                     willBeCompositedOrSquashed = true;
                     willHaveForegroundLayer = true;
 
                     // FIXME: temporary solution for the first negative z-index composited child:
                     //        re-compute the absBounds for the child so that we can add the
                     //        negative z-index child's bounds to the new overlap context.
                     if (overlapMap) {
                         overlapMap->geometryMap().pushMappingsToAncestor(curNode->layer(), layer);
                         IntRect childAbsBounds = enclosingIntRect(overlapMap->geometryMap().absoluteRect(curNode->layer()->overlapBounds()));
-                        bool boundsComputed = true;
                         overlapMap->beginNewOverlapTestingContext();
-                        addToOverlapMap(*overlapMap, curNode->layer(), childAbsBounds, boundsComputed);
+                        addToOverlapMap(*overlapMap, curNode->layer(), childAbsBounds);
                         overlapMap->finishCurrentOverlapTestingContext();
                         overlapMap->geometryMap().popMappingsToAncestor(layer);
                     }
                 }
             }
         }
     }
 
     if (overlapMap && willHaveForegroundLayer) {
         ASSERT(willBeCompositedOrSquashed);
         // A foreground layer effectively is a new backing for all subsequent children, so
         // we don't need to test for overlap with anything behind this. So, we can finish
         // the previous context that was accumulating rects for the negative z-index
         // children, and start with a fresh new empty context.
         overlapMap->finishCurrentOverlapTestingContext();
         overlapMap->beginNewOverlapTestingContext();
         // This layer is going to be composited, so children can safely ignore the fact that there's an
         // animation running behind this layer, meaning they can rely on the overlap map testing again
         childRecursionData.m_testingOverlap = true;
     }
 
     if (requiresCompositing(reasonsToComposite)) {
         currentRecursionData.m_mostRecentCompositedLayer = layer;
         childRecursionData.m_mostRecentCompositedLayer = layer;
     }
 
     RenderLayerStackingNodeIterator iterator(*layer->stackingNode(), NormalFlowChildren | PositiveZOrderChildren);
-    while (RenderLayerStackingNode* curNode = iterator.next())
-        computeCompositingRequirements(layer, curNode->layer(), overlapMap, childRecursionData, anyDescendantHas3DTransform, unclippedDescendants);
+    while (RenderLayerStackingNode* curNode = iterator.next()) {
+        IntRect absoluteChildDecendantBoundingBox;
+        computeCompositingRequirements(layer, curNode->layer(), overlapMap, childRecursionData, anyDescendantHas3DTransform, unclippedDescendants, absoluteChildDecendantBoundingBox);
+        absoluteDecendantBoundingBox.unite(absoluteChildDecendantBoundingBox);
+    }
 
     currentRecursionData.m_mostRecentCompositedLayer = childRecursionData.m_mostRecentCompositedLayer;
 
     // Now that the subtree has been traversed, we can check for compositing reasons that depended on the state of the subtree.
 
     // If we entered compositing mode during the recursion, the root will also need to be composited (as long as accelerated compositing is enabled).
     if (layer->isRootLayer()) {
         if (inCompositingMode() && m_hasAcceleratedCompositing)
             willBeCompositedOrSquashed = true;
     }
 
     // All layers (even ones that aren't being composited) need to get added to
     // the overlap map. Layers that are not separately composited will paint into their
     // compositing ancestor's backing, and so are still considered for overlap.
     if (overlapMap && childRecursionData.m_compositingAncestor && !childRecursionData.m_compositingAncestor->isRootLayer())
-        addToOverlapMap(*overlapMap, layer, absBounds, haveComputedBounds);
+        addToOverlapMap(*overlapMap, layer, absBounds);
 
     if (layer->stackingNode()->isStackingContext()) {
         layer->setShouldIsolateCompositedDescendants(childRecursionData.m_hasUnisolatedCompositedBlendingDescendant);
     } else {
         layer->setShouldIsolateCompositedDescendants(false);
         currentRecursionData.m_hasUnisolatedCompositedBlendingDescendant = childRecursionData.m_hasUnisolatedCompositedBlendingDescendant;
     }
 
     // Now check for reasons to become composited that depend on the state of descendant layers.
     CompositingReasons subtreeCompositingReasons = subtreeReasonsForCompositing(layer->renderer(), childRecursionData.m_subtreeIsCompositing, anyDescendantHas3DTransform);
     reasonsToComposite |= subtreeCompositingReasons;
     if (!willBeCompositedOrSquashed && canBeComposited(layer) && requiresCompositingOrSquashing(subtreeCompositingReasons)) {
         childRecursionData.m_compositingAncestor = layer;
         if (overlapMap) {
             // FIXME: this context push is effectively a no-op but needs to exist for
             // now, because the code is designed to push overlap information to the
             // second-from-top context of the stack.
             overlapMap->beginNewOverlapTestingContext();
-            addToOverlapMapRecursive(*overlapMap, layer);
+            addToOverlapMap(*overlapMap, layer, absoluteDecendantBoundingBox);
         }
         willBeCompositedOrSquashed = true;
     }
 
     // If the original layer is composited, the reflection needs to be, too.
     if (layer->reflectionInfo()) {
         // FIXME: Shouldn't we call computeCompositingRequirements to handle a reflection overlapping with another renderer?
         CompositingReasons reflectionCompositingReason = willBeCompositedOrSquashed ? CompositingReasonReflectionOfCompositedParent : CompositingReasonNone;
         layer->reflectionInfo()->reflectionLayer()->setCompositingReasons(layer->reflectionInfo()->reflectionLayer()->compositingReasons() | reflectionCompositingReason);
     }
@@ skipping 1269 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "LocalFrame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore