Style bikeshed - remove extraneous whitespace

src/gpu/batches/GrAAConvexTessellator.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrAAConvexTessellator_DEFINED
 #define GrAAConvexTessellator_DEFINED
 
@@ skipping 13 matching lines @@
 static const SkScalar kAntialiasingRadius = 0.5f;
 
 class GrAAConvexTessellator;
 
 // The AAConvexTessellator holds the global pool of points and the triangulation
 // that connects them. It also drives the tessellation process.
 // The outward facing normals of the original polygon are stored (in 'fNorms') to service
 // computeDepthFromEdge requests.
 class GrAAConvexTessellator {
 public:
-    GrAAConvexTessellator(SkScalar strokeWidth = -1.0f, 
-                          SkPaint::Join join = SkPaint::Join::kBevel_Join, 
+    GrAAConvexTessellator(SkScalar strokeWidth = -1.0f,
+                          SkPaint::Join join = SkPaint::Join::kBevel_Join,
                           SkScalar miterLimit = 0.0f)
         : fSide(SkPoint::kOn_Side)
         , fStrokeWidth(strokeWidth)
         , fJoin(join)
         , fMiterLimit(miterLimit) {
     }
 
     SkPoint::Side side() const { return fSide; }
 
     bool tessellate(const SkMatrix& m, const SkPath& path);
 
     // The next five should only be called after tessellate to extract the result
     int numPts() const { return fPts.count(); }
     int numIndices() const { return fIndices.count(); }
 
     const SkPoint& lastPoint() const { return fPts.top(); }
     const SkPoint& point(int index) const { return fPts[index]; }
     int index(int index) const { return fIndices[index]; }
     SkScalar coverage(int index) const { return fCoverages[index]; }
 
 #if GR_AA_CONVEX_TESSELLATOR_VIZ
     void draw(SkCanvas* canvas) const;
 #endif
 
     // The tessellator can be reused for multiple paths by rewinding in between
     void rewind();
 
 private:
-    // CandidateVerts holds the vertices for the next ring while they are 
+    // CandidateVerts holds the vertices for the next ring while they are
     // being generated. Its main function is to de-dup the points.
     class CandidateVerts {
     public:
         void setReserve(int numPts) { fPts.setReserve(numPts); }
         void rewind() { fPts.rewind(); }
 
         int numPts() const { return fPts.count(); }
 
         const SkPoint& lastPoint() const { return fPts.top().fPt; }
         const SkPoint& firstPoint() const { return fPts[0].fPt; }
@@ skipping 131 matching lines @@
     void terminate(const Ring& lastRing);
 
     // return false on failure/degenerate path
     bool extractFromPath(const SkMatrix& m, const SkPath& path);
     void computeBisectors();
 
     void fanRing(const Ring& ring);
 
     Ring* getNextRing(Ring* lastRing);
 
-    void createOuterRing(const Ring& previousRing, SkScalar outset, SkScalar coverage, 
+    void createOuterRing(const Ring& previousRing, SkScalar outset, SkScalar coverage,
                          Ring* nextRing);
 
-    bool createInsetRings(Ring& previousRing, SkScalar initialDepth, SkScalar initialCoverage, 
+    bool createInsetRings(Ring& previousRing, SkScalar initialDepth, SkScalar initialCoverage,
                           SkScalar targetDepth, SkScalar targetCoverage, Ring** finalRing);
 
-    bool createInsetRing(const Ring& lastRing, Ring* nextRing, 
-                         SkScalar initialDepth, SkScalar initialCoverage, SkScalar targetDepth, 
+    bool createInsetRing(const Ring& lastRing, Ring* nextRing,
+                         SkScalar initialDepth, SkScalar initialCoverage, SkScalar targetDepth,
                          SkScalar targetCoverage, bool forceNew);
 
     void validate() const;
 
     // fPts, fCoverages & fMovable should always have the same # of elements
     SkTDArray<SkPoint>  fPts;
     SkTDArray<SkScalar> fCoverages;
     // movable points are those that can be slid further along their bisector
     SkTDArray<bool>     fMovable;
 
     // The outward facing normals for the original polygon
     SkTDArray<SkVector> fNorms;
     // The inward facing bisector at each point in the original polygon. Only
     // needed for exterior ring creation and then handed off to the initial ring.
     SkTDArray<SkVector> fBisectors;
 
-    // Tracks whether a given point is interior to a curve. Such points are 
+    // Tracks whether a given point is interior to a curve. Such points are
     // assumed to have shallow curvature.
     SkTDArray<bool> fIsCurve;
 
     SkPoint::Side       fSide;    // winding of the original polygon
 
     // The triangulation of the points
     SkTDArray<int>      fIndices;
 
     Ring                fInitialRing;
 #if GR_AA_CONVEX_TESSELLATOR_VIZ
     // When visualizing save all the rings
     SkTDArray<Ring*>    fRings;
 #else
     Ring                fRings[2];
 #endif
     CandidateVerts      fCandidateVerts;
 
     // < 0 means filling rather than stroking
     SkScalar            fStrokeWidth;
 
     SkPaint::Join        fJoin;
 
     SkScalar            fMiterLimit;
 
     SkTDArray<SkPoint>  fPointBuffer;
 };
 
 
 #endif
-