diff --git a/gn/gpu.gni b/gn/gpu.gni
index 261be7a..8edaf9b 100644
--- a/gn/gpu.gni
+++ b/gn/gpu.gni
@@ -188,6 +188,8 @@
   "$_src/gpu/GrSimpleMesh.h",
   "$_src/gpu/GrSoftwarePathRenderer.cpp",
   "$_src/gpu/GrSoftwarePathRenderer.h",
+  "$_src/gpu/GrStagingBuffer.cpp",
+  "$_src/gpu/GrStagingBuffer.h",
   "$_src/gpu/GrStencilAttachment.cpp",
   "$_src/gpu/GrStencilAttachment.h",
   "$_src/gpu/GrStencilClip.h",
@@ -770,8 +772,8 @@
   "$_src/gpu/dawn/GrDawnRenderTarget.h",
   "$_src/gpu/dawn/GrDawnRingBuffer.cpp",
   "$_src/gpu/dawn/GrDawnRingBuffer.h",
-  "$_src/gpu/dawn/GrDawnStagingManager.cpp",
-  "$_src/gpu/dawn/GrDawnStagingManager.h",
+  "$_src/gpu/dawn/GrDawnStagingBuffer.cpp",
+  "$_src/gpu/dawn/GrDawnStagingBuffer.h",
   "$_src/gpu/dawn/GrDawnStencilAttachment.cpp",
   "$_src/gpu/dawn/GrDawnStencilAttachment.h",
   "$_src/gpu/dawn/GrDawnTexture.cpp",
diff --git a/src/gpu/GrGpu.cpp b/src/gpu/GrGpu.cpp
index 6b8e47e..43adfba 100644
--- a/src/gpu/GrGpu.cpp
+++ b/src/gpu/GrGpu.cpp
@@ -26,6 +26,7 @@
 #include "src/gpu/GrResourceCache.h"
 #include "src/gpu/GrResourceProvider.h"
 #include "src/gpu/GrSemaphore.h"
+#include "src/gpu/GrStagingBuffer.h"
 #include "src/gpu/GrStencilAttachment.h"
 #include "src/gpu/GrStencilSettings.h"
 #include "src/gpu/GrSurfacePriv.h"
@@ -34,11 +35,15 @@
 #include "src/gpu/GrTracing.h"
 #include "src/utils/SkJSONWriter.h"
 
+static const size_t kMinStagingBufferSize = 32 * 1024;
+
 ////////////////////////////////////////////////////////////////////////////////
 
 GrGpu::GrGpu(GrContext* context) : fResetBits(kAll_GrBackendState), fContext(context) {}
 
-GrGpu::~GrGpu() {}
+GrGpu::~GrGpu() {
+    SkASSERT(fBusyStagingBuffers.isEmpty());
+}
 
 void GrGpu::disconnect(DisconnectType) {}
 
@@ -611,12 +616,44 @@
     return fSamplePatternDictionary.findOrAssignSamplePatternKey(sampleLocations);
 }
 
+#ifdef SK_DEBUG
+bool GrGpu::inStagingBuffers(GrStagingBuffer* b) const {
+    for (const auto& i : fStagingBuffers) {
+        if (b == i.get()) {
+            return true;
+        }
+    }
+    return false;
+}
+
+void GrGpu::validateStagingBuffers() const {
+    for (const auto& i : fStagingBuffers) {
+        GrStagingBuffer* buffer = i.get();
+        SkASSERT(fAvailableStagingBuffers.isInList(buffer) ||
+                 fActiveStagingBuffers.isInList(buffer) ||
+                 fBusyStagingBuffers.isInList(buffer));
+    }
+    for (auto b : fAvailableStagingBuffers) {
+        SkASSERT(this->inStagingBuffers(b));
+    }
+    for (auto b : fActiveStagingBuffers) {
+        SkASSERT(this->inStagingBuffers(b));
+    }
+    for (auto b : fBusyStagingBuffers) {
+        SkASSERT(this->inStagingBuffers(b));
+    }
+}
+#endif
+
 GrSemaphoresSubmitted GrGpu::finishFlush(GrSurfaceProxy* proxies[],
                                          int n,
                                          SkSurface::BackendSurfaceAccess access,
                                          const GrFlushInfo& info,
                                          const GrPrepareForExternalIORequests& externalRequests) {
     TRACE_EVENT0("skia.gpu", TRACE_FUNC);
+#ifdef SK_DEBUG
+    this->validateStagingBuffers();
+#endif
     this->stats()->incNumFinishFlushes();
     GrResourceProvider* resourceProvider = fContext->priv().resourceProvider();
 
@@ -650,6 +687,8 @@
         }
     }
 
