Add test configs for instanced rendering

src/gpu/instanced/InstancedRendering.cpp

 /*
  * Copyright 2016 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "InstancedRendering.h"
 
 #include "GrBatchFlushState.h"
 #include "GrCaps.h"
 #include "GrPipeline.h"
 #include "GrResourceProvider.h"
 #include "instanced/InstanceProcessor.h"
 
 namespace gr_instanced {
 
-InstancedRendering::InstancedRendering(GrGpu* gpu, AntialiasMode lastSupportedAAMode,
-                                       bool canRenderToFloat)
+InstancedRendering::InstancedRendering(GrGpu* gpu)
     : fGpu(SkRef(gpu)),
-      fLastSupportedAAMode(lastSupportedAAMode),
-      fCanRenderToFloat(canRenderToFloat),
       fState(State::kRecordingDraws),
       fDrawPool(1024 * sizeof(Batch::Draw), 1024 * sizeof(Batch::Draw)) {
 }
 
 GrDrawBatch* InstancedRendering::recordRect(const SkRect& rect, const SkMatrix& viewMatrix,
                                             GrColor color, bool antialias,
                                             const GrInstancedPipelineInfo& info, bool* useHWAA) {
     return this->recordShape(ShapeType::kRect, rect, viewMatrix, color, rect, antialias, info,
                              useHWAA);
 }
@@ skipping 67 matching lines @@
 }
 
 InstancedRendering::Batch* InstancedRendering::recordShape(ShapeType type, const SkRect& bounds,
                                                            const SkMatrix& viewMatrix,
                                                            GrColor color, const SkRect& localRect,
                                                            bool antialias,
                                                            const GrInstancedPipelineInfo& info,
                                                            bool* useHWAA) {
     SkASSERT(State::kRecordingDraws == fState);
 
-    if (info.fIsRenderingToFloat && !fCanRenderToFloat) {
+    if (info.fIsRenderingToFloat && fGpu->caps()->avoidInstancedDrawsToFPTargets()) {
         return nullptr;
     }
 
     AntialiasMode antialiasMode;
     if (!this->selectAntialiasMode(viewMatrix, antialias, info, useHWAA, &antialiasMode)) {
         return nullptr;
     }
 
     Batch* batch = this->createBatch();
     batch->fInfo.fAntialiasMode = antialiasMode;
@@ skipping 73 matching lines @@
 
     batch->fPixelLoad = batch->bounds().height() * batch->bounds().width();
     return batch;
 }
 
 inline bool InstancedRendering::selectAntialiasMode(const SkMatrix& viewMatrix, bool antialias,
                                                     const GrInstancedPipelineInfo& info,
                                                     bool* useHWAA, AntialiasMode* antialiasMode) {
     SkASSERT(!info.fColorDisabled || info.fDrawingShapeToStencil);
     SkASSERT(!info.fIsMixedSampled || info.fIsMultisampled);
+    SkASSERT(GrCaps::InstancedSupport::kNone != fGpu->caps()->instancedSupport());
 
     if (!info.fIsMultisampled || fGpu->caps()->multisampleDisableSupport()) {
-        SkASSERT(fLastSupportedAAMode >= AntialiasMode::kCoverage);
         if (!antialias) {
             if (info.fDrawingShapeToStencil && !info.fCanDiscard) {
                 // We can't draw to the stencil buffer without discard (or sample mask if MSAA).
                 return false;
             }
             *antialiasMode = AntialiasMode::kNone;
             *useHWAA = false;
             return true;
         }
 
         if (info.canUseCoverageAA() && viewMatrix.preservesRightAngles()) {
             *antialiasMode = AntialiasMode::kCoverage;
             *useHWAA = false;
             return true;
         }
     }
 
-    if (info.fIsMultisampled && fLastSupportedAAMode >= AntialiasMode::kMSAA) {
+    if (info.fIsMultisampled &&
+        fGpu->caps()->instancedSupport() >= GrCaps::InstancedSupport::kMultisampled) {
         if (!info.fIsMixedSampled || info.fColorDisabled) {
             *antialiasMode = AntialiasMode::kMSAA;
             *useHWAA = true;
             return true;
         }
-        if (fLastSupportedAAMode >= AntialiasMode::kMixedSamples) {
+        if (fGpu->caps()->instancedSupport() >= GrCaps::InstancedSupport::kMixedSampled) {
             *antialiasMode = AntialiasMode::kMixedSamples;
             *useHWAA = true;
             return true;
         }
     }
 
     return false;
 }
 
 InstancedRendering::Batch::Batch(uint32_t classID, InstancedRendering* ir)
@@ skipping 248 matching lines @@
 }
 
 void InstancedRendering::resetGpuResources(ResetType resetType) {
     fVertexBuffer.reset();
     fIndexBuffer.reset();
     fParamsBuffer.reset();
     this->onResetGpuResources(resetType);
 }
 
 }