Simplify GrDrawBatch uploads and token uage.

src/gpu/GrBatchAtlas.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrBatchAtlas.h"
 #include "GrBatchFlushState.h"
 #include "GrRectanizer.h"
 #include "GrTracing.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 
 GrBatchAtlas::BatchPlot::BatchPlot(int index, uint64_t genID, int offX, int offY, int width,
                                    int height, GrPixelConfig config)
-    : fLastUpload(0)
-    , fLastUse(0)
+    : fLastUpload(GrBatchDrawToken::AlreadyFlushedToken())
+    , fLastUse(GrBatchDrawToken::AlreadyFlushedToken())
     , fIndex(index)
     , fGenID(genID)
     , fID(CreateId(fIndex, fGenID))
     , fData(nullptr)
     , fWidth(width)
     , fHeight(height)
     , fX(offX)
     , fY(offY)
     , fRects(nullptr)
     , fOffset(SkIPoint16::Make(fX * fWidth, fY * fHeight))
@@ skipping 42 matching lines @@
 
     fDirtyRect.join(loc->fX, loc->fY, loc->fX + width, loc->fY + height);
 
     loc->fX += fOffset.fX;
     loc->fY += fOffset.fY;
     SkDEBUGCODE(fDirty = true;)
 
     return true;
 }
 
