Style bikeshed - remove extraneous whitespace

tests/PathOpsConicIntersectionTest.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 "PathOpsTestCommon.h"
 #include "SkGeometry.h"
 #include "SkIntersections.h"
 #include "Test.h"
 
 /*
 manually compute the intersection of a pair of circles and see if the conic intersection matches
   given two circles
     construct a line connecting their centers
-    
+
  */
 
 static const SkDConic testSet[] = {
     {{{{306.588013,-227.983994}, {212.464996,-262.242004}, {95.5512009,58.9763985}}}, 0.707107008f},
     {{{{377.218994,-141.981003}, {40.578701,-201.339996}, {23.1854992,-102.697998}}}, 0.707107008f},
 
     {{{{5.1114602088928223, 628.77813720703125},
-        {10.834027290344238, 988.964111328125}, 
+        {10.834027290344238, 988.964111328125},
         {163.40835571289062, 988.964111328125}}}, 0.72944212f},
-    {{{{163.40835571289062, 988.964111328125}, 
-        {5, 988.964111328125}, 
+    {{{{163.40835571289062, 988.964111328125},
+        {5, 988.964111328125},
         {5, 614.7423095703125}}}, 0.707106769f},
 
     {{{{11.17222976684570312, -8.103978157043457031},
         {22.91432571411132812, -10.37866020202636719},
         {23.7764129638671875, -7.725424289703369141}}}, 1.00862849f},
     {{{{-1.545085430145263672, -4.755282402038574219},
         {22.23132705688476562, -12.48070907592773438},
         {23.7764129638671875, -7.725427150726318359}}}, 0.707106769f},
 
     {{{{-4,1}, {-4,5}, {0,5}}}, 0.707106769f},
@@ skipping 71 matching lines @@
     paint.setARGB(0x80, 0, 0, 0xFF);
     canvas.drawPath(path, paint);
     SkString filename("c:\\Users\\caryclark\\Documents\\");
     filename.appendf("%s.png", name);
     SkImageEncoder::EncodeFile(filename.c_str(), bitmap,
             SkImageEncoder::kPNG_Type, 100);
 }
 
 static void writeDPng(const SkDConic& dC, const char* name) {
     const int scale = 5;
-    SkDConic dConic = {{{ {dC.fPts[0].fX * scale, dC.fPts[0].fY * scale }, 
-        {dC.fPts[1].fX * scale, dC.fPts[1].fY * scale }, 
+    SkDConic dConic = {{{ {dC.fPts[0].fX * scale, dC.fPts[0].fY * scale },
+        {dC.fPts[1].fX * scale, dC.fPts[1].fY * scale },
         {dC.fPts[2].fX * scale, dC.fPts[2].fY * scale }}}, dC.fWeight };
     SkBitmap bitmap;
     SkDRect bounds;
     bounds.setBounds(dConic);
     bounds.fLeft -= 10;
     bounds.fTop -= 10;
     bounds.fRight += 10;
     bounds.fBottom += 10;
     bitmap.tryAllocPixels(SkImageInfo::MakeN32Premul(
           SkScalarRoundToInt(SkDoubleToScalar(bounds.width())),
@@ skipping 88 matching lines @@
 };
 
 const SkDConic frame6[] = {
 {{{{306.588013,-227.983994}, {212.464996,-262.242004}, {95.5512009,58.9763985}}}, 0.707107008f},
 {{{{377.218994,-141.981003}, {40.578701,-201.339996}, {23.1854992,-102.697998}}}, 0.707107008f},
 {{{{205.78973252799028, -158.12538713371103}, {190.33692178059735, -137.11320166154385}, {174.87004877564593, -111.2132534799228}}}, 0.858117759f},
 {{{{252.08225670812539, -156.90491625851064}, {219.70109133058406, -158.81912754088933}, {190.17095392508796, -158.38373974664466}}}, 0.858306944f},
 };
 
 const SkDConic* frames[] = {
-    frame0, frame1, frame2, frame3, frame4, frame5, frame6 
+    frame0, frame1, frame2, frame3, frame4, frame5, frame6
 };
 
 const int frameSizes[] = { (int) SK_ARRAY_COUNT(frame0), (int) SK_ARRAY_COUNT(frame1),
         (int) SK_ARRAY_COUNT(frame2), (int) SK_ARRAY_COUNT(frame3),
         (int) SK_ARRAY_COUNT(frame4), (int) SK_ARRAY_COUNT(frame5),
         (int) SK_ARRAY_COUNT(frame6),
 };
 
 static void writeFrames() {
     const int scale = 5;
 
     for (int index = 0; index < (int) SK_ARRAY_COUNT(frameSizes); ++index) {
         SkDRect bounds;
         bool boundsSet = false;
         int frameSize = frameSizes[index];
         for (int fIndex = 0; fIndex < frameSize; ++fIndex) {
             const SkDConic& dC = frames[index][fIndex];
-            SkDConic dConic = {{{ {dC.fPts[0].fX * scale, dC.fPts[0].fY * scale }, 
-                {dC.fPts[1].fX * scale, dC.fPts[1].fY * scale }, 
+            SkDConic dConic = {{{ {dC.fPts[0].fX * scale, dC.fPts[0].fY * scale },
+                {dC.fPts[1].fX * scale, dC.fPts[1].fY * scale },
                 {dC.fPts[2].fX * scale, dC.fPts[2].fY * scale }}}, dC.fWeight };
             SkDRect dBounds;
             dBounds.setBounds(dConic);
             if (!boundsSet) {
                 bounds = dBounds;
                 boundsSet = true;
             } else {
                 bounds.add((SkDPoint&) dBounds.fLeft);
                 bounds.add((SkDPoint&) dBounds.fRight);
             }
         }
         bounds.fLeft -= 10;
         bounds.fTop -= 10;
         bounds.fRight += 10;
         bounds.fBottom += 10;
         SkBitmap bitmap;
         bitmap.tryAllocPixels(SkImageInfo::MakeN32Premul(
               SkScalarRoundToInt(SkDoubleToScalar(bounds.width())),
               SkScalarRoundToInt(SkDoubleToScalar(bounds.height()))));
         SkCanvas canvas(bitmap);
         SkPaint paint;
         paint.setAntiAlias(true);
         paint.setStyle(SkPaint::kStroke_Style);
         canvas.translate(SkDoubleToScalar(-bounds.fLeft), SkDoubleToScalar(-bounds.fTop));
         canvas.drawColor(SK_ColorWHITE);
         for (int fIndex = 0; fIndex < frameSize; ++fIndex) {
             const SkDConic& dC = frames[index][fIndex];
-            SkDConic dConic = {{{ {dC.fPts[0].fX * scale, dC.fPts[0].fY * scale }, 
-                {dC.fPts[1].fX * scale, dC.fPts[1].fY * scale }, 
+            SkDConic dConic = {{{ {dC.fPts[0].fX * scale, dC.fPts[0].fY * scale },
+                {dC.fPts[1].fX * scale, dC.fPts[1].fY * scale },
                 {dC.fPts[2].fX * scale, dC.fPts[2].fY * scale }}}, dC.fWeight };
             SkPath path;
             path.moveTo(dConic.fPts[0].asSkPoint());
             path.conicTo(dConic.fPts[1].asSkPoint(), dConic.fPts[2].asSkPoint(), dConic.fWeight);
             if (fIndex < 2) {
                 paint.setARGB(0x80, 0xFF, 0, 0);
             } else {
                 paint.setARGB(0x80, 0, 0, 0xFF);
             }
             canvas.drawPath(path, paint);
@@ skipping 53 matching lines @@
     }
 }
 
 DEF_TEST(PathOpsConicIntersectionOneOff, reporter) {
     oneOff(reporter, 0, 1);
 }
 
 DEF_TEST(PathOpsConicIntersection, reporter) {
     oneOffTests(reporter);
 }