reflow comments in core/paint

third_party/WebKit/Source/core/paint/PaintInvalidator.cpp

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/paint/PaintInvalidator.h"
 
 #include "core/editing/FrameSelection.h"
 #include "core/frame/FrameView.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Settings.h"
@@ skipping 197 matching lines @@
 
   if (object.isTable()) {
     const LayoutTable& table = toLayoutTable(object);
     if (table.collapseBorders() && !table.collapsedBorders().isEmpty())
       context.paintingLayer->setNeedsPaintPhaseDescendantBlockBackgrounds();
   }
 }
 
 namespace {
 
-// This is temporary to workaround paint invalidation issues in non-rootLayerScrolls mode.
-// It undos FrameView's content clip and scroll for paint invalidation of frame
-// scroll controls and the LayoutView to which the content clip and scroll don't apply.
+// This is temporary to workaround paint invalidation issues in
+// non-rootLayerScrolls mode.
+// It undoes FrameView's content clip and scroll for paint invalidation of frame
+// scroll controls and the LayoutView to which the content clip and scroll don't
+// apply.
 class ScopedUndoFrameViewContentClipAndScroll {
  public:
   ScopedUndoFrameViewContentClipAndScroll(const FrameView& frameView,
                                           PaintInvalidatorContext& context)
       : m_treeBuilderContext(const_cast<PaintPropertyTreeBuilderContext&>(
             context.treeBuilderContext)),
         m_savedContext(m_treeBuilderContext.current) {
     DCHECK(!RuntimeEnabledFeatures::rootLayerScrollingEnabled());
 
     if (frameView.contentClip() == m_savedContext.clip)
@@ skipping 20 matching lines @@
                                      PaintInvalidatorContext& context) {
   Optional<ScopedUndoFrameViewContentClipAndScroll>
       undoFrameViewContentClipAndScroll;
 
   if (object.isPaintInvalidationContainer()) {
     context.paintInvalidationContainer = toLayoutBoxModelObject(&object);
     if (object.styleRef().isStackingContext())
       context.paintInvalidationContainerForStackedContents =
           toLayoutBoxModelObject(&object);
   } else if (object.isLayoutView()) {
-    // paintInvalidationContainerForStackedContents is only for stacked descendants in its own frame,
-    // because it doesn't establish stacking context for stacked contents in sub-frames.
-    // Contents stacked in the root stacking context in this frame should use this frame's paintInvalidationContainer.
+    // paintInvalidationContainerForStackedContents is only for stacked
+    // descendants in its own frame, because it doesn't establish stacking
+    // context for stacked contents in sub-frames.
+    // Contents stacked in the root stacking context in this frame should use
+    // this frame's paintInvalidationContainer.
     context.paintInvalidationContainerForStackedContents =
         context.paintInvalidationContainer;
     if (!RuntimeEnabledFeatures::rootLayerScrollingEnabled())
       undoFrameViewContentClipAndScroll.emplace(
           *toLayoutView(object).frameView(), context);
-  } else if (
-      object.styleRef().isStacked()
-      // This is to exclude some objects (e.g. LayoutText) inheriting stacked style from parent but aren't actually stacked.
-      && object.hasLayer() &&
-      context.paintInvalidationContainer !=
-          context.paintInvalidationContainerForStackedContents) {
-    // The current object is stacked, so we should use m_paintInvalidationContainerForStackedContents as its
-    // paint invalidation container on which the current object is painted.
+  } else if (object.styleRef().isStacked() &&
+             // This is to exclude some objects (e.g. LayoutText) inheriting
+             // stacked style from parent but aren't actually stacked.
+             object.hasLayer() &&
+             context.paintInvalidationContainer !=
+                 context.paintInvalidationContainerForStackedContents) {
+    // The current object is stacked, so we should use
+    // m_paintInvalidationContainerForStackedContents as its paint invalidation
+    // container on which the current object is painted.
     context.paintInvalidationContainer =
         context.paintInvalidationContainerForStackedContents;
     if (context.forcedSubtreeInvalidationFlags &
         PaintInvalidatorContext::
             ForcedSubtreeFullInvalidationForStackedContents)
       context.forcedSubtreeInvalidationFlags |=
           PaintInvalidatorContext::ForcedSubtreeFullInvalidation;
   }
 
   if (object == context.paintInvalidationContainer) {
     // When we hit a new paint invalidation container, we don't need to
     // continue forcing a check for paint invalidation, since we're
     // descending into a different invalidation container. (For instance if
     // our parents were moved, the entire container will just move.)
     if (object != context.paintInvalidationContainerForStackedContents) {
-      // However, we need to keep the ForcedSubtreeFullInvalidationForStackedContents flag
-      // if the current object isn't the paint invalidation container of stacked contents.
+      // However, we need to keep the
+      // ForcedSubtreeFullInvalidationForStackedContents flag if the current
+      // object isn't the paint invalidation container of stacked contents.
       context.forcedSubtreeInvalidationFlags &= PaintInvalidatorContext::
           ForcedSubtreeFullInvalidationForStackedContents;
     } else {
       context.forcedSubtreeInvalidationFlags = 0;
     }
   }
 
   DCHECK(context.paintInvalidationContainer ==
          object.containerForPaintInvalidation());
   DCHECK(context.paintingLayer == object.paintingLayer());
 
   if (object.mayNeedPaintInvalidationSubtree())
     context.forcedSubtreeInvalidationFlags |=
         PaintInvalidatorContext::ForcedSubtreeInvalidationChecking;
 
-  // TODO(crbug.com/637313): This is temporary before we support filters in paint property tree.
+  // TODO(crbug.com/637313): This is temporary before we support filters in
+  // paint property tree.
   // TODO(crbug.com/648274): This is a workaround for multi-column contents.
   if (object.hasFilterInducingProperty() || object.isLayoutFlowThread())
     context.forcedSubtreeInvalidationFlags |=
         PaintInvalidatorContext::ForcedSubtreeSlowPathRect;
 
   context.oldBounds = object.previousPaintInvalidationRect();
   context.oldLocation = object.previousPositionFromPaintInvalidationBacking();
   context.newBounds = computePaintInvalidationRectInBacking(object, context);
   context.newLocation =
       computeLocationFromPaintInvalidationBacking(object, context);
@@ skipping 66 matching lines @@
   TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("blink.invalidation"),
                "PaintInvalidator::invalidatePaintIfNeeded()", "object",
                object.debugName().ascii());
 
   updateContext(object, context);
 
   if (!object
            .shouldCheckForPaintInvalidationRegardlessOfPaintInvalidationState() &&
       context.forcedSubtreeInvalidationFlags ==
           PaintInvalidatorContext::ForcedSubtreeInvalidationRectUpdate) {
-    // We are done updating the paint invalidation rect. No other paint invalidation work to do for this object.
+    // We are done updating the paint invalidation rect. No other paint
+    // invalidation work to do for this object.
     return;
   }
 
   PaintInvalidationReason reason = object.invalidatePaintIfNeeded(context);
   switch (reason) {
     case PaintInvalidationDelayedFull:
       m_pendingDelayedPaintInvalidations.append(&object);
       break;
     case PaintInvalidationSubtree:
       context.forcedSubtreeInvalidationFlags |=
           (PaintInvalidatorContext::ForcedSubtreeFullInvalidation |
            PaintInvalidatorContext::
                ForcedSubtreeFullInvalidationForStackedContents);
       break;
     case PaintInvalidationSVGResourceChange:
       context.forcedSubtreeInvalidationFlags |=
           PaintInvalidatorContext::ForcedSubtreeInvalidationChecking;
       break;
     default:
       break;
   }
 
   if (context.oldLocation != context.newLocation)
     context.forcedSubtreeInvalidationFlags |=
         PaintInvalidatorContext::ForcedSubtreeInvalidationChecking;
 
-  // TODO(crbug.com/533277): This is a workaround for the bug. Remove when we detect paint offset change.
+  // TODO(crbug.com/533277): This is a workaround for the bug. Remove when we
+  // detect paint offset change.
   if (reason != PaintInvalidationNone &&
       hasPercentageTransform(object.styleRef()))
     context.forcedSubtreeInvalidationFlags |=
         PaintInvalidatorContext::ForcedSubtreeInvalidationChecking;
 
-  // TODO(crbug.com/490725): This is a workaround for the bug, to force descendant to update paint invalidation
-  // rects on clipping change.
+  // TODO(crbug.com/490725): This is a workaround for the bug, to force
+  // descendant to update paint invalidation rects on clipping change.
   if (!RuntimeEnabledFeatures::slimmingPaintV2Enabled() &&
       context.oldBounds != context.newBounds
-      // Note that isLayoutView() below becomes unnecessary after the launch of root layer scrolling.
+      // Note that isLayoutView() below becomes unnecessary after the launch of
+      // root layer scrolling.
       && (object.hasOverflowClip() || object.isLayoutView()) &&
       !toLayoutBox(object).usesCompositedScrolling())
     context.forcedSubtreeInvalidationFlags |=
         PaintInvalidatorContext::ForcedSubtreeInvalidationRectUpdate;
 
   object.getMutableForPainting().clearPaintInvalidationFlags();
 }
 
 void PaintInvalidator::processPendingDelayedPaintInvalidations() {
   for (auto target : m_pendingDelayedPaintInvalidations)
     target->getMutableForPainting().setShouldDoFullPaintInvalidation(
         PaintInvalidationDelayedFull);
 }
 
 }  // namespace blink