Even more hiding of Geometry structs in GrBatch subclasses.

src/gpu/batches/GrDefaultPathRenderer.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDefaultPathRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 79 matching lines @@
             append_countour_edge_indices(isHairline, subpathIdxStart,
                                          firstQPtIdx + i, idx);
         }
     }
 }
 
 class DefaultPathBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
-    struct Geometry {
-        GrColor fColor;
-        SkPath fPath;
-        SkScalar fTolerance;
-    };
+    DefaultPathBatch(GrColor color, const SkPath& path, SkScalar tolerance,
+                     uint8_t coverage, const SkMatrix& viewMatrix, bool isHairline,
+                     const SkRect& devBounds)
+            : INHERITED(ClassID()) {
+        fBatch.fCoverage = coverage;
+        fBatch.fIsHairline = isHairline;
+        fBatch.fViewMatrix = viewMatrix;
+        fGeoData.emplace_back(Geometry{color, path, tolerance});
 
-    static GrDrawBatch* Create(const Geometry& geometry, uint8_t coverage,
-                               const SkMatrix& viewMatrix, bool isHairline,
-                               const SkRect& devBounds) {
-        return new DefaultPathBatch(geometry, coverage, viewMatrix, isHairline, devBounds);
+        this->setBounds(devBounds);
+
+        // This is b.c. hairlines are notionally infinitely thin so without expansion
+        // two overlapping lines could be reordered even though they hit the same pixels.
+        if (isHairline) {
+            fBounds.outset(0.5f, 0.5f);
+        }
     }
 
     const char* name() const override { return "DefaultPathBatch"; }
 
     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);
         coverage->setKnownSingleComponent(this->coverage());
@@ skipping 129 matching lines @@
         } else {
             mesh.init(primitiveType, vertexBuffer, firstVertex, vertexOffset);
         }
         target->draw(gp.get(), mesh);
 
         // put back reserves
         target->putBackIndices((size_t)(maxIndices - indexOffset));
         target->putBackVertices((size_t)(maxVertices - vertexOffset), (size_t)vertexStride);
     }
 
-    SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
-
-    DefaultPathBatch(const Geometry& geometry, uint8_t coverage, const SkMatrix& viewMatrix,
-                     bool isHairline, const SkRect& devBounds)
-        : INHERITED(ClassID()) {
-        fBatch.fCoverage = coverage;
-        fBatch.fIsHairline = isHairline;
-        fBatch.fViewMatrix = viewMatrix;
-        fGeoData.push_back(geometry);
-
-        this->setBounds(devBounds);
-
-        // This is b.c. hairlines are notionally infinitely thin so without expansion
-        // two overlapping lines could be reordered even though they hit the same pixels.
-        if (isHairline) {
-            fBounds.outset(0.5f, 0.5f);
-        }
-    }
-
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
         DefaultPathBatch* that = t->cast<DefaultPathBatch>();
         if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
                                      that->bounds(), caps)) {
             return false;
         }
 
         if (this->color() != that->color()) {
             return false;
         }
 
         if (this->coverage() != that->coverage()) {
             return false;
         }
 
         if (!this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             return false;
         }
 
         if (this->isHairline() != that->isHairline()) {
             return false;
         }
 
-        fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
+        fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin());
         this->joinBounds(that->bounds());
         return true;
     }
 
     bool createGeom(void* vertices,
                     size_t vertexOffset,
                     void* indices,
                     size_t indexOffset,
                     int* vertexCnt,
                     int* indexCnt,
@@ skipping 98 matching lines @@
     struct BatchTracker {
         GrColor fColor;
         uint8_t fCoverage;
         SkMatrix fViewMatrix;
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
         bool fIsHairline;
     };
 
+    struct Geometry {
+        GrColor fColor;
+        SkPath fPath;
+        SkScalar fTolerance;
+    };
+
     BatchTracker fBatch;
     SkSTArray<1, Geometry, true> fGeoData;
 
     typedef GrVertexBatch INHERITED;
 };
 
 bool GrDefaultPathRenderer::internalDrawPath(GrDrawContext* drawContext,
                                              const GrPaint& paint,
                                              const GrUserStencilSettings* userStencilSettings,
                                              const GrClip& clip,
@@ skipping 140 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 {
-            DefaultPathBatch::Geometry geometry;
-            geometry.fColor = color;
-            geometry.fPath = path;
-            geometry.fTolerance = srcSpaceTol;
-
-            SkAutoTUnref<GrDrawBatch> batch(DefaultPathBatch::Create(geometry, newCoverage,
-                                                                     viewMatrix, isHairline,
-                                                                     devBounds));
+            SkAutoTUnref<GrDrawBatch> batch(new DefaultPathBatch(color, path, srcSpaceTol,
+                                                                 newCoverage, viewMatrix,
+                                                                 isHairline, devBounds));
 
             GrPipelineBuilder pipelineBuilder(paint, drawContext->mustUseHWAA(paint));
             pipelineBuilder.setDrawFace(drawFace[p]);
             if (passes[p]) {
                 pipelineBuilder.setUserStencil(passes[p]);
             } else {
                 pipelineBuilder.setUserStencil(userStencilSettings);
             }
             if (passCount > 1) {
                 pipelineBuilder.setDisableColorXPFactory();
@@ skipping 49 matching lines @@
     // For now just hairlines because the other types of draws require two batches.
     // TODO we should figure out a way to combine the stencil and cover steps into one batch
     GrStyle style(SkStrokeRec::kHairline_InitStyle);
     SkPath path = GrTest::TestPath(random);
 
     // Compute srcSpaceTol
     SkRect bounds = path.getBounds();
     SkScalar tol = GrPathUtils::kDefaultTolerance;
     SkScalar srcSpaceTol = GrPathUtils::scaleToleranceToSrc(tol, viewMatrix, bounds);
 
-    DefaultPathBatch::Geometry geometry;
-    geometry.fColor = color;
-    geometry.fPath = path;
-    geometry.fTolerance = srcSpaceTol;
-
     viewMatrix.mapRect(&bounds);
     uint8_t coverage = GrRandomCoverage(random);
-    return DefaultPathBatch::Create(geometry, coverage, viewMatrix, true, bounds);
+    return new DefaultPathBatch(color, path, srcSpaceTol, coverage, viewMatrix, true, bounds);
 }
 
 #endif