Add test configs for instanced rendering

tools/gpu/GrContextFactory.cpp

 
 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrContextFactory.h"
 #include "gl/GLTestContext.h"
@@ skipping 13 matching lines @@
 #endif
 #include "gl/null/NullGLTestContext.h"
 #include "gl/GrGLGpu.h"
 #include "GrCaps.h"
 
 namespace sk_gpu_test {
 GrContextFactory::GrContextFactory() { }
 
 GrContextFactory::GrContextFactory(const GrContextOptions& opts)
     : fGlobalOptions(opts) {
+    // In this factory, instanced rendering is specified with kUseInstanced_ContextOptions.
+    SkASSERT(!fGlobalOptions.fEnableInstancedRendering);
 }
 
 GrContextFactory::~GrContextFactory() {
     this->destroyContexts();
 }
 
 void GrContextFactory::destroyContexts() {
     for (Context& context : fContexts) {
         if (context.fTestContext) {
             context.fTestContext->makeCurrent();
@@ skipping 99 matching lines @@
                     glCtx = CreateDebugGLTestContext();
                     break;
                 default:
                     return ContextInfo();
             }
             if (!glCtx) {
                 return ContextInfo();
             }
             testCtx.reset(glCtx);
             glInterface.reset(SkRef(glCtx->gl()));
-            // Block NVPR from non-NVPR types.
-            if (!(kEnableNVPR_ContextOptions & options)) {
+            // Block NVPR from non-NVPR types. We don't block NVPR from contexts that will use
+            // instanced rendering because that would prevent us from testing mixed samples.
+            if (!((kEnableNVPR_ContextOptions | kUseInstanced_ContextOptions) & options)) {
                 glInterface.reset(GrGLInterfaceRemoveNVPR(glInterface.get()));
                 if (!glInterface) {
                     return ContextInfo();
                 }
             }
             backendContext = reinterpret_cast<GrBackendContext>(glInterface.get());
             break;
         }
 #ifdef SK_VULKAN
         case kVulkan_GrBackend:
@@ skipping 16 matching lines @@
                 }
             }
             backendContext = testCtx->backendContext();
             break;
 #endif
         default:
             return ContextInfo();
     }
     testCtx->makeCurrent();
     SkASSERT(testCtx && testCtx->backend() == backend);
-    grCtx.reset(GrContext::Create(backend, backendContext, fGlobalOptions));
+    GrContextOptions grOptions = fGlobalOptions;
+    if (kUseInstanced_ContextOptions & options) {
+        grOptions.fEnableInstancedRendering = true;
+    }
+    grCtx.reset(GrContext::Create(backend, backendContext, grOptions));
     if (!grCtx.get()) {
         return ContextInfo();
     }
     if (kEnableNVPR_ContextOptions & options) {
         if (!grCtx->caps()->shaderCaps()->pathRenderingSupport()) {
             return ContextInfo();
         }
     }
+    if (kUseInstanced_ContextOptions & options) {
+        if (GrCaps::InstancedSupport::kNone == grCtx->caps()->instancedSupport()) {
+            return ContextInfo();
+        }
+    }
     if (kRequireSRGBSupport_ContextOptions & options) {
         if (!grCtx->caps()->srgbSupport()) {
             return ContextInfo();
         }
     }
 
     Context& context = fContexts.push_back();
     context.fBackend = backend;
     context.fTestContext = testCtx.release();
     context.fGrContext = SkRef(grCtx.get());
     context.fType = type;
     context.fOptions = options;
     context.fAbandoned = false;
     return ContextInfo(context.fBackend, context.fTestContext, context.fGrContext);
 }
 }  // namespace sk_gpu_test