Use bounds of batches for render pass bounds

src/gpu/GrDrawTarget.cpp

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrDrawTarget.h"
 
 #include "GrAuditTrail.h"
@@ skipping 197 matching lines @@
     if (fInstancedRendering) {
         fInstancedRendering->beginFlush(flushState->resourceProvider());
     }
 }
 
 void GrDrawTarget::drawBatches(GrBatchFlushState* flushState) {
     // Draw all the generated geometry.
     SkRandom random;
     GrRenderTarget* currentRT = nullptr;
     SkAutoTDelete<GrGpuCommandBuffer> commandBuffer;
+    SkRect bounds = SkRect::MakeEmpty();
     for (int i = 0; i < fBatches.count(); ++i) {
         if (!fBatches[i]) {
             continue;
         }
         if (fBatches[i]->renderTarget() != currentRT) {
             if (commandBuffer) {
                 commandBuffer->end();
-                // For now just use size of whole render target, but this should be updated to
-                // only be the actual bounds of the various draws.
-                SkIRect bounds = SkIRect::MakeWH(currentRT->width(), currentRT->height());
-                commandBuffer->submit(bounds);
+                if (bounds.intersect(0, 0,
+                                     SkIntToScalar(currentRT->width()),
+                                     SkIntToScalar(currentRT->height()))) {
+                    SkIRect iBounds;
+                    bounds.roundOut(&iBounds);
+                    commandBuffer->submit(iBounds);
+                }
                 commandBuffer.reset();
             }
+            bounds.setEmpty();
             currentRT = fBatches[i]->renderTarget();
             if (currentRT) {
                 static const GrGpuCommandBuffer::LoadAndStoreInfo kBasicLoadStoreInfo
                     { GrGpuCommandBuffer::LoadOp::kLoad,GrGpuCommandBuffer::StoreOp::kStore,
                       GrColor_ILLEGAL };
                 commandBuffer.reset(fGpu->createCommandBuffer(currentRT,
                                                               kBasicLoadStoreInfo,   // Color
                                                               kBasicLoadStoreInfo)); // Stencil
             }
             flushState->setCommandBuffer(commandBuffer);
         }
+        if (commandBuffer) {
+            bounds.join(fBatches[i]->bounds());
+        }
         if (fDrawBatchBounds) {
-            const SkRect& bounds = fBatches[i]->bounds();
-            SkIRect ibounds;
-            bounds.roundOut(&ibounds);
+            const SkRect& batchBounds = fBatches[i]->bounds();
+            SkIRect iBatchBounds;
+            batchBounds.roundOut(&iBatchBounds);
             // In multi-draw buffer all the batches use the same render target and we won't need to
             // get the batchs bounds.
             if (GrRenderTarget* rt = fBatches[i]->renderTarget()) {
-                fGpu->drawDebugWireRect(rt, ibounds, 0xFF000000 | random.nextU());
+                fGpu->drawDebugWireRect(rt, iBatchBounds, 0xFF000000 | random.nextU());
             }
         }
         fBatches[i]->draw(flushState);
     }
     if (commandBuffer) {
         commandBuffer->end();
-        // For now just use size of whole render target, but this should be updated to
-        // only be the actual bounds of the various draws.
-        SkIRect bounds = SkIRect::MakeWH(currentRT->width(), currentRT->height());
-        commandBuffer->submit(bounds);
+        if (bounds.intersect(0, 0,
+                             SkIntToScalar(currentRT->width()),
+                             SkIntToScalar(currentRT->height()))) {
+            SkIRect iBounds;
+            bounds.roundOut(&iBounds);
+            commandBuffer->submit(iBounds);
+        }
         flushState->setCommandBuffer(nullptr);
     }
 
     fGpu->finishDrawTarget();
 }
 
 void GrDrawTarget::reset() {
     fBatches.reset();
     if (fInstancedRendering) {
         fInstancedRendering->endFlush();
@@ skipping 291 matching lines @@
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrDrawTarget::clearStencilClip(const SkIRect& rect, bool insideClip, GrRenderTarget* rt) {
     GrBatch* batch = new GrClearStencilClipBatch(rect, insideClip, rt);
     this->recordBatch(batch);
     batch->unref();
 }