reflow comments in core/paint

third_party/WebKit/Source/core/paint/BlockFlowPaintInvalidator.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/BlockFlowPaintInvalidator.h"
 
 #include "core/layout/LayoutBlockFlow.h"
 #include "core/layout/LayoutInline.h"
 #include "core/paint/BoxPaintInvalidator.h"
 #include "core/paint/PaintInvalidator.h"
 
 namespace blink {
 
 void BlockFlowPaintInvalidator::invalidatePaintForOverhangingFloatsInternal(
     InvalidateDescendantMode invalidateDescendants) {
-  // Invalidate paint of any overhanging floats (if we know we're the one to paint them).
-  // Otherwise, bail out.
+  // Invalidate paint of any overhanging floats (if we know we're the one to
+  // paint them).  Otherwise, bail out.
   if (!m_blockFlow.hasOverhangingFloats())
     return;
 
   for (const auto& floatingObject : m_blockFlow.floatingObjects()->set()) {
-    // Only issue paint invalidations for the object if it is overhanging, is not in its own layer, and
-    // is our responsibility to paint (m_shouldPaint is set). When paintAllDescendants is true, the latter
-    // condition is replaced with being a descendant of us.
+    // Only issue paint invalidations for the object if it is overhanging, is
+    // not in its own layer, and is our responsibility to paint (m_shouldPaint
+    // is set). When paintAllDescendants is true, the latter condition is
+    // replaced with being a descendant of us.
     if (m_blockFlow.isOverhangingFloat(*floatingObject) &&
         !floatingObject->layoutObject()->hasSelfPaintingLayer() &&
         (floatingObject->shouldPaint() ||
          (invalidateDescendants == InvalidateDescendants &&
           floatingObject->layoutObject()->isDescendantOf(&m_blockFlow)))) {
       LayoutBox* floatingBox = floatingObject->layoutObject();
       floatingBox->setShouldDoFullPaintInvalidation();
       if (floatingBox->isLayoutBlockFlow())
         BlockFlowPaintInvalidator(*toLayoutBlockFlow(floatingBox))
             .invalidatePaintForOverhangingFloatsInternal(
                 DontInvalidateDescendants);
     }
   }
 }
 
 void BlockFlowPaintInvalidator::invalidateDisplayItemClients(
     PaintInvalidationReason reason) {
   ObjectPaintInvalidator objectPaintInvalidator(m_blockFlow);
   objectPaintInvalidator.invalidateDisplayItemClient(m_blockFlow, reason);
 
   // PaintInvalidationRectangle happens when we invalidate the caret.
-  // The later conditions don't apply when we invalidate the caret or the selection.
+  // The later conditions don't apply when we invalidate the caret or the
+  // selection.
   if (reason == PaintInvalidationRectangle ||
       reason == PaintInvalidationSelection)
     return;
 
-  // If the block is a continuation or containing block of an inline continuation, invalidate the
-  // start object of the continuations if it has focus ring because change of continuation may change
-  // the shape of the focus ring.
+  // If the block is a continuation or containing block of an inline
+  // continuation, invalidate the start object of the continuations if it has
+  // focus ring because change of continuation may change the shape of the focus
+  // ring.
   if (m_blockFlow.isAnonymous()) {
     LayoutObject* startOfContinuations = nullptr;
     if (LayoutInline* inlineElementContinuation =
             m_blockFlow.inlineElementContinuation()) {
       // This block is an anonymous block continuation.
       startOfContinuations = inlineElementContinuation->node()->layoutObject();
     } else if (LayoutObject* firstChild = m_blockFlow.firstChild()) {
-      // This block is the anonymous containing block of an inline element continuation.
+      // This block is the anonymous containing block of an inline element
+      // continuation.
       if (firstChild->isElementContinuation())
         startOfContinuations = firstChild->node()->layoutObject();
     }
     if (startOfContinuations &&
         startOfContinuations->styleRef().outlineStyleIsAuto())
       ObjectPaintInvalidator(*startOfContinuations)
           .slowSetPaintingLayerNeedsRepaintAndInvalidateDisplayItemClient(
               *startOfContinuations, reason);
   }
 
   RootInlineBox* line = m_blockFlow.firstRootBox();
   if (line && line->isFirstLineStyle()) {
-    // It's the RootInlineBox that paints the ::first-line background. Note that since it may be
-    // expensive to figure out if the first line is affected by any ::first-line selectors at all,
-    // we just invalidate it unconditionally which is typically cheaper.
+    // It's the RootInlineBox that paints the ::first-line background. Note that
+    // since it may be expensive to figure out if the first line is affected by
+    // any ::first-line selectors at all, we just invalidate it unconditionally
+    // which is typically cheaper.
     objectPaintInvalidator.invalidateDisplayItemClient(*line, reason);
   }
 
   if (m_blockFlow.multiColumnFlowThread()) {
-    // Invalidate child LayoutMultiColumnSets which may need to repaint column rules after
-    // m_blockFlow's column rule style and/or layout changed.
+    // Invalidate child LayoutMultiColumnSets which may need to repaint column
+    // rules after m_blockFlow's column rule style and/or layout changed.
     for (LayoutObject* child = m_blockFlow.firstChild(); child;
          child = child->nextSibling()) {
       if (child->isLayoutMultiColumnSet() &&
           !child->shouldDoFullPaintInvalidation())
         objectPaintInvalidator.invalidateDisplayItemClient(*child, reason);
     }
   }
 }
 
 }  // namespace blink