BitmapTextBatch and BitmapTextBlob

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 "GrBatchTarget.h"
 #include "GrGpu.h"
@@ skipping 209 matching lines @@
     typedef GrBatchTarget::Uploader INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrBatchAtlas::GrBatchAtlas(GrTexture* texture, int numPlotsX, int numPlotsY)
     : fTexture(texture)
     , fNumPlotsX(numPlotsX)
     , fNumPlotsY(numPlotsY)
     , fPlotWidth(texture->width() / numPlotsX)
-    , fPlotHeight(texture->height() / numPlotsY) {
+    , fPlotHeight(texture->height() / numPlotsY)
+    , fAtlasGeneration(kInvalidAtlasGeneration + 1) {
     SkASSERT(fPlotWidth * fNumPlotsX == texture->width());
     SkASSERT(fPlotHeight * fNumPlotsY == texture->height());
 
     // We currently do not support compressed atlases...
     SkASSERT(!GrPixelConfigIsCompressed(texture->desc().fConfig));
 
     // set up allocated plots
     fBPP = GrBytesPerPixel(texture->desc().fConfig);
     fPlotArray = SkNEW_ARRAY(SkAutoTUnref<BatchPlot>, (fNumPlotsX * fNumPlotsY));
 
     SkAutoTUnref<BatchPlot>* currPlot = fPlotArray;
     for (int y = fNumPlotsY - 1, r = 0; y >= 0; --y, ++r) {
         for (int x = fNumPlotsX - 1, c = 0; x >= 0; --x, ++c) {
             int id = r * fNumPlotsX + c;
             currPlot->reset(SkNEW(BatchPlot));
-            (*currPlot)->init(this, texture, id, 0, x, y, fPlotWidth, fPlotHeight, fBPP);
+            (*currPlot)->init(this, texture, id, 1, x, y, fPlotWidth, fPlotHeight, fBPP);
 
             // build LRU list
             fPlotList.addToHead(currPlot->get());
             ++currPlot;
         }
     }
 }
 
 GrBatchAtlas::~GrBatchAtlas() {
     SkSafeUnref(fTexture);
@@ skipping 54 matching lines @@
     // gpu
     plotIter.init(fPlotList, GrBatchPlotList::Iter::kTail_IterStart);
     plot = plotIter.get();
     SkASSERT(plot);
     if (batchTarget->isIssued(plot->lastRefToken())) {
         this->processEviction(plot->id());
         plot->resetRects();
         SkDEBUGCODE(bool verify = )plot->addSubImage(width, height, image, loc, fBPP * width);
         SkASSERT(verify);
         this->updatePlot(batchTarget, id, plot);
+        fAtlasGeneration++;
         return true;
     }
 
     // The least recently refed 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 ref 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->lastRefToken() == batchTarget->currentToken()) {
@@ skipping 14 matching lines @@
     newPlot->init(this, fTexture, index, ++generation, x, y, fPlotWidth, fPlotHeight, fBPP);
 
     fPlotList.addToHead(newPlot.get());
     SkDEBUGCODE(bool verify = )newPlot->addSubImage(width, height, image, loc, fBPP * width);
     SkASSERT(verify);
     newPlot->setLastUploadToken(batchTarget->currentToken());
     SkAutoTUnref<GrPlotUploader> uploader(SkNEW_ARGS(GrPlotUploader, (newPlot)));
     batchTarget->upload(uploader);
     *id = newPlot->id();
     plot->unref();
+    fAtlasGeneration++;
     return true;
 }
 
 bool GrBatchAtlas::hasID(AtlasID id) {
     int index = this->getIndexFromID(id);
     SkASSERT(index < fNumPlotsX * fNumPlotsY);
     return fPlotArray[index]->genID() == this->getGenerationFromID(id);
 }
 
 void GrBatchAtlas::setLastRefToken(AtlasID id, BatchToken batchToken) {
     SkASSERT(this->hasID(id));
     int index = this->getIndexFromID(id);
     this->makeMRU(fPlotArray[index]);
     fPlotArray[index]->setLastRefToken(batchToken);
 }