diff --git a/gn/gpu.gni b/gn/gpu.gni
index 1d77327..55c7c78 100644
--- a/gn/gpu.gni
+++ b/gn/gpu.gni
@@ -261,6 +261,8 @@
   "$_src/gpu/GrTextureResolveRenderTask.h",
   "$_src/gpu/GrThreadSafeCache.cpp",
   "$_src/gpu/GrThreadSafeCache.h",
+  "$_src/gpu/GrThreadSafePipelineBuilder.cpp",
+  "$_src/gpu/GrThreadSafePipelineBuilder.h",
   "$_src/gpu/GrTracing.h",
   "$_src/gpu/GrTransferFromRenderTask.cpp",
   "$_src/gpu/GrTransferFromRenderTask.h",
diff --git a/include/gpu/GrContextThreadSafeProxy.h b/include/gpu/GrContextThreadSafeProxy.h
index ccfbefd..f645b87 100644
--- a/include/gpu/GrContextThreadSafeProxy.h
+++ b/include/gpu/GrContextThreadSafeProxy.h
@@ -23,6 +23,7 @@
 class GrContextThreadSafeProxyPriv;
 class GrTextBlobCache;
 class GrThreadSafeCache;
+class GrThreadSafePipelineBuilder;
 class SkSurfaceCharacterization;
 class SkSurfaceProps;
 
@@ -130,15 +131,16 @@
     // TODO: This should be part of the constructor but right now we have a chicken-and-egg problem
     // with GrContext where we get the caps by creating a GPU which requires a context (see the
     // `init` method on GrContext_Base).
-    void init(sk_sp<const GrCaps>);
+    void init(sk_sp<const GrCaps>, sk_sp<GrThreadSafePipelineBuilder>);
 
-    const GrBackendApi                 fBackend;
-    const GrContextOptions             fOptions;
-    const uint32_t                     fContextID;
-    sk_sp<const GrCaps>                fCaps;
-    std::unique_ptr<GrTextBlobCache>   fTextBlobCache;
-    std::unique_ptr<GrThreadSafeCache> fThreadSafeCache;
-    std::atomic<bool>                  fAbandoned{false};
+    const GrBackendApi                      fBackend;
+    const GrContextOptions                  fOptions;
+    const uint32_t                          fContextID;
+    sk_sp<const GrCaps>                     fCaps;
+    std::unique_ptr<GrTextBlobCache>        fTextBlobCache;
+    std::unique_ptr<GrThreadSafeCache>      fThreadSafeCache;
+    sk_sp<GrThreadSafePipelineBuilder>      fPipelineBuilder;
+    std::atomic<bool>                       fAbandoned{false};
 };
 
 #else // !SK_SUPPORT_GPU
diff --git a/src/gpu/GrContextThreadSafeProxy.cpp b/src/gpu/GrContextThreadSafeProxy.cpp
index 16b1847..2c3a221 100644
--- a/src/gpu/GrContextThreadSafeProxy.cpp
+++ b/src/gpu/GrContextThreadSafeProxy.cpp
@@ -14,6 +14,7 @@
 #include "src/gpu/GrBaseContextPriv.h"
 #include "src/gpu/GrCaps.h"
 #include "src/gpu/GrThreadSafeCache.h"
+#include "src/gpu/GrThreadSafePipelineBuilder.h"
 #include "src/gpu/effects/GrSkSLFP.h"
 #include "src/image/SkSurface_Gpu.h"
 
@@ -37,10 +38,12 @@
 
 GrContextThreadSafeProxy::~GrContextThreadSafeProxy() = default;
 
