Simplify GrDrawBatch uploads and token uage.

src/gpu/GrBatchAtlas.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrBatchAtlas_DEFINED
 #define GrBatchAtlas_DEFINED
 
@@ skipping 47 matching lines @@
 
     uint64_t atlasGeneration() const { return fAtlasGeneration; }
 
     inline bool hasID(AtlasID id) {
         uint32_t index = GetIndexFromID(id);
         SkASSERT(index < fNumPlots);
         return fPlotArray[index]->genID() == GetGenerationFromID(id);
     }
 
     // To ensure the atlas does not evict a given entry, the client must set the last use token
-    inline void setLastUseToken(AtlasID id, GrBatchToken batchToken) {
+    inline void setLastUseToken(AtlasID id, GrBatchDrawToken batchToken) {
         SkASSERT(this->hasID(id));
         uint32_t index = GetIndexFromID(id);
         SkASSERT(index < fNumPlots);
         this->makeMRU(fPlotArray[index]);
         fPlotArray[index]->setLastUseToken(batchToken);
     }
 
     inline void registerEvictionCallback(EvictionFunc func, void* userData) {
         EvictionData* data = fEvictionCallbacks.append();
         data->fFunc = func;
@@ skipping 38 matching lines @@
         }
 
         static const int kMinItems = 4;
         static const int kMaxPlots = 32;
         SkSTArray<kMinItems, int, true> fPlotsToUpdate;
         uint32_t fPlotAlreadyUpdated;
 
         friend class GrBatchAtlas;
     };
 
-    void setLastUseTokenBulk(const BulkUseTokenUpdater& updater, GrBatchToken batchToken) {
+    void setLastUseTokenBulk(const BulkUseTokenUpdater& updater, GrBatchDrawToken batchToken) {
         int count = updater.fPlotsToUpdate.count();
         for (int i = 0; i < count; i++) {
             BatchPlot* plot = fPlotArray[updater.fPlotsToUpdate[i]];
             this->makeMRU(plot);
             plot->setLastUseToken(batchToken);
         }
     }
 
     static const int kGlyphMaxDim = 256;
     static bool GlyphTooLargeForAtlas(int width, int height) {
@@ skipping 22 matching lines @@
         }
         SkDEBUGCODE(size_t bpp() const { return fBytesPerPixel; })
 
         bool addSubImage(int width, int height, const void* image, SkIPoint16* loc);
 
         // To manage the lifetime of a plot, we use two tokens.  We use the last upload token to
         // know when we can 'piggy back' uploads, ie if the last upload hasn't been flushed to gpu,
         // we don't need to issue a new upload even if we update the cpu backing store.  We use
         // lastUse to determine when we can evict a plot from the cache, ie if the last use has
         // already flushed through the gpu then we can reuse the plot.
-        GrBatchToken lastUploadToken() const { return fLastUpload; }
-        GrBatchToken lastUseToken() const { return fLastUse; }
-        void setLastUploadToken(GrBatchToken batchToken) {
-            SkASSERT(batchToken >= fLastUpload);
-            fLastUpload = batchToken;
-        }
-        void setLastUseToken(GrBatchToken batchToken) {
-            SkASSERT(batchToken >= fLastUse);
-            fLastUse = batchToken;
-        }
+        GrBatchDrawToken lastUploadToken() const { return fLastUpload; }
+        GrBatchDrawToken lastUseToken() const { return fLastUse; }
+        void setLastUploadToken(GrBatchDrawToken batchToken) { fLastUpload = batchToken; }
+        void setLastUseToken(GrBatchDrawToken batchToken) { fLastUse = batchToken; }
 
-        void uploadToTexture(GrBatchUploader::TextureUploader* uploader, GrTexture* texture);
+        void uploadToTexture(GrDrawBatch::WritePixelsFn&, GrTexture* texture);
         void resetRects();
 
     private:
         BatchPlot(int index, uint64_t genID, int offX, int offY, int width, int height,
                   GrPixelConfig config);
 
         ~BatchPlot() override;
 
         // Create a clone of this plot. The cloned plot will take the place of the
         // current plot in the atlas.
         BatchPlot* clone() const {
             return new BatchPlot(fIndex, fGenID+1, fX, fY, fWidth, fHeight, fConfig);
         }
 
         static GrBatchAtlas::AtlasID CreateId(uint32_t index, uint64_t generation) {
             SkASSERT(index < (1 << 16));
             SkASSERT(generation < ((uint64_t)1 << 48));
             return generation << 16 | index;
         }
 
-        GrBatchToken          fLastUpload;
-        GrBatchToken          fLastUse;
+        GrBatchDrawToken      fLastUpload;
+        GrBatchDrawToken      fLastUse;
 
         const uint32_t        fIndex;
         uint64_t              fGenID;
         GrBatchAtlas::AtlasID fID;
         unsigned char*        fData;
         const int             fWidth;
         const int             fHeight;
         const int             fX;
         const int             fY;
         GrRectanizer*         fRects;
@@ skipping 25 matching lines @@
         if (fPlotList.head() == plot) {
             return;
         }
 
         fPlotList.remove(plot);
         fPlotList.addToHead(plot);
     }
 
     inline void processEviction(AtlasID);
 
-    friend class GrPlotUploader; // to access GrBatchPlot
-
     GrTexture* fTexture;
     SkDEBUGCODE(uint32_t fNumPlots;)
 
     uint64_t fAtlasGeneration;
 
     struct EvictionData {
         EvictionFunc fFunc;
         void* fData;
     };
 
     SkTDArray<EvictionData> fEvictionCallbacks;
     // allocated array of GrBatchPlots
     SkAutoTUnref<BatchPlot>* fPlotArray;
     // LRU list of GrPlots (MRU at head - LRU at tail)
     GrBatchPlotList fPlotList;
 };
 
 #endif