reflow comments in core/paint

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

 // Copyright 2014 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/BlockPainter.h"
 
 #include "core/editing/DragCaretController.h"
 #include "core/editing/FrameSelection.h"
 #include "core/layout/LayoutFlexibleBox.h"
 #include "core/layout/LayoutInline.h"
@@ skipping 18 matching lines @@
 
 void BlockPainter::paint(const PaintInfo& paintInfo,
                          const LayoutPoint& paintOffset) {
   LayoutPoint adjustedPaintOffset = paintOffset + m_layoutBlock.location();
   if (!intersectsPaintRect(paintInfo, adjustedPaintOffset))
     return;
 
   PaintInfo localPaintInfo(paintInfo);
   PaintPhase originalPhase = localPaintInfo.phase;
 
-  // There are some cases where not all clipped visual overflow is accounted for.
+  // There are some cases where not all clipped visual overflow is accounted
+  // for.
   // FIXME: reduce the number of such cases.
   ContentsClipBehavior contentsClipBehavior = ForceContentsClip;
   if (m_layoutBlock.hasOverflowClip() && !m_layoutBlock.hasControlClip() &&
       !m_layoutBlock.hasCaret())
     contentsClipBehavior = SkipContentsClipIfPossible;
 
   if (originalPhase == PaintPhaseOutline) {
     localPaintInfo.phase = PaintPhaseDescendantOutlinesOnly;
   } else if (shouldPaintSelfBlockBackground(originalPhase)) {
     localPaintInfo.phase = PaintPhaseSelfBlockBackgroundOnly;
     m_layoutBlock.paintObject(localPaintInfo, adjustedPaintOffset);
     if (shouldPaintDescendantBlockBackgrounds(originalPhase))
       localPaintInfo.phase = PaintPhaseDescendantBlockBackgroundsOnly;
   }
 
   if (originalPhase != PaintPhaseSelfBlockBackgroundOnly &&
       originalPhase != PaintPhaseSelfOutlineOnly) {
     BoxClipper boxClipper(m_layoutBlock, localPaintInfo, adjustedPaintOffset,
                           contentsClipBehavior);
     m_layoutBlock.paintObject(localPaintInfo, adjustedPaintOffset);
   }
 
   if (shouldPaintSelfOutline(originalPhase)) {
     localPaintInfo.phase = PaintPhaseSelfOutlineOnly;
     m_layoutBlock.paintObject(localPaintInfo, adjustedPaintOffset);
   }
 
-  // Our scrollbar widgets paint exactly when we tell them to, so that they work properly with
-  // z-index. We paint after we painted the background/border, so that the scrollbars will
-  // sit above the background/border.
+  // Our scrollbar widgets paint exactly when we tell them to, so that they work
+  // properly with z-index. We paint after we painted the background/border, so
+  // that the scrollbars will sit above the background/border.
   localPaintInfo.phase = originalPhase;
   paintOverflowControlsIfNeeded(localPaintInfo, adjustedPaintOffset);
 }
 
 void BlockPainter::paintOverflowControlsIfNeeded(
     const PaintInfo& paintInfo,
     const LayoutPoint& paintOffset) {
   if (m_layoutBlock.hasOverflowClip() &&
       m_layoutBlock.style()->visibility() == EVisibility::Visible &&
       shouldPaintSelfBlockBackground(paintInfo.phase) &&
@@ skipping 50 matching lines @@
     ObjectPainter(child).paintAllPhasesAtomically(paintInfo, childPoint);
 }
 
 void BlockPainter::paintInlineBox(const InlineBox& inlineBox,
                                   const PaintInfo& paintInfo,
                                   const LayoutPoint& paintOffset) {
   if (paintInfo.phase != PaintPhaseForeground &&
       paintInfo.phase != PaintPhaseSelection)
     return;
 
-  // Text clips are painted only for the direct inline children of the object that has a text clip style on it, not block children.
+  // Text clips are painted only for the direct inline children of the object
+  // that has a text clip style on it, not block children.
   ASSERT(paintInfo.phase != PaintPhaseTextClip);
 
   LayoutPoint childPoint = paintOffset;
   if (inlineBox.parent()
           ->getLineLayoutItem()
           .style()
-          ->isFlippedBlocksWritingMode())  // Faster than calling containingBlock().
+          ->isFlippedBlocksWritingMode()) {
+    // Faster than calling containingBlock().
     childPoint =
         LineLayoutAPIShim::layoutObjectFrom(inlineBox.getLineLayoutItem())
             ->containingBlock()
             ->flipForWritingModeForChild(
                 toLayoutBox(LineLayoutAPIShim::layoutObjectFrom(
                     inlineBox.getLineLayoutItem())),
                 childPoint);
+  }
 
   ObjectPainter(
       *LineLayoutAPIShim::constLayoutObjectFrom(inlineBox.getLineLayoutItem()))
       .paintAllPhasesAtomically(paintInfo, childPoint);
 }
 
 void BlockPainter::paintObject(const PaintInfo& paintInfo,
                                const LayoutPoint& paintOffset) {
   const PaintPhase paintPhase = paintInfo.phase;
 
@@ skipping 67 matching lines @@
           paintPhase == PaintPhaseTextClip)
         blockFlowPainter.paintFloats(contentsPaintInfo, paintOffset);
     } else {
       paintContents(contentsPaintInfo, paintOffset);
     }
   }
 
   if (shouldPaintSelfOutline(paintPhase))
     ObjectPainter(m_layoutBlock).paintOutline(paintInfo, paintOffset);
 
