Hide more GrBatch Geometry structs.

src/gpu/batches/GrAAHairLinePathRenderer.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 "GrAAHairLinePathRenderer.h"
 
 #include "GrBatchFlushState.h"
@@ skipping 658 matching lines @@
         return tolDevBounds.contains(actualBounds);
     }
 
     return true;
 }
 
 class AAHairlineBatch : public GrVertexBatch {
 public:
     DEFINE_BATCH_CLASS_ID
 
-    struct Geometry {
-        GrColor fColor;
-        uint8_t fCoverage;
-        SkMatrix fViewMatrix;
-        SkPath fPath;
-        SkIRect fDevClipBounds;
-    };
+    AAHairlineBatch(GrColor color,
+                    uint8_t coverage,
+                    const SkMatrix& viewMatrix,
+                    const SkPath& path,
+                    SkIRect devClipBounds) : INHERITED(ClassID()) {
+        fGeoData.emplace_back(Geometry{color, coverage, viewMatrix, path, devClipBounds});
 
-    static GrDrawBatch* Create(const Geometry& geometry) { return new AAHairlineBatch(geometry); }
+        // compute bounds
+        fBounds = path.getBounds();
+        viewMatrix.mapRect(&fBounds);
+
+        // 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.
+        fBounds.outset(0.5f, 0.5f);
+    }
 
     const char* name() const override { return "AAHairlineBatch"; }
 
     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->setUnknownSingleComponent();
     }
 
 private:
     void initBatchTracker(const GrXPOverridesForBatch& overrides) override {
         // Handle any color overrides
         if (!overrides.readsColor()) {
             fGeoData[0].fColor = GrColor_ILLEGAL;
         }
         overrides.getOverrideColorIfSet(&fGeoData[0].fColor);
 
         // setup batch properties
         fBatch.fColorIgnored = !overrides.readsColor();
         fBatch.fColor = fGeoData[0].fColor;
         fBatch.fUsesLocalCoords = overrides.readsLocalCoords();
         fBatch.fCoverageIgnored = !overrides.readsCoverage();
         fBatch.fCoverage = fGeoData[0].fCoverage;
     }
 
-    SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
-
     void onPrepareDraws(Target*) const override;
 
     typedef SkTArray<SkPoint, true> PtArray;
     typedef SkTArray<int, true> IntArray;
     typedef SkTArray<float, true> FloatArray;
 
-    AAHairlineBatch(const Geometry& geometry) : INHERITED(ClassID()) {
-        fGeoData.push_back(geometry);
-
-        // compute bounds
-        fBounds = geometry.fPath.getBounds();
-        geometry.fViewMatrix.mapRect(&fBounds);
-
-        // 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.
-        fBounds.outset(0.5f, 0.5f);
-    }
-
     bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override {
         AAHairlineBatch* that = t->cast<AAHairlineBatch>();
 
         if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(),
                                     that->bounds(), caps)) {
             return false;
         }
 
         if (this->viewMatrix().hasPerspective() != that->viewMatrix().hasPerspective()) {
             return false;
@@ skipping 14 matching lines @@
 
         if (this->color() != that->color()) {
             return false;
         }
 
         SkASSERT(this->usesLocalCoords() == that->usesLocalCoords());
         if (this->usesLocalCoords() && !this->viewMatrix().cheapEqualTo(that->viewMatrix())) {
             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;
     }
 
     GrColor color() const { return fBatch.fColor; }
     uint8_t coverage() const { return fBatch.fCoverage; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
     bool coverageIgnored() const { return fBatch.fCoverageIgnored; }
 
+
+    struct Geometry {
+        GrColor fColor;
+        uint8_t fCoverage;
+        SkMatrix fViewMatrix;
+        SkPath fPath;
+        SkIRect fDevClipBounds;
+    };
+
     struct BatchTracker {
         GrColor fColor;
         uint8_t fCoverage;
         SkRect fDevBounds;
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
     };
 
     BatchTracker fBatch;
@@ skipping 156 matching lines @@
                                           const SkMatrix& viewMatrix,
                                           const SkPath& path,
                                           const GrStyle& style,
                                           const SkIRect& devClipBounds) {
     SkScalar hairlineCoverage;
     uint8_t newCoverage = 0xff;
     if (GrPathRenderer::IsStrokeHairlineOrEquivalent(style, viewMatrix, &hairlineCoverage)) {
         newCoverage = SkScalarRoundToInt(hairlineCoverage * 0xff);
     }
 
-    AAHairlineBatch::Geometry geometry;
-    geometry.fColor = color;
-    geometry.fCoverage = newCoverage;
-    geometry.fViewMatrix = viewMatrix;
-    geometry.fPath = path;
-    geometry.fDevClipBounds = devClipBounds;
-
-    return AAHairlineBatch::Create(geometry);
+    return new AAHairlineBatch(color, newCoverage, viewMatrix, path, devClipBounds);
 }
 
 bool GrAAHairLinePathRenderer::onDrawPath(const DrawPathArgs& args) {
     GR_AUDIT_TRAIL_AUTO_FRAME(args.fDrawContext->auditTrail(),
                               "GrAAHairlinePathRenderer::onDrawPath");
     SkASSERT(!args.fDrawContext->isUnifiedMultisampled());
 
     SkIRect devClipBounds;
     args.fClip->getConservativeBounds(args.fDrawContext->width(), args.fDrawContext->height(),
                                       &devClipBounds);
@@ skipping 17 matching lines @@
 DRAW_BATCH_TEST_DEFINE(AAHairlineBatch) {
     GrColor color = GrRandomColor(random);
     SkMatrix viewMatrix = GrTest::TestMatrix(random);
     SkPath path = GrTest::TestPath(random);
     SkIRect devClipBounds;
     devClipBounds.setEmpty();
     return create_hairline_batch(color, viewMatrix, path, GrStyle::SimpleHairline(), devClipBounds);
 }
 
 #endif