-void GrContextThreadSafeProxy::init(sk_sp<const GrCaps> caps) {
+void GrContextThreadSafeProxy::init(sk_sp<const GrCaps> caps,
+                                    sk_sp<GrThreadSafePipelineBuilder> pipelineBuilder) {
     fCaps = std::move(caps);
     fTextBlobCache = std::make_unique<GrTextBlobCache>(fContextID);
     fThreadSafeCache = std::make_unique<GrThreadSafeCache>();
+    fPipelineBuilder = std::move(pipelineBuilder);
 }
 
 SkSurfaceCharacterization GrContextThreadSafeProxy::createCharacterization(
@@ -167,3 +170,8 @@
     return sk_sp<GrContextThreadSafeProxy>(new GrContextThreadSafeProxy(backend, options));
 }
 
+void GrContextThreadSafeProxyPriv::init(sk_sp<const GrCaps> caps,
+                                        sk_sp<GrThreadSafePipelineBuilder> builder) const {
+    fProxy->init(std::move(caps), std::move(builder));
+}
+
diff --git a/src/gpu/GrContextThreadSafeProxyPriv.h b/src/gpu/GrContextThreadSafeProxyPriv.h
index 606aa16..aae17e4 100644
--- a/src/gpu/GrContextThreadSafeProxyPriv.h
+++ b/src/gpu/GrContextThreadSafeProxyPriv.h
@@ -21,9 +21,7 @@
  */
 class GrContextThreadSafeProxyPriv {
 public:
-    void init(sk_sp<const GrCaps> caps) const {
-        fProxy->init(std::move(caps));
-    }
+    void init(sk_sp<const GrCaps>, sk_sp<GrThreadSafePipelineBuilder>) const;
 
     bool matches(GrContext_Base* candidate) const {
         return fProxy == candidate->threadSafeProxy().get();
diff --git a/src/gpu/GrDirectContext.cpp b/src/gpu/GrDirectContext.cpp
index 3301027..42ad297 100644
--- a/src/gpu/GrDirectContext.cpp
+++ b/src/gpu/GrDirectContext.cpp
@@ -190,7 +190,7 @@
         return false;
     }
 
-    fThreadSafeProxy->priv().init(fGpu->refCaps());
+    fThreadSafeProxy->priv().init(fGpu->refCaps(), fGpu->refPipelineBuilder());
     if (!INHERITED::init()) {
         return false;
     }
diff --git a/src/gpu/GrDirectContextPriv.cpp b/src/gpu/GrDirectContextPriv.cpp
index 9d03432..cf96536 100644
--- a/src/gpu/GrDirectContextPriv.cpp
+++ b/src/gpu/GrDirectContextPriv.cpp
@@ -17,6 +17,7 @@
 #include "src/gpu/GrSurfaceContext.h"
 #include "src/gpu/GrSurfaceDrawContext.h"
 #include "src/gpu/GrTexture.h"
+#include "src/gpu/GrThreadSafePipelineBuilder.h"
 #include "src/gpu/SkGr.h"
 #include "src/gpu/effects/GrSkSLFP.h"
 #include "src/gpu/effects/generated/GrConfigConversionEffect.h"
@@ -112,14 +113,20 @@
 
 void GrDirectContextPriv::dumpGpuStats(SkString* out) const {
 #if GR_GPU_STATS
-    return fContext->fGpu->stats()->dump(out);
+    fContext->fGpu->stats()->dump(out);
+    if (auto builder = fContext->fGpu->pipelineBuilder()) {
+        builder->stats()->dump(out);
+    }
 #endif
 }
 
 void GrDirectContextPriv::dumpGpuStatsKeyValuePairs(SkTArray<SkString>* keys,
                                                     SkTArray<double>* values) const {
 #if GR_GPU_STATS
-    return fContext->fGpu->stats()->dumpKeyValuePairs(keys, values);
+    fContext->fGpu->stats()->dumpKeyValuePairs(keys, values);
+    if (auto builder = fContext->fGpu->pipelineBuilder()) {
+        builder->stats()->dumpKeyValuePairs(keys, values);
+    }
 #endif
 }
 
diff --git a/src/gpu/GrGpu.cpp b/src/gpu/GrGpu.cpp
index 43df47f..2a450f2 100644
--- a/src/gpu/GrGpu.cpp
+++ b/src/gpu/GrGpu.cpp
@@ -720,22 +720,9 @@
 #if GR_TEST_UTILS
 
 #if GR_GPU_STATS
-static const char* cache_result_to_str(int i) {
-    const char* kCacheResultStrings[GrGpu::Stats::kNumProgramCacheResults] = {
-        "hits",
-        "misses",
-        "partials"
-    };
-    static_assert(0 == (int) GrGpu::Stats::ProgramCacheResult::kHit);
-    static_assert(1 == (int) GrGpu::Stats::ProgramCacheResult::kMiss);
-    static_assert(2 == (int) GrGpu::Stats::ProgramCacheResult::kPartial);
-    static_assert(GrGpu::Stats::kNumProgramCacheResults == 3);
-    return kCacheResultStrings[i];
-}
 
 void GrGpu::Stats::dump(SkString* out) {
     out->appendf("Render Target Binds: %d\n", fRenderTargetBinds);
-    out->appendf("Shader Compilations: %d\n", fShaderCompilations);
     out->appendf("Textures Created: %d\n", fTextureCreates);
     out->appendf("Texture Uploads: %d\n", fTextureUploads);
     out->appendf("Transfers to Texture: %d\n", fTransfersToTexture);
@@ -747,26 +734,6 @@
     out->appendf("Number of Scratch MSAA Attachments reused %d\n",
                  fNumScratchMSAAAttachmentsReused);
 
-    SkASSERT(fNumInlineCompilationFailures == 0);
-    out->appendf("Number of Inline compile failures %d\n", fNumInlineCompilationFailures);
-    for (int i = 0; i < Stats::kNumProgramCacheResults-1; ++i) {
-        out->appendf("Inline Program Cache %s %d\n", cache_result_to_str(i),
-                     fInlineProgramCacheStats[i]);
-    }
-
-    SkASSERT(fNumPreCompilationFailures == 0);
-    out->appendf("Number of precompile failures %d\n", fNumPreCompilationFailures);
-    for (int i = 0; i < Stats::kNumProgramCacheResults-1; ++i) {
-        out->appendf("Precompile Program Cache %s %d\n", cache_result_to_str(i),
-                     fPreProgramCacheStats[i]);
-    }
-
-    SkASSERT(fNumCompilationFailures == 0);
-    out->appendf("Total number of compilation failures %d\n", fNumCompilationFailures);
-    out->appendf("Total number of partial compilation successes %d\n",
-                 fNumPartialCompilationSuccesses);
-    out->appendf("Total number of compilation successes %d\n", fNumCompilationSuccesses);
-
     // enable this block to output CSV-style stats for program pre-compilation
 #if 0
     SkASSERT(fNumInlineCompilationFailures == 0);
@@ -785,7 +752,6 @@
 
 void GrGpu::Stats::dumpKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* values) {
     keys->push_back(SkString("render_target_binds")); values->push_back(fRenderTargetBinds);
-    keys->push_back(SkString("shader_compilations")); values->push_back(fShaderCompilations);
 }
 
 #endif // GR_GPU_STATS
diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h
index 90edca8..d020c42 100644
--- a/src/gpu/GrGpu.h
+++ b/src/gpu/GrGpu.h
@@ -43,6 +43,7 @@
 class GrStencilSettings;
 class GrSurface;
 class GrTexture;
+class GrThreadSafePipelineBuilder;
 class SkJSONWriter;
 
 namespace SkSL {
@@ -83,6 +84,9 @@
     // before GrDirectContext.
     virtual void disconnect(DisconnectType);
 
+    virtual GrThreadSafePipelineBuilder* pipelineBuilder() = 0;
+    virtual sk_sp<GrThreadSafePipelineBuilder> refPipelineBuilder() = 0;
+
     // Called by GrDirectContext::isContextLost. Returns true if the backend Gpu object has gotten
     // into an unrecoverable, lost state.
     virtual bool isDeviceLost() const { return false; }
@@ -414,16 +418,6 @@
 
     class Stats {
     public:
-        enum class ProgramCacheResult {
-            kHit,       // the program was found in the cache
-            kMiss,      // the program was not found in the cache (and was, thus, compiled)
-            kPartial,   // a precompiled version was found in the persistent cache
-
-            kLast = kPartial
-        };
-
-        static const int kNumProgramCacheResults = (int)ProgramCacheResult::kLast + 1;
-
 #if GR_GPU_STATS
         Stats() = default;
 
@@ -432,9 +426,6 @@
         int renderTargetBinds() const { return fRenderTargetBinds; }
         void incRenderTargetBinds() { fRenderTargetBinds++; }
 
-        int shaderCompilations() const { return fShaderCompilations; }
-        void incShaderCompilations() { fShaderCompilations++; }
-
         int textureCreates() const { return fTextureCreates; }
         void incTextureCreates() { fTextureCreates++; }
 
@@ -468,42 +459,12 @@
         int numScratchMSAAAttachmentsReused() const { return fNumScratchMSAAAttachmentsReused; }
         void incNumScratchMSAAAttachmentsReused() { ++fNumScratchMSAAAttachmentsReused; }
 
-        int numInlineCompilationFailures() const { return fNumInlineCompilationFailures; }
-        void incNumInlineCompilationFailures() { ++fNumInlineCompilationFailures; }
-
-        int numInlineProgramCacheResult(ProgramCacheResult stat) const {
-            return fInlineProgramCacheStats[(int) stat];
-        }
-        void incNumInlineProgramCacheResult(ProgramCacheResult stat) {
-            ++fInlineProgramCacheStats[(int) stat];
-        }
-
-        int numPreCompilationFailures() const { return fNumPreCompilationFailures; }
-        void incNumPreCompilationFailures() { ++fNumPreCompilationFailures; }
-
-        int numPreProgramCacheResult(ProgramCacheResult stat) const {
-            return fPreProgramCacheStats[(int) stat];
-        }
-        void incNumPreProgramCacheResult(ProgramCacheResult stat) {
-            ++fPreProgramCacheStats[(int) stat];
-        }
-
-        int numCompilationFailures() const { return fNumCompilationFailures; }
-        void incNumCompilationFailures() { ++fNumCompilationFailures; }
-
-        int numPartialCompilationSuccesses() const { return fNumPartialCompilationSuccesses; }
-        void incNumPartialCompilationSuccesses() { ++fNumPartialCompilationSuccesses; }
-
-        int numCompilationSuccesses() const { return fNumCompilationSuccesses; }
-        void incNumCompilationSuccesses() { ++fNumCompilationSuccesses; }
-
 #if GR_TEST_UTILS
         void dump(SkString*);
         void dumpKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* values);
 #endif
     private:
         int fRenderTargetBinds = 0;
-        int fShaderCompilations = 0;
         int fTextureCreates = 0;
         int fTextureUploads = 0;
         int fTransfersToTexture = 0;
@@ -516,16 +477,6 @@
         int fNumScratchTexturesReused = 0;
         int fNumScratchMSAAAttachmentsReused = 0;
 
-        int fNumInlineCompilationFailures = 0;
-        int fInlineProgramCacheStats[kNumProgramCacheResults] = { 0 };
-
-        int fNumPreCompilationFailures = 0;
-        int fPreProgramCacheStats[kNumProgramCacheResults] = { 0 };
-
-        int fNumCompilationFailures = 0;
-        int fNumPartialCompilationSuccesses = 0;
-        int fNumCompilationSuccesses = 0;
-
 #else
 
 #if GR_TEST_UTILS
@@ -533,7 +484,6 @@
         void dumpKeyValuePairs(SkTArray<SkString>*, SkTArray<double>*) {}
 #endif
         void incRenderTargetBinds() {}
-        void incShaderCompilations() {}
         void incTextureCreates() {}
         void incTextureUploads() {}
         void incTransfersToTexture() {}
@@ -545,13 +495,6 @@
         void incNumSubmitToGpus() {}
         void incNumScratchTexturesReused() {}
         void incNumScratchMSAAAttachmentsReused() {}
-        void incNumInlineCompilationFailures() {}
-        void incNumInlineProgramCacheResult(ProgramCacheResult stat) {}
-        void incNumPreCompilationFailures() {}
-        void incNumPreProgramCacheResult(ProgramCacheResult stat) {}
-        void incNumCompilationFailures() {}
-        void incNumPartialCompilationSuccesses() {}
-        void incNumCompilationSuccesses() {}
 #endif
     };
 
diff --git a/src/gpu/GrThreadSafePipelineBuilder.cpp b/src/gpu/GrThreadSafePipelineBuilder.cpp
new file mode 100644
index 0000000..1a522ce
--- /dev/null
+++ b/src/gpu/GrThreadSafePipelineBuilder.cpp
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2021 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/GrThreadSafePipelineBuilder.h"
+
+#if GR_GPU_STATS
+#if GR_TEST_UTILS
+#include "include/core/SkString.h"
+
+using Stats = GrThreadSafePipelineBuilder::Stats;
+
+static const char* cache_result_to_str(int i) {
+    const char* kCacheResultStrings[Stats::kNumProgramCacheResults] = {
+        "hits",
+        "misses",
+        "partials"
+    };
+    static_assert(0 == (int) Stats::ProgramCacheResult::kHit);
+    static_assert(1 == (int) Stats::ProgramCacheResult::kMiss);
+    static_assert(2 == (int) Stats::ProgramCacheResult::kPartial);
+    static_assert(Stats::kNumProgramCacheResults == 3);
+    return kCacheResultStrings[i];
+}
+
+void GrThreadSafePipelineBuilder::Stats::dump(SkString* out) {
+    out->appendf("Shader Compilations: %d\n", fShaderCompilations.load());
+
+    SkASSERT(fNumInlineCompilationFailures == 0);
+    out->appendf("Number of Inline compile failures %d\n", fNumInlineCompilationFailures.load());
+    for (int i = 0; i < Stats::kNumProgramCacheResults-1; ++i) {
+        out->appendf("Inline Program Cache %s %d\n", cache_result_to_str(i),
+                     fInlineProgramCacheStats[i].load());
+    }
+
+    SkASSERT(fNumPreCompilationFailures == 0);
+    out->appendf("Number of precompile failures %d\n", fNumPreCompilationFailures.load());
+    for (int i = 0; i < Stats::kNumProgramCacheResults-1; ++i) {
+        out->appendf("Precompile Program Cache %s %d\n", cache_result_to_str(i),
+                     fPreProgramCacheStats[i].load());
+    }
+
+    SkASSERT(fNumCompilationFailures == 0);
+    out->appendf("Total number of compilation failures %d\n", fNumCompilationFailures.load());
+    out->appendf("Total number of partial compilation successes %d\n",
+                 fNumPartialCompilationSuccesses.load());
+    out->appendf("Total number of compilation successes %d\n", fNumCompilationSuccesses.load());
+}
+
+void GrThreadSafePipelineBuilder::Stats::dumpKeyValuePairs(SkTArray<SkString>* keys,
+                                                           SkTArray<double>* values) {
+    keys->push_back(SkString("shader_compilations")); values->push_back(fShaderCompilations);
+}
+
+#endif // GR_TEST_UTILS
+#endif // GR_GPU_STATS
diff --git a/src/gpu/GrThreadSafePipelineBuilder.h b/src/gpu/GrThreadSafePipelineBuilder.h
new file mode 100644
index 0000000..6d6b3a1
--- /dev/null
+++ b/src/gpu/GrThreadSafePipelineBuilder.h
@@ -0,0 +1,112 @@
+/*
+ * Copyright 2021 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrThreadSafePipelineBuilder_Base_DEFINED
+#define GrThreadSafePipelineBuilder_Base_DEFINED
+
+#include "include/core/SkRefCnt.h"
+#include "include/gpu/GrConfig.h"
+
+#if GR_TEST_UTILS
+#include "include/private/SkTArray.h"
+class SkString;
+#endif
+
+class GrThreadSafePipelineBuilder : public SkRefCnt {
+public:
+    GrThreadSafePipelineBuilder() = default;
+
+    class Stats {
+    public:
+        enum class ProgramCacheResult {
+            kHit,       // the program was found in the cache
+            kMiss,      // the program was not found in the cache (and was, thus, compiled)
+            kPartial,   // a precompiled version was found in the persistent cache
+
+            kLast = kPartial
+        };
+
+#if GR_GPU_STATS
+        static const int kNumProgramCacheResults = (int)ProgramCacheResult::kLast + 1;
+
+        Stats() = default;
+
+        int shaderCompilations() const { return fShaderCompilations; }
+        void incShaderCompilations() { fShaderCompilations++; }
+
+        int numInlineCompilationFailures() const { return fNumInlineCompilationFailures; }
+        void incNumInlineCompilationFailures() { ++fNumInlineCompilationFailures; }
+
+        int numInlineProgramCacheResult(ProgramCacheResult stat) const {
+            return fInlineProgramCacheStats[(int) stat];
+        }
+        void incNumInlineProgramCacheResult(ProgramCacheResult stat) {
+            ++fInlineProgramCacheStats[(int) stat];
+        }
+
+        int numPreCompilationFailures() const { return fNumPreCompilationFailures; }
+        void incNumPreCompilationFailures() { ++fNumPreCompilationFailures; }
+
+        int numPreProgramCacheResult(ProgramCacheResult stat) const {
+            return fPreProgramCacheStats[(int) stat];
+        }
+        void incNumPreProgramCacheResult(ProgramCacheResult stat) {
+            ++fPreProgramCacheStats[(int) stat];
+        }
+
+        int numCompilationFailures() const { return fNumCompilationFailures; }
+        void incNumCompilationFailures() { ++fNumCompilationFailures; }
+
+        int numPartialCompilationSuccesses() const { return fNumPartialCompilationSuccesses; }
+        void incNumPartialCompilationSuccesses() { ++fNumPartialCompilationSuccesses; }
+
+        int numCompilationSuccesses() const { return fNumCompilationSuccesses; }
+        void incNumCompilationSuccesses() { ++fNumCompilationSuccesses; }
+
+#if GR_TEST_UTILS
+        void dump(SkString*);
+        void dumpKeyValuePairs(SkTArray<SkString>* keys, SkTArray<double>* values);
+#endif
+
+    private:
+        std::atomic<int> fShaderCompilations{0};
+
+        std::atomic<int> fNumInlineCompilationFailures{0};
+        std::atomic<int> fInlineProgramCacheStats[kNumProgramCacheResults]{0};
+
+        std::atomic<int> fNumPreCompilationFailures{0};
+        std::atomic<int> fPreProgramCacheStats[kNumProgramCacheResults]{0};
+
+        std::atomic<int> fNumCompilationFailures{0};
+        std::atomic<int> fNumPartialCompilationSuccesses{0};
+        std::atomic<int> fNumCompilationSuccesses{0};
+
+#else
+        void incShaderCompilations() {}
+        void incNumInlineCompilationFailures() {}
+        void incNumInlineProgramCacheResult(ProgramCacheResult stat) {}
+        void incNumPreCompilationFailures() {}
+        void incNumPreProgramCacheResult(ProgramCacheResult stat) {}
+        void incNumCompilationFailures() {}
+        void incNumPartialCompilationSuccesses() {}
+        void incNumCompilationSuccesses() {}
+
+#if GR_TEST_UTILS
+        void dump(SkString*) {}
+        void dumpKeyValuePairs(SkTArray<SkString>*, SkTArray<double>*) {}
+#endif
+
+#endif // GR_GPU_STATS
+    };
+
+    Stats* stats() { return &fStats; }
+
+protected:
+    Stats fStats;
+};
+
+#endif
diff --git a/src/gpu/d3d/GrD3DGpu.cpp b/src/gpu/d3d/GrD3DGpu.cpp
index 7d76ccf..81d9ebb 100644
--- a/src/gpu/d3d/GrD3DGpu.cpp
+++ b/src/gpu/d3d/GrD3DGpu.cpp
@@ -14,6 +14,7 @@
 #include "src/gpu/GrBackendUtils.h"
 #include "src/gpu/GrDataUtils.h"
 #include "src/gpu/GrTexture.h"
+#include "src/gpu/GrThreadSafePipelineBuilder.h"
 #include "src/gpu/d3d/GrD3DAMDMemoryAllocator.h"
 #include "src/gpu/d3d/GrD3DAttachment.h"
 #include "src/gpu/d3d/GrD3DBuffer.h"
@@ -29,6 +30,15 @@
 #include <DXProgrammableCapture.h>
 #endif
 
+GrThreadSafePipelineBuilder* GrD3DGpu::pipelineBuilder() {
+    return nullptr;
+}
+
+sk_sp<GrThreadSafePipelineBuilder> GrD3DGpu::refPipelineBuilder() {
+    return nullptr;
+}
+
+
 sk_sp<GrGpu> GrD3DGpu::Make(const GrD3DBackendContext& backendContext,
                             const GrContextOptions& contextOptions, GrDirectContext* direct) {
     sk_sp<GrD3DMemoryAllocator> memoryAllocator = backendContext.fMemoryAllocator;
diff --git a/src/gpu/d3d/GrD3DGpu.h b/src/gpu/d3d/GrD3DGpu.h
index 1b0e216..9d66f15 100644
--- a/src/gpu/d3d/GrD3DGpu.h
+++ b/src/gpu/d3d/GrD3DGpu.h
@@ -36,6 +36,9 @@
 
     GrD3DResourceProvider& resourceProvider() { return fResourceProvider; }
 
+    GrThreadSafePipelineBuilder* pipelineBuilder() override;
+    sk_sp<GrThreadSafePipelineBuilder> refPipelineBuilder() override;
+
     ID3D12Device* device() const { return fDevice.get(); }
     ID3D12CommandQueue* queue() const { return fQueue.get(); }
 
diff --git a/src/gpu/dawn/GrDawnGpu.cpp b/src/gpu/dawn/GrDawnGpu.cpp
index 9e64a05..fe635b6 100644
--- a/src/gpu/dawn/GrDawnGpu.cpp
+++ b/src/gpu/dawn/GrDawnGpu.cpp
@@ -21,6 +21,7 @@
 #include "src/gpu/GrSemaphore.h"
 #include "src/gpu/GrStencilSettings.h"
 #include "src/gpu/GrTexture.h"
+#include "src/gpu/GrThreadSafePipelineBuilder.h"
 #include "src/gpu/dawn/GrDawnAttachment.h"
 #include "src/gpu/dawn/GrDawnBuffer.h"
 #include "src/gpu/dawn/GrDawnCaps.h"
@@ -145,6 +146,14 @@
     INHERITED::disconnect(type);
 }
 
+GrThreadSafePipelineBuilder* GrDawnGpu::pipelineBuilder() {
+    return nullptr;
+}
+
+sk_sp<GrThreadSafePipelineBuilder> GrDawnGpu::refPipelineBuilder() {
+    return nullptr;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 GrOpsRenderPass* GrDawnGpu::onGetOpsRenderPass(
diff --git a/src/gpu/dawn/GrDawnGpu.h b/src/gpu/dawn/GrDawnGpu.h
index d24ebcb..53bfc1b 100644
--- a/src/gpu/dawn/GrDawnGpu.h
+++ b/src/gpu/dawn/GrDawnGpu.h
@@ -34,6 +34,9 @@
 
     void disconnect(DisconnectType) override;
 
+    GrThreadSafePipelineBuilder* pipelineBuilder() override;
+    sk_sp<GrThreadSafePipelineBuilder> refPipelineBuilder() override;
+
     GrStagingBufferManager* stagingBufferManager() override { return &fStagingBufferManager; }
     void takeOwnershipOfBuffer(sk_sp<GrGpuBuffer>) override;
 
diff --git a/src/gpu/gl/GrGLGpu.cpp b/src/gpu/gl/GrGLGpu.cpp
index 7b43170..61d3ac1 100644
--- a/src/gpu/gl/GrGLGpu.cpp
+++ b/src/gpu/gl/GrGLGpu.cpp
@@ -387,6 +387,9 @@
     fPathRendering.reset();
     fCopyProgramArrayBuffer.reset();
     fMipmapProgramArrayBuffer.reset();
+    if (fProgramCache) {
+        fProgramCache->reset();
+    }
 
     fHWProgram.reset();
     if (fHWProgramID) {
@@ -461,6 +464,7 @@
     }
 
     fHWProgram.reset();
+    fProgramCache->reset();
     fProgramCache.reset();
 
     fHWProgramID = 0;
@@ -482,6 +486,14 @@
     fFinishCallbacks.callAll(/* doDelete */ DisconnectType::kCleanup == type);
 }
 
