Eliminate special case nvpr batch handling

src/gpu/batches/GrDrawPathBatch.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 "GrDrawPathBatch.h"
 
+#include "GrRenderTargetPriv.h"
+
 static void pre_translate_transform_values(const float* xforms,
                                            GrPathRendering::PathTransformType type, int count,
                                            SkScalar x, SkScalar y, float* dst);
 
+void GrDrawPathBatchBase::onPrepare(GrBatchFlushState*) {
+    const GrRenderTargetPriv& rtPriv = this->pipeline()->getRenderTarget()->renderTargetPriv();
+    fStencilPassSettings.reset(GrPathRendering::GetStencilPassSettings(fFillType),
+                               this->pipeline()->hasStencilClip(), rtPriv.numStencilBits());
+}
+
 SkString GrDrawPathBatch::dumpInfo() const {
     SkString string;
     string.printf("PATH: 0x%p", fPath.get());
     return string;
 }
 
 void GrDrawPathBatch::onDraw(GrBatchFlushState* state) {
     GrProgramDesc  desc;
 
     SkAutoTUnref<GrPathProcessor> pathProc(GrPathProcessor::Create(this->color(),
                                                                    this->overrides(),
                                                                    this->viewMatrix()));
-    state->gpu()->pathRendering()->drawPath(*this->pipeline(), *pathProc, this->stencilSettings(),
-                                            fPath.get());
+    state->gpu()->pathRendering()->drawPath(*this->pipeline(), *pathProc,
+                                            this->stencilPassSettings(), fPath.get());
 }
 
 SkString GrDrawPathRangeBatch::dumpInfo() const {
     SkString string;
     string.printf("RANGE: 0x%p COUNTS: [", fPathRange.get());
     for (DrawList::Iter iter(fDraws); iter.get(); iter.next()) {
         string.appendf("%d, ", iter.get()->fInstanceData->count());
     }
     string.remove(string.size() - 2, 2);
     string.append("]");
@@ skipping 44 matching lines @@
         default: break;
     }
     // TODO: Check some other things here. (winding, opaque, pathProc color, vm, ...)
     // Try to combine this call with the previous DrawPaths. We do this by stenciling all the
     // paths together and then covering them in a single pass. This is not equivalent to two
     // separate draw calls, so we can only do it if there is no blending (no overlap would also
     // work). Note that it's also possible for overlapping paths to cancel each other's winding
     // numbers, and we only partially account for this by not allowing even/odd paths to be
     // combined. (Glyphs in the same font tend to wind the same direction so it works out OK.)
     if (GrPathRendering::kWinding_FillType != this->fillType() ||
-        this->stencilSettings() != that->stencilSettings() ||
+        GrPathRendering::kWinding_FillType != that->fillType() ||
         this->overrides().willColorBlendWithDst()) {
         return false;
     }
     SkASSERT(!that->overrides().willColorBlendWithDst());
     fTotalPathCount += that->fTotalPathCount;
     while (Draw* head = that->fDraws.head()) {
         Draw* draw = fDraws.addToTail();
         draw->fInstanceData.reset(head->fInstanceData.release());
         draw->fX = head->fX;
         draw->fY = head->fY;
@@ skipping 16 matching lines @@
 
     SkAutoTUnref<GrPathProcessor> pathProc(GrPathProcessor::Create(this->color(),
                                                                    this->overrides(),
                                                                    drawMatrix,
                                                                    localMatrix));
 
     if (fDraws.count() == 1) {
         const InstanceData& instances = *head.fInstanceData;
         state->gpu()->pathRendering()->drawPaths(*this->pipeline(),
                                                  *pathProc,
-                                                 this->stencilSettings(),
+                                                 this->stencilPassSettings(),
                                                  fPathRange.get(),
                                                  instances.indices(),
                                                  GrPathRange::kU16_PathIndexType,
                                                  instances.transformValues(),
                                                  instances.transformType(),
                                                  instances.count());
     } else {
         int floatsPerTransform = GrPathRendering::PathTransformSize(this->transformType());
         SkAutoSTMalloc<4096, float> transformStorage(floatsPerTransform * fTotalPathCount);
         SkAutoSTMalloc<2048, uint16_t> indexStorage(fTotalPathCount);
         int idx = 0;
         for (DrawList::Iter iter(fDraws); iter.get(); iter.next()) {
             const Draw& draw = *iter.get();
             const InstanceData& instances = *draw.fInstanceData;
             memcpy(&indexStorage[idx], instances.indices(), instances.count() * sizeof(uint16_t));
             pre_translate_transform_values(instances.transformValues(), this->transformType(),
                                            instances.count(),
                                            draw.fX - head.fX, draw.fY - head.fY,
                                            &transformStorage[floatsPerTransform * idx]);
             idx += instances.count();
 
             // TODO: Support mismatched transform types if we start using more types other than 2D.
             SkASSERT(instances.transformType() == this->transformType());
         }
         SkASSERT(idx == fTotalPathCount);
 
         state->gpu()->pathRendering()->drawPaths(*this->pipeline(),
                                                  *pathProc,
-                                                 this->stencilSettings(),
+                                                 this->stencilPassSettings(),
                                                  fPathRange.get(),
                                                  indexStorage,
                                                  GrPathRange::kU16_PathIndexType,
                                                  transformStorage,
                                                  this->transformType(),
                                                  fTotalPathCount);
     }
 }
 
 inline void pre_translate_transform_values(const float* xforms,
@@ skipping 33 matching lines @@
                 dst[i + 3] = xforms[i + 3];
                 dst[i + 4] = xforms[i + 4];
                 dst[i + 5] = xforms[i + 3] * x + xforms[i + 4] * y + xforms[i + 5];
             }
             break;
         default:
             SkFAIL("Unknown transform type.");
             break;
     }
 }