Add base class for GLTestContext and add new subclass VkTestContext.

tools/gpu/GrContextFactory.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrContextFactory_DEFINED
 #define GrContextFactory_DEFINED
 
 #include "GrContext.h"
 #include "GrContextOptions.h"
 
 #include "gl/GLTestContext.h"
+#include "vk/VkTestContext.h"
 #include "SkTArray.h"
 
 struct GrVkBackendContext;
 
 namespace sk_gpu_test {
 
 class ContextInfo {
 public:
+    ContextInfo() = default;
+    ContextInfo& operator=(const ContextInfo&) = default;
+
+    GrBackend backend() const { return fBackend; };
+
     GrContext* grContext() const { return fGrContext; }
-    GLTestContext* glContext() const { return fGLContext; }
+
+    GLTestContext* glContext() const {
+        SkASSERT(kOpenGL_GrBackend == fBackend);
+        return static_cast<GLTestContext*>(fTestContext);
+    }
+
+#ifdef SK_VULKAN
+    VkTestContext* vkContext() const {
+        SkASSERT(kVulkan_GrBackend == fBackend);
+        return static_cast<VkTestContext*>(fTestContext);
+    }
+#endif
 
 private:
-    ContextInfo()
-            : fGrContext(nullptr), fGLContext(nullptr) { }
-    ContextInfo(GrContext* grContext, GLTestContext* glContext)
-            : fGrContext(grContext), fGLContext(glContext) { }
-    GrContext* fGrContext;
-    GLTestContext* fGLContext; //! Valid until the factory destroys it via abandonContexts() or
-                               //! destroyContexts(). Null if context is not based on OpenGL.
+    ContextInfo(GrBackend backend, TestContext* testContext, GrContext* grContext)
+            : fBackend(backend)
+            , fTestContext(testContext)
+            , fGrContext(grContext) {}
+
+    GrBackend       fBackend = kOpenGL_GrBackend;
+    // Valid until the factory destroys it via abandonContexts() or destroyContexts().
+    TestContext*    fTestContext = nullptr;
+    GrContext*      fGrContext = nullptr;
 
     friend class GrContextFactory;
 };
 
 /**
  * This is a simple class that is useful in test apps that use different
  * GrContexts backed by different types of GL contexts. It manages creating the
  * GL context and a GrContext that uses it. The GL/Gr contexts persist until the
  * factory is destroyed (though the caller can always grab a ref on the returned
  * Gr and GL contexts to make them outlive the factory).
@@ skipping 83 matching lines @@
 
     /**
      * Get a context initialized with a type of GL context. It also makes the GL context current.
      */
     ContextInfo getContextInfo(ContextType type,
                                ContextOptions options = kNone_ContextOptions);
     /**
      * Get a GrContext initialized with a type of GL context. It also makes the GL context current.
      */
     GrContext* get(ContextType type, ContextOptions options = kNone_ContextOptions) {
-        return this->getContextInfo(type, options).fGrContext;
+        return this->getContextInfo(type, options).grContext();
     }
     const GrContextOptions& getGlobalOptions() const { return fGlobalOptions; }
 
 private:
     struct Context {
         ContextType     fType;
         ContextOptions  fOptions;
-        GLTestContext*  fGLContext; //  null if non-GL
+        GrBackend       fBackend;
+        TestContext*    fTestContext;
         GrContext*      fGrContext;
         bool            fAbandoned;
     };
     SkTArray<Context, true>         fContexts;
     SkAutoTDelete<GLTestContext>    fSentinelGLContext;
     const GrContextOptions          fGlobalOptions;
 };
 }  // namespace sk_gpu_test
 #endif