Use transfer buffer for BatchAtlas texture copies

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
 
 #include "GrTexture.h"
 #include "SkPoint.h"
 #include "SkTDArray.h"
 #include "SkTInternalLList.h"
 
 #include "batches/GrDrawBatch.h"
 
 class GrRectanizer;
+class GrResourceProvider;
+class GrBuffer;
 
 struct GrBatchAtlasConfig {
     int numPlotsX() const { return fWidth / fPlotWidth; }
     int numPlotsY() const { return fHeight / fPlotWidth; }
     int fWidth;
     int fHeight;
     int fLog2Width;
     int fLog2Height;
     int fPlotWidth;
     int fPlotHeight;
 };
 
 class GrBatchAtlas {
 public:
     // An AtlasID is an opaque handle which callers can use to determine if the atlas contains
     // a specific piece of data
     typedef uint64_t AtlasID;
     static const uint32_t kInvalidAtlasID = 0;
     static const uint64_t kInvalidAtlasGeneration = 0;
 
     // A function pointer for use as a callback during eviction.  Whenever GrBatchAtlas evicts a
     // specific AtlasID, it will call all of the registered listeners so they can optionally process
     // the eviction
     typedef void (*EvictionFunc)(GrBatchAtlas::AtlasID, void*);
 
-    GrBatchAtlas(GrTexture*, int numPlotsX, int numPlotsY);
+    GrBatchAtlas(GrResourceProvider*, GrTexture*, int numPlotsX, int numPlotsY);
     ~GrBatchAtlas();
 
     // Adds a width x height subimage to the atlas. Upon success it returns
     // the containing GrPlot and absolute location in the backing texture.
     // nullptr is returned if the subimage cannot fit in the atlas.
     // If provided, the image data will be written to the CPU-side backing bitmap.
     // NOTE: If the client intends to refer to the atlas, they should immediately call 'setUseToken'
     // with the currentToken from the batch target, otherwise the next call to addToAtlas might
     // cause an eviction
     bool addToAtlas(AtlasID*, GrDrawBatch::Target*, int width, int height, const void* image,
@@ skipping 110 matching lines @@
         // 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.
         GrBatchDrawToken lastUploadToken() const { return fLastUpload; }
         GrBatchDrawToken lastUseToken() const { return fLastUse; }
         void setLastUploadToken(GrBatchDrawToken batchToken) { fLastUpload = batchToken; }
         void setLastUseToken(GrBatchDrawToken batchToken) { fLastUse = batchToken; }
 
-        void uploadToTexture(GrDrawBatch::WritePixelsFn&, GrTexture* texture);
+        void uploadToTexture(GrDrawBatch::WritePixelsFn&, GrDrawBatch::TransferPixelsFn&, 
+                             GrTexture* texture);
         void resetRects();
 
     private:
         BatchPlot(int index, uint64_t genID, int offX, int offY, int width, int height,
-                  GrPixelConfig config);
+                  GrPixelConfig config, GrResourceProvider* rp);
 
         ~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);
+            return new BatchPlot(fIndex, fGenID+1, fX, fY, fWidth, fHeight, fConfig,
+                                 fResourceProvider);
         }
 
         static GrBatchAtlas::AtlasID CreateId(uint32_t index, uint64_t generation) {
             SkASSERT(index < (1 << 16));
             SkASSERT(generation < ((uint64_t)1 << 48));
             return generation << 16 | index;
         }
 
+        // used to create transfer buffers
+        GrResourceProvider*   fResourceProvider;
         GrBatchDrawToken      fLastUpload;
         GrBatchDrawToken      fLastUse;
 
         const uint32_t        fIndex;
         uint64_t              fGenID;
         GrBatchAtlas::AtlasID fID;
-        unsigned char*        fData;
+        unsigned char*        fDataPtr;
+        GrBuffer*             fTransferBuffer;
+        GrFence               fTransferFence;
         const int             fWidth;
         const int             fHeight;
         const int             fX;
         const int             fY;
         GrRectanizer*         fRects;
         const SkIPoint16      fOffset;        // the offset of the plot in the backing texture
         const GrPixelConfig   fConfig;
         const size_t          fBytesPerPixel;
         SkIRect               fDirtyRect;
         SkDEBUGCODE(bool      fDirty;)
@@ skipping 40 matching lines @@
     };
 
     SkTDArray<EvictionData> fEvictionCallbacks;
     // allocated array of GrBatchPlots
     SkAutoTUnref<BatchPlot>* fPlotArray;
     // LRU list of GrPlots (MRU at head - LRU at tail)
     GrBatchPlotList fPlotList;
 };
 
 #endif