Move bounds to GrBatch

src/gpu/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 "GrBatch.h"
@@ skipping 199 matching lines @@
         }
     }
 }
 
 class DefaultPathBatch : public GrBatch {
 public:
     struct Geometry {
         GrColor fColor;
         SkPath fPath;
         SkScalar fTolerance;
-        SkDEBUGCODE(SkRect fDevBounds;)
     };
 
     static GrBatch* Create(const Geometry& geometry, uint8_t coverage, const SkMatrix& viewMatrix,
-                           bool isHairline) {
-        return SkNEW_ARGS(DefaultPathBatch, (geometry, coverage, viewMatrix, isHairline));
+                           bool isHairline, const SkRect& devBounds) {
+        return SkNEW_ARGS(DefaultPathBatch, (geometry, coverage, viewMatrix, isHairline,
+                                             devBounds));
     }
 
     const char* name() const override { return "DefaultPathBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
         // When this is called on a batch, there is only one geometry bundle
         out->setKnownFourComponents(fGeoData[0].fColor);
     }
     void getInvariantOutputCoverage(GrInitInvariantOutput* out) const override {
         out->setKnownSingleComponent(this->coverage());
@@ skipping 150 matching lines @@
 
         // put back reserves
         batchTarget->putBackIndices((size_t)(maxIndices - indexOffset));
         batchTarget->putBackVertices((size_t)(maxVertices - vertexOffset), (size_t)vertexStride);
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
     DefaultPathBatch(const Geometry& geometry, uint8_t coverage, const SkMatrix& viewMatrix,
-                     bool isHairline) {
+                     bool isHairline, const SkRect& devBounds) {
         this->initClassID<DefaultPathBatch>();
         fBatch.fCoverage = coverage;
         fBatch.fIsHairline = isHairline;
         fBatch.fViewMatrix = viewMatrix;
         fGeoData.push_back(geometry);
+
+        this->setBounds(devBounds);
     }
 
     bool onCombineIfPossible(GrBatch* t) override {
         DefaultPathBatch* that = t->cast<DefaultPathBatch>();
 
         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());
+        this->joinBounds(that->bounds());
         return true;
     }
 
     bool createGeom(void* vertices,
                     size_t vertexOffset,
                     void* indices,
                     size_t indexOffset,
                     int* vertexCnt,
                     int* indexCnt,
                     const SkPath& path,
@@ skipping 263 matching lines @@
             target->drawRect(pipelineBuilder, color, viewM, bounds, NULL, &localMatrix);
         } else {
             if (passCount > 1) {
                 pipelineBuilder->setDisableColorXPFactory();
             }
 
             DefaultPathBatch::Geometry geometry;
             geometry.fColor = color;
             geometry.fPath = path;
             geometry.fTolerance = srcSpaceTol;
-            SkDEBUGCODE(geometry.fDevBounds = devBounds;)
 
             SkAutoTUnref<GrBatch> batch(DefaultPathBatch::Create(geometry, newCoverage, viewMatrix,
-                                                                 isHairline));
+                                                                 isHairline, devBounds));
 
-            target->drawBatch(pipelineBuilder, batch, &devBounds);
+            target->drawBatch(pipelineBuilder, batch);
         }
     }
     return true;
 }
 
 bool GrDefaultPathRenderer::canDrawPath(const GrDrawTarget* target,
                                         const GrPipelineBuilder* pipelineBuilder,
                                         const SkMatrix& viewMatrix,
                                         const SkPath& path,
                                         const GrStrokeInfo& stroke,
@@ skipping 22 matching lines @@
 
 void GrDefaultPathRenderer::onStencilPath(GrDrawTarget* target,
                                           GrPipelineBuilder* pipelineBuilder,
                                           const SkMatrix& viewMatrix,
                                           const SkPath& path,
                                           const GrStrokeInfo& stroke) {
     SkASSERT(SkPath::kInverseEvenOdd_FillType != path.getFillType());
     SkASSERT(SkPath::kInverseWinding_FillType != path.getFillType());
     this->internalDrawPath(target, pipelineBuilder, GrColor_WHITE, viewMatrix, path, stroke, true);
 }