+GrThreadSafePipelineBuilder* GrGLGpu::pipelineBuilder() {
+    return fProgramCache.get();
+}
+
+sk_sp<GrThreadSafePipelineBuilder> GrGLGpu::refPipelineBuilder() {
+    return fProgramCache;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 void GrGLGpu::onResetContext(uint32_t resetBits) {
@@ -3065,15 +3077,16 @@
     std::unique_ptr<SkSL::Program> program = GrSkSLtoGLSL(this, SkSL::ProgramKind::kVertex,
                                                           sksl, settings, &glsl, errorHandler);
     GrGLuint vshader = GrGLCompileAndAttachShader(*fGLContext, fCopyPrograms[progIdx].fProgram,
-                                                  GR_GL_VERTEX_SHADER, glsl, &fStats, errorHandler);
+                                                  GR_GL_VERTEX_SHADER, glsl, fProgramCache->stats(),
+                                                  errorHandler);
     SkASSERT(program->fInputs.isEmpty());
 
     sksl.assign(fshaderTxt.c_str(), fshaderTxt.size());
     program = GrSkSLtoGLSL(this, SkSL::ProgramKind::kFragment, sksl, settings, &glsl,
                            errorHandler);
     GrGLuint fshader = GrGLCompileAndAttachShader(*fGLContext, fCopyPrograms[progIdx].fProgram,
-                                                  GR_GL_FRAGMENT_SHADER, glsl, &fStats,
-                                                  errorHandler);
+                                                  GR_GL_FRAGMENT_SHADER, glsl,
+                                                  fProgramCache->stats(), errorHandler);
     SkASSERT(program->fInputs.isEmpty());
 
     GL_CALL(LinkProgram(fCopyPrograms[progIdx].fProgram));