-void GrBatchAtlas::BatchPlot::uploadToTexture(GrBatchUploader::TextureUploader* uploader,
+void GrBatchAtlas::BatchPlot::uploadToTexture(GrDrawBatch::WritePixelsFn& writePixels,
                                               GrTexture* texture) {
     // We should only be issuing uploads if we are in fact dirty
     SkASSERT(fDirty && fData && texture);
     TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT("skia.gpu"), "GrBatchPlot::uploadToTexture");
     size_t rowBytes = fBytesPerPixel * fWidth;
     const unsigned char* dataPtr = fData;
     dataPtr += rowBytes * fDirtyRect.fTop;
     dataPtr += fBytesPerPixel * fDirtyRect.fLeft;
-    uploader->writeTexturePixels(texture,
-                                 fOffset.fX + fDirtyRect.fLeft, fOffset.fY + fDirtyRect.fTop,
-                                 fDirtyRect.width(), fDirtyRect.height(),
-                                 fConfig, dataPtr, rowBytes);
+    writePixels(texture, fOffset.fX + fDirtyRect.fLeft, fOffset.fY + fDirtyRect.fTop,
+                fDirtyRect.width(), fDirtyRect.height(), fConfig, dataPtr, rowBytes);
     fDirtyRect.setEmpty();
     SkDEBUGCODE(fDirty = false;)
 }
 
 void GrBatchAtlas::BatchPlot::resetRects() {
     if (fRects) {
         fRects->reset();
     }
 
     fGenID++;
     fID = CreateId(fIndex, fGenID);
 
     // zero out the plot
     if (fData) {
         sk_bzero(fData, fBytesPerPixel * fWidth * fHeight);
     }
 
     fDirtyRect.setEmpty();
     SkDEBUGCODE(fDirty = false;)
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-class GrPlotUploader : public GrBatchUploader {
-public:
-    GrPlotUploader(GrBatchAtlas::BatchPlot* plot, GrTexture* texture)
-        : INHERITED(plot->lastUploadToken())
-        , fPlot(SkRef(plot))
-        , fTexture(texture) {
-        SkASSERT(plot);
-    }
-
-    void upload(TextureUploader* uploader) override {
-        fPlot->uploadToTexture(uploader, fTexture);
-    }
-
-private:
-    SkAutoTUnref<GrBatchAtlas::BatchPlot> fPlot;
-    GrTexture* fTexture;
-
-    typedef GrBatchUploader INHERITED;
-};
-
 ///////////////////////////////////////////////////////////////////////////////
 
 GrBatchAtlas::GrBatchAtlas(GrTexture* texture, int numPlotsX, int numPlotsY)
     : fTexture(texture)
     , fAtlasGeneration(kInvalidAtlasGeneration + 1) {
 
     int plotWidth = texture->width() / numPlotsX;
     int plotHeight = texture->height() / numPlotsY;
     SkASSERT(numPlotsX * numPlotsY <= BulkUseTokenUpdater::kMaxPlots);
     SkASSERT(plotWidth * numPlotsX == texture->width());
@@ skipping 31 matching lines @@
         (*fEvictionCallbacks[i].fFunc)(id, fEvictionCallbacks[i].fData);
     }
 }
 
 inline void GrBatchAtlas::updatePlot(GrDrawBatch::Target* target, AtlasID* id, BatchPlot* plot) {
     this->makeMRU(plot);
 
     // If our most recent upload has already occurred then we have to insert a new
     // upload. Otherwise, we already have a scheduled upload that hasn't yet ocurred.
     // This new update will piggy back on that previously scheduled update.
-    if (target->hasTokenBeenFlushed(plot->lastUploadToken())) {
-        plot->setLastUploadToken(target->asapToken());
-        SkAutoTUnref<GrPlotUploader> uploader(new GrPlotUploader(plot, fTexture));
-        target->upload(uploader);
+    if (target->hasDrawBeenFlushed(plot->lastUploadToken())) {
+        // With c+14 we could move sk_sp into lamba to only ref once.
+        sk_sp<BatchPlot> plotsp(SkRef(plot));
+        GrTexture* texture = fTexture;
+        GrBatchDrawToken lastUploadToken = target->addAsapUpload(
+            [plotsp, texture] (GrDrawBatch::WritePixelsFn& writePixels) {
+               plotsp->uploadToTexture(writePixels, texture);
+            }
+        );
+        plot->setLastUploadToken(lastUploadToken);
     }
     *id = plot->id();
 }
 
-bool GrBatchAtlas::addToAtlas(AtlasID* id, GrDrawBatch::Target* batchTarget,
+bool GrBatchAtlas::addToAtlas(AtlasID* id, GrDrawBatch::Target* target,
                               int width, int height, const void* image, SkIPoint16* loc) {
     // We should already have a texture, TODO clean this up
     SkASSERT(fTexture);
 
     // now look through all allocated plots for one we can share, in Most Recently Refed order
     GrBatchPlotList::Iter plotIter;
     plotIter.init(fPlotList, GrBatchPlotList::Iter::kHead_IterStart);
     BatchPlot* plot;
     while ((plot = plotIter.get())) {
         SkASSERT(GrBytesPerPixel(fTexture->desc().fConfig) == plot->bpp());
         if (plot->addSubImage(width, height, image, loc)) {
-            this->updatePlot(batchTarget, id, plot);
+            this->updatePlot(target, id, plot);
             return true;
         }
         plotIter.next();
     }
 
     // If the above fails, then see if the least recently refed plot has already been flushed to the
     // gpu
     plot = fPlotList.tail();
     SkASSERT(plot);
-    if (batchTarget->hasTokenBeenFlushed(plot->lastUseToken())) {
+    if (target->hasDrawBeenFlushed(plot->lastUseToken())) {
         this->processEviction(plot->id());
         plot->resetRects();
         SkASSERT(GrBytesPerPixel(fTexture->desc().fConfig) == plot->bpp());
         SkDEBUGCODE(bool verify = )plot->addSubImage(width, height, image, loc);
         SkASSERT(verify);
-        this->updatePlot(batchTarget, id, plot);
+        this->updatePlot(target, id, plot);
         fAtlasGeneration++;
         return true;
     }
 
-    // The least recently used plot hasn't been flushed to the gpu yet, however, if we have flushed
-    // it to the batch target than we can reuse it.  Our last use token is guaranteed to be less
-    // than or equal to the current token.  If its 'less than' the current token, than we can spin
-    // off the plot (ie let the batch target manage it) and create a new plot in its place in our
-    // array.  If it is equal to the currentToken, then the caller has to flush draws to the batch
-    // target so we can spin off the plot
-    if (plot->lastUseToken() == batchTarget->currentToken()) {
+    // If this plot has been used in a draw that is currently being prepared by a batch, then we
+    // have to fail. This gives the batch a chance to enqueue the draw, and call back into this
+    // function. When that draw is enqueued, the draw token advances, and the subsequent call will
+    // continue past this branch and prepare an inline upload that will occur after the enqueued
+    // draw which references the plot's pre-upload content.
+    if (plot->lastUseToken() == target->nextDrawToken()) {
         return false;
     }
 
-    SkASSERT(plot->lastUseToken() < batchTarget->currentToken());
-    SkASSERT(!batchTarget->hasTokenBeenFlushed(batchTarget->currentToken()));
-
     SkASSERT(!plot->unique());  // The GrPlotUpdater should have a ref too
 
     this->processEviction(plot->id());
     fPlotList.remove(plot);
     SkAutoTUnref<BatchPlot>& newPlot = fPlotArray[plot->index()];
     newPlot.reset(plot->clone());
 
     fPlotList.addToHead(newPlot.get());
     SkASSERT(GrBytesPerPixel(fTexture->desc().fConfig) == newPlot->bpp());
     SkDEBUGCODE(bool verify = )newPlot->addSubImage(width, height, image, loc);
     SkASSERT(verify);
 
     // Note that this plot will be uploaded inline with the draws whereas the
     // one it displaced most likely was uploaded asap.
-    newPlot->setLastUploadToken(batchTarget->currentToken());
-    SkAutoTUnref<GrPlotUploader> uploader(new GrPlotUploader(newPlot, fTexture));
-    batchTarget->upload(uploader);
+    // With c+14 we could move sk_sp into lamba to only ref once.
+    sk_sp<BatchPlot> plotsp(SkRef(newPlot.get()));
+    GrTexture* texture = fTexture;
+    GrBatchDrawToken lastUploadToken = target->addInlineUpload(
+        [plotsp, texture] (GrDrawBatch::WritePixelsFn& writePixels) {
+            plotsp->uploadToTexture(writePixels, texture);
+        }
+    );
+    newPlot->setLastUploadToken(lastUploadToken);
+
     *id = newPlot->id();
 
     fAtlasGeneration++;
     return true;
 }