diff --git a/include/private/GrRecordingContext.h b/include/private/GrRecordingContext.h
index 86e84f8..b671fd6 100644
--- a/include/private/GrRecordingContext.h
+++ b/include/private/GrRecordingContext.h
@@ -21,6 +21,7 @@
 class GrSurfaceContext;
 class GrSurfaceProxy;
 class GrTextBlobCache;
+class GrTextureContext;
 
 class SK_API GrRecordingContext : public GrImageContext {
 public:
@@ -62,16 +63,18 @@
                                                       sk_sp<SkColorSpace> = nullptr,
                                                       const SkSurfaceProps* = nullptr);
 
-    sk_sp<GrSurfaceContext> makeDeferredSurfaceContext(const GrBackendFormat&,
-                                                       const GrSurfaceDesc&,
-                                                       GrSurfaceOrigin,
-                                                       GrMipMapped,
-                                                       SkBackingFit,
-                                                       SkBudgeted,
-                                                       GrColorType,
-                                                       SkAlphaType,
-                                                       sk_sp<SkColorSpace> colorSpace = nullptr,
-                                                       const SkSurfaceProps* = nullptr);
+    /** Create a new texture context backed by a deferred-style GrTextureProxy. */
+    sk_sp<GrTextureContext> makeDeferredTextureContext(
+            SkBackingFit,
+            int width,
+            int height,
+            GrColorType,
+            SkAlphaType,
+            sk_sp<SkColorSpace>,
+            GrMipMapped = GrMipMapped::kNo,
+            GrSurfaceOrigin = kTopLeft_GrSurfaceOrigin,
+            SkBudgeted = SkBudgeted::kYes,
+            GrProtected = GrProtected::kNo);
 
     /*
      * Create a new render target context backed by a deferred-style
diff --git a/src/gpu/GrCaps.cpp b/src/gpu/GrCaps.cpp
index 145c3aa..50774c6 100644
--- a/src/gpu/GrCaps.cpp
+++ b/src/gpu/GrCaps.cpp
@@ -329,7 +329,8 @@
     // has the expected values stored in the right places taking the swizzle into account. For now
     // we can be more restrictive and just make sure the configs are the same and if we generalize
     // copies and swizzles more in the future this can be updated.
-    if (dst->config() != src->config()) {
+    if (this->makeConfigSpecific(dst->config(), dst->backendFormat()) !=
+        this->makeConfigSpecific(src->config(), src->backendFormat())) {
         return false;
     }
     return this->onCanCopySurface(dst, src, srcRect, dstPoint);
diff --git a/src/gpu/GrCaps.h b/src/gpu/GrCaps.h
index 5bd4234..617838a 100644
--- a/src/gpu/GrCaps.h
+++ b/src/gpu/GrCaps.h
@@ -432,6 +432,17 @@
 
     const GrDriverBugWorkarounds& workarounds() const { return fDriverBugWorkarounds; }
 
+    /**
+     * Given a possibly generic GrPixelConfig and a backend format return a specific
+     * GrPixelConfig.
+     */
+    GrPixelConfig makeConfigSpecific(GrPixelConfig config, const GrBackendFormat& format) const {
+        auto ct = GrPixelConfigToColorType(config);
+        auto result = this->getConfigFromBackendFormat(format, ct);
+        SkASSERT(config == result || AreConfigsCompatible(config, result));
+        return result;
+    }
+
 #ifdef SK_DEBUG
     // This is just a debugging entry point until we're weaned off of GrPixelConfig. It
     // should be used to verify that the pixel config from user-level code (the genericConfig)
diff --git a/src/gpu/GrContextPriv.cpp b/src/gpu/GrContextPriv.cpp
index 476bd08..ad6d8ab 100644
--- a/src/gpu/GrContextPriv.cpp
+++ b/src/gpu/GrContextPriv.cpp
@@ -57,19 +57,19 @@
                                                std::move(colorSpace), props);
 }
 
