diff --git a/tests/AAClipTest.cpp b/tests/AAClipTest.cpp
index c5e82ba..1b060a7 100644
--- a/tests/AAClipTest.cpp
+++ b/tests/AAClipTest.cpp
@@ -272,7 +272,7 @@
             }
             REPORTER_ASSERT(reporter, nonEmptyAA == nonEmptyBW);
             REPORTER_ASSERT(reporter, clip2.getBounds() == rgn2.getBounds());
-            
+
             SkMask maskBW, maskAA;
             copyToMask(rgn2, &maskBW);
             clip2.copyToMask(&maskAA);
@@ -307,7 +307,7 @@
     for (int i = 0; i < 2; ++i) {
         SkAAClip clip;
         clip.setPath(path, NULL, 1 == i);
-        
+
         SkMask mask;
         clip.copyToMask(&mask);
         SkAutoMaskFreeImage freeM(mask.fImage);
@@ -350,7 +350,7 @@
     for (size_t i = 0; i < count; ++i) {
         SkRect r;
         r.set(ir);
-        
+
         SkRasterClip rc0(ir);
         SkRasterClip rc1(ir);
         SkRasterClip rc2(ir);
@@ -360,7 +360,7 @@
         rc1.op(r, SkRegion::kIntersect_Op, true);
         r.offset(-2*dx[i], 0);
         rc2.op(r, SkRegion::kIntersect_Op, true);
-    
+
         REPORTER_ASSERT(reporter, changed != (rc0 == rc1));
         REPORTER_ASSERT(reporter, changed != (rc0 == rc2));
     }
@@ -368,7 +368,7 @@
 
 static void test_nearly_integral(skiatest::Reporter* reporter) {
     // All of these should generate equivalent rasterclips
-    
+
     static const SkScalar gSafeX[] = {
         0, SK_Scalar1/1000, SK_Scalar1/100, SK_Scalar1/10,
     };
@@ -388,7 +388,7 @@
         SkRect r;
         r.fLeft = SkFloatToScalar(129.892181f);
         r.fTop = SkFloatToScalar(10.3999996f);
-        r.fRight = SkFloatToScalar(130.892181f); 
+        r.fRight = SkFloatToScalar(130.892181f);
         r.fBottom = SkFloatToScalar(20.3999996f);
         clip.setRect(r, true);
     }
diff --git a/tests/BlitRowTest.cpp b/tests/BlitRowTest.cpp
index b37b47e..fca4588 100644
--- a/tests/BlitRowTest.cpp
+++ b/tests/BlitRowTest.cpp
@@ -136,7 +136,7 @@
         SkBitmap dstBM;
         dstBM.setConfig(gDstConfig[i], W, 1);
         dstBM.allocPixels();
-        
+
         SkCanvas canvas(dstBM);
         for (size_t j = 0; j < SK_ARRAY_COUNT(gSrcRec); j++) {
             srcBM.eraseColor(gSrcRec[j].fSrc);
@@ -178,7 +178,7 @@
         SkShader* s = SkShader::CreateBitmapShader(bm, SkShader::kClamp_TileMode,
                                                    SkShader::kClamp_TileMode);
         paint->setShader(s)->unref();
-        
+
     }
 
     void draw(SkCanvas* canvas, SkPaint* paint) {
@@ -199,7 +199,7 @@
 static void test_diagonal(skiatest::Reporter* reporter) {
     static const int W = 64;
     static const int H = W;
-    
+
     static const SkBitmap::Config gDstConfig[] = {
         SkBitmap::kARGB_8888_Config,
         SkBitmap::kRGB_565_Config,
@@ -210,7 +210,7 @@
     static const SkColor gDstBG[] = { 0, 0xFFFFFFFF };
 
     SkPaint paint;
-    
+
     SkBitmap srcBM;
     srcBM.setConfig(SkBitmap::kARGB_8888_Config, W, H);
     srcBM.allocPixels();
@@ -226,7 +226,7 @@
         dstBM1.setConfig(gDstConfig[i], W, H);
         dstBM0.allocPixels();
         dstBM1.allocPixels();
-        
+
         SkCanvas canvas0(dstBM0);
         SkCanvas canvas1(dstBM1);
         SkColor bgColor;
@@ -236,7 +236,7 @@
 
             for (int c = 0; c <= 0xFF; c++) {
                 srcBM.eraseARGB(0xFF, c, c, c);
-                
+
                 for (int k = 0; k < 4; k++) {
                     bool dither = (k & 1) != 0;
                     uint8_t alpha = (k & 2) ? 0x80 : 0xFF;
diff --git a/tests/CanvasTest.cpp b/tests/CanvasTest.cpp
index 3ff6d4b..6063dd9 100644
--- a/tests/CanvasTest.cpp
+++ b/tests/CanvasTest.cpp
@@ -18,7 +18,7 @@
  *      The general pattern for creating a new test step is to write a test
  *      function of the form:
  *
- *          static void MyTestStepFunction(SkCanvas* canvas, 
+ *          static void MyTestStepFunction(SkCanvas* canvas,
  *                                         skiatest::Reporter* reporter,
  *                                         CanvasTestStep* testStep)
  *          {
@@ -79,7 +79,7 @@
 
 static void test_clipVisitor(skiatest::Reporter* reporter, SkCanvas* canvas) {
     SkISize size = canvas->getDeviceSize();
-    
+
     SkBitmap bm;
     bm.setConfig(SkBitmap::kARGB_8888_Config, size.width(), size.height());
     SkCanvas c(bm);
@@ -93,7 +93,7 @@
 static const int kWidth = 2;
 static const int kHeight = 2;
 // Maximum stream length for picture serialization
-static const size_t kMaxPictureBufferSize = 1024; 
+static const size_t kMaxPictureBufferSize = 1024;
 
 // Format strings that describe the test context.  The %s token is where
 // the name of the test step is inserted.  The context is required for
@@ -101,31 +101,31 @@
 // functions that are called multiple times in different contexts (test
 // cases and test steps).
 static const char* const kDefaultAssertMessageFormat = "%s";
-static const char* const kCanvasDrawAssertMessageFormat = 
+static const char* const kCanvasDrawAssertMessageFormat =
     "Drawing test step %s with SkCanvas";
-static const char* const kPictureDrawAssertMessageFormat = 
+static const char* const kPictureDrawAssertMessageFormat =
     "Drawing test step %s with SkPicture";
-static const char* const kPictureSecondDrawAssertMessageFormat = 
+static const char* const kPictureSecondDrawAssertMessageFormat =
     "Duplicate draw of test step %s with SkPicture";
-static const char* const kPictureReDrawAssertMessageFormat = 
+static const char* const kPictureReDrawAssertMessageFormat =
     "Playing back test step %s from an SkPicture to another SkPicture";
-static const char* const kDeferredDrawAssertMessageFormat = 
+static const char* const kDeferredDrawAssertMessageFormat =
     "Drawing test step %s with SkDeferredCanvas";
-static const char* const kProxyDrawAssertMessageFormat = 
+static const char* const kProxyDrawAssertMessageFormat =
     "Drawing test step %s with SkProxyCanvas";
-static const char* const kNWayDrawAssertMessageFormat = 
+static const char* const kNWayDrawAssertMessageFormat =
     "Drawing test step %s with SkNWayCanvas";
-static const char* const kRoundTripAssertMessageFormat = 
+static const char* const kRoundTripAssertMessageFormat =
     "test step %s, SkPicture consistency after round trip";
-static const char* const kPictureRecoringAssertMessageFormat = 
+static const char* const kPictureRecoringAssertMessageFormat =
     "test step %s, SkPicture state consistency after recording";
-static const char* const kPicturePlaybackAssertMessageFormat = 
+static const char* const kPicturePlaybackAssertMessageFormat =
     "test step %s, SkPicture state consistency in playback canvas";
-static const char* const kDeferredPreFlushAssertMessageFormat = 
+static const char* const kDeferredPreFlushAssertMessageFormat =
     "test step %s, SkDeferredCanvas state consistency before flush";
 static const char* const kDeferredPostFlushPlaybackAssertMessageFormat =
     "test step %s, SkDeferredCanvas playback canvas state consistency after flush";
-static const char* const kDeferredPostFlushAssertMessageFormat = 
+static const char* const kDeferredPostFlushAssertMessageFormat =
     "test step %s, SkDeferredCanvas state consistency after flush";
 static const char* const kPictureResourceReuseMessageFormat =
     "test step %s, SkPicture duplicate flattened object test";
@@ -180,7 +180,7 @@
 ///////////////////////////////////////////////////////////////////////////////
 // Constants used by test steps
 
-const SkRect kTestRect = 
+const SkRect kTestRect =
     SkRect::MakeXYWH(SkIntToScalar(0), SkIntToScalar(0),
                      SkIntToScalar(2), SkIntToScalar(1));
 static SkMatrix testMatrix() {
@@ -233,7 +233,7 @@
   { SkIntToScalar(9), SkIntToScalar(1) },
   { SkIntToScalar(10), SkIntToScalar(1) },
 };
-  
+
 
 ///////////////////////////////////////////////////////////////////////////////
 // Macros for defining test steps
@@ -265,7 +265,7 @@
 
 
 ///////////////////////////////////////////////////////////////////////////////
-// Basic test steps for most virtual methods in SkCanvas that draw or affect 
+// Basic test steps for most virtual methods in SkCanvas that draw or affect
 // the state of the canvas.
 
 SIMPLE_TEST_STEP_WITH_ASSERT(Translate,
@@ -323,9 +323,9 @@
 ///////////////////////////////////////////////////////////////////////////////
 // Complex test steps
 
-// Save/restore calls cannot be in isolated simple test steps because the test 
+// Save/restore calls cannot be in isolated simple test steps because the test
 // cases that use SkPicture require that save and restore calls be balanced.
-static void SaveMatrixStep(SkCanvas* canvas, 
+static void SaveMatrixStep(SkCanvas* canvas,
                            skiatest::Reporter* reporter,
                            CanvasTestStep* testStep) {
     int saveCount = canvas->getSaveCount();
@@ -333,16 +333,16 @@
     canvas->clipRegion(kTestRegion);
     canvas->translate(SkIntToScalar(1), SkIntToScalar(2));
     canvas->restore();
-    REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount, 
+    REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
         testStep->assertMessage());
-    REPORTER_ASSERT_MESSAGE(reporter, canvas->getTotalMatrix().isIdentity(), 
+    REPORTER_ASSERT_MESSAGE(reporter, canvas->getTotalMatrix().isIdentity(),
         testStep->assertMessage());
     REPORTER_ASSERT_MESSAGE(reporter, canvas->getTotalClip() == kTestRegion,
         testStep->assertMessage());
 }
 TEST_STEP(SaveMatrix, SaveMatrixStep);
 
-static void SaveClipStep(SkCanvas* canvas, 
+static void SaveClipStep(SkCanvas* canvas,
                          skiatest::Reporter* reporter,
                          CanvasTestStep* testStep) {
     int saveCount = canvas->getSaveCount();
@@ -350,16 +350,16 @@
     canvas->translate(SkIntToScalar(1), SkIntToScalar(2));
     canvas->clipRegion(kTestRegion);
     canvas->restore();
-    REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount, 
+    REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
         testStep->assertMessage());
-    REPORTER_ASSERT_MESSAGE(reporter, !canvas->getTotalMatrix().isIdentity(), 
+    REPORTER_ASSERT_MESSAGE(reporter, !canvas->getTotalMatrix().isIdentity(),
         testStep->assertMessage());
     REPORTER_ASSERT_MESSAGE(reporter, canvas->getTotalClip() != kTestRegion,
         testStep->assertMessage());
 }
 TEST_STEP(SaveClip, SaveClipStep);
 
-static void SaveMatrixClipStep(SkCanvas* canvas, 
+static void SaveMatrixClipStep(SkCanvas* canvas,
                                skiatest::Reporter* reporter,
                                CanvasTestStep* testStep) {
     int saveCount = canvas->getSaveCount();
@@ -367,53 +367,53 @@
     canvas->translate(SkIntToScalar(1), SkIntToScalar(2));
     canvas->clipRegion(kTestRegion);
     canvas->restore();
-    REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount, 
+    REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
         testStep->assertMessage());
-    REPORTER_ASSERT_MESSAGE(reporter, canvas->getTotalMatrix().isIdentity(), 
+    REPORTER_ASSERT_MESSAGE(reporter, canvas->getTotalMatrix().isIdentity(),
         testStep->assertMessage());
     REPORTER_ASSERT_MESSAGE(reporter, canvas->getTotalClip() != kTestRegion,
         testStep->assertMessage());
 }
 TEST_STEP(SaveMatrixClip, SaveMatrixClipStep);
 
-static void SaveLayerStep(SkCanvas* canvas, 
+static void SaveLayerStep(SkCanvas* canvas,
                           skiatest::Reporter* reporter,
                           CanvasTestStep* testStep) {
     int saveCount = canvas->getSaveCount();
     canvas->saveLayer(NULL, NULL);
     canvas->restore();
-    REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount, 
+    REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
         testStep->assertMessage());
 }
 TEST_STEP(SaveLayer, SaveLayerStep);
 
-static void BoundedSaveLayerStep(SkCanvas* canvas, 
+static void BoundedSaveLayerStep(SkCanvas* canvas,
                           skiatest::Reporter* reporter,
                           CanvasTestStep* testStep) {
     int saveCount = canvas->getSaveCount();
     canvas->saveLayer(&kTestRect, NULL);
     canvas->restore();
-    REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount, 
+    REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
         testStep->assertMessage());
 }
 TEST_STEP(BoundedSaveLayer, BoundedSaveLayerStep);
 
-static void PaintSaveLayerStep(SkCanvas* canvas, 
+static void PaintSaveLayerStep(SkCanvas* canvas,
                           skiatest::Reporter* reporter,
                           CanvasTestStep* testStep) {
     int saveCount = canvas->getSaveCount();
     canvas->saveLayer(NULL, &kTestPaint);
     canvas->restore();
-    REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount, 
+    REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
         testStep->assertMessage());
 }
 TEST_STEP(PaintSaveLayer, PaintSaveLayerStep);
 
-static void TwoClipOpsStep(SkCanvas* canvas, 
+static void TwoClipOpsStep(SkCanvas* canvas,
                            skiatest::Reporter* reporter,
                            CanvasTestStep* testStep) {
     // This test exercises a functionality in SkPicture that leads to the
-    // recording of restore offset placeholders.  This test will trigger an 
+    // recording of restore offset placeholders.  This test will trigger an
     // assertion at playback time if the placeholders are not properly
     // filled when the recording ends.
     canvas->clipRect(kTestRect);
@@ -423,7 +423,7 @@
 
 // exercise fix for http://code.google.com/p/skia/issues/detail?id=560
 // ('SkPathStroker::lineTo() fails for line with length SK_ScalarNearlyZero')
-static void DrawNearlyZeroLengthPathTestStep(SkCanvas* canvas, 
+static void DrawNearlyZeroLengthPathTestStep(SkCanvas* canvas,
                                              skiatest::Reporter* reporter,
                                              CanvasTestStep* testStep) {
     SkPaint paint;
@@ -444,7 +444,7 @@
 }
 TEST_STEP(DrawNearlyZeroLengthPath, DrawNearlyZeroLengthPathTestStep);
 
-static void DrawVerticesShaderTestStep(SkCanvas* canvas, 
+static void DrawVerticesShaderTestStep(SkCanvas* canvas,
                                        skiatest::Reporter* reporter,
                                        CanvasTestStep* testStep) {
     SkPoint pts[4];
@@ -461,7 +461,7 @@
 }
 TEST_STEP(DrawVerticesShader, DrawVerticesShaderTestStep);
 
-static void DrawPictureTestStep(SkCanvas* canvas, 
+static void DrawPictureTestStep(SkCanvas* canvas,
                                 skiatest::Reporter* reporter,
                                 CanvasTestStep* testStep) {
     SkPicture* testPicture = SkNEW_ARGS(SkPicture, ());
@@ -474,7 +474,7 @@
 }
 TEST_STEP(DrawPicture, DrawPictureTestStep);
 
-static void SaveRestoreTestStep(SkCanvas* canvas, 
+static void SaveRestoreTestStep(SkCanvas* canvas,
                                 skiatest::Reporter* reporter,
                                 CanvasTestStep* testStep) {
     int baseSaveCount = canvas->getSaveCount();
@@ -497,7 +497,7 @@
 }
 TEST_STEP(SaveRestore, SaveRestoreTestStep);
 
-static void DrawLayerTestStep(SkCanvas* canvas, 
+static void DrawLayerTestStep(SkCanvas* canvas,
                               skiatest::Reporter* reporter,
                               CanvasTestStep* testStep) {
     REPORTER_ASSERT_MESSAGE(reporter, !canvas->isDrawingToLayer(),
@@ -506,7 +506,7 @@
     REPORTER_ASSERT_MESSAGE(reporter, !canvas->isDrawingToLayer(),
         testStep->assertMessage());
     canvas->restore();
-    
+
     const SkRect* bounds = NULL;    // null means include entire bounds
     const SkPaint* paint = NULL;
 
@@ -575,7 +575,7 @@
     NestedSaveRestoreWithFlushTestStep);
 
 static void AssertCanvasStatesEqual(skiatest::Reporter* reporter,
-                                    const SkCanvas* canvas1, 
+                                    const SkCanvas* canvas1,
                                     const SkCanvas* canvas2,
                                     CanvasTestStep* testStep) {
     REPORTER_ASSERT_MESSAGE(reporter, canvas1->getDeviceSize() ==
@@ -611,7 +611,7 @@
         canvas2->getTotalClip(), testStep->assertMessage());
 
     // The following test code is commented out because the test fails when
-    // the canvas is an SkPictureRecord or SkDeferredCanvas 
+    // the canvas is an SkPictureRecord or SkDeferredCanvas
     // Issue: http://code.google.com/p/skia/issues/detail?id=498
     // Also, creating a LayerIter on an SkProxyCanvas crashes
     // Issue: http://code.google.com/p/skia/issues/detail?id=499
@@ -699,12 +699,12 @@
             }
         }
         */
-    
+
     }
 
 public:
 
-    static void TestPictureFlattenedObjectReuse(skiatest::Reporter* reporter, 
+    static void TestPictureFlattenedObjectReuse(skiatest::Reporter* reporter,
                                                 CanvasTestStep* testStep,
                                                 uint32_t recordFlags) {
         // Verify that when a test step is executed twice, no extra resources
@@ -753,7 +753,7 @@
         deferredCanvas.flush();
         testStep->setAssertMessageFormat(
             kDeferredPostFlushPlaybackAssertMessageFormat);
-        AssertCanvasStatesEqual(reporter, 
+        AssertCanvasStatesEqual(reporter,
             deferredCanvas.immediateCanvas(),
             &referenceCanvas, testStep);
 
@@ -835,7 +835,7 @@
  * that the all canvas derivatives report the same state as an SkCanvas
  * after having executed the test step.
  */
-static void TestOverrideStateConsistency(skiatest::Reporter* reporter, 
+static void TestOverrideStateConsistency(skiatest::Reporter* reporter,
                                          CanvasTestStep* testStep) {
     SkBitmap referenceStore;
     createBitmap(&referenceStore, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
@@ -862,7 +862,7 @@
     if (false) { // avoid bit rot, suppress warning
         TestNWayCanvasStateConsistency(reporter, testStep, referenceCanvas);
     }
-    
+
     if (false) { // avoid bit rot, suppress warning
         test_clipVisitor(reporter, &referenceCanvas);
     }
diff --git a/tests/ClampRangeTest.cpp b/tests/ClampRangeTest.cpp
index dd13bf4..fa3804e 100644
--- a/tests/ClampRangeTest.cpp
+++ b/tests/ClampRangeTest.cpp
@@ -96,7 +96,7 @@
     test_range(0xFFFF, 0, 20);
     test_range(-ff(2), 0, 20);
     test_range( ff(2), 0, 20);
-    
+
     test_range(-10, 1, 20);
     test_range(10, -1, 20);
     test_range(-10, 3, 20);
@@ -108,7 +108,7 @@
     test_range(ff(1)/2, ff(-16384), 100);
 
     SkRandom rand;
-    
+
     // test non-overflow cases
     for (int i = 0; i < 1000000; i++) {
         SkFixed fx = rand.nextS() >> 1;
@@ -117,7 +117,7 @@
         SkFixed dx = (sx - fx) / count;
         test_range(fx, dx, count);
     }
-    
+
     // test overflow cases
     for (int i = 0; i < 100000; i++) {
         SkFixed fx = rand.nextS();
diff --git a/tests/ClipCacheTest.cpp b/tests/ClipCacheTest.cpp
index b0be2f1..795e861 100644
--- a/tests/ClipCacheTest.cpp
+++ b/tests/ClipCacheTest.cpp
@@ -60,7 +60,7 @@
     GrAutoUnref au(texture);
 
     SkIRect intScreen = SkIRect::MakeWH(kXSize, kYSize);
-    SkRect screen = SkRect::MakeWH(SkIntToScalar(kXSize), 
+    SkRect screen = SkRect::MakeWH(SkIntToScalar(kXSize),
                                    SkIntToScalar(kYSize));
     SkRect clipRect(screen);
     clipRect.outset(10, 10);
@@ -73,8 +73,8 @@
     bool isIntersectionOfRects = true;
     SkRect devStackBounds;
 
-    stack.getConservativeBounds(0, 0, kXSize, kYSize, 
-                                &devStackBounds, 
+    stack.getConservativeBounds(0, 0, kXSize, kYSize,
+                                &devStackBounds,
                                 &isIntersectionOfRects);
 
     // make sure that the SkClipStack is behaving itself
@@ -119,7 +119,7 @@
 static void test_cache(skiatest::Reporter* reporter, GrContext* context) {
 
     if (false) { // avoid bit rot, suppress warning
-        createTexture(context); 
+        createTexture(context);
     }
     GrClipMaskCache cache;
 
diff --git a/tests/ClipCubicTest.cpp b/tests/ClipCubicTest.cpp
index 1c9199f..2e913a7 100644
--- a/tests/ClipCubicTest.cpp
+++ b/tests/ClipCubicTest.cpp
@@ -21,7 +21,7 @@
     bm.allocPixels();
     SkCanvas canvas(bm);
     canvas.clear(0);
-    
+
     SkPath path;
     path.moveTo(0, 0); path.lineTo(1, 0); path.lineTo(33, 1);
     SkPaint paint;
diff --git a/tests/ClipStackTest.cpp b/tests/ClipStackTest.cpp
index 1def9b4..19e28ad 100644
--- a/tests/ClipStackTest.cpp
+++ b/tests/ClipStackTest.cpp
@@ -269,7 +269,7 @@
                                         &isIntersectionOfRects);
 
             if (useRects) {
-                REPORTER_ASSERT(reporter, isIntersectionOfRects == 
+                REPORTER_ASSERT(reporter, isIntersectionOfRects ==
                         (gOps[op] == SkRegion::kIntersect_Op));
             } else {
                 REPORTER_ASSERT(reporter, !isIntersectionOfRects);
diff --git a/tests/ClipperTest.cpp b/tests/ClipperTest.cpp
index 724ff56..b914374 100644
--- a/tests/ClipperTest.cpp
+++ b/tests/ClipperTest.cpp
@@ -16,7 +16,7 @@
     bm.setConfig(SkBitmap::kARGB_8888_Config, 4, 4);
     bm.allocPixels();
     bm.eraseColor(SK_ColorWHITE);
-    
+
     SkPaint paint;
     paint.setAntiAlias(true);
 
@@ -24,7 +24,7 @@
     canvas.clipRect(SkRect::MakeWH(SkIntToScalar(4), SkIntToScalar(2)));
     canvas.drawLine(SkFloatToScalar(1.5f), SkFloatToScalar(1.5f),
                     SkFloatToScalar(3.5f), SkFloatToScalar(3.5f), paint);
-    
+
     /**
      *  We had a bug where we misinterpreted the bottom of the clip, and
      *  would draw another pixel (to the right in this case) on the same
@@ -50,7 +50,7 @@
 
 static void test_edgeclipper(skiatest::Reporter* reporter) {
     SkEdgeClipper clipper;
-    
+
     const SkPoint pts[] = {
         { SkFloatToScalar(3.0995476e+010f),  SkFloatToScalar(42.929779f) },
         { SkFloatToScalar(-3.0995163e+010f), SkFloatToScalar(51.050385f) },
@@ -97,7 +97,7 @@
         }
         REPORTER_ASSERT(reporter, !valid);
     }
-    
+
     static const SkPoint gFull[] = {
         // diagonals, chords
         { L, T }, { R, B },
@@ -121,7 +121,7 @@
         }
         REPORTER_ASSERT(reporter, valid && !memcmp(&gFull[i], dst, sizeof(dst)));
     }
-    
+
     static const SkPoint gPartial[] = {
         { L - 10, CY }, { CX, CY }, { L, CY }, { CX, CY },
         { CX, T - 10 }, { CX, CY }, { CX, T }, { CX, CY },
@@ -141,7 +141,7 @@
         REPORTER_ASSERT(reporter, valid &&
                                   !memcmp(&gPartial[i+2], dst, sizeof(dst)));
     }
-    
+
 }
 
 static void TestClipper(skiatest::Reporter* reporter) {
diff --git a/tests/ColorFilterTest.cpp b/tests/ColorFilterTest.cpp
index 7cfb467..4016f21 100644
--- a/tests/ColorFilterTest.cpp
+++ b/tests/ColorFilterTest.cpp
@@ -72,13 +72,13 @@
             if (m != expectedMode) {
                 expectedMode = SkXfermode::kSrc_Mode;
             }
-        } 
+        }
 
 //        SkDebugf("--- got [%d %x] expected [%d %x]\n", m, c, expectedMode, expectedColor);
 
         REPORTER_ASSERT(reporter, c == expectedColor);
         REPORTER_ASSERT(reporter, m == expectedMode);
-        
+
         {
             SkColorFilter* cf2 = reincarnate(cf);
             SkAutoUnref aur2(cf2);
diff --git a/tests/DataRefTest.cpp b/tests/DataRefTest.cpp
index 8505fa9..d6ba775 100644
--- a/tests/DataRefTest.cpp
+++ b/tests/DataRefTest.cpp
@@ -14,7 +14,7 @@
 public:
     SkTUnref(T* ref) : fRef(ref) {}
     ~SkTUnref() { fRef->unref(); }
-    
+
     operator T*() { return fRef; }
     operator const T*() { return fRef; }
 
@@ -42,7 +42,7 @@
 static void test_datasets_equal(skiatest::Reporter* reporter,
                                 const SkDataSet& ds0, const SkDataSet& ds1) {
     REPORTER_ASSERT(reporter, ds0.count() == ds1.count());
-    
+
     test_dataset_subset(reporter, ds0, ds1);
     test_dataset_subset(reporter, ds1, ds0);
 }
@@ -50,7 +50,7 @@
 static void test_dataset(skiatest::Reporter* reporter, const SkDataSet& ds,
                          int count) {
     REPORTER_ASSERT(reporter, ds.count() == count);
-    
+
     SkDataSet::Iter iter(ds);
     int index = 0;
     for (; !iter.done(); iter.next()) {
@@ -66,14 +66,14 @@
     SkMemoryStream istream;
     istream.setData(ostream.copyToData())->unref();
     SkDataSet copy(&istream);
-    
+
     test_datasets_equal(reporter, ds, copy);
 }
 
 static void test_dataset(skiatest::Reporter* reporter) {
     SkDataSet set0(NULL, 0);
     SkDataSet set1("hello", SkTUnref<SkData>(SkData::NewWithCString("world")));
-    
+
     const SkDataSet::Pair pairs[] = {
         { "one", SkData::NewWithCString("1") },
         { "two", SkData::NewWithCString("2") },
@@ -133,7 +133,7 @@
     assert_len(reporter, r1, strlen(str));
     assert_len(reporter, r2, N * sizeof(int));
     assert_len(reporter, r3, 6);
-    
+
     assert_data(reporter, r1, str, strlen(str));
     assert_data(reporter, r3, "people", 6);
 
@@ -143,7 +143,7 @@
     tmp = SkData::NewSubset(r1, 0, 0);
     assert_len(reporter, tmp, 0);
     tmp->unref();
-    
+
     test_cstring(reporter);
     test_dataset(reporter);
 }
diff --git a/tests/DeferredCanvasTest.cpp b/tests/DeferredCanvasTest.cpp
index 8f72603..5eda568 100644
--- a/tests/DeferredCanvasTest.cpp
+++ b/tests/DeferredCanvasTest.cpp
@@ -90,7 +90,7 @@
     canvas.clipRect(partialRect, SkRegion::kIntersect_Op, false);
     canvas.clear(0x00000000);
     canvas.restore();
-    REPORTER_ASSERT(reporter, canvas.isFreshFrame());    
+    REPORTER_ASSERT(reporter, canvas.isFreshFrame());
 
     // Verify that full frame rects with different forms of opaque paint
     // trigger frames to be marked as fresh
@@ -107,11 +107,11 @@
         SkBitmap bmp;
         create(&bmp, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
         bmp.setIsOpaque(true);
-        SkShader* shader = SkShader::CreateBitmapShader(bmp, 
+        SkShader* shader = SkShader::CreateBitmapShader(bmp,
             SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
         paint.setShader(shader)->unref();
         canvas.drawRect(fullRect, paint);
-        REPORTER_ASSERT(reporter, canvas.isFreshFrame());        
+        REPORTER_ASSERT(reporter, canvas.isFreshFrame());
     }
 
     // Verify that full frame rects with different forms of non-opaque paint
@@ -129,11 +129,11 @@
         SkBitmap bmp;
         create(&bmp, SkBitmap::kARGB_8888_Config, 0xFFFFFFFF);
         bmp.setIsOpaque(false);
-        SkShader* shader = SkShader::CreateBitmapShader(bmp, 
+        SkShader* shader = SkShader::CreateBitmapShader(bmp,
             SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
         paint.setShader(shader)->unref();
         canvas.drawRect(fullRect, paint);
-        REPORTER_ASSERT(reporter, !canvas.isFreshFrame());        
+        REPORTER_ASSERT(reporter, !canvas.isFreshFrame());
     }
 
     // Verify that incomplete coverage does not trigger a fresh frame
@@ -165,7 +165,7 @@
         canvas.drawRect(fullRect, paint);
         REPORTER_ASSERT(reporter, !canvas.isFreshFrame());
     }
-    
+
     // Verify kSrcMode triggers a fresh frame even with transparent color
     {
         SkPaint paint;
@@ -227,7 +227,7 @@
         fStorageAllocatedChangedCount++;
     }
     virtual void flushedDrawCommands() SK_OVERRIDE {
-        fFlushedDrawCommandsCount++;        
+        fFlushedDrawCommandsCount++;
     }
 
     int fPrepareForDrawCount;
@@ -258,7 +258,7 @@
     REPORTER_ASSERT(reporter, 1 == notificationCounter.fStorageAllocatedChangedCount);
     // stored bitmap + drawBitmap command
     REPORTER_ASSERT(reporter, canvas.storageAllocatedForRecording() > bitmapSize);
-    
+
     // verify that nothing can be freed at this point
     REPORTER_ASSERT(reporter, 0 == canvas.freeMemoryIfPossible(~0));
 
@@ -292,7 +292,7 @@
     REPORTER_ASSERT(reporter,  bytesFreed >= bitmapSize);
     REPORTER_ASSERT(reporter,  bytesFreed < 2*bitmapSize);
 
-    // Verifiy that partial purge works, image zero is in cache but not reffed by 
+    // Verifiy that partial purge works, image zero is in cache but not reffed by
     // a pending draw, while image 1 is locked-in.
     canvas.freeMemoryIfPossible(~0);
     REPORTER_ASSERT(reporter, 2 == notificationCounter.fFlushedDrawCommandsCount);
diff --git a/tests/DequeTest.cpp b/tests/DequeTest.cpp
index 00162bb..62e8e4d 100644
--- a/tests/DequeTest.cpp
+++ b/tests/DequeTest.cpp
@@ -80,10 +80,10 @@
     }
 };
 
-static void assert_blocks(skiatest::Reporter* reporter, 
+static void assert_blocks(skiatest::Reporter* reporter,
                           const SkDeque& deq,
                           int allocCount) {
-    DequeUnitTestHelper helper(deq);                                
+    DequeUnitTestHelper helper(deq);
 
     if (0 == deq.count()) {
         REPORTER_ASSERT(reporter, 1 == helper.fNumBlocksAllocated);
@@ -91,8 +91,8 @@
         int expected = (deq.count() + allocCount - 1) / allocCount;
         // A block isn't freed in the deque when it first becomes empty so
         // sometimes an extra block lingers around
-        REPORTER_ASSERT(reporter, 
-            expected == helper.fNumBlocksAllocated || 
+        REPORTER_ASSERT(reporter,
+            expected == helper.fNumBlocksAllocated ||
             expected+1 == helper.fNumBlocksAllocated);
     }
 }
diff --git a/tests/DrawBitmapRectTest.cpp b/tests/DrawBitmapRectTest.cpp
index e11acbc..0147a71 100644
--- a/tests/DrawBitmapRectTest.cpp
+++ b/tests/DrawBitmapRectTest.cpp
@@ -37,41 +37,41 @@
     dev.setConfig(SkBitmap::kARGB_8888_Config, 0x56F, 0x4f6);
     dev.allocPixels();
     dev.eraseColor(0);  // necessary, so we know if we draw to it
-    
+
     SkMatrix matrix;
-    
+
     SkCanvas c(dev);
-    matrix.setAll(SkFloatToScalar(-119.34097f), 
-                  SkFloatToScalar(-43.436558f), 
+    matrix.setAll(SkFloatToScalar(-119.34097f),
+                  SkFloatToScalar(-43.436558f),
                   SkFloatToScalar(93489.945f),
-                  SkFloatToScalar(43.436558f), 
-                  SkFloatToScalar(-119.34097f), 
+                  SkFloatToScalar(43.436558f),
+                  SkFloatToScalar(-119.34097f),
                   SkFloatToScalar(123.98426f),
                   0, 0, SK_Scalar1);
     c.concat(matrix);
-    
+
     SkBitmap bm;
     bm.setConfig(SkBitmap::kARGB_8888_Config, width, height);
     bm.allocPixels();
     bm.eraseColor(SK_ColorRED);
-    
+
     SkShader* s = SkShader::CreateBitmapShader(bm, SkShader::kRepeat_TileMode,
                                                SkShader::kRepeat_TileMode);
-    matrix.setAll(SkFloatToScalar(0.0078740157f), 
-                  0, 
+    matrix.setAll(SkFloatToScalar(0.0078740157f),
+                  0,
                   SkIntToScalar(249),
-                  0, 
-                  SkFloatToScalar(0.0078740157f), 
+                  0,
+                  SkFloatToScalar(0.0078740157f),
                   SkIntToScalar(239),
                   0, 0, SK_Scalar1);
     s->setLocalMatrix(matrix);
-    
+
     SkPaint paint;
     paint.setShader(s)->unref();
-    
+
     SkRect r = SkRect::MakeXYWH(681, 239, 695, 253);
     c.drawRect(r, paint);
-    
+
     assert_ifDrawnTo(reporter, dev, shouldBeDrawn);
 }
 #endif
@@ -106,7 +106,7 @@
         { 0x7f, 0xFFFF,    true },   // should draw, test max height
         { 0xFFFF, 0xFFFF, false },   // allocation fails (too much RAM)
     };
-    
+
     for (size_t i = 0; i < SK_ARRAY_COUNT(gTests); ++i) {
         test_wacky_bitmapshader(reporter,
                                 gTests[i].fWidth, gTests[i].fHeight,
@@ -127,11 +127,11 @@
     SkPath path;
     path.moveTo(0, 0);
     path.lineTo(10, SK_ScalarNaN);
-    
+
     SkPaint paint;
     paint.setAntiAlias(true);
     paint.setStyle(SkPaint::kStroke_Style);
-    
+
     // before our fix to SkScan_Antihair.cpp to check for integral NaN (0x800...)
     // this would trigger an assert/crash.
     //
diff --git a/tests/DrawPathTest.cpp b/tests/DrawPathTest.cpp
index 8b787bb..55e3164 100644
--- a/tests/DrawPathTest.cpp
+++ b/tests/DrawPathTest.cpp
@@ -64,13 +64,13 @@
         0x419727af, 0x43011f0c, 0x41972663, 0x43011f27,
         0x419728fc, 0x43011ed4, 0x4194064b, 0x43012197
     };
-    
+
     SkPath path;
     moveToH(&path, &data[0]);
     cubicToH(&path, &data[2]);
-    
+
     SkAutoTUnref<SkCanvas> canvas(new_canvas(640, 480));
-    
+
     SkPaint paint;
     paint.setAntiAlias(true);
     canvas->drawPath(path, paint);
@@ -84,7 +84,7 @@
     bm.setConfig(SkBitmap::kARGB_8888_Config, 2700, 30*1024);
     bm.allocPixels();
     SkCanvas canvas(bm);
-    
+
     SkPath path;
     path.moveTo(2762, 20);
     path.quadTo(11, 21702, 10, 21706);
@@ -100,7 +100,7 @@
 //
 static void test_inversepathwithclip(skiatest::Reporter* reporter) {
     SkPath path;
-    
+
     path.moveTo(0, SkIntToScalar(20));
     path.quadTo(SkIntToScalar(10), SkIntToScalar(10),
                 SkIntToScalar(20), SkIntToScalar(20));
@@ -118,7 +118,7 @@
     canvas.get()->drawPath(path, paint);
 
     canvas.get()->restore();
-    
+
     // Now do the test again, with the path flipped, so we only draw in the
     // top half of our bounds, and have the clip intersect our bounds at the
     // bottom.
@@ -145,7 +145,7 @@
     SkPath path;
     path.moveTo(64, 3);
     path.quadTo(-329936, -100000000, 1153, 330003);
-    
+
     SkPaint paint;
     paint.setAntiAlias(true);
 
@@ -194,10 +194,10 @@
     SkPath path;
     path.moveTo(64, 3);
     path.cubicTo(-329936, -100000000, -329936, 100000000, 1153, 330003);
-    
+
     SkPaint paint;
     paint.setAntiAlias(true);
-    
+
     SkAutoTUnref<SkCanvas> canvas(new_canvas(640, 480));
     canvas.get()->drawPath(path, paint);
 #endif
@@ -211,7 +211,7 @@
     const int H = 400;
     SkAutoTUnref<SkCanvas> canvas(new_canvas(33000, 10));
     canvas.get()->clear(0);
-    
+
     SkPaint paint;
     paint.setAntiAlias(true);
     SkPath path;
diff --git a/tests/DrawTextTest.cpp b/tests/DrawTextTest.cpp
index c5fa326..4f3eb82 100644
--- a/tests/DrawTextTest.cpp
+++ b/tests/DrawTextTest.cpp
@@ -67,7 +67,7 @@
     SkPaint paint;
     paint.setColor(SK_ColorGRAY);
     paint.setTextSize(SkIntToScalar(20));
-    
+
     SkIRect drawTextRect = SkIRect::MakeWH(64, 64);
     SkBitmap drawTextBitmap;
     create(&drawTextBitmap, drawTextRect, SkBitmap::kARGB_8888_Config);
diff --git a/tests/FillPathTest.cpp b/tests/FillPathTest.cpp
index 22ceb19..0ddf4e2 100644
--- a/tests/FillPathTest.cpp
+++ b/tests/FillPathTest.cpp
@@ -28,7 +28,7 @@
 }
 
 // http://code.google.com/p/skia/issues/detail?id=87
-// Lines which is not clipped by boundary based clipping, 
+// Lines which is not clipped by boundary based clipping,
 // but skipped after tessellation, should be cleared by the blitter.
 static void TestFillPathInverse(skiatest::Reporter* reporter) {
   FakeBlitter blitter;
diff --git a/tests/FlateTest.cpp b/tests/FlateTest.cpp
index 446e412..879973f 100644
--- a/tests/FlateTest.cpp
+++ b/tests/FlateTest.cpp
@@ -74,13 +74,13 @@
         inputSize = testStream->read(NULL, SkZeroSizeMemStream::kGetSizeKey);
     REPORTER_ASSERT(reporter, data1->size() == inputSize);
     REPORTER_ASSERT(reporter, memcmp(testStream->getMemoryBase(),
-                                     data1->data(), 
+                                     data1->data(),
                                      data1->size()) == 0);
 
     // Check that the uncompressed data matches the source data.
     SkAutoDataUnref data2(uncompressed.copyToData());
     REPORTER_ASSERT(reporter, testData.getLength() == uncompressed.getOffset());
-    REPORTER_ASSERT(reporter, memcmp(testData.getMemoryBase(), 
+    REPORTER_ASSERT(reporter, memcmp(testData.getMemoryBase(),
                                      data2->data(),
                                      testData.getLength()) == 0);
 }
diff --git a/tests/FontHostStreamTest.cpp b/tests/FontHostStreamTest.cpp
index b1c49f8..eb301e3 100644
--- a/tests/FontHostStreamTest.cpp
+++ b/tests/FontHostStreamTest.cpp
@@ -71,7 +71,7 @@
         SkPaint paint;
         paint.setColor(SK_ColorGRAY);
         paint.setTextSize(SkIntToScalar(30));
-    
+
         paint.setTypeface(SkTypeface::CreateFromName("Georgia", SkTypeface::kNormal))->unref();
 
         SkIRect origRect = SkIRect::MakeWH(64, 64);
diff --git a/tests/FontHostTest.cpp b/tests/FontHostTest.cpp
index ab0d58e..879fdd0 100644
--- a/tests/FontHostTest.cpp
+++ b/tests/FontHostTest.cpp
@@ -73,7 +73,7 @@
                 REPORTER_ASSERT(reporter, gKnownTableSizes[j].fSize == size);
             }
         }
-        
+
         // do we get the same size from GetTableData and GetTableSize
         {
             SkAutoMalloc data(size);
diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp
index 888da2d..e14198c 100644
--- a/tests/GLProgramsTest.cpp
+++ b/tests/GLProgramsTest.cpp
@@ -74,7 +74,7 @@
     dummyDesc.fHeight = 22;
     SkAutoTUnref<GrTexture> dummyTexture2(this->createTexture(dummyDesc, NULL, 0));
 
-    // GrGLSLGeneration glslGeneration = 
+    // GrGLSLGeneration glslGeneration =
             GrGetGLSLGeneration(this->glBinding(), this->glInterface());
     static const int STAGE_OPTS[] = {
         0,
@@ -199,7 +199,7 @@
 #include "TestClassDef.h"
 DEFINE_GPUTESTCLASS("GLPrograms", GLProgramsTestClass, GLProgramsTest)
 
-// This is evil evil evil. The linker may throw away whole translation units as dead code if it 
+// This is evil evil evil. The linker may throw away whole translation units as dead code if it
 // thinks none of the functions are called. It will do this even if there are static initilializers
 // in the unit that could pass pointers to functions from the unit out to other translation units!
 // We force some of the effects that would otherwise be discarded to link here.
diff --git a/tests/GeometryTest.cpp b/tests/GeometryTest.cpp
index 12cc816..69d980a 100644
--- a/tests/GeometryTest.cpp
+++ b/tests/GeometryTest.cpp
@@ -15,7 +15,7 @@
 static void testChopCubic(skiatest::Reporter* reporter) {
     /*
         Inspired by this test, which used to assert that the tValues had dups
-     
+
         <path stroke="#202020" d="M0,0 C0,0 1,1 2190,5130 C2190,5070 2220,5010 2205,4980" />
      */
     const SkPoint src[] = {
@@ -57,7 +57,7 @@
     for (int i = 0; i < 4; ++i) {
         REPORTER_ASSERT(reporter, nearly_equal(cubic[i], dst[i]));
     }
-    
+
     testChopCubic(reporter);
 }
 
diff --git a/tests/GradientTest.cpp b/tests/GradientTest.cpp
index 36103c1..007caa3 100644
--- a/tests/GradientTest.cpp
+++ b/tests/GradientTest.cpp
@@ -62,7 +62,7 @@
                                                             rec.fPos,
                                                             rec.fColorCount,
                                                             rec.fTileMode));
-    
+
     SkShader::GradientInfo info;
     rec.gradCheck(reporter, s, &info, SkShader::kLinear_GradientType);
     REPORTER_ASSERT(reporter, !memcmp(info.fPoint, rec.fPoint, 2 * sizeof(SkPoint)));
@@ -75,7 +75,7 @@
                                                             rec.fPos,
                                                             rec.fColorCount,
                                                             rec.fTileMode));
-    
+
     SkShader::GradientInfo info;
     rec.gradCheck(reporter, s, &info, SkShader::kRadial_GradientType);
     REPORTER_ASSERT(reporter, info.fPoint[0] == rec.fPoint[0]);
@@ -91,7 +91,7 @@
                                                             rec.fPos,
                                                             rec.fColorCount,
                                                             rec.fTileMode));
-    
+
     SkShader::GradientInfo info;
     rec.gradCheck(reporter, s, &info, SkShader::kRadial2_GradientType);
     REPORTER_ASSERT(reporter, !memcmp(info.fPoint, rec.fPoint, 2 * sizeof(SkPoint)));
@@ -104,7 +104,7 @@
                                                            rec.fColors,
                                                            rec.fPos,
                                                            rec.fColorCount));
-    
+
     SkShader::GradientInfo info;
     rec.gradCheck(reporter, s, &info, SkShader::kSweep_GradientType);
     REPORTER_ASSERT(reporter, info.fPoint[0] == rec.fPoint[0]);
@@ -119,7 +119,7 @@
                                                              rec.fPos,
                                                              rec.fColorCount,
                                                              rec.fTileMode));
-    
+
     SkShader::GradientInfo info;
     rec.gradCheck(reporter, s, &info, SkShader::kConical_GradientType);
     REPORTER_ASSERT(reporter, !memcmp(info.fPoint, rec.fPoint, 2 * sizeof(SkPoint)));
@@ -154,7 +154,7 @@
         sweep_gradproc,
         conical_gradproc,
     };
-    
+
     for (size_t i = 0; i < SK_ARRAY_COUNT(gProcs); ++i) {
         gProcs[i](reporter, rec);
     }
diff --git a/tests/MathTest.cpp b/tests/MathTest.cpp
index 6f945dd..fb2adc1 100644
--- a/tests/MathTest.cpp
+++ b/tests/MathTest.cpp
@@ -39,7 +39,7 @@
     static const float gVals[] = {
         0, 1, 1.1f, 1.01f, 1.001f, 1.0001f, 1.00001f, 1.000001f, 1.0000001f
     };
-    
+
     for (size_t i = 0; i < SK_ARRAY_COUNT(gVals); ++i) {
         test_floor_value(reporter, gVals[i]);
 //        test_floor_value(reporter, -gVals[i]);
@@ -305,7 +305,7 @@
     REPORTER_ASSERT(reporter, !SkScalarIsNaN(big));
     REPORTER_ASSERT(reporter, !SkScalarIsNaN(-big));
     REPORTER_ASSERT(reporter, !SkScalarIsNaN(0));
-    
+
     REPORTER_ASSERT(reporter, !SkScalarIsFinite(nan));
     REPORTER_ASSERT(reporter,  SkScalarIsFinite(big));
     REPORTER_ASSERT(reporter,  SkScalarIsFinite(-big));
@@ -457,11 +457,11 @@
         // These random values are being treated as 32-bit-patterns, not as
         // ints; calling SkIntToScalar() here produces crashes.
         p.setLength((SkScalar) rand.nextS(),
-                    (SkScalar) rand.nextS(), 
+                    (SkScalar) rand.nextS(),
                     SK_Scalar1);
         check_length(reporter, p, SK_Scalar1);
         p.setLength((SkScalar) (rand.nextS() >> 13),
-                    (SkScalar) (rand.nextS() >> 13), 
+                    (SkScalar) (rand.nextS() >> 13),
                     SK_Scalar1);
         check_length(reporter, p, SK_Scalar1);
     }
diff --git a/tests/Matrix44Test.cpp b/tests/Matrix44Test.cpp
index 9e589e6..7037877 100644
--- a/tests/Matrix44Test.cpp
+++ b/tests/Matrix44Test.cpp
@@ -115,7 +115,7 @@
         mat.setTranslate(2, 3, 4);
         float dataf[16];
         double datad[16];
-        
+
         mat.asColMajorf(dataf);
         assert16<float>(reporter, dataf,
                  1, 0, 0, 0,
diff --git a/tests/MatrixTest.cpp b/tests/MatrixTest.cpp
index 60f4831..30542dc 100644
--- a/tests/MatrixTest.cpp
+++ b/tests/MatrixTest.cpp
@@ -88,12 +88,12 @@
     uint32_t size2 = m.writeToMemory(buffer);
     REPORTER_ASSERT(reporter, size1 == size2);
     REPORTER_ASSERT(reporter, size1 <= SkMatrix::kMaxFlattenSize);
-    
+
     SkMatrix m2;
     uint32_t size3 = m2.readFromMemory(buffer);
     REPORTER_ASSERT(reporter, size1 == size3);
     REPORTER_ASSERT(reporter, are_equal(reporter, m, m2));
-    
+
     char buffer2[SkMatrix::kMaxFlattenSize + 100];
     size3 = m2.writeToMemory(buffer2);
     REPORTER_ASSERT(reporter, size1 == size3);
@@ -149,7 +149,7 @@
             mat.postConcat(mats[x]);
         }
         SkScalar stretch = mat.getMaxStretch();
-        
+
         if ((stretch < 0) != mat.hasPerspective()) {
             stretch = mat.getMaxStretch();
         }
diff --git a/tests/MemsetTest.cpp b/tests/MemsetTest.cpp
index 7e80b57..ad1a21c 100644
--- a/tests/MemsetTest.cpp
+++ b/tests/MemsetTest.cpp
@@ -12,7 +12,7 @@
 static void test_chunkalloc(skiatest::Reporter* reporter) {
     size_t min = 256;
     SkChunkAlloc alloc(min);
-    
+
     REPORTER_ASSERT(reporter, 0 == alloc.totalCapacity());
     REPORTER_ASSERT(reporter, 0 == alloc.blockCount());
     REPORTER_ASSERT(reporter, !alloc.contains(NULL));
@@ -27,7 +27,7 @@
     REPORTER_ASSERT(reporter, alloc.totalCapacity() >= size);
     REPORTER_ASSERT(reporter, alloc.blockCount() > 0);
     REPORTER_ASSERT(reporter, alloc.contains(ptr));
-    
+
     alloc.reset();
     REPORTER_ASSERT(reporter, !alloc.contains(ptr));
 }
@@ -71,14 +71,14 @@
 
 static void test_16(skiatest::Reporter* reporter) {
     uint16_t buffer[TOTAL];
-    
+
     for (int count = 0; count < MAX_COUNT; ++count) {
         for (int alignment = 0; alignment < MAX_ALIGNMENT; ++alignment) {
             set_zero(buffer, sizeof(buffer));
-            
+
             uint16_t* base = &buffer[PAD + alignment];
             sk_memset16(base, VALUE16, count);
-            
+
             compare16(buffer,       0,       PAD + alignment);
             compare16(base,         VALUE16, count);
             compare16(base + count, 0,       TOTAL - count - PAD - alignment);
@@ -88,14 +88,14 @@
 
 static void test_32(skiatest::Reporter* reporter) {
     uint32_t buffer[TOTAL];
-    
+
     for (int count = 0; count < MAX_COUNT; ++count) {
         for (int alignment = 0; alignment < MAX_ALIGNMENT; ++alignment) {
             set_zero(buffer, sizeof(buffer));
-            
+
             uint32_t* base = &buffer[PAD + alignment];
             sk_memset32(base, VALUE32, count);
-            
+
             compare32(buffer,       0,       PAD + alignment);
             compare32(base,         VALUE32, count);
             compare32(base + count, 0,       TOTAL - count - PAD - alignment);
@@ -111,7 +111,7 @@
 static void TestMemset(skiatest::Reporter* reporter) {
     test_16(reporter);
     test_32(reporter);
-    
+
     test_chunkalloc(reporter);
 };
 
diff --git a/tests/MetaDataTest.cpp b/tests/MetaDataTest.cpp
index 1cc3cca..4390652 100644
--- a/tests/MetaDataTest.cpp
+++ b/tests/MetaDataTest.cpp
@@ -36,7 +36,7 @@
 
 static void TestMetaData(skiatest::Reporter* reporter) {
     SkMetaData  m1;
-    
+
     REPORTER_ASSERT(reporter, !m1.findS32("int"));
     REPORTER_ASSERT(reporter, !m1.findScalar("scalar"));
     REPORTER_ASSERT(reporter, !m1.findString("hello"));
@@ -45,28 +45,28 @@
     REPORTER_ASSERT(reporter, !m1.removeString("hello"));
     REPORTER_ASSERT(reporter, !m1.removeString("true"));
     REPORTER_ASSERT(reporter, !m1.removeString("false"));
-    
+
     m1.setS32("int", 12345);
     m1.setScalar("scalar", SK_Scalar1 * 42);
     m1.setString("hello", "world");
     m1.setPtr("ptr", &m1);
     m1.setBool("true", true);
     m1.setBool("false", false);
-    
+
     int32_t     n;
     SkScalar    s;
-    
+
     m1.setScalar("scalar", SK_Scalar1/2);
-    
+
     REPORTER_ASSERT(reporter, m1.findS32("int", &n) && n == 12345);
     REPORTER_ASSERT(reporter, m1.findScalar("scalar", &s) && s == SK_Scalar1/2);
     REPORTER_ASSERT(reporter, !strcmp(m1.findString("hello"), "world"));
     REPORTER_ASSERT(reporter, m1.hasBool("true", true));
     REPORTER_ASSERT(reporter, m1.hasBool("false", false));
-    
+
     SkMetaData::Iter iter(m1);
     const char* name;
-    
+
     static const struct {
         const char*         fName;
         SkMetaData::Type    fType;
@@ -79,7 +79,7 @@
         { "true",   SkMetaData::kBool_Type,     1 },
         { "false",  SkMetaData::kBool_Type,     1 }
     };
-    
+
     int                 loop = 0;
     int count;
     SkMetaData::Type    t;
@@ -99,13 +99,13 @@
         loop += 1;
     }
     REPORTER_ASSERT(reporter, loop == SK_ARRAY_COUNT(gElems));
-    
+
     REPORTER_ASSERT(reporter, m1.removeS32("int"));
     REPORTER_ASSERT(reporter, m1.removeScalar("scalar"));
     REPORTER_ASSERT(reporter, m1.removeString("hello"));
     REPORTER_ASSERT(reporter, m1.removeBool("true"));
     REPORTER_ASSERT(reporter, m1.removeBool("false"));
-    
+
     REPORTER_ASSERT(reporter, !m1.findS32("int"));
     REPORTER_ASSERT(reporter, !m1.findScalar("scalar"));
     REPORTER_ASSERT(reporter, !m1.findString("hello"));
diff --git a/tests/PaintTest.cpp b/tests/PaintTest.cpp
index d459b39..2a84e4c 100644
--- a/tests/PaintTest.cpp
+++ b/tests/PaintTest.cpp
@@ -77,7 +77,7 @@
                  SkFloatToScalar(304.720354932878f),
                  SkFloatToScalar(453.15255460013304f),
                  SkFloatToScalar(305.788586869862f));
-    
+
     SkRect fillR, strokeR;
     fillR = path.getBounds();
 
diff --git a/tests/ParsePathTest.cpp b/tests/ParsePathTest.cpp
index 116dbd0..c911860 100644
--- a/tests/ParsePathTest.cpp
+++ b/tests/ParsePathTest.cpp
@@ -49,7 +49,7 @@
 
         test_to_from(reporter, path);
     }
-    
+
     SkRect r;
     r.set(0, 0, SkFloatToScalar(10), SkFloatToScalar(10.5f));
     SkPath p;
diff --git a/tests/PathCoverageTest.cpp b/tests/PathCoverageTest.cpp
index 9734f75..87ec908 100644
--- a/tests/PathCoverageTest.cpp
+++ b/tests/PathCoverageTest.cpp
@@ -123,7 +123,7 @@
             quadraticPointCount_CC(path, SkIntToScalar(1));
         uint32_t estimatedCount =
             quadraticPointCount_EE(path, SkIntToScalar(1));
-        
+
         if (false) { // avoid bit rot, suppress warning
             computedCount =
                     quadraticPointCount_EC(path, SkIntToScalar(1));
diff --git a/tests/PathMeasureTest.cpp b/tests/PathMeasureTest.cpp
index 9d153c2..211eb11 100644
--- a/tests/PathMeasureTest.cpp
+++ b/tests/PathMeasureTest.cpp
@@ -16,12 +16,12 @@
         { 100000000000.0f, 100000000000.0f }, { 0, 0 }, { 10, 10 },
         { 10, 10 }, { 0, 0 }, { 10, 10 }
     };
-    
+
     path.moveTo(pts[0]);
     for (size_t i = 1; i < SK_ARRAY_COUNT(pts); i += 2) {
         path.cubicTo(pts[i], pts[i + 1], pts[i + 2]);
     }
-    
+
     SkPathMeasure meas(path, false);
     meas.getLength();
 #endif
@@ -32,10 +32,10 @@
     SkPath path;
     const SkPoint pts[] = {
         { 0, 0 },
-        { 100000000000.0f, 100000000000.0f }, { 0, 0 }, 
-        { 10, 10 }, { 0, 0 }, 
+        { 100000000000.0f, 100000000000.0f }, { 0, 0 },
+        { 10, 10 }, { 0, 0 },
     };
-    
+
     path.moveTo(pts[0]);
     for (size_t i = 1; i < SK_ARRAY_COUNT(pts); i += 2) {
         path.quadTo(pts[i], pts[i + 1]);
@@ -55,7 +55,7 @@
         // tiny (non-zero) jump between these points
         { SK_Scalar1, SK_Scalar1 },
     };
-    
+
     path.moveTo(pts[0]);
     for (size_t i = 1; i < SK_ARRAY_COUNT(pts); ++i) {
         path.lineTo(pts[i]);
@@ -161,11 +161,11 @@
     REPORTER_ASSERT(reporter, tangent.fY == SK_Scalar1);
     REPORTER_ASSERT(reporter, meas.getPosTan(SkFloatToScalar(4.5f), &position, &tangent));
     REPORTER_ASSERT(reporter,
-        SkScalarNearlyEqual(position.fX, 
-                            SkFloatToScalar(2.5f), 
+        SkScalarNearlyEqual(position.fX,
+                            SkFloatToScalar(2.5f),
                             SkFloatToScalar(0.0001f)));
     REPORTER_ASSERT(reporter,
-        SkScalarNearlyEqual(position.fY, 
+        SkScalarNearlyEqual(position.fY,
                             SkFloatToScalar(2.0f),
                             SkFloatToScalar(0.0001f)));
     REPORTER_ASSERT(reporter, tangent.fX == SK_Scalar1);
@@ -193,7 +193,7 @@
     REPORTER_ASSERT(reporter, length == SK_Scalar1);
     REPORTER_ASSERT(reporter, meas.getPosTan(SK_ScalarHalf, &position, &tangent));
     REPORTER_ASSERT(reporter,
-        SkScalarNearlyEqual(position.fX, 
+        SkScalarNearlyEqual(position.fX,
                             SkFloatToScalar(1.5f),
                             SkFloatToScalar(0.0001f)));
     REPORTER_ASSERT(reporter,
diff --git a/tests/PathTest.cpp b/tests/PathTest.cpp
index 0053640..50b3583 100644
--- a/tests/PathTest.cpp
+++ b/tests/PathTest.cpp
@@ -22,7 +22,7 @@
     SkPath path;
     path.quadTo(157, 366, 286, 208);
     path.arcTo(37, 442, 315, 163, 957494590897113.0f);
-    
+
     SkMatrix matrix;
     matrix.setScale(1000*1000, 1000*1000);
 
@@ -47,7 +47,7 @@
 static void test_rect_isfinite(skiatest::Reporter* reporter) {
     const SkScalar inf = SK_ScalarInfinity;
     const SkScalar nan = SK_ScalarNaN;
-    
+
     SkRect r;
     r.setEmpty();
     REPORTER_ASSERT(reporter, r.isFinite());
@@ -55,22 +55,22 @@
     REPORTER_ASSERT(reporter, !r.isFinite());
     r.set(0, 0, nan, 0);
     REPORTER_ASSERT(reporter, !r.isFinite());
-    
+
     SkPoint pts[] = {
         { 0, 0 },
         { SK_Scalar1, 0 },
         { 0, SK_Scalar1 },
     };
-    
+
     bool isFine = r.setBoundsCheck(pts, 3);
     REPORTER_ASSERT(reporter, isFine);
     REPORTER_ASSERT(reporter, !r.isEmpty());
-    
+
     pts[1].set(inf, 0);
     isFine = r.setBoundsCheck(pts, 3);
     REPORTER_ASSERT(reporter, !isFine);
     REPORTER_ASSERT(reporter, r.isEmpty());
-    
+
     pts[1].set(nan, 0);
     isFine = r.setBoundsCheck(pts, 3);
     REPORTER_ASSERT(reporter, !isFine);
@@ -80,7 +80,7 @@
 static void test_path_isfinite(skiatest::Reporter* reporter) {
     const SkScalar inf = SK_ScalarInfinity;
     const SkScalar nan = SK_ScalarNaN;
-    
+
     SkPath path;
     REPORTER_ASSERT(reporter, path.isFinite());
 
@@ -155,7 +155,7 @@
 static void test_addPoly(skiatest::Reporter* reporter) {
     SkPoint pts[32];
     SkRandom rand;
-    
+
     for (size_t i = 0; i < SK_ARRAY_COUNT(pts); ++i) {
         pts[i].fX = rand.nextSScalar1();
         pts[i].fY = rand.nextSScalar1();
@@ -173,19 +173,19 @@
 static void test_strokerec(skiatest::Reporter* reporter) {
     SkStrokeRec rec(SkStrokeRec::kFill_InitStyle);
     REPORTER_ASSERT(reporter, rec.isFillStyle());
-    
+
     rec.setHairlineStyle();
     REPORTER_ASSERT(reporter, rec.isHairlineStyle());
-    
+
     rec.setStrokeStyle(SK_Scalar1, false);
     REPORTER_ASSERT(reporter, SkStrokeRec::kStroke_Style == rec.getStyle());
-    
+
     rec.setStrokeStyle(SK_Scalar1, true);
     REPORTER_ASSERT(reporter, SkStrokeRec::kStrokeAndFill_Style == rec.getStyle());
-    
+
     rec.setStrokeStyle(0, false);
     REPORTER_ASSERT(reporter, SkStrokeRec::kHairline_Style == rec.getStyle());
-    
+
     rec.setStrokeStyle(0, true);
     REPORTER_ASSERT(reporter, SkStrokeRec::kFill_Style == rec.getStyle());
 }
@@ -226,7 +226,7 @@
         REPORTER_ASSERT(reporter, valid);
         REPORTER_ASSERT(reporter, !path.cheapComputeDirection(NULL));
     }
-    
+
     static const char* gCW[] = {
         "M 10 10 L 10 10 Q 20 10 20 20",
         "M 10 10 C 20 10 20 20 20 20",
@@ -241,7 +241,7 @@
         REPORTER_ASSERT(reporter, valid);
         check_direction(&path, SkPath::kCW_Direction, reporter);
     }
-    
+
     static const char* gCCW[] = {
         "M 10 10 L 10 10 Q 20 10 20 -20",
         "M 10 10 C 20 10 20 -20 20 -20",
@@ -309,11 +309,11 @@
     SkPath path;
     path.moveTo(pts[0]);
     path.cubicTo(pts[1], pts[2], pts[3]);
-    
+
     SkPaint paint;
     paint.setStyle(SkPaint::kStroke_Style);
     paint.setStrokeWidth(SK_Scalar1 * 2);
-    
+
     SkPath fill;
     paint.getFillPath(path, &fill);
 }
@@ -328,16 +328,16 @@
         { 372.0f,   92.0f },
         { 372.0f,   92.0f },
     };
-    
+
     stroke_cubic(p0);
-    
+
     SkPoint p1[] = {
         { 372.0f,       92.0f },
         { 372.0007f,    92.000755f },
         { 371.99927f,   92.003922f },
         { 371.99826f,   92.003899f },
     };
-    
+
     stroke_cubic(p1);
 }
 
@@ -398,7 +398,7 @@
     check_close(reporter, quad);
 
     SkPath cubic;
-    quad.cubicTo(SK_Scalar1, SK_Scalar1, 10 * SK_Scalar1, 
+    quad.cubicTo(SK_Scalar1, SK_Scalar1, 10 * SK_Scalar1,
                  10*SK_Scalar1, 20 * SK_Scalar1, 20*SK_Scalar1);
     check_close(reporter, cubic);
     cubic.close();
@@ -448,27 +448,27 @@
     pt.moveTo(0, 0);
     pt.close();
     check_convexity(reporter, pt, SkPath::kConvex_Convexity);
-    
+
     SkPath line;
     line.moveTo(12*SK_Scalar1, 20*SK_Scalar1);
     line.lineTo(-12*SK_Scalar1, -20*SK_Scalar1);
     line.close();
     check_convexity(reporter, pt, SkPath::kConvex_Convexity);
-    
+
     SkPath triLeft;
     triLeft.moveTo(0, 0);
     triLeft.lineTo(SK_Scalar1, 0);
     triLeft.lineTo(SK_Scalar1, SK_Scalar1);
     triLeft.close();
     check_convexity(reporter, triLeft, SkPath::kConvex_Convexity);
-    
+
     SkPath triRight;
     triRight.moveTo(0, 0);
     triRight.lineTo(-SK_Scalar1, 0);
     triRight.lineTo(SK_Scalar1, SK_Scalar1);
     triRight.close();
     check_convexity(reporter, triRight, SkPath::kConvex_Convexity);
-    
+
     SkPath square;
     square.moveTo(0, 0);
     square.lineTo(SK_Scalar1, 0);
@@ -476,7 +476,7 @@
     square.lineTo(0, SK_Scalar1);
     square.close();
     check_convexity(reporter, square, SkPath::kConvex_Convexity);
-    
+
     SkPath redundantSquare;
     redundantSquare.moveTo(0, 0);
     redundantSquare.lineTo(0, 0);
@@ -492,7 +492,7 @@
     redundantSquare.lineTo(0, SK_Scalar1);
     redundantSquare.close();
     check_convexity(reporter, redundantSquare, SkPath::kConvex_Convexity);
-    
+
     SkPath bowTie;
     bowTie.moveTo(0, 0);
     bowTie.lineTo(0, 0);
@@ -508,7 +508,7 @@
     bowTie.lineTo(0, SK_Scalar1);
     bowTie.close();
     check_convexity(reporter, bowTie, SkPath::kConcave_Convexity);
-    
+
     SkPath spiral;
     spiral.moveTo(0, 0);
     spiral.lineTo(100*SK_Scalar1, 0);
@@ -519,7 +519,7 @@
     spiral.lineTo(50*SK_Scalar1, 75*SK_Scalar1);
     spiral.close();
     check_convexity(reporter, spiral, SkPath::kConcave_Convexity);
-    
+
     SkPath dent;
     dent.moveTo(0, 0);
     dent.lineTo(100*SK_Scalar1, 100*SK_Scalar1);
@@ -583,7 +583,7 @@
     path.addRect(0, 0, SkIntToScalar(10), SkIntToScalar(10), SkPath::kCW_Direction);
     REPORTER_ASSERT(reporter, V == SkPath::ComputeConvexity(path));
     REPORTER_ASSERT(reporter, path.cheapIsDirection(SkPath::kCW_Direction));
-    
+
     static const struct {
         const char*         fPathStr;
         SkPath::Convexity   fExpectedConvexity;
@@ -612,7 +612,7 @@
     const SkScalar value = SkIntToScalar(5);
 
     REPORTER_ASSERT(reporter, !path.isLine(NULL));
-    
+
     // set some non-zero values
     pts[0].set(value, value);
     pts[1].set(value, value);
@@ -672,7 +672,7 @@
     SkPoint rc[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 0}};
     SkPoint rd[] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}, {0, 0}};
     SkPoint re[] = {{0, 0}, {1, 0}, {1, 0}, {1, 1}, {0, 1}};
-    
+
     // failing tests
     SkPoint f1[] = {{0, 0}, {1, 0}, {1, 1}}; // too few points
     SkPoint f2[] = {{0, 0}, {1, 1}, {0, 1}, {1, 0}}; // diagonal
@@ -682,7 +682,7 @@
     SkPoint f6[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}, {0, 2}}; // end overshoots
     SkPoint f7[] = {{0, 0}, {1, 0}, {1, 1}, {0, 2}}; // end overshoots
     SkPoint f8[] = {{0, 0}, {1, 0}, {1, 1}, {1, 0}}; // 'L'
-    
+
     // failing, no close
     SkPoint c1[] = {{0, 0}, {1, 0}, {1, 1}, {0, 1}}; // close doesn't match
     SkPoint c2[] = {{0, 0}, {1, 0}, {1, 2}, {0, 2}, {0, 1}}; // ditto
@@ -693,12 +693,12 @@
         sizeof(rd), sizeof(re),
         sizeof(f1), sizeof(f2), sizeof(f3), sizeof(f4), sizeof(f5), sizeof(f6),
         sizeof(f7), sizeof(f8),
-        sizeof(c1), sizeof(c2) 
+        sizeof(c1), sizeof(c2)
     };
     SkPoint* tests[] = {
         r1, r2, r3, r4, r5, r6, r7, r8, r9, ra, rb, rc, rd, re,
         f1, f2, f3, f4, f5, f6, f7, f8,
-        c1, c2 
+        c1, c2
     };
     SkPoint* lastPass = re;
     SkPoint* lastClose = f8;
@@ -723,7 +723,7 @@
             close = false;
         }
     }
-    
+
     // fail, close then line
     SkPath path1;
     path1.moveTo(r1[0].fX, r1[0].fY);
@@ -733,7 +733,7 @@
     path1.close();
     path1.lineTo(1, 0);
     REPORTER_ASSERT(reporter, fail ^ path1.isRect(0));
-    
+
     // fail, move in the middle
     path1.reset();
     path1.moveTo(r1[0].fX, r1[0].fY);
@@ -754,7 +754,7 @@
     }
     path1.close();
     REPORTER_ASSERT(reporter, fail ^ path1.isRect(0));
-    
+
     // fail, quad
     path1.reset();
     path1.moveTo(r1[0].fX, r1[0].fY);
@@ -766,7 +766,7 @@
     }
     path1.close();
     REPORTER_ASSERT(reporter, fail ^ path1.isRect(0));
-    
+
     // fail, cubic
     path1.reset();
     path1.moveTo(r1[0].fX, r1[0].fY);
@@ -794,7 +794,7 @@
     reader.readPath(&readBack);
     REPORTER_ASSERT(reporter, readBack == p);
 
-    REPORTER_ASSERT(reporter, readBack.getConvexityOrUnknown() == 
+    REPORTER_ASSERT(reporter, readBack.getConvexityOrUnknown() ==
                               p.getConvexityOrUnknown());
 
     REPORTER_ASSERT(reporter, readBack.isOval(NULL) == p.isOval(NULL));
@@ -850,7 +850,7 @@
 
 static void test_transform(skiatest::Reporter* reporter) {
     SkPath p, p1;
-    
+
     static const SkPoint pts[] = {
         { 0, 0 },
         { SkIntToScalar(10), SkIntToScalar(10) },
@@ -861,12 +861,12 @@
     p.lineTo(pts[1]);
     p.quadTo(pts[2], pts[3]);
     p.cubicTo(pts[4], pts[5], pts[6]);
-    
+
     SkMatrix matrix;
     matrix.reset();
     p.transform(matrix, &p1);
     REPORTER_ASSERT(reporter, p == p1);
-    
+
     matrix.setScale(SK_Scalar1 * 2, SK_Scalar1 * 3);
     p.transform(matrix, &p1);
     SkPoint pts1[7];
@@ -977,7 +977,7 @@
     REPORTER_ASSERT(reporter, SkPath::kCubic_SegmentMask == p.getSegmentMasks());
     p2 = p;
     REPORTER_ASSERT(reporter, p2.getSegmentMasks() == p.getSegmentMasks());
-    
+
     REPORTER_ASSERT(reporter, !p.isEmpty());
 }
 
@@ -1005,7 +1005,7 @@
     iter.setPath(p, true);
     REPORTER_ASSERT(reporter, iter.next(pts) == SkPath::kDone_Verb);
 
-    
+
     struct iterTestData {
         const char* testPath;
         const bool forceClose;
@@ -1092,7 +1092,7 @@
     // Test that setting an empty path works
     noPathIter.setPath(p);
     REPORTER_ASSERT(reporter, noPathIter.next(pts) == SkPath::kDone_Verb);
-    
+
     // Test an iterator with an initial empty path
     SkPath::RawIter iter(p);
     REPORTER_ASSERT(reporter, iter.next(pts) == SkPath::kDone_Verb);
@@ -1242,7 +1242,7 @@
             }
             expectedVerbs[numIterVerbs++] = nextVerb;
         }
-        
+
         iter.setPath(p);
         numVerbs = numIterVerbs;
         numIterVerbs = 0;
diff --git a/tests/ReadPixelsTest.cpp b/tests/ReadPixelsTest.cpp
index 67bb659..392c5ac 100644
--- a/tests/ReadPixelsTest.cpp
+++ b/tests/ReadPixelsTest.cpp
@@ -19,7 +19,7 @@
 
 static const int DEV_W = 100, DEV_H = 100;
 static const SkIRect DEV_RECT = SkIRect::MakeWH(DEV_W, DEV_H);
-static const SkRect DEV_RECT_S = SkRect::MakeWH(DEV_W * SK_Scalar1, 
+static const SkRect DEV_RECT_S = SkRect::MakeWH(DEV_W * SK_Scalar1,
                                                 DEV_H * SK_Scalar1);
 
 namespace {
@@ -51,7 +51,7 @@
     }
     return SkPremultiplyARGBInline(a, r, g, b);
 }
-    
+
 SkPMColor getBitmapColor(int x, int y, int w, int h) {
     int n = y * w + x;
 
@@ -125,7 +125,7 @@
     canvas->drawBitmap(bmp, 0, 0, &paint);
     canvas->restore();
 }
-    
+
 void fillBitmap(SkBitmap* bitmap) {
     SkASSERT(bitmap->lockPixelsAreWritable());
     SkAutoLockPixels alp(*bitmap);
@@ -172,7 +172,7 @@
     SkASSERT(SkBitmap::kARGB_8888_Config == bitmap.config());
     SkASSERT(!bitmap.isNull());
     SkASSERT(checkCanvasPixels || checkBitmapPixels);
-    
+
     int bw = bitmap.width();
     int bh = bitmap.height();
 
@@ -187,7 +187,7 @@
         for (int bx = 0; bx < bw; ++bx) {
             int devx = bx + srcRect.fLeft;
             int devy = by + srcRect.fTop;
-            
+
             uint32_t pixel = *reinterpret_cast<SkPMColor*>(pixels + by * bitmap.rowBytes() + bx * bitmap.bytesPerPixel());
 
             if (clippedSrcRect.contains(devx, devy)) {
@@ -214,11 +214,11 @@
 
 enum BitmapInit {
     kFirstBitmapInit = 0,
-    
+
     kNoPixels_BitmapInit = kFirstBitmapInit,
     kTight_BitmapInit,
     kRowBytes_BitmapInit,
-    
+
     kBitmapInitCnt
 };
 
@@ -253,7 +253,7 @@
 
 void ReadPixelsTest(skiatest::Reporter* reporter, GrContext* context) {
     SkCanvas canvas;
-    
+
     const SkIRect testRects[] = {
         // entire thing
         DEV_RECT,
diff --git a/tests/ReadWriteAlphaTest.cpp b/tests/ReadWriteAlphaTest.cpp
index faa7629..751c912 100644
--- a/tests/ReadWriteAlphaTest.cpp
+++ b/tests/ReadWriteAlphaTest.cpp
@@ -60,7 +60,7 @@
     memset(readback, 0x1, X_SIZE * Y_SIZE);
 
     // read the texture back
-    texture->readPixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig, 
+    texture->readPixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
                         readback, 0);
 
     // make sure the original & read back versions match
@@ -89,11 +89,11 @@
 
     canvas.drawRect(rect, paint);
 
-    texture->readPixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig, 
+    texture->readPixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
                         readback, 0);
 
     match = true;
-    
+
     for (int y = 0; y < Y_SIZE; ++y) {
         for (int x = 0; x < X_SIZE; ++x) {
             if (0xFF != readback[x][y]) {
diff --git a/tests/RefCntTest.cpp b/tests/RefCntTest.cpp
index 5197ffb..ed771e7 100644
--- a/tests/RefCntTest.cpp
+++ b/tests/RefCntTest.cpp
@@ -42,7 +42,7 @@
     REPORTER_ASSERT(reporter, N == InstCounterClass::gInstCounter);
     array->unref();
     REPORTER_ASSERT(reporter, 0 == InstCounterClass::gInstCounter);
-    
+
     // Now test the copy factory
 
     int i;
diff --git a/tests/RegionTest.cpp b/tests/RegionTest.cpp
index db43e33..8e66502 100644
--- a/tests/RegionTest.cpp
+++ b/tests/RegionTest.cpp
@@ -161,7 +161,7 @@
         { 2, 2, 3, 3 },
     };
     REPORTER_ASSERT(reporter, test_rects(r2, SK_ARRAY_COUNT(r2)));
-    
+
     const SkIRect rects[] = {
         { 0, 0, 1, 2 },
         { 2, 1, 3, 3 },
@@ -181,7 +181,7 @@
         }
         REPORTER_ASSERT(reporter, test_rects(rect, N));
     }
-    
+
     test_proc(reporter, contains_proc);
     test_proc(reporter, intersects_proc);
     test_empties(reporter);
diff --git a/tests/ScalarTest.cpp b/tests/ScalarTest.cpp
index 2071914..801872e 100644
--- a/tests/ScalarTest.cpp
+++ b/tests/ScalarTest.cpp
@@ -53,7 +53,7 @@
         { gI2, SK_ARRAY_COUNT(gI2), false },
         { gI3, SK_ARRAY_COUNT(gI3), false },
     };
-    
+
     for (size_t i = 0; i < SK_ARRAY_COUNT(gSets); ++i) {
         SkRect r;
         r.set(gSets[i].fPts, gSets[i].fCount);
@@ -118,7 +118,7 @@
         float   fValue;
         bool    fIsFinite;
     };
-    
+
     float max = 3.402823466e+38f;
     float inf = max * max;
     float nan = inf * 0;
@@ -170,7 +170,7 @@
             const Rec& rec1 = data[j];
             for (size_t k = 0; k < SK_ARRAY_COUNT(gProc1); ++k) {
                 IsFiniteProc1 proc1 = gProc1[k];
-                
+
                 for (size_t m = 0; m < SK_ARRAY_COUNT(gProc2); ++m) {
                     bool finite = gProc2[m](rec0.fValue, rec1.fValue, proc1);
                     bool finite2 = rec0.fIsFinite && rec1.fIsFinite;
@@ -179,7 +179,7 @@
             }
         }
     }
-    
+
     test_isRectFinite(reporter);
 }
 
diff --git a/tests/ShaderOpacityTest.cpp b/tests/ShaderOpacityTest.cpp
index a8177ee..0af25d1 100644
--- a/tests/ShaderOpacityTest.cpp
+++ b/tests/ShaderOpacityTest.cpp
@@ -13,9 +13,9 @@
 static void test_bitmap(skiatest::Reporter* reporter) {
     SkBitmap bmp;
     bmp.setConfig(SkBitmap::kARGB_8888_Config, 2, 2);
-    
+
     // test 1: bitmap without pixel data
-    SkShader* shader = SkShader::CreateBitmapShader(bmp, 
+    SkShader* shader = SkShader::CreateBitmapShader(bmp,
         SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
     REPORTER_ASSERT(reporter, shader);
     REPORTER_ASSERT(reporter, !shader->isOpaque());
@@ -25,7 +25,7 @@
     bmp.allocPixels();
 
     // test 2: not opaque by default
-    shader = SkShader::CreateBitmapShader(bmp, 
+    shader = SkShader::CreateBitmapShader(bmp,
         SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
     REPORTER_ASSERT(reporter, shader);
     REPORTER_ASSERT(reporter, !shader->isOpaque());
@@ -33,7 +33,7 @@
 
     // test 3: explicitly opaque
     bmp.setIsOpaque(true);
-    shader = SkShader::CreateBitmapShader(bmp, 
+    shader = SkShader::CreateBitmapShader(bmp,
         SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
     REPORTER_ASSERT(reporter, shader);
     REPORTER_ASSERT(reporter, shader->isOpaque());
@@ -41,7 +41,7 @@
 
     // test 4: explicitly not opaque
     bmp.setIsOpaque(false);
-    shader = SkShader::CreateBitmapShader(bmp, 
+    shader = SkShader::CreateBitmapShader(bmp,
         SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
     REPORTER_ASSERT(reporter, shader);
     REPORTER_ASSERT(reporter, !shader->isOpaque());
@@ -102,7 +102,7 @@
     SkColorShader colorShader3(SkColorSetARGB(0x7F,0,0,0));
     REPORTER_ASSERT(reporter, !colorShader3.isOpaque());
 
-    // with inherrited color, shader must declare itself as opaque, 
+    // with inherrited color, shader must declare itself as opaque,
     // since lack of opacity will depend solely on the paint
     SkColorShader colorShader4;
     REPORTER_ASSERT(reporter, colorShader4.isOpaque());
diff --git a/tests/SortTest.cpp b/tests/SortTest.cpp
index 2ca8f2f..d1a61d4 100644
--- a/tests/SortTest.cpp
+++ b/tests/SortTest.cpp
@@ -73,7 +73,7 @@
     if (false) { // avoid bit rot, suppress warning
         compare_int(array, array);
     }
-    
+
     test_checksum(reporter);
 }
 
diff --git a/tests/StreamTest.cpp b/tests/StreamTest.cpp
index 85b1b2e..b5e3cd9 100644
--- a/tests/StreamTest.cpp
+++ b/tests/StreamTest.cpp
@@ -108,18 +108,18 @@
         0xFFFFFD, 0xFFFFFE, 0xFFFFFF, 0x1000000, 0x1000001,
         0x7FFFFFFE, 0x7FFFFFFF, 0x80000000, 0x80000001, 0xFFFFFFFE, 0xFFFFFFFF
     };
-    
-    
+
+
     size_t i;
     char buffer[sizeof(sizes) * 4];
-    
+
     SkMemoryWStream wstream(buffer, sizeof(buffer));
     for (i = 0; i < SK_ARRAY_COUNT(sizes); ++i) {
         bool success = wstream.writePackedUInt(sizes[i]);
         REPORTER_ASSERT(reporter, success);
     }
     wstream.flush();
-    
+
     SkMemoryStream rstream(buffer, sizeof(buffer));
     for (i = 0; i < SK_ARRAY_COUNT(sizes); ++i) {
         size_t n = rstream.readPackedUInt();
diff --git a/tests/StringTest.cpp b/tests/StringTest.cpp
index 08bd280..5ae718f 100644
--- a/tests/StringTest.cpp
+++ b/tests/StringTest.cpp
@@ -68,7 +68,7 @@
     REPORTER_ASSERT(reporter,  a.contains("hello"));
     REPORTER_ASSERT(reporter, !a.contains("hellohello"));
     REPORTER_ASSERT(reporter,  a.contains(""));
-    
+
     SkString    e(a);
     SkString    f("hello");
     SkString    g("helloz", 5);
@@ -148,7 +148,7 @@
     REPORTER_ASSERT(reporter, buffer[18] == ' ');
     REPORTER_ASSERT(reporter, buffer[19] == 0);
     REPORTER_ASSERT(reporter, buffer[20] == 'a');
-    
+
 }
 
 #include "TestClassDef.h"
diff --git a/tests/TLSTest.cpp b/tests/TLSTest.cpp
index 9bebb1b..5fa0903 100644
--- a/tests/TLSTest.cpp
+++ b/tests/TLSTest.cpp
@@ -38,7 +38,7 @@
     for (i = 0; i < N; ++i) {
         threads[i] = new SkThread(thread_main);
     }
-    
+
     for (i = 0; i < N; ++i) {
         threads[i]->start();
     }
diff --git a/tests/Test.h b/tests/Test.h
index 2396d6f..a3beb0c 100644
--- a/tests/Test.h
+++ b/tests/Test.h
@@ -59,11 +59,11 @@
         void reportFailed(const SkString& desc) {
             this->report(desc.c_str(), kFailed);
         }
-        
+
         bool getCurrSuccess() const {
             return fCurrTestSuccess;
         }
-        
+
     protected:
         virtual void onStart(Test*) {}
         virtual void onReport(const char desc[], Result) {}
diff --git a/tests/TestSize.cpp b/tests/TestSize.cpp
index 97a6668..6a9a887 100644
--- a/tests/TestSize.cpp
+++ b/tests/TestSize.cpp
@@ -10,7 +10,7 @@
 
 static void TestISize(skiatest::Reporter* reporter) {
     SkISize  a, b;
-    
+
     a.set(0, 0);
     REPORTER_ASSERT(reporter, a.isEmpty());
     a.set(5, -5);
@@ -19,7 +19,7 @@
     REPORTER_ASSERT(reporter, a.isEmpty());
     b.set(5, 0);
     REPORTER_ASSERT(reporter, a == b);
-    
+
     a.set(3, 5);
     REPORTER_ASSERT(reporter, !a.isEmpty());
     b = a;
@@ -32,13 +32,13 @@
 
 static void TestSize(skiatest::Reporter* reporter) {
     TestISize(reporter);
-    
+
     SkSize a, b;
     int ix = 5;
     int iy = 3;
     SkScalar x = SkIntToScalar(ix);
     SkScalar y = SkIntToScalar(iy);
-    
+
     a.set(0, 0);
     REPORTER_ASSERT(reporter, a.isEmpty());
     a.set(x, -x);
@@ -47,7 +47,7 @@
     REPORTER_ASSERT(reporter, a.isEmpty());
     b.set(x, 0);
     REPORTER_ASSERT(reporter, a == b);
-    
+
     a.set(y, x);
     REPORTER_ASSERT(reporter, !a.isEmpty());
     b = a;
@@ -56,7 +56,7 @@
     REPORTER_ASSERT(reporter, !(a != b));
     REPORTER_ASSERT(reporter,
                     a.fWidth == b.fWidth && a.fHeight == b.fHeight);
-    
+
     SkISize ia;
     ia.set(ix, iy);
     a.set(x, y);
diff --git a/tests/UnicodeTest.cpp b/tests/UnicodeTest.cpp
index 1293fb6..ec9a8bc 100644
--- a/tests/UnicodeTest.cpp
+++ b/tests/UnicodeTest.cpp
@@ -72,7 +72,7 @@
     REPORTER_ASSERT(reporter, (int)len8 == count8);
     REPORTER_ASSERT(reporter, (int)len8 == count16);
     REPORTER_ASSERT(reporter, (int)len8 == count32);
-    
+
     REPORTER_ASSERT(reporter, !memcmp(glyphs8, glyphs16, count8 * sizeof(uint16_t)));
     REPORTER_ASSERT(reporter, !memcmp(glyphs8, glyphs32, count8 * sizeof(uint16_t)));
 }
diff --git a/tests/WritePixelsTest.cpp b/tests/WritePixelsTest.cpp
index d5ce8af..5a9cf26 100644
--- a/tests/WritePixelsTest.cpp
+++ b/tests/WritePixelsTest.cpp
@@ -20,7 +20,7 @@
 
 static const int DEV_W = 100, DEV_H = 100;
 static const SkIRect DEV_RECT = SkIRect::MakeWH(DEV_W, DEV_H);
-static const SkRect DEV_RECT_S = SkRect::MakeWH(DEV_W * SK_Scalar1, 
+static const SkRect DEV_RECT_S = SkRect::MakeWH(DEV_W * SK_Scalar1,
                                                 DEV_H * SK_Scalar1);
 static const U8CPU DEV_PAD = 0xee;
 
@@ -351,7 +351,7 @@
 
 void WritePixelsTest(skiatest::Reporter* reporter, GrContext* context) {
     SkCanvas canvas;
-    
+
     const SkIRect testRects[] = {
         // entire thing
         DEV_RECT,
diff --git a/tests/Writer32Test.cpp b/tests/Writer32Test.cpp
index 8b048a7..f2dcf90 100644
--- a/tests/Writer32Test.cpp
+++ b/tests/Writer32Test.cpp
@@ -15,7 +15,7 @@
 
 static void test_ptr(skiatest::Reporter* reporter) {
     SkSWriter32<32> writer(32);
-    
+
     void* p0 = reporter;
     void* p1 = &writer;
 
@@ -135,14 +135,14 @@
         SkWriter32 writer(256 * 4);
         REPORTER_ASSERT(reporter, NULL == writer.getSingleBlock());
         test1(reporter, &writer);
-        
+
         writer.reset();
         test2(reporter, &writer);
 
         writer.reset();
         testWritePad(reporter, &writer);
     }
-    
+
     // single-block
     {
         SkWriter32 writer(0);
@@ -154,33 +154,33 @@
 
         writer.reset(storage, sizeof(storage));
         test2(reporter, &writer);
-        
+
         writer.reset(storage, sizeof(storage));
         testWritePad(reporter, &writer);
     }
-    
+
     // small storage
     {
         SkSWriter32<8 * sizeof(intptr_t)> writer(100);
         test1(reporter, &writer);
         writer.reset(); // should just rewind our storage
         test2(reporter, &writer);
-        
+
         writer.reset();
         testWritePad(reporter, &writer);
     }
-    
+
     // large storage
     {
         SkSWriter32<1024 * sizeof(intptr_t)> writer(100);
         test1(reporter, &writer);
         writer.reset(); // should just rewind our storage
         test2(reporter, &writer);
-        
+
         writer.reset();
         testWritePad(reporter, &writer);
     }
-    
+
     test_ptr(reporter);
 }
 
diff --git a/tests/XfermodeTest.cpp b/tests/XfermodeTest.cpp
index a851b29..0b7012d 100644
--- a/tests/XfermodeTest.cpp
+++ b/tests/XfermodeTest.cpp
@@ -33,7 +33,7 @@
             REPORTER_ASSERT(reporter, reportedMode == mode);
             xfer->unref();
         } else {
-            REPORTER_ASSERT(reporter, SkXfermode::kSrcOver_Mode == mode); 
+            REPORTER_ASSERT(reporter, SkXfermode::kSrcOver_Mode == mode);
         }
     }
 
@@ -52,7 +52,7 @@
 
     for (int i = 0; i <= SkXfermode::kLastMode; ++i) {
         SkXfermode::Mode mode = (SkXfermode::Mode)i;
-        
+
         SkXfermode* xfer = SkXfermode::Create(mode);
         REPORTER_ASSERT(reporter, SkXfermode::IsMode(xfer, mode));
         SkSafeUnref(xfer);
diff --git a/tests/skia_test.cpp b/tests/skia_test.cpp
index ecb0037..7913874 100644
--- a/tests/skia_test.cpp
+++ b/tests/skia_test.cpp
@@ -115,7 +115,7 @@
     for (++argv; argv < stop; ++argv) {
         if (strcmp(*argv, "-android") == 0) {
             androidMode = true;
-        
+
         } else if (strcmp(*argv, "--match") == 0) {
             ++argv;
             if (argv < stop && **argv) {