Move squash preventing reasons out of compositing reasons

third_party/WebKit/Source/core/layout/compositing/CompositingLayerAssigner.cpp

 /*
  * Copyright (C) 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2014 Google 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
@@ skipping 94 matching lines @@
             // We can't compute at this time whether the squashing layer update is a no-op,
             // since that requires walking the paint layer tree.
             update = PutInSquashingLayer;
         } else if (layer->groupedMapping() || layer->lostGroupedMapping()) {
             update = RemoveFromSquashingLayer;
         }
     }
     return update;
 }
 
-CompositingReasons CompositingLayerAssigner::getReasonsPreventingSquashing(const PaintLayer* layer, const CompositingLayerAssigner::SquashingState& squashingState)
+SquashingDisallowedReasons CompositingLayerAssigner::getReasonsPreventingSquashing(const PaintLayer* layer, const CompositingLayerAssigner::SquashingState& squashingState)
 {
     if (!squashingState.haveAssignedBackingsToEntireSquashingLayerSubtree)
-        return CompositingReasonSquashingWouldBreakPaintOrder;
+        return SquashingDisallowedReasonWouldBreakPaintOrder;
 
     ASSERT(squashingState.hasMostRecentMapping);
     const PaintLayer& squashingLayer = squashingState.mostRecentMapping->owningLayer();
 
     // FIXME: this special case for video exists only to deal with corner cases
     // where a LayoutVideo does not report that it needs to be directly composited.
     // Video does not currently support sharing a backing, but this could be
     // generalized in the future. The following layout tests fail if we permit the
     // video to share a backing with other layers.
     //
     // compositing/video/video-controls-layer-creation.html
     if (layer->layoutObject()->isVideo() || squashingLayer.layoutObject()->isVideo())
-        return CompositingReasonSquashingVideoIsDisallowed;
+        return SquashingDisallowedReasonSquashingVideoIsDisallowed;
 
     // Don't squash iframes, frames or plugins.
     // FIXME: this is only necessary because there is frame code that assumes that composited frames are not squashed.
     if (layer->layoutObject()->isLayoutPart() || squashingLayer.layoutObject()->isLayoutPart())
-        return CompositingReasonSquashingLayoutPartIsDisallowed;
+        return SquashingDisallowedReasonSquashingLayoutPartIsDisallowed;
 
     if (layer->reflectionInfo())
-        return CompositingReasonSquashingReflectionIsDisallowed;
+        return SquashingDisallowedReasonSquashingReflectionIsDisallowed;
 
     if (squashingWouldExceedSparsityTolerance(layer, squashingState))
-        return CompositingReasonSquashingSparsityExceeded;
+        return SquashingDisallowedReasonSquashingSparsityExceeded;
 
     if (layer->layoutObject()->style()->hasBlendMode() || squashingLayer.layoutObject()->style()->hasBlendMode())
-        return CompositingReasonSquashingBlendingIsDisallowed;
+        return SquashingDisallowedReasonSquashingBlendingIsDisallowed;
 
     // FIXME: this is not efficient, since it walks up the tree. We should store these values on the CompositingInputsCache.
     if (layer->clippingContainer() != squashingLayer.clippingContainer() && !squashingLayer.compositedLayerMapping()->containingSquashedLayer(layer->clippingContainer(), squashingState.nextSquashedLayerIndex))
-        return CompositingReasonSquashingClippingContainerMismatch;
+        return SquashingDisallowedReasonClippingContainerMismatch;
 
     // Composited descendants need to be clipped by a child containment graphics layer, which would not be available if the layer is
     // squashed (and therefore has no CLM nor a child containment graphics layer).
     if (m_compositor->clipsCompositingDescendants(layer))
-        return CompositingReasonSquashedLayerClipsCompositingDescendants;
+        return SquashingDisallowedReasonSquashedLayerClipsCompositingDescendants;
 
     if (layer->scrollsWithRespectTo(&squashingLayer))
-        return CompositingReasonScrollsWithRespectToSquashingLayer;
+        return SquashingDisallowedReasonScrollsWithRespectToSquashingLayer;
 
     if (layer->scrollParent() && layer->hasCompositingDescendant())
-        return CompositingReasonScrollChildWithCompositedDescendants;
+        return SquashingDisallowedReasonScrollChildWithCompositedDescendants;
 
     if (layer->opacityAncestor() != squashingLayer.opacityAncestor())
-        return CompositingReasonSquashingOpacityAncestorMismatch;
+        return SquashingDisallowedReasonOpacityAncestorMismatch;
 
     if (layer->transformAncestor() != squashingLayer.transformAncestor())
-        return CompositingReasonSquashingTransformAncestorMismatch;
+        return SquashingDisallowedReasonTransformAncestorMismatch;
 
     if (layer->hasFilter() || layer->filterAncestor() != squashingLayer.filterAncestor())
-        return CompositingReasonSquashingFilterMismatch;
+        return SquashingDisallowedReasonFilterMismatch;
 
     if (layer->nearestFixedPositionLayer() != squashingLayer.nearestFixedPositionLayer())
-        return CompositingReasonSquashingNearestFixedPositionMismatch;
+        return SquashingDisallowedReasonNearestFixedPositionMismatch;
     ASSERT(layer->layoutObject()->style()->position() != FixedPosition);
 
     if ((squashingLayer.layoutObject()->style()->subtreeWillChangeContents() && squashingLayer.layoutObject()->style()->isRunningAnimationOnCompositor())
         || squashingLayer.layoutObject()->style()->shouldCompositeForCurrentAnimations())
-        return CompositingReasonSquashingLayerIsAnimating;
+        return SquashingDisallowedReasonSquashingLayerIsAnimating;
 
-    return CompositingReasonNone;
+    return SquashingDisallowedReasonsNone;
 }
 
 void CompositingLayerAssigner::updateSquashingAssignment(PaintLayer* layer, SquashingState& squashingState, const CompositingStateTransitionType compositedLayerUpdate,
     Vector<PaintLayer*>& layersNeedingPaintInvalidation)
 {
     // NOTE: In the future as we generalize this, the background of this layer may need to be assigned to a different backing than
     // the squashed PaintLayer'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 (compositedLayerUpdate == PutInSquashingLayer) {
@@ skipping 51 matching lines @@
 
 static ScrollingCoordinator* scrollingCoordinatorFromLayer(PaintLayer& layer)
 {
     Page* page = layer.layoutObject()->frame()->page();
     return (!page) ? nullptr : page->scrollingCoordinator();
 }
 
 void CompositingLayerAssigner::assignLayersToBackingsInternal(PaintLayer* layer, SquashingState& squashingState, Vector<PaintLayer*>& layersNeedingPaintInvalidation)
 {
     if (requiresSquashing(layer->compositingReasons())) {
-        CompositingReasons reasonsPreventingSquashing = getReasonsPreventingSquashing(layer, squashingState);
-        if (reasonsPreventingSquashing)
-            layer->setCompositingReasons(layer->compositingReasons() | reasonsPreventingSquashing);
+        SquashingDisallowedReasons reasonsPreventingSquashing = getReasonsPreventingSquashing(layer, squashingState);
+        if (reasonsPreventingSquashing) {
+            layer->setCompositingReasons(layer->compositingReasons() | CompositingReasonSquashingDisallowed);
+            layer->setSquashingDisallowedReasons(reasonsPreventingSquashing);
+        }
     }
 
     CompositingStateTransitionType compositedLayerUpdate = computeCompositedLayerUpdate(layer);
 
     if (m_compositor->allocateOrClearCompositedLayerMapping(layer, compositedLayerUpdate)) {
         TRACE_LAYER_INVALIDATION(layer, InspectorLayerInvalidationTrackingEvent::NewCompositedLayer);
         layersNeedingPaintInvalidation.append(layer);
         m_layersChanged = true;
         if (ScrollingCoordinator* scrollingCoordinator = scrollingCoordinatorFromLayer(*layer)) {
             if (layer->layoutObject()->style()->hasViewportConstrainedPosition())
@@ skipping 36 matching lines @@
 
     PaintLayerStackingNodeIterator iterator(*layer->stackingNode(), NormalFlowChildren | PositiveZOrderChildren);
     while (PaintLayerStackingNode* curNode = iterator.next())
         assignLayersToBackingsInternal(curNode->layer(), squashingState, layersNeedingPaintInvalidation);
 
     if (squashingState.hasMostRecentMapping && &squashingState.mostRecentMapping->owningLayer() == layer)
         squashingState.haveAssignedBackingsToEntireSquashingLayerSubtree = true;
 }
 
 } // namespace blink