Land layer squashing behind a flag

Source/core/rendering/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 425 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;
             computeCompositingRequirements(0, updateRoot, &overlapTestRequestMap, recursionData, saw3DTransform, unclippedDescendants);
+        }
 
+        {
+            TRACE_EVENT0("blink_rendering", "RenderLayerCompositor::assignLayersToBackings");
             assignLayersToBackings(updateRoot, layersChanged);
+        }
 
+        {
+            TRACE_EVENT0("blink_rendering", "RenderLayerCompositor::updateHasVisibleNonLayerContent");
             const FrameView::ScrollableAreaSet* scrollableAreas = m_renderView->frameView()->scrollableAreas();
             if (scrollableAreas) {
                 for (FrameView::ScrollableAreaSet::iterator it = scrollableAreas->begin(); it != scrollableAreas->end(); ++it)
                     (*it)->updateHasVisibleNonLayerContent();
             }
         }
+
         needHierarchyAndGeometryUpdate |= layersChanged;
     }
 
     if (needHierarchyAndGeometryUpdate) {
         // Update the hierarchy of the compositing layers.
         Vector<GraphicsLayer*> childList;
         {
             TRACE_EVENT0("blink_rendering", "RenderLayerCompositor::rebuildCompositingLayerTree");
             rebuildCompositingLayerTree(updateRoot, childList, 0);
         }
 
         // Host the document layer in the RenderView's root layer.
         if (RuntimeEnabledFeatures::overlayFullscreenVideoEnabled() && isMainFrame()) {
             RenderVideo* video = findFullscreenVideoRenderer(&m_renderView->document());
             if (video && video->hasCompositedLayerMapping()) {
                 childList.clear();
                 childList.append(video->compositedLayerMapping()->mainGraphicsLayer());
             }
         }
 
         // FIXME: the following comment and if-statement seem wrong. We do traverse visibility:hidden elements.
         // Even when childList is empty, don't drop out of compositing mode if there are
         // composited layers that we didn't hit in our traversal (e.g. because of visibility:hidden).
         if (childList.isEmpty() && !hasAnyAdditionalCompositedLayers(updateRoot))
             destroyRootLayer();
         else
             m_rootContentLayer->setChildren(childList);
     } else if (needGeometryUpdate) {
+

[Ian Vollick, 2013/12/07 02:44:42]

Unnecessary ws change?

[shawnsingh, 2013/12/11 18:50:34]

removed

         // We just need to do a geometry update. This is only used for position:fixed scrolling;
         // most of the time, geometry is updated via RenderLayer::styleChanged().
         updateLayerTreeGeometry(updateRoot);
     }
 
     ASSERT(updateRoot || !m_compositingLayersNeedRebuild);
 
     if (!hasAcceleratedCompositing())
         enableCompositingMode(false);
 
     // The scrolling coordinator may realize that it needs updating while compositing was being updated in this function.
     needsToUpdateScrollingCoordinator |= scrollingCoordinator() ? scrollingCoordinator()->needsToUpdateAfterCompositingChange() : false;
     if (needsToUpdateScrollingCoordinator && isMainFrame() && scrollingCoordinator() && inCompositingMode())
         scrollingCoordinator()->updateAfterCompositingChange();
 
     // Inform the inspector that the layer tree has changed.
     if (isMainFrame())
         InspectorInstrumentation::layerTreeDidChange(page());
 }
 
 void RenderLayerCompositor::layerBecameNonComposited(const RenderLayer* renderLayer)
 {
     ASSERT(m_compositedLayerCount > 0);
     --m_compositedLayerCount;
 }
 
