reflow comments in core/paint

third_party/WebKit/Source/core/paint/ObjectPainter.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/ObjectPainter.h"
 
 #include "core/layout/LayoutBlock.h"
 #include "core/layout/LayoutInline.h"
 #include "core/layout/LayoutObject.h"
 #include "core/layout/LayoutTheme.h"
@@ skipping 30 matching lines @@
   int x2;
   int y2;
   BoxSide side;
 };
 
 // Adjust length of edges if needed. Returns the width of the joint.
 int adjustJoint(int outlineWidth,
                 OutlineEdgeInfo& edge1,
                 OutlineEdgeInfo& edge2) {
   // A clockwise joint:
-  // - needs no adjustment of edge length because our edges are along the clockwise outer edge of the outline;
+  // - needs no adjustment of edge length because our edges are along the
+  //   clockwise outer edge of the outline;
   // - needs a positive adjacent joint width (required by drawLineForBoxSide).
   // A counterclockwise joint:
   // - needs to increase the edge length to include the joint;
   // - needs a negative adjacent joint width (required by drawLineForBoxSide).
   switch (edge1.side) {
     case BSTop:
       switch (edge2.side) {
         case BSRight:  // Clockwise
           return outlineWidth;
         case BSLeft:  // Counterclockwise
@@ skipping 106 matching lines @@
   bool useTransparencyLayer = color.hasAlpha();
   if (useTransparencyLayer) {
     graphicsContext.beginLayer(static_cast<float>(color.alpha()) / 255);
     outlineColor =
         Color(outlineColor.red(), outlineColor.green(), outlineColor.blue());
   }
 
   ASSERT(count >= 4 && edges.size() == count);
   int firstAdjacentWidth = adjustJoint(width, edges.last(), edges.first());
 
-  // The width of the angled part of starting and ending joint of the current edge.
+  // The width of the angled part of starting and ending joint of the current
+  // edge.
   int adjacentWidthStart = firstAdjacentWidth;
   int adjacentWidthEnd;
   for (size_t i = 0; i < count; ++i) {
     OutlineEdgeInfo& edge = edges[i];
     adjacentWidthEnd = i == count - 1 ? firstAdjacentWidth
                                       : adjustJoint(width, edge, edges[i + 1]);
     int adjacentWidth1 = adjacentWidthStart;
     int adjacentWidth2 = adjacentWidthEnd;
     if (edge.side == BSLeft || edge.side == BSBottom)
       std::swap(adjacentWidth1, adjacentWidth2);
@@ skipping 28 matching lines @@
 
 void ObjectPainter::paintOutline(const PaintInfo& paintInfo,
                                  const LayoutPoint& paintOffset) {
   ASSERT(shouldPaintSelfOutline(paintInfo.phase));
 
   const ComputedStyle& styleToUse = m_layoutObject.styleRef();
   if (!styleToUse.hasOutline() ||
       styleToUse.visibility() != EVisibility::Visible)
     return;
 
-  // Only paint the focus ring by hand if the theme isn't able to draw the focus ring.
+  // Only paint the focus ring by hand if the theme isn't able to draw the focus
+  // ring.
   if (styleToUse.outlineStyleIsAuto() &&
       !LayoutTheme::theme().shouldDrawDefaultFocusRing(m_layoutObject))
     return;
 
   Vector<LayoutRect> outlineRects;
   m_layoutObject.addOutlineRects(
       outlineRects, paintOffset,
       m_layoutObject.outlineRectsShouldIncludeBlockVisualOverflow());
   if (outlineRects.isEmpty())
     return;
@@ skipping 109 matching lines @@
   int thickness;
   int length;
   if (side == BSTop || side == BSBottom) {
     thickness = y2 - y1;
     length = x2 - x1;
   } else {
     thickness = x2 - x1;
     length = y2 - y1;
   }
 
-  // We would like this check to be an ASSERT as we don't want to draw empty borders. However
-  // nothing guarantees that the following recursive calls to drawLineForBoxSide will have
-  // positive thickness and length.
+  // We would like this check to be an ASSERT as we don't want to draw empty
+  // borders. However nothing guarantees that the following recursive calls to
+  // drawLineForBoxSide will have positive thickness and length.
   if (length <= 0 || thickness <= 0)
     return;
 
   if (style == BorderStyleDouble && thickness < 3)
     style = BorderStyleSolid;
 
   switch (style) {
     case BorderStyleNone:
     case BorderStyleHidden:
       return;
@@ skipping 290 matching lines @@
       quad[2] = FloatPoint(x2, y2 - std::max(-adjacentWidth2, 0));
       quad[3] = FloatPoint(x2, y1 + std::max(-adjacentWidth1, 0));
       break;
   }
 
   fillQuad(graphicsContext, quad, color, antialias);
 }
 
 void ObjectPainter::paintAllPhasesAtomically(const PaintInfo& paintInfo,
                                              const LayoutPoint& paintOffset) {
-  // Pass PaintPhaseSelection and PaintPhaseTextClip to the descendants so that they will paint
-  // for selection and text clip respectively. We don't need complete painting for these phases.
+  // Pass PaintPhaseSelection and PaintPhaseTextClip to the descendants so that
+  // they will paint for selection and text clip respectively. We don't need
+  // complete painting for these phases.
   if (paintInfo.phase == PaintPhaseSelection ||
       paintInfo.phase == PaintPhaseTextClip) {
     m_layoutObject.paint(paintInfo, paintOffset);
     return;
   }
 
   if (paintInfo.phase != PaintPhaseForeground)
     return;
 
   PaintInfo info(paintInfo);
   info.phase = PaintPhaseBlockBackground;
   m_layoutObject.paint(info, paintOffset);
   info.phase = PaintPhaseFloat;
   m_layoutObject.paint(info, paintOffset);
   info.phase = PaintPhaseForeground;
   m_layoutObject.paint(info, paintOffset);
   info.phase = PaintPhaseOutline;
   m_layoutObject.paint(info, paintOffset);
 }
 
 }  // namespace blink