Move bounds to GrBatch

src/gpu/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 "GrBatch.h"
@@ skipping 681 matching lines @@
     return true;
 }
 
 class AAHairlineBatch : public GrBatch {
 public:
     struct Geometry {
         GrColor fColor;
         uint8_t fCoverage;
         SkMatrix fViewMatrix;
         SkPath fPath;
-        SkDEBUGCODE(SkRect fDevBounds;)
         SkIRect fDevClipBounds;
     };
 
     // TODO Batch itself should not hold on to index buffers.  Instead, these should live in the
     // cache.
     static GrBatch* Create(const Geometry& geometry, const GrIndexBuffer* linesIndexBuffer,
                            const GrIndexBuffer* quadsIndexBuffer) {
         return SkNEW_ARGS(AAHairlineBatch, (geometry, linesIndexBuffer, quadsIndexBuffer));
     }
 
@@ skipping 14 matching lines @@
         } else if (GrColor_ILLEGAL != init.fOverrideColor) {
             fGeoData[0].fColor = init.fOverrideColor;
         }
 
         // setup batch properties
         fBatch.fColorIgnored = init.fColorIgnored;
         fBatch.fColor = fGeoData[0].fColor;
         fBatch.fUsesLocalCoords = init.fUsesLocalCoords;
         fBatch.fCoverageIgnored = init.fCoverageIgnored;
         fBatch.fCoverage = fGeoData[0].fCoverage;
-        SkDEBUGCODE(fBatch.fDevBounds = fGeoData[0].fDevBounds;)
     }
 
     void generateGeometry(GrBatchTarget* batchTarget, const GrPipeline* pipeline) override;
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
     typedef SkTArray<SkPoint, true> PtArray;
     typedef SkTArray<int, true> IntArray;
     typedef SkTArray<float, true> FloatArray;
 
     AAHairlineBatch(const Geometry& geometry, const GrIndexBuffer* linesIndexBuffer,
                     const GrIndexBuffer* quadsIndexBuffer)
         : fLinesIndexBuffer(linesIndexBuffer)
         , fQuadsIndexBuffer(quadsIndexBuffer) {
         SkASSERT(linesIndexBuffer && quadsIndexBuffer);
         this->initClassID<AAHairlineBatch>();
         fGeoData.push_back(geometry);
+
+        // compute bounds
+        fBounds = geometry.fPath.getBounds();
+        geometry.fViewMatrix.mapRect(&fBounds);
     }
 
     bool onCombineIfPossible(GrBatch* t) override {
         AAHairlineBatch* that = t->cast<AAHairlineBatch>();
 
         if (this->viewMatrix().hasPerspective() != that->viewMatrix().hasPerspective()) {
             return false;
         }
 
         // We go to identity if we don't have perspective
@@ skipping 12 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());
+        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; }
 
     struct BatchTracker {
         GrColor fColor;
@@ skipping 242 matching lines @@
     SkScalar hairlineCoverage;
     uint8_t newCoverage = 0xff;
     if (IsStrokeHairlineOrEquivalent(stroke, viewMatrix, &hairlineCoverage)) {
         newCoverage = SkScalarRoundToInt(hairlineCoverage * 0xff);
     }
 
     SkIRect devClipBounds;
     pipelineBuilder->clip().getConservativeBounds(pipelineBuilder->getRenderTarget(),
                                                   &devClipBounds);
 
-    // This outset was determined experimentally by running skps and gms.  It probably could be a
-    // bit tighter
-    SkRect devRect = path.getBounds();
-    viewMatrix.mapRect(&devRect);
-    devRect.outset(2, 2);
-
     AAHairlineBatch::Geometry geometry;
     geometry.fColor = color;
     geometry.fCoverage = newCoverage;
     geometry.fViewMatrix = viewMatrix;
     geometry.fPath = path;
-    SkDEBUGCODE(geometry.fDevBounds = devRect;)
     geometry.fDevClipBounds = devClipBounds;
 
     SkAutoTUnref<GrBatch> batch(AAHairlineBatch::Create(geometry, fLinesIndexBuffer,
                                                         fQuadsIndexBuffer));
-    target->drawBatch(pipelineBuilder, batch, &devRect);
+    target->drawBatch(pipelineBuilder, batch);
 
     return true;
 }