+static bool requiresCompositingOrSquashing(CompositingReasons reasons)
+{
+    return reasons != CompositingReasonNone;
+}
+
 static bool requiresCompositing(CompositingReasons reasons)
 {
-    return reasons != CompositingReasonNone;
+    // Any reasons other than overlap or assumed overlap will require the layer to be separately compositing.
+    return reasons & ~CompositingReasonComboAllOverlapReasons;
+}
+
+static bool requiresSquashing(CompositingReasons reasons)
+{
+    // If the layer has overlap or assumed overlap, but no other reasons, then it should be squashed.
+    return !requiresCompositing(reasons) && (reasons & CompositingReasonComboAllOverlapReasons);
 }
 
 void RenderLayerCompositor::addOutOfFlowPositionedLayer(RenderLayer* layer)
 {
     m_outOfFlowPositionedLayers.add(layer);
 }
 
 void RenderLayerCompositor::removeOutOfFlowPositionedLayer(RenderLayer* layer)
 {
     m_outOfFlowPositionedLayers.remove(layer);
@@ skipping 17 matching lines @@
 
             layer->ensureCompositedLayerMapping();
             compositedLayerMappingChanged = true;
 
             // At this time, the ScrollingCooridnator only supports the top-level frame.
             if (layer->isRootLayer() && isMainFrame()) {
                 if (ScrollingCoordinator* scrollingCoordinator = this->scrollingCoordinator())
                     scrollingCoordinator->frameViewRootLayerDidChange(m_renderView->frameView());
             }
 
+            // If this layer was previously squashed, we need to remove its reference to a groupedMapping right away, so
+            // that computing repaint rects will know the layer's correct compositingState.
+            // FIXME: do we need to also remove the layer from it's location in the squashing list of its groupedMapping?
+            // Need to create a test where a squashed layer pops into compositing. And also to cover all other
+            // sorts of compositingState transitions.
+            layer->setGroupedMapping(0);
+
+            // FIXME: it seems premature to compute this before all compositing state has been updated?
             // This layer and all of its descendants have cached repaints rects that are relative to
             // the repaint container, so change when compositing changes; we need to update them here.
             if (layer->parent())
                 layer->repainter().computeRepaintRectsIncludingDescendants();
         }
 
         if (layer->compositedLayerMapping()->updateRequiresOwnBackingStoreForIntrinsicReasons())
             compositedLayerMappingChanged = true;
     } else {
         if (layer->hasCompositedLayerMapping()) {
@@ skipping 46 matching lines @@
     }
 
     return compositedLayerMappingChanged || nonCompositedReasonChanged;
 }
 
 bool RenderLayerCompositor::updateLayerCompositingState(RenderLayer* layer)
 {
     updateDirectCompositingReasons(layer);
     bool layerChanged = allocateOrClearCompositedLayerMapping(layer);
 
+    // FIXME: this is not correct... info may be out of date and squashing returning true doesn't indicate that the layer changed
+    layerChanged = requiresSquashing(layer->compositingReasons());
+
     // See if we need content or clipping layers. Methods called here should assume
     // that the compositing state of descendant layers has not been updated yet.
     if (layer->hasCompositedLayerMapping() && layer->compositedLayerMapping()->updateGraphicsLayerConfiguration())
         layerChanged = true;
 
     return layerChanged;
 }
 
 void RenderLayerCompositor::repaintOnCompositingChange(RenderLayer* layer)
 {
     // If the renderer is not attached yet, no need to repaint.
     if (layer->renderer() != m_renderView && !layer->renderer()->parent())
         return;
 
     RenderLayerModelObject* repaintContainer = layer->renderer()->containerForRepaint();
     if (!repaintContainer)
         repaintContainer = m_renderView;
 
     layer->repainter().repaintIncludingNonCompositingDescendants(repaintContainer);
 }
 
 // This method assumes that layout is up-to-date, unlike repaintOnCompositingChange().
 void RenderLayerCompositor::repaintInCompositedAncestor(RenderLayer* layer, const LayoutRect& rect)
 {
     RenderLayer* compositedAncestor = layer->enclosingCompositingLayerForRepaint(false /*exclude self*/);
     if (compositedAncestor) {
-        ASSERT(compositedAncestor->compositingState() == PaintsIntoOwnBacking);
-
+        // FIXME: make sure repaintRect is computed correctly for squashed scenario
         LayoutPoint offset;
         layer->convertToLayerCoords(compositedAncestor, offset);
 
         LayoutRect repaintRect = rect;
         repaintRect.moveBy(offset);
 
-        compositedAncestor->repainter().setBackingNeedsRepaintInRect(repaintRect);
+        if (compositedAncestor->compositingState() == PaintsIntoOwnBacking)
+            compositedAncestor->repainter().setBackingNeedsRepaintInRect(repaintRect);
+        else if (compositedAncestor->compositingState() == PaintsIntoGroupedBacking)
+            compositedAncestor->groupedMapping()->squashingLayer()->setNeedsDisplayInRect(repaintRect);
+        else
+            ASSERT_NOT_REACHED();
     }
 }
 
 // The bounds of the GraphicsLayer created for a compositing layer is the union of the bounds of all the descendant
 // RenderLayers that are rendered by the composited RenderLayer.
 IntRect RenderLayerCompositor::calculateCompositedBounds(const RenderLayer* layer, const RenderLayer* ancestorLayer) const
 {
     if (!canBeComposited(layer))
         return IntRect();
 
@@ skipping 142 matching lines @@
         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 && !requiresCompositing(directReasons)) {
+    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.
         absBounds = enclosingIntRect(overlapMap->geometryMap().absoluteRect(layer->overlapBounds()));
 
         // Empty rects never intersect, but we need them to for the purposes of overlap testing.
         if (absBounds.isEmpty())
             absBounds.setSize(IntSize(1, 1));
         haveComputedBounds = true;
         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 willBeComposited = canBeComposited(layer) && requiresCompositing(reasonsToComposite);
+    bool willBeComposited = canBeComposited(layer) && requiresCompositingOrSquashing(reasonsToComposite);
     if (willBeComposited) {
         // 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)
@@ skipping 78 matching lines @@
     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 (!willBeComposited && canBeComposited(layer) && requiresCompositing(subtreeCompositingReasons)) {
+    if (!willBeComposited && 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);
         }
         willBeComposited = true;
     }
@@ skipping 21 matching lines @@
     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 (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 || requiresCompositing(reasonsToComposite) || m_forceCompositingMode) {
+        if (childRecursionData.m_subtreeIsCompositing || requiresCompositingOrSquashing(reasonsToComposite) || m_forceCompositingMode) {
             willBeComposited = true;
             reasonsToComposite |= CompositingReasonRoot;
         } else {
             enableCompositingMode(false);
             willBeComposited = false;
             reasonsToComposite = CompositingReasonNone;
         }
     }
 
     // At this point we have finished collecting all reasons to composite this layer.
     layer->setCompositingReasons(reasonsToComposite);
 
     if (!willBeComposited && layer->parent())
         layer->parent()->setHasNonCompositedChild(true);
 
     descendantHas3DTransform |= anyDescendantHas3DTransform || layer->has3DTransform();
 
     if (overlapMap)
         overlapMap->geometryMap().popMappingsToAncestor(ancestorLayer);
 }
 
