Don't apply clips to children of composited-scrolling elements for overlap testing.

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 47 matching lines @@
   void unite(const OverlapMapContainer& otherContainer) {
     m_layerRects.appendVector(otherContainer.m_layerRects);
     m_boundingBox.unite(otherContainer.m_boundingBox);
   }
 
  private:
   Vector<IntRect, 64> m_layerRects;
   IntRect m_boundingBox;
 };
 
+struct OverlapMapContainers {
+  OverlapMapContainer clipped;
+  OverlapMapContainer unclipped;
+};
+
 class CompositingRequirementsUpdater::OverlapMap {
   WTF_MAKE_NONCOPYABLE(OverlapMap);
 
  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) {
+  // Each rect added is marked as clipped or unclipped. clipped rects may
+  // overlap only with other clipped rects, but unclipped rects may overlap
+  // with anything.
+  //
+  // This is used to model composited overflow scrolling, where PaintLayers
+  // within the scroller are not clipped for overlap testing, whereas
+  // PaintLayers not within it are. This is necessary because PaintLayerClipper
+  // is not smart enough to understand not to clip composited overflow clips,
+  // but still clip otherwise.
+  void add(PaintLayer* layer, const IntRect& bounds, bool isClipped) {
     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.
     DCHECK_GE(m_overlapStack.size(), 2ul);
-    m_overlapStack[m_overlapStack.size() - 2].add(bounds);
+    if (isClipped)
+      m_overlapStack[m_overlapStack.size() - 2].clipped.add(bounds);
+    else
+      m_overlapStack[m_overlapStack.size() - 2].unclipped.add(bounds);
   }
 
-  bool overlapsLayers(const IntRect& bounds) const {
-    return m_overlapStack.last().overlapsLayers(bounds);
+  bool overlapsLayers(const IntRect& bounds, bool isClipped) const {
+    bool clippedOverlap = m_overlapStack.last().clipped.overlapsLayers(bounds);
+    if (isClipped)
+      return clippedOverlap;
+    // Unclipped is allowed to overlap clipped, but not vice-versa.
+    return clippedOverlap ||
+           m_overlapStack.last().unclipped.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
     // siblings does not need to check overlap with things behind it.
-    m_overlapStack.append(OverlapMapContainer());
+    m_overlapStack.append(OverlapMapContainers());
   }
 
   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[m_overlapStack.size() - 2].clipped.unite(
+        m_overlapStack.last().clipped);
+    m_overlapStack[m_overlapStack.size() - 2].unclipped.unite(
+        m_overlapStack.last().unclipped);
     m_overlapStack.removeLast();
   }
 
  private:
-  Vector<OverlapMapContainer> m_overlapStack;
+  Vector<OverlapMapContainers> m_overlapStack;
 };
 
 class CompositingRequirementsUpdater::RecursionData {
  public:
   explicit RecursionData(PaintLayer* compositingAncestor)
       : m_compositingAncestor(compositingAncestor),
         m_subtreeIsCompositing(false),
         m_hasUnisolatedCompositedBlendingDescendant(false),
         m_testingOverlap(true),
         m_hasCompositedScrollingAncestor(false) {}
@@ skipping 100 matching lines @@
       m_compositingReasonFinder.directReasons(layer);
 
   // Video is special. It's the only PaintLayer type that can both have
   // PaintLayer children and whose children can't use its backing to render
   // into. These children (the controls) always need to be promoted into their
   // own layers to draw on top of the accelerated video.
   if (currentRecursionData.m_compositingAncestor &&
       currentRecursionData.m_compositingAncestor->layoutObject()->isVideo())
     directReasons |= CompositingReasonVideoOverlay;
 
+  bool hasCompositedScrollingAncestor =
+      layer->ancestorScrollingLayer() &&
+      (m_compositingReasonFinder.directReasons(
+           layer->ancestorScrollingLayer()) &
+       CompositingReasonOverflowScrollingTouch);
+
+  // TODO(chrishtr): use |hasCompositedScrollingAncestor| instead.
   if (currentRecursionData.m_hasCompositedScrollingAncestor &&
       layer->layoutObject()->styleRef().hasViewportConstrainedPosition())
     directReasons |= CompositingReasonScrollDependentPosition;
 
   bool canBeComposited = compositor->canBeComposited(layer);
   if (canBeComposited) {
     reasonsToComposite |= directReasons;
 
     if (layer->isRootLayer() && compositor->rootShouldAlwaysComposite())
       reasonsToComposite |= CompositingReasonRoot;
@@ skipping 25 matching lines @@
 
   // Next, accumulate reasons related to overlap.
   // If overlap testing is used, this reason will be overridden. If overlap
   // testing is not used, we must assume we overlap if there is anything
   // composited behind us in paint-order.
   CompositingReasons overlapCompositingReason =
       currentRecursionData.m_subtreeIsCompositing
           ? CompositingReasonAssumedOverlap
           : CompositingReasonNone;
 
+  // TODO(chrishtr): use |hasCompositedScrollingAncestor| instead.
   if (currentRecursionData.m_hasCompositedScrollingAncestor) {
     Vector<size_t> unclippedDescendantsToRemove;
     for (size_t i = 0; i < unclippedDescendants.size(); i++) {
       PaintLayer* unclippedDescendant = unclippedDescendants.at(i);
       // If we've reached the containing block of one of the unclipped
       // descendants, that element is no longer relevant to whether or not we
       // should opt in. Unfortunately we can't easily remove from the list
       // while we're iterating, so we have to store it for later removal.
       if (unclippedDescendant->layoutObject()->containingBlock() ==
           layer->layoutObject()) {
@@ skipping 12 matching lines @@
     }
 
     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();
+  const IntRect& absBounds = hasCompositedScrollingAncestor
+                                 ? layer->unclippedAbsoluteBoundingBox()
+                                 : layer->clippedAbsoluteBoundingBox();
   absoluteDescendantBoundingBox = absBounds;
-
   if (currentRecursionData.m_testingOverlap &&
       !requiresCompositingOrSquashing(directReasons)) {
-    overlapCompositingReason = overlapMap.overlapsLayers(absBounds)
-                                   ? CompositingReasonOverlap
-                                   : CompositingReasonNone;
+    bool overlaps =
+        overlapMap.overlapsLayers(absBounds, !hasCompositedScrollingAncestor);
+    overlapCompositingReason =
+        overlaps ? 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;
 
@@ skipping 41 matching lines @@
           childRecursionData.m_compositingAncestor = layer;
           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.
           overlapMap.beginNewOverlapTestingContext();
           overlapMap.add(curNode->layer(),
-                         curNode->layer()->clippedAbsoluteBoundingBox());
+                         curNode->layer()->clippedAbsoluteBoundingBox(), true);
           overlapMap.finishCurrentOverlapTestingContext();
         }
       }
     }
   }
 
   if (willHaveForegroundLayer) {
     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.
@@ skipping 49 matching lines @@
       compositor->setCompositingModeEnabled(false);
       reasonsToComposite = CompositingReasonNone;
     }
   } else {
     // 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 (childRecursionData.m_compositingAncestor &&
         !childRecursionData.m_compositingAncestor->isRootLayer())
