Make OverlapMap a reference. We never actually pass null.

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 488 matching lines @@
         {
             TRACE_EVENT0("blink_rendering", "RenderLayerCompositor::computeCompositingRequirements");
             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;
             IntRect absoluteDecendantBoundingBox;
-            computeCompositingRequirements(0, updateRoot, &overlapTestRequestMap, recursionData, saw3DTransform, unclippedDescendants, absoluteDecendantBoundingBox);
+            computeCompositingRequirements(0, updateRoot, overlapTestRequestMap, recursionData, saw3DTransform, unclippedDescendants, absoluteDecendantBoundingBox);
 #if !ASSERT_DISABLED
             assertNeedsRecomputeBoundsBitsCleared(updateRoot);
 #endif
         }
 
         {
             TRACE_EVENT0("blink_rendering", "RenderLayerCompositor::assignLayersToBackings");
             assignLayersToBackings(updateRoot, layersChanged);
         }
 
@@ skipping 407 matching lines @@
 
 //  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, IntRect& absoluteDecendantBoundingBox)
+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);
+    overlapMap.geometryMap().pushMappingsToAncestor(layer, ancestorLayer);
 
     // Clear the flag
     layer->setHasCompositingDescendant(false);
     layer->setHasNonCompositedChild(false);
 
     // Start by assuming this layer will not need to composite.
     CompositingReasons reasonsToComposite = CompositingReasonNone;
 
     // First accumulate the straightforward compositing reasons.
     CompositingReasons directReasons = m_compositingReasonFinder.directReasons(layer, &m_needsToRecomputeCompositingRequirements);
@@ skipping 32 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);
     }
 
     IntRect absBounds;
-    if (overlapMap && !layer->isRootLayer()) {
+    if (!layer->isRootLayer()) {
         if (currentRecursionData.m_recomputeLayerBoundsUpdateType == ForceUpdate || layer->needsToRecomputeBounds()) {
             // FIXME: If the absolute bounds didn't change, then we don't need to ForceUpdate descendant RenderLayers.
             currentRecursionData.m_recomputeLayerBoundsUpdateType = ForceUpdate;
-            absBounds = enclosingIntRect(overlapMap->geometryMap().absoluteRect(layer->overlapBounds()));
+            absBounds = enclosingIntRect(overlapMap.geometryMap().absoluteRect(layer->overlapBounds()));
             layer->setAbsoluteBoundingBox(absBounds);
         } else {
             absBounds = layer->absoluteBoundingBox();
         }
         // 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));
     }
 
     absoluteDecendantBoundingBox = absBounds;
 
-    if (overlapMap && currentRecursionData.m_testingOverlap && !requiresCompositingOrSquashing(directReasons))
-        overlapCompositingReason = overlapMap->overlapsLayers(absBounds) ? CompositingReasonOverlap : CompositingReasonNone;
+    if (currentRecursionData.m_testingOverlap && !requiresCompositingOrSquashing(directReasons))
+        overlapCompositingReason = overlapMap.overlapsLayers(absBounds) ? CompositingReasonOverlap : CompositingReasonNone;
 
     reasonsToComposite |= overlapCompositingReason;
 
     // The children of this layer don't need to composite, unless there is
     // a compositing layer among them, so start by inheriting the compositing
     // ancestor with m_subtreeIsCompositing set to false.
     CompositingRecursionData childRecursionData(currentRecursionData);
     childRecursionData.m_subtreeIsCompositing = false;
 
     bool willBeCompositedOrSquashed = canBeComposited(layer) && requiresCompositingOrSquashing(reasonsToComposite);
     if (willBeCompositedOrSquashed) {
         // Tell the parent it has compositing descendants.
         currentRecursionData.m_subtreeIsCompositing = true;
         // This layer now acts as the ancestor for kids.
         childRecursionData.m_compositingAncestor = layer;
 
         // Here we know that all children and the layer's own contents can blindly paint into
         // this layer's backing, until a descendant is composited. So, we don't need to check
         // for overlap with anything behind this layer.
-        if (overlapMap)
-            overlapMap->beginNewOverlapTestingContext();
+        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 !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()) {
             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();
+                    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);
-                        // The above call to computeCompositinRequirements will have already updated this layer's absolute bounding box.
-                        overlapMap->beginNewOverlapTestingContext();
-                        ASSERT(!curNode->layer()->needsToRecomputeBounds());
-                        addToOverlapMap(*overlapMap, curNode->layer(), curNode->layer()->absoluteBoundingBox());
-                        overlapMap->finishCurrentOverlapTestingContext();
-                        overlapMap->geometryMap().popMappingsToAncestor(layer);
-                    }
+                    overlapMap.geometryMap().pushMappingsToAncestor(curNode->layer(), layer);
+                    // The above call to computeCompositinRequirements will have already updated this layer's absolute bounding box.
+                    overlapMap.beginNewOverlapTestingContext();
+                    ASSERT(!curNode->layer()->needsToRecomputeBounds());
+                    addToOverlapMap(overlapMap, curNode->layer(), curNode->layer()->absoluteBoundingBox());
+                    overlapMap.finishCurrentOverlapTestingContext();
+                    overlapMap.geometryMap().popMappingsToAncestor(layer);
                 }
             }
         }
     }
 
