reflow comments in core/layout/compositing,core/observer

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 128 matching lines @@
 #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.
+  // 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());
       subtreeReasons |= CompositingReasonIsolateCompositedDescendants;
     }
 
-    // FIXME: This should move into CompositingReasonFinder::potentialCompositingReasonsFromStyle, but
-    // theres a poor interaction with LayoutTextControlSingleLine, which sets this hasOverflowClip directly.
+    // 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.
+  // 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)
     subtreeReasons |= layer->potentialCompositingReasonsFromStyle() &
                       CompositingReasonCombo3DDescendants;
 
   return subtreeReasons;
 }
 
 CompositingRequirementsUpdater::CompositingRequirementsUpdater(
     LayoutView& layoutView,
     CompositingReasonFinder& compositingReasonFinder)
     : m_layoutView(layoutView),
       m_compositingReasonFinder(compositingReasonFinder) {}
 
 CompositingRequirementsUpdater::~CompositingRequirementsUpdater() {}
 
 void CompositingRequirementsUpdater::update(PaintLayer* root) {
   TRACE_EVENT0("blink", "CompositingRequirementsUpdater::updateRecursive");
 
-  // Go through the layers in presentation order, so that we can compute which Layers need compositing layers.
-  // FIXME: we could maybe do this and the hierarchy update in one pass, but the parenting logic would be more complex.
+  // Go through the layers in presentation order, so that we can compute which
+  // Layers need compositing layers.
+  // FIXME: we could maybe do this and the hierarchy update in one pass, but the
+  // parenting logic would be more complex.
   RecursionData recursionData(root);
   OverlapMap overlapTestRequestMap;
   bool saw3DTransform = false;
 
   // 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<PaintLayer*> unclippedDescendants;
   IntRect absoluteDescendantBoundingBox;
@@ skipping 29 matching lines @@
       layer->layoutObject()->styleRef().hasViewportConstrainedPosition())
     directReasons |= CompositingReasonScrollDependentPosition;
 
   bool canBeComposited = compositor->canBeComposited(layer);
   if (canBeComposited) {
     reasonsToComposite |= directReasons;
 
     if (layer->isRootLayer() && compositor->rootShouldAlwaysComposite())
       reasonsToComposite |= CompositingReasonRoot;
 
-    // Add CompositingReasonOverflowScrollingTouch for layers that do not already have it but need it.
-    // Note that m_compositingReasonFinder.directReasons(layer) already includes CompositingReasonOverflowScrollingTouch for
-    // anything that has layer->needsCompositedScrolling() true. That is, for cases where we explicitly decide not to have LCD
-    // text or cases where the layer will still support LCD text even if the layer is composited.
+    // Add CompositingReasonOverflowScrollingTouch for layers that do not
+    // already have it but need it.
+    // Note that m_compositingReasonFinder.directReasons(layer) already includes
+    // CompositingReasonOverflowScrollingTouch for anything that has
+    // layer->needsCompositedScrolling() true. That is, for cases where we
+    // explicitly decide not to have LCD text or cases where the layer will
+    // still support LCD text even if the layer is composited.
     if (reasonsToComposite && layer->scrollsOverflow() &&
         !layer->needsCompositedScrolling()) {
-      // We can get here for a scroller that will be composited for some other reason and hence will already
-      // use grayscale AA text. We recheck for needsCompositedScrolling ignoring LCD to correctly add the
-      // CompositingReasonOverflowScrollingTouch reason to layers that can support it with grayscale AA text.
+      // We can get here for a scroller that will be composited for some other
+      // reason and hence will already use grayscale AA text. We recheck for
+      // needsCompositedScrolling ignoring LCD to correctly add the
+      // CompositingReasonOverflowScrollingTouch reason to layers that can
+      // support it with grayscale AA text.
       layer->getScrollableArea()->updateNeedsCompositedScrolling(
           PaintLayerScrollableArea::IgnoreLCDText);
       if (layer->needsCompositedScrolling())
         reasonsToComposite |= CompositingReasonOverflowScrollingTouch;
     }
   }
 
   if ((reasonsToComposite & CompositingReasonOverflowScrollingTouch) &&
       !layer->isRootLayer())
     currentRecursionData.m_hasCompositedScrollingAncestor = true;
 
   // 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.
