reflow comments in core/svg/

third_party/WebKit/Source/core/svg/SVGPathParser.cpp

 /*
  * Copyright (C) 2002, 2003 The Karbon Developers
  * Copyright (C) 2006 Alexander Kellett <lypanov@kde.org>
  * Copyright (C) 2006, 2007 Rob Buis <buis@kde.org>
  * Copyright (C) 2007, 2009 Apple Inc. All rights reserved.
  * Copyright (C) Research In Motion Limited 2010. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
@@ skipping 150 matching lines @@
   m_currentPoint = normSeg.targetPoint;
 
   if (!isCubicCommand(segment.command) && !isQuadraticCommand(segment.command))
     m_controlPoint = m_currentPoint;
 
   m_lastCommand = segment.command;
 }
 
 // This works by converting the SVG arc to "simple" beziers.
 // Partly adapted from Niko's code in kdelibs/kdecore/svgicons.
-// See also SVG implementation notes: http://www.w3.org/TR/SVG/implnote.html#ArcConversionEndpointToCenter
+// See also SVG implementation notes:
+// http://www.w3.org/TR/SVG/implnote.html#ArcConversionEndpointToCenter
 bool SVGPathNormalizer::decomposeArcToCubic(const FloatPoint& currentPoint,
                                             const PathSegmentData& arcSegment) {
-  // If rx = 0 or ry = 0 then this arc is treated as a straight line segment (a "lineto") joining the endpoints.
+  // If rx = 0 or ry = 0 then this arc is treated as a straight line segment (a
+  // "lineto") joining the endpoints.
   // http://www.w3.org/TR/SVG/implnote.html#ArcOutOfRangeParameters
   float rx = fabsf(arcSegment.arcRadii().x());
   float ry = fabsf(arcSegment.arcRadii().y());
   if (!rx || !ry)
     return false;
 
-  // If the current point and target point for the arc are identical, it should be treated as a zero length
-  // path. This ensures continuity in animations.
+  // If the current point and target point for the arc are identical, it should
+  // be treated as a zero length path. This ensures continuity in animations.
   if (arcSegment.targetPoint == currentPoint)
     return false;
 
   float angle = arcSegment.arcAngle();
 
   FloatSize midPointDistance = currentPoint - arcSegment.targetPoint;
   midPointDistance.scale(0.5f);
 
   AffineTransform pointTransform;
   pointTransform.rotate(-angle);
@@ skipping 39 matching lines @@
   float thetaArc = theta2 - theta1;
   if (thetaArc < 0 && arcSegment.arcSweep)
     thetaArc += twoPiFloat;
   else if (thetaArc > 0 && !arcSegment.arcSweep)
     thetaArc -= twoPiFloat;
 
   pointTransform.makeIdentity();
   pointTransform.rotate(angle);
   pointTransform.scale(rx, ry);
 
-  // Some results of atan2 on some platform implementations are not exact enough. So that we get more
-  // cubic curves than expected here. Adding 0.001f reduces the count of sgements to the correct count.
+  // Some results of atan2 on some platform implementations are not exact
+  // enough. So that we get more cubic curves than expected here. Adding 0.001f
+  // reduces the count of sgements to the correct count.
   int segments = ceilf(fabsf(thetaArc / (piOverTwoFloat + 0.001f)));
   for (int i = 0; i < segments; ++i) {
     float startTheta = theta1 + i * thetaArc / segments;
     float endTheta = theta1 + (i + 1) * thetaArc / segments;
 
     float t = (8 / 6.f) * tanf(0.25f * (endTheta - startTheta));
     if (!std::isfinite(t))
       return false;
     float sinStartTheta = sinf(startTheta);
     float cosStartTheta = cosf(startTheta);
@@ skipping 13 matching lines @@
     cubicSegment.point1 = pointTransform.mapPoint(point1);
     cubicSegment.point2 = pointTransform.mapPoint(point2);
     cubicSegment.targetPoint = pointTransform.mapPoint(targetPoint);
 
     m_consumer->emitSegment(cubicSegment);
   }
   return true;
 }
 
 }  // namespace blink