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

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

 /*
  * Copyright (C) 2009, 2010, 2011 Apple 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
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 144 matching lines @@
 }
 
 static inline bool isAcceleratedContents(LayoutObject* layoutObject) {
   return isAcceleratedCanvas(layoutObject) ||
          (layoutObject->isEmbeddedObject() &&
           toLayoutEmbeddedObject(layoutObject)
               ->requiresAcceleratedCompositing()) ||
          layoutObject->isVideo();
 }
 
-// Get the scrolling coordinator in a way that works inside CompositedLayerMapping's destructor.
+// Get the scrolling coordinator in a way that works inside
+// CompositedLayerMapping's destructor.
 static ScrollingCoordinator* scrollingCoordinatorFromLayer(PaintLayer& layer) {
   Page* page = layer.layoutObject()->frame()->page();
   return (!page) ? nullptr : page->scrollingCoordinator();
 }
 
 CompositedLayerMapping::CompositedLayerMapping(PaintLayer& layer)
     : m_owningLayer(layer),
       m_contentOffsetInCompositingLayerDirty(false),
       m_pendingUpdateScope(GraphicsLayerUpdateNone),
       m_isMainFrameLayoutViewLayer(false),
       m_backgroundLayerPaintsFixedRootBackground(false),
       m_scrollingContentsAreEmpty(false),
       m_backgroundPaintsOntoScrollingContentsLayer(false) {
   if (layer.isRootLayer() && layoutObject()->frame()->isMainFrame())
     m_isMainFrameLayoutViewLayer = true;
 
   createPrimaryGraphicsLayer();
 }
 
 CompositedLayerMapping::~CompositedLayerMapping() {
   // Hits in compositing/squashing/squash-onto-nephew.html.
   DisableCompositingQueryAsserts disabler;
 
-  // Do not leave the destroyed pointer dangling on any Layers that painted to this mapping's squashing layer.
+  // Do not leave the destroyed pointer dangling on any Layers that painted to
+  // this mapping's squashing layer.
   for (size_t i = 0; i < m_squashedLayers.size(); ++i) {
     PaintLayer* oldSquashedLayer = m_squashedLayers[i].paintLayer;
     // Assert on incorrect mappings between layers and groups
     ASSERT(oldSquashedLayer->groupedMapping() == this);
     if (oldSquashedLayer->groupedMapping() == this) {
       oldSquashedLayer->setGroupedMapping(
           0, PaintLayer::DoNotInvalidateLayerAndRemoveFromMapping);
       oldSquashedLayer->setLostGroupedMapping(true);
     }
   }
@@ skipping 52 matching lines @@
 
   m_scrollingLayer = nullptr;
   m_scrollingContentsLayer = nullptr;
 }
 
 void CompositedLayerMapping::updateOpacity(const ComputedStyle& style) {
   m_graphicsLayer->setOpacity(compositingOpacity(style.opacity()));
 }
 
 void CompositedLayerMapping::updateTransform(const ComputedStyle& style) {
-  // FIXME: This could use m_owningLayer.transform(), but that currently has transform-origin
-  // baked into it, and we don't want that.
+  // FIXME: This could use m_owningLayer.transform(), but that currently has
+  // transform-origin baked into it, and we don't want that.
   TransformationMatrix t;
   if (m_owningLayer.hasTransformRelatedProperty()) {
     style.applyTransform(
         t, LayoutSize(toLayoutBox(layoutObject())->pixelSnappedSize()),
         ComputedStyle::ExcludeTransformOrigin, ComputedStyle::IncludeMotionPath,
         ComputedStyle::IncludeIndependentTransformProperties);
     makeMatrixRenderable(t, compositor()->hasAcceleratedCompositing());
   }
 
   m_graphicsLayer->setTransform(t);
@@ skipping 63 matching lines @@
 
   // non stacking context layers should never isolate
   ASSERT(m_owningLayer.stackingNode()->isStackingContext() || !isolate);
 
   m_graphicsLayer->setIsRootForIsolatedGroup(isolate);
 }
 
 void CompositedLayerMapping::
     updateBackgroundPaintsOntoScrollingContentsLayer() {
   // We can only paint the background onto the scrolling contents layer if
-  // it would be visually correct and we are using composited scrolling meaning we
-  // have a scrolling contents layer to paint it into.
+  // it would be visually correct and we are using composited scrolling meaning
+  // we have a scrolling contents layer to paint it into.
   bool shouldPaintOntoScrollingContentsLayer =
       m_owningLayer.canPaintBackgroundOntoScrollingContentsLayer() &&
       m_owningLayer.getScrollableArea()->usesCompositedScrolling();
   if (shouldPaintOntoScrollingContentsLayer !=
       backgroundPaintsOntoScrollingContentsLayer()) {
     m_backgroundPaintsOntoScrollingContentsLayer =
         shouldPaintOntoScrollingContentsLayer;
-    // If the background is no longer painted onto the scrolling contents
-    // layer the scrolling contents layer needs to be updated. If it is
-    // going to be painted onto the scrolling contents layer this update
-    // will be triggered by LayoutBoxModelObject::setBackingNeedsPaintInvalidationInRect
+    // If the background is no longer painted onto the scrolling contents layer
+    // the scrolling contents layer needs to be updated. If it is going to be
+    // painted onto the scrolling contents layer this update will be triggered
+    // by LayoutBoxModelObject::setBackingNeedsPaintInvalidationInRect
     if (hasScrollingLayer() && !shouldPaintOntoScrollingContentsLayer)
       m_scrollingContentsLayer->setNeedsDisplay();
   }
 }
 
 void CompositedLayerMapping::updateContentsOpaque() {
   if (isAcceleratedCanvas(layoutObject())) {
-    // Determine whether the rendering context's external texture layer is opaque.
+    // Determine whether the rendering context's external texture layer is
+    // opaque.
     CanvasRenderingContext* context =
         toHTMLCanvasElement(layoutObject()->node())->renderingContext();
     if (!context->creationAttributes().alpha())
       m_graphicsLayer->setContentsOpaque(true);
     else if (WebLayer* layer = context->platformLayer())
       m_graphicsLayer->setContentsOpaque(
           !Color(layer->backgroundColor()).hasAlpha());
     else
       m_graphicsLayer->setContentsOpaque(false);
   } else if (m_backgroundLayer) {
     m_graphicsLayer->setContentsOpaque(false);
     m_backgroundLayer->setContentsOpaque(
         m_owningLayer.backgroundIsKnownToBeOpaqueInRect(compositedBounds()));
   } else {
-    // For non-root layers, background is painted by the scrolling contents layer if all backgrounds
-    // are background attachment local, otherwise background is painted by the primary graphics layer.
+    // For non-root layers, background is painted by the scrolling contents
+    // layer if all backgrounds are background attachment local, otherwise
+    // background is painted by the primary graphics layer.
     if (hasScrollingLayer() && m_backgroundPaintsOntoScrollingContentsLayer) {
-      // Backgrounds painted onto the foreground are clipped by the padding box rect.
-      // TODO(flackr): This should actually check the entire overflow rect within the
-      // scrolling contents layer but since we currently only trigger this for solid
-      // color backgrounds the answer will be the same.
+      // Backgrounds painted onto the foreground are clipped by the padding box
+      // rect.
+      // TODO(flackr): This should actually check the entire overflow rect
+      // within the scrolling contents layer but since we currently only trigger
+      // this for solid color backgrounds the answer will be the same.
       m_scrollingContentsLayer->setContentsOpaque(
           m_owningLayer.backgroundIsKnownToBeOpaqueInRect(
               toLayoutBox(layoutObject())->paddingBoxRect()));
 
-      // When we paint the background onto the scrolling contents layer we are going
-      // to leave a hole in the m_graphicsLayer where the background is so it is
-      // not opaque.
+      // When we paint the background onto the scrolling contents layer we are
+      // going to leave a hole in the m_graphicsLayer where the background is so
+      // it is not opaque.
       m_graphicsLayer->setContentsOpaque(false);
     } else {
       if (hasScrollingLayer())
         m_scrollingContentsLayer->setContentsOpaque(false);
       m_graphicsLayer->setContentsOpaque(
           m_owningLayer.backgroundIsKnownToBeOpaqueInRect(compositedBounds()));
     }
   }
 }
 
 void CompositedLayerMapping::updateCompositedBounds() {
   ASSERT(m_owningLayer.compositor()->lifecycle().state() ==
          DocumentLifecycle::InCompositingUpdate);
-  // FIXME: if this is really needed for performance, it would be better to store it on Layer.
+  // FIXME: if this is really needed for performance, it would be better to
+  // store it on Layer.
   m_compositedBounds = m_owningLayer.boundingBoxForCompositing();
   m_contentOffsetInCompositingLayerDirty = true;
 }
 
 void CompositedLayerMapping::updateAfterPartResize() {
   if (layoutObject()->isLayoutPart()) {
     if (PaintLayerCompositor* innerCompositor =
             PaintLayerCompositor::frameContentsCompositor(
                 toLayoutPart(layoutObject()))) {
       innerCompositor->frameViewDidChangeSize();
-      // We can floor this point because our frameviews are always aligned to pixel boundaries.
+      // We can floor this point because our frameviews are always aligned to
+      // pixel boundaries.
       ASSERT(m_compositedBounds.location() ==
              flooredIntPoint(m_compositedBounds.location()));
       innerCompositor->frameViewDidChangeLocation(
           flooredIntPoint(contentsBox().location()));
     }
   }
 }
 
 void CompositedLayerMapping::updateCompositingReasons() {
-  // All other layers owned by this mapping will have the same compositing reason
-  // for their lifetime, so they are initialized only when created.
+  // All other layers owned by this mapping will have the same compositing
+  // reason for their lifetime, so they are initialized only when created.
   m_graphicsLayer->setCompositingReasons(m_owningLayer.getCompositingReasons());
   m_graphicsLayer->setSquashingDisallowedReasons(
       m_owningLayer.getSquashingDisallowedReasons());
 }
 
 bool CompositedLayerMapping::
     owningLayerClippedByLayerNotAboveCompositedAncestor(
         const PaintLayer* scrollParent) {
   if (!m_owningLayer.parent())
     return false;
@@ skipping 33 matching lines @@
   const PaintLayer* scrollParent = m_owningLayer.scrollParent();
   if (scrollParent && !scrollParent->needsCompositedScrolling())
     return nullptr;
   return scrollParent;
 }
 
 bool CompositedLayerMapping::updateGraphicsLayerConfiguration() {
   ASSERT(m_owningLayer.compositor()->lifecycle().state() ==
          DocumentLifecycle::InCompositingUpdate);
 
-  // Note carefully: here we assume that the compositing state of all descendants have been updated already,
-  // so it is legitimate to compute and cache the composited bounds for this layer.
+  // Note carefully: here we assume that the compositing state of all
+  // descendants have been updated already, so it is legitimate to compute and
+  // cache the composited bounds for this layer.
   updateCompositedBounds();
 
   PaintLayerCompositor* compositor = this->compositor();
   LayoutObject* layoutObject = this->layoutObject();
   const ComputedStyle& style = layoutObject->styleRef();
 
   bool layerConfigChanged = false;
   setBackgroundLayerPaintsFixedRootBackground(
       compositor->needsFixedRootBackgroundLayer(&m_owningLayer));
 
@@ skipping 13 matching lines @@
     needsDescendantsClippingLayer = false;
 
   // We disable clipping on ancestor layers of the root scroller to give it
   // the same behavior w.r.t top controls as the real root layer. See the
   // RootScrollerController class for more details.
   if (m_owningLayer.hasRootScrollerAsDescendant())
     needsDescendantsClippingLayer = false;
 
   const PaintLayer* scrollParent = this->scrollParent();
 
-  // This is required because compositing layers are parented according to the z-order hierarchy, yet
-  // clipping goes down the layoutObject hierarchy. Thus, a PaintLayer can be clipped by a
-  // PaintLayer that is an ancestor in the layoutObject hierarchy, but a sibling in the z-order
-  // hierarchy. Further, that sibling need not be composited at all. In such scenarios, an ancestor
+  // This is required because compositing layers are parented according to the
+  // z-order hierarchy, yet clipping goes down the layoutObject hierarchy. Thus,
+  // a PaintLayer can be clipped by a PaintLayer that is an ancestor in the
+  // layoutObject hierarchy, but a sibling in the z-order hierarchy. Further,
+  // that sibling need not be composited at all. In such scenarios, an ancestor
   // clipping layer is necessary to apply the composited clip for this layer.
   bool needsAncestorClip =
       owningLayerClippedByLayerNotAboveCompositedAncestor(scrollParent) &&
       !m_owningLayer.clippingContainer()
            ->enclosingLayer()
            ->hasRootScrollerAsDescendant();
 
   if (updateClippingLayers(needsAncestorClip, needsDescendantsClippingLayer))
     layerConfigChanged = true;
 
@@ skipping 31 matching lines @@
   // that's plugged into another GraphicsLayer that is part of the hierarchy.
   // It has no parent or child GraphicsLayer. For that reason, we process it
   // here, after the hierarchy has been updated.
   bool maskLayerChanged = updateMaskLayer(layoutObject->hasMask());
   if (maskLayerChanged)
     m_graphicsLayer->setMaskLayer(m_maskLayer.get());
 
   bool hasChildClippingLayer =
       compositor->clipsCompositingDescendants(&m_owningLayer) &&
       (hasClippingLayer() || hasScrollingLayer());
-  // If we have a border radius or clip path on a scrolling layer, we need a clipping mask to properly
-  // clip the scrolled contents, even if there are no composited descendants.
+  // If we have a border radius or clip path on a scrolling layer, we need a
+  // clipping mask to properly clip the scrolled contents, even if there are no
+  // composited descendants.
   bool hasClipPath = style.clipPath();
   bool needsChildClippingMask =
       (hasClipPath || style.hasBorderRadius()) &&
       (hasChildClippingLayer || isAcceleratedContents(layoutObject) ||
        hasScrollingLayer());
 
   GraphicsLayer* layerToApplyChildClippingMask = nullptr;
   bool shouldApplyChildClippingMaskOnContents = false;
   if (needsChildClippingMask) {
     if (hasClipPath) {
-      // Clip path clips the entire subtree, including scrollbars. It must be attached directly onto
-      // the main m_graphicsLayer.
+      // Clip path clips the entire subtree, including scrollbars. It must be
+      // attached directly onto the main m_graphicsLayer.
       layerToApplyChildClippingMask = m_graphicsLayer.get();
     } else if (hasClippingLayer()) {
       layerToApplyChildClippingMask = clippingLayer();
     } else if (hasScrollingLayer()) {
       layerToApplyChildClippingMask = scrollingLayer();
     } else if (isAcceleratedContents(layoutObject)) {
       shouldApplyChildClippingMaskOnContents = true;
     }
   }
 
@@ skipping 109 matching lines @@
   offsetFromCompositedAncestor =
       computeOffsetFromCompositedAncestor(&m_owningLayer, compositedAncestor);
   snappedOffsetFromCompositedAncestor =
       IntPoint(offsetFromCompositedAncestor.x().round(),
                offsetFromCompositedAncestor.y().round());
 
   LayoutSize subpixelAccumulation =
       offsetFromCompositedAncestor - snappedOffsetFromCompositedAncestor;
   m_owningLayer.setSubpixelAccumulation(subpixelAccumulation);
 
-  // Move the bounds by the subpixel accumulation so that it pixel-snaps relative to absolute pixels instead of local coordinates.
+  // Move the bounds by the subpixel accumulation so that it pixel-snaps
+  // relative to absolute pixels instead of local coordinates.
   localRawCompositingBounds.move(subpixelAccumulation);
   localBounds = pixelSnappedIntRect(localRawCompositingBounds);
 
   compositingBoundsRelativeToCompositedAncestor = localBounds;
   compositingBoundsRelativeToCompositedAncestor.moveBy(
       snappedOffsetFromCompositedAncestor);
 }
 
 void CompositedLayerMapping::updateSquashingLayerGeometry(
     const IntPoint& graphicsLayerParentLocation,
@@ skipping 40 matching lines @@
         layers[i].paintLayer->computeOffsetFromTransformedAncestor();
     LayoutSize squashedLayerOffsetFromCompositingContainer =
         squashedLayerOffsetFromTransformedAncestor -
         compositingContainerOffsetFromTransformedAncestor;
 
     squashedBounds.move(squashedLayerOffsetFromCompositingContainer);
     totalSquashBounds.unite(squashedBounds);
   }
 
   // The totalSquashBounds is positioned with respect to compositingContainer.
-  // But the squashingLayer needs to be positioned with respect to the graphicsLayerParent.
-  // The conversion between compositingContainer and the graphicsLayerParent is already computed
-  // as compositingContainerOffsetFromParentGraphicsLayer.
+  // But the squashingLayer needs to be positioned with respect to the
+  // graphicsLayerParent.  The conversion between compositingContainer and the
+  // graphicsLayerParent is already computed as
+  // compositingContainerOffsetFromParentGraphicsLayer.
   totalSquashBounds.moveBy(compositingContainerOffsetFromParentGraphicsLayer);
   const IntRect squashLayerBounds = enclosingIntRect(totalSquashBounds);
   const IntPoint squashLayerOrigin = squashLayerBounds.location();
   const LayoutSize squashLayerOriginInCompositingContainerSpace =
       squashLayerOrigin - compositingContainerOffsetFromParentGraphicsLayer;
 
-  // Now that the squashing bounds are known, we can convert the PaintLayer painting offsets
-  // from compositingContainer space to the squashing layer space.
+  // Now that the squashing bounds are known, we can convert the PaintLayer
+  // painting offsets from compositingContainer space to the squashing layer
+  // space.
   //
-  // The painting offset we want to compute for each squashed PaintLayer is essentially the
-  // position of the squashed PaintLayer described w.r.t. compositingContainer's origin.
-  // So we just need to convert that point from compositingContainer space to the squashing
-  // layer's space. This is done by subtracting squashLayerOriginInCompositingContainerSpace,
-  // but then the offset overall needs to be negated because that's the direction that the
+  // The painting offset we want to compute for each squashed PaintLayer is
+  // essentially the position of the squashed PaintLayer described w.r.t.
+  // compositingContainer's origin.  So we just need to convert that point from
+  // compositingContainer space to the squashing layer's space. This is done by
+  // subtracting squashLayerOriginInCompositingContainerSpace, but then the
+  // offset overall needs to be negated because that's the direction that the
   // painting code expects the offset to be.
   for (size_t i = 0; i < layers.size(); ++i) {
     const LayoutPoint squashedLayerOffsetFromTransformedAncestor =
         layers[i].paintLayer->computeOffsetFromTransformedAncestor();
     const LayoutSize offsetFromSquashLayerOrigin =
         (squashedLayerOffsetFromTransformedAncestor -
          compositingContainerOffsetFromTransformedAncestor) -
         squashLayerOriginInCompositingContainerSpace;
 
     IntSize newOffsetFromLayoutObject =
         -IntSize(offsetFromSquashLayerOrigin.width().round(),
                  offsetFromSquashLayerOrigin.height().round());
     LayoutSize subpixelAccumulation =
         offsetFromSquashLayerOrigin + newOffsetFromLayoutObject;
     if (layers[i].offsetFromLayoutObjectSet &&
         layers[i].offsetFromLayoutObject != newOffsetFromLayoutObject) {
-      // It is ok to issue paint invalidation here, because all of the geometry needed to correctly invalidate paint is computed by this point.
+      // It is ok to issue paint invalidation here, because all of the geometry
+      // needed to correctly invalidate paint is computed by this point.
       DisablePaintInvalidationStateAsserts disabler;
       ObjectPaintInvalidator(*layers[i].paintLayer->layoutObject())
           .invalidatePaintIncludingNonCompositingDescendants();
 
       TRACE_LAYER_INVALIDATION(layers[i].paintLayer,
                                InspectorLayerInvalidationTrackingEvent::
                                    SquashingLayerGeometryWasUpdated);
       layersNeedingPaintInvalidation.append(layers[i].paintLayer);
     }
     layers[i].offsetFromLayoutObject = newOffsetFromLayoutObject;
@@ skipping 15 matching lines @@
         localClipRectForSquashedLayer(m_owningLayer, layers[i], layers);
 }
 
 void CompositedLayerMapping::updateGraphicsLayerGeometry(
     const PaintLayer* compositingContainer,
     const PaintLayer* compositingStackingContext,
     Vector<PaintLayer*>& layersNeedingPaintInvalidation) {
   ASSERT(m_owningLayer.compositor()->lifecycle().state() ==
          DocumentLifecycle::InCompositingUpdate);
 
-  // Set transform property, if it is not animating. We have to do this here because the transform
-  // is affected by the layer dimensions.
+  // Set transform property, if it is not animating. We have to do this here
+  // because the transform is affected by the layer dimensions.
   if (!layoutObject()->style()->isRunningTransformAnimationOnCompositor())
     updateTransform(layoutObject()->styleRef());
 
   // Set opacity, if it is not animating.
   if (!layoutObject()->style()->isRunningOpacityAnimationOnCompositor())
     updateOpacity(layoutObject()->styleRef());
 
   if (!layoutObject()->style()->isRunningFilterAnimationOnCompositor())
     updateFilters(layoutObject()->styleRef());
 
@@ skipping 88 matching lines @@
   m_graphicsLayer->setPosition(FloatPoint(relativeCompositingBounds.location() -
                                           graphicsLayerParentLocation));
   m_graphicsLayer->setOffsetFromLayoutObject(
       toIntSize(localCompositingBounds.location()));
 
   FloatSize oldSize = m_graphicsLayer->size();
   const FloatSize contentsSize(relativeCompositingBounds.size());
   if (oldSize != contentsSize)
     m_graphicsLayer->setSize(contentsSize);
 
-  // m_graphicsLayer is the corresponding GraphicsLayer for this PaintLayer and its non-compositing
-  // descendants. So, the visibility flag for m_graphicsLayer should be true if there are any
-  // non-compositing visible layers.
+  // m_graphicsLayer is the corresponding GraphicsLayer for this PaintLayer and
+  // its non-compositing descendants. So, the visibility flag for
+  // m_graphicsLayer should be true if there are any non-compositing visible
+  // layers.
   bool contentsVisible = m_owningLayer.hasVisibleContent() ||
                          hasVisibleNonCompositingDescendant(&m_owningLayer);
   m_graphicsLayer->setContentsVisible(contentsVisible);
 
   m_graphicsLayer->setBackfaceVisibility(
       layoutObject()->style()->backfaceVisibility() ==
       BackfaceVisibilityVisible);
 }
 
 void CompositedLayerMapping::computeGraphicsLayerParentLocation(
     const PaintLayer* compositingContainer,
     const IntRect& ancestorCompositingBounds,
     IntPoint& graphicsLayerParentLocation) {
   if (compositingContainer &&
       compositingContainer->compositedLayerMapping()->hasClippingLayer()) {
-    // If the compositing ancestor has a layer to clip children, we parent in that, and therefore
-    // position relative to it.
+    // If the compositing ancestor has a layer to clip children, we parent in
+    // that, and therefore position relative to it.
     IntRect clippingBox =
         clipBox(toLayoutBox(compositingContainer->layoutObject()));
     graphicsLayerParentLocation =
         clippingBox.location() +
         roundedIntSize(compositingContainer->subpixelAccumulation());
   } else if (compositingContainer &&
              compositingContainer->compositedLayerMapping()
                  ->childTransformLayer()) {
-    // Similarly, if the compositing ancestor has a child transform layer, we parent in that, and therefore
-    // position relative to it. It's already taken into account the contents offset, so we do not need to here.
+    // Similarly, if the compositing ancestor has a child transform layer, we
+    // parent in that, and therefore position relative to it. It's already taken
+    // into account the contents offset, so we do not need to here.
     graphicsLayerParentLocation =
         roundedIntPoint(compositingContainer->subpixelAccumulation());
   } else if (compositingContainer) {
     graphicsLayerParentLocation = ancestorCompositingBounds.location();
   } else {
     graphicsLayerParentLocation =
         layoutObject()->view()->documentRect().location();
   }
 
   if (compositingContainer &&
@@ skipping 17 matching lines @@
   ClipRectsContext clipRectsContext(compositingContainer,
                                     PaintingClipRectsIgnoringOverflowClip,
                                     IgnoreOverlayScrollbarSize);
   IntRect parentClipRect = pixelSnappedIntRect(
       m_owningLayer.clipper().backgroundClipRect(clipRectsContext).rect());
   ASSERT(parentClipRect != LayoutRect::infiniteIntRect());
   m_ancestorClippingLayer->setPosition(
       FloatPoint(parentClipRect.location() - graphicsLayerParentLocation));
   m_ancestorClippingLayer->setSize(FloatSize(parentClipRect.size()));
 
-  // backgroundRect is relative to compositingContainer, so subtract snappedOffsetFromCompositedAncestor.X/snappedOffsetFromCompositedAncestor.Y to get back to local coords.
+  // backgroundRect is relative to compositingContainer, so subtract
+  // snappedOffsetFromCompositedAncestor.X/snappedOffsetFromCompositedAncestor.Y
+  // to get back to local coords.
   m_ancestorClippingLayer->setOffsetFromLayoutObject(
       parentClipRect.location() - snappedOffsetFromCompositedAncestor);
 
-  // The primary layer is then parented in, and positioned relative to this clipping layer.
+  // The primary layer is then parented in, and positioned relative to this
+  // clipping layer.
   graphicsLayerParentLocation = parentClipRect.location();
 }
 
 void CompositedLayerMapping::updateOverflowControlsHostLayerGeometry(
     const PaintLayer* compositingStackingContext,
     const PaintLayer* compositingContainer,
     IntPoint graphicsLayerParentLocation) {
   if (!m_overflowControlsHostLayer)
     return;
 
-  // To position and clip the scrollbars correctly, m_overflowControlsHostLayer should match our
-  // border box rect, which is at the origin of our LayoutObject. Its position is computed in
-  // various ways depending on who its parent GraphicsLayer is going to be.
+  // To position and clip the scrollbars correctly, m_overflowControlsHostLayer
+  // should match our border box rect, which is at the origin of our
+  // LayoutObject. Its position is computed in various ways depending on who its
+  // parent GraphicsLayer is going to be.
   LayoutPoint hostLayerPosition;
 
   if (needsToReparentOverflowControls()) {
     CompositedLayerMapping* stackingCLM =
         compositingStackingContext->compositedLayerMapping();
     DCHECK(stackingCLM);
 
-    // Either m_overflowControlsHostLayer or m_overflowControlsAncestorClippingLayer (if it
-    // exists) will be a child of the main GraphicsLayer of the compositing stacking context.
+    // Either m_overflowControlsHostLayer or
+    // m_overflowControlsAncestorClippingLayer (if it exists) will be a child of
+    // the main GraphicsLayer of the compositing stacking context.
     IntSize stackingOffsetFromLayoutObject =
         stackingCLM->mainGraphicsLayer()->offsetFromLayoutObject();
 
     if (m_overflowControlsAncestorClippingLayer) {
       m_overflowControlsAncestorClippingLayer->setSize(
           m_ancestorClippingLayer->size());
       m_overflowControlsAncestorClippingLayer->setOffsetFromLayoutObject(
           m_ancestorClippingLayer->offsetFromLayoutObject());
       m_overflowControlsAncestorClippingLayer->setMasksToBounds(true);
 
       FloatPoint position;
       if (compositingStackingContext == compositingContainer) {
         position = m_ancestorClippingLayer->position();
       } else {
-        // graphicsLayerParentLocation is the location of m_ancestorClippingLayer
-        // relative to compositingContainer (including any offset from
-        // compositingContainer's m_childContainmentLayer).
+        // graphicsLayerParentLocation is the location of
+        // m_ancestorClippingLayer relative to compositingContainer (including
+        // any offset from compositingContainer's m_childContainmentLayer).
         LayoutPoint offset = LayoutPoint(graphicsLayerParentLocation);
         compositingContainer->convertToLayerCoords(compositingStackingContext,
                                                    offset);
         position =
             FloatPoint(offset) - FloatSize(stackingOffsetFromLayoutObject);
       }
 
       m_overflowControlsAncestorClippingLayer->setPosition(position);
       hostLayerPosition.move(
           -m_ancestorClippingLayer->offsetFromLayoutObject());
     } else {
-      // The controls are in the same 2D space as the compositing container, so we can map them into the space of the container.
+      // The controls are in the same 2D space as the compositing container, so
+      // we can map them into the space of the container.
       TransformState transformState(TransformState::ApplyTransformDirection,
                                     FloatPoint());
       m_owningLayer.layoutObject()->mapLocalToAncestor(
           compositingStackingContext->layoutObject(), transformState,
           ApplyContainerFlip);
       transformState.flatten();
       hostLayerPosition = LayoutPoint(transformState.lastPlanarPoint());
       if (PaintLayerScrollableArea* scrollableArea =
               compositingStackingContext->getScrollableArea())
         hostLayerPosition.move(
@@ skipping 64 matching lines @@
   m_maskLayer->setOffsetFromLayoutObject(
       m_graphicsLayer->offsetFromLayoutObject());
 }
 
 void CompositedLayerMapping::updateTransformGeometry(
     const IntPoint& snappedOffsetFromCompositedAncestor,
     const IntRect& relativeCompositingBounds) {
   if (m_owningLayer.hasTransformRelatedProperty()) {
     const LayoutRect borderBox = toLayoutBox(layoutObject())->borderBoxRect();
 
-    // Get layout bounds in the coords of compositingContainer to match relativeCompositingBounds.
+    // Get layout bounds in the coords of compositingContainer to match
+    // relativeCompositingBounds.
     IntRect layerBounds = pixelSnappedIntRect(
         toLayoutPoint(m_owningLayer.subpixelAccumulation()), borderBox.size());
     layerBounds.moveBy(snappedOffsetFromCompositedAncestor);
 
     // Update properties that depend on layer dimensions
     FloatPoint3D transformOrigin =
         computeTransformOrigin(IntRect(IntPoint(), layerBounds.size()));
 
-    // |transformOrigin| is in the local space of this layer. layerBounds - relativeCompositingBounds converts to the space of the
-    // compositing bounds relative to the composited ancestor. This does not apply to the z direction, since the page is 2D.
+    // |transformOrigin| is in the local space of this layer.
+    // layerBounds - relativeCompositingBounds converts to the space of the
+    // compositing bounds relative to the composited ancestor. This does not
+    // apply to the z direction, since the page is 2D.
     FloatPoint3D compositedTransformOrigin(
         layerBounds.x() - relativeCompositingBounds.x() + transformOrigin.x(),
         layerBounds.y() - relativeCompositingBounds.y() + transformOrigin.y(),
         transformOrigin.z());
     m_graphicsLayer->setTransformOrigin(compositedTransformOrigin);
   } else {
     FloatPoint3D compositedTransformOrigin(
         relativeCompositingBounds.width() * 0.5f,
         relativeCompositingBounds.height() * 0.5f, 0.f);
     m_graphicsLayer->setTransformOrigin(compositedTransformOrigin);
@@ skipping 32 matching lines @@
 
   IntSize scrollSize(layoutBox->scrollWidth().toInt(),
                      layoutBox->scrollHeight().toInt());
   if (scrollSize != m_scrollingContentsLayer->size() ||
       overflowClipRectOffsetChanged)
     m_scrollingContentsLayer->setNeedsDisplay();
 
   DoubleSize scrollingContentsOffset(
       overflowClipRect.location().x() - adjustedScrollOffset.width(),
       overflowClipRect.location().y() - adjustedScrollOffset.height());
-  // The scroll offset change is compared using floating point so that fractional scroll offset
-  // change can be propagated to compositor.
+  // The scroll offset change is compared using floating point so that
+  // fractional scroll offset change can be propagated to compositor.
   if (scrollingContentsOffset != m_scrollingContentsOffset ||
       scrollSize != m_scrollingContentsLayer->size()) {
     bool coordinatorHandlesOffset =
         compositor()->scrollingLayerDidChange(&m_owningLayer);
     m_scrollingContentsLayer->setPosition(
         coordinatorHandlesOffset
             ? FloatPoint()
             : FloatPoint(-toFloatSize(adjustedScrollOffset)));
   }
   m_scrollingContentsOffset = scrollingContentsOffset;
@@ skipping 40 matching lines @@
     const FloatSize& relativeCompositingBoundsSize,
     const IntRect& clippingBox) {
   if (!m_foregroundLayer)
     return;
 
   FloatSize foregroundSize = relativeCompositingBoundsSize;
   IntSize foregroundOffset = m_graphicsLayer->offsetFromLayoutObject();
   m_foregroundLayer->setPosition(FloatPoint());
 
   if (hasClippingLayer()) {
-    // If we have a clipping layer (which clips descendants), then the foreground layer is a child of it,
-    // so that it gets correctly sorted with children. In that case, position relative to the clipping layer.
+    // If we have a clipping layer (which clips descendants), then the
+    // foreground layer is a child of it, so that it gets correctly sorted with
+    // children. In that case, position relative to the clipping layer.
     foregroundSize = FloatSize(clippingBox.size());
     foregroundOffset = toIntSize(clippingBox.location());
   } else if (m_childTransformLayer) {
     // Things are different if we have a child transform layer rather
     // than a clipping layer. In this case, we want to actually change
     // the position of the layer (to compensate for our ancestor
     // compositing PaintLayer's position) rather than leave the position the
     // same and use offset-from-layoutObject + size to describe a clipped
     // "window" onto the clipped layer.
 
     m_foregroundLayer->setPosition(-m_childTransformLayer->position());
   }
 
   if (foregroundSize != m_foregroundLayer->size()) {
     m_foregroundLayer->setSize(foregroundSize);
     m_foregroundLayer->setNeedsDisplay();
   }
   m_foregroundLayer->setOffsetFromLayoutObject(foregroundOffset);
 
-  // NOTE: there is some more configuring going on in updateScrollingLayerGeometry().
+  // NOTE: there is some more configuring going on in
+  // updateScrollingLayerGeometry().
 }
 
 void CompositedLayerMapping::updateBackgroundLayerGeometry(
     const FloatSize& relativeCompositingBoundsSize) {
   if (!m_backgroundLayer)
     return;
 
   FloatSize backgroundSize = relativeCompositingBoundsSize;
   if (backgroundLayerPaintsFixedRootBackground()) {
     FrameView* frameView = toLayoutView(layoutObject())->frameView();
     backgroundSize = FloatSize(frameView->visibleContentRect().size());
   }
   m_backgroundLayer->setPosition(FloatPoint());
   if (backgroundSize != m_backgroundLayer->size()) {
     m_backgroundLayer->setSize(backgroundSize);
     m_backgroundLayer->setNeedsDisplay();
   }
   m_backgroundLayer->setOffsetFromLayoutObject(
       m_graphicsLayer->offsetFromLayoutObject());
 }
 
 void CompositedLayerMapping::registerScrollingLayers() {
-  // Register fixed position layers and their containers with the scrolling coordinator.
+  // Register fixed position layers and their containers with the scrolling
+  // coordinator.
   ScrollingCoordinator* scrollingCoordinator =
       scrollingCoordinatorFromLayer(m_owningLayer);
   if (!scrollingCoordinator)
     return;
 
   scrollingCoordinator->updateLayerPositionConstraint(&m_owningLayer);
 
-  // Page scale is applied as a transform on the root layout view layer. Because the scroll
-  // layer is further up in the hierarchy, we need to avoid marking the root layout view
-  // layer as a container.
+  // Page scale is applied as a transform on the root layout view layer. Because
+  // the scroll layer is further up in the hierarchy, we need to avoid marking
+  // the root layout view layer as a container.
   bool isContainer =
       m_owningLayer.layoutObject()->style()->canContainFixedPositionObjects() &&
       !m_owningLayer.isRootLayer();
-  // FIXME: we should make certain that childForSuperLayers will never be the m_squashingContainmentLayer here
+  // FIXME: we should make certain that childForSuperLayers will never be the
+  // m_squashingContainmentLayer here
   scrollingCoordinator->setLayerIsContainerForFixedPositionLayers(
       childForSuperlayers(), isContainer);
 }
 
 void CompositedLayerMapping::updateInternalHierarchy() {
-  // m_foregroundLayer has to be inserted in the correct order with child layers,
-  // so it's not inserted here.
+  // m_foregroundLayer has to be inserted in the correct order with child
+  // layers, so it's not inserted here.
   if (m_ancestorClippingLayer)
     m_ancestorClippingLayer->removeAllChildren();
 
   m_graphicsLayer->removeFromParent();
 
   if (m_ancestorClippingLayer)
     m_ancestorClippingLayer->addChild(m_graphicsLayer.get());
 
   // Layer to which children should be attached as we build the hierarchy.
   GraphicsLayer* bottomLayer = m_graphicsLayer.get();
   auto updateBottomLayer = [&bottomLayer](GraphicsLayer* layer) {
     if (layer) {
       bottomLayer->addChild(layer);
       bottomLayer = layer;
     }
   };
 
   updateBottomLayer(m_childTransformLayer.get());
   updateBottomLayer(m_childContainmentLayer.get());
   updateBottomLayer(m_scrollingLayer.get());
 
   // Now constructing the subtree for the overflow controls.
   bottomLayer = m_graphicsLayer.get();
-  // TODO(pdr): Ensure painting uses the correct GraphicsLayer when root layer scrolls is enabled.
-  // crbug.com/638719
+  // TODO(pdr): Ensure painting uses the correct GraphicsLayer when root layer
+  // scrolls is enabled.  crbug.com/638719
   if (m_isMainFrameLayoutViewLayer &&
       !RuntimeEnabledFeatures::slimmingPaintV2Enabled())
     bottomLayer = layoutObject()
                       ->frame()
                       ->page()
                       ->frameHost()
                       .visualViewport()
                       .containerLayer();
   updateBottomLayer(m_overflowControlsAncestorClippingLayer.get());
   updateBottomLayer(m_overflowControlsHostLayer.get());
   if (m_layerForHorizontalScrollbar)
     m_overflowControlsHostLayer->addChild(m_layerForHorizontalScrollbar.get());
   if (m_layerForVerticalScrollbar)
     m_overflowControlsHostLayer->addChild(m_layerForVerticalScrollbar.get());
   if (m_layerForScrollCorner)
     m_overflowControlsHostLayer->addChild(m_layerForScrollCorner.get());
 
   // The squashing containment layer, if it exists, becomes a no-op parent.
   if (m_squashingLayer) {
     ASSERT((m_ancestorClippingLayer && !m_squashingContainmentLayer) ||
            (!m_ancestorClippingLayer && m_squashingContainmentLayer));
 
     if (m_squashingContainmentLayer) {
       m_squashingContainmentLayer->removeAllChildren();
       m_squashingContainmentLayer->addChild(m_graphicsLayer.get());
       m_squashingContainmentLayer->addChild(m_squashingLayer.get());
     } else {
-      // The ancestor clipping layer is already set up and has m_graphicsLayer under it.
+      // The ancestor clipping layer is already set up and has m_graphicsLayer
+      // under it.
       m_ancestorClippingLayer->addChild(m_squashingLayer.get());
     }
   }
 }
 
 void CompositedLayerMapping::updatePaintingPhases() {
   m_graphicsLayer->setPaintingPhase(paintingPhaseForPrimaryLayer());
   if (m_scrollingContentsLayer) {
     GraphicsLayerPaintingPhase paintPhase =
         GraphicsLayerPaintOverflowContents | GraphicsLayerPaintCompositedScroll;
@@ skipping 25 matching lines @@
   // Our ancestor graphics layers in this CLM (m_graphicsLayer and potentially
   // m_ancestorClippingLayer) have pixel snapped, so if we don't adjust this
   // offset, we'll see accumulated rounding errors due to that snapping.
   //
   // In order to ensure that we account for this rounding, we compute
   // contentsOffsetInCompositingLayer in a somewhat roundabout way.
   //
   // our position = (desired position) - (inherited graphics layer offset).
   //
   // Precisely,
-  // Offset = snappedOffsetFromCompositedAncestor - offsetDueToAncestorGraphicsLayers (See code below)
-  //      = snappedOffsetFromCompositedAncestor - (m_graphicsLayer->position() + graphicsLayerParentLocation)
-  //      = snappedOffsetFromCompositedAncestor - (relativeCompositingBounds.location() - graphicsLayerParentLocation + graphicsLayerParentLocation) (See updateMainGraphicsLayerGeometry)
-  //      = snappedOffsetFromCompositedAncestor - relativeCompositingBounds.location()
-  //      = snappedOffsetFromCompositedAncestor - (pixelSnappedIntRect(contentBounds.location()) + snappedOffsetFromCompositedAncestor) (See computeBoundsOfOwningLayer)
+  // Offset = snappedOffsetFromCompositedAncestor -
+  //          offsetDueToAncestorGraphicsLayers (See code below)
+  //        = snappedOffsetFromCompositedAncestor -
+  //          (m_graphicsLayer->position() + graphicsLayerParentLocation)
+  //        = snappedOffsetFromCompositedAncestor -
+  //          (relativeCompositingBounds.location() -
+  //              graphicsLayerParentLocation +
+  //              graphicsLayerParentLocation)
+  //          (See updateMainGraphicsLayerGeometry)
+  //        = snappedOffsetFromCompositedAncestor -
+  //          relativeCompositingBounds.location()
+  //        = snappedOffsetFromCompositedAncestor -
+  //          (pixelSnappedIntRect(contentBounds.location()) +
+  //              snappedOffsetFromCompositedAncestor)
+  //          (See computeBoundsOfOwningLayer)
   //      = -pixelSnappedIntRect(contentBounds.location())
   //
-  // As you can see, we've ended up at the same spot (-contentBounds.location()),
-  // but by subtracting off our ancestor graphics layers positions, we can be
-  // sure we've accounted correctly for any pixel snapping due to ancestor
-  // graphics layers.
+  // As you can see, we've ended up at the same spot
+  // (-contentBounds.location()), but by subtracting off our ancestor graphics
+  // layers positions, we can be sure we've accounted correctly for any pixel
+  // snapping due to ancestor graphics layers.
   //
   // And drawing of composited children takes into account the subpixel
   // accumulation of this CLM already (through its own
   // graphicsLayerParentLocation it appears).
   FloatPoint offsetDueToAncestorGraphicsLayers =
       m_graphicsLayer->position() + graphicsLayerParentLocation;
   m_contentOffsetInCompositingLayer = LayoutSize(
       snappedOffsetFromCompositedAncestor - offsetDueToAncestorGraphicsLayers);
   m_contentOffsetInCompositingLayerDirty = false;
 }
 
 void CompositedLayerMapping::updateDrawsContent() {
   bool inOverlayFullscreenVideo = false;
   if (layoutObject()->isVideo()) {
     HTMLVideoElement* videoElement = toHTMLVideoElement(layoutObject()->node());
     if (videoElement->isFullscreen() &&
         videoElement->usesOverlayFullscreenVideo())
       inOverlayFullscreenVideo = true;
   }
   bool hasPaintedContent =
       inOverlayFullscreenVideo ? false : containsPaintedContent();
   m_graphicsLayer->setDrawsContent(hasPaintedContent);
 
   if (m_scrollingLayer) {
     // m_scrollingLayer never has backing store.
-    // m_scrollingContentsLayer only needs backing store if the scrolled contents need to paint.
+    // m_scrollingContentsLayer only needs backing store if the scrolled
+    // contents need to paint.
     m_scrollingContentsAreEmpty =
         !m_owningLayer.hasVisibleContent() ||
         !(layoutObject()->styleRef().hasBackground() ||
           layoutObject()->hasBackdropFilter() || paintsChildren());
     m_scrollingContentsLayer->setDrawsContent(!m_scrollingContentsAreEmpty);
   }
 
   if (hasPaintedContent && isAcceleratedCanvas(layoutObject())) {
     CanvasRenderingContext* context =
         toHTMLCanvasElement(layoutObject()->node())->renderingContext();
     // Content layer may be null if context is lost.
     if (WebLayer* contentLayer = context->platformLayer()) {
       Color bgColor(Color::transparent);
       if (contentLayerSupportsDirectBackgroundComposition(layoutObject())) {
         bgColor = layoutObjectBackgroundColor();
         hasPaintedContent = false;
       }
       contentLayer->setBackgroundColor(bgColor.rgb());
     }
   }
 
-  // FIXME: we could refine this to only allocate backings for one of these layers if possible.
+  // FIXME: we could refine this to only allocate backings for one of these
+  // layers if possible.
   if (m_foregroundLayer)
     m_foregroundLayer->setDrawsContent(hasPaintedContent);
 
   if (m_backgroundLayer)
     m_backgroundLayer->setDrawsContent(hasPaintedContent);
 
   if (m_maskLayer)
     m_maskLayer->setDrawsContent(true);
 
   if (m_childClippingMaskLayer)
@@ skipping 22 matching lines @@
       m_ancestorClippingLayer->setShouldFlattenTransform(false);
       layersChanged = true;
     }
   } else if (m_ancestorClippingLayer) {
     m_ancestorClippingLayer->removeFromParent();
     m_ancestorClippingLayer = nullptr;
     layersChanged = true;
   }
 
   if (needsDescendantClip) {
-    // We don't need a child containment layer if we're the main frame layout view
-    // layer. It's redundant as the frame clip above us will handle this clipping.
+    // We don't need a child containment layer if we're the main frame layout
+    // view layer. It's redundant as the frame clip above us will handle this
+    // clipping.
     if (!m_childContainmentLayer && !m_isMainFrameLayoutViewLayer) {
       m_childContainmentLayer =
           createGraphicsLayer(CompositingReasonLayerForDescendantClip);
       m_childContainmentLayer->setMasksToBounds(true);
       layersChanged = true;
     }
   } else if (hasClippingLayer()) {
     m_childContainmentLayer->removeFromParent();
     m_childContainmentLayer = nullptr;
     layersChanged = true;
@@ skipping 218 matching lines @@
 }
 
 struct UpdateRenderingContextFunctor {
   void operator()(GraphicsLayer* layer) const {
     layer->setRenderingContext(renderingContext);
   }
   int renderingContext;
 };
 
 void CompositedLayerMapping::updateRenderingContext() {
-  // All layers but the squashing layer (which contains 'alien' content) should be included in this
-  // rendering context.
+  // All layers but the squashing layer (which contains 'alien' content) should
+  // be included in this rendering context.
   int id = 0;
 
-  // NB, it is illegal at this point to query an ancestor's compositing state. Some compositing
-  // reasons depend on the compositing state of ancestors. So if we want a rendering context id
-  // for the context root, we cannot ask for the id of its associated WebLayer now; it may not have
-  // one yet. We could do a second past after doing the compositing updates to get these ids,
-  // but this would actually be harmful. We do not want to attach any semantic meaning to
-  // the context id other than the fact that they group a number of layers together for the
-  // sake of 3d sorting. So instead we will ask the compositor to vend us an arbitrary, but
-  // consistent id.
+  // NB, it is illegal at this point to query an ancestor's compositing state.
+  // Some compositing reasons depend on the compositing state of ancestors. So
+  // if we want a rendering context id for the context root, we cannot ask for
+  // the id of its associated WebLayer now; it may not have one yet. We could do
+  // a second past after doing the compositing updates to get these ids, but
+  // this would actually be harmful. We do not want to attach any semantic
+  // meaning to the context id other than the fact that they group a number of
+  // layers together for the sake of 3d sorting. So instead we will ask the
+  // compositor to vend us an arbitrary, but consistent id.
   if (PaintLayer* root = m_owningLayer.renderingContextRoot()) {
     if (Node* node = root->layoutObject()->node())
       id = static_cast<int>(PtrHash<Node>::hash(node));
   }
 
   UpdateRenderingContextFunctor functor = {id};
   ApplyToGraphicsLayers<UpdateRenderingContextFunctor>(
       this, functor, ApplyToAllGraphicsLayers);
 }
 
 struct UpdateShouldFlattenTransformFunctor {
   void operator()(GraphicsLayer* layer) const {
     layer->setShouldFlattenTransform(shouldFlatten);
   }
   bool shouldFlatten;
 };
 
 void CompositedLayerMapping::updateShouldFlattenTransform() {
-  // All CLM-managed layers that could affect a descendant layer should update their
-  // should-flatten-transform value (the other layers' transforms don't matter here).
+  // All CLM-managed layers that could affect a descendant layer should update
+  // their should-flatten-transform value (the other layers' transforms don't
+  // matter here).
   UpdateShouldFlattenTransformFunctor functor = {
       !m_owningLayer.shouldPreserve3D()};
   ApplyToGraphicsLayersMode mode = ApplyToLayersAffectedByPreserve3D;
   ApplyToGraphicsLayers(this, functor, mode);
 
   // Note, if we apply perspective, we have to set should flatten differently
   // so that the transform propagates to child layers correctly.
   if (hasChildTransformLayer()) {
     ApplyToGraphicsLayers(
         this,
@@ skipping 198 matching lines @@
 }
 
 static void updateScrollParentForGraphicsLayer(
     GraphicsLayer* layer,
     GraphicsLayer* topmostLayer,
     const PaintLayer* scrollParent,
     ScrollingCoordinator* scrollingCoordinator) {
   if (!layer)
     return;
 
-  // Only the topmost layer has a scroll parent. All other layers have a null scroll parent.
+  // Only the topmost layer has a scroll parent. All other layers have a null
+  // scroll parent.
   if (layer != topmostLayer)
     scrollParent = 0;
 
   scrollingCoordinator->updateScrollParentForGraphicsLayer(layer, scrollParent);
 }
 
 void CompositedLayerMapping::updateScrollParent(
     const PaintLayer* scrollParent) {
   if (ScrollingCoordinator* scrollingCoordinator =
           scrollingCoordinatorFromLayer(m_owningLayer)) {
@@ skipping 10 matching lines @@
 }
 
 static void updateClipParentForGraphicsLayer(
     GraphicsLayer* layer,
     GraphicsLayer* topmostLayer,
     const PaintLayer* clipParent,
     ScrollingCoordinator* scrollingCoordinator) {
   if (!layer)
     return;
 
-  // Only the topmost layer has a scroll parent. All other layers have a null scroll parent.
+  // Only the topmost layer has a scroll parent. All other layers have a null
+  // scroll parent.
   if (layer != topmostLayer)
     clipParent = 0;
 
   scrollingCoordinator->updateClipParentForGraphicsLayer(layer, clipParent);
 }
 
 void CompositedLayerMapping::updateClipParent(const PaintLayer* scrollParent) {
   const PaintLayer* clipParent = nullptr;
   if (!owningLayerClippedByLayerNotAboveCompositedAncestor(scrollParent)) {
     clipParent = m_owningLayer.clipParent();
@@ skipping 156 matching lines @@
   }
 
   return false;
 }
 
 bool CompositedLayerMapping::containsPaintedContent() const {
   if (layoutObject()->isImage() && isDirectlyCompositedImage())
     return false;
 
   LayoutObject* layoutObject = this->layoutObject();
-  // FIXME: we could optimize cases where the image, video or canvas is known to fill the border box entirely,
-  // and set background color on the layer in that case, instead of allocating backing store and painting.
+  // FIXME: we could optimize cases where the image, video or canvas is known to
+  // fill the border box entirely, and set background color on the layer in that
+  // case, instead of allocating backing store and painting.
   if (layoutObject->isVideo() &&
       toLayoutVideo(layoutObject)->shouldDisplayVideo())
     return m_owningLayer.hasBoxDecorationsOrBackground();
 
   if (m_owningLayer.hasVisibleBoxDecorations())
     return true;
 
   if (layoutObject->hasMask())  // masks require special treatment
     return true;
 
@@ skipping 84 matching lines @@
       image, LayoutObject::shouldRespectImageOrientation(imageLayoutObject));
 
   m_graphicsLayer->setFilterQuality(layoutObject()->style()->imageRendering() ==
                                             ImageRenderingPixelated
                                         ? kNone_SkFilterQuality
                                         : kLow_SkFilterQuality);
 
   // Prevent double-drawing: https://bugs.webkit.org/show_bug.cgi?id=58632
   updateDrawsContent();
 
-  // Image animation is "lazy", in that it automatically stops unless someone is drawing
-  // the image. So we have to kick the animation each time; this has the downside that the
-  // image will keep animating, even if its layer is not visible.
+  // Image animation is "lazy", in that it automatically stops unless someone is
+  // drawing the image. So we have to kick the animation each time; this has the
+  // downside that the image will keep animating, even if its layer is not
+  // visible.
   image->startAnimation();
 }
 
 FloatPoint3D CompositedLayerMapping::computeTransformOrigin(
     const IntRect& borderBox) const {
   const ComputedStyle& style = layoutObject()->styleRef();
 
   FloatPoint3D origin;
   origin.setX(floatValueForLength(style.transformOriginX(), borderBox.width()));
   origin.setY(
@@ skipping 50 matching lines @@
       m_overflowControlsAncestorClippingLayer
           ? m_overflowControlsAncestorClippingLayer.get()
           : m_overflowControlsHostLayer.get();
   GraphicsLayer* parent = parentForSublayers();
   bool needsOverflowControlsReattached =
       overflowControlsContainer &&
       overflowControlsContainer->parent() == parent;
 
   parent->setChildren(sublayers);
 
-  // If we have scrollbars, but are not using composited scrolling, then parentForSublayers may return m_graphicsLayer.
-  // In that case, the above call to setChildren has clobbered the overflow controls host layer, so we need to reattach it.
+  // If we have scrollbars, but are not using composited scrolling, then
+  // parentForSublayers may return m_graphicsLayer.  In that case, the above
+  // call to setChildren has clobbered the overflow controls host layer, so we
+  // need to reattach it.
   if (needsOverflowControlsReattached)
     parent->addChild(overflowControlsContainer);
 }
 
 GraphicsLayer* CompositedLayerMapping::childForSuperlayers() const {
   if (m_squashingContainmentLayer)
     return m_squashingContainmentLayer.get();
 
   if (m_ancestorClippingLayer)
     return m_ancestorClippingLayer.get();
@@ skipping 47 matching lines @@
   IntRect r;
   PaintInvalidationReason invalidationReason;
   const DisplayItemClient& client;
 };
 
 void CompositedLayerMapping::setContentsNeedDisplayInRect(
     const LayoutRect& r,
     PaintInvalidationReason invalidationReason,
     const DisplayItemClient& client) {
   DCHECK(!m_owningLayer.layoutObject()->usesCompositedScrolling());
-  // TODO(wangxianzhu): Enable the following assert after paint invalidation for spv2 is ready.
+  // TODO(wangxianzhu): Enable the following assert after paint invalidation for
+  // spv2 is ready.
   // ASSERT(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
   SetContentsNeedsDisplayInRectFunctor functor = {
       enclosingIntRect(LayoutRect(
           r.location() + m_owningLayer.subpixelAccumulation(), r.size())),
       invalidationReason, client};
   ApplyToGraphicsLayers(this, functor, ApplyToContentLayers);
 }
 
 void CompositedLayerMapping::setNonScrollingContentsNeedDisplayInRect(
     const LayoutRect& r,
     PaintInvalidationReason invalidationReason,
     const DisplayItemClient& client) {
   DCHECK(m_owningLayer.layoutObject()->usesCompositedScrolling());
-  // TODO(wangxianzhu): Enable the following assert after paint invalidation for spv2 is ready.
+  // TODO(wangxianzhu): Enable the following assert after paint invalidation for
+  // spv2 is ready.
   // ASSERT(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
   SetContentsNeedsDisplayInRectFunctor functor = {
       enclosingIntRect(LayoutRect(
           r.location() + m_owningLayer.subpixelAccumulation(), r.size())),
       invalidationReason, client};
   ApplyToGraphicsLayers(this, functor, ApplyToNonScrollingContentLayers);
 }
 
 void CompositedLayerMapping::setScrollingContentsNeedDisplayInRect(
     const LayoutRect& r,
     PaintInvalidationReason invalidationReason,
     const DisplayItemClient& client) {
   DCHECK(m_owningLayer.layoutObject()->usesCompositedScrolling());
-  // TODO(wangxianzhu): Enable the following assert after paint invalidation for spv2 is ready.
+  // TODO(wangxianzhu): Enable the following assert after paint invalidation for
+  // spv2 is ready.
   // ASSERT(!RuntimeEnabledFeatures::slimmingPaintV2Enabled());
 
   SetContentsNeedsDisplayInRectFunctor functor = {
       enclosingIntRect(LayoutRect(
           r.location() + m_owningLayer.subpixelAccumulation(), r.size())),
       invalidationReason, client};
   ApplyToGraphicsLayers(this, functor, ApplyToScrollingContentLayers);
 }
 
 const GraphicsLayerPaintInfo* CompositedLayerMapping::containingSquashedLayer(
@@ skipping 20 matching lines @@
     const Vector<GraphicsLayerPaintInfo>& layers) {
   const LayoutObject* clippingContainer =
       paintInfo.paintLayer->clippingContainer();
   if (clippingContainer == referenceLayer.clippingContainer())
     return LayoutRect::infiniteIntRect();
 
   ASSERT(clippingContainer);
 
   const GraphicsLayerPaintInfo* ancestorPaintInfo =
       containingSquashedLayer(clippingContainer, layers, layers.size());
-  // Must be there, otherwise CompositingLayerAssigner::canSquashIntoCurrentSquashingOwner would have disallowed squashing.
+  // Must be there, otherwise
+  // CompositingLayerAssigner::canSquashIntoCurrentSquashingOwner would have
+  // disallowed squashing.
   ASSERT(ancestorPaintInfo);
 
-  // FIXME: this is a potential performance issue. We should consider caching these clip rects or otherwise optimizing.
+  // FIXME: this is a potential performance issue. We should consider caching
+  // these clip rects or otherwise optimizing.
   ClipRectsContext clipRectsContext(ancestorPaintInfo->paintLayer,
                                     UncachedClipRects);
   IntRect parentClipRect =
       pixelSnappedIntRect(paintInfo.paintLayer->clipper()
                               .backgroundClipRect(clipRectsContext)
                               .rect());
   ASSERT(parentClipRect != LayoutRect::infiniteIntRect());
 
   // Convert from ancestor to local coordinates.
   IntSize ancestorToLocalOffset = paintInfo.offsetFromLayoutObject -
@@ skipping 49 matching lines @@
     if (paintInfo.paintLayer->containsDirtyOverlayScrollbars())
       PaintLayerPainter(*paintInfo.paintLayer)
           .paintLayerContents(
               context, paintingInfo,
               paintLayerFlags | PaintLayerPaintingOverlayScrollbars);
   } else {
     PaintLayerPaintingInfo paintingInfo(
         paintInfo.paintLayer, LayoutRect(dirtyRect), GlobalPaintNormalPhase,
         paintInfo.paintLayer->subpixelAccumulation());
 
-    // PaintLayer::paintLayer assumes that the caller clips to the passed rect. Squashed layers need to do this clipping in software,
-    // since there is no graphics layer to clip them precisely. Furthermore, in some cases we squash layers that need clipping in software
-    // from clipping ancestors (see CompositedLayerMapping::localClipRectForSquashedLayer()).
+    // PaintLayer::paintLayer assumes that the caller clips to the passed rect.
+    // Squashed layers need to do this clipping in software, since there is no
+    // graphics layer to clip them precisely. Furthermore, in some cases we
+    // squash layers that need clipping in software from clipping ancestors (see
+    // CompositedLayerMapping::localClipRectForSquashedLayer()).
     // FIXME: Is it correct to clip to dirtyRect in slimming paint mode?
     // FIXME: Combine similar code here and LayerClipRecorder.
     dirtyRect.intersect(paintInfo.localClipRectForSquashedLayer);
     context.getPaintController().createAndAppend<ClipDisplayItem>(
         graphicsLayer, DisplayItem::kClipLayerOverflowControls, dirtyRect);
 
     PaintLayerPainter(*paintInfo.paintLayer)
         .paintLayer(context, paintingInfo, paintLayerFlags);
     context.getPaintController().endItem<EndClipDisplayItem>(
         graphicsLayer, DisplayItem::clipTypeToEndClipType(
@@ skipping 20 matching lines @@
 // headless, where we would like to record an exact area (distance = 0).
 static const int kPixelDistanceToRecord = 4000;
 
 IntRect CompositedLayerMapping::recomputeInterestRect(
     const GraphicsLayer* graphicsLayer) const {
   FloatRect graphicsLayerBounds(FloatPoint(), graphicsLayer->size());
 
   IntSize offsetFromAnchorLayoutObject;
   const LayoutBoxModelObject* anchorLayoutObject;
   if (graphicsLayer == m_squashingLayer.get()) {
-    // TODO(chrishtr): this is a speculative fix for crbug.com/561306. However, it should never be the case that
-    // m_squashingLayer exists yet m_squashedLayers.size() == 0. There must be a bug elsewhere.
+    // TODO(chrishtr): this is a speculative fix for crbug.com/561306. However,
+    // it should never be the case that m_squashingLayer exists,
+    // yet m_squashedLayers.size() == 0. There must be a bug elsewhere.
     if (m_squashedLayers.size() == 0)
       return IntRect();
-    // All squashed layers have the same clip and transform space, so we can use the first squashed layer's
-    // layoutObject to map the squashing layer's bounds into viewport space, with offsetFromAnchorLayoutObject
-    // to translate squashing layer's bounds into the first squashed layer's space.
+    // All squashed layers have the same clip and transform space, so we can use
+    // the first squashed layer's layoutObject to map the squashing layer's
+    // bounds into viewport space, with offsetFromAnchorLayoutObject to
+    // translate squashing layer's bounds into the first squashed layer's space.
     anchorLayoutObject = m_squashedLayers[0].paintLayer->layoutObject();
     offsetFromAnchorLayoutObject = m_squashedLayers[0].offsetFromLayoutObject;
   } else {
     ASSERT(graphicsLayer == m_graphicsLayer.get() ||
            graphicsLayer == m_scrollingContentsLayer.get());
     anchorLayoutObject = m_owningLayer.layoutObject();
     offsetFromAnchorLayoutObject = graphicsLayer->offsetFromLayoutObject();
     adjustForCompositedScrolling(graphicsLayer, offsetFromAnchorLayoutObject);
   }
 
-  // Start with the bounds of the graphics layer in the space of the anchor LayoutObject.
+  // Start with the bounds of the graphics layer in the space of the anchor
+  // LayoutObject.
   FloatRect graphicsLayerBoundsInObjectSpace(graphicsLayerBounds);
   graphicsLayerBoundsInObjectSpace.move(offsetFromAnchorLayoutObject);
 
-  // Now map the bounds to its visible content rect in root view space, including applying clips along the way.
+  // Now map the bounds to its visible content rect in root view space,
+  // including applying clips along the way.
   LayoutRect graphicsLayerBoundsInRootViewSpace(
       graphicsLayerBoundsInObjectSpace);
   LayoutView* rootView = anchorLayoutObject->view();
   while (!rootView->frame()->ownerLayoutItem().isNull())
     rootView =
         LayoutAPIShim::layoutObjectFrom(rootView->frame()->ownerLayoutItem())
             ->view();
   anchorLayoutObject->mapToVisualRectInAncestorSpace(
       rootView, graphicsLayerBoundsInRootViewSpace);
   FloatRect visibleContentRect(graphicsLayerBoundsInRootViewSpace);
   rootView->frameView()->clipPaintRect(&visibleContentRect);
 
   IntRect enclosingGraphicsLayerBounds(enclosingIntRect(graphicsLayerBounds));
 
-  // Map the visible content rect from root view space to local graphics layer space.
+  // Map the visible content rect from root view space to local graphics layer
+  // space.
   IntRect localInterestRect;
-  // If the visible content rect is empty, then it makes no sense to map it back since there is nothing to map.
+  // If the visible content rect is empty, then it makes no sense to map it back
+  // since there is nothing to map.
   if (!visibleContentRect.isEmpty()) {
     localInterestRect =
         anchorLayoutObject
             ->absoluteToLocalQuad(visibleContentRect,
                                   UseTransforms | TraverseDocumentBoundaries)
             .enclosingBoundingBox();
     localInterestRect.move(-offsetFromAnchorLayoutObject);
-    // TODO(chrishtr): the code below is a heuristic, instead we should detect and return whether the mapping failed.
-    // In some cases, absoluteToLocalQuad can fail to map back to the local space, due to passing through
-    // non-invertible transforms or floating-point accuracy issues. Examples include rotation near 90 degrees
-    // or perspective. In such cases, fall back to painting the first kPixelDistanceToRecord pixels in each direction.
+    // TODO(chrishtr): the code below is a heuristic, instead we should detect
+    // and return whether the mapping failed.  In some cases,
+    // absoluteToLocalQuad can fail to map back to the local space, due to
+    // passing through non-invertible transforms or floating-point accuracy
+    // issues. Examples include rotation near 90 degrees or perspective. In such
+    // cases, fall back to painting the first kPixelDistanceToRecord pixels in
+    // each direction.
     localInterestRect.intersect(enclosingGraphicsLayerBounds);
   }
   // Expand by interest rect padding amount.
   localInterestRect.inflate(kPixelDistanceToRecord);
   localInterestRect.intersect(enclosingGraphicsLayerBounds);
   return localInterestRect;
 }
 
 static const int kMinimumDistanceBeforeRepaint = 512;
 
 bool CompositedLayerMapping::interestRectChangedEnoughToRepaint(
     const IntRect& previousInterestRect,
     const IntRect& newInterestRect,
     const IntSize& layerSize) {
   if (previousInterestRect.isEmpty() && newInterestRect.isEmpty())
     return false;
 
-  // Repaint when going from empty to not-empty, to cover cases where the layer is
-  // painted for the first time, or otherwise becomes visible.
+  // Repaint when going from empty to not-empty, to cover cases where the layer
+  // is painted for the first time, or otherwise becomes visible.
   if (previousInterestRect.isEmpty())
     return true;
 
-  // Repaint if the new interest rect includes area outside of a skirt around the existing interest rect.
+  // Repaint if the new interest rect includes area outside of a skirt around
+  // the existing interest rect.
   IntRect expandedPreviousInterestRect(previousInterestRect);
   expandedPreviousInterestRect.inflate(kMinimumDistanceBeforeRepaint);
   if (!expandedPreviousInterestRect.contains(newInterestRect))
     return true;
 
-  // Even if the new interest rect doesn't include enough new area to satisfy the condition above,
-  // repaint anyway if it touches a layer edge not touched by the existing interest rect.
-  // Because it's impossible to expose more area in the direction, repainting cannot be deferred
-  // until the exposed new area satisfies the condition above.
+  // Even if the new interest rect doesn't include enough new area to satisfy
+  // the condition above, repaint anyway if it touches a layer edge not touched
+  // by the existing interest rect.  Because it's impossible to expose more area
+  // in the direction, repainting cannot be deferred until the exposed new area
+  // satisfies the condition above.
   if (newInterestRect.x() == 0 && previousInterestRect.x() != 0)
     return true;
   if (newInterestRect.y() == 0 && previousInterestRect.y() != 0)
     return true;
   if (newInterestRect.maxX() == layerSize.width() &&
       previousInterestRect.maxX() != layerSize.width())
     return true;
   if (newInterestRect.maxY() == layerSize.height() &&
       previousInterestRect.maxY() != layerSize.height())
     return true;
@@ skipping 35 matching lines @@
 }
 
 void CompositedLayerMapping::adjustForCompositedScrolling(
     const GraphicsLayer* graphicsLayer,
     IntSize& offset) const {
   if (graphicsLayer == m_scrollingContentsLayer.get() ||
       graphicsLayer == m_foregroundLayer.get()) {
     if (PaintLayerScrollableArea* scrollableArea =
             m_owningLayer.getScrollableArea()) {
       if (scrollableArea->usesCompositedScrolling()) {
-        // Note: this is just the scroll offset, *not* the "adjusted scroll offset". Scroll offset
-        // does not include the origin adjustment. That is instead baked already into offsetFromLayoutObject.
+        // Note: this is just the scroll offset, *not* the "adjusted scroll
+        // offset". Scroll offset does not include the origin adjustment. That
+        // is instead baked already into offsetFromLayoutObject.
         DoubleSize scrollOffset = scrollableArea->scrollOffset();
         offset.expand(-scrollOffset.width(), -scrollOffset.height());
       }
     }
   }
 }
 
 void CompositedLayerMapping::paintContents(
     const GraphicsLayer* graphicsLayer,
     GraphicsContext& context,
     GraphicsLayerPaintingPhase graphicsLayerPaintingPhase,
     const IntRect& interestRect) const {
   // https://code.google.com/p/chromium/issues/detail?id=343772
   DisableCompositingQueryAsserts disabler;
   // Allow throttling to make sure no painting paths (e.g.,
   // ContentLayerDelegate::paintContents) try to paint throttled content.
   DocumentLifecycle::AllowThrottlingScope allowThrottling(
       m_owningLayer.layoutObject()->document().lifecycle());
 #if ENABLE(ASSERT)
-  // FIXME: once the state machine is ready, this can be removed and we can refer to that instead.
+  // FIXME: once the state machine is ready, this can be removed and we can
+  // refer to that instead.
   if (Page* page = layoutObject()->frame()->page())
     page->setIsPainting(true);
 #endif
 
   TRACE_EVENT1(
       "devtools.timeline,rail", "Paint", "data",
       InspectorPaintEvent::data(m_owningLayer.layoutObject(),
                                 LayoutRect(interestRect), graphicsLayer));
 
   PaintLayerFlags paintLayerFlags = 0;
@@ skipping 34 matching lines @@
       else
         paintLayerFlags |= PaintLayerPaintingSkipRootBackground;
     }
     GraphicsLayerPaintInfo paintInfo;
     paintInfo.paintLayer = &m_owningLayer;
     paintInfo.compositedBounds = compositedBounds();
     paintInfo.offsetFromLayoutObject = graphicsLayer->offsetFromLayoutObject();
     adjustForCompositedScrolling(graphicsLayer,
                                  paintInfo.offsetFromLayoutObject);
 
-    // We have to use the same root as for hit testing, because both methods can compute and cache clipRects.
+    // We have to use the same root as for hit testing, because both methods can
+    // compute and cache clipRects.
     doPaintTask(paintInfo, *graphicsLayer, paintLayerFlags, context,
                 interestRect);
   } else if (graphicsLayer == m_squashingLayer.get()) {
     for (size_t i = 0; i < m_squashedLayers.size(); ++i)
       doPaintTask(m_squashedLayers[i], *graphicsLayer, paintLayerFlags, context,
                   interestRect);
   } else if (isScrollableAreaLayer(graphicsLayer)) {
     paintScrollableArea(graphicsLayer, context, interestRect);
   }
   InspectorInstrumentation::didPaint(m_owningLayer.layoutObject()->frame(),
                                      graphicsLayer, context,
                                      LayoutRect(interestRect));
 #if ENABLE(ASSERT)
   if (Page* page = layoutObject()->frame()->page())
     page->setIsPainting(false);
 #endif
 }
 
 void CompositedLayerMapping::paintScrollableArea(
     const GraphicsLayer* graphicsLayer,
     GraphicsContext& context,
     const IntRect& interestRect) const {
-  // Note the composited scrollable area painted here is never associated with a frame. For
-  // painting frame ScrollableAreas, see PaintLayerCompositor::paintContents.
+  // Note the composited scrollable area painted here is never associated with a
+  // frame. For painting frame ScrollableAreas, see
+  // PaintLayerCompositor::paintContents.
 
   if (DrawingRecorder::useCachedDrawingIfPossible(
           context, *graphicsLayer, DisplayItem::kScrollbarCompositedScrollbar))
     return;
 
   FloatRect layerBounds(FloatPoint(), graphicsLayer->size());
   SkPictureBuilder pictureBuilder(layerBounds, nullptr, &context);
   PaintLayerScrollableArea* scrollableArea = m_owningLayer.getScrollableArea();
   if (graphicsLayer == layerForHorizontalScrollbar()) {
     paintScrollbar(scrollableArea->horizontalScrollbar(),
                    pictureBuilder.context(), interestRect);
   } else if (graphicsLayer == layerForVerticalScrollbar()) {
     paintScrollbar(scrollableArea->verticalScrollbar(),
                    pictureBuilder.context(), interestRect);
   } else if (graphicsLayer == layerForScrollCorner()) {
-    // Note that scroll corners always paint into local space, whereas scrollbars paint in the space of their containing frame.
+    // Note that scroll corners always paint into local space, whereas
+    // scrollbars paint in the space of their containing frame.
     IntPoint scrollCornerAndResizerLocation =
         scrollableArea->scrollCornerAndResizerRect().location();
     CullRect cullRect(enclosingIntRect(interestRect));
     ScrollableAreaPainter(*scrollableArea)
         .paintScrollCorner(pictureBuilder.context(),
                            -scrollCornerAndResizerLocation, cullRect);
     ScrollableAreaPainter(*scrollableArea)
         .paintResizer(pictureBuilder.context(), -scrollCornerAndResizerLocation,
                       cullRect);
   }
-  // Replay the painted scrollbar content with the GraphicsLayer backing as the DisplayItemClient
-  // in order for the resulting DrawingDisplayItem to produce the correct visualRect (i.e., the
-  // bounds of the involved GraphicsLayer).
+  // Replay the painted scrollbar content with the GraphicsLayer backing as the
+  // DisplayItemClient in order for the resulting DrawingDisplayItem to produce
+  // the correct visualRect (i.e., the bounds of the involved GraphicsLayer).
   DrawingRecorder drawingRecorder(context, *graphicsLayer,
                                   DisplayItem::kScrollbarCompositedScrollbar,
                                   layerBounds);
   pictureBuilder.endRecording()->playback(context.canvas());
 }
 
 bool CompositedLayerMapping::isScrollableAreaLayer(
     const GraphicsLayer* graphicsLayer) const {
   return graphicsLayer == layerForHorizontalScrollbar() ||
          graphicsLayer == layerForVerticalScrollbar() ||
          graphicsLayer == layerForScrollCorner();
 }
 
 bool CompositedLayerMapping::isTrackingRasterInvalidations() const {
   GraphicsLayerClient* client = compositor();
   return client ? client->isTrackingRasterInvalidations() : false;
 }
 
 #if ENABLE(ASSERT)
 void CompositedLayerMapping::verifyNotPainting() {
   ASSERT(!layoutObject()->frame()->page() ||
          !layoutObject()->frame()->page()->isPainting());
 }
 #endif
 
-// Only used for performance benchmark testing. Intended to be a sufficiently-unique
-// element id name to allow picking out the target element for invalidation.
+// Only used for performance benchmark testing. Intended to be a
+// sufficiently-unique element id name to allow picking out the target element
+// for invalidation.
 static const char* kTestPaintInvalidationTargetName =
     "blinkPaintInvalidationTarget";
 
 void CompositedLayerMapping::invalidateTargetElementForTesting() {
-  // The below is an artificial construct formed intentionally to focus a microbenchmark on the cost of paint with a
-  // partial invalidation.
+  // The below is an artificial construct formed intentionally to focus a
+  // microbenchmark on the cost of paint with a partial invalidation.
   Element* targetElement =
       m_owningLayer.layoutObject()->document().getElementById(
           AtomicString(kTestPaintInvalidationTargetName));
-  // TODO(wkorman): If we don't find the expected target element, we could consider walking to the first leaf node so
-  // that the partial-invalidation benchmark mode still provides some value when running on generic pages.
+  // TODO(wkorman): If we don't find the expected target element, we could
+  // consider walking to the first leaf node so that the partial-invalidation
+  // benchmark mode still provides some value when running on generic pages.
   if (!targetElement)
     return;
   LayoutObject* targetObject = targetElement->layoutObject();
   if (!targetObject)
     return;
   targetObject->enclosingLayer()->setNeedsRepaint();
-  // TODO(wkorman): Consider revising the below to invalidate all non-compositing descendants as well.
+  // TODO(wkorman): Consider revising the below to invalidate all
+  // non-compositing descendants as well.
   targetObject->invalidateDisplayItemClients(PaintInvalidationForTesting);
 }
 
 void CompositedLayerMapping::notifyPaint(bool isFirstPaint,
                                          bool textPainted,
                                          bool imagePainted) {
   if (PaintTiming* timing = m_owningLayer.paintTiming())
     timing->notifyPaint(isFirstPaint, textPainted, imagePainted);
 }
 
@@ skipping 20 matching lines @@
 }
 
 bool CompositedLayerMapping::updateSquashingLayerAssignment(
     PaintLayer* squashedLayer,
     size_t nextSquashedLayerIndex) {
   GraphicsLayerPaintInfo paintInfo;
   paintInfo.paintLayer = squashedLayer;
   // NOTE: composited bounds are updated elsewhere
   // NOTE: offsetFromLayoutObject is updated elsewhere
 
-  // Change tracking on squashing layers: at the first sign of something changed, just invalidate the layer.
+  // Change tracking on squashing layers: at the first sign of something
+  // changed, just invalidate the layer.
   // FIXME: Perhaps we can find a tighter more clever mechanism later.
   if (nextSquashedLayerIndex < m_squashedLayers.size()) {
     if (paintInfo.paintLayer ==
         m_squashedLayers[nextSquashedLayerIndex].paintLayer)
       return false;
 
     // Must invalidate before adding the squashed layer to the mapping.
     compositor()->paintInvalidationOnCompositingChange(squashedLayer);
 
-    // If the layer which was previously at |nextSquashedLayerIndex| is not earlier in the grouped mapping, invalidate its current
-    // backing now, since it will move later or be removed from the squashing layer.
+    // If the layer which was previously at |nextSquashedLayerIndex| is not
+    // earlier in the grouped mapping, invalidate its current backing now, since
+    // it will move later or be removed from the squashing layer.
     invalidateLayerIfNoPrecedingEntry(nextSquashedLayerIndex);
 
     m_squashedLayers.insert(nextSquashedLayerIndex, paintInfo);
   } else {
     // Must invalidate before adding the squashed layer to the mapping.
     compositor()->paintInvalidationOnCompositingChange(squashedLayer);
     m_squashedLayers.append(paintInfo);
   }
   squashedLayer->setGroupedMapping(
       this, PaintLayer::InvalidateLayerAndRemoveFromMapping);
@@ skipping 27 matching lines @@
   }
 
   return false;
 }
 #endif
 
 void CompositedLayerMapping::finishAccumulatingSquashingLayers(
     size_t nextSquashedLayerIndex,
     Vector<PaintLayer*>& layersNeedingPaintInvalidation) {
   if (nextSquashedLayerIndex < m_squashedLayers.size()) {
-    // Any additional squashed Layers in the array no longer belong here, but they might have been
-    // added already at an earlier index. Clear pointers on those that do not appear in the valid set
-    // before removing all the extra entries.
+    // Any additional squashed Layers in the array no longer belong here, but
+    // they might have been added already at an earlier index. Clear pointers on
+    // those that do not appear in the valid set before removing all the extra
+    // entries.
     for (size_t i = nextSquashedLayerIndex; i < m_squashedLayers.size(); ++i) {
       if (invalidateLayerIfNoPrecedingEntry(i))
         m_squashedLayers[i].paintLayer->setGroupedMapping(
             nullptr, PaintLayer::DoNotInvalidateLayerAndRemoveFromMapping);
       layersNeedingPaintInvalidation.append(m_squashedLayers[i].paintLayer);
     }
 
     m_squashedLayers.remove(nextSquashedLayerIndex,
                             m_squashedLayers.size() - nextSquashedLayerIndex);
   }
@@ skipping 41 matching lines @@
   } else if (graphicsLayer == m_scrollingContentsLayer.get()) {
     name = "Scrolling Contents Layer";
   } else {
     ASSERT_NOT_REACHED();
   }
 
   return name;
 }
 
 }  // namespace blink