Rewrap comments to 80 columns in Source/platform/graphics/.

third_party/WebKit/Source/platform/graphics/Path.cpp

 /*
  * Copyright (C) 2003, 2006 Apple Computer, Inc.  All rights reserved.
  *                     2006 Rob Buis <buis@kde.org>
  * Copyright (C) 2007 Eric Seidel <eric@webkit.org>
  * Copyright (C) 2013 Google Inc. All rights reserved.
  * Copyright (C) 2013 Intel Corporation. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
@@ skipping 65 matching lines @@
   SkScalar y = WebCoreFloatToSkScalar(point.y());
   SkPath::FillType fillType = WebCoreWindRuleToSkFillType(rule);
   if (m_path.getFillType() != fillType) {
     SkPath tmp(m_path);
     tmp.setFillType(fillType);
     return tmp.contains(x, y);
   }
   return m_path.contains(x, y);
 }
 
-// FIXME: this method ignores the CTM and may yield inaccurate results for large scales.
+// FIXME: this method ignores the CTM and may yield inaccurate results for large
+// scales.
 SkPath Path::strokePath(const StrokeData& strokeData) const {
   SkPaint paint;
   strokeData.setupPaint(&paint);
 
   // Skia stroke resolution scale. This is multiplied by 4 internally
   // (i.e. 1.0 corresponds to 1/4 pixel res).
   static const SkScalar kResScale = 0.3f;
 
   SkPath strokePath;
   paint.getFillPath(m_path, &strokePath, nullptr, kResScale);
 
   return strokePath;
 }
 
 bool Path::strokeContains(const FloatPoint& point,
                           const StrokeData& strokeData) const {
   return strokePath(strokeData)
       .contains(WebCoreFloatToSkScalar(point.x()),
                 WebCoreFloatToSkScalar(point.y()));
 }
 
 namespace {
 
 FloatRect pathBounds(const SkPath& path, Path::BoundsType boundsType) {
   SkRect bounds;
   if (boundsType == Path::BoundsType::Conservative ||
       !TightBounds(path, &bounds) ||
-      bounds
-          .isEmpty())  // workaround for https://bugs.chromium.org/p/skia/issues/detail?id=5555
+      // Workaround for https://bugs.chromium.org/p/skia/issues/detail?id=5555 .
+      bounds.isEmpty())
     return path.getBounds();
 
   DCHECK_EQ(boundsType, Path::BoundsType::Exact);
   return bounds;
 }
 
 }  // anonymous ns
 
 // TODO(fmalita): evaluate returning exact bounds in all cases.
 FloatRect Path::boundingRect(BoundsType boundsType) const {
@@ skipping 33 matching lines @@
         break;
       case SkPath::kQuad_Verb:
         pathElement.type = PathElementAddQuadCurveToPoint;
         pathElement.points = convertPathPoints(pathPoints, &pts[1], 2);
         break;
       case SkPath::kCubic_Verb:
         pathElement.type = PathElementAddCurveToPoint;
         pathElement.points = convertPathPoints(pathPoints, &pts[1], 3);
         break;
       case SkPath::kConic_Verb: {
-        // Approximate with quads.  Use two for now, increase if more precision is needed.
+        // Approximate with quads.  Use two for now, increase if more precision
+        // is needed.
         const int kPow2 = 1;
         const unsigned quadCount = 1 << kPow2;
         SkPoint quads[1 + 2 * quadCount];
         SkPath::ConvertConicToQuads(pts[0], pts[1], pts[2], iter.conicWeight(),
                                     quads, kPow2);
 
         pathElement.type = PathElementAddQuadCurveToPoint;
         for (unsigned i = 0; i < quadCount; ++i) {
           pathElement.points =
               convertPathPoints(pathPoints, &quads[1 + 2 * i], 2);
@@ skipping 200 matching lines @@
 
   SkRect oval;
   oval.set(cx - radiusXScalar, cy - radiusYScalar, cx + radiusXScalar,
            cy + radiusYScalar);
 
   float sweep = endAngle - startAngle;
   SkScalar startDegrees = WebCoreFloatToSkScalar(startAngle * 180 / piFloat);
   SkScalar sweepDegrees = WebCoreFloatToSkScalar(sweep * 180 / piFloat);
   SkScalar s360 = SkIntToScalar(360);
 
-  // We can't use SkPath::addOval(), because addOval() makes new sub-path. addOval() calls moveTo() and close() internally.
+  // We can't use SkPath::addOval(), because addOval() makes a new sub-path.
+  // addOval() calls moveTo() and close() internally.
 
-  // Use s180, not s360, because SkPath::arcTo(oval, angle, s360, false) draws nothing.
+  // Use s180, not s360, because SkPath::arcTo(oval, angle, s360, false) draws
+  // nothing.
   SkScalar s180 = SkIntToScalar(180);
   if (SkScalarNearlyEqual(sweepDegrees, s360)) {
-    // SkPath::arcTo can't handle the sweepAngle that is equal to or greater than 2Pi.
+    // SkPath::arcTo can't handle the sweepAngle that is equal to or greater
+    // than 2Pi.
     m_path.arcTo(oval, startDegrees, s180, false);
     m_path.arcTo(oval, startDegrees + s180, s180, false);
     return;
   }
   if (SkScalarNearlyEqual(sweepDegrees, -s360)) {
     m_path.arcTo(oval, startDegrees, -s180, false);
     m_path.arcTo(oval, startDegrees - s180, -s180, false);
     return;
   }
 
@@ skipping 53 matching lines @@
 }
 
 void Path::addRoundedRect(const FloatRect& rect,
                           const FloatSize& roundingRadii) {
   if (rect.isEmpty())
     return;
 
   FloatSize radius(roundingRadii);
   FloatSize halfSize(rect.width() / 2, rect.height() / 2);
 
-  // Apply the SVG corner radius constraints, per the rect section of the SVG shapes spec: if
-  // one of rx,ry is negative, then the other corner radius value is used. If both values are
-  // negative then rx = ry = 0. If rx is greater than half of the width of the rectangle
-  // then set rx to half of the width; ry is handled similarly.
+  // Apply the SVG corner radius constraints, per the rect section of the SVG
+  // shapes spec: if one of rx,ry is negative, then the other corner radius
+  // value is used. If both values are negative then rx = ry = 0. If rx is
+  // greater than half of the width of the rectangle then set rx to half of the
+  // width; ry is handled similarly.
 
   if (radius.width() < 0)
     radius.setWidth((radius.height() < 0) ? 0 : radius.height());
 
   if (radius.height() < 0)
     radius.setHeight(radius.width());
 
   if (radius.width() > halfSize.width())
     radius.setWidth(halfSize.width());
 
   if (radius.height() > halfSize.height())
     radius.setHeight(halfSize.height());
 
   addPathForRoundedRect(rect, radius, radius, radius, radius);
 }
 
 void Path::addRoundedRect(const FloatRect& rect,
                           const FloatSize& topLeftRadius,
                           const FloatSize& topRightRadius,
                           const FloatSize& bottomLeftRadius,
                           const FloatSize& bottomRightRadius) {
   if (rect.isEmpty())
     return;
 
   if (rect.width() < topLeftRadius.width() + topRightRadius.width() ||
       rect.width() < bottomLeftRadius.width() + bottomRightRadius.width() ||
       rect.height() < topLeftRadius.height() + bottomLeftRadius.height() ||
       rect.height() < topRightRadius.height() + bottomRightRadius.height()) {
     // If all the radii cannot be accommodated, return a rect.
-    // FIXME: is this an error scenario, given that it appears the code in FloatRoundedRect::constrainRadii()
-    // should be always called first? Should we assert that this code is not reached?
-    // This fallback is very bad, since it means that radii that are just barely too big due to rounding or snapping
-    // will get completely ignored.
+    // FIXME: Is this an error scenario, given that it appears the code in
+    // FloatRoundedRect::constrainRadii() should be always called first? Should
+    // we assert that this code is not reached? This fallback is very bad, since
+    // it means that radii that are just barely too big due to rounding or
+    // snapping will get completely ignored.
     addRect(rect);
     return;
   }
 
   addPathForRoundedRect(rect, topLeftRadius, topRightRadius, bottomLeftRadius,
                         bottomRightRadius);
 }
 
 void Path::addPathForRoundedRect(const FloatRect& rect,
                                  const FloatSize& topLeftRadius,
@@ skipping 28 matching lines @@
 }
 
 #if ENABLE(ASSERT)
 bool ellipseIsRenderable(float startAngle, float endAngle) {
   return (std::abs(endAngle - startAngle) < twoPiFloat) ||
          WebCoreFloatNearlyEqual(std::abs(endAngle - startAngle), twoPiFloat);
 }
 #endif
 
 }  // namespace blink