-sk_sp<GrSurfaceContext> GrContextPriv::makeDeferredSurfaceContext(const GrBackendFormat& format,
-                                                                  const GrSurfaceDesc& dstDesc,
-                                                                  GrSurfaceOrigin origin,
-                                                                  GrMipMapped mipMapped,
-                                                                  SkBackingFit fit,
-                                                                  SkBudgeted isDstBudgeted,
+sk_sp<GrTextureContext> GrContextPriv::makeDeferredTextureContext(SkBackingFit fit,
+                                                                  int width,
+                                                                  int height,
                                                                   GrColorType colorType,
                                                                   SkAlphaType alphaType,
                                                                   sk_sp<SkColorSpace> colorSpace,
-                                                                  const SkSurfaceProps* props) {
-    return fContext->makeDeferredSurfaceContext(format, dstDesc, origin, mipMapped, fit,
-                                                isDstBudgeted, colorType, alphaType,
-                                                std::move(colorSpace), props);
+                                                                  GrMipMapped mipMapped,
+                                                                  GrSurfaceOrigin origin,
+                                                                  SkBudgeted budgeted,
+                                                                  GrProtected isProtected) {
+    return fContext->makeDeferredTextureContext(fit, width, height, colorType, alphaType,
+                                                std::move(colorSpace), mipMapped, origin, budgeted,
+                                                isProtected);
 }
 
 sk_sp<GrRenderTargetContext> GrContextPriv::makeDeferredRenderTargetContext(
diff --git a/src/gpu/GrContextPriv.h b/src/gpu/GrContextPriv.h
index adea6c8..0e129b0 100644
--- a/src/gpu/GrContextPriv.h
+++ b/src/gpu/GrContextPriv.h
@@ -79,16 +79,18 @@
                                                       sk_sp<SkColorSpace> = nullptr,
                                                       const SkSurfaceProps* = nullptr);
 
-    sk_sp<GrSurfaceContext> makeDeferredSurfaceContext(const GrBackendFormat&,
-                                                       const GrSurfaceDesc&,
-                                                       GrSurfaceOrigin,
-                                                       GrMipMapped,
-                                                       SkBackingFit,
-                                                       SkBudgeted,
-                                                       GrColorType,
-                                                       SkAlphaType,
-                                                       sk_sp<SkColorSpace> colorSpace = nullptr,
-                                                       const SkSurfaceProps* = nullptr);
+    /** Create a new texture context backed by a deferred-style GrTextureProxy. */
+    sk_sp<GrTextureContext> makeDeferredTextureContext(
+            SkBackingFit,
+            int width,
+            int height,
+            GrColorType,
+            SkAlphaType,
+            sk_sp<SkColorSpace>,
+            GrMipMapped = GrMipMapped::kNo,
+            GrSurfaceOrigin = kTopLeft_GrSurfaceOrigin,
+            SkBudgeted = SkBudgeted::kYes,
+            GrProtected = GrProtected::kNo);
 
     /*
      * Create a new render target context backed by a deferred-style
diff --git a/src/gpu/GrRecordingContext.cpp b/src/gpu/GrRecordingContext.cpp
index d720771..cac1492 100644
--- a/src/gpu/GrRecordingContext.cpp
+++ b/src/gpu/GrRecordingContext.cpp
@@ -163,38 +163,46 @@
     }
 }
 
-sk_sp<GrSurfaceContext> GrRecordingContext::makeDeferredSurfaceContext(
-        const GrBackendFormat& format,
-        const GrSurfaceDesc& dstDesc,
-        GrSurfaceOrigin origin,
-        GrMipMapped mipMapped,
+sk_sp<GrTextureContext> GrRecordingContext::makeDeferredTextureContext(
         SkBackingFit fit,
-        SkBudgeted isDstBudgeted,
+        int width,
+        int height,
         GrColorType colorType,
         SkAlphaType alphaType,
         sk_sp<SkColorSpace> colorSpace,
-        const SkSurfaceProps* props) {
-    sk_sp<GrTextureProxy> proxy;
-    if (GrMipMapped::kNo == mipMapped) {
-        proxy = this->proxyProvider()->createProxy(format, dstDesc, origin, fit, isDstBudgeted);
-    } else {
-        SkASSERT(SkBackingFit::kExact == fit);
-        proxy = this->proxyProvider()->createMipMapProxy(format, dstDesc, origin, isDstBudgeted);
+        GrMipMapped mipMapped,
+        GrSurfaceOrigin origin,
+        SkBudgeted budgeted,
+        GrProtected isProtected) {
+    auto format = this->caps()->getBackendFormatFromColorType(colorType);
+    if (!format.isValid()) {
+        return nullptr;
     }
-    if (!proxy) {
+    auto config = this->caps()->getConfigFromBackendFormat(format, colorType);
+    if (config == kUnknown_GrPixelConfig) {
         return nullptr;
     }
 
-    sk_sp<GrSurfaceContext> sContext = this->makeWrappedSurfaceContext(std::move(proxy),
-                                                                       colorType,
-                                                                       alphaType,
-                                                                       std::move(colorSpace),
-                                                                       props);
-    if (sContext && sContext->asRenderTargetContext()) {
-        sContext->asRenderTargetContext()->discard();
+    GrSurfaceDesc desc;
+    desc.fWidth = width;
+    desc.fHeight = height;
+    desc.fIsProtected = isProtected;
+    desc.fConfig = config;
+
+    sk_sp<GrTextureProxy> texture;
+    if (GrMipMapped::kNo == mipMapped) {
+        texture = this->proxyProvider()->createProxy(format, desc, origin, fit, budgeted);
+    } else {
+        texture = this->proxyProvider()->createMipMapProxy(format, desc, origin, budgeted);
+    }
+    if (!texture) {
+        return nullptr;
     }
 
-    return sContext;
+    auto drawingManager = this->drawingManager();
+
+    return drawingManager->makeTextureContext(std::move(texture), colorType, alphaType,
+                                              std::move(colorSpace));
 }
 
 sk_sp<GrRenderTargetContext> GrRecordingContext::makeDeferredRenderTargetContext(
@@ -325,20 +333,20 @@
                                                std::move(colorSpace), props);
 }
 
-sk_sp<GrSurfaceContext> GrRecordingContextPriv::makeDeferredSurfaceContext(
-        const GrBackendFormat& format,
-        const GrSurfaceDesc& dstDesc,
-        GrSurfaceOrigin origin,
-        GrMipMapped mipMapped,
+sk_sp<GrTextureContext> GrRecordingContextPriv::makeDeferredTextureContext(
         SkBackingFit fit,
-        SkBudgeted isDstBudgeted,
+        int width,
+        int height,
         GrColorType colorType,
         SkAlphaType alphaType,
         sk_sp<SkColorSpace> colorSpace,
-        const SkSurfaceProps* props) {
-    return fContext->makeDeferredSurfaceContext(format, dstDesc, origin, mipMapped, fit,
-                                                isDstBudgeted, colorType, alphaType,
-                                                std::move(colorSpace), props);
+        GrMipMapped mipMapped,
+        GrSurfaceOrigin origin,
+        SkBudgeted budgeted,
+        GrProtected isProtected) {
+    return fContext->makeDeferredTextureContext(fit, width, height, colorType, alphaType,
+                                                std::move(colorSpace), mipMapped, origin, budgeted,
+                                                isProtected);
 }
 
 sk_sp<GrRenderTargetContext> GrRecordingContextPriv::makeDeferredRenderTargetContext(
diff --git a/src/gpu/GrRecordingContextPriv.h b/src/gpu/GrRecordingContextPriv.h
index 0743ae7..62ec136 100644
--- a/src/gpu/GrRecordingContextPriv.h
+++ b/src/gpu/GrRecordingContextPriv.h
@@ -63,16 +63,18 @@
                                                       sk_sp<SkColorSpace> = nullptr,
                                                       const SkSurfaceProps* = nullptr);
 
-    sk_sp<GrSurfaceContext> makeDeferredSurfaceContext(const GrBackendFormat&,
-                                                       const GrSurfaceDesc&,
-                                                       GrSurfaceOrigin,
-                                                       GrMipMapped,
-                                                       SkBackingFit,
-                                                       SkBudgeted,
-                                                       GrColorType,
-                                                       SkAlphaType,
-                                                       sk_sp<SkColorSpace> colorSpace = nullptr,
-                                                       const SkSurfaceProps* = nullptr);
+    /** Create a new texture context backed by a deferred-style GrTextureProxy. */
+    sk_sp<GrTextureContext> makeDeferredTextureContext(
+            SkBackingFit,
+            int width,
+            int height,
+            GrColorType,
+            SkAlphaType,
+            sk_sp<SkColorSpace>,
+            GrMipMapped = GrMipMapped::kNo,
+            GrSurfaceOrigin = kTopLeft_GrSurfaceOrigin,
+            SkBudgeted = SkBudgeted::kYes,
+            GrProtected = GrProtected::kNo);
 
     /*
      * Create a new render target context backed by a deferred-style
diff --git a/src/gpu/GrSurfaceContext.cpp b/src/gpu/GrSurfaceContext.cpp
index 708002e..94a3abe 100644
--- a/src/gpu/GrSurfaceContext.cpp
+++ b/src/gpu/GrSurfaceContext.cpp
@@ -403,13 +403,17 @@
     SkDEBUGCODE(this->validate();)
     GR_AUDIT_TRAIL_AUTO_FRAME(this->auditTrail(), "GrSurfaceContextPriv::copy");
 
+    const GrCaps* caps = fContext->priv().caps();
+
     SkASSERT(src->backendFormat().textureType() != GrTextureType::kExternal);
     SkASSERT(src->origin() == this->asSurfaceProxy()->origin());
-    SkASSERT(src->config() == this->asSurfaceProxy()->config());
+    SkASSERT(caps->makeConfigSpecific(src->config(), src->backendFormat()) ==
+             caps->makeConfigSpecific(this->asSurfaceProxy()->config(),
+                                      this->asSurfaceProxy()->backendFormat()));
 
     GrSurfaceProxy* dst = this->asSurfaceProxy();
 
-    if (!fContext->priv().caps()->canCopySurface(dst, src, srcRect, dstPoint)) {
+    if (!caps->canCopySurface(dst, src, srcRect, dstPoint)) {
         return false;
     }
 
diff --git a/src/gpu/GrSurfaceProxy.cpp b/src/gpu/GrSurfaceProxy.cpp
index b24dc45..db7e794 100644
--- a/src/gpu/GrSurfaceProxy.cpp
+++ b/src/gpu/GrSurfaceProxy.cpp
@@ -10,6 +10,8 @@
 
 #include "include/gpu/GrContext.h"
 #include "include/private/GrRecordingContext.h"
+#include "src/core/SkMathPriv.h"
+#include "src/core/SkMipMap.h"
 #include "src/gpu/GrCaps.h"
 #include "src/gpu/GrClip.h"
 #include "src/gpu/GrContextPriv.h"
@@ -18,15 +20,11 @@
 #include "src/gpu/GrProxyProvider.h"
 #include "src/gpu/GrRecordingContextPriv.h"
 #include "src/gpu/GrStencilAttachment.h"
-#include "src/gpu/GrSurfaceContext.h"
-#include "src/gpu/GrSurfaceContextPriv.h"
 #include "src/gpu/GrSurfacePriv.h"
+#include "src/gpu/GrTextureContext.h"
 #include "src/gpu/GrTexturePriv.h"
 #include "src/gpu/GrTextureRenderTargetProxy.h"
 
-#include "src/core/SkMathPriv.h"
-#include "src/core/SkMipMap.h"
-
 #ifdef SK_DEBUG
 #include "include/gpu/GrRenderTarget.h"
 #include "src/gpu/GrRenderTargetPriv.h"
@@ -342,18 +340,18 @@
                                            SkBudgeted budgeted,
                                            RectsMustMatch rectsMustMatch) {
     SkASSERT(LazyState::kFully != src->lazyInstantiationState());
-    GrSurfaceDesc dstDesc;
-    dstDesc.fIsProtected = src->isProtected() ? GrProtected::kYes : GrProtected::kNo;
-    dstDesc.fConfig = src->config();
+    GrProtected isProtected = src->isProtected() ? GrProtected::kYes : GrProtected::kNo;
+    int width;
+    int height;
 
     SkIPoint dstPoint;
     if (rectsMustMatch == RectsMustMatch::kYes) {
-        dstDesc.fWidth = src->width();
-        dstDesc.fHeight = src->height();
+        width = src->width();
+        height = src->height();
         dstPoint = {srcRect.fLeft, srcRect.fTop};
     } else {
-        dstDesc.fWidth = srcRect.width();
-        dstDesc.fHeight = srcRect.height();
+        width = srcRect.width();
+        height = srcRect.height();
         dstPoint = {0, 0};
     }
 
@@ -362,9 +360,9 @@
     }
     auto colorType = GrPixelConfigToColorType(src->config());
     if (src->backendFormat().textureType() != GrTextureType::kExternal) {
-        sk_sp<GrSurfaceContext> dstContext(context->priv().makeDeferredSurfaceContext(
-                src->backendFormat().makeTexture2D(), dstDesc, src->origin(), mipMapped, fit,
-                budgeted, colorType, kUnknown_SkAlphaType));
+        sk_sp<GrTextureContext> dstContext(context->priv().makeDeferredTextureContext(
+                fit, width, height, colorType, kUnknown_SkAlphaType, nullptr, mipMapped,
+                src->origin(), budgeted, isProtected));
         if (!dstContext) {
             return nullptr;
         }
@@ -374,8 +372,8 @@
     }
     if (src->asTextureProxy()) {
         sk_sp<GrRenderTargetContext> dstContext = context->priv().makeDeferredRenderTargetContext(
-                fit, dstDesc.fWidth, dstDesc.fHeight, colorType, nullptr, 1, mipMapped,
-                src->origin(), nullptr, budgeted);
+                fit, width, height, colorType, nullptr, 1, mipMapped, src->origin(), nullptr,
+                budgeted);
 
         if (dstContext && dstContext->blitTexture(src->asTextureProxy(), srcRect, dstPoint)) {
             return dstContext->asTextureProxyRef();
diff --git a/src/image/SkSurface_Gpu.cpp b/src/image/SkSurface_Gpu.cpp
index 0bf78cf..6bc6d3d 100644
--- a/src/image/SkSurface_Gpu.cpp
+++ b/src/image/SkSurface_Gpu.cpp
@@ -363,37 +363,25 @@
     }
 
     GrColorType grColorType = SkColorTypeToGrColorType(c.colorType());
-    GrPixelConfig config = caps->getConfigFromBackendFormat(c.backendFormat(), grColorType);
-    if (config == kUnknown_GrPixelConfig) {
-        return nullptr;
-    }
 
-    GrSurfaceDesc desc;
-    desc.fFlags = kRenderTarget_GrSurfaceFlag;
-    desc.fWidth = c.width();
-    desc.fHeight = c.height();
-    desc.fIsProtected = c.isProtected();
-    desc.fConfig = config;
-    desc.fSampleCnt = c.sampleCount();
-
-    sk_sp<GrSurfaceContext> sc(
-            context->priv().makeDeferredSurfaceContext(c.backendFormat(),
-                                                       desc,
-                                                       c.origin(),
-                                                       GrMipMapped(c.isMipMapped()),
-                                                       SkBackingFit::kExact,
-                                                       budgeted,
-                                                       grColorType,
-                                                       kPremul_SkAlphaType,
-                                                       c.refColorSpace(),
-                                                       &c.surfaceProps()));
-    if (!sc || !sc->asRenderTargetContext()) {
+    sk_sp<GrRenderTargetContext> rtc(context->priv().makeDeferredRenderTargetContext(
+            SkBackingFit::kExact,
+            c.width(),
+            c.height(),
+            grColorType,
+            c.refColorSpace(),
+            c.sampleCount(),
+            GrMipMapped(c.isMipMapped()),
+            c.origin(),
+            &c.surfaceProps(),
+            budgeted,
+            c.isProtected()));
+    if (!rtc) {
         return nullptr;
     }
 
     // CONTEXT TODO: remove this use of 'backdoor' to create an SkGpuDevice
-    sk_sp<SkGpuDevice> device(SkGpuDevice::Make(context->priv().backdoor(),
-                                                sk_ref_sp(sc->asRenderTargetContext()),
+    sk_sp<SkGpuDevice> device(SkGpuDevice::Make(context->priv().backdoor(), std::move(rtc),
                                                 c.width(), c.height(),
                                                 SkGpuDevice::kClear_InitContents));
     if (!device) {
diff --git a/tests/GrSurfaceTest.cpp b/tests/GrSurfaceTest.cpp
index e16eb89..869ed75 100644
--- a/tests/GrSurfaceTest.cpp
+++ b/tests/GrSurfaceTest.cpp
@@ -280,14 +280,19 @@
                         }
 
                         GrColorType colorType = GrPixelConfigToColorType(desc.fConfig);
-                        const GrBackendFormat format =
-                                caps->getBackendFormatFromColorType(colorType);
 
                         // Try creating the texture as a deferred proxy.
                         for (int i = 0; i < 2; ++i) {
-                            auto surfCtx = context->priv().makeDeferredSurfaceContext(
-                                    format, desc, origin, GrMipMapped::kNo, fit, SkBudgeted::kYes,
-                                    colorType, kPremul_SkAlphaType);
+                            sk_sp<GrSurfaceContext> surfCtx;
+                            if (desc.fFlags & kRenderTarget_GrSurfaceFlag) {
+                                surfCtx = context->priv().makeDeferredRenderTargetContext(
+                                        fit, desc.fWidth, desc.fHeight, colorType, nullptr,
+                                        desc.fSampleCnt, GrMipMapped::kNo, origin, nullptr);
+                            } else {
+                                surfCtx = context->priv().makeDeferredTextureContext(
+                                        fit, desc.fWidth, desc.fHeight, colorType,
+                                        kUnknown_SkAlphaType, nullptr, GrMipMapped::kNo, origin);
+                            }
                             if (!surfCtx) {
                                 continue;
                             }
diff --git a/tests/SRGBReadWritePixelsTest.cpp b/tests/SRGBReadWritePixelsTest.cpp
index 765805e..d78b79d 100644
--- a/tests/SRGBReadWritePixelsTest.cpp
+++ b/tests/SRGBReadWritePixelsTest.cpp
@@ -10,6 +10,7 @@
 #include "include/gpu/GrContext.h"
 #include "src/gpu/GrCaps.h"
 #include "src/gpu/GrContextPriv.h"
+#include "src/gpu/GrRenderTargetContext.h"
 #include "src/gpu/GrSurfaceContext.h"
 #include "src/gpu/SkGr.h"
 #include "tests/Test.h"
@@ -187,23 +188,14 @@
 
 static sk_sp<GrSurfaceContext> make_surface_context(Encoding contextEncoding, GrContext* context,
                                                     skiatest::Reporter* reporter) {
-    GrSurfaceDesc desc;
-    desc.fFlags = kRenderTarget_GrSurfaceFlag;
-    desc.fWidth = kW;
-    desc.fHeight = kH;
-    desc.fConfig = kRGBA_8888_GrPixelConfig;
-
-    GrColorType colorType = GrPixelConfigToColorType(desc.fConfig);
-    const GrBackendFormat format = context->priv().caps()->getBackendFormatFromColorType(colorType);
-
-    auto surfaceContext = context->priv().makeDeferredSurfaceContext(
-            format, desc, kBottomLeft_GrSurfaceOrigin, GrMipMapped::kNo, SkBackingFit::kExact,
-            SkBudgeted::kNo, colorType, kPremul_SkAlphaType,
-            encoding_as_color_space(contextEncoding));
+    auto surfaceContext = context->priv().makeDeferredRenderTargetContext(
+            SkBackingFit::kExact, kW, kH, GrColorType::kRGBA_8888,
+            encoding_as_color_space(contextEncoding), 1, GrMipMapped::kNo,
+            kBottomLeft_GrSurfaceOrigin, nullptr, SkBudgeted::kNo, GrProtected::kNo);
     if (!surfaceContext) {
         ERRORF(reporter, "Could not create %s surface context.", encoding_as_str(contextEncoding));
     }
-    return surfaceContext;
+    return std::move(surfaceContext);
 }
 
 static void test_write_read(Encoding contextEncoding, Encoding writeEncoding, Encoding readEncoding,