reflow comments in core/paint

third_party/WebKit/Source/core/paint/PaintLayer.h

 /*
  * Copyright (C) 2003, 2009, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. All rights reserved.
  *
  * Portions are Copyright (C) 1998 Netscape Communications Corporation.
  *
  * Other contributors:
  *   Robert O'Callahan <roc+@cs.cmu.edu>
  *   David Baron <dbaron@fas.harvard.edu>
  *   Christian Biesinger <cbiesinger@web.de>
  *   Randall Jesup <rjesup@wgate.com>
  *   Roland Mainz <roland.mainz@informatik.med.uni-giessen.de>
  *   Josh Soref <timeless@mac.com>
  *   Boris Zbarsky <bzbarsky@mit.edu>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  *
  * Alternatively, the contents of this file may be used under the terms
  * of either the Mozilla Public License Version 1.1, found at
  * http://www.mozilla.org/MPL/ (the "MPL") or the GNU General Public
  * License Version 2.0, found at http://www.fsf.org/copyleft/gpl.html
  * (the "GPL"), in which case the provisions of the MPL or the GPL are
  * applicable instead of those above.  If you wish to allow use of your
  * version of this file only under the terms of one of those two
  * licenses (the MPL or the GPL) and not to allow others to use your
  * version of this file under the LGPL, indicate your decision by
@@ skipping 57 matching lines @@
 
 struct PaintLayerRareData {
   PaintLayerRareData();
   ~PaintLayerRareData();
 
   // Our current relative position offset.
   LayoutSize offsetForInFlowPosition;
 
   std::unique_ptr<TransformationMatrix> transform;
 
-  // Pointer to the enclosing Layer that caused us to be paginated. It is 0 if we are not paginated.
+  // Pointer to the enclosing Layer that caused us to be paginated. It is 0 if
+  // we are not paginated.
   //
   // See LayoutMultiColumnFlowThread and
   // https://sites.google.com/a/chromium.org/dev/developers/design-documents/multi-column-layout
-  // for more information about the multicol implementation. It's important to understand the
-  // difference between flow thread coordinates and visual coordinates when working with multicol
-  // in Layer, since Layer is one of the few places where we have to worry about the
-  // visual ones. Internally we try to use flow-thread coordinates whenever possible.
+  // for more information about the multicol implementation. It's important to
+  // understand the difference between flow thread coordinates and visual
+  // coordinates when working with multicol in Layer, since Layer is one of the
+  // few places where we have to worry about the visual ones. Internally we try
+  // to use flow-thread coordinates whenever possible.
   PaintLayer* enclosingPaginationLayer;
 
-  // These compositing reasons are updated whenever style changes, not while updating compositing layers.
-  // They should not be used to infer the compositing state of this layer.
+  // These compositing reasons are updated whenever style changes, not while
+  // updating compositing layers.  They should not be used to infer the
+  // compositing state of this layer.
   CompositingReasons potentialCompositingReasonsFromStyle;
 
-  // Once computed, indicates all that a layer needs to become composited using the CompositingReasons enum bitfield.
+  // Once computed, indicates all that a layer needs to become composited using
+  // the CompositingReasons enum bitfield.
   CompositingReasons compositingReasons;
 
   // This captures reasons why a paint layer might be forced to be separately
   // composited rather than sharing a backing with another layer.
   SquashingDisallowedReasons squashingDisallowedReasons;
 
-  // If the layer paints into its own backings, this keeps track of the backings.
-  // It's nullptr if the layer is not composited or paints into grouped backing.
+  // If the layer paints into its own backings, this keeps track of the
+  // backings.  It's nullptr if the layer is not composited or paints into
+  // grouped backing.
   std::unique_ptr<CompositedLayerMapping> compositedLayerMapping;
 
-  // If the layer paints into grouped backing (i.e. squashed), this points to the
-  // grouped CompositedLayerMapping. It's null if the layer is not composited or
-  // paints into its own backing.
+  // If the layer paints into grouped backing (i.e. squashed), this points to
+  // the grouped CompositedLayerMapping. It's null if the layer is not
+  // composited or paints into its own backing.
   CompositedLayerMapping* groupedMapping;
 
   Persistent<PaintLayerFilterInfo> filterInfo;
 
-  // The accumulated subpixel offset of a composited layer's composited bounds compared to absolute coordinates.
+  // The accumulated subpixel offset of a composited layer's composited bounds
+  // compared to absolute coordinates.
   LayoutSize subpixelAccumulation;
 };
 
 // PaintLayer is an old object that handles lots of unrelated operations.
 //
 // We want it to die at some point and be replaced by more focused objects,
 // which would remove (or at least compartimentalize) a lot of complexity.
 // See the STATUS OF PAINTLAYER section below.
 //
 // The class is central to painting and hit-testing. That's because it handles
@@ skipping 73 matching lines @@
     return m_layoutObject && m_layoutObject->isBox()
                ? toLayoutBox(m_layoutObject)
                : 0;
   }
   PaintLayer* parent() const { return m_parent; }
   PaintLayer* previousSibling() const { return m_previous; }
   PaintLayer* nextSibling() const { return m_next; }
   PaintLayer* firstChild() const { return m_first; }
   PaintLayer* lastChild() const { return m_last; }
 
-  // TODO(wangxianzhu): Find a better name for it. 'paintContainer' might be good but
-  // we can't use it for now because it conflicts with PaintInfo::paintContainer.
+  // TODO(wangxianzhu): Find a better name for it. 'paintContainer' might be
+  // good but we can't use it for now because it conflicts with
+  // PaintInfo::paintContainer.
   PaintLayer* compositingContainer() const;
 
   void addChild(PaintLayer* newChild, PaintLayer* beforeChild = 0);
   PaintLayer* removeChild(PaintLayer*);
 
   void removeOnlyThisLayerAfterStyleChange();
   void insertOnlyThisLayerAfterStyleChange();
 
   void styleDidChange(StyleDifference, const ComputedStyle* oldStyle);
 
   // FIXME: Many people call this function while it has out-of-date information.
   bool isSelfPaintingLayer() const { return m_isSelfPaintingLayer; }
 
-  // PaintLayers which represent LayoutParts may become self-painting due to being composited.
-  // If this is the case, this method returns true.
+  // PaintLayers which represent LayoutParts may become self-painting due to
+  // being composited.  If this is the case, this method returns true.
   bool isSelfPaintingOnlyBecauseIsCompositedPart() const;
 
   bool isTransparent() const {
     return layoutObject()->isTransparent() ||
            layoutObject()->style()->hasBlendMode() || layoutObject()->hasMask();
   }
 
   const PaintLayer* root() const {
     const PaintLayer* curr = this;
     while (curr->parent())
       curr = curr->parent();
     return curr;
   }
 
   const LayoutPoint& location() const {
     ASSERT(!m_needsPositionUpdate);
     return m_location;
   }
-  // FIXME: size() should ASSERT(!m_needsPositionUpdate) as well, but that fails in some tests,
-  // for example, fast/repaint/clipped-relative.html.
+  // FIXME: size() should ASSERT(!m_needsPositionUpdate) as well, but that fails
+  // in some tests, for example, fast/repaint/clipped-relative.html.
   const IntSize& size() const { return m_size; }
   void setSizeHackForLayoutTreeAsText(const IntSize& size) { m_size = size; }
 
   LayoutRect rect() const { return LayoutRect(location(), LayoutSize(size())); }
 
   bool isRootLayer() const { return m_isRootLayer; }
 
   PaintLayerCompositor* compositor() const;
 
-  // Notification from the layoutObject that its content changed (e.g. current frame of image changed).
-  // Allows updates of layer content without invalidating paint.
+  // Notification from the layoutObject that its content changed (e.g. current
+  // frame of image changed).  Allows updates of layer content without
+  // invalidating paint.
   void contentChanged(ContentChangeType);
 
   void updateLayerPosition();
 
   void updateLayerPositionsAfterLayout();
   void updateLayerPositionsAfterOverflowScroll(const DoubleSize& scrollDelta);
 
   PaintLayer* enclosingPaginationLayer() const {
     return m_rareData ? m_rareData->enclosingPaginationLayer : nullptr;
   }
 
   void updateTransformationMatrix();
   PaintLayer* renderingContextRoot();
   const PaintLayer* renderingContextRoot() const;
 
   LayoutSize offsetForInFlowPosition() const {
     return m_rareData ? m_rareData->offsetForInFlowPosition : LayoutSize();
   }
 
   PaintLayerStackingNode* stackingNode() { return m_stackingNode.get(); }
   const PaintLayerStackingNode* stackingNode() const {
     return m_stackingNode.get();
   }
 
   bool subtreeIsInvisible() const {
     return !hasVisibleContent() && !hasVisibleDescendant();
   }
 
-  // FIXME: hasVisibleContent() should call updateDescendantDependentFlags() if m_isVisibleContentDirty.
+  // FIXME: hasVisibleContent() should call updateDescendantDependentFlags() if
+  // m_isVisibleContentDirty.
   bool hasVisibleContent() const {
     DCHECK(!m_isVisibleContentDirty);
     return m_hasVisibleContent;
   }
 
-  // FIXME: hasVisibleDescendant() should call updateDescendantDependentFlags() if m_isVisibleDescendantDirty.
+  // FIXME: hasVisibleDescendant() should call updateDescendantDependentFlags()
+  // if m_isVisibleDescendantDirty.
   bool hasVisibleDescendant() const {
     DCHECK(!m_isVisibleDescendantDirty);
     return m_hasVisibleDescendant;
   }
 
   void dirtyVisibleContentStatus();
   void potentiallyDirtyVisibleContentStatus(EVisibility);
 
   bool hasBoxDecorationsOrBackground() const;
   bool hasVisibleBoxDecorations() const;
   // True if this layer container layoutObjects that paint.
   bool hasNonEmptyChildLayoutObjects() const;
 
   // Will ensure that isAllScrollingContentComposited() is up to date.
   void updateScrollingStateAfterCompositingChange();
   bool isAllScrollingContentComposited() const {
     return m_isAllScrollingContentComposited;
   }
 
-  // Gets the ancestor layer that serves as the containing block of this layer. This is either
-  // another out of flow positioned layer, or one that contains paint.
-  // If |ancestor| is specified, |*skippedAncestor| will be set to true if |ancestor| is found in
-  // the ancestry chain between this layer and the containing block layer; if not found, it will
-  // be set to false. Either both |ancestor| and |skippedAncestor| should be nullptr, or none of
-  // them should.
+  // Gets the ancestor layer that serves as the containing block of this layer.
+  // This is either another out of flow positioned layer, or one that contains
+  // paint.  If |ancestor| is specified, |*skippedAncestor| will be set to true
+  // if |ancestor| is found in the ancestry chain between this layer and the
+  // containing block layer; if not found, it will be set to false. Either both
+  // |ancestor| and |skippedAncestor| should be nullptr, or none of them should.
   PaintLayer* containingLayerForOutOfFlowPositioned(
       const PaintLayer* ancestor = nullptr,
       bool* skippedAncestor = nullptr) const;
 
   bool isPaintInvalidationContainer() const;
 
-  // Do *not* call this method unless you know what you are dooing. You probably want to call enclosingCompositingLayerForPaintInvalidation() instead.
+  // Do *not* call this method unless you know what you are dooing. You probably
+  // want to call enclosingCompositingLayerForPaintInvalidation() instead.
   // If includeSelf is true, may return this.
   PaintLayer* enclosingLayerWithCompositedLayerMapping(IncludeSelfOrNot) const;
 
-  // Returns the enclosing layer root into which this layer paints, inclusive of this one. Note that the enclosing layer may or may not have its own
-  // GraphicsLayer backing, but is nevertheless the root for a call to the Layer::paint*() methods.
+  // Returns the enclosing layer root into which this layer paints, inclusive of
+  // this one. Note that the enclosing layer may or may not have its own
+  // GraphicsLayer backing, but is nevertheless the root for a call to the
+  // Layer::paint*() methods.
   PaintLayer* enclosingLayerForPaintInvalidation() const;
 
   PaintLayer* enclosingLayerForPaintInvalidationCrossingFrameBoundaries() const;
 
   bool hasAncestorWithFilterThatMovesPixels() const;
 
   bool canUseConvertToLayerCoords() const {
-    // These LayoutObjects have an impact on their layers without the layoutObjects knowing about it.
+    // These LayoutObjects have an impact on their layers without the
+    // layoutObjects knowing about it.
     return !layoutObject()->hasTransformRelatedProperty() &&
            !layoutObject()->isSVGRoot();
   }
 
   void convertToLayerCoords(const PaintLayer* ancestorLayer,
                             LayoutPoint&) const;
   void convertToLayerCoords(const PaintLayer* ancestorLayer, LayoutRect&) const;
 
-  // Does the same as convertToLayerCoords() when not in multicol. For multicol, however,
-  // convertToLayerCoords() calculates the offset in flow-thread coordinates (what the layout
-  // engine uses internally), while this method calculates the visual coordinates; i.e. it figures
-  // out which column the layer starts in and adds in the offset. See
-  // http://www.chromium.org/developers/design-documents/multi-column-layout for more info.
+  // Does the same as convertToLayerCoords() when not in multicol. For multicol,
+  // however, convertToLayerCoords() calculates the offset in flow-thread
+  // coordinates (what the layout engine uses internally), while this method
+  // calculates the visual coordinates; i.e. it figures out which column the
+  // layer starts in and adds in the offset. See
+  // http://www.chromium.org/developers/design-documents/multi-column-layout for
+  // more info.
   LayoutPoint visualOffsetFromAncestor(const PaintLayer* ancestorLayer) const;
 
-  // Convert a bounding box from flow thread coordinates, relative to |this|, to visual coordinates, relative to |ancestorLayer|.
-  // See http://www.chromium.org/developers/design-documents/multi-column-layout for more info on these coordinate types.
-  // This method requires this layer to be paginated; i.e. it must have an enclosingPaginationLayer().
+  // Convert a bounding box from flow thread coordinates, relative to |this|, to
+  // visual coordinates, relative to |ancestorLayer|.
+  // See http://www.chromium.org/developers/design-documents/multi-column-layout
+  // for more info on these coordinate types.  This method requires this layer
+  // to be paginated; i.e. it must have an enclosingPaginationLayer().
   void convertFromFlowThreadToVisualBoundingBoxInAncestor(
       const PaintLayer* ancestorLayer,
       LayoutRect&) const;
 
-  // The hitTest() method looks for mouse events by walking layers that intersect the point from front to back.
+  // The hitTest() method looks for mouse events by walking layers that
+  // intersect the point from front to back.
   bool hitTest(HitTestResult&);
 
   bool intersectsDamageRect(const LayoutRect& layerBounds,
                             const LayoutRect& damageRect,
                             const LayoutPoint& offsetFromRoot) const;
 
-  // MaybeIncludeTransformForAncestorLayer means that a transform on |ancestorLayer| may be applied to the bounding box,
-  // in particular if paintsWithTransform() is true.
+  // MaybeIncludeTransformForAncestorLayer means that a transform on
+  // |ancestorLayer| may be applied to the bounding box, in particular if
+  // paintsWithTransform() is true.
   enum CalculateBoundsOptions {
     MaybeIncludeTransformForAncestorLayer,
     NeverIncludeTransformForAncestorLayer,
     IncludeTransformsAndCompositedChildLayers,
   };
 
   // Bounding box relative to some ancestor layer. Pass offsetFromRoot if known.
   LayoutRect physicalBoundingBox(const LayoutPoint& offsetFromRoot) const;
   LayoutRect physicalBoundingBox(const PaintLayer* ancestorLayer) const;
   LayoutRect physicalBoundingBoxIncludingStackingChildren(
       const LayoutPoint& offsetFromRoot,
       CalculateBoundsOptions = MaybeIncludeTransformForAncestorLayer) const;
   LayoutRect fragmentsBoundingBox(const PaintLayer* ancestorLayer) const;
 
   FloatRect boxForFilter() const;
   LayoutRect boxForClipPath() const;
 
   LayoutRect boundingBoxForCompositingOverlapTest() const;
 
-  // If true, this layer's children are included in its bounds for overlap testing.
-  // We can't rely on the children's positions if this layer has a filter that could have moved the children's pixels around.
+  // If true, this layer's children are included in its bounds for overlap
+  // testing.  We can't rely on the children's positions if this layer has a
+  // filter that could have moved the children's pixels around.
   bool overlapBoundsIncludeChildren() const;
   LayoutRect boundingBoxForCompositing(
       const PaintLayer* ancestorLayer = 0,
       CalculateBoundsOptions = MaybeIncludeTransformForAncestorLayer) const;
 
   LayoutUnit staticInlinePosition() const { return m_staticInlinePosition; }
   LayoutUnit staticBlockPosition() const { return m_staticBlockPosition; }
 
   void setStaticInlinePosition(LayoutUnit position) {
     m_staticInlinePosition = position;
   }
   void setStaticBlockPosition(LayoutUnit position) {
     m_staticBlockPosition = position;
   }
 
   LayoutSize subpixelAccumulation() const;
   void setSubpixelAccumulation(const LayoutSize&);
 
   bool hasTransformRelatedProperty() const {
     return layoutObject()->hasTransformRelatedProperty();
   }
   // Note that this transform has the transform-origin baked in.
   TransformationMatrix* transform() const {
     return m_rareData ? m_rareData->transform.get() : nullptr;
   }
 
-  // currentTransform computes a transform which takes accelerated animations into account. The
-  // resulting transform has transform-origin baked in. If the layer does not have a transform,
-  // returns the identity matrix.
+  // currentTransform computes a transform which takes accelerated animations
+  // into account. The resulting transform has transform-origin baked in. If the
+  // layer does not have a transform, returns the identity matrix.
   TransformationMatrix currentTransform() const;
   TransformationMatrix renderableTransform(GlobalPaintFlags) const;
 
   // Get the perspective transform, which is applied to transformed sublayers.
   // Returns true if the layer has a -webkit-perspective.
   // Note that this transform does not have the perspective-origin baked in.
   TransformationMatrix perspectiveTransform() const;
   FloatPoint perspectiveOrigin() const;
   bool preserves3D() const { return layoutObject()->style()->preserves3D(); }
   bool has3DTransform() const {
     return m_rareData && m_rareData->transform &&
            !m_rareData->transform->isAffine();
   }
 
-  // FIXME: reflections should force transform-style to be flat in the style: https://bugs.webkit.org/show_bug.cgi?id=106959
+  // FIXME: reflections should force transform-style to be flat in the style:
+  // https://bugs.webkit.org/show_bug.cgi?id=106959
   bool shouldPreserve3D() const {
     return !layoutObject()->hasReflection() &&
            layoutObject()->style()->preserves3D();
   }
 
   void filterNeedsPaintInvalidation();
 
   // Returns |true| if any property that renders using filter operations is
   // used (including, but not limited to, 'filter' and 'box-reflect').
   bool hasFilterInducingProperty() const {
     return layoutObject()->hasFilterInducingProperty();
   }
 
   void* operator new(size_t);
   // Only safe to call from LayoutBoxModelObject::destroyLayer()
   void operator delete(void*);
 
   CompositingState compositingState() const;
 
-  // This returns true if our document is in a phase of its lifestyle during which
-  // compositing state may legally be read.
+  // This returns true if our document is in a phase of its lifestyle during
+  // which compositing state may legally be read.
   bool isAllowedToQueryCompositingState() const;
 
   // Don't null check this.
   // FIXME: Rename.
   CompositedLayerMapping* compositedLayerMapping() const;
   GraphicsLayer* graphicsLayerBacking() const;
   GraphicsLayer* graphicsLayerBackingForScrolling() const;
   // Returns true for layers with scrollable overflow which have a background
-  // that can be painted into the composited scrolling contents layer when it exist
-  // (i.e. the background can scroll with the content). When the background is also
-  // opaque this allows us to composite the scroller even on low DPI as we can
-  // draw with subpixel anti-aliasing.
+  // that can be painted into the composited scrolling contents layer when it
+  // exist (i.e. the background can scroll with the content). When the
+  // background is also opaque this allows us to composite the scroller even on
+  // low DPI as we can draw with subpixel anti-aliasing.
   bool canPaintBackgroundOntoScrollingContentsLayer() const;
-  // NOTE: If you are using hasCompositedLayerMapping to determine the state of compositing for this layer,
-  // (and not just to do bookkeeping related to the mapping like, say, allocating or deallocating a mapping),
-  // then you may have incorrect logic. Use compositingState() instead.
-  // FIXME: This is identical to null checking compositedLayerMapping(), why not just call that?
+  // NOTE: If you are using hasCompositedLayerMapping to determine the state of
+  // compositing for this layer, (and not just to do bookkeeping related to the
+  // mapping like, say, allocating or deallocating a mapping), then you may have
+  // incorrect logic. Use compositingState() instead.
+  // FIXME: This is identical to null checking compositedLayerMapping(), why not
+  // just call that?
   bool hasCompositedLayerMapping() const {
     return m_rareData && m_rareData->compositedLayerMapping;
   }
   void ensureCompositedLayerMapping();
   void clearCompositedLayerMapping(bool layerBeingDestroyed = false);
   CompositedLayerMapping* groupedMapping() const {
     return m_rareData ? m_rareData->groupedMapping : nullptr;
   }
   enum SetGroupMappingOptions {
     InvalidateLayerAndRemoveFromMapping,
     DoNotInvalidateLayerAndRemoveFromMapping
   };
   void setGroupedMapping(CompositedLayerMapping*, SetGroupMappingOptions);
 
   bool hasCompositedMask() const;
   bool hasCompositedClippingMask() const;
   bool needsCompositedScrolling() const {
     return m_scrollableArea && m_scrollableArea->needsCompositedScrolling();
   }
 
   static void mapPointInPaintInvalidationContainerToBacking(
       const LayoutBoxModelObject& paintInvalidationContainer,
       FloatPoint&);
   static void mapRectInPaintInvalidationContainerToBacking(
       const LayoutBoxModelObject& paintInvalidationContainer,
       LayoutRect&);
 
-  // Adjusts the given rect (in the coordinate space of the LayoutObject) to the coordinate space of |paintInvalidationContainer|'s GraphicsLayer backing.
-  // Should use PaintInvalidationState::mapRectToPaintInvalidationBacking() instead if PaintInvalidationState is available.
+  // Adjusts the given rect (in the coordinate space of the LayoutObject) to the
+  // coordinate space of |paintInvalidationContainer|'s GraphicsLayer backing.
+  // Should use PaintInvalidationState::mapRectToPaintInvalidationBacking()
+  // instead if PaintInvalidationState is available.
   static void mapRectToPaintInvalidationBacking(
       const LayoutObject&,
       const LayoutBoxModelObject& paintInvalidationContainer,
       LayoutRect&);
 
   bool paintsWithTransparency(GlobalPaintFlags globalPaintFlags) const {
     return isTransparent() &&
            ((globalPaintFlags & GlobalPaintFlattenCompositingLayers) ||
             compositingState() != PaintsIntoOwnBacking);
   }
@@ skipping 42 matching lines @@
   bool isInTopLayer() const;
 
   bool scrollsWithViewport() const;
   bool scrollsWithRespectTo(const PaintLayer*) const;
 
   void addLayerHitTestRects(LayerHitTestRects&) const;
 
   // Compute rects only for this layer
   void computeSelfHitTestRects(LayerHitTestRects&) const;
 
-  // FIXME: This should probably return a ScrollableArea but a lot of internal methods are mistakenly exposed.
+  // FIXME: This should probably return a ScrollableArea but a lot of internal
+  // methods are mistakenly exposed.
   PaintLayerScrollableArea* getScrollableArea() const {
     return m_scrollableArea.get();
   }
 
   PaintLayerClipper clipper() const { return PaintLayerClipper(*this); }
 
   bool scrollsOverflow() const;
 
   CompositingReasons potentialCompositingReasonsFromStyle() const {
     return m_rareData ? m_rareData->potentialCompositingReasonsFromStyle
@@ skipping 189 matching lines @@
     ASSERT(isAllowedToQueryCompositingState());
     return m_shouldIsolateCompositedDescendants;
   }
   void setShouldIsolateCompositedDescendants(bool);
 
   void updateDescendantDependentFlags();
 
   void updateOrRemoveFilterEffect();
 
   void updateSelfPaintingLayer();
-  // This is O(depth) so avoid calling this in loops. Instead use optimizations like
-  // those in PaintInvalidationState.
+  // This is O(depth) so avoid calling this in loops. Instead use optimizations
+  // like those in PaintInvalidationState.
   PaintLayer* enclosingSelfPaintingLayer();
 
   PaintLayer* enclosingTransformedAncestor() const;
   LayoutPoint computeOffsetFromTransformedAncestor() const;
 
   void didUpdateNeedsCompositedScrolling();
 
   bool hasSelfPaintingLayerDescendant() const {
     if (m_hasSelfPaintingLayerDescendantDirty)
       updateHasSelfPaintingLayerDescendant();
@@ skipping 43 matching lines @@
       const PaintLayer* rootLayer,
       TransparencyClipBoxBehavior transparencyBehavior,
       TransparencyClipBoxMode transparencyMode,
       const LayoutSize& subPixelAccumulation,
       GlobalPaintFlags = GlobalPaintNormalPhase);
 
   bool needsRepaint() const { return m_needsRepaint; }
   void setNeedsRepaint();
   void clearNeedsRepaintRecursively();
 
-  // These previousXXX() functions are for subsequence caching. They save the painting status of the layer
-  // during the previous painting with subsequence. A painting without subsequence [1] doesn't change this status.
-  // [1] See shouldCreateSubsequence() in PaintLayerPainter.cpp for the cases we use subsequence when painting a PaintLayer.
+  // These previousXXX() functions are for subsequence caching. They save the
+  // painting status of the layer during the previous painting with subsequence.
+  // A painting without subsequence [1] doesn't change this status.  [1] See
+  // shouldCreateSubsequence() in PaintLayerPainter.cpp for the cases we use
+  // subsequence when painting a PaintLayer.
 
   IntSize previousScrollOffsetAccumulationForPainting() const {
     return m_previousScrollOffsetAccumulationForPainting;
   }
   void setPreviousScrollOffsetAccumulationForPainting(const IntSize& s) {
     m_previousScrollOffsetAccumulationForPainting = s;
   }
 
   ClipRects* previousPaintingClipRects() const {
     return m_previousPaintingClipRects.get();
   }
   void setPreviousPaintingClipRects(ClipRects& clipRects) {
     m_previousPaintingClipRects = &clipRects;
   }
 
   LayoutRect previousPaintDirtyRect() const { return m_previousPaintDirtyRect; }
   void setPreviousPaintDirtyRect(const LayoutRect& rect) {
     m_previousPaintDirtyRect = rect;
   }
 
   PaintLayerPainter::PaintResult previousPaintResult() const {
     return static_cast<PaintLayerPainter::PaintResult>(m_previousPaintResult);
   }
   void setPreviousPaintResult(PaintLayerPainter::PaintResult result) {
     m_previousPaintResult = static_cast<unsigned>(result);
     ASSERT(m_previousPaintResult == static_cast<unsigned>(result));
   }
 
-  // Used to skip PaintPhaseDescendantOutlinesOnly for layers that have never had descendant outlines.
-  // The flag is set during paint invalidation on a self painting layer if any contained object has outline.
-  // It's cleared during painting if PaintPhaseDescendantOutlinesOnly painted nothing.
+  // Used to skip PaintPhaseDescendantOutlinesOnly for layers that have never
+  // had descendant outlines.  The flag is set during paint invalidation on a
+  // self painting layer if any contained object has outline.  It's cleared
+  // during painting if PaintPhaseDescendantOutlinesOnly painted nothing.
   // For more details, see core/paint/REAME.md#Empty paint phase optimization.
   bool needsPaintPhaseDescendantOutlines() const {
     return m_needsPaintPhaseDescendantOutlines &&
            !m_previousPaintPhaseDescendantOutlinesWasEmpty;
   }
   void setNeedsPaintPhaseDescendantOutlines() {
     DCHECK(isSelfPaintingLayer());
     m_needsPaintPhaseDescendantOutlines = true;
     m_previousPaintPhaseDescendantOutlinesWasEmpty = false;
   }
@@ skipping 131 matching lines @@
 
   bool shouldBeSelfPaintingLayer() const;
 
   // FIXME: We should only create the stacking node if needed.
   bool requiresStackingNode() const { return true; }
   void updateStackingNode();
 
   FilterOperations addReflectionToFilterOperations(const ComputedStyle&) const;
   FilterEffect* updateFilterEffect() const;
 
-  // FIXME: We could lazily allocate our ScrollableArea based on style properties ('overflow', ...)
-  // but for now, we are always allocating it for LayoutBox as it's safer. crbug.com/467721.
+  // FIXME: We could lazily allocate our ScrollableArea based on style
+  // properties ('overflow', ...) but for now, we are always allocating it for
+  // LayoutBox as it's safer.  crbug.com/467721.
   bool requiresScrollableArea() const { return layoutBox(); }
   void updateScrollableArea();
 
   void dirtyAncestorChainVisibleDescendantStatus();
 
   bool attemptDirectCompositingUpdate(StyleDifference,
                                       const ComputedStyle* oldStyle);
   void updateTransform(const ComputedStyle* oldStyle,
                        const ComputedStyle& newStyle);
 
@@ skipping 18 matching lines @@
         layer.m_needsPaintPhaseDescendantOutlines;
     m_needsPaintPhaseFloat |= layer.m_needsPaintPhaseFloat;
     m_needsPaintPhaseDescendantBlockBackgrounds |=
         layer.m_needsPaintPhaseDescendantBlockBackgrounds;
   }
 
   bool isSelfPaintingLayerForIntrinsicOrScrollingReasons() const;
 
   bool shouldFragmentCompositedBounds(const PaintLayer* compositingLayer) const;
 
-  // Self-painting layer is an optimization where we avoid the heavy Layer painting
-  // machinery for a Layer allocated only to handle the overflow clip case.
-  // FIXME(crbug.com/332791): Self-painting layer should be merged into the overflow-only concept.
+  // Self-painting layer is an optimization where we avoid the heavy Layer
+  // painting machinery for a Layer allocated only to handle the overflow clip
+  // case.
+  // FIXME(crbug.com/332791): Self-painting layer should be merged into the
+  // overflow-only concept.
   unsigned m_isSelfPaintingLayer : 1;
 
-  // If have no self-painting descendants, we don't have to walk our children during painting. This can lead to
-  // significant savings, especially if the tree has lots of non-self-painting layers grouped together (e.g. table cells).
+  // If have no self-painting descendants, we don't have to walk our children
+  // during painting. This can lead to significant savings, especially if the
+  // tree has lots of non-self-painting layers grouped together (e.g. table
+  // cells).
   mutable unsigned m_hasSelfPaintingLayerDescendant : 1;
   mutable unsigned m_hasSelfPaintingLayerDescendantDirty : 1;
 
   const unsigned m_isRootLayer : 1;
 
   unsigned m_isVisibleContentDirty : 1;
   unsigned m_hasVisibleContent : 1;
   unsigned m_isVisibleDescendantDirty : 1;
   unsigned m_hasVisibleDescendant : 1;
 
 #if ENABLE(ASSERT)
   unsigned m_needsPositionUpdate : 1;
 #endif
 
   unsigned m_is3DTransformedDescendantDirty : 1;
   // Set on a stacking context layer that has 3D descendants anywhere
   // in a preserves3D hierarchy. Hint to do 3D-aware hit testing.
   unsigned m_has3DTransformedDescendant : 1;
 
   unsigned m_containsDirtyOverlayScrollbars : 1;
 
   unsigned m_needsAncestorDependentCompositingInputsUpdate : 1;
   unsigned m_needsDescendantDependentCompositingInputsUpdate : 1;
   unsigned m_childNeedsCompositingInputsUpdate : 1;
 
-  // Used only while determining what layers should be composited. Applies to the tree of z-order lists.
+  // Used only while determining what layers should be composited. Applies to
+  // the tree of z-order lists.
   unsigned m_hasCompositingDescendant : 1;
 
-  // True iff we have scrollable overflow and all children of m_layoutObject are known to paint
-  // exclusively into their own composited layers.  Set by updateScrollingStateAfterCompositingChange().
+  // True iff we have scrollable overflow and all children of m_layoutObject are
+  // known to paint exclusively into their own composited layers.  Set by
+  // updateScrollingStateAfterCompositingChange().
   unsigned m_isAllScrollingContentComposited : 1;
 
   // Should be for stacking contexts having unisolated blending descendants.
   unsigned m_shouldIsolateCompositedDescendants : 1;
 
-  // True if this layout layer just lost its grouped mapping due to the CompositedLayerMapping being destroyed,
-  // and we don't yet know to what graphics layer this Layer will be assigned.
+  // True if this layout layer just lost its grouped mapping due to the
+  // CompositedLayerMapping being destroyed, and we don't yet know to what
+  // graphics layer this Layer will be assigned.
   unsigned m_lostGroupedMapping : 1;
 
   unsigned m_needsRepaint : 1;
   unsigned m_previousPaintResult : 1;  // PaintLayerPainter::PaintResult
 
   unsigned m_needsPaintPhaseDescendantOutlines : 1;
   unsigned m_previousPaintPhaseDescendantOutlinesWasEmpty : 1;
   unsigned m_needsPaintPhaseFloat : 1;
   unsigned m_previousPaintPhaseFloatWasEmpty : 1;
   unsigned m_needsPaintPhaseDescendantBlockBackgrounds : 1;
   unsigned m_previousPaintPhaseDescendantBlockBackgroundsWasEmpty : 1;
 
-  // These bitfields are part of ancestor/descendant dependent compositing inputs.
+  // These bitfields are part of ancestor/descendant dependent compositing
+  // inputs.
   unsigned m_hasDescendantWithClipPath : 1;
   unsigned m_hasNonIsolatedDescendantWithBlendMode : 1;
   unsigned m_hasAncestorWithClipPath : 1;
   unsigned m_hasRootScrollerAsDescendant : 1;
 
   LayoutBoxModelObject* m_layoutObject;
 
   PaintLayer* m_parent;
   PaintLayer* m_previous;
   PaintLayer* m_next;
   PaintLayer* m_first;
   PaintLayer* m_last;
 
   // Our (x,y) coordinates are in our parent layer's coordinate space.
   LayoutPoint m_location;
 
   // The layer's size.
   //
   // If the associated LayoutBoxModelObject is a LayoutBox, it's its border
   // box. Otherwise, this is the LayoutInline's lines' bounding box.
   IntSize m_size;
 
-  // Cached normal flow values for absolute positioned elements with static left/top values.
+  // Cached normal flow values for absolute positioned elements with static
+  // left/top values.
   LayoutUnit m_staticInlinePosition;
   LayoutUnit m_staticBlockPosition;
 
   // The first ancestor having a non visible overflow.
   const PaintLayer* m_ancestorOverflowLayer;
 
   AncestorDependentCompositingInputs m_ancestorDependentCompositingInputs;
   std::unique_ptr<RareAncestorDependentCompositingInputs>
       m_rareAncestorDependentCompositingInputs;
 
@@ skipping 12 matching lines @@
 
 }  // namespace blink
 
 #ifndef NDEBUG
 // Outside the WebCore namespace for ease of invocation from gdb.
 void showLayerTree(const blink::PaintLayer*);
 void showLayerTree(const blink::LayoutObject*);
 #endif
 
 #endif  // Layer_h