+    this->unmapStagingBuffers();
+
     // We always want to try flushing, so do that before checking if we failed semaphore creation.
     if (!this->onFinishFlush(proxies, n, access, info, externalRequests) ||
         failedSemaphoreCreation) {
@@ -666,6 +705,12 @@
         return GrSemaphoresSubmitted::kNo;
     }
 
+    // Move all active staging buffers to the busy list.
+    while (GrStagingBuffer* buffer = fActiveStagingBuffers.head()) {
+        fActiveStagingBuffers.remove(buffer);
+        fBusyStagingBuffers.addToTail(buffer);
+    }
+
     for (int i = 0; i < info.fNumSemaphores; ++i) {
         if (!info.fSignalSemaphores[i].isInitialized()) {
             SkASSERT(semaphoreInfos[i].fSemaphore);
@@ -891,3 +936,54 @@
     return this->onCreateCompressedBackendTexture(dimensions, format, mipMapped,
                                                   isProtected, data);
 }
+
+GrStagingBuffer* GrGpu::findStagingBuffer(size_t size) {
+#ifdef SK_DEBUG
+    this->validateStagingBuffers();
+#endif
+    for (auto b : fActiveStagingBuffers) {
+        if (b->remaining() >= size) {
+            return b;
+        }
+    }
+    for (auto b : fAvailableStagingBuffers) {
+        if (b->remaining() >= size) {
+            fAvailableStagingBuffers.remove(b);
+            fActiveStagingBuffers.addToTail(b);
+            return b;
+        }
+    }
+    size = SkNextPow2(size);
+    size = std::max(size, kMinStagingBufferSize);
+    std::unique_ptr<GrStagingBuffer> b = this->createStagingBuffer(size);
+    GrStagingBuffer* stagingBuffer = b.get();
+    fStagingBuffers.push_back(std::move(b));
+    fActiveStagingBuffers.addToTail(stagingBuffer);
+    return stagingBuffer;
+}
+
+GrStagingBuffer::Slice GrGpu::allocateStagingBufferSlice(size_t size) {
+#ifdef SK_DEBUG
+    this->validateStagingBuffers();
+#endif
+    GrStagingBuffer* stagingBuffer = this->findStagingBuffer(size);
+    return stagingBuffer->allocate(size);
+}
+
+void GrGpu::unmapStagingBuffers() {
+#ifdef SK_DEBUG
+    this->validateStagingBuffers();
+#endif
+    // Unmap all active buffers.
+    for (auto buffer : fActiveStagingBuffers) {
+        buffer->unmap();
+    }
+}
+
+void GrGpu::markStagingBufferAvailable(GrStagingBuffer* buffer) {
+#ifdef SK_DEBUG
+    this->validateStagingBuffers();
+#endif
+    fBusyStagingBuffers.remove(buffer);
+    fAvailableStagingBuffers.addToTail(buffer);
+}
diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h
index 3c4cc78..4684805 100644
--- a/src/gpu/GrGpu.h
+++ b/src/gpu/GrGpu.h
@@ -12,9 +12,11 @@
 #include "include/core/SkSurface.h"
 #include "include/gpu/GrTypes.h"
 #include "include/private/SkTArray.h"
+#include "src/core/SkTInternalLList.h"
 #include "src/gpu/GrCaps.h"
 #include "src/gpu/GrOpsRenderPass.h"
 #include "src/gpu/GrSamplePatternDictionary.h"
+#include "src/gpu/GrStagingBuffer.h"
 #include "src/gpu/GrSwizzle.h"
 #include "src/gpu/GrTextureProducer.h"
 #include "src/gpu/GrXferProcessor.h"
@@ -678,6 +680,12 @@
     // Called before certain draws in order to guarantee coherent results from dst reads.
     virtual void xferBarrier(GrRenderTarget*, GrXferBarrierType) = 0;
 
+    GrStagingBuffer* findStagingBuffer(size_t size);
+    GrStagingBuffer::Slice allocateStagingBufferSlice(size_t size);
+    virtual std::unique_ptr<GrStagingBuffer> createStagingBuffer(size_t size) { return nullptr; }
+    void unmapStagingBuffers();
+    void markStagingBufferAvailable(GrStagingBuffer* buffer);
+
 protected:
     static bool MipMapsAreCorrect(SkISize dimensions, GrMipMapped, const BackendTextureData*);
     static bool CompressedDataIsCorrect(SkISize dimensions, SkImage::CompressionType,
@@ -687,10 +695,18 @@
     void didWriteToSurface(GrSurface* surface, GrSurfaceOrigin origin, const SkIRect* bounds,
                            uint32_t mipLevels = 1) const;
 
+    typedef SkTInternalLList<GrStagingBuffer> StagingBufferList;
+
     Stats                            fStats;
     std::unique_ptr<GrPathRendering> fPathRendering;
     // Subclass must initialize this in its constructor.
     sk_sp<const GrCaps>              fCaps;
+    std::vector<std::unique_ptr<GrStagingBuffer>> fStagingBuffers;
+
+    StagingBufferList                fAvailableStagingBuffers;
+    StagingBufferList                fActiveStagingBuffers;
+    StagingBufferList                fBusyStagingBuffers;
+
 
 private:
     virtual GrBackendTexture onCreateBackendTexture(SkISize dimensions,
@@ -809,6 +825,10 @@
         this->onResetContext(fResetBits);
         fResetBits = 0;
     }
+#ifdef SK_DEBUG
+    bool inStagingBuffers(GrStagingBuffer* b) const;
+    void validateStagingBuffers() const;
+#endif
 
     uint32_t fResetBits;
     // The context owns us, not vice-versa, so this ptr is not ref'ed by Gpu.
diff --git a/src/gpu/GrStagingBuffer.cpp b/src/gpu/GrStagingBuffer.cpp
new file mode 100644
index 0000000..19c64d5
--- /dev/null
+++ b/src/gpu/GrStagingBuffer.cpp
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2020 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "src/gpu/GrGpu.h"
+#include "src/gpu/GrStagingBuffer.h"
+
+#include "src/core/SkMathPriv.h"
+
+void GrStagingBuffer::markAvailable(void* data) {
+    fData = data;
+    fOffset = 0;
+    fGpu->markStagingBufferAvailable(this);
+}
+
+void GrStagingBuffer::unmap() {
+    this->onUnmap();
+}
+
+GrStagingBuffer::Slice GrStagingBuffer::allocate(size_t size) {
+    size_t offset = fOffset;
+    fOffset += size;
+    char* data = static_cast<char*>(fData) + offset;
+    return Slice(this, offset, data);
+}
diff --git a/src/gpu/GrStagingBuffer.h b/src/gpu/GrStagingBuffer.h
new file mode 100644
index 0000000..a50b1a4
--- /dev/null
+++ b/src/gpu/GrStagingBuffer.h
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2020 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrStagingBuffer_DEFINED
+#define GrStagingBuffer_DEFINED
+
+#include "src/core/SkTInternalLList.h"
+
+class GrGpu;
+
+class GrStagingBuffer {
+public:
+    GrStagingBuffer(GrGpu* gpu, size_t size, void* data) : fGpu(gpu), fSize(size), fData(data) {}
+    virtual ~GrStagingBuffer() {
+        fGpu = nullptr;
+    }
+    void markAvailable(void* data);
+    struct Slice {
+        Slice(GrStagingBuffer* buffer, int offset, void* data)
+          : fBuffer(buffer), fOffset(offset), fData(data) {}
+        GrStagingBuffer*   fBuffer;
+        int                fOffset;
+        void*              fData;
+    };
+    size_t remaining() const { return fSize - fOffset; }
+    GrGpu* getGpu() const { return fGpu; }
+    void unmap();
+    Slice allocate(size_t size);
+private:
+    virtual void onUnmap() = 0;
+
+    GrGpu*                 fGpu;
+    size_t                 fSize;
+    size_t                 fOffset = 0;
+    void*                  fData;
+
+    SK_DECLARE_INTERNAL_LLIST_INTERFACE(GrStagingBuffer);
+};
+
+#endif
diff --git a/src/gpu/dawn/GrDawnBuffer.cpp b/src/gpu/dawn/GrDawnBuffer.cpp
index 6af4133..eb0a747 100644
--- a/src/gpu/dawn/GrDawnBuffer.cpp
+++ b/src/gpu/dawn/GrDawnBuffer.cpp
@@ -6,6 +6,7 @@
  */
 
 #include "src/gpu/dawn/GrDawnBuffer.h"
+#include "src/gpu/dawn/GrDawnStagingBuffer.h"
 
 #include "src/gpu/dawn/GrDawnGpu.h"
 
@@ -29,8 +30,7 @@
 
 GrDawnBuffer::GrDawnBuffer(GrDawnGpu* gpu, size_t sizeInBytes, GrGpuBufferType type,
                            GrAccessPattern pattern)
-    : INHERITED(gpu, sizeInBytes, type, pattern)
-    , fStagingBuffer(nullptr) {
+    : INHERITED(gpu, sizeInBytes, type, pattern) {
     wgpu::BufferDescriptor bufferDesc;
     bufferDesc.size = sizeInBytes;
     bufferDesc.usage = GrGpuBufferTypeToDawnUsageBit(type) | wgpu::BufferUsage::CopyDst;
@@ -45,18 +45,19 @@
     if (this->wasDestroyed()) {
         return;
     }
-    fStagingBuffer = getDawnGpu()->getStagingBuffer(this->size());
-    fMapPtr = fStagingBuffer->fData;
+    GrStagingBuffer::Slice slice = getGpu()->allocateStagingBufferSlice(this->size());
+    fStagingBuffer = static_cast<GrDawnStagingBuffer*>(slice.fBuffer)->buffer();
+    fStagingOffset = slice.fOffset;
+    fMapPtr = slice.fData;
 }
 
 void GrDawnBuffer::onUnmap() {
     if (this->wasDestroyed()) {
         return;
     }
-    fStagingBuffer->fBuffer.Unmap();
     fMapPtr = nullptr;
     getDawnGpu()->getCopyEncoder()
-        .CopyBufferToBuffer(fStagingBuffer->fBuffer, 0, fBuffer, 0, this->size());
+        .CopyBufferToBuffer(fStagingBuffer, fStagingOffset, fBuffer, 0, this->size());
 }
 
 bool GrDawnBuffer::onUpdateData(const void* src, size_t srcSizeInBytes) {
@@ -64,7 +65,7 @@
         return false;
     }
     this->onMap();
-    memcpy(fStagingBuffer->fData, src, srcSizeInBytes);
+    memcpy(fMapPtr, src, srcSizeInBytes);
     this->onUnmap();
     return true;
 }
diff --git a/src/gpu/dawn/GrDawnBuffer.h b/src/gpu/dawn/GrDawnBuffer.h
index 52a03a8..999dabb 100644
--- a/src/gpu/dawn/GrDawnBuffer.h
+++ b/src/gpu/dawn/GrDawnBuffer.h
@@ -12,7 +12,6 @@
 #include "dawn/webgpu_cpp.h"
 
 class GrDawnGpu;
-struct GrDawnStagingBuffer;
 
 class GrDawnBuffer : public GrGpuBuffer {
 public:
@@ -28,7 +27,8 @@
 
 private:
     wgpu::Buffer fBuffer;
-    GrDawnStagingBuffer* fStagingBuffer;
+    wgpu::Buffer fStagingBuffer;
+    size_t       fStagingOffset;
     typedef GrGpuBuffer INHERITED;
 };
 
diff --git a/src/gpu/dawn/GrDawnGpu.cpp b/src/gpu/dawn/GrDawnGpu.cpp
index b3c05f0..e2686cb 100644
--- a/src/gpu/dawn/GrDawnGpu.cpp
+++ b/src/gpu/dawn/GrDawnGpu.cpp
@@ -22,6 +22,7 @@
 #include "src/gpu/dawn/GrDawnOpsRenderPass.h"
 #include "src/gpu/dawn/GrDawnProgramBuilder.h"
 #include "src/gpu/dawn/GrDawnRenderTarget.h"
+#include "src/gpu/dawn/GrDawnStagingBuffer.h"
 #include "src/gpu/dawn/GrDawnStencilAttachment.h"
 #include "src/gpu/dawn/GrDawnTexture.h"
 #include "src/gpu/dawn/GrDawnUtil.h"
@@ -34,7 +35,7 @@
 #include <unistd.h>
 #endif // !defined(SK_BUILD_FOR_WIN)
 
-const int kMaxRenderPipelineEntries = 1024;
+static const int kMaxRenderPipelineEntries = 1024;
 
 static wgpu::FilterMode to_dawn_filter_mode(GrSamplerState::Filter filter) {
     switch (filter) {
@@ -83,17 +84,28 @@
         , fQueue(device.CreateQueue())
         , fCompiler(new SkSL::Compiler())
         , fUniformRingBuffer(this, wgpu::BufferUsage::Uniform)
-        , fRenderPipelineCache(kMaxRenderPipelineEntries)
-        , fStagingManager(fDevice) {
+        , fRenderPipelineCache(kMaxRenderPipelineEntries) {
     fCaps.reset(new GrDawnCaps(options));
 }
 
 GrDawnGpu::~GrDawnGpu() {
+    while (!fBusyStagingBuffers.isEmpty()) {
+        fDevice.Tick();
+    }
 }
 
 
 void GrDawnGpu::disconnect(DisconnectType type) {
-    SkASSERT(!"unimplemented");
+    if (DisconnectType::kAbandon == type) {
+        fBusyStagingBuffers.reset();
+        fAvailableStagingBuffers.reset();
+        fActiveStagingBuffers.reset();
+    } else {
+        while (!fBusyStagingBuffers.isEmpty()) {
+            fDevice.Tick();
+        }
+    }
+    fStagingBuffers.clear();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -312,24 +324,21 @@
         size_t origRowBytes = bpp * w;
         size_t rowBytes = GrDawnRoundRowBytes(origRowBytes);
         size_t size = rowBytes * h;
-        GrDawnStagingBuffer* stagingBuffer = this->getStagingBuffer(size);
+        GrStagingBuffer::Slice stagingBuffer = this->allocateStagingBufferSlice(size);
         if (rowBytes == origRowBytes) {
-            memcpy(stagingBuffer->fData, pixels, size);
+            memcpy(stagingBuffer.fData, pixels, size);
         } else {
             const char* src = static_cast<const char*>(pixels);
-            char* dst = static_cast<char*>(stagingBuffer->fData);
+            char* dst = static_cast<char*>(stagingBuffer.fData);
             for (int row = 0; row < h; row++) {
                 memcpy(dst, src, origRowBytes);
                 dst += rowBytes;
                 src += origRowBytes;
             }
         }
-        wgpu::Buffer buffer = stagingBuffer->fBuffer;
-        buffer.Unmap();
-        stagingBuffer->fData = nullptr;
         wgpu::BufferCopyView srcBuffer;
-        srcBuffer.buffer = buffer;
-        srcBuffer.offset = 0;
+        srcBuffer.buffer = static_cast<GrDawnStagingBuffer*>(stagingBuffer.fBuffer)->buffer();
+        srcBuffer.offset = stagingBuffer.fOffset;
         srcBuffer.rowPitch = rowBytes;
         srcBuffer.imageHeight = h;
         wgpu::TextureCopyView dstTexture;
@@ -424,13 +433,12 @@
 #endif
 
 void GrDawnGpu::flush() {
-    fUniformRingBuffer.flush();
     this->flushCopyEncoder();
     if (!fCommandBuffers.empty()) {
         fQueue.Submit(fCommandBuffers.size(), &fCommandBuffers.front());
         fCommandBuffers.clear();
     }
-    fStagingManager.mapBusyList();
+    this->mapStagingBuffers();
     fDevice.Tick();
 }
 
@@ -634,8 +642,13 @@
     return fUniformRingBuffer.allocate(size);
 }
 
-GrDawnStagingBuffer* GrDawnGpu::getStagingBuffer(size_t size) {
-    return fStagingManager.findOrCreateStagingBuffer(size);
+std::unique_ptr<GrStagingBuffer> GrDawnGpu::createStagingBuffer(size_t size) {
+    wgpu::BufferDescriptor desc;
+    desc.usage = wgpu::BufferUsage::MapWrite | wgpu::BufferUsage::CopySrc;
+    desc.size = size;
+    wgpu::CreateBufferMappedResult result = fDevice.CreateBufferMapped(&desc);
+    auto stagingBuffer = new GrDawnStagingBuffer(this, result.buffer, desc.size, result.data);
+    return std::unique_ptr<GrStagingBuffer>(stagingBuffer);
 }
 
 void GrDawnGpu::appendCommandBuffer(wgpu::CommandBuffer commandBuffer) {
@@ -657,3 +670,10 @@
         fCopyEncoder = nullptr;
     }
 }
+
+void GrDawnGpu::mapStagingBuffers() {
+    // Map all active buffers, so we get a callback when they're done.
+    for (auto buffer : fActiveStagingBuffers) {
+        static_cast<GrDawnStagingBuffer*>(buffer)->mapAsync();
+    }
+}
diff --git a/src/gpu/dawn/GrDawnGpu.h b/src/gpu/dawn/GrDawnGpu.h
index 8afd08a..a8d41db 100644
--- a/src/gpu/dawn/GrDawnGpu.h
+++ b/src/gpu/dawn/GrDawnGpu.h
@@ -14,11 +14,11 @@
 #include "src/core/SkLRUCache.h"
 #include "src/gpu/GrProgramDesc.h"
 #include "src/gpu/dawn/GrDawnRingBuffer.h"
-#include "src/gpu/dawn/GrDawnStagingManager.h"
 
 #include <unordered_map>
 
 class GrDawnOpsRenderPass;
+class GrDawnStagingBuffer;
 class GrPipeline;
 struct GrDawnProgram;
 
@@ -65,6 +65,7 @@
     void testingOnly_flushGpuAndSync() override;
 #endif
     void flush();
+    std::unique_ptr<GrStagingBuffer> createStagingBuffer(size_t size) override;
 
     GrStencilAttachment* createStencilAttachmentForRenderTarget(const GrRenderTarget*,
                                                                 int width,
@@ -103,8 +104,6 @@
     wgpu::Sampler getOrCreateSampler(GrSamplerState samplerState);
 
     GrDawnRingBuffer::Slice allocateUniformRingBufferSlice(int size);
-    GrDawnStagingBuffer* getStagingBuffer(size_t size);
-    GrDawnStagingManager* getStagingManager() { return &fStagingManager; }
     wgpu::CommandEncoder getCopyEncoder();
     void flushCopyEncoder();
     void appendCommandBuffer(wgpu::CommandBuffer commandBuffer);
@@ -176,6 +175,8 @@
     bool onFinishFlush(GrSurfaceProxy*[], int n, SkSurface::BackendSurfaceAccess access,
                        const GrFlushInfo& info, const GrPrepareForExternalIORequests&) override;
 
+    void mapStagingBuffers();
+
     wgpu::Device                                    fDevice;
     wgpu::Queue                                     fQueue;
     std::unique_ptr<SkSL::Compiler>                 fCompiler;
@@ -198,7 +199,6 @@
 
     SkLRUCache<GrProgramDesc, sk_sp<GrDawnProgram>, ProgramDescHash>    fRenderPipelineCache;
     std::unordered_map<GrSamplerState, wgpu::Sampler, SamplerHash> fSamplers;
-    GrDawnStagingManager fStagingManager;
 
     typedef GrGpu INHERITED;
 };
diff --git a/src/gpu/dawn/GrDawnRingBuffer.cpp b/src/gpu/dawn/GrDawnRingBuffer.cpp
index 4c48828..2e7cb83 100644
--- a/src/gpu/dawn/GrDawnRingBuffer.cpp
+++ b/src/gpu/dawn/GrDawnRingBuffer.cpp
@@ -8,6 +8,7 @@
 #include "src/gpu/dawn/GrDawnRingBuffer.h"
 
 #include "src/gpu/dawn/GrDawnGpu.h"
+#include "src/gpu/dawn/GrDawnStagingBuffer.h"
 #include "src/gpu/dawn/GrDawnUtil.h"
 
 namespace {
@@ -23,7 +24,6 @@
 
 GrDawnRingBuffer::Slice GrDawnRingBuffer::allocate(int size) {
     if (!fBuffer || fOffset + size > kDefaultSize) {
-        flush();
         wgpu::BufferDescriptor desc;
         desc.usage = fUsage | wgpu::BufferUsage::CopyDst;
         desc.size = kDefaultSize;
@@ -31,25 +31,12 @@
         fOffset = 0;
     }
 
-    if (!fStagingBuffer) {
-        wgpu::BufferDescriptor desc;
-        desc.usage = wgpu::BufferUsage::MapWrite | wgpu::BufferUsage::CopySrc;
-        desc.size = kDefaultSize;
-        wgpu::CreateBufferMappedResult result = fGpu->device().CreateBufferMapped(&desc);
-        fStagingBuffer = result.buffer;
-        fData = result.data;
-    }
-    int offset = fOffset;
+    GrStagingBuffer::Slice staging = fGpu->allocateStagingBufferSlice(size);
+    size_t offset = fOffset;
     fOffset += size;
     fOffset = GrDawnRoundRowBytes(fOffset);
-    fGpu->getCopyEncoder().CopyBufferToBuffer(fStagingBuffer, offset, fBuffer, offset, size);
-    return Slice(fBuffer, offset, static_cast<uint8_t*>(fData) + offset);
-}
-
-void GrDawnRingBuffer::flush() {
-    if (fStagingBuffer) {
-        fStagingBuffer.Unmap();
-        fStagingBuffer = nullptr;   // FIXME: reuse staging buffer
-        fData = nullptr;
-    }
+    wgpu::Buffer srcBuffer = static_cast<GrDawnStagingBuffer*>(staging.fBuffer)->buffer();
+    fGpu->getCopyEncoder().CopyBufferToBuffer(srcBuffer, staging.fOffset,
+                                              fBuffer, offset, size);
+    return Slice(fBuffer, offset, staging.fData);
 }
diff --git a/src/gpu/dawn/GrDawnRingBuffer.h b/src/gpu/dawn/GrDawnRingBuffer.h
index bbc5a0a..6ac47dd 100644
--- a/src/gpu/dawn/GrDawnRingBuffer.h
+++ b/src/gpu/dawn/GrDawnRingBuffer.h
@@ -37,14 +37,11 @@
         void*        fData;
     };
     Slice allocate(int size);
-    void flush();
 
 private:
     GrDawnGpu*            fGpu;
     wgpu::BufferUsage     fUsage;
     wgpu::Buffer          fBuffer;
-    wgpu::Buffer          fStagingBuffer;
-    void*                 fData;
     int                   fOffset = 0;
 };
 
diff --git a/src/gpu/dawn/GrDawnStagingBuffer.cpp b/src/gpu/dawn/GrDawnStagingBuffer.cpp
new file mode 100644
index 0000000..25b0844
--- /dev/null
+++ b/src/gpu/dawn/GrDawnStagingBuffer.cpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2020 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "src/gpu/dawn/GrDawnGpu.h"
+#include "src/gpu/dawn/GrDawnStagingBuffer.h"
+
+#include "src/core/SkMathPriv.h"
+
+static void callback(WGPUBufferMapAsyncStatus status, void* data, uint64_t dataLength,
+                     void* userData) {
+    GrDawnStagingBuffer* buffer = static_cast<GrDawnStagingBuffer*>(userData);
+    buffer->markAvailable(data);
+}
+
+GrDawnGpu* GrDawnStagingBuffer::getDawnGpu() const {
+    return static_cast<GrDawnGpu*>(this->getGpu());
+}
+
+void GrDawnStagingBuffer::mapAsync() {
+    fBuffer.MapWriteAsync(callback, this);
+}
+
+void GrDawnStagingBuffer::onUnmap() {
+    fBuffer.Unmap();
+}
diff --git a/src/gpu/dawn/GrDawnStagingBuffer.h b/src/gpu/dawn/GrDawnStagingBuffer.h
new file mode 100644
index 0000000..82f53b1
--- /dev/null
+++ b/src/gpu/dawn/GrDawnStagingBuffer.h
@@ -0,0 +1,30 @@
+/*
+ * Copyright 2020 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrDawnStagingBuffer_DEFINED
+#define GrDawnStagingBuffer_DEFINED
+
+#include "dawn/webgpu_cpp.h"
+#include "src/gpu/GrStagingBuffer.h"
+
+class GrDawnStagingBuffer : public GrStagingBuffer {
+public:
+    GrDawnStagingBuffer(GrGpu* gpu, wgpu::Buffer buffer, size_t size, void* data)
+        : INHERITED(gpu, size, data), fBuffer(buffer) {}
+    ~GrDawnStagingBuffer() override {}
+    void           mapAsync();
+    wgpu::Buffer   buffer() const { return fBuffer; }
+    GrDawnGpu*     getDawnGpu() const;
+
+private:
+    void           onUnmap() override;
+
+    wgpu::Buffer   fBuffer;
+    typedef GrStagingBuffer INHERITED;
+};
+
+#endif
diff --git a/src/gpu/dawn/GrDawnStagingManager.cpp b/src/gpu/dawn/GrDawnStagingManager.cpp
deleted file mode 100644
index e655722..0000000
--- a/src/gpu/dawn/GrDawnStagingManager.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright 2019 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#include "src/gpu/dawn/GrDawnStagingManager.h"
-
-#include "src/core/SkMathPriv.h"
-
-GrDawnStagingManager::GrDawnStagingManager(wgpu::Device device) : fDevice(device) {
-}
-
-GrDawnStagingManager::~GrDawnStagingManager() {
-    // Clean up any pending callbacks before destroying the StagingBuffers.
-    while (fWaitingCount > 0) {
-        fDevice.Tick();
-    }
-}
-
-GrDawnStagingBuffer* GrDawnStagingManager::findOrCreateStagingBuffer(size_t size) {
-    size_t sizePow2 = GrNextPow2(size);
-    GrDawnStagingBuffer* stagingBuffer;
-    auto i = fReadyPool.find(sizePow2);
-    if (i != fReadyPool.end()) {
-        stagingBuffer = i->second;
-        fReadyPool.erase(i);
-    } else {
-        wgpu::BufferDescriptor desc;
-        desc.usage = wgpu::BufferUsage::MapWrite | wgpu::BufferUsage::CopySrc;
-        desc.size = sizePow2;
-        wgpu::CreateBufferMappedResult result = fDevice.CreateBufferMapped(&desc);
-        std::unique_ptr<GrDawnStagingBuffer> b(new GrDawnStagingBuffer(
-            this, result.buffer, sizePow2, result.data));
-        stagingBuffer = b.get();
-        fBuffers.push_back(std::move(b));
-    }
-    fBusyList.push_back(stagingBuffer);
-    return stagingBuffer;
-}
-
-static void callback(WGPUBufferMapAsyncStatus status, void* data, uint64_t dataLength,
-                     void* userData) {
-    GrDawnStagingBuffer* buffer = static_cast<GrDawnStagingBuffer*>(userData);
-    buffer->fData = data;
-    if (buffer->fManager) {
-        buffer->fManager->addToReadyPool(buffer);
-    }
-}
-
-void GrDawnStagingManager::mapBusyList() {
-    // Map all buffers on the busy list for writing. When they're no longer in flight on the GPU,
-    // their callback will be called and they'll be moved to the ready pool.
-    for (GrDawnStagingBuffer* buffer : fBusyList) {
-        buffer->fBuffer.MapWriteAsync(callback, buffer);
-        fWaitingCount++;
-    }
-    fBusyList.clear();
-}
-
-void GrDawnStagingManager::addToReadyPool(GrDawnStagingBuffer* buffer) {
-    fWaitingCount--;
-    fReadyPool.insert(std::pair<size_t, GrDawnStagingBuffer*>(buffer->fSize, buffer));
-}
diff --git a/src/gpu/dawn/GrDawnStagingManager.h b/src/gpu/dawn/GrDawnStagingManager.h
deleted file mode 100644
index 1bcc339..0000000
--- a/src/gpu/dawn/GrDawnStagingManager.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- * Copyright 2019 Google Inc.
- *
- * Use of this source code is governed by a BSD-style license that can be
- * found in the LICENSE file.
- */
-
-#ifndef GrDawnStagingManager_DEFINED
-#define GrDawnStagingManager_DEFINED
-
-#include <map>
-#include <memory>
-#include <vector>
-
-#include "dawn/webgpu_cpp.h"
-
-struct GrDawnStagingBuffer;
-
-class GrDawnStagingManager {
-public:
-    GrDawnStagingManager(wgpu::Device device);
-   ~GrDawnStagingManager();
-    GrDawnStagingBuffer* findOrCreateStagingBuffer(size_t size);
-
-    void addToReadyPool(GrDawnStagingBuffer* buffer);
-    void mapBusyList();
-
-private:
-    wgpu::Device                                       fDevice;
-    std::vector<std::unique_ptr<GrDawnStagingBuffer>>  fBuffers;
-    std::multimap<size_t, GrDawnStagingBuffer*>        fReadyPool;
-    std::vector<GrDawnStagingBuffer*>                  fBusyList;
-    int                                                fWaitingCount = 0;
-};
-
-struct GrDawnStagingBuffer {
-    GrDawnStagingBuffer(GrDawnStagingManager* manager, wgpu::Buffer buffer, size_t size,
-                       void* data)
-        : fManager(manager), fBuffer(buffer), fSize(size), fData(data) {}
-    ~GrDawnStagingBuffer() {
-        fManager = nullptr;
-    }
-    GrDawnStagingManager*  fManager;
-    wgpu::Buffer           fBuffer;
-    size_t                 fSize;
-    void*                  fData;
-};
-
-#endif
diff --git a/src/gpu/dawn/GrDawnTexture.cpp b/src/gpu/dawn/GrDawnTexture.cpp
index 81f898e..5acc963 100644
--- a/src/gpu/dawn/GrDawnTexture.cpp
+++ b/src/gpu/dawn/GrDawnTexture.cpp
@@ -9,6 +9,7 @@
 
 #include "src/core/SkConvertPixels.h"
 #include "src/gpu/dawn/GrDawnGpu.h"
+#include "src/gpu/dawn/GrDawnStagingBuffer.h"
 #include "src/gpu/dawn/GrDawnTextureRenderTarget.h"
 #include "src/gpu/dawn/GrDawnUtil.h"
 
@@ -151,15 +152,12 @@
         size_t trimRowBytes = width * SkColorTypeBytesPerPixel(colorType);
         size_t dstRowBytes = GrDawnRoundRowBytes(trimRowBytes);
         size_t size = dstRowBytes * height;
-        GrDawnStagingBuffer* stagingBuffer = getDawnGpu()->getStagingBuffer(size);
-        SkRectMemcpy(stagingBuffer->fData, dstRowBytes, src, srcRowBytes, trimRowBytes, height);
-        wgpu::Buffer buffer = stagingBuffer->fBuffer;
-        buffer.Unmap();
-        stagingBuffer->fData = nullptr;
+        GrStagingBuffer::Slice slice = getDawnGpu()->allocateStagingBufferSlice(size);
+        SkRectMemcpy(slice.fData, dstRowBytes, src, srcRowBytes, trimRowBytes, height);
 
         wgpu::BufferCopyView srcBuffer;
-        srcBuffer.buffer = buffer;
-        srcBuffer.offset = 0;
+        srcBuffer.buffer = static_cast<GrDawnStagingBuffer*>(slice.fBuffer)->buffer();
+        srcBuffer.offset = slice.fOffset;
         srcBuffer.rowPitch = dstRowBytes;
         srcBuffer.imageHeight = height;