Make GPU unit tests use GrContexts of different GL types.

Review URL: https://codereview.appspot.com/7281046

git-svn-id: http://skia.googlecode.com/svn/trunk@7540 2bbb7eff-a529-9590-31e7-b0007b416f81

12 files changed, 430 insertions, 352 deletions

diff --git a/tests/ClipCacheTest.cpp b/tests/ClipCacheTest.cpp
index c80ba631da..aebbef5952 100644
--- a/tests/ClipCacheTest.cpp
+++ b/tests/ClipCacheTest.cpp
@@ -9,6 +9,7 @@
 #include "Test.h"
 // This is a GR test
 #if SK_SUPPORT_GPU
+#include "GrContextFactory.h"
 #include "SkGpuDevice.h"
 #include "../../src/gpu/GrClipMaskManager.h"
 
@@ -216,10 +217,20 @@ static void test_cache(skiatest::Reporter* reporter, GrContext* context) {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-static void TestClipCache(skiatest::Reporter* reporter, GrContext* context) {
-
-    test_cache(reporter, context);
-    test_clip_bounds(reporter, context);
+static void TestClipCache(skiatest::Reporter* reporter, GrContextFactory* factory) {
+    for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) {
+        GrContextFactory::GLContextType glType = static_cast<GrContextFactory::GLContextType>(type);
+        if (!GrContextFactory::IsRenderingGLContext(glType)) {
+            continue;
+        }
+        GrContext* context = factory->get(glType);
+        if (NULL == context) {
+            continue;
+        }
+
+        test_cache(reporter, context);
+        test_clip_bounds(reporter, context);
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp
index 3106377d84..b93f9c3269 100644
--- a/tests/GLProgramsTest.cpp
+++ b/tests/GLProgramsTest.cpp
@@ -14,6 +14,7 @@
 
 #include "gl/GrGpuGL.h"
 #include "GrBackendEffectFactory.h"
+#include "GrContextFactory.h"
 #include "effects/GrConfigConversionEffect.h"
 
 #include "SkRandom.h"
@@ -147,9 +148,14 @@ bool GrGpuGL::programUnitTest() {
     return true;
 }
 
-static void GLProgramsTest(skiatest::Reporter* reporter, GrContext* context) {
-    GrGpuGL* shadersGpu = static_cast<GrGpuGL*>(context->getGpu());
-    REPORTER_ASSERT(reporter, shadersGpu->programUnitTest());
+static void GLProgramsTest(skiatest::Reporter* reporter, GrContextFactory* factory) {
+    for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) {
+        GrContext* context = factory->get(static_cast<GrContextFactory::GLContextType>(type));
+        if (NULL != context) {
+            GrGpuGL* shadersGpu = static_cast<GrGpuGL*>(context->getGpu());
+            REPORTER_ASSERT(reporter, shadersGpu->programUnitTest());
+        }
+    }
 }
 
 #include "TestClassDef.h"
diff --git a/tests/GpuBitmapCopyTest.cpp b/tests/GpuBitmapCopyTest.cpp
index 63e3cca4bc..74299da4e6 100644
--- a/tests/GpuBitmapCopyTest.cpp
+++ b/tests/GpuBitmapCopyTest.cpp
@@ -9,6 +9,7 @@
 #if SK_SUPPORT_GPU
 
 #include "GrContext.h"
+#include "GrContextFactory.h"
 #include "SkBitmap.h"
 #include "SkCanvas.h"
 #include "SkColor.h"
@@ -117,88 +118,106 @@ static void TestIndividualCopy(skiatest::Reporter* reporter, const SkBitmap::Con
 
 // Stripped down version of TestBitmapCopy that checks basic fields (width, height, config, genID)
 // to ensure that they were copied properly.
-static void TestGpuBitmapCopy(skiatest::Reporter* reporter, GrContext* grContext) {
+static void TestGpuBitmapCopy(skiatest::Reporter* reporter, GrContextFactory* factory) {
 #ifdef SK_BUILD_FOR_ANDROID // https://code.google.com/p/skia/issues/detail?id=753
     return;
 #endif
-    if (NULL == grContext) {
-        return;
-    }
-    static const Pair gPairs[] = {
-        { SkBitmap::kNo_Config,         "000"  },
-        { SkBitmap::kARGB_4444_Config,  "011"  },
-        { SkBitmap::kARGB_8888_Config,  "011"  },
-    };
-
-    const int W = 20;
-    const int H = 33;
-
-    for (size_t i = 0; i < SK_ARRAY_COUNT(gPairs); i++) {
-        SkBitmap src, dst;
-
-        SkGpuDevice* device = SkNEW_ARGS(SkGpuDevice, (grContext, gPairs[i].fConfig, W, H));
-        SkAutoUnref aur(device);
-        src = device->accessBitmap(false);
-        device->clear(SK_ColorWHITE);
-
-        // Draw something different to the same portion of the bitmap that we will extract as a
-        // subset, so that comparing the pixels of the subset will be meaningful.
-        SkIRect subsetRect = SkIRect::MakeLTRB(W/2, H/2, W, H);
-        SkCanvas drawingCanvas(device);
-        SkPaint paint;
-        paint.setColor(SK_ColorRED);
-        drawingCanvas.drawRect(SkRect::MakeFromIRect(subsetRect), paint);
-
-        // Extract a subset. If this succeeds we will test copying the subset.
-        SkBitmap subset;
-        const bool extracted = src.extractSubset(&subset, subsetRect);
-        if (extracted) {
-            TestSubsetHelpers(reporter, subset);
+    for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) {
+        GrContextFactory::GLContextType glType = static_cast<GrContextFactory::GLContextType>(type);
+        if (!GrContextFactory::IsRenderingGLContext(glType)) {
+            continue;
         }
+#if SK_ANGLE // This test breaks ANGLE: memcmps fail and readpixels return value is false.
+        if (type == GrContextFactory::kANGLE_GLContextType) {
+            continue;
+        }
+#endif
 
-        for (size_t j = 0; j < SK_ARRAY_COUNT(gPairs); j++) {
-            dst.reset();
-            bool success = src.deepCopyTo(&dst, gPairs[j].fConfig);
-            bool expected = gPairs[i].fValid[j] != '0';
-            if (success != expected) {
-                SkString str;
-                str.printf("SkBitmap::deepCopyTo from %s to %s. expected %s returned %s",
-                           gConfigName[i], gConfigName[j], boolStr(expected),
-                           boolStr(success));
-                reporter->reportFailed(str);
-            }
-
-            bool canSucceed = src.canCopyTo(gPairs[j].fConfig);
-            if (success != canSucceed) {
-                SkString str;
-                str.printf("SkBitmap::deepCopyTo from %s to %s returned %s,"
-                           "but canCopyTo returned %s",
-                           gConfigName[i], gConfigName[j], boolStr(success),
-                           boolStr(canSucceed));
-                reporter->reportFailed(str);
-            }
+        GrContext* grContext = factory->get(glType);
+        if (NULL == grContext) {
+            continue;
+        }
 
-            TestIndividualCopy(reporter, gPairs[j].fConfig, success, src, dst);
 
-            // Test copying the subset bitmap, using both copyTo and deepCopyTo.
+        if (NULL == grContext) {
+            return;
+        }
+        static const Pair gPairs[] = {
+            { SkBitmap::kNo_Config,         "000"  },
+            { SkBitmap::kARGB_4444_Config,  "011"  },
+            { SkBitmap::kARGB_8888_Config,  "011"  },
+        };
+
+        const int W = 20;
+        const int H = 33;
+
+        for (size_t i = 0; i < SK_ARRAY_COUNT(gPairs); i++) {
+            SkBitmap src, dst;
+
+            SkGpuDevice* device = SkNEW_ARGS(SkGpuDevice, (grContext, gPairs[i].fConfig, W, H));
+            SkAutoUnref aur(device);
+            src = device->accessBitmap(false);
+            device->clear(SK_ColorWHITE);
+
+            // Draw something different to the same portion of the bitmap that we will extract as a
+            // subset, so that comparing the pixels of the subset will be meaningful.
+            SkIRect subsetRect = SkIRect::MakeLTRB(W/2, H/2, W, H);
+            SkCanvas drawingCanvas(device);
+            SkPaint paint;
+            paint.setColor(SK_ColorRED);
+            drawingCanvas.drawRect(SkRect::MakeFromIRect(subsetRect), paint);
+
+            // Extract a subset. If this succeeds we will test copying the subset.
+            SkBitmap subset;
+            const bool extracted = src.extractSubset(&subset, subsetRect);
             if (extracted) {
-                SkBitmap subsetCopy;
-                success = subset.copyTo(&subsetCopy, gPairs[j].fConfig);
-                REPORTER_ASSERT(reporter, success == expected);
-                REPORTER_ASSERT(reporter, success == canSucceed);
-                TestIndividualCopy(reporter, gPairs[j].fConfig, success, subset, subsetCopy, false,
-                                   &subsetRect);
-
-                // Reset the bitmap so that a failed copyTo will leave it in the expected state.
-                subsetCopy.reset();
-                success = subset.deepCopyTo(&subsetCopy, gPairs[j].fConfig);
-                REPORTER_ASSERT(reporter, success == expected);
-                REPORTER_ASSERT(reporter, success == canSucceed);
-                TestIndividualCopy(reporter, gPairs[j].fConfig, success, subset, subsetCopy, true,
-                                   &subsetRect);
+                TestSubsetHelpers(reporter, subset);
             }
-        } // for (size_t j = ...
-    } // for (size_t i = ...
+
+            for (size_t j = 0; j < SK_ARRAY_COUNT(gPairs); j++) {
+                dst.reset();
+                bool success = src.deepCopyTo(&dst, gPairs[j].fConfig);
+                bool expected = gPairs[i].fValid[j] != '0';
+                if (success != expected) {
+                    SkString str;
+                    str.printf("SkBitmap::deepCopyTo from %s to %s. expected %s returned %s",
+                               gConfigName[i], gConfigName[j], boolStr(expected),
+                               boolStr(success));
+                    reporter->reportFailed(str);
+                }
+
+                bool canSucceed = src.canCopyTo(gPairs[j].fConfig);
+                if (success != canSucceed) {
+                    SkString str;
+                    str.printf("SkBitmap::deepCopyTo from %s to %s returned %s,"
+                               "but canCopyTo returned %s",
+                               gConfigName[i], gConfigName[j], boolStr(success),
+                               boolStr(canSucceed));
+                    reporter->reportFailed(str);
+                }
+
+                TestIndividualCopy(reporter, gPairs[j].fConfig, success, src, dst);
+
+                // Test copying the subset bitmap, using both copyTo and deepCopyTo.
+                if (extracted) {
+                    SkBitmap subsetCopy;
+                    success = subset.copyTo(&subsetCopy, gPairs[j].fConfig);
+                    REPORTER_ASSERT(reporter, success == expected);
+                    REPORTER_ASSERT(reporter, success == canSucceed);
+                    TestIndividualCopy(reporter, gPairs[j].fConfig, success, subset, subsetCopy, false,
+                                       &subsetRect);
+
+                    // Reset the bitmap so that a failed copyTo will leave it in the expected state.
+                    subsetCopy.reset();
+                    success = subset.deepCopyTo(&subsetCopy, gPairs[j].fConfig);
+                    REPORTER_ASSERT(reporter, success == expected);
+                    REPORTER_ASSERT(reporter, success == canSucceed);
+                    TestIndividualCopy(reporter, gPairs[j].fConfig, success, subset, subsetCopy, true,
+                                       &subsetRect);
+                }
+            } // for (size_t j = ...
+        } // for (size_t i = ...
+    } // GrContextFactory::GLContextType
 }
 
 #include "TestClassDef.h"
diff --git a/tests/HashCacheTest.cpp b/tests/HashCacheTest.cpp
index f26dd8abec..d58b86c046 100644
--- a/tests/HashCacheTest.cpp
+++ b/tests/HashCacheTest.cpp
@@ -63,7 +63,7 @@ protected:
 };
 
 ////////////////////////////////////////////////////////////////////////////////
-static void TestHashCache(skiatest::Reporter* reporter, GrContext* context) {
+static void TestHashCache(skiatest::Reporter* reporter) {
 
     GrTHashTable<HashElement, HashKey, 4> cache;
 
@@ -165,6 +165,6 @@ static void TestHashCache(skiatest::Reporter* reporter, GrContext* context) {
 
 ////////////////////////////////////////////////////////////////////////////////
 #include "TestClassDef.h"
-DEFINE_GPUTESTCLASS("HashCache", HashCacheTestClass, TestHashCache)
+DEFINE_TESTCLASS("HashCache", HashCacheTestClass, TestHashCache)
 
 #endif
diff --git a/tests/PremulAlphaRoundTripTest.cpp b/tests/PremulAlphaRoundTripTest.cpp
index 8321c940b9..b25d35834d 100644
--- a/tests/PremulAlphaRoundTripTest.cpp
+++ b/tests/PremulAlphaRoundTripTest.cpp
@@ -12,6 +12,7 @@
 #include "SkDevice.h"
 
 #if SK_SUPPORT_GPU
+#include "GrContextFactory.h"
 #include "SkGpuDevice.h"
 #endif
 
@@ -46,61 +47,75 @@ static const SkCanvas::Config8888 gUnpremulConfigs[] = {
     SkCanvas::kRGBA_Unpremul_Config8888,
 };
 
-void PremulAlphaRoundTripTest(skiatest::Reporter* reporter,
-                              GrContext* context) {
+void PremulAlphaRoundTripTest(skiatest::Reporter* reporter, GrContextFactory* factory) {
     SkAutoTUnref<SkDevice> device;
     for (int dtype = 0; dtype < 2; ++dtype) {
-        if (0 == dtype) {
-            device.reset(new SkDevice(SkBitmap::kARGB_8888_Config,
-                                          256,
-                                          256,
-                                          false));
-        } else {
-#if !SK_SUPPORT_GPU || defined(SK_SCALAR_IS_FIXED)
-            // GPU device known not to work in the fixed pt build.
-            continue;
+
+        int glCtxTypeCnt = 1;
+#if SK_SUPPORT_GPU
+        if (0 != dtype)  {
+            glCtxTypeCnt = GrContextFactory::kGLContextTypeCnt;
+        }
+#endif
+        for (int glCtxType = 0; glCtxType < glCtxTypeCnt; ++glCtxType) {
+            if (0 == dtype) {
+                device.reset(new SkDevice(SkBitmap::kARGB_8888_Config,
+                                              256,
+                                              256,
+                                              false));
+            } else {
+#if SK_SUPPORT_GPU
+                GrContextFactory::GLContextType type =
+                    static_cast<GrContextFactory::GLContextType>(glCtxType);
+                if (!GrContextFactory::IsRenderingGLContext(type)) {
+                    continue;
+                }
+                GrContext* context = factory->get(type);
+                if (NULL == context) {
+                    continue;
+                }
+
+                device.reset(new SkGpuDevice(context, SkBitmap::kARGB_8888_Config, 256, 256));
 #else
-            device.reset(new SkGpuDevice(context,
-                                             SkBitmap::kARGB_8888_Config,
-                                             256,
-                                             256));
+                continue;
 #endif
-        }
-        SkCanvas canvas(device);
-
-        SkBitmap readBmp1;
-        readBmp1.setConfig(SkBitmap::kARGB_8888_Config, 256, 256);
-        readBmp1.allocPixels();
-        SkBitmap readBmp2;
-        readBmp2.setConfig(SkBitmap::kARGB_8888_Config, 256, 256);
-        readBmp2.allocPixels();
-
-        for (size_t upmaIdx = 0;
-             upmaIdx < SK_ARRAY_COUNT(gUnpremulConfigs);
-             ++upmaIdx) {
-            fillCanvas(&canvas, gUnpremulConfigs[upmaIdx]);
-            {
-                SkAutoLockPixels alp1(readBmp1);
-                SkAutoLockPixels alp2(readBmp2);
-                sk_bzero(readBmp1.getPixels(), readBmp1.getSafeSize());
-                sk_bzero(readBmp2.getPixels(), readBmp2.getSafeSize());
             }
+            SkCanvas canvas(device);
+
+            SkBitmap readBmp1;
+            readBmp1.setConfig(SkBitmap::kARGB_8888_Config, 256, 256);
+            readBmp1.allocPixels();
+            SkBitmap readBmp2;
+            readBmp2.setConfig(SkBitmap::kARGB_8888_Config, 256, 256);
+            readBmp2.allocPixels();
+
+            for (size_t upmaIdx = 0;
+                 upmaIdx < SK_ARRAY_COUNT(gUnpremulConfigs);
+                 ++upmaIdx) {
+                fillCanvas(&canvas, gUnpremulConfigs[upmaIdx]);
+                {
+                    SkAutoLockPixels alp1(readBmp1);
+                    SkAutoLockPixels alp2(readBmp2);
+                    sk_bzero(readBmp1.getPixels(), readBmp1.getSafeSize());
+                    sk_bzero(readBmp2.getPixels(), readBmp2.getSafeSize());
+                }
+
+                canvas.readPixels(&readBmp1, 0, 0, gUnpremulConfigs[upmaIdx]);
+                canvas.writePixels(readBmp1, 0, 0, gUnpremulConfigs[upmaIdx]);
+                canvas.readPixels(&readBmp2, 0, 0, gUnpremulConfigs[upmaIdx]);
 
-            canvas.readPixels(&readBmp1, 0, 0, gUnpremulConfigs[upmaIdx]);
-            canvas.writePixels(readBmp1, 0, 0, gUnpremulConfigs[upmaIdx]);
-            canvas.readPixels(&readBmp2, 0, 0, gUnpremulConfigs[upmaIdx]);
-
-            SkAutoLockPixels alp1(readBmp1);
-            SkAutoLockPixels alp2(readBmp2);
-            uint32_t* pixels1 =
-                reinterpret_cast<uint32_t*>(readBmp1.getPixels());
-            uint32_t* pixels2 =
-                reinterpret_cast<uint32_t*>(readBmp2.getPixels());
-            bool success = true;
-            for (int y = 0; y < 256 && success; ++y) {
-                for (int x = 0; x < 256 && success; ++x) {
-                    int i = y * 256 + x;
-                    REPORTER_ASSERT(reporter, success = pixels1[i] == pixels2[i]);
+                SkAutoLockPixels alp1(readBmp1);
+                SkAutoLockPixels alp2(readBmp2);
+                uint32_t* pixels1 =
+                    reinterpret_cast<uint32_t*>(readBmp1.getPixels());
+                uint32_t* pixels2 =
+                    reinterpret_cast<uint32_t*>(readBmp2.getPixels());
+                bool success = true;
+                for (int y = 0; y < 256 && success; ++y) {
+                    for (int x = 0; x < 256 && success; ++x) {
+                        int i = y * 256 + x;
+                        REPORTER_ASSERT(reporter, success = pixels1[i] == pixels2[i]);
+                    }
                 }
             }
         }
diff --git a/tests/ReadPixelsTest.cpp b/tests/ReadPixelsTest.cpp
index a33e819c28..41ecccff35 100644
--- a/tests/ReadPixelsTest.cpp
+++ b/tests/ReadPixelsTest.cpp
@@ -14,6 +14,7 @@
 #include "SkRegion.h"
 #if SK_SUPPORT_GPU
 #include "SkGpuDevice.h"
+#include "GrContextFactory.h"
 #endif
 
 
@@ -254,7 +255,7 @@ void init_bitmap(SkBitmap* bitmap, const SkIRect& rect, BitmapInit init) {
     }
 }
 
-void ReadPixelsTest(skiatest::Reporter* reporter, GrContext* context) {
+void ReadPixelsTest(skiatest::Reporter* reporter, GrContextFactory* factory) {
     const SkIRect testRects[] = {
         // entire thing
         DEV_RECT,
@@ -303,93 +304,103 @@ void ReadPixelsTest(skiatest::Reporter* reporter, GrContext* context) {
     };
 
     for (int dtype = 0; dtype < 2; ++dtype) {
-        SkAutoTUnref<SkDevice> device;
-        if (0 == dtype) {
-            device.reset(new SkDevice(SkBitmap::kARGB_8888_Config,
-                                          DEV_W,
-                                          DEV_H,
-                                          false));
-        } else {
-// GPU device known not to work in the fixed pt build.
-#if defined(SK_SCALAR_IS_FIXED) || !SK_SUPPORT_GPU
-            continue;
+        int glCtxTypeCnt = 1;
+#if SK_SUPPORT_GPU
+        if (0 != dtype)  {
+            glCtxTypeCnt = GrContextFactory::kGLContextTypeCnt;
+        }
+#endif
+        for (int glCtxType = 0; glCtxType < glCtxTypeCnt; ++glCtxType) {
+            SkAutoTUnref<SkDevice> device;
+            if (0 == dtype) {
+                device.reset(new SkDevice(SkBitmap::kARGB_8888_Config, DEV_W, DEV_H, false));
+            } else {
+#if SK_SUPPORT_GPU
+                GrContextFactory::GLContextType type =
+                    static_cast<GrContextFactory::GLContextType>(glCtxType);
+                if (!GrContextFactory::IsRenderingGLContext(type)) {
+                    continue;
+                }
+                GrContext* context = factory->get(type);
+                if (NULL == context) {
+                    continue;
+                }
+                device.reset(new SkGpuDevice(context, SkBitmap::kARGB_8888_Config, DEV_W, DEV_H));
 #else
-            device.reset(new SkGpuDevice(context,
-                                             SkBitmap::kARGB_8888_Config,
-                                             DEV_W,
-                                             DEV_H));
+                continue;
 #endif
-        }
-        SkCanvas canvas(device);
-        fillCanvas(&canvas);
+            }
+            SkCanvas canvas(device);
+            fillCanvas(&canvas);
 
-        static const SkCanvas::Config8888 gReadConfigs[] = {
-            SkCanvas::kNative_Premul_Config8888,
-            SkCanvas::kNative_Unpremul_Config8888,
+            static const SkCanvas::Config8888 gReadConfigs[] = {
+                SkCanvas::kNative_Premul_Config8888,
+                SkCanvas::kNative_Unpremul_Config8888,
 /**
- * There is a bug in Ganesh (http://code.google.com/p/skia/issues/detail?id=438)
- * that causes the readback of pixels from BGRA canvas to an RGBA bitmap to
- * fail. This should be removed as soon as the issue above is resolved.
- */
+    * There is a bug in Ganesh (http://code.google.com/p/skia/issues/detail?id=438)
+    * that causes the readback of pixels from BGRA canvas to an RGBA bitmap to
+    * fail. This should be removed as soon as the issue above is resolved.
+    */
 #if !defined(SK_BUILD_FOR_ANDROID)
-            SkCanvas::kBGRA_Premul_Config8888,
-            SkCanvas::kBGRA_Unpremul_Config8888,
+                SkCanvas::kBGRA_Premul_Config8888,
+                SkCanvas::kBGRA_Unpremul_Config8888,
 #endif
-            SkCanvas::kRGBA_Premul_Config8888,
-            SkCanvas::kRGBA_Unpremul_Config8888,
-        };
-        for (size_t rect = 0; rect < SK_ARRAY_COUNT(testRects); ++rect) {
-            const SkIRect& srcRect = testRects[rect];
-            for (BitmapInit bmi = kFirstBitmapInit;
-                 bmi < kBitmapInitCnt;
-                 bmi = nextBMI(bmi)) {
-                for (size_t c = 0; c < SK_ARRAY_COUNT(gReadConfigs); ++c) {
-                    SkCanvas::Config8888 config8888 = gReadConfigs[c];
-                    SkBitmap bmp;
-                    init_bitmap(&bmp, srcRect, bmi);
-
-                    // if the bitmap has pixels allocated before the readPixels,
-                    // note that and fill them with pattern
-                    bool startsWithPixels = !bmp.isNull();
-                    if (startsWithPixels) {
-                        fillBitmap(&bmp);
+                SkCanvas::kRGBA_Premul_Config8888,
+                SkCanvas::kRGBA_Unpremul_Config8888,
+            };
+            for (size_t rect = 0; rect < SK_ARRAY_COUNT(testRects); ++rect) {
+                const SkIRect& srcRect = testRects[rect];
+                for (BitmapInit bmi = kFirstBitmapInit;
+                     bmi < kBitmapInitCnt;
+                     bmi = nextBMI(bmi)) {
+                    for (size_t c = 0; c < SK_ARRAY_COUNT(gReadConfigs); ++c) {
+                        SkCanvas::Config8888 config8888 = gReadConfigs[c];
+                        SkBitmap bmp;
+                        init_bitmap(&bmp, srcRect, bmi);
+
+                        // if the bitmap has pixels allocated before the readPixels,
+                        // note that and fill them with pattern
+                        bool startsWithPixels = !bmp.isNull();
+                        if (startsWithPixels) {
+                            fillBitmap(&bmp);
+                        }
+                        uint32_t idBefore = canvas.getDevice()->accessBitmap(false).getGenerationID();
+                        bool success =
+                            canvas.readPixels(&bmp, srcRect.fLeft,
+                                              srcRect.fTop, config8888);
+                        uint32_t idAfter = canvas.getDevice()->accessBitmap(false).getGenerationID();
+
+                        // we expect to succeed when the read isn't fully clipped
+                        // out.
+                        bool expectSuccess = SkIRect::Intersects(srcRect, DEV_RECT);
+                        // determine whether we expected the read to succeed.
+                        REPORTER_ASSERT(reporter, success == expectSuccess);
+                        // read pixels should never change the gen id
+                        REPORTER_ASSERT(reporter, idBefore == idAfter);
+
+                        if (success || startsWithPixels) {
+                            checkRead(reporter, bmp, srcRect.fLeft, srcRect.fTop,
+                                      success, startsWithPixels, config8888);
+                        } else {
+                            // if we had no pixels beforehand and the readPixels
+                            // failed then our bitmap should still not have pixels
+                            REPORTER_ASSERT(reporter, bmp.isNull());
+                        }
                     }
-                    uint32_t idBefore = canvas.getDevice()->accessBitmap(false).getGenerationID();
-                    bool success =
-                        canvas.readPixels(&bmp, srcRect.fLeft,
-                                          srcRect.fTop, config8888);
-                    uint32_t idAfter = canvas.getDevice()->accessBitmap(false).getGenerationID();
-
-                    // we expect to succeed when the read isn't fully clipped
-                    // out.
-                    bool expectSuccess = SkIRect::Intersects(srcRect, DEV_RECT);
-                    // determine whether we expected the read to succeed.
-                    REPORTER_ASSERT(reporter, success == expectSuccess);
-                    // read pixels should never change the gen id
-                    REPORTER_ASSERT(reporter, idBefore == idAfter);
-
-                    if (success || startsWithPixels) {
-                        checkRead(reporter, bmp, srcRect.fLeft, srcRect.fTop,
-                                  success, startsWithPixels, config8888);
+                    // check the old webkit version of readPixels that clips the
+                    // bitmap size
+                    SkBitmap wkbmp;
+                    bool success = canvas.readPixels(srcRect, &wkbmp);
+                    SkIRect clippedRect = DEV_RECT;
+                    if (clippedRect.intersect(srcRect)) {
+                        REPORTER_ASSERT(reporter, success);
+                        checkRead(reporter, wkbmp, clippedRect.fLeft,
+                                  clippedRect.fTop, true, false,
+                                  SkCanvas::kNative_Premul_Config8888);
                     } else {
-                        // if we had no pixels beforehand and the readPixels
-                        // failed then our bitmap should still not have pixels
-                        REPORTER_ASSERT(reporter, bmp.isNull());
+                        REPORTER_ASSERT(reporter, !success);
                     }
                 }
-                // check the old webkit version of readPixels that clips the
-                // bitmap size
-                SkBitmap wkbmp;
-                bool success = canvas.readPixels(srcRect, &wkbmp);
-                SkIRect clippedRect = DEV_RECT;
-                if (clippedRect.intersect(srcRect)) {
-                    REPORTER_ASSERT(reporter, success);
-                    checkRead(reporter, wkbmp, clippedRect.fLeft,
-                              clippedRect.fTop, true, false,
-                              SkCanvas::kNative_Premul_Config8888);
-                } else {
-                    REPORTER_ASSERT(reporter, !success);
-                }
             }
         }
     }
diff --git a/tests/ReadWriteAlphaTest.cpp b/tests/ReadWriteAlphaTest.cpp
index eea78ce6c0..a3bf5dee98 100644
--- a/tests/ReadWriteAlphaTest.cpp
+++ b/tests/ReadWriteAlphaTest.cpp
@@ -11,97 +11,103 @@
 
 #include "Test.h"
 #include "SkGpuDevice.h"
+#include "GrContextFactory.h"
 
 static const int X_SIZE = 12;
 static const int Y_SIZE = 12;
 
-static void ReadWriteAlphaTest(skiatest::Reporter* reporter, GrContext* context) {
-
-#if SK_SCALAR_IS_FIXED
-    // GPU device known not to work in the fixed pt build.
-    return;
-#endif
+static void ReadWriteAlphaTest(skiatest::Reporter* reporter, GrContextFactory* factory) {
+    for (int type = 0; type < GrContextFactory::kLastGLContextType; ++type) {
+        GrContextFactory::GLContextType glType = static_cast<GrContextFactory::GLContextType>(type);
+        if (!GrContextFactory::IsRenderingGLContext(glType)) {
+            continue;
+        }
+        GrContext* context = factory->get(glType);
+        if (NULL == context) {
+            continue;
+        }
 
-    unsigned char textureData[X_SIZE][Y_SIZE];
+        unsigned char textureData[X_SIZE][Y_SIZE];
 
-    memset(textureData, 0, X_SIZE * Y_SIZE);
+        memset(textureData, 0, X_SIZE * Y_SIZE);
 
-    GrTextureDesc desc;
+        GrTextureDesc desc;
 
-    // let Skia know we will be using this texture as a render target
-    desc.fFlags     = kRenderTarget_GrTextureFlagBit;
-    // it is a single channel texture
-    desc.fConfig    = kAlpha_8_GrPixelConfig;
-    desc.fWidth     = X_SIZE;
-    desc.fHeight    = Y_SIZE;
+        // let Skia know we will be using this texture as a render target
+        desc.fFlags     = kRenderTarget_GrTextureFlagBit;
+        // it is a single channel texture
+        desc.fConfig    = kAlpha_8_GrPixelConfig;
+        desc.fWidth     = X_SIZE;
+        desc.fHeight    = Y_SIZE;
 
-    // We are initializing the texture with zeros here
-    GrTexture* texture = context->createUncachedTexture(desc, textureData, 0);
-    if (!texture) {
-        return;
-    }
+        // We are initializing the texture with zeros here
+        GrTexture* texture = context->createUncachedTexture(desc, textureData, 0);
+        if (!texture) {
+            return;
+        }
 
-    GrAutoUnref au(texture);
+        GrAutoUnref au(texture);
 
-    // create a distinctive texture
-    for (int y = 0; y < Y_SIZE; ++y) {
-        for (int x = 0; x < X_SIZE; ++x) {
-            textureData[x][y] = x*Y_SIZE+y;
+        // create a distinctive texture
+        for (int y = 0; y < Y_SIZE; ++y) {
+            for (int x = 0; x < X_SIZE; ++x) {
+                textureData[x][y] = x*Y_SIZE+y;
+            }
         }
-    }
 
-    // upload the texture
-    texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
-                         textureData, 0);
+        // upload the texture
+        texture->writePixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
+                             textureData, 0);
 
-    unsigned char readback[X_SIZE][Y_SIZE];
+        unsigned char readback[X_SIZE][Y_SIZE];
 
-    // clear readback to something non-zero so we can detect readback failures
-    memset(readback, 0x1, X_SIZE * Y_SIZE);
+        // clear readback to something non-zero so we can detect readback failures
+        memset(readback, 0x1, X_SIZE * Y_SIZE);
 
-    // read the texture back
-    texture->readPixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
-                        readback, 0);
+        // read the texture back
+        texture->readPixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
+                            readback, 0);
 
-    // make sure the original & read back versions match
-    bool match = true;
+        // make sure the original & read back versions match
+        bool match = true;
 
-    for (int y = 0; y < Y_SIZE; ++y) {
-        for (int x = 0; x < X_SIZE; ++x) {
-            if (textureData[x][y] != readback[x][y]) {
-                match = false;
+        for (int y = 0; y < Y_SIZE; ++y) {
+            for (int x = 0; x < X_SIZE; ++x) {
+                if (textureData[x][y] != readback[x][y]) {
+                    match = false;
+                }
             }
         }
-    }
 
-    REPORTER_ASSERT(reporter, match);
+        REPORTER_ASSERT(reporter, match);
 
-    // Now try writing on the single channel texture
-    SkAutoTUnref<SkDevice> device(new SkGpuDevice(context, texture->asRenderTarget()));
-    SkCanvas canvas(device);
+        // Now try writing on the single channel texture
+        SkAutoTUnref<SkDevice> device(new SkGpuDevice(context, texture->asRenderTarget()));
+        SkCanvas canvas(device);
 
-    SkPaint paint;
+        SkPaint paint;
 
-    const SkRect rect = SkRect::MakeLTRB(-10, -10, X_SIZE + 10, Y_SIZE + 10);
+        const SkRect rect = SkRect::MakeLTRB(-10, -10, X_SIZE + 10, Y_SIZE + 10);
 
-    paint.setColor(SK_ColorWHITE);
+        paint.setColor(SK_ColorWHITE);
 
-    canvas.drawRect(rect, paint);
+        canvas.drawRect(rect, paint);
 
-    texture->readPixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
-                        readback, 0);
+        texture->readPixels(0, 0, desc.fWidth, desc.fHeight, desc.fConfig,
+                            readback, 0);
 
-    match = true;
+        match = true;
 
-    for (int y = 0; y < Y_SIZE; ++y) {
-        for (int x = 0; x < X_SIZE; ++x) {
-            if (0xFF != readback[x][y]) {
-                match = false;
+        for (int y = 0; y < Y_SIZE; ++y) {
+            for (int x = 0; x < X_SIZE; ++x) {
+                if (0xFF != readback[x][y]) {
+                    match = false;
+                }
             }
         }
-    }
 
-    REPORTER_ASSERT(reporter, match);
+        REPORTER_ASSERT(reporter, match);
+    }
 }
 
 #ifndef SK_BUILD_FOR_ANDROID
diff --git a/tests/Test.cpp b/tests/Test.cpp
index de5e79335f..e0b997a8b7 100644
--- a/tests/Test.cpp
+++ b/tests/Test.cpp
@@ -84,33 +84,20 @@ bool Test::run() {
 ///////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
-    static SkAutoTUnref<SkNativeGLContext> gGLContext;
-    static SkAutoTUnref<GrContext> gGrContext;
+#include "GrContextFactory.h"
+GrContextFactory gGrContextFactory;
 #endif
 
-void GpuTest::DestroyContext() {
+GrContextFactory* GpuTest::GetGrContextFactory() {
 #if SK_SUPPORT_GPU
-    // preserve this order, we want gGrContext destroyed before gGLContext
-    gGrContext.reset(NULL);
-    gGLContext.reset(NULL);
+    return &gGrContextFactory;
+#else
+    return NULL;
 #endif
 }
 
-
-GrContext* GpuTest::GetContext() {
+void GpuTest::DestroyContexts() {
 #if SK_SUPPORT_GPU
-    if (NULL == gGrContext.get()) {
-        gGLContext.reset(new SkNativeGLContext());
-        if (gGLContext.get()->init(800, 600)) {
-            GrBackendContext ctx = reinterpret_cast<GrBackendContext>(gGLContext.get()->gl());
-            gGrContext.reset(GrContext::Create(kOpenGL_GrBackend, ctx));
-        }
-    }
-    if (gGLContext.get()) {
-        gGLContext.get()->makeCurrent();
-    }
-    return gGrContext.get();
-#else
-    return NULL;
+    gGrContextFactory.destroyContexts();
 #endif
 }
diff --git a/tests/Test.h b/tests/Test.h
index 2cbd00b594..2dca0e6fd0 100644
--- a/tests/Test.h
+++ b/tests/Test.h
@@ -12,8 +12,7 @@
 #include "SkString.h"
 #include "SkTRegistry.h"
 
-class GrContext;
-class SkGLContext;
+class GrContextFactory;
 
 namespace skiatest {
 
@@ -100,13 +99,9 @@ namespace skiatest {
 
     class GpuTest : public Test{
     public:
-        GpuTest() : Test() {
-            fContext = GetContext();
-        }
-        static GrContext* GetContext();
-        static void DestroyContext();
-    protected:
-        GrContext* fContext;
+        GpuTest() : Test() {}
+        static GrContextFactory* GetGrContextFactory();
+        static void DestroyContexts();
     private:
     };
 
diff --git a/tests/TestClassDef.h b/tests/TestClassDef.h
index ffef2a157b..ee4b1397b7 100644
--- a/tests/TestClassDef.h
+++ b/tests/TestClassDef.h
@@ -17,30 +17,28 @@
         void MyTestFunction(skiatest::Reporter*)
 */
 
-#define DEFINE_TESTCLASS(uiname, classname, function)                       \
-    namespace skiatest {                                                    \
-        class classname : public Test {                                     \
-        public:                                                             \
-            static Test* Factory(void*) { return SkNEW(classname); }        \
-        protected:                                                          \
-            virtual void onGetName(SkString* name) { name->set(uiname); }   \
-            virtual void onRun(Reporter* reporter) { function(reporter); }  \
-        };                                                                  \
-        static TestRegistry gReg(classname::Factory);                       \
+#define DEFINE_TESTCLASS(uiname, classname, function)                                   \
+    namespace skiatest {                                                                \
+        class classname : public Test {                                                 \
+        public:                                                                         \
+            static Test* Factory(void*) { return SkNEW(classname); }                    \
+        protected:                                                                      \
+            virtual void onGetName(SkString* name) SK_OVERRIDE { name->set(uiname); }   \
+            virtual void onRun(Reporter* reporter) SK_OVERRIDE { function(reporter); }  \
+        };                                                                              \
+        static TestRegistry gReg(classname::Factory);                                   \
     }
 
-#define DEFINE_GPUTESTCLASS(uiname, classname, function)                    \
-    namespace skiatest {                                                    \
-        class classname : public GpuTest {                                  \
-        public:                                                             \
-            static Test* Factory(void*) { return SkNEW(classname); }        \
-        protected:                                                          \
-            virtual void onGetName(SkString* name) { name->set(uiname); }   \
-            virtual void onRun(Reporter* reporter) {                        \
-                if (fContext) {                                             \
-                    function(reporter, fContext);                           \
-                }                                                           \
-            }                                                               \
-        };                                                                  \
-        static TestRegistry gReg(classname::Factory);                       \
+#define DEFINE_GPUTESTCLASS(uiname, classname, function)                                \
+    namespace skiatest {                                                                \
+        class classname : public GpuTest {                                              \
+        public:                                                                         \
+            static Test* Factory(void*) { return SkNEW(classname); }                    \
+        protected:                                                                      \
+            virtual void onGetName(SkString* name) SK_OVERRIDE { name->set(uiname); }   \
+            virtual void onRun(Reporter* reporter) SK_OVERRIDE {                        \
+                function(reporter, GetGrContextFactory());                              \
+            }                                                                           \
+        };                                                                              \
+        static TestRegistry gReg(classname::Factory);                                   \
     }
diff --git a/tests/WritePixelsTest.cpp b/tests/WritePixelsTest.cpp
index 715d8f77ee..14b2c51e9a 100644
--- a/tests/WritePixelsTest.cpp
+++ b/tests/WritePixelsTest.cpp
@@ -14,8 +14,10 @@
 #include "SkRegion.h"
 #if SK_SUPPORT_GPU
 #include "SkGpuDevice.h"
+#include "GrContextFactory.h"
 #else
 class GrContext;
+class GrContextFactory;
 #endif
 
 static const int DEV_W = 100, DEV_H = 100;
@@ -346,7 +348,7 @@ bool setupBitmap(SkBitmap* bitmap,
     return true;
 }
 
-void WritePixelsTest(skiatest::Reporter* reporter, GrContext* context) {
+void WritePixelsTest(skiatest::Reporter* reporter, GrContextFactory* factory) {
     SkCanvas canvas;
 
     const SkIRect testRects[] = {
@@ -397,36 +399,64 @@ void WritePixelsTest(skiatest::Reporter* reporter, GrContext* context) {
     };
 
     for (size_t i = 0; i < SK_ARRAY_COUNT(gCanvasConfigs); ++i) {
-        SkAutoTUnref<SkDevice> device(createDevice(gCanvasConfigs[i], context));
-        SkCanvas canvas(device);
+        int glCtxTypeCnt = 1;
+#if SK_SUPPORT_GPU
+        if (kGpu_DevType == gCanvasConfigs[i].fDevType)  {
+            glCtxTypeCnt = GrContextFactory::kGLContextTypeCnt;
+        }
+#endif
+        for (int glCtxType = 0; glCtxType < glCtxTypeCnt; ++glCtxType) {
+            GrContext* context = NULL;
+#if SK_SUPPORT_GPU
+            if (kGpu_DevType == gCanvasConfigs[i].fDevType) {
+                GrContextFactory::GLContextType type =
+                    static_cast<GrContextFactory::GLContextType>(glCtxType);
+#if SK_ANGLE // This test breaks ANGLE with GL errors in texsubimage2D. Disable until debugged.
+                if (type == GrContextFactory::kANGLE_GLContextType) {
+                    continue;
+                }
+#endif
+                if (!GrContextFactory::IsRenderingGLContext(type)) {
+                    continue;
+                }
+                context = factory->get(type);
+                if (NULL == context) {
+                    continue;
+                }
+            }
+#endif
+
+            SkAutoTUnref<SkDevice> device(createDevice(gCanvasConfigs[i], context));
+            SkCanvas canvas(device);
 
-        static const SkCanvas::Config8888 gSrcConfigs[] = {
-            SkCanvas::kNative_Premul_Config8888,
-            SkCanvas::kNative_Unpremul_Config8888,
-            SkCanvas::kBGRA_Premul_Config8888,
-            SkCanvas::kBGRA_Unpremul_Config8888,
-            SkCanvas::kRGBA_Premul_Config8888,
-            SkCanvas::kRGBA_Unpremul_Config8888,
-        };
-        for (size_t r = 0; r < SK_ARRAY_COUNT(testRects); ++r) {
-            const SkIRect& rect = testRects[r];
-            for (int tightBmp = 0; tightBmp < 2; ++tightBmp) {
-                for (size_t c = 0; c < SK_ARRAY_COUNT(gSrcConfigs); ++c) {
-                    fillCanvas(&canvas);
-                    SkCanvas::Config8888 config8888 = gSrcConfigs[c];
-                    SkBitmap bmp;
-                    REPORTER_ASSERT(reporter, setupBitmap(&bmp, config8888, rect.width(), rect.height(), SkToBool(tightBmp)));
-                    uint32_t idBefore = canvas.getDevice()->accessBitmap(false).getGenerationID();
-                    canvas.writePixels(bmp, rect.fLeft, rect.fTop, config8888);
-                    uint32_t idAfter = canvas.getDevice()->accessBitmap(false).getGenerationID();
-                    REPORTER_ASSERT(reporter, checkWrite(reporter, &canvas, bmp, rect.fLeft, rect.fTop, config8888));
+            static const SkCanvas::Config8888 gSrcConfigs[] = {
+                SkCanvas::kNative_Premul_Config8888,
+                SkCanvas::kNative_Unpremul_Config8888,
+                SkCanvas::kBGRA_Premul_Config8888,
+                SkCanvas::kBGRA_Unpremul_Config8888,
+                SkCanvas::kRGBA_Premul_Config8888,
+                SkCanvas::kRGBA_Unpremul_Config8888,
+            };
+            for (size_t r = 0; r < SK_ARRAY_COUNT(testRects); ++r) {
+                const SkIRect& rect = testRects[r];
+                for (int tightBmp = 0; tightBmp < 2; ++tightBmp) {
+                    for (size_t c = 0; c < SK_ARRAY_COUNT(gSrcConfigs); ++c) {
+                        fillCanvas(&canvas);
+                        SkCanvas::Config8888 config8888 = gSrcConfigs[c];
+                        SkBitmap bmp;
+                        REPORTER_ASSERT(reporter, setupBitmap(&bmp, config8888, rect.width(), rect.height(), SkToBool(tightBmp)));
+                        uint32_t idBefore = canvas.getDevice()->accessBitmap(false).getGenerationID();
+                        canvas.writePixels(bmp, rect.fLeft, rect.fTop, config8888);
+                        uint32_t idAfter = canvas.getDevice()->accessBitmap(false).getGenerationID();
+                        REPORTER_ASSERT(reporter, checkWrite(reporter, &canvas, bmp, rect.fLeft, rect.fTop, config8888));
 
-                    // we should change the genID iff pixels were actually written.
-                    SkIRect canvasRect = SkIRect::MakeSize(canvas.getDeviceSize());
-                    SkIRect writeRect = SkIRect::MakeXYWH(rect.fLeft, rect.fTop,
-                                                          bmp.width(), bmp.height());
-                    bool intersects = SkIRect::Intersects(canvasRect, writeRect) ;
-                    REPORTER_ASSERT(reporter, intersects == (idBefore != idAfter));
+                        // we should change the genID iff pixels were actually written.
+                        SkIRect canvasRect = SkIRect::MakeSize(canvas.getDeviceSize());
+                        SkIRect writeRect = SkIRect::MakeXYWH(rect.fLeft, rect.fTop,
+                                                              bmp.width(), bmp.height());
+                        bool intersects = SkIRect::Intersects(canvasRect, writeRect) ;
+                        REPORTER_ASSERT(reporter, intersects == (idBefore != idAfter));
+                    }
                 }
             }
         }
diff --git a/tests/skia_test.cpp b/tests/skia_test.cpp
index 8a1feaec31..18c8c84444 100644
--- a/tests/skia_test.cpp
+++ b/tests/skia_test.cpp
@@ -154,7 +154,7 @@ int tool_main(int argc, char** argv) {
 #endif
 
     SkGraphics::Term();
-    GpuTest::DestroyContext();
+    GpuTest::DestroyContexts();
 
     return (failCount == 0) ? 0 : 1;
 }