@@ -3218,15 +3231,16 @@
     std::unique_ptr<SkSL::Program> program = GrSkSLtoGLSL(this, SkSL::ProgramKind::kVertex,
                                                           sksl, settings, &glsl, errorHandler);
     GrGLuint vshader = GrGLCompileAndAttachShader(*fGLContext, fMipmapPrograms[progIdx].fProgram,
-                                                  GR_GL_VERTEX_SHADER, glsl, &fStats, errorHandler);
+                                                  GR_GL_VERTEX_SHADER, glsl,
+                                                  fProgramCache->stats(), errorHandler);
     SkASSERT(program->fInputs.isEmpty());
 
     sksl.assign(fshaderTxt.c_str(), fshaderTxt.size());
     program = GrSkSLtoGLSL(this, SkSL::ProgramKind::kFragment, sksl, settings, &glsl,
                            errorHandler);
     GrGLuint fshader = GrGLCompileAndAttachShader(*fGLContext, fMipmapPrograms[progIdx].fProgram,
-                                                  GR_GL_FRAGMENT_SHADER, glsl, &fStats,
-                                                  errorHandler);
+                                                  GR_GL_FRAGMENT_SHADER, glsl,
+                                                  fProgramCache->stats(), errorHandler);
     SkASSERT(program->fInputs.isEmpty());
 
     GL_CALL(LinkProgram(fMipmapPrograms[progIdx].fProgram));
