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)>;
+
+    /**
+     * Batches can insert uploads when preparing their draws. The can eithe be inserted before

[egdaniel, 2016/03/28 20:05:20]

The->They, eithe->either

+     * all the draws (of all batches in a flush), which is called an "asap upload", or schedule
+     * them between draws, which is called an "inline upload". ASAP uploads are typically used

[egdaniel, 2016/03/28 20:05:20]

Wouldn't you want inline uploads in the case where two draws want different
content in the same GrSurface?

[bsalomon, 2016/03/28 20:11:02]

Yes, mental slip

+     * when the content of the GrSurface must be modified between draws because two draws require
+     * different contents to appear in the surface.
+     */
+    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