-    if (overlapMap && willHaveForegroundLayer) {
+    if (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();
+        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;
     }
 
@@ skipping 10 matching lines @@
 
     // 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);
+    if (childRecursionData.m_compositingAncestor && !childRecursionData.m_compositingAncestor->isRootLayer())
+        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();
-            addToOverlapMap(*overlapMap, layer, absoluteDecendantBoundingBox);
-        }
+        // 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();
+        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?
         RenderLayer* reflectionLayer = layer->reflectionInfo()->reflectionLayer();
         reflectionLayer->clearNeedsToRecomputeBounds();
         CompositingReasons reflectionCompositingReason = willBeCompositedOrSquashed ? CompositingReasonReflectionOfCompositedParent : CompositingReasonNone;
         reflectionLayer->setCompositingReasons(reflectionLayer->compositingReasons() | reflectionCompositingReason);
     }
 
     // Subsequent layers in the parent's stacking context may also need to composite.
     if (childRecursionData.m_subtreeIsCompositing)
         currentRecursionData.m_subtreeIsCompositing = true;
 
     if (willBeCompositedOrSquashed && layer->blendInfo().hasBlendMode())
         currentRecursionData.m_hasUnisolatedCompositedBlendingDescendant = true;
 
     // Set the flag to say that this SC has compositing children.
     layer->setHasCompositingDescendant(childRecursionData.m_subtreeIsCompositing);
 
     // Turn overlap testing off for later layers if it's already off, or if we have an animating transform.
     // Note that if the layer clips its descendants, there's no reason to propagate the child animation to the parent layers. That's because
     // we know for sure the animation is contained inside the clipping rectangle, which is already added to the overlap map.
     bool isCompositedClippingLayer = canBeComposited(layer) && (reasonsToComposite & CompositingReasonClipsCompositingDescendants);
     if ((!childRecursionData.m_testingOverlap && !isCompositedClippingLayer) || isRunningAcceleratedTransformAnimation(layer->renderer()))
         currentRecursionData.m_testingOverlap = false;
 
-    if (overlapMap && childRecursionData.m_compositingAncestor == layer && !layer->isRootLayer())
-        overlapMap->finishCurrentOverlapTestingContext();
+    if (childRecursionData.m_compositingAncestor == layer && !layer->isRootLayer())
+        overlapMap.finishCurrentOverlapTestingContext();
 
     if (layer->isRootLayer()) {
         // The root layer needs to be composited if anything else in the tree is composited.
         // Otherwise, we can disable compositing entirely.
         if (childRecursionData.m_subtreeIsCompositing || requiresCompositingOrSquashing(reasonsToComposite) || m_forceCompositingMode) {
             willBeCompositedOrSquashed = true;
             reasonsToComposite |= CompositingReasonRoot;
         } else {
             enableCompositingMode(false);
             willBeCompositedOrSquashed = false;
             reasonsToComposite = CompositingReasonNone;
         }
     }
 
     if (requiresCompositing(reasonsToComposite))
         currentRecursionData.m_mostRecentCompositedLayer = layer;
 
     // At this point we have finished collecting all reasons to composite this layer.
     layer->setCompositingReasons(reasonsToComposite);
 
     if (!willBeCompositedOrSquashed && layer->parent())
         layer->parent()->setHasNonCompositedChild(true);
 
     descendantHas3DTransform |= anyDescendantHas3DTransform || layer->has3DTransform();
-
-    if (overlapMap)
-        overlapMap->geometryMap().popMappingsToAncestor(ancestorLayer);
+    overlapMap.geometryMap().popMappingsToAncestor(ancestorLayer);
 }
 
 void RenderLayerCompositor::SquashingState::updateSquashingStateForNewMapping(CompositedLayerMappingPtr newCompositedLayerMapping, bool hasNewCompositedLayerMapping, LayoutPoint newOffsetFromAbsoluteForSquashingCLM, RenderLayer* newClippingAncestorForMostRecentMapping)
 {
     // The most recent backing is done accumulating any more squashing layers.
     if (hasMostRecentMapping)
         mostRecentMapping->finishAccumulatingSquashingLayers(nextSquashedLayerIndex);
 
     nextSquashedLayerIndex = 0;
     mostRecentMapping = newCompositedLayerMapping;
@@ skipping 1094 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "LocalFrame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore