Hide MSAAPathBatch::Geometry and rename to PathInfo

src/gpu/batches/GrMSAAPathRenderer.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 "GrMSAAPathRenderer.h"
 
 #include "GrAuditTrail.h"
@@ skipping 207 matching lines @@
 
     GR_DECLARE_GEOMETRY_PROCESSOR_TEST;
 
     typedef GrGeometryProcessor INHERITED;
 };
 
 class MSAAPathBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
-    struct Geometry {
-        GrColor fColor;
-        SkPath fPath;
-        SkScalar fTolerance;
-    };
-
-    static MSAAPathBatch* Create(const Geometry& geometry, const SkMatrix& viewMatrix,
-                               const SkRect& devBounds) {
-        return new MSAAPathBatch(geometry, viewMatrix, devBounds);
+    MSAAPathBatch(GrColor color, const SkPath& path, const SkMatrix& viewMatrix,
+                  const SkRect& devBounds)
+            : INHERITED(ClassID())
+            , fViewMatrix(viewMatrix) {
+        fPaths.emplace_back(PathInfo{color, path});
+        this->setBounds(devBounds);
+        int contourCount;
+        this->computeWorstCasePointCount(path, &contourCount, &fMaxLineVertices, &fMaxQuadVertices);
+        fMaxLineIndices = fMaxLineVertices * 3;
+        fMaxQuadIndices = fMaxQuadVertices * 3;
+        fIsIndexed = contourCount > 1;
     }
 
     const char* name() const override { return "MSAAPathBatch"; }
 
     void computePipelineOptimizations(GrInitInvariantOutput* color,
                                       GrInitInvariantOutput* coverage,
                                       GrBatchToXPOverrides* overrides) const override {
-        // When this is called on a batch, there is only one geometry bundle
-        color->setKnownFourComponents(fGeoData[0].fColor);
+        // When this is called on a batch, there is only one path
+        color->setKnownFourComponents(fPaths[0].fColor);
         coverage->setKnownSingleComponent(0xff);
     }
 
     bool isValid() const {
         return !fIsIndexed || fMaxLineIndices <= SK_MaxU16;
     }
 
 private:
     void initBatchTracker(const GrXPOverridesForBatch& overrides) override {
         // Handle any color overrides
         if (!overrides.readsColor()) {
-            fGeoData[0].fColor = GrColor_ILLEGAL;
+            fPaths[0].fColor = GrColor_ILLEGAL;
         }
-        overrides.getOverrideColorIfSet(&fGeoData[0].fColor);
+        overrides.getOverrideColorIfSet(&fPaths[0].fColor);
     }
 
-    void computeWorstCasePointCount(const SkPath& path, int* subpaths, SkScalar tol,
-                                    int* outLinePointCount, int* outQuadPointCount) const {
+    void computeWorstCasePointCount(const SkPath& path, int* subpaths, int* outLinePointCount,
+                                    int* outQuadPointCount) const {
         int linePointCount = 0;
         int quadPointCount = 0;
         *subpaths = 1;
 
         bool first = true;
 
         SkPath::Iter iter(path, false);
         SkPath::Verb verb;
 
         SkPoint pts[4];
@@ skipping 89 matching lines @@
         if (fIsIndexed) {
             quads.indices = (uint16_t*) sk_malloc_throw(fMaxQuadIndices * sizeof(uint16_t));
             quadIndexPtr.set(quads.indices);
             quads.nextIndex = quads.indices;
         } else {
             quads.indices = nullptr;
             quads.nextIndex = nullptr;
         }
 
         // fill buffers
-        for (int i = 0; i < fGeoData.count(); i++) {
-            const Geometry& args = fGeoData[i];
+        for (int i = 0; i < fPaths.count(); i++) {
+            const PathInfo& pathInfo = fPaths[i];
 
             if (!this->createGeom(lines,
                                   quads,
-                                  args.fPath,
-                                  args.fTolerance,
+                                  pathInfo.fPath,
                                   fViewMatrix,
-                                  args.fColor,
+                                  pathInfo.fColor,
                                   fIsIndexed)) {
                 return;
             }
         }
         int lineVertexOffset = (int) (lines.nextVertex - lines.vertices);
         int lineIndexOffset = (int) (lines.nextIndex - lines.indices);
         SkASSERT(lineVertexOffset <= fMaxLineVertices && lineIndexOffset <= fMaxLineIndices);
         int quadVertexOffset = (int) (quads.nextVertex - quads.vertices);
         int quadIndexOffset = (int) (quads.nextIndex - quads.indices);
         SkASSERT(quadVertexOffset <= fMaxQuadVertices && quadIndexOffset <= fMaxQuadIndices);
@@ skipping 43 matching lines @@
                                        quadIndexBuffer, firstQuadVertex, firstQuadIndex,
                                        quadVertexOffset, quadIndexOffset);
             } else {
                 quadMeshes.init(kTriangles_GrPrimitiveType, quadVertexBuffer, firstQuadVertex,
                                 quadVertexOffset);
             }
             target->draw(quadGP, quadMeshes);
         }
     }
 