@@ -3675,14 +3689,14 @@
 bool GrGLGpu::compile(const GrProgramDesc& desc, const GrProgramInfo& programInfo) {
     SkASSERT(!(GrProcessor::CustomFeatures::kSampleLocations & programInfo.requestedFeatures()));
 
-    Stats::ProgramCacheResult stat;
+    GrThreadSafePipelineBuilder::Stats::ProgramCacheResult stat;
 
     sk_sp<GrGLProgram> tmp = fProgramCache->findOrCreateProgram(desc, programInfo, &stat);
     if (!tmp) {
         return false;
     }
 
-    return stat != Stats::ProgramCacheResult::kHit;
+    return stat != GrThreadSafePipelineBuilder::Stats::ProgramCacheResult::kHit;
 }
 
 #if GR_TEST_UTILS
diff --git a/src/gpu/gl/GrGLGpu.h b/src/gpu/gl/GrGLGpu.h
index 4a27164..16ea5e1 100644
--- a/src/gpu/gl/GrGLGpu.h
+++ b/src/gpu/gl/GrGLGpu.h
@@ -15,6 +15,7 @@
 #include "src/gpu/GrGpu.h"
 #include "src/gpu/GrNativeRect.h"
 #include "src/gpu/GrProgramDesc.h"
+#include "src/gpu/GrThreadSafePipelineBuilder.h"
 #include "src/gpu/GrWindowRectsState.h"
 #include "src/gpu/GrXferProcessor.h"
 #include "src/gpu/gl/GrGLAttachment.h"
@@ -37,6 +38,9 @@
 
     void disconnect(DisconnectType) override;
 
+    GrThreadSafePipelineBuilder* pipelineBuilder() override;
+    sk_sp<GrThreadSafePipelineBuilder> refPipelineBuilder() override;
+
     const GrGLContext& glContext() const { return *fGLContext; }
 
     const GrGLInterface* glInterface() const { return fGLContext->glInterface(); }
@@ -352,10 +356,10 @@
     bool copySurfaceAsBlitFramebuffer(GrSurface* dst, GrSurface* src, const SkIRect& srcRect,
                                       const SkIPoint& dstPoint);
 
