Initial CL to create GrBatchTest infrastructure

src/gpu/GrAARectRenderer.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrAARectRenderer.h"
 #include "GrBatch.h"
 #include "GrBatchTarget.h"
+#include "GrBatchTest.h"
 #include "GrBufferAllocPool.h"
+#include "GrContext.h"
 #include "GrDefaultGeoProcFactory.h"
 #include "GrGeometryProcessor.h"
 #include "GrGpu.h"
 #include "GrInvariantOutput.h"
+#include "GrTestUtils.h"
 #include "SkColorPriv.h"
 #include "gl/GrGLProcessor.h"
 #include "gl/GrGLGeometryProcessor.h"
 #include "gl/builders/GrGLProgramBuilder.h"
 
 ///////////////////////////////////////////////////////////////////////////////
 
 static void set_inset_fan(SkPoint* pts, size_t stride,
                           const SkRect& r, SkScalar dx, SkScalar dy) {
     pts->setRectFan(r.fLeft + dx, r.fTop + dy,
@@ skipping 288 matching lines @@
         bool fColorIgnored;
         bool fCoverageIgnored;
         bool fCanTweakAlphaForCoverage;
     };
 
     BatchTracker fBatch;
     const GrIndexBuffer* fIndexBuffer;
     SkSTArray<1, Geometry, true> fGeoData;
 };
 
