Style bikeshed - remove extraneous whitespace

src/gpu/GrTessellator.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrTessellator.h"
 
 #include "GrPathUtils.h"
@@ skipping 1259 matching lines @@
             LOG("%g -> %g, lpoly %d, rpoly %d\n", e->fTop->fID, e->fBottom->fID,
                 e->fLeftPoly ? e->fLeftPoly->fID : -1, e->fRightPoly ? e->fRightPoly->fID : -1);
         }
 #endif
     }
     return polys;
 }
 
 // This is a driver function which calls stages 2-5 in turn.
 
-Poly* contours_to_polys(Vertex** contours, int contourCnt, const SkRect& pathBounds, 
+Poly* contours_to_polys(Vertex** contours, int contourCnt, const SkRect& pathBounds,
                         SkChunkAlloc& alloc) {
     Comparator c;
     if (pathBounds.width() > pathBounds.height()) {
         c.sweep_lt = sweep_lt_horiz;
         c.sweep_gt = sweep_gt_horiz;
     } else {
         c.sweep_lt = sweep_lt_vert;
         c.sweep_gt = sweep_gt_vert;
     }
 #if LOGGING_ENABLED
@@ skipping 18 matching lines @@
 #if LOGGING_ENABLED
     for (Vertex* v = vertices; v != nullptr; v = v->fNext) {
         static float gID = 0.0f;
         v->fID = gID++;
     }
 #endif
     simplify(vertices, c, alloc);
     return tessellate(vertices, alloc);
 }
 
-Poly* path_to_polys(const SkPath& path, SkScalar tolerance, const SkRect& clipBounds, 
+Poly* path_to_polys(const SkPath& path, SkScalar tolerance, const SkRect& clipBounds,
                     int contourCnt, SkChunkAlloc& alloc, bool* isLinear) {
     SkPath::FillType fillType = path.getFillType();
     if (SkPath::IsInverseFillType(fillType)) {
         contourCnt++;
     }
     SkAutoTDeleteArray<Vertex*> contours(new Vertex* [contourCnt]);
 
     path_to_contours(path, tolerance, clipBounds, contours.get(), alloc, isLinear);
     return contours_to_polys(contours.get(), contourCnt, path.getBounds(), alloc);
 }
 
-void get_contour_count_and_size_estimate(const SkPath& path, SkScalar tolerance, int* contourCnt, 
+void get_contour_count_and_size_estimate(const SkPath& path, SkScalar tolerance, int* contourCnt,
                                          int* sizeEstimate) {
     int maxPts = GrPathUtils::worstCasePointCount(path, contourCnt, tolerance);
     if (maxPts <= 0) {
         *contourCnt = 0;
         return;
     }
     if (maxPts > ((int)SK_MaxU16 + 1)) {
         SkDebugf("Path not rendered, too many verts (%d)\n", maxPts);
         *contourCnt = 0;
         return;
@@ skipping 14 matching lines @@
     }
     return count;
 }
 
 } // namespace
 
 namespace GrTessellator {
 
 // Stage 6: Triangulate the monotone polygons into a vertex buffer.
 
-int PathToTriangles(const SkPath& path, SkScalar tolerance, const SkRect& clipBounds, 
+int PathToTriangles(const SkPath& path, SkScalar tolerance, const SkRect& clipBounds,
                     VertexAllocator* vertexAllocator, bool* isLinear) {
     int contourCnt;
     int sizeEstimate;
     get_contour_count_and_size_estimate(path, tolerance, &contourCnt, &sizeEstimate);
     if (contourCnt <= 0) {
         *isLinear = true;
         return 0;
     }
     SkChunkAlloc alloc(sizeEstimate);
     Poly* polys = path_to_polys(path, tolerance, clipBounds, contourCnt, alloc, isLinear);
@@ skipping 14 matching lines @@
             end = poly->emit(end);
         }
     }
     int actualCount = static_cast<int>(end - verts);
     LOG("actual count: %d\n", actualCount);
     SkASSERT(actualCount <= count);
     vertexAllocator->unlock(actualCount);
     return actualCount;
 }
 
-int PathToVertices(const SkPath& path, SkScalar tolerance, const SkRect& clipBounds, 
+int PathToVertices(const SkPath& path, SkScalar tolerance, const SkRect& clipBounds,
                    GrTessellator::WindingVertex** verts) {
     int contourCnt;
     int sizeEstimate;
     get_contour_count_and_size_estimate(path, tolerance, &contourCnt, &sizeEstimate);
     if (contourCnt <= 0) {
         return 0;
     }
     SkChunkAlloc alloc(sizeEstimate);
     bool isLinear;
     Poly* polys = path_to_polys(path, tolerance, clipBounds, contourCnt, alloc, &isLinear);
@@ skipping 21 matching lines @@
         }
     }
     int actualCount = static_cast<int>(vertsEnd - *verts);
     SkASSERT(actualCount <= count);
     SkASSERT(pointsEnd - points == actualCount);
     delete[] points;
     return actualCount;
 }
 
 } // namespace