Remove globals from tests/CanvasTest.cpp

tests/CanvasTest.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 /*  Description:
  *      This test defines a series of elementatry test steps that perform
  *      a single or a small group of canvas API calls. Each test step is
@@ skipping 47 matching lines @@
 #include "SkPictureRecorder.h"
 #include "SkProxyCanvas.h"
 #include "SkRect.h"
 #include "SkRegion.h"
 #include "SkShader.h"
 #include "SkStream.h"
 #include "SkSurface.h"
 #include "SkTDArray.h"
 #include "Test.h"
 
+static const int kWidth = 2, kHeight = 2;
+
+static void createBitmap(SkBitmap* bm, SkColor color) {
+    bm->allocN32Pixels(kWidth, kHeight);
+    bm->eraseColor(color);
+}
+
+static SkSurface* createSurface(SkColor color) {
+    SkSurface* surface = SkSurface::NewRasterPMColor(kWidth, kHeight);
+    surface->getCanvas()->clear(color);
+    return surface;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Constants used by test steps
+const SkPoint kTestPoints[] = {
+    {SkIntToScalar(0), SkIntToScalar(0)},
+    {SkIntToScalar(2), SkIntToScalar(1)},
+    {SkIntToScalar(0), SkIntToScalar(2)}
+};
+const SkPoint kTestPoints2[] = {
+    { SkIntToScalar(0), SkIntToScalar(1) },
+    { SkIntToScalar(1), SkIntToScalar(1) },
+    { SkIntToScalar(2), SkIntToScalar(1) },
+    { SkIntToScalar(3), SkIntToScalar(1) },
+    { SkIntToScalar(4), SkIntToScalar(1) },
+    { SkIntToScalar(5), SkIntToScalar(1) },
+    { SkIntToScalar(6), SkIntToScalar(1) },
+    { SkIntToScalar(7), SkIntToScalar(1) },
+    { SkIntToScalar(8), SkIntToScalar(1) },
+    { SkIntToScalar(9), SkIntToScalar(1) },
+    { SkIntToScalar(10), SkIntToScalar(1) }
+};
+
+struct TestData {
+public:
+    TestData()
+    : fRect(SkRect::MakeXYWH(SkIntToScalar(0), SkIntToScalar(0),
+                                 SkIntToScalar(2), SkIntToScalar(1)))
+    , fMatrix(TestMatrix())
+    , fPath(TestPath())
+    , fNearlyZeroLengthPath(TestNearlyZeroLengthPath())
+    , fIRect(SkIRect::MakeXYWH(0, 0, 2, 1))
+    , fRegion(TestRegion())
+    , fColor(0x01020304)
+    , fPoints(kTestPoints)
+    , fPointCount(3)
+    , fWidth(2)
+    , fHeight(2)
+    , fText("Hello World")
+    , fPoints2(kTestPoints2)
+    , fBitmap(TestBitmap())
+    { }
+
+    SkRect fRect;
+    SkMatrix fMatrix;;
+    SkPath fPath;
+    SkPath fNearlyZeroLengthPath;
+    SkIRect fIRect;
+    SkRegion fRegion;
+    SkColor fColor;
+    SkPaint fPaint;
+    const SkPoint* fPoints;
+    size_t fPointCount;
+    int fWidth;
+    int fHeight;
+    SkString fText;
+    const SkPoint* fPoints2;
+    SkBitmap fBitmap;
+
+private:
+    static SkMatrix TestMatrix() {
+        SkMatrix matrix;
+        matrix.reset();
+        matrix.setScale(SkIntToScalar(2), SkIntToScalar(3));
+
+        return matrix;
+    }
+    static SkPath TestPath() {
+        SkPath path;
+        path.addRect(SkRect::MakeXYWH(SkIntToScalar(0), SkIntToScalar(0),
+                                      SkIntToScalar(2), SkIntToScalar(1)));
+        return path;
+    }
+    static SkPath TestNearlyZeroLengthPath() {
+        SkPath path;
+        SkPoint pt1 = { 0, 0 };
+        SkPoint pt2 = { 0, SK_ScalarNearlyZero };
+        SkPoint pt3 = { SkIntToScalar(1), 0 };
+        SkPoint pt4 = { SkIntToScalar(1), SK_ScalarNearlyZero/2 };
+        path.moveTo(pt1);
+        path.lineTo(pt2);
+        path.lineTo(pt3);
+        path.lineTo(pt4);
+        return path;
+    }
+    static SkRegion TestRegion() {
+        SkRegion region;
+        SkIRect rect = SkIRect::MakeXYWH(0, 0, 2, 1);
+        region.setRect(rect);
+        return region;
+    }
+    static SkBitmap TestBitmap() {
+        SkBitmap bitmap;
+        createBitmap(&bitmap, 0x05060708);
+        return bitmap;
+    }
+};
+
 static bool equal_clips(const SkCanvas& a, const SkCanvas& b) {
     if (a.isClipEmpty()) {
         return b.isClipEmpty();
     }
     if (!a.isClipRect()) {
         // this is liberally true, since we don't expose a way to know this exactly (for non-rects)
         return !b.isClipRect();
     }
     SkIRect ar, br;
     a.getClipDeviceBounds(&ar);
@@ skipping 25 matching lines @@
     SkBitmap bm;
     bm.setInfo(SkImageInfo::MakeN32Premul(size.width(), size.height()));
     SkCanvas c(bm);
 
     Canvas2CanvasClipVisitor visitor(&c);
     canvas->replayClips(&visitor);
 
     REPORTER_ASSERT(reporter, equal_clips(c, *canvas));
 }
 
-static const int kWidth = 2;
-static const int kHeight = 2;
-
 // 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
 // disambiguating the error in the case of failures that are reported in
 // 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 =
     "Drawing test step %s with SkCanvas";
 static const char* const kDeferredDrawAssertMessageFormat =
     "Drawing test step %s with SkDeferredCanvas";
@@ skipping 13 matching lines @@
     "test step %s, SkProxyCanvas indirect canvas state consistency";
 static const char* const kNWayStateAssertMessageFormat =
     "test step %s, SkNWayCanvas state consistency";
 static const char* const kNWayIndirect1StateAssertMessageFormat =
     "test step %s, SkNWayCanvas indirect canvas 1 state consistency";
 static const char* const kNWayIndirect2StateAssertMessageFormat =
     "test step %s, SkNWayCanvas indirect canvas 2 state consistency";
 static const char* const kPdfAssertMessageFormat =
     "PDF sanity check failed %s";
 
-static void createBitmap(SkBitmap* bm, SkColor color) {
-    bm->allocN32Pixels(kWidth, kHeight);
-    bm->eraseColor(color);
-}
-
-static SkSurface* createSurface(SkColor color) {
-    SkSurface* surface = SkSurface::NewRasterPMColor(kWidth, kHeight);
-    surface->getCanvas()->clear(color);
-    return surface;
-}
-
 class CanvasTestStep;
 static SkTDArray<CanvasTestStep*>& testStepArray() {
     static SkTDArray<CanvasTestStep*> theTests;
     return theTests;
 }
 
 class CanvasTestStep {
 public:
     CanvasTestStep(bool fEnablePdfTesting = true) {
         *testStepArray().append() = this;
         fAssertMessageFormat = kDefaultAssertMessageFormat;
         this->fEnablePdfTesting = fEnablePdfTesting;
     }
     virtual ~CanvasTestStep() { }
 
-    virtual void draw(SkCanvas*, skiatest::Reporter*) = 0;
+    virtual void draw(SkCanvas*, const TestData&, skiatest::Reporter*) = 0;
     virtual const char* name() const = 0;
 
     const char* assertMessage() {
         fAssertMessage.printf(fAssertMessageFormat, name());
         return fAssertMessage.c_str();
     }
 
     void setAssertMessageFormat(const char* format) {
         fAssertMessageFormat = format;
     }
 
     bool enablePdfTesting() { return fEnablePdfTesting; }
 
 private:
     SkString fAssertMessage;
     const char* fAssertMessageFormat;
     bool fEnablePdfTesting;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
-// Constants used by test steps
-
-const SkRect kTestRect =
-    SkRect::MakeXYWH(SkIntToScalar(0), SkIntToScalar(0),
-                     SkIntToScalar(2), SkIntToScalar(1));
-static SkMatrix testMatrix() {
-    SkMatrix matrix;
-    matrix.reset();
-    matrix.setScale(SkIntToScalar(2), SkIntToScalar(3));
-    return matrix;
-}
-const SkMatrix kTestMatrix = testMatrix();
-static SkPath test_path() {
-    SkPath path;
-    path.addRect(SkRect::MakeXYWH(SkIntToScalar(0), SkIntToScalar(0),
-                                  SkIntToScalar(2), SkIntToScalar(1)));
-    return path;
-}
-const SkPath kTestPath = test_path();
-static SkPath test_nearly_zero_length_path() {
-    SkPath path;
-    SkPoint pt1 = { 0, 0 };
-    SkPoint pt2 = { 0, SK_ScalarNearlyZero };
-    SkPoint pt3 = { SkIntToScalar(1), 0 };
-    SkPoint pt4 = { SkIntToScalar(1), SK_ScalarNearlyZero/2 };
-    path.moveTo(pt1);
-    path.lineTo(pt2);
-    path.lineTo(pt3);
-    path.lineTo(pt4);
-    return path;
-}
-const SkPath kNearlyZeroLengthPath = test_nearly_zero_length_path();
-static SkRegion testRegion() {
-    SkRegion region;
-    SkIRect rect = SkIRect::MakeXYWH(0, 0, 2, 1);
-    region.setRect(rect);
-    return region;
-}
-const SkIRect kTestIRect = SkIRect::MakeXYWH(0, 0, 2, 1);
-const SkRegion kTestRegion = testRegion();
-const SkColor kTestColor = 0x01020304;
-const SkPaint kTestPaint;
-const SkPoint kTestPoints[3] = {
-    {SkIntToScalar(0), SkIntToScalar(0)},
-    {SkIntToScalar(2), SkIntToScalar(1)},
-    {SkIntToScalar(0), SkIntToScalar(2)}
-};
-const size_t kTestPointCount = 3;
-static SkBitmap testBitmap() {
-    SkBitmap bitmap;
-    createBitmap(&bitmap, 0x05060708);
-    return bitmap;
-}
-SkBitmap kTestBitmap; // cannot be created during static init
-SkString kTestText("Hello World");
-SkPoint kTestPoints2[] = {
-  { SkIntToScalar(0), SkIntToScalar(1) },
-  { SkIntToScalar(1), SkIntToScalar(1) },
-  { SkIntToScalar(2), SkIntToScalar(1) },
-  { SkIntToScalar(3), SkIntToScalar(1) },
-  { SkIntToScalar(4), SkIntToScalar(1) },
-  { SkIntToScalar(5), SkIntToScalar(1) },
-  { SkIntToScalar(6), SkIntToScalar(1) },
-  { SkIntToScalar(7), SkIntToScalar(1) },
-  { SkIntToScalar(8), SkIntToScalar(1) },
-  { SkIntToScalar(9), SkIntToScalar(1) },
-  { SkIntToScalar(10), SkIntToScalar(1) },
-};
-
-
-///////////////////////////////////////////////////////////////////////////////
 // Macros for defining test steps
 
 #define TEST_STEP(NAME, FUNCTION)                                       \
 class NAME##_TestStep : public CanvasTestStep{                          \
 public:                                                                 \
-    virtual void draw(SkCanvas* canvas, skiatest::Reporter* reporter) { \
-        FUNCTION (canvas, reporter, this);                              \
+    virtual void draw(SkCanvas* canvas, const TestData& d,       \
+        skiatest::Reporter* reporter) {                                 \
+        FUNCTION (canvas, d, reporter, this);                    \
     }                                                                   \
     virtual const char* name() const {return #NAME ;}                   \
 };                                                                      \
 static NAME##_TestStep NAME##_TestStepInstance;
 
-#define TEST_STEP_NO_PDF(NAME, FUNCTION)                                       \
+#define TEST_STEP_NO_PDF(NAME, FUNCTION)                                \
 class NAME##_TestStep : public CanvasTestStep{                          \
 public:                                                                 \
     NAME##_TestStep() : CanvasTestStep(false) {}                        \
-    virtual void draw(SkCanvas* canvas, skiatest::Reporter* reporter) { \
-        FUNCTION (canvas, reporter, this);                              \
+    virtual void draw(SkCanvas* canvas, const TestData& d,       \
+        skiatest::Reporter* reporter) {                                 \
+        FUNCTION (canvas, d, reporter, this);                    \
     }                                                                   \
     virtual const char* name() const {return #NAME ;}                   \
 };                                                                      \
 static NAME##_TestStep NAME##_TestStepInstance;
 
-#define SIMPLE_TEST_STEP(NAME, CALL)                              \
-static void NAME##TestStep(SkCanvas* canvas, skiatest::Reporter*, \
-    CanvasTestStep*) {                                            \
-    canvas-> CALL ;                                               \
-}                                                                 \
+#define SIMPLE_TEST_STEP(NAME, CALL)                                    \
+static void NAME##TestStep(SkCanvas* canvas, const TestData& d,  \
+    skiatest::Reporter*, CanvasTestStep*) {                             \
+    canvas-> CALL ;                                                     \
+}                                                                       \
 TEST_STEP(NAME, NAME##TestStep )
 
 #define SIMPLE_TEST_STEP_WITH_ASSERT(NAME, CALL)                           \
-static void NAME##TestStep(SkCanvas* canvas, skiatest::Reporter* reporter, \
-    CanvasTestStep* testStep) {                                            \
+static void NAME##TestStep(SkCanvas* canvas, const TestData& d,     \
+    skiatest::Reporter*, CanvasTestStep* testStep) {                       \
     REPORTER_ASSERT_MESSAGE(reporter, canvas-> CALL ,                      \
         testStep->assertMessage());                                        \
 }                                                                          \
 TEST_STEP(NAME, NAME##TestStep )
 
 
 ///////////////////////////////////////////////////////////////////////////////
 // Basic test steps for most virtual methods in SkCanvas that draw or affect
 // the state of the canvas.
 
 SIMPLE_TEST_STEP(Translate, translate(SkIntToScalar(1), SkIntToScalar(2)));
 SIMPLE_TEST_STEP(Scale, scale(SkIntToScalar(1), SkIntToScalar(2)));
 SIMPLE_TEST_STEP(Rotate, rotate(SkIntToScalar(1)));
 SIMPLE_TEST_STEP(Skew, skew(SkIntToScalar(1), SkIntToScalar(2)));
-SIMPLE_TEST_STEP(Concat, concat(kTestMatrix));
-SIMPLE_TEST_STEP(SetMatrix, setMatrix(kTestMatrix));
-SIMPLE_TEST_STEP(ClipRect, clipRect(kTestRect));
-SIMPLE_TEST_STEP(ClipPath, clipPath(kTestPath));
-SIMPLE_TEST_STEP(ClipRegion,
-    clipRegion(kTestRegion, SkRegion::kReplace_Op));
-SIMPLE_TEST_STEP(Clear, clear(kTestColor));
-SIMPLE_TEST_STEP(DrawPaint, drawPaint(kTestPaint));
+SIMPLE_TEST_STEP(Concat, concat(d.fMatrix));
+SIMPLE_TEST_STEP(SetMatrix, setMatrix(d.fMatrix));
+SIMPLE_TEST_STEP(ClipRect, clipRect(d.fRect));
+SIMPLE_TEST_STEP(ClipPath, clipPath(d.fPath));
+SIMPLE_TEST_STEP(ClipRegion, clipRegion(d.fRegion, SkRegion::kReplace_Op));
+SIMPLE_TEST_STEP(Clear, clear(d.fColor));
+SIMPLE_TEST_STEP(DrawPaint, drawPaint(d.fPaint));
 SIMPLE_TEST_STEP(DrawPointsPoints, drawPoints(SkCanvas::kPoints_PointMode,
-    kTestPointCount, kTestPoints, kTestPaint));
+    d.fPointCount, d.fPoints, d.fPaint));
 SIMPLE_TEST_STEP(DrawPointsLiness, drawPoints(SkCanvas::kLines_PointMode,
-    kTestPointCount, kTestPoints, kTestPaint));
+    d.fPointCount, d.fPoints, d.fPaint));
 SIMPLE_TEST_STEP(DrawPointsPolygon, drawPoints(SkCanvas::kPolygon_PointMode,
-    kTestPointCount, kTestPoints, kTestPaint));
-SIMPLE_TEST_STEP(DrawRect, drawRect(kTestRect, kTestPaint));
-SIMPLE_TEST_STEP(DrawPath, drawPath(kTestPath, kTestPaint));
-SIMPLE_TEST_STEP(DrawBitmap, drawBitmap(kTestBitmap, 0, 0));
-SIMPLE_TEST_STEP(DrawBitmapPaint, drawBitmap(kTestBitmap, 0, 0, &kTestPaint));
-SIMPLE_TEST_STEP(DrawBitmapRect, drawBitmapRect(kTestBitmap, NULL, kTestRect,
-    NULL));
-SIMPLE_TEST_STEP(DrawBitmapRectSrcRect, drawBitmapRect(kTestBitmap,
-    &kTestIRect, kTestRect, NULL));
-SIMPLE_TEST_STEP(DrawBitmapRectPaint, drawBitmapRect(kTestBitmap, NULL,
-    kTestRect, &kTestPaint));
-SIMPLE_TEST_STEP(DrawBitmapMatrix, drawBitmapMatrix(kTestBitmap, kTestMatrix,
-    NULL));
-SIMPLE_TEST_STEP(DrawBitmapMatrixPaint, drawBitmapMatrix(kTestBitmap,
-    kTestMatrix, &kTestPaint));
-SIMPLE_TEST_STEP(DrawBitmapNine, drawBitmapNine(kTestBitmap, kTestIRect,
-    kTestRect, NULL));
-SIMPLE_TEST_STEP(DrawBitmapNinePaint, drawBitmapNine(kTestBitmap, kTestIRect,
-    kTestRect, &kTestPaint));
-SIMPLE_TEST_STEP(DrawSprite, drawSprite(kTestBitmap, 0, 0, NULL));
-SIMPLE_TEST_STEP(DrawSpritePaint, drawSprite(kTestBitmap, 0, 0, &kTestPaint));
-SIMPLE_TEST_STEP(DrawText, drawText(kTestText.c_str(), kTestText.size(),
-    0, 1, kTestPaint));
-SIMPLE_TEST_STEP(DrawPosText, drawPosText(kTestText.c_str(),
-    kTestText.size(), kTestPoints2, kTestPaint));
-SIMPLE_TEST_STEP(DrawTextOnPath, drawTextOnPath(kTestText.c_str(),
-    kTestText.size(), kTestPath, NULL, kTestPaint));
-SIMPLE_TEST_STEP(DrawTextOnPathMatrix, drawTextOnPath(kTestText.c_str(),
-    kTestText.size(), kTestPath, &kTestMatrix, kTestPaint));
-SIMPLE_TEST_STEP(DrawData, drawData(kTestText.c_str(), kTestText.size()));
-SIMPLE_TEST_STEP(BeginGroup, beginCommentGroup(kTestText.c_str()));
-SIMPLE_TEST_STEP(AddComment, addComment(kTestText.c_str(), kTestText.c_str()));
+    d.fPointCount, d.fPoints, d.fPaint));
+SIMPLE_TEST_STEP(DrawRect, drawRect(d.fRect, d.fPaint));
+SIMPLE_TEST_STEP(DrawPath, drawPath(d.fPath, d.fPaint));
+SIMPLE_TEST_STEP(DrawBitmap, drawBitmap(d.fBitmap, 0, 0));
+SIMPLE_TEST_STEP(DrawBitmapPaint, drawBitmap(d.fBitmap, 0, 0, &d.fPaint));
+SIMPLE_TEST_STEP(DrawBitmapRect, drawBitmapRect(d.fBitmap, NULL, d.fRect, NULL));
+SIMPLE_TEST_STEP(DrawBitmapRectSrcRect, drawBitmapRect(d.fBitmap, &d.fIRect, d.fRect, NULL));
+SIMPLE_TEST_STEP(DrawBitmapRectPaint, drawBitmapRect(d.fBitmap, NULL, d.fRect, &d.fPaint));
+SIMPLE_TEST_STEP(DrawBitmapMatrix, drawBitmapMatrix(d.fBitmap, d.fMatrix, NULL));
+SIMPLE_TEST_STEP(DrawBitmapMatrixPaint, drawBitmapMatrix(d.fBitmap, d.fMatrix, &d.fPaint));
+SIMPLE_TEST_STEP(DrawBitmapNine, drawBitmapNine(d.fBitmap, d.fIRect, d.fRect, NULL));
+SIMPLE_TEST_STEP(DrawBitmapNinePaint, drawBitmapNine(d.fBitmap, d.fIRect, d.fRect, &d.fPaint));
+SIMPLE_TEST_STEP(DrawSprite, drawSprite(d.fBitmap, 0, 0, NULL));
+SIMPLE_TEST_STEP(DrawSpritePaint, drawSprite(d.fBitmap, 0, 0, &d.fPaint));
+SIMPLE_TEST_STEP(DrawText, drawText(d.fText.c_str(), d.fText.size(), 0, 1, d.fPaint));
+SIMPLE_TEST_STEP(DrawPosText, drawPosText(d.fText.c_str(), d.fText.size(), d.fPoints2, d.fPaint));
+SIMPLE_TEST_STEP(DrawTextOnPath, drawTextOnPath(d.fText.c_str(), d.fText.size(),
+                                                d.fPath, NULL, d.fPaint));
+SIMPLE_TEST_STEP(DrawTextOnPathMatrix, drawTextOnPath(d.fText.c_str(), d.fText.size(), d.fPath,
+                                                      &d.fMatrix, d.fPaint));
+SIMPLE_TEST_STEP(DrawData, drawData(d.fText.c_str(), d.fText.size()));
+SIMPLE_TEST_STEP(BeginGroup, beginCommentGroup(d.fText.c_str()));
+SIMPLE_TEST_STEP(AddComment, addComment(d.fText.c_str(), d.fText.c_str()));
 SIMPLE_TEST_STEP(EndGroup, endCommentGroup());
 
 ///////////////////////////////////////////////////////////////////////////////
 // Complex test steps
 
-static void SaveMatrixClipStep(SkCanvas* canvas,
-                               skiatest::Reporter* reporter,
-                               CanvasTestStep* testStep) {
+static void SaveMatrixClipStep(SkCanvas* canvas, const TestData& d,
+                               skiatest::Reporter* reporter, CanvasTestStep* testStep) {
     int saveCount = canvas->getSaveCount();
     canvas->save();
     canvas->translate(SkIntToScalar(1), SkIntToScalar(2));
-    canvas->clipRegion(kTestRegion);
+    canvas->clipRegion(d.fRegion);
     canvas->restore();
     REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
         testStep->assertMessage());
     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,
-                          skiatest::Reporter* reporter,
-                          CanvasTestStep* testStep) {
+static void SaveLayerStep(SkCanvas* canvas, const TestData& d,
+                          skiatest::Reporter* reporter, CanvasTestStep* testStep) {
     int saveCount = canvas->getSaveCount();
     canvas->saveLayer(NULL, NULL);
     canvas->restore();
     REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
         testStep->assertMessage());
 }
 TEST_STEP(SaveLayer, SaveLayerStep);
 
-static void BoundedSaveLayerStep(SkCanvas* canvas,
-                          skiatest::Reporter* reporter,
-                          CanvasTestStep* testStep) {
+static void BoundedSaveLayerStep(SkCanvas* canvas, const TestData& d,
+                                 skiatest::Reporter* reporter, CanvasTestStep* testStep) {
     int saveCount = canvas->getSaveCount();
-    canvas->saveLayer(&kTestRect, NULL);
+    canvas->saveLayer(&d.fRect, NULL);
     canvas->restore();
     REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
         testStep->assertMessage());
 }
 TEST_STEP(BoundedSaveLayer, BoundedSaveLayerStep);
 
-static void PaintSaveLayerStep(SkCanvas* canvas,
-                          skiatest::Reporter* reporter,
-                          CanvasTestStep* testStep) {
+static void PaintSaveLayerStep(SkCanvas* canvas, const TestData& d,
+                               skiatest::Reporter* reporter, CanvasTestStep* testStep) {
     int saveCount = canvas->getSaveCount();
-    canvas->saveLayer(NULL, &kTestPaint);
+    canvas->saveLayer(NULL, &d.fPaint);
     canvas->restore();
     REPORTER_ASSERT_MESSAGE(reporter, canvas->getSaveCount() == saveCount,
         testStep->assertMessage());
 }
 TEST_STEP(PaintSaveLayer, PaintSaveLayerStep);
 
-static void TwoClipOpsStep(SkCanvas* canvas,
-                           skiatest::Reporter*,
-                           CanvasTestStep*) {
+static void TwoClipOpsStep(SkCanvas* canvas, const TestData& d,
+                           skiatest::Reporter*, CanvasTestStep*) {
     // This test exercises a functionality in SkPicture that leads to the
     // 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);
-    canvas->clipRegion(kTestRegion);
+    canvas->clipRect(d.fRect);
+    canvas->clipRegion(d.fRegion);
 }
 TEST_STEP(TwoClipOps, TwoClipOpsStep);
 
 // 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,
-                                             skiatest::Reporter*,
-                                             CanvasTestStep*) {
+static void DrawNearlyZeroLengthPathTestStep(SkCanvas* canvas, const TestData& d,
+                                             skiatest::Reporter*, CanvasTestStep*) {
     SkPaint paint;
     paint.setStrokeWidth(SkIntToScalar(1));
     paint.setStyle(SkPaint::kStroke_Style);
 
-    canvas->drawPath(kNearlyZeroLengthPath, paint);
+    canvas->drawPath(d.fNearlyZeroLengthPath, paint);
 }
 TEST_STEP(DrawNearlyZeroLengthPath, DrawNearlyZeroLengthPathTestStep);
 
-static void DrawVerticesShaderTestStep(SkCanvas* canvas,
-                                       skiatest::Reporter*,
-                                       CanvasTestStep*) {
+static void DrawVerticesShaderTestStep(SkCanvas* canvas, const TestData& d,
+                                       skiatest::Reporter*, CanvasTestStep*) {
     SkPoint pts[4];
     pts[0].set(0, 0);
-    pts[1].set(SkIntToScalar(kWidth), 0);
-    pts[2].set(SkIntToScalar(kWidth), SkIntToScalar(kHeight));
-    pts[3].set(0, SkIntToScalar(kHeight));
+    pts[1].set(SkIntToScalar(d.fWidth), 0);
+    pts[2].set(SkIntToScalar(d.fWidth), SkIntToScalar(d.fHeight));
+    pts[3].set(0, SkIntToScalar(d.fHeight));
     SkPaint paint;
-    SkShader* shader = SkShader::CreateBitmapShader(kTestBitmap,
+    SkShader* shader = SkShader::CreateBitmapShader(d.fBitmap,
         SkShader::kClamp_TileMode, SkShader::kClamp_TileMode);
     paint.setShader(shader)->unref();
     canvas->drawVertices(SkCanvas::kTriangleFan_VertexMode, 4, pts, pts,
                          NULL, NULL, NULL, 0, paint);
 }
 // NYI: issue 240.
 TEST_STEP_NO_PDF(DrawVerticesShader, DrawVerticesShaderTestStep);
 
-static void DrawPictureTestStep(SkCanvas* canvas,
-                                skiatest::Reporter*,
-                                CanvasTestStep*) {
+static void DrawPictureTestStep(SkCanvas* canvas, const TestData& d,
+                                skiatest::Reporter*, CanvasTestStep*) {
     SkPictureRecorder recorder;
-    SkCanvas* testCanvas = recorder.beginRecording(SkIntToScalar(kWidth), SkIntToScalar(kHeight),
+    SkCanvas* testCanvas = recorder.beginRecording(SkIntToScalar(d.fWidth), SkIntToScalar(d.fHeight),
                                                    NULL, 0);
     testCanvas->scale(SkIntToScalar(2), SkIntToScalar(1));
-    testCanvas->clipRect(kTestRect);
-    testCanvas->drawRect(kTestRect, kTestPaint);
+    testCanvas->clipRect(d.fRect);
+    testCanvas->drawRect(d.fRect, d.fPaint);
     SkAutoTUnref<SkPicture> testPicture(recorder.endRecording());
 
     canvas->drawPicture(testPicture);
 }
 TEST_STEP(DrawPicture, DrawPictureTestStep);
 
-static void SaveRestoreTestStep(SkCanvas* canvas,
-                                skiatest::Reporter* reporter,
-                                CanvasTestStep* testStep) {
+static void SaveRestoreTestStep(SkCanvas* canvas, const TestData& d,
+                                skiatest::Reporter* reporter, CanvasTestStep* testStep) {
     int baseSaveCount = canvas->getSaveCount();
     int n = canvas->save();
     REPORTER_ASSERT_MESSAGE(reporter, baseSaveCount == n, testStep->assertMessage());
     REPORTER_ASSERT_MESSAGE(reporter, baseSaveCount + 1 == canvas->getSaveCount(),
         testStep->assertMessage());
     canvas->save();
     canvas->save();
     REPORTER_ASSERT_MESSAGE(reporter, baseSaveCount + 3 == canvas->getSaveCount(),
         testStep->assertMessage());
     canvas->restoreToCount(baseSaveCount + 1);
     REPORTER_ASSERT_MESSAGE(reporter, baseSaveCount + 1 == canvas->getSaveCount(),
         testStep->assertMessage());
 
     // should this pin to 1, or be a no-op, or crash?
     canvas->restoreToCount(0);
     REPORTER_ASSERT_MESSAGE(reporter, 1 == canvas->getSaveCount(),
         testStep->assertMessage());
 }
 TEST_STEP(SaveRestore, SaveRestoreTestStep);
 
-static void DrawLayerTestStep(SkCanvas* canvas,
-                              skiatest::Reporter* reporter,
-                              CanvasTestStep* testStep) {
+static void DrawLayerTestStep(SkCanvas* canvas, const TestData& d,
+                              skiatest::Reporter* reporter, CanvasTestStep* testStep) {
     REPORTER_ASSERT_MESSAGE(reporter, !canvas->isDrawingToLayer(),
         testStep->assertMessage());
     canvas->save();
     REPORTER_ASSERT_MESSAGE(reporter, !canvas->isDrawingToLayer(),
         testStep->assertMessage());
     canvas->restore();
 
     const SkRect* bounds = NULL;    // null means include entire bounds
     const SkPaint* paint = NULL;
 
@@ skipping 11 matching lines @@
     canvas->restore();
     REPORTER_ASSERT_MESSAGE(reporter, canvas->isDrawingToLayer(),
         testStep->assertMessage());
     canvas->restore();
     // now layer count should be 0
     REPORTER_ASSERT_MESSAGE(reporter, !canvas->isDrawingToLayer(),
         testStep->assertMessage());
 }
 TEST_STEP(DrawLayer, DrawLayerTestStep);
 
-static void NestedSaveRestoreWithSolidPaintTestStep(SkCanvas* canvas,
-                                      skiatest::Reporter*,
-                                      CanvasTestStep*) {
+static void NestedSaveRestoreWithSolidPaintTestStep(SkCanvas* canvas, const TestData& d,
+                                                    skiatest::Reporter*, CanvasTestStep*) {
     // This test step challenges the TestDeferredCanvasStateConsistency
     // test cases because the opaque paint can trigger an optimization
     // that discards previously recorded commands. The challenge is to maintain
     // correct clip and matrix stack state.
     canvas->resetMatrix();
     canvas->rotate(SkIntToScalar(30));
     canvas->save();
     canvas->translate(SkIntToScalar(2), SkIntToScalar(1));
     canvas->save();
     canvas->scale(SkIntToScalar(3), SkIntToScalar(3));
     SkPaint paint;
     paint.setColor(0xFFFFFFFF);
     canvas->drawPaint(paint);
     canvas->restore();
     canvas->restore();
 }
 TEST_STEP(NestedSaveRestoreWithSolidPaint, \
     NestedSaveRestoreWithSolidPaintTestStep);
 
-static void NestedSaveRestoreWithFlushTestStep(SkCanvas* canvas,
-                                      skiatest::Reporter*,
-                                      CanvasTestStep*) {
+static void NestedSaveRestoreWithFlushTestStep(SkCanvas* canvas, const TestData& d,
+                                               skiatest::Reporter*, CanvasTestStep*) {
     // This test step challenges the TestDeferredCanvasStateConsistency
     // test case because the canvas flush on a deferred canvas will
     // reset the recording session. The challenge is to maintain correct
     // clip and matrix stack state on the playback canvas.
     canvas->resetMatrix();
     canvas->rotate(SkIntToScalar(30));
     canvas->save();
     canvas->translate(SkIntToScalar(2), SkIntToScalar(1));
     canvas->save();
     canvas->scale(SkIntToScalar(3), SkIntToScalar(3));
-    canvas->drawRect(kTestRect,kTestPaint);
+    canvas->drawRect(d.fRect,d.fPaint);
     canvas->flush();
     canvas->restore();
     canvas->restore();
 }
-TEST_STEP(NestedSaveRestoreWithFlush, \
-    NestedSaveRestoreWithFlushTestStep);
+TEST_STEP(NestedSaveRestoreWithFlush, NestedSaveRestoreWithFlushTestStep);
 
-static void AssertCanvasStatesEqual(skiatest::Reporter* reporter,
-                                    const SkCanvas* canvas1,
-                                    const SkCanvas* canvas2,
+static void AssertCanvasStatesEqual(skiatest::Reporter* reporter, const TestData& d,
+                                    const SkCanvas* canvas1, const SkCanvas* canvas2,
                                     CanvasTestStep* testStep) {
     REPORTER_ASSERT_MESSAGE(reporter, canvas1->getDeviceSize() ==
         canvas2->getDeviceSize(), testStep->assertMessage());
     REPORTER_ASSERT_MESSAGE(reporter, canvas1->getSaveCount() ==
         canvas2->getSaveCount(), testStep->assertMessage());
     REPORTER_ASSERT_MESSAGE(reporter, canvas1->isDrawingToLayer() ==
         canvas2->isDrawingToLayer(), testStep->assertMessage());
 
     SkRect bounds1, bounds2;
     REPORTER_ASSERT_MESSAGE(reporter,
@@ skipping 84 matching lines @@
                     (*referenceRecord->fPathHeap)[i] ==
                     (*testRecord->fPathHeap)[i], testStep->assertMessage());
             }
         }
         */
 
     }
 };
 
 static void TestPdfDevice(skiatest::Reporter* reporter,
+                          const TestData& d,
                           CanvasTestStep* testStep) {
-    SkISize pageSize = SkISize::Make(kWidth, kHeight);
+    SkISize pageSize = SkISize::Make(d.fWidth, d.fHeight);
     SkPDFDevice device(pageSize, pageSize, SkMatrix::I());
     SkCanvas canvas(&device);
     testStep->setAssertMessageFormat(kPdfAssertMessageFormat);
-    testStep->draw(&canvas, reporter);
+    testStep->draw(&canvas, d, reporter);
     SkPDFDocument doc;
     doc.appendPage(&device);
     SkDynamicMemoryWStream stream;
     doc.emitPDF(&stream);
 }
 
 // The following class groups static functions that need to access
 // the privates members of SkDeferredCanvas
 class SkDeferredCanvasTester {
 public:
     static void TestDeferredCanvasStateConsistency(
         skiatest::Reporter* reporter,
+        const TestData& d,
         CanvasTestStep* testStep,
         const SkCanvas& referenceCanvas, bool silent) {
 
         SkAutoTUnref<SkSurface> surface(createSurface(0xFFFFFFFF));
         SkAutoTUnref<SkDeferredCanvas> deferredCanvas(SkDeferredCanvas::Create(surface.get()));
 
         testStep->setAssertMessageFormat(kDeferredDrawAssertMessageFormat);
-        testStep->draw(deferredCanvas, reporter);
+        testStep->draw(deferredCanvas, d, reporter);
         testStep->setAssertMessageFormat(kDeferredPreFlushAssertMessageFormat);
-        AssertCanvasStatesEqual(reporter, deferredCanvas, &referenceCanvas,
-            testStep);
+        AssertCanvasStatesEqual(reporter, d, deferredCanvas, &referenceCanvas, testStep);
 
         if (silent) {
             deferredCanvas->silentFlush();
         } else {
             deferredCanvas->flush();
         }
 
         testStep->setAssertMessageFormat(
             silent ? kDeferredPostSilentFlushPlaybackAssertMessageFormat :
             kDeferredPostFlushPlaybackAssertMessageFormat);
-        AssertCanvasStatesEqual(reporter,
-            deferredCanvas->immediateCanvas(),
-            &referenceCanvas, testStep);
+        AssertCanvasStatesEqual(reporter, d, deferredCanvas->immediateCanvas(),
+                                &referenceCanvas, testStep);
 
         // Verified that deferred canvas state is not affected by flushing
         // pending draw operations
 
         // The following test code is commented out because it currently fails.
         // Issue: http://code.google.com/p/skia/issues/detail?id=496
         /*
         testStep->setAssertMessageFormat(kDeferredPostFlushAssertMessageFormat);
         AssertCanvasStatesEqual(reporter, &deferredCanvas, &referenceCanvas,
             testStep);
         */
     }
 };
 
 // unused
 static void TestProxyCanvasStateConsistency(
     skiatest::Reporter* reporter,
+    const TestData& d,
     CanvasTestStep* testStep,
     const SkCanvas& referenceCanvas) {
 
     SkBitmap indirectStore;
     createBitmap(&indirectStore, 0xFFFFFFFF);
     SkCanvas indirectCanvas(indirectStore);
     SkProxyCanvas proxyCanvas(&indirectCanvas);
     testStep->setAssertMessageFormat(kProxyDrawAssertMessageFormat);
-    testStep->draw(&proxyCanvas, reporter);
+    testStep->draw(&proxyCanvas, d, reporter);
     // Verify that the SkProxyCanvas reports consitent state
     testStep->setAssertMessageFormat(kProxyStateAssertMessageFormat);
-    AssertCanvasStatesEqual(reporter, &proxyCanvas, &referenceCanvas,
-        testStep);
+    AssertCanvasStatesEqual(reporter, d, &proxyCanvas, &referenceCanvas, testStep);
     // Verify that the indirect canvas reports consitent state
     testStep->setAssertMessageFormat(kProxyIndirectStateAssertMessageFormat);
-    AssertCanvasStatesEqual(reporter, &indirectCanvas, &referenceCanvas,
-        testStep);
+    AssertCanvasStatesEqual(reporter, d, &indirectCanvas, &referenceCanvas, testStep);
 }
 
 // unused
 static void TestNWayCanvasStateConsistency(
     skiatest::Reporter* reporter,
+    const TestData& d,
     CanvasTestStep* testStep,
     const SkCanvas& referenceCanvas) {
 
     SkBitmap indirectStore1;
     createBitmap(&indirectStore1, 0xFFFFFFFF);
     SkCanvas indirectCanvas1(indirectStore1);
 
     SkBitmap indirectStore2;
     createBitmap(&indirectStore2, 0xFFFFFFFF);
     SkCanvas indirectCanvas2(indirectStore2);
 
     SkISize canvasSize = referenceCanvas.getDeviceSize();
     SkNWayCanvas nWayCanvas(canvasSize.width(), canvasSize.height());
     nWayCanvas.addCanvas(&indirectCanvas1);
     nWayCanvas.addCanvas(&indirectCanvas2);
 
     testStep->setAssertMessageFormat(kNWayDrawAssertMessageFormat);
-    testStep->draw(&nWayCanvas, reporter);
+    testStep->draw(&nWayCanvas, d, reporter);
     // Verify that the SkProxyCanvas reports consitent state
     testStep->setAssertMessageFormat(kNWayStateAssertMessageFormat);
-    AssertCanvasStatesEqual(reporter, &nWayCanvas, &referenceCanvas,
-        testStep);
+    AssertCanvasStatesEqual(reporter, d, &nWayCanvas, &referenceCanvas, testStep);
     // Verify that the indirect canvases report consitent state
     testStep->setAssertMessageFormat(kNWayIndirect1StateAssertMessageFormat);
-    AssertCanvasStatesEqual(reporter, &indirectCanvas1, &referenceCanvas,
-        testStep);
+    AssertCanvasStatesEqual(reporter, d, &indirectCanvas1, &referenceCanvas, testStep);
     testStep->setAssertMessageFormat(kNWayIndirect2StateAssertMessageFormat);
-    AssertCanvasStatesEqual(reporter, &indirectCanvas2, &referenceCanvas,
-        testStep);
+    AssertCanvasStatesEqual(reporter, d, &indirectCanvas2, &referenceCanvas, testStep);
 }
 
 /*
  * This sub-test verifies that the test step passes when executed
  * with SkCanvas and with classes derrived from SkCanvas. It also verifies
  * 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, const TestData& d,
                                          CanvasTestStep* testStep) {
     SkBitmap referenceStore;
     createBitmap(&referenceStore, 0xFFFFFFFF);
     SkCanvas referenceCanvas(referenceStore);
     testStep->setAssertMessageFormat(kCanvasDrawAssertMessageFormat);
-    testStep->draw(&referenceCanvas, reporter);
+    testStep->draw(&referenceCanvas, d, reporter);
 
-    SkDeferredCanvasTester::TestDeferredCanvasStateConsistency(reporter, testStep, referenceCanvas, false);
+    SkDeferredCanvasTester::TestDeferredCanvasStateConsistency(reporter, d, testStep, referenceCanvas, false);
 
-    SkDeferredCanvasTester::TestDeferredCanvasStateConsistency(reporter, testStep, referenceCanvas, true);
+    SkDeferredCanvasTester::TestDeferredCanvasStateConsistency(reporter, d, testStep, referenceCanvas, true);
 
     // The following test code is disabled because SkProxyCanvas is
     // missing a lot of virtual overrides on get* methods, which are used
     // to verify canvas state.
     // Issue: http://code.google.com/p/skia/issues/detail?id=500
 
     if (false) { // avoid bit rot, suppress warning
-        TestProxyCanvasStateConsistency(reporter, testStep, referenceCanvas);
+        TestProxyCanvasStateConsistency(reporter, d, testStep, referenceCanvas);
     }
 
     // The following test code is disabled because SkNWayCanvas does not
     // report correct clipping and device bounds information
     // Issue: http://code.google.com/p/skia/issues/detail?id=501
 
     if (false) { // avoid bit rot, suppress warning
-        TestNWayCanvasStateConsistency(reporter, testStep, referenceCanvas);
+        TestNWayCanvasStateConsistency(reporter, d, testStep, referenceCanvas);
     }
 
     if (false) { // avoid bit rot, suppress warning
         test_clipVisitor(reporter, &referenceCanvas);
     }
 }
 
 static void test_newraster(skiatest::Reporter* reporter) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(10, 10);
     SkCanvas* canvas = SkCanvas::NewRaster(info);
@@ skipping 25 matching lines @@
     REPORTER_ASSERT(reporter, NULL == SkCanvas::NewRaster(info));
 
     // We should succeed with a zero-sized valid info
     info = SkImageInfo::MakeN32Premul(0, 0);
     canvas = SkCanvas::NewRaster(info);
     REPORTER_ASSERT(reporter, canvas);
     SkDELETE(canvas);
 }
 
 DEF_TEST(Canvas, reporter) {
-    // Init global here because bitmap pixels cannot be alocated during
-    // static initialization
-    kTestBitmap = testBitmap();
+    TestData d;
 
     for (int testStep = 0; testStep < testStepArray().count(); testStep++) {
-        TestOverrideStateConsistency(reporter, testStepArray()[testStep]);
+        TestOverrideStateConsistency(reporter, d, testStepArray()[testStep]);
         if (testStepArray()[testStep]->enablePdfTesting()) {
-            TestPdfDevice(reporter, testStepArray()[testStep]);
+            TestPdfDevice(reporter, d, testStepArray()[testStep]);
         }
     }
 
-    // Explicitly call reset(), so we don't leak the pixels (since kTestBitmap is a global)
-    kTestBitmap.reset();
-
     test_newraster(reporter);
 }