Simplify GrDrawBatch uploads and token uage.

src/gpu/batches/GrDrawBatch.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 GrDrawBatch_DEFINED
 #define GrDrawBatch_DEFINED
 
+#include <functional>
 #include "GrBatch.h"
 #include "GrPipeline.h"
 
 struct GrInitInvariantOutput;
 
 /**
  * GrDrawBatches are flushed in two phases (preDraw, and draw). In preDraw uploads to GrGpuResources
  * and draws are determined and scheduled. They are issued in the draw phase. GrBatchToken is used
  * to sequence the uploads relative to each other and to draws.
  **/
 
-typedef uint64_t GrBatchToken;
+class GrBatchDrawToken {
+public:
+    static GrBatchDrawToken AlreadyFlushedToken() { return GrBatchDrawToken(0); }
 
-class GrBatchUploader : public SkRefCnt {
-public:
-    class TextureUploader;
-
-    GrBatchUploader(GrBatchToken lastUploadToken) : fLastUploadToken(lastUploadToken) {}
-    GrBatchToken lastUploadToken() const { return fLastUploadToken; }
-    virtual void upload(TextureUploader*)=0;
+    GrBatchDrawToken(const GrBatchDrawToken& that) : fSequenceNumber(that.fSequenceNumber) {}
+    GrBatchDrawToken& operator =(const GrBatchDrawToken& that) {
+        fSequenceNumber = that.fSequenceNumber;
+        return *this;
+    }
+    bool operator==(const GrBatchDrawToken& that) const {
+        return fSequenceNumber == that.fSequenceNumber;
+    }
+    bool operator!=(const GrBatchDrawToken& that) const { return !(*this == that); }
 
 private:
-    GrBatchToken fLastUploadToken;
+    GrBatchDrawToken();
+    explicit GrBatchDrawToken(uint64_t sequenceNumber) : fSequenceNumber(sequenceNumber) {}
+    friend class GrBatchFlushState;
+    uint64_t fSequenceNumber;
 };
 
 /**
  * Base class for GrBatches that draw. These batches have a GrPipeline installed by GrDrawTarget.
  */
 class GrDrawBatch : public GrBatch {
 public:
+    /** Method that performs an upload on behalf of a DeferredUploadFn. */
+    using WritePixelsFn = std::function<bool(GrSurface* texture,
+                                             int left, int top, int width, int height,
+                                             GrPixelConfig config, const void* buffer,
+                                             size_t rowBytes)>;
+    /** See comments before GrDrawBatch::Target definition on how deferred uploaders work. */

[egdaniel, 2016/03/30 15:52:33]

Can you comment on where GrDrawBatch::Target definition actually is? It does not
seem obvious that it is actually declared in another class's header file

[bsalomon, 2016/03/30 16:59:11]

Not crazy about doing that for 3 reasons: 1) Likelihood that comments about what
files things are in will get out of date is pretty high, 2) I'd like to try to
rearrange where things are defined soon after this CL, 3) seems pretty simple to
grep for it.

+    using DeferredUploadFn = std::function<void(WritePixelsFn&)>;
+
     class Target;
 
     GrDrawBatch(uint32_t classID);
     ~GrDrawBatch() override;
 
     /**
      * Fills in a structure informing the XP of overrides to its normal behavior.
      */
     void getPipelineOptimizations(GrPipelineOptimizations* override) const;
 
@@ skipping 42 matching lines @@
                                               GrBatchToXPOverrides* overrides) const = 0;
 
 private:
     /**
      * initBatchTracker is a hook for the some additional overrides / optimization possibilities
      * from the GrXferProcessor.
      */
     virtual void initBatchTracker(const GrXPOverridesForBatch&) = 0;
 
 protected:
-    SkTArray<SkAutoTUnref<GrBatchUploader>, true>   fInlineUploads;
+    struct QueuedUpload {
+        QueuedUpload(DeferredUploadFn&& upload, GrBatchDrawToken token)
+            : fUpload(std::move(upload))
+            , fUploadBeforeToken(token) {}
+        DeferredUploadFn    fUpload;
+        GrBatchDrawToken    fUploadBeforeToken;
+    };
+    SkTArray<QueuedUpload>   fInlineUploads;
 
 private:
     SkAlignedSTStorage<1, GrPipeline>               fPipelineStorage;
     bool                                            fPipelineInstalled;
     typedef GrBatch INHERITED;
 };
 
 #endif