diff --git a/gn/gpu.gni b/gn/gpu.gni
index 1d91c73..1d2fe87 100644
--- a/gn/gpu.gni
+++ b/gn/gpu.gni
@@ -575,6 +575,7 @@
 
 skia_ccpr_sources = [
   # coverage counting path renderer
+  "$_src/gpu/ccpr/GrAutoMapVertexBuffer.h",
   "$_src/gpu/ccpr/GrCCAtlas.cpp",
   "$_src/gpu/ccpr/GrCCAtlas.h",
   "$_src/gpu/ccpr/GrCCClipPath.cpp",
diff --git a/src/gpu/ccpr/GrAutoMapVertexBuffer.h b/src/gpu/ccpr/GrAutoMapVertexBuffer.h
new file mode 100644
index 0000000..5121e4d
--- /dev/null
+++ b/src/gpu/ccpr/GrAutoMapVertexBuffer.h
@@ -0,0 +1,74 @@
+/*
+ * 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 GrAutoMapVertexBuffer_DEFINED
+#define GrAutoMapVertexBuffer_DEFINED
+
+#include "include/private/SkNoncopyable.h"
+#include "src/gpu/GrGpuBuffer.h"
+#include "src/gpu/GrOnFlushResourceProvider.h"
+
+// This class automatically allocates and maps a GPU vertex buffer, and polyfills the mapping
+// functionality with a mirror buffer on CPU if it is not supported.
+class GrAutoMapVertexBuffer : SkNoncopyable {
+public:
+    ~GrAutoMapVertexBuffer() {
+        if (this->isMapped()) {
+            this->unmapBuffer();
+        }
+    }
+
+    const GrGpuBuffer* gpuBuffer() const { return fGpuBuffer.get(); }
+    bool isMapped() const { return SkToBool(fData); }
+    void* data() const { SkASSERT(this->isMapped()); return fData; }
+
+    void resetAndMapBuffer(GrOnFlushResourceProvider* onFlushRP, size_t sizeInBytes) {
+        if (this->isMapped()) {
+            this->unmapBuffer();
+        }
+        fGpuBuffer = onFlushRP->makeBuffer(GrGpuBufferType::kVertex, sizeInBytes);
+        if (!fGpuBuffer) {
+            fSizeInBytes = 0;
+            fData = nullptr;
+            return;
+        }
+        fSizeInBytes = sizeInBytes;
+        fData = fGpuBuffer->map();
+        if (!fData) {
+            // Mapping failed. Allocate a mirror buffer on CPU.
+            fData = sk_malloc_throw(fSizeInBytes);
+        }
+    }
+
+    void unmapBuffer() {
+        SkASSERT(this->isMapped());
+        if (fGpuBuffer->isMapped()) {
+            fGpuBuffer->unmap();
+        } else {
+            // fData is a mirror buffer on CPU.
+            fGpuBuffer->updateData(fData, fSizeInBytes);
+            sk_free(fData);
+        }
+        fData = nullptr;
+    }
+
+protected:
+    sk_sp<GrGpuBuffer> fGpuBuffer;
+    size_t fSizeInBytes = 0;
+    void* fData = nullptr;
+};
+
+template<typename T> class GrTAutoMapVertexBuffer : public GrAutoMapVertexBuffer {
+public:
+    T& operator[](int idx) {
+        SkASSERT(this->isMapped());
+        SkASSERT(idx >= 0 && (size_t)idx < fSizeInBytes / sizeof(T));
+        return ((T*)fData)[idx];
+    }
+};
+
+#endif
diff --git a/src/gpu/ccpr/GrCCFiller.cpp b/src/gpu/ccpr/GrCCFiller.cpp
index 5e3e305..3816fb6 100644
--- a/src/gpu/ccpr/GrCCFiller.cpp
+++ b/src/gpu/ccpr/GrCCFiller.cpp
@@ -37,7 +37,7 @@
 void GrCCFiller::parseDeviceSpaceFill(const SkPath& path, const SkPoint* deviceSpacePts,
                                       GrScissorTest scissorTest, const SkIRect& clippedDevIBounds,
                                       const SkIVector& devToAtlasOffset) {
-    SkASSERT(!fInstanceBuffer);  // Can't call after prepareToDraw().
+    SkASSERT(!fInstanceBuffer.gpuBuffer());  // Can't call after prepareToDraw().
     SkASSERT(!path.isEmpty());
 
     int currPathPointsIdx = fGeometry.points().count();
@@ -206,7 +206,7 @@
 }
 
 GrCCFiller::BatchID GrCCFiller::closeCurrentBatch() {
-    SkASSERT(!fInstanceBuffer);
+    SkASSERT(!fInstanceBuffer.gpuBuffer());
     SkASSERT(!fBatches.empty());
 
     const auto& lastBatch = fBatches.back();
@@ -294,7 +294,7 @@
 
 bool GrCCFiller::prepareToDraw(GrOnFlushResourceProvider* onFlushRP) {
     using Verb = GrCCFillGeometry::Verb;
-    SkASSERT(!fInstanceBuffer);
+    SkASSERT(!fInstanceBuffer.gpuBuffer());
     SkASSERT(fBatches.back().fEndNonScissorIndices == // Call closeCurrentBatch().
              fTotalPrimitiveCounts[(int)GrScissorTest::kDisabled]);
     SkASSERT(fBatches.back().fEndScissorSubBatchIdx == fScissorSubBatches.count());
@@ -340,16 +340,14 @@
     fBaseInstances[1].fConics = fBaseInstances[0].fConics + fTotalPrimitiveCounts[0].fConics;
     int quadEndIdx = fBaseInstances[1].fConics + fTotalPrimitiveCounts[1].fConics;
 
-    fInstanceBuffer =
-            onFlushRP->makeBuffer(GrGpuBufferType::kVertex, quadEndIdx * sizeof(QuadPointInstance));
-    if (!fInstanceBuffer) {
+    fInstanceBuffer.resetAndMapBuffer(onFlushRP, quadEndIdx * sizeof(QuadPointInstance));
+    if (!fInstanceBuffer.gpuBuffer()) {
         SkDebugf("WARNING: failed to allocate CCPR fill instance buffer.\n");
         return false;
     }
 
-    TriPointInstance* triPointInstanceData = static_cast<TriPointInstance*>(fInstanceBuffer->map());
-    QuadPointInstance* quadPointInstanceData =
-            reinterpret_cast<QuadPointInstance*>(triPointInstanceData);
+    auto triPointInstanceData = reinterpret_cast<TriPointInstance*>(fInstanceBuffer.data());
+    auto quadPointInstanceData = reinterpret_cast<QuadPointInstance*>(fInstanceBuffer.data());
     SkASSERT(quadPointInstanceData);
 
     PathInfo* nextPathInfo = fPathInfos.begin();
@@ -453,7 +451,7 @@
         }
     }
 
-    fInstanceBuffer->unmap();
+    fInstanceBuffer.unmapBuffer();
 
     SkASSERT(nextPathInfo == fPathInfos.end());
     SkASSERT(ptsIdx == pts.count() - 1);
@@ -476,7 +474,7 @@
         BatchID batchID, const SkIRect& drawBounds) const {
     using PrimitiveType = GrCCCoverageProcessor::PrimitiveType;
 
-    SkASSERT(fInstanceBuffer);
+    SkASSERT(fInstanceBuffer.gpuBuffer());
 
     GrResourceProvider* rp = flushState->resourceProvider();
     const PrimitiveTallies& batchTotalCounts = fBatches[batchID].fTotalPrimitiveCounts;
@@ -532,7 +530,7 @@
 
     GrOpsRenderPass* renderPass = flushState->opsRenderPass();
     proc.bindPipeline(flushState, pipeline, SkRect::Make(drawBounds));
-    proc.bindBuffers(renderPass, fInstanceBuffer.get());
+    proc.bindBuffers(renderPass, fInstanceBuffer.gpuBuffer());
 
     SkASSERT(batchID > 0);
     SkASSERT(batchID < fBatches.count());
diff --git a/src/gpu/ccpr/GrCCFiller.h b/src/gpu/ccpr/GrCCFiller.h
index 52c3ee4..e69ce20 100644
--- a/src/gpu/ccpr/GrCCFiller.h
+++ b/src/gpu/ccpr/GrCCFiller.h
@@ -12,6 +12,7 @@
 #include "include/core/SkRefCnt.h"
 #include "src/core/SkPathPriv.h"
 #include "src/gpu/GrTessellator.h"
+#include "src/gpu/ccpr/GrAutoMapVertexBuffer.h"
 #include "src/gpu/ccpr/GrCCCoverageProcessor.h"
 #include "src/gpu/ccpr/GrCCFillGeometry.h"
 #include "src/gpu/ops/GrDrawOp.h"
@@ -117,7 +118,7 @@
     PrimitiveTallies fTotalPrimitiveCounts[kNumScissorModes];
     int fMaxMeshesPerDraw = 0;
 
-    sk_sp<GrGpuBuffer> fInstanceBuffer;
+    GrAutoMapVertexBuffer fInstanceBuffer;
     PrimitiveTallies fBaseInstances[kNumScissorModes];
 };
 
diff --git a/src/gpu/ccpr/GrCCPerFlushResources.cpp b/src/gpu/ccpr/GrCCPerFlushResources.cpp
index 7fd5d5c..06dd3ff 100644
--- a/src/gpu/ccpr/GrCCPerFlushResources.cpp
+++ b/src/gpu/ccpr/GrCCPerFlushResources.cpp
@@ -193,8 +193,6 @@
         , fRenderedAtlasStack(coverageType, specs.fRenderedAtlasSpecs, onFlushRP->caps())
         , fIndexBuffer(GrCCPathProcessor::FindIndexBuffer(onFlushRP))
         , fVertexBuffer(GrCCPathProcessor::FindVertexBuffer(onFlushRP))
-        , fInstanceBuffer(onFlushRP->makeBuffer(GrGpuBufferType::kVertex,
-                                                inst_buffer_count(specs) * sizeof(PathInstance)))
         , fNextCopyInstanceIdx(0)
         , fNextPathInstanceIdx(
                 specs.fNumCopiedPaths[kFillIdx] + specs.fNumCopiedPaths[kStrokeIdx]) {
@@ -206,23 +204,24 @@
         SkDebugf("WARNING: failed to allocate CCPR vertex buffer. No paths will be drawn.\n");
         return;
     }
-    if (!fInstanceBuffer) {
+    fPathInstanceBuffer.resetAndMapBuffer(onFlushRP,
+                                          inst_buffer_count(specs) * sizeof(PathInstance));
+    if (!fPathInstanceBuffer.gpuBuffer()) {
         SkDebugf("WARNING: failed to allocate CCPR instance buffer. No paths will be drawn.\n");
         return;
     }
-    fPathInstanceData = static_cast<PathInstance*>(fInstanceBuffer->map());
-    SkASSERT(fPathInstanceData);
 
     if (CoverageType::kA8_Multisample == coverageType) {
         int numRenderedPaths =
                 specs.fNumRenderedPaths[kFillIdx] + specs.fNumRenderedPaths[kStrokeIdx] +
                 specs.fNumClipPaths;
-        fStencilResolveBuffer = onFlushRP->makeBuffer(
-                GrGpuBufferType::kVertex,
-                numRenderedPaths * sizeof(GrStencilAtlasOp::ResolveRectInstance));
-        fStencilResolveInstanceData = static_cast<GrStencilAtlasOp::ResolveRectInstance*>(
-                fStencilResolveBuffer->map());
-        SkASSERT(fStencilResolveInstanceData);
+        fStencilResolveBuffer.resetAndMapBuffer(
+                onFlushRP, numRenderedPaths * sizeof(GrStencilAtlasOp::ResolveRectInstance));
+        if (!fStencilResolveBuffer.gpuBuffer()) {
+            SkDebugf("WARNING: failed to allocate CCPR stencil resolve buffer. "
+                     "No paths will be drawn.\n");
+            return;
+        }
         SkDEBUGCODE(fEndStencilResolveInstance = numRenderedPaths);
     }
 
@@ -284,7 +283,7 @@
                                 (((uint64_t) SK_Half1) << 16) |
                                 (((uint64_t) SK_Half1) << 32) |
                                 (((uint64_t) SK_Half1) << 48);
-    fPathInstanceData[currentInstanceIdx].set(entry, newAtlasOffset, kWhite, fillRule);
+    fPathInstanceBuffer[currentInstanceIdx].set(entry, newAtlasOffset, kWhite, fillRule);
 
     // Percolate the instance forward until it's contiguous with other instances that share the same
     // proxy.
@@ -294,7 +293,8 @@
             return;
         }
         int rangeFirstInstanceIdx = currentInstanceIdx - fCopyPathRanges[i].fCount;
-        std::swap(fPathInstanceData[rangeFirstInstanceIdx], fPathInstanceData[currentInstanceIdx]);
+        std::swap(fPathInstanceBuffer[rangeFirstInstanceIdx],
+                  fPathInstanceBuffer[currentInstanceIdx]);
         currentInstanceIdx = rangeFirstInstanceIdx;
     }
 
@@ -492,7 +492,7 @@
         // "nonzero" settings in front and "even/odd" settings in back.
         std::swap(atlasIBounds.fLeft, atlasIBounds.fRight);
     }
-    fStencilResolveInstanceData[fNextStencilResolveInstanceIdx++] = {
+    fStencilResolveBuffer[fNextStencilResolveInstanceIdx++] = {
             (int16_t)atlasIBounds.left(), (int16_t)atlasIBounds.top(),
             (int16_t)atlasIBounds.right(), (int16_t)atlasIBounds.bottom()};
 }
@@ -504,12 +504,10 @@
     SkASSERT(GrCCAtlas::CoverageType::kA8_Multisample != this->renderedPathCoverageType() ||
              fNextStencilResolveInstanceIdx == fEndStencilResolveInstance);
 
-    fInstanceBuffer->unmap();
-    fPathInstanceData = nullptr;
+    fPathInstanceBuffer.unmapBuffer();
 
-    if (fStencilResolveBuffer) {
-        fStencilResolveBuffer->unmap();
-        fStencilResolveInstanceData = nullptr;
+    if (fStencilResolveBuffer.gpuBuffer()) {
+        fStencilResolveBuffer.unmapBuffer();
     }
 
     if (!fCopyAtlasStack.empty()) {
diff --git a/src/gpu/ccpr/GrCCPerFlushResources.h b/src/gpu/ccpr/GrCCPerFlushResources.h
index 86f918d..c094a9f 100644
--- a/src/gpu/ccpr/GrCCPerFlushResources.h
+++ b/src/gpu/ccpr/GrCCPerFlushResources.h
@@ -9,6 +9,7 @@
 #define GrCCPerFlushResources_DEFINED
 
 #include "src/gpu/GrNonAtomicRef.h"
+#include "src/gpu/ccpr/GrAutoMapVertexBuffer.h"
 #include "src/gpu/ccpr/GrCCAtlas.h"
 #include "src/gpu/ccpr/GrCCFiller.h"
 #include "src/gpu/ccpr/GrCCPathProcessor.h"
@@ -70,7 +71,7 @@
     GrCCPerFlushResources(
             GrOnFlushResourceProvider*, GrCCAtlas::CoverageType,const GrCCPerFlushResourceSpecs&);
 
-    bool isMapped() const { return SkToBool(fPathInstanceData); }
+    bool isMapped() const { return fPathInstanceBuffer.isMapped(); }
 
     GrCCAtlas::CoverageType renderedPathCoverageType() const {
         return fRenderedAtlasStack.coverageType();
@@ -103,7 +104,7 @@
     GrCCPathProcessor::Instance& appendDrawPathInstance() {
         SkASSERT(this->isMapped());
         SkASSERT(fNextPathInstanceIdx < fEndPathInstance);
-        return fPathInstanceData[fNextPathInstanceIdx++];
+        return fPathInstanceBuffer[fNextPathInstanceIdx++];
     }
 
     // Finishes off the GPU buffers and renders the atlas(es).
@@ -118,7 +119,7 @@
     }
     const GrGpuBuffer* instanceBuffer() const {
         SkASSERT(!this->isMapped());
-        return fInstanceBuffer.get();
+        return fPathInstanceBuffer.gpuBuffer();
     }
     const GrGpuBuffer* vertexBuffer() const {
         SkASSERT(!this->isMapped());
@@ -126,7 +127,7 @@
     }
     const GrGpuBuffer* stencilResolveBuffer() const {
         SkASSERT(!this->isMapped());
-        return fStencilResolveBuffer.get();
+        return fStencilResolveBuffer.gpuBuffer();
     }
 
 private:
@@ -148,9 +149,8 @@
 
     const sk_sp<const GrGpuBuffer> fIndexBuffer;
     const sk_sp<const GrGpuBuffer> fVertexBuffer;
-    const sk_sp<GrGpuBuffer> fInstanceBuffer;
 
-    GrCCPathProcessor::Instance* fPathInstanceData = nullptr;
+    GrTAutoMapVertexBuffer<GrCCPathProcessor::Instance> fPathInstanceBuffer;
     int fNextCopyInstanceIdx;
     SkDEBUGCODE(int fEndCopyInstance);
     int fNextPathInstanceIdx;
@@ -175,8 +175,7 @@
     SkSTArray<2, sk_sp<GrTexture>> fRecyclableAtlasTextures;
 
     // Used in MSAA mode make an intermediate draw that resolves stencil winding values to coverage.
-    sk_sp<GrGpuBuffer> fStencilResolveBuffer;
-    GrStencilAtlasOp::ResolveRectInstance* fStencilResolveInstanceData = nullptr;
+    GrTAutoMapVertexBuffer<GrStencilAtlasOp::ResolveRectInstance> fStencilResolveBuffer;
     int fNextStencilResolveInstanceIdx = 0;
     SkDEBUGCODE(int fEndStencilResolveInstance);
 
diff --git a/src/gpu/ccpr/GrCCStroker.cpp b/src/gpu/ccpr/GrCCStroker.cpp
index bbf1486..4b5ef14 100644
--- a/src/gpu/ccpr/GrCCStroker.cpp
+++ b/src/gpu/ccpr/GrCCStroker.cpp
@@ -12,6 +12,7 @@
 #include "src/gpu/GrOnFlushResourceProvider.h"
 #include "src/gpu/GrOpsRenderPass.h"
 #include "src/gpu/GrProgramInfo.h"
+#include "src/gpu/ccpr/GrAutoMapVertexBuffer.h"
 #include "src/gpu/ccpr/GrCCCoverageProcessor.h"
 #include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
 #include "src/gpu/glsl/GrGLSLVertexGeoBuilder.h"
@@ -375,16 +376,14 @@
 
         int endConicsIdx = stroker->fBaseInstances[1].fConics +
                            stroker->fInstanceCounts[1]->fConics;
-        fInstanceBuffer = onFlushRP->makeBuffer(GrGpuBufferType::kVertex,
-                                                endConicsIdx * sizeof(ConicInstance));
-        if (!fInstanceBuffer) {
+        fInstanceBuffer.resetAndMapBuffer(onFlushRP, endConicsIdx * sizeof(ConicInstance));
+        if (!fInstanceBuffer.gpuBuffer()) {
             SkDebugf("WARNING: failed to allocate CCPR stroke instance buffer.\n");
             return;
         }
-        fInstanceBufferData = fInstanceBuffer->map();
     }
 
-    bool isMapped() const { return SkToBool(fInstanceBufferData); }
+    bool isMapped() const { return fInstanceBuffer.isMapped(); }
 
     void updateCurrentInfo(const PathInfo& pathInfo) {
         SkASSERT(this->isMapped());
@@ -514,10 +513,9 @@
     sk_sp<GrGpuBuffer> finish() {
         SkASSERT(this->isMapped());
         SkASSERT(!memcmp(fNextInstances, fEndInstances, sizeof(fNextInstances)));
-        fInstanceBuffer->unmap();
-        fInstanceBufferData = nullptr;
+        fInstanceBuffer.unmapBuffer();
         SkASSERT(!this->isMapped());
-        return std::move(fInstanceBuffer);
+        return sk_ref_sp(fInstanceBuffer.gpuBuffer());
     }
 
 private:
@@ -525,7 +523,7 @@
         int instanceIdx = fCurrNextInstances->fStrokes[0]++;
         SkASSERT(instanceIdx < fCurrEndInstances->fStrokes[0]);
 
-        return reinterpret_cast<LinearStrokeInstance*>(fInstanceBufferData)[instanceIdx];
+        return reinterpret_cast<LinearStrokeInstance*>(fInstanceBuffer.data())[instanceIdx];
     }
 
     CubicStrokeInstance& appendCubicStrokeInstance(int numLinearSegmentsLog2) {
@@ -535,21 +533,21 @@
         int instanceIdx = fCurrNextInstances->fStrokes[numLinearSegmentsLog2]++;
         SkASSERT(instanceIdx < fCurrEndInstances->fStrokes[numLinearSegmentsLog2]);
 
-        return reinterpret_cast<CubicStrokeInstance*>(fInstanceBufferData)[instanceIdx];
+        return reinterpret_cast<CubicStrokeInstance*>(fInstanceBuffer.data())[instanceIdx];
     }
 
     TriangleInstance& appendTriangleInstance() {
         int instanceIdx = fCurrNextInstances->fTriangles++;
         SkASSERT(instanceIdx < fCurrEndInstances->fTriangles);
 
-        return reinterpret_cast<TriangleInstance*>(fInstanceBufferData)[instanceIdx];
+        return reinterpret_cast<TriangleInstance*>(fInstanceBuffer.data())[instanceIdx];
     }
 
     ConicInstance& appendConicInstance() {
         int instanceIdx = fCurrNextInstances->fConics++;
         SkASSERT(instanceIdx < fCurrEndInstances->fConics);
 
-        return reinterpret_cast<ConicInstance*>(fInstanceBufferData)[instanceIdx];
+        return reinterpret_cast<ConicInstance*>(fInstanceBuffer.data())[instanceIdx];
     }
 
     float fCurrDX, fCurrDY;
@@ -557,8 +555,7 @@
     InstanceTallies* fCurrNextInstances;
     SkDEBUGCODE(const InstanceTallies* fCurrEndInstances);
 
-    sk_sp<GrGpuBuffer> fInstanceBuffer;
-    void* fInstanceBufferData = nullptr;
+    GrAutoMapVertexBuffer fInstanceBuffer;
     InstanceTallies fNextInstances[2];
     SkDEBUGCODE(InstanceTallies fEndInstances[2]);
 };
diff --git a/src/gpu/ccpr/GrCoverageCountingPathRenderer.cpp b/src/gpu/ccpr/GrCoverageCountingPathRenderer.cpp
index bede7b6..c6c60f6 100644
--- a/src/gpu/ccpr/GrCoverageCountingPathRenderer.cpp
+++ b/src/gpu/ccpr/GrCoverageCountingPathRenderer.cpp
@@ -23,7 +23,6 @@
                                                                    GrRenderable::kYes);
     if (caps.driverBlacklistCCPR() || !shaderCaps.integerSupport() ||
         !caps.instanceAttribSupport() || !shaderCaps.floatIs32Bits() ||
-        GrCaps::kNone_MapFlags == caps.mapBufferFlags() ||
         !defaultA8Format.isValid() || // This checks both texturable and renderable
         !caps.halfFloatVertexAttributeSupport()) {
         return false;