Revert the removal of CompositingReasonOutOfFlowClipping

third_party/WebKit/Source/core/layout/compositing/CompositingRequirementsUpdater.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 59 matching lines @@
 
  public:
   OverlapMap() {
     // 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(PaintLayer* layer, const IntRect& bounds) {
-    ASSERT(!layer->isRootLayer());
+    DCHECK(!layer->isRootLayer());
     if (bounds.isEmpty())
       return;
 
     // 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);
+    DCHECK_GE(m_overlapStack.size(), 2ul);
     m_overlapStack[m_overlapStack.size() - 2].add(bounds);
   }
 
   bool overlapsLayers(const IntRect& bounds) const {
     return m_overlapStack.last().overlapsLayers(bounds);
   }
 
   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
@@ skipping 30 matching lines @@
   bool m_subtreeIsCompositing;
   bool m_hasUnisolatedCompositedBlendingDescendant;
   bool m_testingOverlap;
   bool m_hasCompositedScrollingAncestor;
 };
 
 static bool requiresCompositingOrSquashing(CompositingReasons reasons) {
 #if ENABLE(ASSERT)
   bool fastAnswer = reasons != CompositingReasonNone;
   bool slowAnswer = requiresCompositing(reasons) || requiresSquashing(reasons);
-  ASSERT(fastAnswer == slowAnswer);
+  DCHECK_EQ(fastAnswer, slowAnswer);

[flackr, 2016/10/06 17:23:44]

nit: expected value should come first for equality checks (I'm not sure if it
technically matters for DCHECK but for many of our macros the error message
shows "expected" and "actual" in the resulting message), in this case slowAnswer
would be the expected value since we don't normally compute it.

 #endif
   return reasons != CompositingReasonNone;
 }
 
 static CompositingReasons subtreeReasonsForCompositing(
     PaintLayer* layer,
     bool hasCompositedDescendants,
     bool has3DTransformedDescendants) {
   CompositingReasons subtreeReasons = CompositingReasonNone;
 
   // When a layer has composited descendants, some effects, like 2d transforms,
   // filters, masks etc must be implemented via compositing so that they also
   // apply to those composited descendants.
   if (hasCompositedDescendants) {
     subtreeReasons |= layer->potentialCompositingReasonsFromStyle() &
                       CompositingReasonComboCompositedDescendants;
 
     if (layer->shouldIsolateCompositedDescendants()) {
-      ASSERT(layer->stackingNode()->isStackingContext());
+      DCHECK(layer->stackingNode()->isStackingContext());
       subtreeReasons |= CompositingReasonIsolateCompositedDescendants;
     }
 
     // FIXME: This should move into
     // CompositingReasonFinder::potentialCompositingReasonsFromStyle, but theres
     // a poor interaction with LayoutTextControlSingleLine, which sets this
     // hasOverflowClip directly.
     if (layer->layoutObject()->hasClipRelatedProperty())
       subtreeReasons |= CompositingReasonClipsCompositingDescendants;
 
     if (layer->layoutObject()->style()->position() == FixedPosition)
       subtreeReasons |= CompositingReasonPositionFixedWithCompositedDescendants;
   }
 
   // A layer with preserve-3d or perspective only needs to be composited if
   // there are descendant layers that will be affected by the preserve-3d or
   // perspective.
-  if (has3DTransformedDescendants)
+  if (has3DTransformedDescendants) {
     subtreeReasons |= layer->potentialCompositingReasonsFromStyle() &
                       CompositingReasonCombo3DDescendants;
+  }
 
   return subtreeReasons;
 }
 
 CompositingRequirementsUpdater::CompositingRequirementsUpdater(
     LayoutView& layoutView,
     CompositingReasonFinder& compositingReasonFinder)
     : m_layoutView(layoutView),
       m_compositingReasonFinder(compositingReasonFinder) {}
 
@@ skipping 101 matching lines @@
           layer->layoutObject()) {
         unclippedDescendantsToRemove.append(i);
         continue;
       }
       if (layer->scrollsWithRespectTo(unclippedDescendant))
         reasonsToComposite |= CompositingReasonAssumedOverlap;
     }
 
     // Remove irrelevant unclipped descendants in reverse order so our stored
     // indices remain valid.
-    for (size_t i = 0; i < unclippedDescendantsToRemove.size(); i++)
+    for (size_t i = 0; i < unclippedDescendantsToRemove.size(); i++) {
       unclippedDescendants.remove(unclippedDescendantsToRemove.at(
           unclippedDescendantsToRemove.size() - i - 1));
+    }
 
-    if (layer->clipParent()) {
+    if (reasonsToComposite & CompositingReasonOutOfFlowClipping) {
       // TODO(schenney): We only need to promote when the clipParent is not a
       // descendant of the ancestor scroller, which we do not check for here.
       // Hence we might be promoting needlessly.
       unclippedDescendants.append(layer);
     }
   }
 
   const IntRect& absBounds = layer->clippedAbsoluteBoundingBox();
   absoluteDescendantBoundingBox = absBounds;
 
   if (currentRecursionData.m_testingOverlap &&
-      !requiresCompositingOrSquashing(directReasons))
+      !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.
   RecursionData childRecursionData = currentRecursionData;
   childRecursionData.m_subtreeIsCompositing = false;
 
   bool willBeCompositedOrSquashed =
@@ skipping 48 matching lines @@
           overlapMap.beginNewOverlapTestingContext();
           overlapMap.add(curNode->layer(),
                          curNode->layer()->clippedAbsoluteBoundingBox());
           overlapMap.finishCurrentOverlapTestingContext();
         }
       }
     }
   }
 
   if (willHaveForegroundLayer) {
-    ASSERT(willBeCompositedOrSquashed);
+    DCHECK(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;
@@ skipping 60 matching lines @@
         requiresCompositingOrSquashing(subtreeCompositingReasons)) {
       childRecursionData.m_compositingAncestor = layer;
       // 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();
       overlapMap.add(layer, absoluteDescendantBoundingBox);
       willBeCompositedOrSquashed = true;
     }
 
-    if (willBeCompositedOrSquashed)
+    if (willBeCompositedOrSquashed) {
       reasonsToComposite |= layer->potentialCompositingReasonsFromStyle() &
                             CompositingReasonInlineTransform;
+    }
 
     if (willBeCompositedOrSquashed &&
         layer->layoutObject()->style()->hasBlendMode())
       currentRecursionData.m_hasUnisolatedCompositedBlendingDescendant = true;
 
     // Tell the parent it has compositing descendants.
     if (willBeCompositedOrSquashed)
       currentRecursionData.m_subtreeIsCompositing = true;
 
     // Turn overlap testing off for later layers if it's already off, or if we
@@ skipping 17 matching lines @@
     descendantHas3DTransform |=
         anyDescendantHas3DTransform || layer->has3DTransform();
   }
 
   // At this point we have finished collecting all reasons to composite this
   // layer.
   layer->setCompositingReasons(reasonsToComposite);
 }
 
 }  // namespace blink