-      overlapMap.add(layer, absBounds);
+      overlapMap.add(layer, absBounds, !hasCompositedScrollingAncestor);
 
     // Now check for reasons to become composited that depend on the state of
     // descendant layers.
     CompositingReasons subtreeCompositingReasons = subtreeReasonsForCompositing(
         layer, childRecursionData.m_subtreeIsCompositing,
         anyDescendantHas3DTransform);
     reasonsToComposite |= subtreeCompositingReasons;
     if (!willBeCompositedOrSquashed && canBeComposited &&
         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);
+      overlapMap.add(layer, absoluteDescendantBoundingBox,
+                     !hasCompositedScrollingAncestor);
       willBeCompositedOrSquashed = true;
     }
 
     if (willBeCompositedOrSquashed) {
       reasonsToComposite |= layer->potentialCompositingReasonsFromStyle() &
                             CompositingReasonInlineTransform;
     }
 
     if (willBeCompositedOrSquashed &&
         layer->layoutObject()->style()->hasBlendMode())
@@ skipping 24 matching lines @@
     descendantHas3DTransform |=
         anyDescendantHas3DTransform || layer->has3DTransform();
   }
 
   // At this point we have finished collecting all reasons to composite this
   // layer.
   layer->setCompositingReasons(reasonsToComposite);
 }
 
 }  // namespace blink