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

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

 /*
  * Copyright (C) 2003, 2006, 2009 Apple Inc. All rights reserved.
  *               2006 Rob Buis <buis@kde.org>
  * Copyright (C) 2007-2008 Torch Mobile, Inc.
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
@@ skipping 36 matching lines @@
 
 enum PathElementType {
   PathElementMoveToPoint,          // The points member will contain 1 value.
   PathElementAddLineToPoint,       // The points member will contain 1 value.
   PathElementAddQuadCurveToPoint,  // The points member will contain 2 values.
   PathElementAddCurveToPoint,      // The points member will contain 3 values.
   PathElementCloseSubpath          // The points member will contain no values.
 };
 
 // The points in the structure are the same as those that would be used with the
-// add... method. For example, a line returns the endpoint, while a cubic returns
-// two tangent points and the endpoint.
+// add... method. For example, a line returns the endpoint, while a cubic
+// returns two tangent points and the endpoint.
 struct PathElement {
   PathElementType type;
   FloatPoint* points;
 };
 
 typedef void (*PathApplierFunction)(void* info, const PathElement*);
 
 class PLATFORM_EXPORT Path {
   USING_FAST_MALLOC(Path);
 
@@ skipping 16 matching lines @@
     Exact,         // Tight, slower version.
   };
   FloatRect boundingRect(BoundsType = BoundsType::Conservative) const;
   FloatRect strokeBoundingRect(const StrokeData&,
                                BoundsType = BoundsType::Conservative) const;
 
   float length() const;
   FloatPoint pointAtLength(float length) const;
   void pointAndNormalAtLength(float length, FloatPoint&, float&) const;
 
-  // Helper for computing a sequence of positions and normals (normal angles) on a path.
-  // The best possible access pattern will be one where the |length| value is
-  // strictly increasing.
-  // For other access patterns, performance will vary depending on curvature
-  // and number of segments, but should never be worse than that of the
-  // state-less method on Path.
+  // Helper for computing a sequence of positions and normals (normal angles) on
+  // a path. The best possible access pattern will be one where the |length|
+  // value is strictly increasing. For other access patterns, performance will
+  // vary depending on curvature and number of segments, but should never be
+  // worse than that of the state-less method on Path.
   class PLATFORM_EXPORT PositionCalculator {
     WTF_MAKE_NONCOPYABLE(PositionCalculator);
     USING_FAST_MALLOC(PositionCalculator);
 
    public:
     explicit PositionCalculator(const Path&);
 
     void pointAndNormalAtLength(float length, FloatPoint&, float&);
 
    private:
     SkPath m_path;
     SkPathMeasure m_pathMeasure;
     SkScalar m_accumulatedLength;
   };
 
   void clear();
   bool isEmpty() const;
   bool isClosed() const;
-  // Specify whether this path is volatile. Temporary paths that are discarded or
-  // modified after use should be marked as volatile. This is a hint to the device
-  // to not cache this path.
+
+  // Specify whether this path is volatile. Temporary paths that are discarded
+  // or modified after use should be marked as volatile. This is a hint to the
+  // device to not cache this path.
   void setIsVolatile(bool);
-  // Gets the current point of the current path, which is conceptually the final point reached by the path so far.
-  // Note the Path can be empty (isEmpty() == true) and still have a current point.
+
+  // Gets the current point of the current path, which is conceptually the final
+  // point reached by the path so far. Note the Path can be empty
+  // (isEmpty() == true) and still have a current point.
   bool hasCurrentPoint() const;
   FloatPoint currentPoint() const;
 
   void setWindRule(const WindRule);
 
   void moveTo(const FloatPoint&);
   void addLineTo(const FloatPoint&);
   void addQuadCurveTo(const FloatPoint& controlPoint,
                       const FloatPoint& endPoint);
   void addBezierCurveTo(const FloatPoint& controlPoint1,
@@ skipping 40 matching lines @@
   void transform(const AffineTransform&);
 
   void addPathForRoundedRect(const FloatRect&,
                              const FloatSize& topLeftRadius,
                              const FloatSize& topRightRadius,
                              const FloatSize& bottomLeftRadius,
                              const FloatSize& bottomRightRadius);
 
   bool subtractPath(const Path&);
 
-  // Updates the path to the union (inclusive-or) of itself with the given argument.
+  // Updates the path to the union (inclusive-or) of itself with the given
+  // argument.
   bool unionPath(const Path& other);
+
   bool intersectPath(const Path& other);
 
  private:
   void addEllipse(const FloatPoint&,
                   float radiusX,
                   float radiusY,
                   float startAngle,
                   float endAngle,
                   bool anticlockwise);
   SkPath strokePath(const StrokeData&) const;
 
   SkPath m_path;
 };
 
 #if ENABLE(ASSERT)
 PLATFORM_EXPORT bool ellipseIsRenderable(float startAngle, float endAngle);
 #endif
 
 }  // namespace blink
 
 #endif