-    SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
-
-    MSAAPathBatch(const Geometry& geometry, const SkMatrix& viewMatrix, const SkRect& devBounds)
-        : INHERITED(ClassID())
-        , fViewMatrix(viewMatrix) {
-        fGeoData.push_back(geometry);
-        this->setBounds(devBounds);
-        int contourCount;
-        this->computeWorstCasePointCount(geometry.fPath, &contourCount, kTolerance,
-                                         &fMaxLineVertices, &fMaxQuadVertices);
-        fMaxLineIndices = fMaxLineVertices * 3;
-        fMaxQuadIndices = fMaxQuadVertices * 3;
-        fIsIndexed = contourCount > 1;
-    }
-
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
         MSAAPathBatch* that = t->cast<MSAAPathBatch>();
         if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
                                      that->bounds(), caps)) {
             return false;
         }
 
         if (!fViewMatrix.cheapEqualTo(that->fViewMatrix)) {
             return false;
         }
 
         if ((fMaxLineIndices + that->fMaxLineIndices > SK_MaxU16) ||
             (fMaxQuadIndices + that->fMaxQuadIndices > SK_MaxU16)) {
             return false;
         }
 
-        fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
+        fPaths.push_back_n(that->fPaths.count(), that->fPaths.begin());
         this->joinBounds(that->bounds());
         fIsIndexed = true;
         fMaxLineVertices += that->fMaxLineVertices;
         fMaxQuadVertices += that->fMaxQuadVertices;
         fMaxLineIndices += that->fMaxLineIndices;
         fMaxQuadIndices += that->fMaxQuadIndices;
         return true;
     }
 
     bool createGeom(MSAALineVertices& lines,
                     MSAAQuadVertices& quads,
                     const SkPath& path,
-                    SkScalar srcSpaceTol,
                     const SkMatrix& m,
                     SkColor color,
                     bool isIndexed) const {
         {
             uint16_t subpathIdxStart = (uint16_t) (lines.nextVertex - lines.vertices);
 
             SkPoint pts[4];
 
             bool first = true;
             SkPath::Iter iter(path, false);
@@ skipping 16 matching lines @@
                             if (prevIdx > subpathIdxStart) {
                                 append_contour_edge_indices(subpathIdxStart, prevIdx, lines);
                             }
                         }
                         SkASSERT(lines.nextVertex < lines.verticesEnd);
                         *(lines.nextVertex++) = { pts[1], color };
                         break;
                     case SkPath::kConic_Verb: {
                         SkScalar weight = iter.conicWeight();
                         SkAutoConicToQuads converter;
-                        const SkPoint* quadPts = converter.computeQuads(pts, weight,
-                                                                        kTolerance);
+                        const SkPoint* quadPts = converter.computeQuads(pts, weight, kTolerance);
                         for (int i = 0; i < converter.countQuads(); ++i) {
                             add_quad(lines, quads, quadPts + i * 2, color, isIndexed,
                                      subpathIdxStart);
                         }
                         break;
                     }
                     case SkPath::kQuad_Verb: {
                         add_quad(lines, quads, pts, color, isIndexed, subpathIdxStart);
                         break;
                     }
@@ skipping 10 matching lines @@
                         break;
                     case SkPath::kDone_Verb:
                         done = true;
                 }
                 first = false;
             }
         }
         return true;
     }
 
-    SkSTArray<1, Geometry, true> fGeoData;
+    struct PathInfo {
+        GrColor  fColor;
+        SkPath   fPath;
+    };
+
+    SkSTArray<1, PathInfo, true> fPaths;
 
     SkMatrix fViewMatrix;
     int fMaxLineVertices;
     int fMaxQuadVertices;
     int fMaxLineIndices;
     int fMaxQuadIndices;
     bool fIsIndexed;
 
     typedef GrVertexBatch INHERITED;
 };
@@ skipping 104 matching lines @@
             GrPipelineBuilder pipelineBuilder(paint, drawContext->mustUseHWAA(paint));
             pipelineBuilder.setDrawFace(drawFace[p]);
             if (passes[p]) {
                 pipelineBuilder.setUserStencil(passes[p]);
             } else {
                 pipelineBuilder.setUserStencil(userStencilSettings);
             }
 
             drawContext->drawBatch(pipelineBuilder, clip, batch);
         } else {
-            MSAAPathBatch::Geometry geometry;
-            geometry.fColor = color;
-            geometry.fPath = path;
-            geometry.fTolerance = kTolerance;
-
-            SkAutoTUnref<MSAAPathBatch> batch(MSAAPathBatch::Create(geometry, viewMatrix,
-                                                                    devBounds));
+            SkAutoTUnref<MSAAPathBatch> batch(new MSAAPathBatch(color, path, viewMatrix,
+                                                                devBounds));
             if (!batch->isValid()) {
                 return false;
             }
 
             GrPipelineBuilder pipelineBuilder(paint, drawContext->mustUseHWAA(paint));
             pipelineBuilder.setDrawFace(drawFace[p]);
             if (passes[p]) {
                 pipelineBuilder.setUserStencil(passes[p]);
             } else {
                 pipelineBuilder.setUserStencil(userStencilSettings);
@@ skipping 43 matching lines @@
 
     GrPaint paint;
     paint.setXPFactory(GrDisableColorXPFactory::Make());
     paint.setAntiAlias(args.fIsAA);
 
     this->internalDrawPath(args.fDrawContext, paint, &GrUserStencilSettings::kUnused, *args.fClip,
                            GrColor_WHITE, *args.fViewMatrix, *args.fShape, true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////