Add transfer buffer support.

src/gpu/GrTransferBuffer.h

Index: src/gpu/GrTransferBuffer.h
diff --git a/src/gpu/GrTransferBuffer.h b/src/gpu/GrTransferBuffer.h
new file mode 100755
index 0000000000000000000000000000000000000000..5bb6f97c6776f1b671bbf596840e79c100f8660f
--- /dev/null
+++ b/src/gpu/GrTransferBuffer.h
@@ -0,0 +1,100 @@
+
+/*
+ * 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 GrTransferBuffer_DEFINED
+#define GrTransferBuffer_DEFINED
+
+#include "GrGpuResource.h"
+
+class GrTransferBuffer : public GrGpuResource {
+public:
+    /**
+    * Maps the buffer to be written by the CPU.
+    *
+    * The previous content of the buffer is invalidated. It is an error

[bsalomon, 2015/12/02 16:38:31]

Looks like these comments came from geometrybuffer... wondering if it makes
sense to drop language around no map support since these wouldn't be useful at
all without mapping IIUC.

[jvanverth1, 2015/12/02 18:05:07]

Done.

+    * to draw from the buffer while it is mapped. It is an error to call map
+    * on an already mapped buffer. It may fail if the backend doesn't support
+    * mapping the buffer. If the buffer is CPU backed then it will always
+    * succeed and is a free operation. Must be matched by an unmap() call.
+    * Currently only one map at a time is supported (no nesting of
+    * map/unmap).
+    *
+    * Note that buffer mapping does not go through GrContext and therefore is
+    * not serialized with other operations.
+    *
+    * @return a pointer to the data or nullptr if the map fails.
+    */
+    void* map() { return (fMapPtr = this->onMap()); }
+
+    /**
+    * Unmaps the buffer.
+    *
+    * The pointer returned by the previous map call will no longer be valid.
+    */
+    void unmap() {
+        SkASSERT(fMapPtr);
+        this->onUnmap();
+        fMapPtr = nullptr;
+    }
+
+    /**
+    * Returns the same ptr that map() returned at time of map or nullptr if the
+    * is not mapped.
+    *
+    * @return ptr to mapped buffer data or nullptr if buffer is not mapped.
+    */
+    void* mapPtr() const { return fMapPtr; }
+
+    /**
+    Queries whether the buffer has been mapped.
+
+    @return true if the buffer is mapped, false otherwise.
+    */
+    bool isMapped() const { return SkToBool(fMapPtr); }
+
+    /**
+    * Updates the buffer data.

[bsalomon, 2015/12/02 16:38:31]

Do we want this at all or should we just assume mapability?

[jvanverth1, 2015/12/02 18:05:07]

BufferData is supported by PBOs, as far as I can tell. But I don't think we'd
use it. Removed.

+    *
+    * The size of the buffer will be preserved. The src data will be
+    * placed at the beginning of the buffer and any remaining contents will
+    * be undefined. srcSizeInBytes must be <= to the buffer size.
+    *
+    * The buffer must not be mapped.
+    *
+    * Note that buffer updates do not go through GrContext and therefore are
+    * not serialized with other operations.
+    *
+    * @return returns true if the update succeeds, false otherwise.
+    */
+    bool updateData(const void* src, size_t srcSizeInBytes) {
+        SkASSERT(!this->isMapped());
+        SkASSERT(srcSizeInBytes <= fGpuMemorySize);
+        return this->onUpdateData(src, srcSizeInBytes);
+    }
+
+protected:
+    GrTransferBuffer(GrGpu* gpu, size_t gpuMemorySize)
+        : INHERITED(gpu, kUncached_LifeCycle)
+        , fGpuMemorySize(gpuMemorySize) {
+    }
+
+private:
+    virtual size_t onGpuMemorySize() const { return fGpuMemorySize; }
+
+    virtual bool onUpdateData(const void* src, size_t srcSizeInBytes) = 0;
+    virtual void* onMap() = 0;
+    virtual void  onUnmap() = 0;
+
+    void*    fMapPtr;
+    size_t   fGpuMemorySize;
+
+    typedef GrGpuResource INHERITED;
+};
+
+#endif