Make unit tests use generic testcontext rather than glcontext

tests/ImageTest.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <functional>
 #include <initializer_list>
 #include "DMGpuSupport.h"
@@ skipping 386 matching lines @@
         }
     }
 
     image.reset(nullptr);
     {
         SkBitmap cachedBitmap;
         REPORTER_ASSERT(reporter, !SkBitmapCache::Find(uniqueID, &cachedBitmap));
     }
 }
 
-DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(SkImage_newTextureImage, reporter, contextInfo) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SkImage_newTextureImage, reporter, contextInfo) {
     GrContext* context = contextInfo.grContext();
-    sk_gpu_test::GLTestContext* glContext = contextInfo.glContext();
+    sk_gpu_test::TestContext* testContext = contextInfo.testContext();
 
     GrContextFactory otherFactory;
-    ContextInfo otherContextInfo =
-        otherFactory.getContextInfo(GrContextFactory::kNativeGL_ContextType);
-    glContext->makeCurrent();
+    GrContextFactory::ContextType otherContextType =
+            GrContextFactory::NativeContextTypeForBackend(testContext->backend());
+    ContextInfo otherContextInfo = otherFactory.getContextInfo(otherContextType);
+    testContext->makeCurrent();
 
     std::function<sk_sp<SkImage>()> imageFactories[] = {
         create_image,
         create_codec_image,
         create_data_image,
         // Create an image from a picture.
         create_picture_image,
         // Create a texture image.
         [context] { return create_gpu_image(context); },
         // Create a texture image in a another GrContext.
-        [glContext, otherContextInfo] {
-            otherContextInfo.glContext()->makeCurrent();
+        [testContext, otherContextInfo] {
+            otherContextInfo.testContext()->makeCurrent();
             sk_sp<SkImage> otherContextImage = create_gpu_image(otherContextInfo.grContext());
-            glContext->makeCurrent();
+            testContext->makeCurrent();
             return otherContextImage;
         }
     };
 
     for (auto factory : imageFactories) {
         sk_sp<SkImage> image(factory());
         if (!image) {
             ERRORF(reporter, "Error creating image.");
             continue;
         }
@@ skipping 378 matching lines @@
                                                                    SkBudgeted::kNo));
             if (!texImage) {
                 ERRORF(reporter, "NewTextureFromPixmap failed.");
             } else {
                 check_images_same(reporter, image.get(), texImage.get());
             }
         }
     }
 }
 
-DEF_GPUTEST_FOR_GL_RENDERING_CONTEXTS(DeferredTextureImage, reporter, ctxInfo) {
+DEF_GPUTEST_FOR_RENDERING_CONTEXTS(DeferredTextureImage, reporter, ctxInfo) {
     GrContext* context = ctxInfo.grContext();
-    sk_gpu_test::GLTestContext* glContext = ctxInfo.glContext();
+    sk_gpu_test::TestContext* testContext = ctxInfo.testContext();
     SkAutoTUnref<GrContextThreadSafeProxy> proxy(context->threadSafeProxy());
 
     GrContextFactory otherFactory;
     ContextInfo otherContextInfo =
         otherFactory.getContextInfo(GrContextFactory::kNativeGL_ContextType);
 
-    glContext->makeCurrent();
+    testContext->makeCurrent();
     REPORTER_ASSERT(reporter, proxy);
     struct {
         std::function<sk_sp<SkImage> ()> fImageFactory;
         bool                       fExpectation;
     } testCases[] = {
         { create_image,          true },
         { create_codec_image,    true },
         { create_data_image,     true },
         { create_picture_image,  false },
         { [context] { return create_gpu_image(context); }, false },
         // Create a texture image in a another GrContext.
-        { [glContext, otherContextInfo] {
-            otherContextInfo.glContext()->makeCurrent();
+        { [testContext, otherContextInfo] {
+            otherContextInfo.testContext()->makeCurrent();
             sk_sp<SkImage> otherContextImage = create_gpu_image(otherContextInfo.grContext());
-            glContext->makeCurrent();
+            testContext->makeCurrent();
             return otherContextImage;
           }, false },
     };
 
 
     for (auto testCase : testCases) {
         sk_sp<SkImage> image(testCase.fImageFactory());
 
         // This isn't currently used in the implementation, just set any old values.
         SkImage::DeferredTextureImageUsageParams params;
@@ skipping 21 matching lines @@
                         SkImage::MakeFromDeferredTextureImageData(context, buffer, budgeted));
                     REPORTER_ASSERT(reporter, newImage != nullptr);
                     if (newImage) {
                         check_images_same(reporter, image.get(), newImage.get());
                     }
                     // The other context should not be able to create images from texture data
                     // created by the original context.
                     sk_sp<SkImage> newImage2(SkImage::MakeFromDeferredTextureImageData(
                         otherContextInfo.grContext(), buffer, budgeted));
                     REPORTER_ASSERT(reporter, !newImage2);
-                    glContext->makeCurrent();
+                    testContext->makeCurrent();
                 }
             }
             sk_free(buffer);
         }
     }
 }
 #endif