Move bounds to GrBatch

src/gpu/effects/GrDashingEffect.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDashingEffect.h"
 
 #include "GrBatch.h"
@@ skipping 238 matching lines @@
     struct Geometry {
         GrColor fColor;
         SkMatrix fViewMatrix;
         SkMatrix fSrcRotInv;
         SkPoint fPtsRot[2];
         SkScalar fSrcStrokeWidth;
         SkScalar fPhase;
         SkScalar fIntervals[2];
         SkScalar fParallelScale;
         SkScalar fPerpendicularScale;
-        SkDEBUGCODE(SkRect fDevBounds;)
     };
 
     static GrBatch* Create(const Geometry& geometry, SkPaint::Cap cap, DashAAMode aaMode,
                            bool fullDash) {
         return SkNEW_ARGS(DashBatch, (geometry, cap, aaMode, fullDash));
     }
 
     const char* name() const override { return "DashBatch"; }
 
     void getInvariantOutputColor(GrInitInvariantOutput* out) const override {
@@ skipping 90 matching lines @@
 
             SkScalar strokeAdj;
             if (!hasCap) {
                 strokeAdj = 0.f;
             } else {
                 strokeAdj = halfSrcStroke;
             }
 
             SkScalar startAdj = 0;
 
-            SkMatrix& combinedMatrix = args.fSrcRotInv;
-            combinedMatrix.postConcat(args.fViewMatrix);
-
             bool lineDone = false;
 
             // Too simplify the algorithm, we always push back rects for start and end rect.
             // Otherwise we'd have to track start / end rects for each individual geometry
             rects.push_back();
             rects.push_back();
             rects.push_back();
             SkRect& bounds = rects[rectOffset++];
             SkRect& startRect = rects[rectOffset++];
             SkRect& endRect = rects[rectOffset++];
@@ skipping 256 matching lines @@
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
     DashBatch(const Geometry& geometry, SkPaint::Cap cap, DashAAMode aaMode, bool fullDash) {
         this->initClassID<DashBatch>();
         fGeoData.push_back(geometry);
 
         fBatch.fAAMode = aaMode;
         fBatch.fCap = cap;
         fBatch.fFullDash = fullDash;
+
+        // compute bounds
+        SkScalar halfStrokeWidth = 0.5f * geometry.fSrcStrokeWidth;
+        SkScalar xBloat = SkPaint::kButt_Cap == cap ? 0 : halfStrokeWidth;
+        fBounds.set(geometry.fPtsRot[0], geometry.fPtsRot[1]);
+        fBounds.outset(xBloat, halfStrokeWidth);
+
+        // Note, we actually create the combined matrix here, and save the work
+        SkMatrix& combinedMatrix = fGeoData[0].fSrcRotInv;
+        combinedMatrix.postConcat(geometry.fViewMatrix);
+        combinedMatrix.mapRect(&fBounds);
     }
 
     bool onCombineIfPossible(GrBatch* t) override {
         DashBatch* that = t->cast<DashBatch>();
 
         if (this->aaMode() != that->aaMode()) {
             return false;
         }
 
         if (this->fullDash() != that->fullDash()) {
             return false;
         }
 
         if (this->cap() != that->cap()) {
             return false;
         }
 
         // TODO vertex color
         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; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
     DashAAMode aaMode() const { return fBatch.fAAMode; }
     bool fullDash() const { return fBatch.fFullDash; }
     SkPaint::Cap cap() const { return fBatch.fCap; }
 
@@ skipping 677 matching lines @@
     info.fIntervals = intervals;
     info.fCount = 2;
     info.fPhase = phase;
     SkDEBUGCODE(bool success = ) strokeInfo.setDashInfo(info);
     SkASSERT(success);
 
     return create_batch(color, viewMatrix, pts, useAA, strokeInfo, msaaRT);
 }
 
 #endif