-void RenderLayerCompositor::assignLayersToBackings(RenderLayer* layer, bool& layersChanged)
+void RenderLayerCompositor::SquashingState::updateSquashingStateForNewMapping(CompositedLayerMappingPtr newCompositedLayerMapping, bool hasNewCompositedLayerMapping, IntPoint newOffsetFromAbsolute)
+{
+    // The most recent backing is done accumulating any more squashing layers.
+    if (hasMostRecentMapping)
+        mostRecentMapping->finishAccumulatingSquashingLayers(nextSquashedLayerIndex);
+
+    nextSquashedLayerIndex = 0;
+    mostRecentMapping = newCompositedLayerMapping;
+    hasMostRecentMapping = hasNewCompositedLayerMapping;
+    offsetFromAbsolute = newOffsetFromAbsolute;
+}
+
+void RenderLayerCompositor::assignLayersToBackings(RenderLayer* updateRoot, bool& layersChanged)
+{
+    SquashingState squashingState;
+    assignLayersToBackingsInternal(updateRoot, squashingState, layersChanged);
+    if (squashingState.hasMostRecentMapping)
+        squashingState.mostRecentMapping->finishAccumulatingSquashingLayers(squashingState.nextSquashedLayerIndex);
+}
+
+static IntPoint computeOffsetFromAbsolute(RenderLayer* layer)
+{
+    TransformState transformState(TransformState::ApplyTransformDirection, FloatPoint());
+    layer->renderer()->mapLocalToContainer(0, transformState, ApplyContainerFlip);
+    transformState.flatten();
+    return roundedIntPoint(transformState.lastPlanarPoint());
+}
+
+void RenderLayerCompositor::assignLayersToBackingsInternal(RenderLayer* layer, SquashingState& squashingState, bool& layersChanged)
 {
     if (allocateOrClearCompositedLayerMapping(layer))
         layersChanged = true;
 
     if (layer->reflectionInfo() && updateLayerCompositingState(layer->reflectionInfo()->reflectionLayer()))
         layersChanged = true;
 
-    // FIXME: squashing code here: if a layer requiresSquashing(), then assign this layer to the most recent
-    // squashing layer and update recursion state of this function.
+    // Add this layer to a squashing backing if needed.
+    if (isLayerSquashingEnabled()) {
+        // NOTE: In the future as we generalize this, the background of this layer may need to be assigned to a different backing than
+        // the layer's own primary contents. This would happen when we have a composited negative z-index element that needs to
+        // paint on top of the background, but below the layer's main contents. For now, because we always composite layers
+        // when they have a composited negative z-index child, such layers will never need squashing so it is not yet an issue.
+        if (requiresSquashing(layer->compositingReasons())) {
+            // A layer that is squashed with other layers cannot have its own CompositedLayerMapping.
+            ASSERT(!layer->hasCompositedLayerMapping());
+            ASSERT(squashingState.hasMostRecentMapping);
+
+            IntPoint offsetFromAbsolute = computeOffsetFromAbsolute(layer);
+
+            // FIXME: see if we can refactor this to be clearer
+            IntSize offsetFromTargetBacking(offsetFromAbsolute.x() - squashingState.offsetFromAbsolute.x(),
+                offsetFromAbsolute.y() - squashingState.offsetFromAbsolute.y());
+
+            squashingState.mostRecentMapping->addRenderLayerToSquashingGraphicsLayer(layer, offsetFromTargetBacking, squashingState.nextSquashedLayerIndex);
+            squashingState.nextSquashedLayerIndex++;
+
+            // FIXME: does this need to be true here? Do we need more logic to decide when it should be true?
+            layersChanged = true;
+        }
+    }
 
     if (layer->stackingNode()->isStackingContainer()) {
         RenderLayerStackingNodeIterator iterator(*layer->stackingNode(), NegativeZOrderChildren);
         while (RenderLayerStackingNode* curNode = iterator.next())
-            assignLayersToBackings(curNode->layer(), layersChanged);
+            assignLayersToBackingsInternal(curNode->layer(), squashingState, layersChanged);
     }
 
-    // FIXME: squashing code here: if this layer actually becomes separately composited, then we need to update the
-    // squashing layer that subsequent overlapping layers will contribute to.
+    if (isLayerSquashingEnabled()) {
+        // At this point, if the layer is to be "separately" composited, then its backing becomes the most recent in paint-order.
+        if (layer->compositingState() == PaintsIntoOwnBacking || layer->compositingState() == HasOwnBackingButPaintsIntoAncestor) {
+            ASSERT(!requiresSquashing(layer->compositingReasons()));
+            IntPoint offsetFromAbsolute = computeOffsetFromAbsolute(layer);
+            squashingState.updateSquashingStateForNewMapping(layer->compositedLayerMapping(), layer->hasCompositedLayerMapping(), offsetFromAbsolute);
+        }
+    }
 
     RenderLayerStackingNodeIterator iterator(*layer->stackingNode(), NormalFlowChildren | PositiveZOrderChildren);
     while (RenderLayerStackingNode* curNode = iterator.next())
-        assignLayersToBackings(curNode->layer(), layersChanged);
+        assignLayersToBackingsInternal(curNode->layer(), squashingState, layersChanged);
 }
 
 void RenderLayerCompositor::setCompositingParent(RenderLayer* childLayer, RenderLayer* parentLayer)
 {
     ASSERT(!parentLayer || childLayer->ancestorCompositingLayer() == parentLayer);
     ASSERT(childLayer->hasCompositedLayerMapping());
 
     // It's possible to be called with a parent that isn't yet composited when we're doing
     // partial updates as required by painting or hit testing. Just bail in that case;
     // we'll do a full layer update soon.
     if (!parentLayer || !parentLayer->hasCompositedLayerMapping())
         return;
 
     if (parentLayer) {
         GraphicsLayer* hostingLayer = parentLayer->compositedLayerMapping()->parentForSublayers();
         GraphicsLayer* hostedLayer = childLayer->compositedLayerMapping()->childForSuperlayers();
 
         hostingLayer->addChild(hostedLayer);
     } else {
         childLayer->compositedLayerMapping()->childForSuperlayers()->removeFromParent();
     }
 }
 
 void RenderLayerCompositor::removeCompositedChildren(RenderLayer* layer)
 {
     ASSERT(layer->hasCompositedLayerMapping());
+    // FIXME: this is probably not necessary, a leftover from the hacked prototype.
+    if (!layer->hasCompositedLayerMapping())
+        return;
 
     GraphicsLayer* hostingLayer = layer->compositedLayerMapping()->parentForSublayers();
     hostingLayer->removeAllChildren();
 }
 
 bool RenderLayerCompositor::canAccelerateVideoRendering(RenderVideo* o) const
 {
     if (!m_hasAcceleratedCompositing)
         return false;
 
@@ skipping 452 matching lines @@
     layerReasons &= ~CompositingReasonComboAllDirectReasons;
     layerReasons |= directReasonsForCompositing(layer);
     layer->setCompositingReasons(layerReasons);
 }
 
 bool RenderLayerCompositor::needsOwnBacking(const RenderLayer* layer) const
 {
     if (!canBeComposited(layer))
         return false;
 
-    return requiresCompositing(layer->compositingReasons()) || (inCompositingMode() && layer->isRootLayer());
+    // If squashing is disabled, then layers that would have been squashed should just be separately composited.
+    bool needsOwnBackingDueToOverlap = !isLayerSquashingEnabled() && requiresSquashing(layer->compositingReasons());

[Ian Vollick, 2013/12/07 02:44:42]

Does this not imply that the only reason we'd ever squash is overlap? Will that
always be true?

[shawnsingh, 2013/12/11 18:50:34]

No, it may not always be true... re-named variable to avoid this confusion.

+
+    return requiresCompositing(layer->compositingReasons()) || needsOwnBackingDueToOverlap || (inCompositingMode() && layer->isRootLayer());
 }
 
 bool RenderLayerCompositor::canBeComposited(const RenderLayer* layer) const
 {
     // FIXME: We disable accelerated compositing for elements in a RenderFlowThread as it doesn't work properly.
     // See http://webkit.org/b/84900 to re-enable it.
     return m_hasAcceleratedCompositing && layer->isSelfPaintingLayer() && layer->renderer()->flowThreadState() == RenderObject::NotInsideFlowThread;
 }
 
 CompositingReasons RenderLayerCompositor::directReasonsForCompositing(const RenderLayer* layer) const