-    class ProgramCache : public ::SkNoncopyable {
+    class ProgramCache : public GrThreadSafePipelineBuilder {
     public:
         ProgramCache(GrGLGpu* gpu);
-        ~ProgramCache();
+        ~ProgramCache() override;
 
         void abandon();
         void reset();
@@ -365,9 +369,9 @@
                                                Stats::ProgramCacheResult* stat) {
             sk_sp<GrGLProgram> tmp = this->findOrCreateProgram(nullptr, desc, programInfo, stat);
             if (!tmp) {
-                fGpu->fStats.incNumPreCompilationFailures();
+                fStats.incNumPreCompilationFailures();
             } else {
-                fGpu->fStats.incNumPreProgramCacheResult(*stat);
+                fStats.incNumPreProgramCacheResult(*stat);
             }
 
             return tmp;
@@ -514,7 +518,7 @@
     std::unique_ptr<GrGLContext> fGLContext;
 
     // GL program-related state
-    std::unique_ptr<ProgramCache> fProgramCache;
+    sk_sp<ProgramCache>         fProgramCache;
 
     ///////////////////////////////////////////////////////////////////////////
     ///@name Caching of GL State
diff --git a/src/gpu/gl/GrGLGpuProgramCache.cpp b/src/gpu/gl/GrGLGpuProgramCache.cpp
index 9916aaa..4bc0e78 100644
--- a/src/gpu/gl/GrGLGpuProgramCache.cpp
+++ b/src/gpu/gl/GrGLGpuProgramCache.cpp
@@ -61,9 +61,9 @@
     Stats::ProgramCacheResult stat;
     sk_sp<GrGLProgram> tmp = this->findOrCreateProgram(renderTarget, desc, programInfo, &stat);
     if (!tmp) {
-        fGpu->fStats.incNumInlineCompilationFailures();
+        fStats.incNumInlineCompilationFailures();
     } else {
-        fGpu->fStats.incNumInlineProgramCacheResult(stat);
+        fStats.incNumInlineProgramCacheResult(stat);
     }
 
     return tmp;
@@ -84,20 +84,20 @@
         if (!(*entry)->fProgram) {
             // Should we purge the program ID from the cache at this point?
             SkDEBUGFAIL("Couldn't create program from precompiled program");
-            fGpu->fStats.incNumCompilationFailures();
+            fStats.incNumCompilationFailures();
             return nullptr;
         }
-        fGpu->fStats.incNumPartialCompilationSuccesses();
+        fStats.incNumPartialCompilationSuccesses();
         *stat = Stats::ProgramCacheResult::kPartial;
     } else if (!entry) {
         // We have a cache miss
         sk_sp<GrGLProgram> program = GrGLProgramBuilder::CreateProgram(fGpu, renderTarget,
                                                                        desc, programInfo);
         if (!program) {
-            fGpu->fStats.incNumCompilationFailures();
+            fStats.incNumCompilationFailures();
             return nullptr;
         }
-        fGpu->fStats.incNumCompilationSuccesses();
+        fStats.incNumCompilationSuccesses();
         entry = fMap.insert(desc, std::make_unique<Entry>(std::move(program)));
         *stat = Stats::ProgramCacheResult::kMiss;
     }
diff --git a/src/gpu/gl/builders/GrGLProgramBuilder.cpp b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
index cb14885..d0bd1f2 100644
--- a/src/gpu/gl/builders/GrGLProgramBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLProgramBuilder.cpp
@@ -106,7 +106,7 @@
                                                    programId,
                                                    type,
                                                    glsl,
-                                                   gpu->stats(),
+                                                   gpu->pipelineBuilder()->stats(),
                                                    errHandler);
     if (!shaderId) {
         return false;
@@ -614,7 +614,8 @@
         }
 
         if (GrGLuint shaderID = GrGLCompileAndAttachShader(gpu->glContext(), programID, type, glsl,
-                                                           gpu->stats(), errorHandler)) {
+                                                           gpu->pipelineBuilder()->stats(),
+                                                           errorHandler)) {
             shadersToDelete.push_back(shaderID);
             return true;
         } else {
diff --git a/src/gpu/gl/builders/GrGLShaderStringBuilder.cpp b/src/gpu/gl/builders/GrGLShaderStringBuilder.cpp
index eb32e2e..a9a9c69 100644
--- a/src/gpu/gl/builders/GrGLShaderStringBuilder.cpp
+++ b/src/gpu/gl/builders/GrGLShaderStringBuilder.cpp
@@ -55,7 +55,7 @@
                                     GrGLuint programId,
                                     GrGLenum type,
                                     const SkSL::String& glsl,
-                                    GrGpu::Stats* stats,
+                                    GrThreadSafePipelineBuilder::Stats* stats,
                                     GrContextOptions::ShaderErrorHandler* errorHandler) {
     TRACE_EVENT0_ALWAYS("skia.gpu", "driver_compile_shader");
     const GrGLInterface* gli = glCtx.glInterface();
diff --git a/src/gpu/gl/builders/GrGLShaderStringBuilder.h b/src/gpu/gl/builders/GrGLShaderStringBuilder.h
index 16ac700..01d31dc 100644
--- a/src/gpu/gl/builders/GrGLShaderStringBuilder.h
+++ b/src/gpu/gl/builders/GrGLShaderStringBuilder.h
@@ -25,7 +25,7 @@
                                     GrGLuint programId,
                                     GrGLenum type,
                                     const SkSL::String& glsl,
-                                    GrGpu::Stats*,
+                                    GrThreadSafePipelineBuilder::Stats*,
                                     GrContextOptions::ShaderErrorHandler* errorHandler);
 
 #endif
diff --git a/src/gpu/mock/GrMockGpu.cpp b/src/gpu/mock/GrMockGpu.cpp
index 0caa16a..1927b18 100644
--- a/src/gpu/mock/GrMockGpu.cpp
+++ b/src/gpu/mock/GrMockGpu.cpp
@@ -7,6 +7,7 @@
 
 #include "src/gpu/mock/GrMockGpu.h"
 
+#include "src/gpu/GrThreadSafePipelineBuilder.h"
 #include "src/gpu/mock/GrMockAttachment.h"
 #include "src/gpu/mock/GrMockBuffer.h"
 #include "src/gpu/mock/GrMockCaps.h"
@@ -79,6 +80,16 @@
     this->initCapsAndCompiler(sk_make_sp<GrMockCaps>(contextOptions, options));
 }
 
