Move bounds to GrBatch

src/gpu/GrInOrderDrawBuffer.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 "GrInOrderDrawBuffer.h"
 
 #include "GrDefaultGeoProcFactory.h"
@@ skipping 194 matching lines @@
             instanceCount -= drawInfo.instanceCount();
        }
     }
 
     SkSTArray<1, Geometry, true>* geoData() { return &fGeoData; }
 
 private:
     RectBatch(const Geometry& geometry) {
         this->initClassID<RectBatch>();
         fGeoData.push_back(geometry);
+
+        fBounds = geometry.fRect;
+        geometry.fViewMatrix.mapRect(&fBounds);
     }
 
     GrColor color() const { return fBatch.fColor; }
     bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; }
     bool colorIgnored() const { return fBatch.fColorIgnored; }
     const SkMatrix& viewMatrix() const { return fGeoData[0].fViewMatrix; }
     const SkMatrix& localMatrix() const { return fGeoData[0].fLocalMatrix; }
     bool hasLocalRect() const { return fGeoData[0].fHasLocalRect; }
     bool hasLocalMatrix() const { return fGeoData[0].fHasLocalMatrix; }
 
@@ skipping 16 matching lines @@
 
             if (this->hasLocalMatrix() && !this->localMatrix().cheapEqualTo(that->localMatrix())) {
                 return false;
             }
         }
 
         if (this->color() != that->color()) {
             fBatch.fColor = GrColor_ILLEGAL;
         }
         fGeoData.push_back_n(that->geoData()->count(), that->geoData()->begin());
+        this->joinBounds(that->bounds());
         return true;
     }
 
     struct BatchTracker {
         GrColor fColor;
         bool fUsesLocalCoords;
         bool fColorIgnored;
         bool fCoverageIgnored;
     };
 
@@ skipping 23 matching lines @@
     }
 
     if (localMatrix) {
         geometry.fHasLocalMatrix = true;
         geometry.fLocalMatrix = *localMatrix;
     } else {
         geometry.fHasLocalMatrix = false;
     }
 
     SkAutoTUnref<GrBatch> batch(RectBatch::Create(geometry));
-
-    SkRect bounds = rect;
-    viewMatrix.mapRect(&bounds);
-    this->drawBatch(pipelineBuilder, batch, &bounds);
+    this->drawBatch(pipelineBuilder, batch);
 }
 
 void GrInOrderDrawBuffer::onDrawBatch(GrBatch* batch,
                                       const PipelineInfo& pipelineInfo) {
     GrTargetCommands::Cmd* cmd = fCommands.recordDrawBatch(this, batch, pipelineInfo);
     this->recordTraceMarkersIfNecessary(cmd);
 }
 
 void GrInOrderDrawBuffer::onStencilPath(const GrPipelineBuilder& pipelineBuilder,
                                         const GrPathProcessor* pathProc,
@@ skipping 84 matching lines @@
     const GrTraceMarkerSet& activeTraceMarkers = this->getActiveTraceMarkers();
     if (activeTraceMarkers.count() > 0) {
         if (cmd->isTraced()) {
             fGpuCmdMarkers[cmd->markerID()].addSet(activeTraceMarkers);
         } else {
             cmd->setMarkerID(fGpuCmdMarkers.count());
             fGpuCmdMarkers.push_back(activeTraceMarkers);
         }
     }
 }