@@ skipping 44 matching lines @@
 // Return true if the given layer has some ancestor in the RenderLayer hierarchy that clips,
 // up to the enclosing compositing ancestor. This is required because compositing layers are parented
 // according to the z-order hierarchy, yet clipping goes down the renderer hierarchy.
 // Thus, a RenderLayer can be clipped by a RenderLayer that is an ancestor in the renderer hierarchy,
 // but a sibling in the z-order hierarchy.
 bool RenderLayerCompositor::clippedByAncestor(const RenderLayer* layer) const
 {
     if (!layer->hasCompositedLayerMapping() || !layer->parent())
         return false;
 
+    // FIXME: need to see if new semantics of ancestorCompositingLayer() work correctly here?
     const RenderLayer* compositingAncestor = layer->ancestorCompositingLayer();
     if (!compositingAncestor)
         return false;
 
     // If the compositingAncestor clips, that will be taken care of by clipsCompositingDescendants(),
     // so we only care about clipping between its first child that is our ancestor (the computeClipRoot),
     // and layer.
     const RenderLayer* computeClipRoot = 0;
     const RenderLayer* curr = layer;
     while (curr) {
@@ skipping 912 matching lines @@
     } else if (graphicsLayer == m_scrollLayer.get()) {
         name = "Frame Scrolling Layer";
     } else {
         ASSERT_NOT_REACHED();
     }
 
     return name;
 }
 
 } // namespace WebCore