+  // 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;
 
   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()) {
         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++)
       unclippedDescendants.remove(unclippedDescendantsToRemove.at(
           unclippedDescendantsToRemove.size() - i - 1));
 
     if (layer->clipParent()) {
-      // 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.
+      // 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))
     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 =
       canBeComposited && requiresCompositingOrSquashing(reasonsToComposite);
   if (willBeCompositedOrSquashed) {
     // 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.
+    // 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.
     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.
+    // 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 ENABLE(ASSERT)
   LayerListMutationDetector mutationChecker(layer->stackingNode());
 #endif
 
   bool anyDescendantHas3DTransform = false;
   bool willHaveForegroundLayer = false;
 
   if (layer->stackingNode()->isStackingContext()) {
     PaintLayerStackingNodeIterator iterator(*layer->stackingNode(),
                                             NegativeZOrderChildren);
     while (PaintLayerStackingNode* curNode = iterator.next()) {
       IntRect absoluteChildDescendantBoundingBox;
       updateRecursive(layer, curNode->layer(), overlapMap, childRecursionData,
                       anyDescendantHas3DTransform, unclippedDescendants,
                       absoluteChildDescendantBoundingBox);
       absoluteDescendantBoundingBox.unite(absoluteChildDescendantBoundingBox);
 
-      // 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 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;
           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.
+          // 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());
           overlapMap.finishCurrentOverlapTestingContext();
         }
       }
     }
   }
 
   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.
+    // 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
+    // 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;
   }
 
   PaintLayerStackingNodeIterator iterator(
       *layer->stackingNode(), NormalFlowChildren | PositiveZOrderChildren);
   while (PaintLayerStackingNode* curNode = iterator.next()) {
     IntRect absoluteChildDescendantBoundingBox;
     updateRecursive(layer, curNode->layer(), overlapMap, childRecursionData,
                     anyDescendantHas3DTransform, unclippedDescendants,
                     absoluteChildDescendantBoundingBox);
     absoluteDescendantBoundingBox.unite(absoluteChildDescendantBoundingBox);
   }
 
-  // Now that the subtree has been traversed, we can check for compositing reasons that depended on the state of the subtree.
+  // Now that the subtree has been traversed, we can check for compositing
+  // reasons that depended on the state of the subtree.
 
   if (layer->stackingNode()->isStackingContext()) {
     layer->setShouldIsolateCompositedDescendants(
         childRecursionData.m_hasUnisolatedCompositedBlendingDescendant);
   } else {
     layer->setShouldIsolateCompositedDescendants(false);
     currentRecursionData.m_hasUnisolatedCompositedBlendingDescendant =
         childRecursionData.m_hasUnisolatedCompositedBlendingDescendant;
   }
 
-  // Subsequent layers in the parent's stacking context may also need to composite.
+  // Subsequent layers in the parent's stacking context may also need to
+  // composite.
   if (childRecursionData.m_subtreeIsCompositing)
     currentRecursionData.m_subtreeIsCompositing = true;
 
   // Set the flag to say that this SC has compositing children.
   layer->setHasCompositingDescendant(childRecursionData.m_subtreeIsCompositing);
 
   if (layer->isRootLayer()) {
-    // The root layer needs to be composited if anything else in the tree is composited.
-    // Otherwise, we can disable compositing entirely.
+    // 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) ||
         compositor->rootShouldAlwaysComposite()) {
       reasonsToComposite |= CompositingReasonRoot;
       currentRecursionData.m_subtreeIsCompositing = true;
     } else {
       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.
+    // 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);
 
-    // Now check for reasons to become composited that depend on the state of descendant layers.
+    // 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);
       willBeCompositedOrSquashed = true;
     }
 
     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 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.
+    // 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 &&
         (reasonsToComposite & CompositingReasonClipsCompositingDescendants);
     bool isCompositedWithInlineTransform =
         reasonsToComposite & CompositingReasonInlineTransform;
     if ((!childRecursionData.m_testingOverlap && !isCompositedClippingLayer) ||
         layer->layoutObject()->style()->hasCurrentTransformAnimation() ||
         isCompositedWithInlineTransform)
       currentRecursionData.m_testingOverlap = false;
 
     if (childRecursionData.m_compositingAncestor == layer)
       overlapMap.finishCurrentOverlapTestingContext();
 
     descendantHas3DTransform |=
         anyDescendantHas3DTransform || layer->has3DTransform();
   }
 
-  // At this point we have finished collecting all reasons to composite this layer.
+  // At this point we have finished collecting all reasons to composite this
+  // layer.
   layer->setCompositingReasons(reasonsToComposite);
 }
 
 }  // namespace blink