+BATCH_TEST_DEFINE(AAFillRectBatch) {
+    AAFillRectBatch::Geometry geo;
+    geo.fColor = GrRandomColor(random);
+    geo.fViewMatrix = GrTest::TestMatrix(random);
+    geo.fRect = GrTest::TestRect(random);
+    geo.fDevRect = GrTest::TestRect(random);
+
+    static GrIndexBuffer* aaFillRectIndexBuffer = NULL;
+    if (!aaFillRectIndexBuffer) {
+        aaFillRectIndexBuffer =
+                context->getGpu()->createInstancedIndexBuffer(gFillAARectIdx,
+                                                              kIndicesPerAAFillRect,
+                                                              kNumAAFillRectsInIndexBuffer,
+                                                              kVertsPerAAFillRect);
+    }
+
+    return AAFillRectBatch::Create(geo, aaFillRectIndexBuffer);
+}
+
 namespace {
 // Should the coverage be multiplied into the color attrib or use a separate attrib.
 enum CoverageAttribType {
     kUseColor_CoverageAttribType,
     kUseCoverage_CoverageAttribType,
 };
 }
 
 void GrAARectRenderer::reset() {
     SkSafeSetNull(fAAFillRectIndexBuffer);
@@ skipping 81 matching lines @@
 
 static const int kIndicesPerBevelStrokeRect = SK_ARRAY_COUNT(gBevelStrokeAARectIdx);
 static const int kVertsPerBevelStrokeRect = 24;
 static const int kNumBevelStrokeRectsInIndexBuffer = 256;
 
 static int aa_stroke_rect_index_count(bool miterStroke) {
     return miterStroke ? SK_ARRAY_COUNT(gMiterStrokeAARectIdx) :
                          SK_ARRAY_COUNT(gBevelStrokeAARectIdx);
 }
 
-GrIndexBuffer* GrAARectRenderer::aaStrokeRectIndexBuffer(bool miterStroke) {
+static GrIndexBuffer* setup_aa_stroke_rect_indexbuffer(GrIndexBuffer** aaMiterStrokeRectIndexBuffer,
+                                                       GrIndexBuffer** aaBevelStrokeRectIndexBuffer,
+                                                       GrGpu* gpu,
+                                                       bool miterStroke) {
     if (miterStroke) {
-        if (NULL == fAAMiterStrokeRectIndexBuffer) {
-            fAAMiterStrokeRectIndexBuffer =
-                    fGpu->createInstancedIndexBuffer(gMiterStrokeAARectIdx,
-                                                     kIndicesPerMiterStrokeRect,
-                                                     kNumMiterStrokeRectsInIndexBuffer,
-                                                     kVertsPerMiterStrokeRect);
+        if (!*aaMiterStrokeRectIndexBuffer) {
+            *aaMiterStrokeRectIndexBuffer =
+                    gpu->createInstancedIndexBuffer(gMiterStrokeAARectIdx,
+                                                    kIndicesPerMiterStrokeRect,
+                                                    kNumMiterStrokeRectsInIndexBuffer,
+                                                    kVertsPerMiterStrokeRect);
         }
-        return fAAMiterStrokeRectIndexBuffer;
+        return *aaMiterStrokeRectIndexBuffer;
     } else {
-        if (NULL == fAABevelStrokeRectIndexBuffer) {
-            fAABevelStrokeRectIndexBuffer =
-                    fGpu->createInstancedIndexBuffer(gBevelStrokeAARectIdx,
-                                                     kIndicesPerBevelStrokeRect,
-                                                     kNumBevelStrokeRectsInIndexBuffer,
-                                                     kVertsPerBevelStrokeRect);
+        if (!*aaBevelStrokeRectIndexBuffer) {
+            *aaBevelStrokeRectIndexBuffer =
+                    gpu->createInstancedIndexBuffer(gBevelStrokeAARectIdx,
+                                                    kIndicesPerBevelStrokeRect,
+                                                    kNumBevelStrokeRectsInIndexBuffer,
+                                                    kVertsPerBevelStrokeRect);
         }
-        return fAABevelStrokeRectIndexBuffer;
+        return *aaBevelStrokeRectIndexBuffer;
     }
 }
 
 void GrAARectRenderer::geometryFillAARect(GrDrawTarget* target,
                                           GrPipelineBuilder* pipelineBuilder,
                                           GrColor color,
                                           const SkMatrix& viewMatrix,
                                           const SkRect& rect,
                                           const SkRect& devRect) {
     if (!fAAFillRectIndexBuffer) {
@@ skipping 390 matching lines @@
         bool fCoverageIgnored;
         bool fMiterStroke;
         bool fCanTweakAlphaForCoverage;
     };
 
     BatchTracker fBatch;
     const GrIndexBuffer* fIndexBuffer;
     SkSTArray<1, Geometry, true> fGeoData;
 };
 
+BATCH_TEST_DEFINE(AAStrokeRectBatch) {
+    static GrIndexBuffer* aaMiterStrokeRectIndexBuffer = NULL;
+    static GrIndexBuffer* aaBevelStrokeRectIndexBuffer = NULL;
+
+    bool miterStroke = random->nextBool();
+
+    GrIndexBuffer* indexBuffer = setup_aa_stroke_rect_indexbuffer(&aaMiterStrokeRectIndexBuffer,
+                                                                  &aaBevelStrokeRectIndexBuffer,
+                                                                  context->getGpu(),
+                                                                  miterStroke);
+
+    // Create mock stroke rect
+    SkRect outside = GrTest::TestRect(random);
+    SkScalar minDim = SkMinScalar(outside.width(), outside.height());
+    SkScalar strokeWidth = minDim * 0.1f;
+    SkRect outsideAssist = outside;
+    outsideAssist.outset(strokeWidth, strokeWidth);
+    SkRect inside = outside;
+    inside.inset(strokeWidth, strokeWidth);
+
+    AAStrokeRectBatch::Geometry geo;
+    geo.fColor = GrRandomColor(random);
+    geo.fDevOutside = outside;
+    geo.fDevOutsideAssist = outsideAssist;
+    geo.fDevInside = inside;
+    geo.fMiterStroke = miterStroke;
+
+    return AAStrokeRectBatch::Create(geo, GrTest::TestMatrix(random), indexBuffer);
+}
 
 void GrAARectRenderer::geometryStrokeAARect(GrDrawTarget* target,
                                             GrPipelineBuilder* pipelineBuilder,
                                             GrColor color,
                                             const SkMatrix& viewMatrix,
                                             const SkRect& devOutside,
                                             const SkRect& devOutsideAssist,
                                             const SkRect& devInside,
                                             bool miterStroke) {
-    GrIndexBuffer* indexBuffer = this->aaStrokeRectIndexBuffer(miterStroke);
+    GrIndexBuffer* indexBuffer = setup_aa_stroke_rect_indexbuffer(&fAAMiterStrokeRectIndexBuffer,
+                                                                  &fAABevelStrokeRectIndexBuffer,
+                                                                  fGpu,
+                                                                  miterStroke);
     if (!indexBuffer) {
         SkDebugf("Failed to create index buffer!\n");
         return;
     }
 
     AAStrokeRectBatch::Geometry geometry;
     geometry.fColor = color;
     geometry.fDevOutside = devOutside;
     geometry.fDevOutsideAssist = devOutsideAssist;
     geometry.fDevInside = devInside;
@@ skipping 17 matching lines @@
     viewMatrix.mapPoints((SkPoint*)&devInside, (const SkPoint*)&rects[1], 2);
 
     if (devInside.isEmpty()) {
         this->fillAARect(target, pipelineBuilder, color, viewMatrix, devOutside, devOutside);
         return;
     }
 
     this->geometryStrokeAARect(target, pipelineBuilder, color, viewMatrix, devOutside,
                                devOutsideAssist, devInside, true);
 }