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

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 90 matching lines @@
   if (needsOwnBacking(layer)) {
     if (!layer->hasCompositedLayerMapping()) {
       update = AllocateOwnCompositedLayerMapping;
     }
   } else {
     if (layer->hasCompositedLayerMapping())
       update = RemoveOwnCompositedLayerMapping;
 
     if (!layer->subtreeIsInvisible() && m_compositor->canBeComposited(layer) &&
         requiresSquashing(layer->getCompositingReasons())) {
-      // We can't compute at this time whether the squashing layer update is a no-op,
-      // since that requires walking the paint layer tree.
+      // 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;
 }
 
 SquashingDisallowedReasons
 CompositingLayerAssigner::getReasonsPreventingSquashing(
     const PaintLayer* layer,
     const CompositingLayerAssigner::SquashingState& squashingState) {
   if (!squashingState.haveAssignedBackingsToEntireSquashingLayerSubtree)
     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.
+  // 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 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.
+  // 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 SquashingDisallowedReasonSquashingLayoutPartIsDisallowed;
 
   if (squashingWouldExceedSparsityTolerance(layer, squashingState))
     return SquashingDisallowedReasonSquashingSparsityExceeded;
 
   if (layer->layoutObject()->style()->hasBlendMode() ||
       squashingLayer.layoutObject()->style()->hasBlendMode())
     return SquashingDisallowedReasonSquashingBlendingIsDisallowed;
 
-  // FIXME: this is not efficient, since it walks up the tree. We should store these values on the CompositingInputsCache.
+  // 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 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).
+  // 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 SquashingDisallowedReasonSquashedLayerClipsCompositingDescendants;
 
   if (layer->scrollsWithRespectTo(&squashingLayer))
     return SquashingDisallowedReasonScrollsWithRespectToSquashingLayer;
 
   if (layer->scrollParent() && layer->hasCompositingDescendant())
     return SquashingDisallowedReasonScrollChildWithCompositedDescendants;
 
   if (layer->opacityAncestor() != squashingLayer.opacityAncestor())
@@ skipping 30 matching lines @@
     return SquashingDisallowedReasonFragmentedContent;
 
   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.
+  // 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) {
-    // A layer that is squashed with other layers cannot have its own CompositedLayerMapping.
+    // A layer that is squashed with other layers cannot have its own
+    // CompositedLayerMapping.
     ASSERT(!layer->hasCompositedLayerMapping());
     ASSERT(squashingState.hasMostRecentMapping);
 
     bool changedSquashingLayer =
         squashingState.mostRecentMapping->updateSquashingLayerAssignment(
             layer, squashingState.nextSquashedLayerIndex);
     if (!changedSquashingLayer)
       return;
 
     // If we've modified the collection of squashed layers, we must update
     // the graphics layer geometry.
     squashingState.mostRecentMapping->setNeedsGraphicsLayerUpdate(
         GraphicsLayerUpdateSubtree);
 
     layer->clipper().clearClipRectsIncludingDescendants();
 
-    // Issue a paint invalidation, since |layer| may have been added to an already-existing squashing layer.
+    // Issue a paint invalidation, since |layer| may have been added to an
+    // already-existing squashing layer.
     TRACE_LAYER_INVALIDATION(
         layer, InspectorLayerInvalidationTrackingEvent::AddedToSquashingLayer);
     layersNeedingPaintInvalidation.append(layer);
     m_layersChanged = true;
   } else if (compositedLayerUpdate == RemoveFromSquashingLayer) {
     if (layer->groupedMapping()) {
-      // Before removing |layer| from an already-existing squashing layer that may have other content, issue a paint invalidation.
+      // Before removing |layer| from an already-existing squashing layer that
+      // may have other content, issue a paint invalidation.
       m_compositor->paintInvalidationOnCompositingChange(layer);
       layer->groupedMapping()->setNeedsGraphicsLayerUpdate(
           GraphicsLayerUpdateSubtree);
       layer->setGroupedMapping(nullptr,
                                PaintLayer::InvalidateLayerAndRemoveFromMapping);
     }
 
-    // If we need to issue paint invalidations, do so now that we've removed it from a squashed layer.
+    // If we need to issue paint invalidations, do so now that we've removed it
+    // from a squashed layer.
     TRACE_LAYER_INVALIDATION(
         layer,
         InspectorLayerInvalidationTrackingEvent::RemovedFromSquashingLayer);
     layersNeedingPaintInvalidation.append(layer);
     m_layersChanged = true;
 
     layer->setLostGroupedMapping(false);
   }
 }
 
@@ skipping 49 matching lines @@
   }
 
   if (layer->stackingNode()->isStackingContext()) {
     PaintLayerStackingNodeIterator iterator(*layer->stackingNode(),
                                             NegativeZOrderChildren);
     while (PaintLayerStackingNode* curNode = iterator.next())
       assignLayersToBackingsInternal(curNode->layer(), squashingState,
                                      layersNeedingPaintInvalidation);
   }
 
-  // At this point, if the layer is to be separately composited, then its backing becomes the most recent in paint-order.
+  // 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) {
     ASSERT(!requiresSquashing(layer->getCompositingReasons()));
     squashingState.updateSquashingStateForNewMapping(
         layer->compositedLayerMapping(), layer->hasCompositedLayerMapping(),
         layersNeedingPaintInvalidation);
   }
 
   if (layer->scrollParent())
     layer->scrollParent()->getScrollableArea()->setTopmostScrollChild(layer);
 
   if (layer->needsCompositedScrolling())
     layer->getScrollableArea()->setTopmostScrollChild(nullptr);
 
   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