+GrMockGpu::~GrMockGpu() {}
+
+GrThreadSafePipelineBuilder* GrMockGpu::pipelineBuilder() {
+    return nullptr;
+}
+
+sk_sp<GrThreadSafePipelineBuilder> GrMockGpu::refPipelineBuilder() {
+    return nullptr;
+}
+
 void GrMockGpu::querySampleLocations(GrRenderTarget* rt, SkTArray<SkPoint>* sampleLocations) {
     sampleLocations->reset();
     int numRemainingSamples = rt->numSamples();
diff --git a/src/gpu/mock/GrMockGpu.h b/src/gpu/mock/GrMockGpu.h
index d77ce5b..a3e0c76 100644
--- a/src/gpu/mock/GrMockGpu.h
+++ b/src/gpu/mock/GrMockGpu.h
@@ -22,7 +22,10 @@
 public:
     static sk_sp<GrGpu> Make(const GrMockOptions*, const GrContextOptions&, GrDirectContext*);
 
-    ~GrMockGpu() override {}
+    ~GrMockGpu() override;
+
+    GrThreadSafePipelineBuilder* pipelineBuilder() override;
+    sk_sp<GrThreadSafePipelineBuilder> refPipelineBuilder() override;
 
     GrFence SK_WARN_UNUSED_RESULT insertFence() override { return 0; }
     bool waitFence(GrFence) override { return true; }
diff --git a/src/gpu/mtl/GrMtlGpu.h b/src/gpu/mtl/GrMtlGpu.h
index 221273a..7d9ffd4 100644
--- a/src/gpu/mtl/GrMtlGpu.h
+++ b/src/gpu/mtl/GrMtlGpu.h
@@ -38,6 +38,9 @@
 
     void disconnect(DisconnectType) override;
 
+    GrThreadSafePipelineBuilder* pipelineBuilder() override;
+    sk_sp<GrThreadSafePipelineBuilder> refPipelineBuilder() override;
+
     const GrMtlCaps& mtlCaps() const { return *fMtlCaps.get(); }
 
     id<MTLDevice> device() const { return fDevice; }
diff --git a/src/gpu/mtl/GrMtlGpu.mm b/src/gpu/mtl/GrMtlGpu.mm
index 48ad7a8..0537cd6 100644
--- a/src/gpu/mtl/GrMtlGpu.mm
+++ b/src/gpu/mtl/GrMtlGpu.mm
@@ -15,6 +15,7 @@
 #include "src/gpu/GrDataUtils.h"
 #include "src/gpu/GrRenderTarget.h"
 #include "src/gpu/GrTexture.h"
+#include "src/gpu/GrThreadSafePipelineBuilder.h"
 #include "src/gpu/mtl/GrMtlBuffer.h"
 #include "src/gpu/mtl/GrMtlCommandBuffer.h"
 #include "src/gpu/mtl/GrMtlOpsRenderPass.h"
@@ -168,6 +169,14 @@
     }
 }
 
+GrThreadSafePipelineBuilder* GrMtlGpu::pipelineBuilder() {
+    return nullptr;
+}
+
+sk_sp<GrThreadSafePipelineBuilder> GrMtlGpu::refPipelineBuilder() {
+    return nullptr;
+}
+
 void GrMtlGpu::destroyResources() {
     this->submitCommandBuffer(SyncQueue::kForce_SyncQueue);
 
diff --git a/src/gpu/vk/GrVkGpu.cpp b/src/gpu/vk/GrVkGpu.cpp
index 4bffecb..47de405 100644
--- a/src/gpu/vk/GrVkGpu.cpp
+++ b/src/gpu/vk/GrVkGpu.cpp
@@ -25,6 +25,7 @@
 #include "src/gpu/GrRenderTarget.h"
 #include "src/gpu/GrSurfaceDrawContext.h"
 #include "src/gpu/GrTexture.h"
+#include "src/gpu/GrThreadSafePipelineBuilder.h"
 #include "src/gpu/SkGpuDevice.h"
 #include "src/gpu/SkGr.h"
 #include "src/gpu/vk/GrVkAMDMemoryAllocator.h"
@@ -289,6 +290,14 @@
     }
 }
 
+GrThreadSafePipelineBuilder* GrVkGpu::pipelineBuilder() {
+    return fResourceProvider.pipelineStateCache();
+}
+
+sk_sp<GrThreadSafePipelineBuilder> GrVkGpu::refPipelineBuilder() {
+    return fResourceProvider.refPipelineStateCache();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 GrOpsRenderPass* GrVkGpu::onGetOpsRenderPass(
@@ -1978,7 +1987,7 @@
         return false;
     }
 
-    Stats::ProgramCacheResult stat;
+    GrThreadSafePipelineBuilder::Stats::ProgramCacheResult stat;
 
     auto pipelineState = this->resourceProvider().findOrCreateCompatiblePipelineState(
                                     desc,
@@ -1989,7 +1998,7 @@
         return false;
     }
 
-    return stat != Stats::ProgramCacheResult::kHit;
+    return stat != GrThreadSafePipelineBuilder::Stats::ProgramCacheResult::kHit;
 }
 
 #if GR_TEST_UTILS
diff --git a/src/gpu/vk/GrVkGpu.h b/src/gpu/vk/GrVkGpu.h
index 870d75d..e2390d8 100644
--- a/src/gpu/vk/GrVkGpu.h
+++ b/src/gpu/vk/GrVkGpu.h
@@ -43,6 +43,9 @@
     void disconnect(DisconnectType) override;
     bool disconnected() const { return fDisconnected; }
 
+    GrThreadSafePipelineBuilder* pipelineBuilder() override;
+    sk_sp<GrThreadSafePipelineBuilder> refPipelineBuilder() override;
+
     const GrVkInterface* vkInterface() const { return fInterface.get(); }
     const GrVkCaps& vkCaps() const { return *fVkCaps; }
 