-  // If the caret's node's layout object's containing block is this block, and the paint action is PaintPhaseForeground,
-  // then paint the caret.
+  // If the caret's node's layout object's containing block is this block, and
+  // the paint action is PaintPhaseForeground, then paint the caret.
   if (paintPhase == PaintPhaseForeground && m_layoutBlock.hasCaret())
     paintCarets(paintInfo, paintOffset);
 }
 
 void BlockPainter::paintCarets(const PaintInfo& paintInfo,
                                const LayoutPoint& paintOffset) {
   LocalFrame* frame = m_layoutBlock.frame();
 
   if (m_layoutBlock.hasCursorCaret())
     frame->selection().paintCaret(paintInfo.context, paintOffset);
 
   if (m_layoutBlock.hasDragCaret())
     frame->page()->dragCaretController().paintDragCaret(
         frame, paintInfo.context, paintOffset);
 }
 
 bool BlockPainter::intersectsPaintRect(
     const PaintInfo& paintInfo,
     const LayoutPoint& adjustedPaintOffset) const {
   LayoutRect overflowRect;
   if (paintInfo.isPrinting() && m_layoutBlock.isAnonymousBlock() &&
       m_layoutBlock.childrenInline()) {
-    // For case <a href="..."><div>...</div></a>, when m_layoutBlock is the anonymous container
-    // of <a>, the anonymous container's visual overflow is empty, but we need to continue
-    // painting to output <a>'s PDF URL rect which covers the continuations, as if we included
-    // <a>'s PDF URL rect into m_layoutBlock's visual overflow.
+    // For case <a href="..."><div>...</div></a>, when m_layoutBlock is the
+    // anonymous container of <a>, the anonymous container's visual overflow is
+    // empty, but we need to continue painting to output <a>'s PDF URL rect
+    // which covers the continuations, as if we included <a>'s PDF URL rect into
+    // m_layoutBlock's visual overflow.
     Vector<LayoutRect> rects;
     m_layoutBlock.addElementVisualOverflowRects(rects, LayoutPoint());
     overflowRect = unionRect(rects);
   }
   overflowRect.unite(m_layoutBlock.visualOverflowRect());
 
   bool usesCompositedScrolling = m_layoutBlock.hasOverflowModel() &&
                                  m_layoutBlock.usesCompositedScrolling();
 
   if (usesCompositedScrolling) {
     LayoutRect layoutOverflowRect = m_layoutBlock.layoutOverflowRect();
     overflowRect.unite(layoutOverflowRect);
   }
   m_layoutBlock.flipForWritingMode(overflowRect);
 
-  // Scrolling is applied in physical space, which is why it is after the flip above.
+  // Scrolling is applied in physical space, which is why it is after the flip
+  // above.
   if (usesCompositedScrolling) {
     overflowRect.move(-m_layoutBlock.scrolledContentOffset());
   }
 
   overflowRect.moveBy(adjustedPaintOffset);
   return paintInfo.cullRect().intersectsCullRect(overflowRect);
 }
 
 void BlockPainter::paintContents(const PaintInfo& paintInfo,
                                  const LayoutPoint& paintOffset) {
   DCHECK(!m_layoutBlock.childrenInline());
   PaintInfo paintInfoForDescendants = paintInfo.forDescendants();
   m_layoutBlock.paintChildren(paintInfoForDescendants, paintOffset);
 }
 
 }  // namespace blink