diff --git a/src/gpu/vk/GrVkPipelineStateBuilder.cpp b/src/gpu/vk/GrVkPipelineStateBuilder.cpp
index 52d0f34..fc77272 100644
--- a/src/gpu/vk/GrVkPipelineStateBuilder.cpp
+++ b/src/gpu/vk/GrVkPipelineStateBuilder.cpp
@@ -29,7 +29,9 @@
         VkRenderPass compatibleRenderPass,
         bool overrideSubpassForResolveLoad) {
 
-    gpu->stats()->incShaderCompilations();
+    GrVkResourceProvider& resourceProvider = gpu->resourceProvider();
+
+    resourceProvider.pipelineStateCache()->stats()->incShaderCompilations();
 
     // ensure that we use "." as a decimal separator when creating SkSL code
     GrAutoLocaleSetter als("C");
diff --git a/src/gpu/vk/GrVkPipelineStateCache.cpp b/src/gpu/vk/GrVkPipelineStateCache.cpp
index 7aa080e..3d3fb23 100644
--- a/src/gpu/vk/GrVkPipelineStateCache.cpp
+++ b/src/gpu/vk/GrVkPipelineStateCache.cpp
@@ -50,13 +50,13 @@
     // dump stats
 #ifdef SK_DEBUG
     if (c_DisplayVkPipelineCache) {
-        using CacheResult = GrGpu::Stats::ProgramCacheResult;
+        using CacheResult = Stats::ProgramCacheResult;
 
-        int misses = fGpu->stats()->numInlineProgramCacheResult(CacheResult::kMiss) +
-                     fGpu->stats()->numPreProgramCacheResult(CacheResult::kMiss);
+        int misses = fStats.numInlineProgramCacheResult(CacheResult::kMiss) +
+                     fStats.numPreProgramCacheResult(CacheResult::kMiss);
 
-        int total = misses + fGpu->stats()->numInlineProgramCacheResult(CacheResult::kHit) +
-                             fGpu->stats()->numPreProgramCacheResult(CacheResult::kHit);
+        int total = misses + fStats.numInlineProgramCacheResult(CacheResult::kHit) +
+                             fStats.numPreProgramCacheResult(CacheResult::kHit);
 
         SkDebugf("--- Pipeline State Cache ---\n");
         SkDebugf("Total requests: %d\n", total);
@@ -94,14 +94,14 @@
         return nullptr;
     }
 
-    GrGpu::Stats::ProgramCacheResult stat;
+    Stats::ProgramCacheResult stat;
     auto tmp = this->findOrCreatePipelineState(renderTarget, desc, programInfo,
                                                compatibleRenderPass, overrideSubpassForResolveLoad,
                                                &stat);
     if (!tmp) {
-        fGpu->stats()->incNumInlineCompilationFailures();
+        fStats.incNumInlineCompilationFailures();
     } else {
-        fGpu->stats()->incNumInlineProgramCacheResult(stat);
+        fStats.incNumInlineProgramCacheResult(stat);
     }
 
     return tmp;
@@ -113,15 +113,15 @@
         const GrProgramInfo& programInfo,
         VkRenderPass compatibleRenderPass,
         bool overrideSubpassForResolveLoad,
-        GrGpu::Stats::ProgramCacheResult* stat) {
+        Stats::ProgramCacheResult* stat) {
     if (stat) {
-        *stat = GrGpu::Stats::ProgramCacheResult::kHit;
+        *stat = Stats::ProgramCacheResult::kHit;
     }
 
     std::unique_ptr<Entry>* entry = fMap.find(desc);
     if (!entry) {
         if (stat) {
-            *stat = GrGpu::Stats::ProgramCacheResult::kMiss;
+            *stat = Stats::ProgramCacheResult::kMiss;
         }
         GrVkPipelineState* pipelineState(GrVkPipelineStateBuilder::CreatePipelineState(
                 fGpu, renderTarget, desc, programInfo, compatibleRenderPass,
diff --git a/src/gpu/vk/GrVkResourceProvider.cpp b/src/gpu/vk/GrVkResourceProvider.cpp
index bcf2768..75f1a25 100644
--- a/src/gpu/vk/GrVkResourceProvider.cpp
+++ b/src/gpu/vk/GrVkResourceProvider.cpp
@@ -22,7 +22,7 @@
 GrVkResourceProvider::GrVkResourceProvider(GrVkGpu* gpu)
     : fGpu(gpu)
     , fPipelineCache(VK_NULL_HANDLE) {
-    fPipelineStateCache = new PipelineStateCache(gpu);
+    fPipelineStateCache = sk_make_sp<PipelineStateCache>(gpu);
 }
 
 GrVkResourceProvider::~GrVkResourceProvider() {
@@ -30,7 +30,6 @@
     SkASSERT(0 == fExternalRenderPasses.count());
     SkASSERT(0 == fMSAALoadPipelines.count());
     SkASSERT(VK_NULL_HANDLE == fPipelineCache);
-    delete fPipelineStateCache;
 }
 
 VkPipelineCache GrVkResourceProvider::pipelineCache() {
@@ -266,14 +265,14 @@
         const GrProgramDesc& desc,
         const GrProgramInfo& programInfo,
         VkRenderPass compatibleRenderPass,
-        GrGpu::Stats::ProgramCacheResult* stat) {
+        GrThreadSafePipelineBuilder::Stats::ProgramCacheResult* stat) {
 
     auto tmp =  fPipelineStateCache->findOrCreatePipelineState(desc, programInfo,
                                                                compatibleRenderPass, stat);
     if (!tmp) {
-        fGpu->stats()->incNumPreCompilationFailures();
+        fPipelineStateCache->stats()->incNumPreCompilationFailures();
     } else {
-        fGpu->stats()->incNumPreProgramCacheResult(*stat);
+        fPipelineStateCache->stats()->incNumPreProgramCacheResult(*stat);
     }
 
     return tmp;
diff --git a/src/gpu/vk/GrVkResourceProvider.h b/src/gpu/vk/GrVkResourceProvider.h
index 38b7744..0b269f1 100644
--- a/src/gpu/vk/GrVkResourceProvider.h
+++ b/src/gpu/vk/GrVkResourceProvider.h
@@ -17,6 +17,7 @@
 #include "src/gpu/GrManagedResource.h"
 #include "src/gpu/GrProgramDesc.h"
 #include "src/gpu/GrResourceHandle.h"
+#include "src/gpu/GrThreadSafePipelineBuilder.h"
 #include "src/gpu/vk/GrVkDescriptorPool.h"
 #include "src/gpu/vk/GrVkDescriptorSetManager.h"
 #include "src/gpu/vk/GrVkPipelineStateBuilder.h"
@@ -42,6 +43,14 @@
     GrVkResourceProvider(GrVkGpu* gpu);
     ~GrVkResourceProvider();
 
+    GrThreadSafePipelineBuilder* pipelineStateCache() {
+        return fPipelineStateCache.get();
+    }
+
+    sk_sp<GrThreadSafePipelineBuilder> refPipelineStateCache() {
+        return fPipelineStateCache;
+    }
+
     // Set up any initial vk objects
     void init();
 
@@ -139,7 +148,7 @@
             const GrProgramDesc&,
             const GrProgramInfo&,
             VkRenderPass compatibleRenderPass,
-            GrGpu::Stats::ProgramCacheResult* stat);
+            GrThreadSafePipelineBuilder::Stats::ProgramCacheResult* stat);
 
     sk_sp<const GrVkPipeline> findOrCreateMSAALoadPipeline(
             const GrVkRenderPass& renderPass,
@@ -210,10 +219,10 @@
 
 private:
 
-    class PipelineStateCache : public ::SkNoncopyable {
+    class PipelineStateCache : public GrThreadSafePipelineBuilder {
     public:
         PipelineStateCache(GrVkGpu* gpu);
-        ~PipelineStateCache();
+        ~PipelineStateCache() override;
 
         void release();
         GrVkPipelineState* findOrCreatePipelineState(GrRenderTarget*,
@@ -223,7 +232,7 @@
         GrVkPipelineState* findOrCreatePipelineState(const GrProgramDesc& desc,
                                                      const GrProgramInfo& programInfo,
                                                      VkRenderPass compatibleRenderPass,
-                                                     GrGpu::Stats::ProgramCacheResult* stat) {
+                                                     Stats::ProgramCacheResult* stat) {
             return this->findOrCreatePipelineState(nullptr, desc, programInfo,
                                                    compatibleRenderPass, false, stat);
         }
@@ -236,7 +245,7 @@
                                                      const GrProgramInfo&,
                                                      VkRenderPass compatibleRenderPass,
                                                      bool overrideSubpassForResolveLoad,
-                                                     GrGpu::Stats::ProgramCacheResult*);
+                                                     Stats::ProgramCacheResult*);
 
         struct DescHash {
             uint32_t operator()(const GrProgramDesc& desc) const {
@@ -313,7 +322,7 @@
     SkTDynamicHash<GrVkSamplerYcbcrConversion, GrVkSamplerYcbcrConversion::Key> fYcbcrConversions;
 
     // Cache of GrVkPipelineStates
-    PipelineStateCache* fPipelineStateCache;
+    sk_sp<PipelineStateCache> fPipelineStateCache;
 
     SkSTArray<4, std::unique_ptr<GrVkDescriptorSetManager>> fDescriptorSetManagers;