diff --git a/src/core/SkDeferredDisplayListRecorder.cpp b/src/core/SkDeferredDisplayListRecorder.cpp
index bf8e1f8..d523f5c 100644
--- a/src/core/SkDeferredDisplayListRecorder.cpp
+++ b/src/core/SkDeferredDisplayListRecorder.cpp
@@ -163,7 +163,6 @@
             fCharacterization.dimensions(),
             readSwizzle,
             fCharacterization.sampleCount(),
-            fCharacterization.origin(),
             surfaceFlags,
             optionalTextureInfo,
             GrMipMapsStatus::kNotAllocated,
diff --git a/src/gpu/GrAHardwareBufferImageGenerator.cpp b/src/gpu/GrAHardwareBufferImageGenerator.cpp
index 28d67a2..936c6a9 100644
--- a/src/gpu/GrAHardwareBufferImageGenerator.cpp
+++ b/src/gpu/GrAHardwareBufferImageGenerator.cpp
@@ -179,10 +179,9 @@
 
                 return tex;
             },
-            backendFormat, {width, height}, readSwizzle, GrRenderable::kNo, 1, fSurfaceOrigin,
-            GrMipMapped::kNo, GrMipMapsStatus::kNotAllocated, GrInternalSurfaceFlags::kReadOnly,
-            SkBackingFit::kExact, SkBudgeted::kNo, GrProtected::kNo,
-            GrSurfaceProxy::UseAllocator::kYes);
+            backendFormat, {width, height}, readSwizzle, GrRenderable::kNo, 1, GrMipMapped::kNo,
+            GrMipMapsStatus::kNotAllocated, GrInternalSurfaceFlags::kReadOnly, SkBackingFit::kExact,
+            SkBudgeted::kNo, GrProtected::kNo, GrSurfaceProxy::UseAllocator::kYes);
 
     return GrSurfaceProxyView(std::move(texProxy), fSurfaceOrigin, readSwizzle);
 }
diff --git a/src/gpu/GrBackendTextureImageGenerator.cpp b/src/gpu/GrBackendTextureImageGenerator.cpp
index d9cbf6e..533bca8 100644
--- a/src/gpu/GrBackendTextureImageGenerator.cpp
+++ b/src/gpu/GrBackendTextureImageGenerator.cpp
@@ -155,49 +155,54 @@
     // Must make copies of member variables to capture in the lambda since this image generator may
     // be deleted before we actually execute the lambda.
     sk_sp<GrTextureProxy> proxy = proxyProvider->createLazyProxy(
-            [refHelper = fRefHelper, releaseProcHelper, backendTexture = fBackendTexture,
-             grColorType](
-                    GrResourceProvider* resourceProvider) -> GrSurfaceProxy::LazyCallbackResult {
-                if (refHelper->fSemaphore) {
-                    resourceProvider->priv().gpu()->waitSemaphore(refHelper->fSemaphore.get());
-                }
+            [
+              refHelper = fRefHelper, releaseProcHelper, backendTexture = fBackendTexture,
+              grColorType
+            ](GrResourceProvider * resourceProvider)
+                    ->GrSurfaceProxy::LazyCallbackResult {
+                        if (refHelper->fSemaphore) {
+                            resourceProvider->priv().gpu()->waitSemaphore(
+                                    refHelper->fSemaphore.get());
+                        }
 
-                // If a client re-draws the same image multiple times, the texture we return
-                // will be cached and re-used. If they draw a subset, though, we may be
-                // re-called. In that case, we want to re-use the borrowed texture we've
-                // previously created.
-                sk_sp<GrTexture> tex;
-                SkASSERT(refHelper->fBorrowedTextureKey.isValid());
-                auto surf = resourceProvider->findByUniqueKey<GrSurface>(
-                        refHelper->fBorrowedTextureKey);
-                if (surf) {
-                    SkASSERT(surf->asTexture());
-                    tex = sk_ref_sp(surf->asTexture());
-                } else {
-                    // We just gained access to the texture. If we're on the original context, we
-                    // could use the original texture, but we'd have no way of detecting that it's
-                    // no longer in-use. So we always make a wrapped copy, where the release proc
-                    // informs us that the context is done with it. This is unfortunate - we'll have
-                    // two texture objects referencing the same GPU object. However, no client can
-                    // ever see the original texture, so this should be safe.
-                    // We make the texture uncacheable so that the release proc is called ASAP.
-                    tex = resourceProvider->wrapBackendTexture(
-                            backendTexture, grColorType, kBorrow_GrWrapOwnership,
-                            GrWrapCacheable::kNo, kRead_GrIOType);
-                    if (!tex) {
-                        return {};
-                    }
-                    tex->setRelease(releaseProcHelper);
-                    tex->resourcePriv().setUniqueKey(refHelper->fBorrowedTextureKey);
-                }
-                // We use keys to avoid re-wrapping the GrBackendTexture in a GrTexture. This is
-                // unrelated to the whatever SkImage key may be assigned to the proxy.
-                return {std::move(tex), true, GrSurfaceProxy::LazyInstantiationKeyMode::kUnsynced};
-            },
+                        // If a client re-draws the same image multiple times, the texture we return
+                        // will be cached and re-used. If they draw a subset, though, we may be
+                        // re-called. In that case, we want to re-use the borrowed texture we've
+                        // previously created.
+                        sk_sp<GrTexture> tex;
+                        SkASSERT(refHelper->fBorrowedTextureKey.isValid());
+                        auto surf = resourceProvider->findByUniqueKey<GrSurface>(
+                                refHelper->fBorrowedTextureKey);
+                        if (surf) {
+                            SkASSERT(surf->asTexture());
+                            tex = sk_ref_sp(surf->asTexture());
+                        } else {
+                            // We just gained access to the texture. If we're on the original
+                            // context, we could use the original texture, but we'd have no way of
+                            // detecting that it's no longer in-use. So we always make a wrapped
+                            // copy, where the release proc informs us that the context is done with
+                            // it. This is unfortunate - we'll have two texture objects referencing
+                            // the same GPU object. However, no client can ever see the original
+                            // texture, so this should be safe. We make the texture uncacheable so
+                            // that the release proc is called ASAP.
+                            tex = resourceProvider->wrapBackendTexture(
+                                    backendTexture, grColorType, kBorrow_GrWrapOwnership,
+                                    GrWrapCacheable::kNo, kRead_GrIOType);
+                            if (!tex) {
+                                return {};
+                            }
+                            tex->setRelease(releaseProcHelper);
+                            tex->resourcePriv().setUniqueKey(refHelper->fBorrowedTextureKey);
+                        }
+                        // We use keys to avoid re-wrapping the GrBackendTexture in a GrTexture.
+                        // This is unrelated to the whatever SkImage key may be assigned to the
+                        // proxy.
+                        return {std::move(tex), true,
+                                GrSurfaceProxy::LazyInstantiationKeyMode::kUnsynced};
+                    },
             backendFormat, fBackendTexture.dimensions(), readSwizzle, GrRenderable::kNo, 1,
-            fSurfaceOrigin, mipMapped, mipMapsStatus, GrInternalSurfaceFlags::kReadOnly,
-            SkBackingFit::kExact, SkBudgeted::kNo, GrProtected::kNo,
-            GrSurfaceProxy::UseAllocator::kYes);
+            mipMapped, mipMapsStatus, GrInternalSurfaceFlags::kReadOnly, SkBackingFit::kExact,
+            SkBudgeted::kNo, GrProtected::kNo, GrSurfaceProxy::UseAllocator::kYes);
     if (!proxy) {
         return {};
     }
diff --git a/src/gpu/GrBitmapTextureMaker.cpp b/src/gpu/GrBitmapTextureMaker.cpp
index 67a3281..e3a9eb5 100644
--- a/src/gpu/GrBitmapTextureMaker.cpp
+++ b/src/gpu/GrBitmapTextureMaker.cpp
@@ -51,8 +51,7 @@
 
     if (fOriginalKey.isValid()) {
         auto colorType = SkColorTypeToGrColorType(fBitmap.colorType());
-        proxy = proxyProvider->findOrCreateProxyByUniqueKey(fOriginalKey, colorType,
-                                                            kTopLeft_GrSurfaceOrigin);
+        proxy = proxyProvider->findOrCreateProxyByUniqueKey(fOriginalKey, colorType);
         if (proxy) {
             swizzle = this->context()->priv().caps()->getReadSwizzle(proxy->backendFormat(),
                                                                      this->colorType());
diff --git a/src/gpu/GrBlurUtils.cpp b/src/gpu/GrBlurUtils.cpp
index 6f4055c..1ce1e82 100644
--- a/src/gpu/GrBlurUtils.cpp
+++ b/src/gpu/GrBlurUtils.cpp
@@ -83,8 +83,7 @@
     if (key.isValid()) {
         // TODO: this cache look up is duplicated in draw_shape_with_mask_filter for gpu
         static const GrSurfaceOrigin kCacheOrigin = kTopLeft_GrSurfaceOrigin;
-        auto filteredMask = proxyProvider->findOrCreateProxyByUniqueKey(key, GrColorType::kAlpha_8,
-                                                                        kCacheOrigin);
+        auto filteredMask = proxyProvider->findOrCreateProxyByUniqueKey(key, GrColorType::kAlpha_8);
         if (filteredMask) {
             GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(
                     filteredMask->backendFormat(), GrColorType::kAlpha_8);
@@ -402,8 +401,8 @@
         if (maskKey.isValid()) {
             // TODO: this cache look up is duplicated in sw_draw_with_mask_filter for raster
             static const GrSurfaceOrigin kCacheOrigin = kTopLeft_GrSurfaceOrigin;
-            auto filteredMask = proxyProvider->findOrCreateProxyByUniqueKey(
-                    maskKey, GrColorType::kAlpha_8, kCacheOrigin);
+            auto filteredMask =
+                    proxyProvider->findOrCreateProxyByUniqueKey(maskKey, GrColorType::kAlpha_8);
             if (filteredMask) {
                 GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(
                         filteredMask->backendFormat(), GrColorType::kAlpha_8);
diff --git a/src/gpu/GrClipStackClip.cpp b/src/gpu/GrClipStackClip.cpp
index 283d3a8..2c5a941 100644
--- a/src/gpu/GrClipStackClip.cpp
+++ b/src/gpu/GrClipStackClip.cpp
@@ -349,8 +349,8 @@
     create_clip_mask_key(reducedClip.maskGenID(), reducedClip.scissor(),
                          reducedClip.numAnalyticFPs(), &key);
 
-    if (sk_sp<GrTextureProxy> proxy = proxyProvider->findOrCreateProxyByUniqueKey(
-                key, GrColorType::kAlpha_8, kTopLeft_GrSurfaceOrigin)) {
+    if (sk_sp<GrTextureProxy> proxy =
+                proxyProvider->findOrCreateProxyByUniqueKey(key, GrColorType::kAlpha_8)) {
         GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(proxy->backendFormat(),
                                                                    GrColorType::kAlpha_8);
         return {std::move(proxy), kTopLeft_GrSurfaceOrigin, swizzle};
@@ -464,8 +464,8 @@
     GrProxyProvider* proxyProvider = context->priv().proxyProvider();
     const GrCaps* caps = context->priv().caps();
 
-    if (sk_sp<GrTextureProxy> proxy = proxyProvider->findOrCreateProxyByUniqueKey(
-                key, GrColorType::kAlpha_8, kTopLeft_GrSurfaceOrigin)) {
+    if (sk_sp<GrTextureProxy> proxy =
+                proxyProvider->findOrCreateProxyByUniqueKey(key, GrColorType::kAlpha_8)) {
         GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(proxy->backendFormat(),
                                                                    GrColorType::kAlpha_8);
         return {std::move(proxy), kTopLeft_GrSurfaceOrigin, swizzle};
@@ -495,7 +495,6 @@
                                                 swizzle,
                                                 GrRenderable::kNo,
                                                 1,
-                                                kTopLeft_GrSurfaceOrigin,
                                                 GrMipMapped::kNo,
                                                 SkBackingFit::kApprox,
                                                 SkBudgeted::kYes,
diff --git a/src/gpu/GrDrawOpAtlas.cpp b/src/gpu/GrDrawOpAtlas.cpp
index 2ca5e6b..ee6b5da 100644
--- a/src/gpu/GrDrawOpAtlas.cpp
+++ b/src/gpu/GrDrawOpAtlas.cpp
@@ -562,8 +562,8 @@
     for (uint32_t i = 0; i < this->maxPages(); ++i) {
         GrSwizzle swizzle = proxyProvider->caps()->getReadSwizzle(fFormat, fColorType);
         sk_sp<GrSurfaceProxy> proxy = proxyProvider->createProxy(
-                fFormat, dims, swizzle, GrRenderable::kNo, 1, kTopLeft_GrSurfaceOrigin,
-                GrMipMapped::kNo, SkBackingFit::kExact, SkBudgeted::kYes, GrProtected::kNo,
+                fFormat, dims, swizzle, GrRenderable::kNo, 1, GrMipMapped::kNo,
+                SkBackingFit::kExact, SkBudgeted::kYes, GrProtected::kNo,
                 GrInternalSurfaceFlags::kNone, GrSurfaceProxy::UseAllocator::kNo);
         if (!proxy) {
             return false;
diff --git a/src/gpu/GrDynamicAtlas.cpp b/src/gpu/GrDynamicAtlas.cpp
index 6128db5..dce5337 100644
--- a/src/gpu/GrDynamicAtlas.cpp
+++ b/src/gpu/GrDynamicAtlas.cpp
@@ -64,7 +64,7 @@
 
     sk_sp<GrTextureProxy> proxy = GrProxyProvider::MakeFullyLazyProxy(
             std::move(instantiate), format, readSwizzle, GrRenderable::kYes, sampleCount,
-            GrProtected::kNo, kTextureOrigin, caps, useAllocator);
+            GrProtected::kNo, caps, useAllocator);
 
     return proxy;
 }
diff --git a/src/gpu/GrOnFlushResourceProvider.cpp b/src/gpu/GrOnFlushResourceProvider.cpp
index 0d0ffa5..3386f15 100644
--- a/src/gpu/GrOnFlushResourceProvider.cpp
+++ b/src/gpu/GrOnFlushResourceProvider.cpp
@@ -81,10 +81,9 @@
 sk_sp<GrTextureProxy> GrOnFlushResourceProvider::findOrCreateProxyByUniqueKey(
         const GrUniqueKey& key,
         GrColorType colorType,
-        GrSurfaceOrigin origin,
         UseAllocator useAllocator) {
     auto proxyProvider = fDrawingMgr->getContext()->priv().proxyProvider();
-    return proxyProvider->findOrCreateProxyByUniqueKey(key, colorType, origin, useAllocator);
+    return proxyProvider->findOrCreateProxyByUniqueKey(key, colorType, useAllocator);
 }
 
 bool GrOnFlushResourceProvider::instatiateProxy(GrSurfaceProxy* proxy) {
diff --git a/src/gpu/GrOnFlushResourceProvider.h b/src/gpu/GrOnFlushResourceProvider.h
index 1f18d49..692714a 100644
--- a/src/gpu/GrOnFlushResourceProvider.h
+++ b/src/gpu/GrOnFlushResourceProvider.h
@@ -79,7 +79,6 @@
     // GrColorType is necessary to set the proxy's texture swizzle.
     sk_sp<GrTextureProxy> findOrCreateProxyByUniqueKey(const GrUniqueKey&,
                                                        GrColorType,
-                                                       GrSurfaceOrigin,
                                                        UseAllocator);
 
     bool instatiateProxy(GrSurfaceProxy*);
diff --git a/src/gpu/GrProxyProvider.cpp b/src/gpu/GrProxyProvider.cpp
index a2c896c..bbf3493 100644
--- a/src/gpu/GrProxyProvider.cpp
+++ b/src/gpu/GrProxyProvider.cpp
@@ -95,8 +95,7 @@
     this->processInvalidUniqueKey(proxy->getUniqueKey(), proxy, InvalidateGPUResource::kYes);
 }
 
-sk_sp<GrTextureProxy> GrProxyProvider::findProxyByUniqueKey(const GrUniqueKey& key,
-                                                            GrSurfaceOrigin origin) {
+sk_sp<GrTextureProxy> GrProxyProvider::findProxyByUniqueKey(const GrUniqueKey& key) {
     ASSERT_SINGLE_OWNER
 
     if (this->isAbandoned()) {
@@ -119,7 +118,6 @@
         const GrBackendFormat& format,
         GrRenderable renderable,
         int renderTargetSampleCnt,
-        GrSurfaceOrigin origin,
         SkBackingFit fit,
         SkBudgeted budgeted,
         GrProtected isProtected) {
@@ -152,7 +150,7 @@
         return nullptr;
     }
 
-    return this->createWrapped(std::move(tex), colorType, origin, UseAllocator::kYes);
+    return this->createWrapped(std::move(tex), colorType, UseAllocator::kYes);
 }
 
 sk_sp<GrTextureProxy> GrProxyProvider::testingOnly_createInstantiatedProxy(
@@ -160,7 +158,6 @@
         GrColorType colorType,
         GrRenderable renderable,
         int renderTargetSampleCnt,
-        GrSurfaceOrigin origin,
         SkBackingFit fit,
         SkBudgeted budgeted,
         GrProtected isProtected) {
@@ -174,42 +171,37 @@
                                                      format,
                                                      renderable,
                                                      renderTargetSampleCnt,
-                                                     origin,
                                                      fit,
                                                      budgeted,
                                                      isProtected);
 }
 
 sk_sp<GrTextureProxy> GrProxyProvider::testingOnly_createWrapped(sk_sp<GrTexture> tex,
-                                                                 GrColorType colorType,
-                                                                 GrSurfaceOrigin origin) {
-    return this->createWrapped(std::move(tex), colorType, origin, UseAllocator::kYes);
+                                                                 GrColorType colorType) {
+    return this->createWrapped(std::move(tex), colorType, UseAllocator::kYes);
 }
 #endif
 
 sk_sp<GrTextureProxy> GrProxyProvider::createWrapped(sk_sp<GrTexture> tex,
                                                      GrColorType colorType,
-                                                     GrSurfaceOrigin origin,
                                                      UseAllocator useAllocator) {
 #ifdef SK_DEBUG
     if (tex->getUniqueKey().isValid()) {
-        SkASSERT(!this->findProxyByUniqueKey(tex->getUniqueKey(), origin));
+        SkASSERT(!this->findProxyByUniqueKey(tex->getUniqueKey()));
     }
 #endif
     GrSwizzle readSwizzle = this->caps()->getReadSwizzle(tex->backendFormat(), colorType);
 
     if (tex->asRenderTarget()) {
-        return sk_sp<GrTextureProxy>(new GrTextureRenderTargetProxy(
-                std::move(tex), origin, readSwizzle, useAllocator));
-    } else {
         return sk_sp<GrTextureProxy>(
-                new GrTextureProxy(std::move(tex), origin, readSwizzle, useAllocator));
+                new GrTextureRenderTargetProxy(std::move(tex), readSwizzle, useAllocator));
+    } else {
+        return sk_sp<GrTextureProxy>(new GrTextureProxy(std::move(tex), readSwizzle, useAllocator));
     }
 }
 
 sk_sp<GrTextureProxy> GrProxyProvider::findOrCreateProxyByUniqueKey(const GrUniqueKey& key,
                                                                     GrColorType colorType,
-                                                                    GrSurfaceOrigin origin,
                                                                     UseAllocator useAllocator) {
     ASSERT_SINGLE_OWNER
 
@@ -217,7 +209,7 @@
         return nullptr;
     }
 
-    sk_sp<GrTextureProxy> result = this->findProxyByUniqueKey(key, origin);
+    sk_sp<GrTextureProxy> result = this->findProxyByUniqueKey(key);
     if (result) {
         return result;
     }
@@ -237,7 +229,7 @@
     sk_sp<GrTexture> texture(static_cast<GrSurface*>(resource)->asTexture());
     SkASSERT(texture);
 
-    result = this->createWrapped(std::move(texture), colorType, origin, useAllocator);
+    result = this->createWrapped(std::move(texture), colorType, useAllocator);
     SkASSERT(result->getUniqueKey() == key);
     // createWrapped should've added this for us
     SkASSERT(fUniquelyKeyedProxies.find(key));
@@ -322,7 +314,7 @@
                         dims, format, colorType, GrRenderable::kNo, 1, SkBudgeted::kYes, fit,
                         GrProtected::kNo, mipLevel));
             },
-            format, dims, swizzle, GrRenderable::kNo, 1, kTopLeft_GrSurfaceOrigin, GrMipMapped::kNo,
+            format, dims, swizzle, GrRenderable::kNo, 1, GrMipMapped::kNo,
             GrMipMapsStatus::kNotAllocated, GrInternalSurfaceFlags::kNone, fit, SkBudgeted::kYes,
             GrProtected::kNo, UseAllocator::kYes);
 
@@ -368,9 +360,9 @@
                         dims, format, colorType, GrRenderable::kNo, 1, SkBudgeted::kYes,
                         GrProtected::kNo, texels.get(), mipLevelCount));
             },
-            format, dims, readSwizzle, GrRenderable::kNo, 1, kTopLeft_GrSurfaceOrigin,
-            GrMipMapped::kYes, GrMipMapsStatus::kValid, GrInternalSurfaceFlags::kNone,
-            SkBackingFit::kExact, SkBudgeted::kYes, GrProtected::kNo, UseAllocator::kYes);
+            format, dims, readSwizzle, GrRenderable::kNo, 1, GrMipMapped::kYes,
+            GrMipMapsStatus::kValid, GrInternalSurfaceFlags::kNone, SkBackingFit::kExact,
+            SkBudgeted::kYes, GrProtected::kNo, UseAllocator::kYes);
 
     if (!proxy) {
         return nullptr;
@@ -386,7 +378,6 @@
                                                    GrSwizzle readSwizzle,
                                                    GrRenderable renderable,
                                                    int renderTargetSampleCnt,
-                                                   GrSurfaceOrigin origin,
                                                    GrMipMapped mipMapped,
                                                    SkBackingFit fit,
                                                    SkBudgeted budgeted,
@@ -427,13 +418,13 @@
         // We know anything we instantiate later from this deferred path will be
         // both texturable and renderable
         return sk_sp<GrTextureProxy>(new GrTextureRenderTargetProxy(
-                *caps, format, dimensions, renderTargetSampleCnt, origin, mipMapped, mipMapsStatus,
+                *caps, format, dimensions, renderTargetSampleCnt, mipMapped, mipMapsStatus,
                 readSwizzle, fit, budgeted, isProtected, surfaceFlags, useAllocator));
     }
 
-    return sk_sp<GrTextureProxy>(new GrTextureProxy(format, dimensions, origin, mipMapped,
-                                                    mipMapsStatus, readSwizzle, fit, budgeted,
-                                                    isProtected, surfaceFlags, useAllocator));
+    return sk_sp<GrTextureProxy>(new GrTextureProxy(format, dimensions, mipMapped, mipMapsStatus,
+                                                    readSwizzle, fit, budgeted, isProtected,
+                                                    surfaceFlags, useAllocator));
 }
 
 sk_sp<GrTextureProxy> GrProxyProvider::createCompressedTextureProxy(
@@ -460,9 +451,9 @@
                 return LazyCallbackResult(resourceProvider->createCompressedTexture(
                     dimensions, format, budgeted, mipMapped, isProtected, data.get()));
             },
-            format, dimensions, GrSwizzle(), GrRenderable::kNo, 1, kTopLeft_GrSurfaceOrigin,
-            mipMapped, mipMapsStatus, GrInternalSurfaceFlags::kReadOnly, SkBackingFit::kExact,
-            SkBudgeted::kYes, GrProtected::kNo, UseAllocator::kYes);
+            format, dimensions, GrSwizzle(), GrRenderable::kNo, 1, mipMapped, mipMapsStatus,
+            GrInternalSurfaceFlags::kReadOnly, SkBackingFit::kExact, SkBudgeted::kYes,
+            GrProtected::kNo, UseAllocator::kYes);
 
     if (!proxy) {
         return nullptr;
@@ -482,7 +473,6 @@
 
 sk_sp<GrTextureProxy> GrProxyProvider::wrapBackendTexture(const GrBackendTexture& backendTex,
                                                           GrColorType grColorType,
-                                                          GrSurfaceOrigin origin,
                                                           GrWrapOwnership ownership,
                                                           GrWrapCacheable cacheable,
                                                           GrIOType ioType,
@@ -521,11 +511,10 @@
     GrSwizzle readSwizzle = caps->getReadSwizzle(tex->backendFormat(), grColorType);
 
     return sk_sp<GrTextureProxy>(
-            new GrTextureProxy(std::move(tex), origin, readSwizzle, UseAllocator::kNo));
+            new GrTextureProxy(std::move(tex), readSwizzle, UseAllocator::kNo));
 }
 
 sk_sp<GrTextureProxy> GrProxyProvider::wrapCompressedBackendTexture(const GrBackendTexture& beTex,
-                                                                    GrSurfaceOrigin origin,
                                                                     GrWrapOwnership ownership,
                                                                     GrWrapCacheable cacheable,
                                                                     ReleaseProc releaseProc,
@@ -563,14 +552,13 @@
     GrSwizzle texSwizzle = SkCompressionTypeIsOpaque(compressionType) ? GrSwizzle::RGB1()
                                                                       : GrSwizzle::RGBA();
 
-    return sk_sp<GrTextureProxy>(
-        new GrTextureProxy(std::move(tex), origin, texSwizzle, UseAllocator::kNo));
+    return sk_sp<GrTextureProxy>(new GrTextureProxy(std::move(tex), texSwizzle, UseAllocator::kNo));
 }
 
 sk_sp<GrTextureProxy> GrProxyProvider::wrapRenderableBackendTexture(
-        const GrBackendTexture& backendTex, GrSurfaceOrigin origin, int sampleCnt,
-        GrColorType colorType, GrWrapOwnership ownership, GrWrapCacheable cacheable,
-        ReleaseProc releaseProc, ReleaseContext releaseCtx) {
+        const GrBackendTexture& backendTex, int sampleCnt, GrColorType colorType,
+        GrWrapOwnership ownership, GrWrapCacheable cacheable, ReleaseProc releaseProc,
+        ReleaseContext releaseCtx) {
     if (this->isAbandoned()) {
         return nullptr;
     }
@@ -610,13 +598,13 @@
 
     GrSwizzle readSwizzle = caps->getReadSwizzle(tex->backendFormat(), colorType);
 
-    return sk_sp<GrTextureProxy>(new GrTextureRenderTargetProxy(std::move(tex), origin, readSwizzle,
-                                                                UseAllocator::kNo));
+    return sk_sp<GrTextureProxy>(
+            new GrTextureRenderTargetProxy(std::move(tex), readSwizzle, UseAllocator::kNo));
 }
 
 sk_sp<GrSurfaceProxy> GrProxyProvider::wrapBackendRenderTarget(
-        const GrBackendRenderTarget& backendRT, GrColorType grColorType,
-        GrSurfaceOrigin origin, ReleaseProc releaseProc, ReleaseContext releaseCtx) {
+        const GrBackendRenderTarget& backendRT, GrColorType grColorType, ReleaseProc releaseProc,
+        ReleaseContext releaseCtx) {
     if (this->isAbandoned()) {
         return nullptr;
     }
@@ -647,13 +635,12 @@
 
     GrSwizzle readSwizzle = caps->getReadSwizzle(rt->backendFormat(), grColorType);
 
-    return sk_sp<GrRenderTargetProxy>(new GrRenderTargetProxy(std::move(rt), origin, readSwizzle,
-                                                              UseAllocator::kNo));
+    return sk_sp<GrRenderTargetProxy>(
+            new GrRenderTargetProxy(std::move(rt), readSwizzle, UseAllocator::kNo));
 }
 
 sk_sp<GrSurfaceProxy> GrProxyProvider::wrapBackendTextureAsRenderTarget(
-        const GrBackendTexture& backendTex, GrColorType grColorType,
-        GrSurfaceOrigin origin, int sampleCnt) {
+        const GrBackendTexture& backendTex, GrColorType grColorType, int sampleCnt) {
     if (this->isAbandoned()) {
         return nullptr;
     }
@@ -680,8 +667,8 @@
 
     GrSwizzle readSwizzle = caps->getReadSwizzle(rt->backendFormat(), grColorType);
 
-    return sk_sp<GrSurfaceProxy>(new GrRenderTargetProxy(std::move(rt), origin, readSwizzle,
-                                                         UseAllocator::kNo));
+    return sk_sp<GrSurfaceProxy>(
+            new GrRenderTargetProxy(std::move(rt), readSwizzle, UseAllocator::kNo));
 }
 
 sk_sp<GrRenderTargetProxy> GrProxyProvider::wrapVulkanSecondaryCBAsRenderTarget(
@@ -717,10 +704,9 @@
         return nullptr;
     }
 
-    // All Vulkan surfaces uses top left origins.
-    return sk_sp<GrRenderTargetProxy>(new GrRenderTargetProxy(
-            std::move(rt), kTopLeft_GrSurfaceOrigin, readSwizzle, UseAllocator::kNo,
-            GrRenderTargetProxy::WrapsVkSecondaryCB::kYes));
+    return sk_sp<GrRenderTargetProxy>(
+            new GrRenderTargetProxy(std::move(rt), readSwizzle, UseAllocator::kNo,
+                                    GrRenderTargetProxy::WrapsVkSecondaryCB::kYes));
 }
 
 sk_sp<GrTextureProxy> GrProxyProvider::createLazyProxy(LazyInstantiateCallback&& callback,
@@ -729,7 +715,6 @@
                                                        GrSwizzle readSwizzle,
                                                        GrRenderable renderable,
                                                        int renderTargetSampleCnt,
-                                                       GrSurfaceOrigin origin,
                                                        GrMipMapped mipMapped,
                                                        GrMipMapsStatus mipMapsStatus,
                                                        GrInternalSurfaceFlags surfaceFlags,
@@ -759,7 +744,6 @@
                                                                     format,
                                                                     dimensions,
                                                                     renderTargetSampleCnt,
-                                                                    origin,
                                                                     mipMapped,
                                                                     mipMapsStatus,
                                                                     readSwizzle,
@@ -772,7 +756,6 @@
         return sk_sp<GrTextureProxy>(new GrTextureProxy(std::move(callback),
                                                         format,
                                                         dimensions,
-                                                        origin,
                                                         mipMapped,
                                                         mipMapsStatus,
                                                         readSwizzle,
@@ -790,7 +773,6 @@
         SkISize dimensions,
         GrSwizzle readSwizzle,
         int sampleCnt,
-        GrSurfaceOrigin origin,
         GrInternalSurfaceFlags surfaceFlags,
         const TextureInfo* textureInfo,
         GrMipMapsStatus mipMapsStatus,
@@ -816,7 +798,7 @@
         // actual VkImage to texture from.
         SkASSERT(!wrapsVkSecondaryCB);
         return sk_sp<GrRenderTargetProxy>(new GrTextureRenderTargetProxy(
-                *this->caps(), std::move(callback), format, dimensions, sampleCnt, origin,
+                *this->caps(), std::move(callback), format, dimensions, sampleCnt,
                 textureInfo->fMipMapped, mipMapsStatus, readSwizzle, fit, budgeted, isProtected,
                 surfaceFlags, useAllocator));
     }
@@ -825,9 +807,9 @@
             wrapsVkSecondaryCB ? GrRenderTargetProxy::WrapsVkSecondaryCB::kYes
                                : GrRenderTargetProxy::WrapsVkSecondaryCB::kNo;
 
-    return sk_sp<GrRenderTargetProxy>(new GrRenderTargetProxy(
-            std::move(callback), format, dimensions, sampleCnt, origin, readSwizzle, fit, budgeted,
-            isProtected, surfaceFlags, useAllocator, vkSCB));
+    return sk_sp<GrRenderTargetProxy>(
+            new GrRenderTargetProxy(std::move(callback), format, dimensions, sampleCnt, readSwizzle,
+                                    fit, budgeted, isProtected, surfaceFlags, useAllocator, vkSCB));
 }
 
 sk_sp<GrTextureProxy> GrProxyProvider::MakeFullyLazyProxy(LazyInstantiateCallback&& callback,
@@ -836,7 +818,6 @@
                                                           GrRenderable renderable,
                                                           int renderTargetSampleCnt,
                                                           GrProtected isProtected,
-                                                          GrSurfaceOrigin origin,
                                                           const GrCaps& caps,
                                                           UseAllocator useAllocator) {
     if (!format.isValid()) {
@@ -849,12 +830,12 @@
     static constexpr SkISize kLazyDims = {-1, -1};
     if (GrRenderable::kYes == renderable) {
         return sk_sp<GrTextureProxy>(new GrTextureRenderTargetProxy(
-                caps, std::move(callback), format, kLazyDims, renderTargetSampleCnt, origin,
+                caps, std::move(callback), format, kLazyDims, renderTargetSampleCnt,
                 GrMipMapped::kNo, GrMipMapsStatus::kNotAllocated, readSwizzle,
                 SkBackingFit::kApprox, SkBudgeted::kYes, isProtected, surfaceFlags, useAllocator));
     } else {
         return sk_sp<GrTextureProxy>(new GrTextureProxy(
-                std::move(callback), format, kLazyDims, origin, GrMipMapped::kNo,
+                std::move(callback), format, kLazyDims, GrMipMapped::kNo,
                 GrMipMapsStatus::kNotAllocated, readSwizzle, SkBackingFit::kApprox,
                 SkBudgeted::kYes, isProtected, surfaceFlags, useAllocator));
     }
diff --git a/src/gpu/GrProxyProvider.h b/src/gpu/GrProxyProvider.h
index e89a373..24d9363 100644
--- a/src/gpu/GrProxyProvider.h
+++ b/src/gpu/GrProxyProvider.h
@@ -50,7 +50,7 @@
     /*
      * Finds a proxy by unique key.
      */
-    sk_sp<GrTextureProxy> findProxyByUniqueKey(const GrUniqueKey&, GrSurfaceOrigin);
+    sk_sp<GrTextureProxy> findProxyByUniqueKey(const GrUniqueKey&);
 
     /*
      * Finds a proxy by unique key or creates a new one that wraps a resource matching the unique
@@ -60,7 +60,6 @@
      */
     sk_sp<GrTextureProxy> findOrCreateProxyByUniqueKey(const GrUniqueKey&,
                                                        GrColorType colorType,
-                                                       GrSurfaceOrigin,
                                                        UseAllocator = UseAllocator::kYes);
 
     /*
@@ -78,7 +77,6 @@
                                       GrSwizzle readSwizzle,
                                       GrRenderable,
                                       int renderTargetSampleCnt,
-                                      GrSurfaceOrigin,
                                       GrMipMapped,
                                       SkBackingFit,
                                       SkBudgeted,
@@ -104,29 +102,26 @@
      * Create a texture proxy that wraps a (non-renderable) backend texture. GrIOType must be
      * kRead or kRW.
      */
-    sk_sp<GrTextureProxy> wrapBackendTexture(const GrBackendTexture&, GrColorType, GrSurfaceOrigin,
-                                             GrWrapOwnership, GrWrapCacheable, GrIOType,
-                                             ReleaseProc = nullptr, ReleaseContext = nullptr);
+    sk_sp<GrTextureProxy> wrapBackendTexture(const GrBackendTexture&, GrColorType, GrWrapOwnership,
+                                             GrWrapCacheable, GrIOType, ReleaseProc = nullptr,
+                                             ReleaseContext = nullptr);
 
-    sk_sp<GrTextureProxy> wrapCompressedBackendTexture(const GrBackendTexture&, GrSurfaceOrigin,
-                                                       GrWrapOwnership, GrWrapCacheable,
-                                                       ReleaseProc = nullptr,
+    sk_sp<GrTextureProxy> wrapCompressedBackendTexture(const GrBackendTexture&, GrWrapOwnership,
+                                                       GrWrapCacheable, ReleaseProc = nullptr,
                                                        ReleaseContext = nullptr);
 
     /*
      * Create a texture proxy that wraps a backend texture and is both texture-able and renderable
      */
-    sk_sp<GrTextureProxy> wrapRenderableBackendTexture(const GrBackendTexture&, GrSurfaceOrigin,
-                                                       int sampleCnt, GrColorType,
-                                                       GrWrapOwnership, GrWrapCacheable,
-                                                       ReleaseProc = nullptr,
+    sk_sp<GrTextureProxy> wrapRenderableBackendTexture(const GrBackendTexture&, int sampleCnt,
+                                                       GrColorType, GrWrapOwnership,
+                                                       GrWrapCacheable, ReleaseProc = nullptr,
                                                        ReleaseContext = nullptr);
 
     /*
      * Create a render target proxy that wraps a backend render target
      */
     sk_sp<GrSurfaceProxy> wrapBackendRenderTarget(const GrBackendRenderTarget&, GrColorType,
-                                                  GrSurfaceOrigin,
                                                   ReleaseProc = nullptr, ReleaseContext = nullptr);
 
     /*
@@ -134,7 +129,6 @@
      */
     sk_sp<GrSurfaceProxy> wrapBackendTextureAsRenderTarget(const GrBackendTexture&,
                                                            GrColorType,
-                                                           GrSurfaceOrigin,
                                                            int sampleCnt);
 
     sk_sp<GrRenderTargetProxy> wrapVulkanSecondaryCBAsRenderTarget(const SkImageInfo&,
@@ -165,7 +159,6 @@
                                           GrSwizzle readSwizzle,
                                           GrRenderable,
                                           int renderTargetSampleCnt,
-                                          GrSurfaceOrigin,
                                           GrMipMapped,
                                           GrMipMapsStatus,
                                           GrInternalSurfaceFlags,
@@ -180,7 +173,6 @@
                                                            SkISize dimensions,
                                                            GrSwizzle readSwizzle,
                                                            int renderTargetSampleCnt,
-                                                           GrSurfaceOrigin origin,
                                                            GrInternalSurfaceFlags,
                                                            const TextureInfo*,
                                                            GrMipMapsStatus,
@@ -200,7 +192,6 @@
                                                     GrRenderable,
                                                     int renderTargetSampleCnt,
                                                     GrProtected,
-                                                    GrSurfaceOrigin,
                                                     const GrCaps&,
                                                     UseAllocator);
 
@@ -251,7 +242,6 @@
                                                               const GrBackendFormat& format,
                                                               GrRenderable renderable,
                                                               int renderTargetSampleCnt,
-                                                              GrSurfaceOrigin origin,
                                                               SkBackingFit fit,
                                                               SkBudgeted budgeted,
                                                               GrProtected isProtected);
@@ -261,12 +251,11 @@
                                                               GrColorType colorType,
                                                               GrRenderable renderable,
                                                               int renderTargetSampleCnt,
-                                                              GrSurfaceOrigin origin,
                                                               SkBackingFit fit,
                                                               SkBudgeted budgeted,
                                                               GrProtected isProtected);
 
-    sk_sp<GrTextureProxy> testingOnly_createWrapped(sk_sp<GrTexture>, GrColorType, GrSurfaceOrigin);
+    sk_sp<GrTextureProxy> testingOnly_createWrapped(sk_sp<GrTexture>, GrColorType);
 #endif
 
 private:
@@ -290,7 +279,7 @@
                                                       GrColorType colorType);
 
     // GrColorType is used to determine the proxy's texture swizzle.
-    sk_sp<GrTextureProxy> createWrapped(sk_sp<GrTexture> tex, GrColorType, GrSurfaceOrigin origin,
+    sk_sp<GrTextureProxy> createWrapped(sk_sp<GrTexture> tex, GrColorType,
                                         UseAllocator useAllocator);
 
     struct UniquelyKeyedProxyHashTraits {
diff --git a/src/gpu/GrRenderTargetContext.cpp b/src/gpu/GrRenderTargetContext.cpp
index 720e770..b9ce882 100644
--- a/src/gpu/GrRenderTargetContext.cpp
+++ b/src/gpu/GrRenderTargetContext.cpp
@@ -184,8 +184,8 @@
     GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(format, colorType);
 
     sk_sp<GrTextureProxy> proxy = context->priv().proxyProvider()->createProxy(
-            format, dimensions, swizzle, GrRenderable::kYes, sampleCnt, origin, mipMapped, fit,
-            budgeted, isProtected);
+            format, dimensions, swizzle, GrRenderable::kYes, sampleCnt, mipMapped, fit, budgeted,
+            isProtected);
     if (!proxy) {
         return nullptr;
     }
@@ -276,8 +276,8 @@
         ReleaseContext releaseCtx) {
     SkASSERT(sampleCnt > 0);
     sk_sp<GrTextureProxy> proxy(context->priv().proxyProvider()->wrapRenderableBackendTexture(
-            tex, origin, sampleCnt, colorType, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
-            releaseProc, releaseCtx));
+            tex, sampleCnt, colorType, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, releaseProc,
+            releaseCtx));
     if (!proxy) {
         return nullptr;
     }
@@ -296,7 +296,7 @@
         const SkSurfaceProps* surfaceProps) {
     SkASSERT(sampleCnt > 0);
     sk_sp<GrSurfaceProxy> proxy(context->priv().proxyProvider()->wrapBackendTextureAsRenderTarget(
-            tex, colorType, origin, sampleCnt));
+            tex, colorType, sampleCnt));
     if (!proxy) {
         return nullptr;
     }
@@ -315,7 +315,7 @@
         ReleaseProc releaseProc,
         ReleaseContext releaseCtx) {
     sk_sp<GrSurfaceProxy> proxy(context->priv().proxyProvider()->wrapBackendRenderTarget(
-            rt, colorType, origin, releaseProc, releaseCtx));
+            rt, colorType, releaseProc, releaseCtx));
     if (!proxy) {
         return nullptr;
     }
diff --git a/src/gpu/GrRenderTargetProxy.cpp b/src/gpu/GrRenderTargetProxy.cpp
index e16dba4..b927ca2 100644
--- a/src/gpu/GrRenderTargetProxy.cpp
+++ b/src/gpu/GrRenderTargetProxy.cpp
@@ -25,14 +25,13 @@
                                          const GrBackendFormat& format,
                                          SkISize dimensions,
                                          int sampleCount,
-                                         GrSurfaceOrigin origin,
                                          const GrSwizzle& textureSwizzle,
                                          SkBackingFit fit,
                                          SkBudgeted budgeted,
                                          GrProtected isProtected,
                                          GrInternalSurfaceFlags surfaceFlags,
                                          UseAllocator useAllocator)
-        : INHERITED(format, dimensions, GrRenderable::kYes, origin, textureSwizzle, fit, budgeted,
+        : INHERITED(format, dimensions, GrRenderable::kYes, textureSwizzle, fit, budgeted,
                     isProtected, surfaceFlags, useAllocator)
         , fSampleCnt(sampleCount)
         , fWrapsVkSecondaryCB(WrapsVkSecondaryCB::kNo) {}
@@ -42,7 +41,6 @@
                                          const GrBackendFormat& format,
                                          SkISize dimensions,
                                          int sampleCount,
-                                         GrSurfaceOrigin origin,
                                          const GrSwizzle& textureSwizzle,
                                          SkBackingFit fit,
                                          SkBudgeted budgeted,
@@ -50,18 +48,17 @@
                                          GrInternalSurfaceFlags surfaceFlags,
                                          UseAllocator useAllocator,
                                          WrapsVkSecondaryCB wrapsVkSecondaryCB)
-        : INHERITED(std::move(callback), format, dimensions, GrRenderable::kYes, origin,
-                    textureSwizzle, fit, budgeted, isProtected, surfaceFlags, useAllocator)
+        : INHERITED(std::move(callback), format, dimensions, GrRenderable::kYes, textureSwizzle,
+                    fit, budgeted, isProtected, surfaceFlags, useAllocator)
         , fSampleCnt(sampleCount)
         , fWrapsVkSecondaryCB(wrapsVkSecondaryCB) {}
 
 // Wrapped version
 GrRenderTargetProxy::GrRenderTargetProxy(sk_sp<GrSurface> surf,
-                                         GrSurfaceOrigin origin,
                                          const GrSwizzle& textureSwizzle,
                                          UseAllocator useAllocator,
                                          WrapsVkSecondaryCB wrapsVkSecondaryCB)
-        : INHERITED(std::move(surf), origin, textureSwizzle, SkBackingFit::kExact, useAllocator)
+        : INHERITED(std::move(surf), textureSwizzle, SkBackingFit::kExact, useAllocator)
         , fSampleCnt(fTarget->asRenderTarget()->numSamples())
         , fWrapsVkSecondaryCB(wrapsVkSecondaryCB) {
     // The kRequiresManualMSAAResolve flag better not be set if we are not multisampled or if
diff --git a/src/gpu/GrRenderTargetProxy.h b/src/gpu/GrRenderTargetProxy.h
index 5def7b7..576d37c 100644
--- a/src/gpu/GrRenderTargetProxy.h
+++ b/src/gpu/GrRenderTargetProxy.h
@@ -95,7 +95,6 @@
                         const GrBackendFormat&,
                         SkISize,
                         int sampleCount,
-                        GrSurfaceOrigin,
                         const GrSwizzle& textureSwizzle,
                         SkBackingFit,
                         SkBudgeted,
@@ -119,7 +118,6 @@
                         const GrBackendFormat&,
                         SkISize,
                         int sampleCount,
-                        GrSurfaceOrigin,
                         const GrSwizzle& textureSwizzle,
                         SkBackingFit,
                         SkBudgeted,
@@ -130,7 +128,6 @@
 
     // Wrapped version
     GrRenderTargetProxy(sk_sp<GrSurface>,
-                        GrSurfaceOrigin,
                         const GrSwizzle& textureSwizzle,
                         UseAllocator,
                         WrapsVkSecondaryCB = WrapsVkSecondaryCB::kNo);
diff --git a/src/gpu/GrSoftwarePathRenderer.cpp b/src/gpu/GrSoftwarePathRenderer.cpp
index 6572ac7..4362f17 100644
--- a/src/gpu/GrSoftwarePathRenderer.cpp
+++ b/src/gpu/GrSoftwarePathRenderer.cpp
@@ -181,9 +181,9 @@
 
     GrSwizzle swizzle = caps->getReadSwizzle(format, GrColorType::kAlpha_8);
 
-    auto proxy = proxyProvider->createProxy(format, dimensions, swizzle, GrRenderable::kNo, 1,
-                                            kTopLeft_GrSurfaceOrigin, GrMipMapped::kNo, fit,
-                                            SkBudgeted::kYes, GrProtected::kNo);
+    auto proxy =
+            proxyProvider->createProxy(format, dimensions, swizzle, GrRenderable::kNo, 1,
+                                       GrMipMapped::kNo, fit, SkBudgeted::kYes, GrProtected::kNo);
     return {std::move(proxy), kTopLeft_GrSurfaceOrigin, swizzle};
 }
 
@@ -323,8 +323,7 @@
     sk_sp<GrTextureProxy> proxy;
     GrSurfaceProxyView view;
     if (useCache) {
-        auto proxy = fProxyProvider->findOrCreateProxyByUniqueKey(maskKey, GrColorType::kAlpha_8,
-                                                                  kTopLeft_GrSurfaceOrigin);
+        auto proxy = fProxyProvider->findOrCreateProxyByUniqueKey(maskKey, GrColorType::kAlpha_8);
         if (proxy) {
             GrSwizzle swizzle = args.fRenderTargetContext->caps()->getReadSwizzle(
                     proxy->backendFormat(), GrColorType::kAlpha_8);
diff --git a/src/gpu/GrSurfaceContext.cpp b/src/gpu/GrSurfaceContext.cpp
index e5a1143..407dfe3 100644
--- a/src/gpu/GrSurfaceContext.cpp
+++ b/src/gpu/GrSurfaceContext.cpp
@@ -77,7 +77,7 @@
     GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(format, colorType);
 
     sk_sp<GrTextureProxy> proxy = context->priv().proxyProvider()->createProxy(
-            format, dimensions, swizzle, renderable, renderTargetSampleCnt, origin, mipMapped, fit,
+            format, dimensions, swizzle, renderable, renderTargetSampleCnt, mipMapped, fit,
             budgeted, isProtected);
     if (!proxy) {
         return nullptr;
@@ -380,7 +380,7 @@
         GrSurfaceOrigin tempOrigin =
                 this->asRenderTargetContext() ? kTopLeft_GrSurfaceOrigin : this->origin();
         auto tempProxy = direct->priv().proxyProvider()->createProxy(
-                format, srcInfo.dimensions(), tempReadSwizzle, GrRenderable::kNo, 1, tempOrigin,
+                format, srcInfo.dimensions(), tempReadSwizzle, GrRenderable::kNo, 1,
                 GrMipMapped::kNo, SkBackingFit::kApprox, SkBudgeted::kYes, GrProtected::kNo);
         if (!tempProxy) {
             return false;
diff --git a/src/gpu/GrSurfaceProxy.cpp b/src/gpu/GrSurfaceProxy.cpp
index 26720aa..12cac52 100644
--- a/src/gpu/GrSurfaceProxy.cpp
+++ b/src/gpu/GrSurfaceProxy.cpp
@@ -47,7 +47,6 @@
 GrSurfaceProxy::GrSurfaceProxy(const GrBackendFormat& format,
                                SkISize dimensions,
                                GrRenderable renderable,
-                               GrSurfaceOrigin origin,
                                const GrSwizzle& textureSwizzle,
                                SkBackingFit fit,
                                SkBudgeted budgeted,
@@ -57,7 +56,6 @@
         : fSurfaceFlags(surfaceFlags)
         , fFormat(format)
         , fDimensions(dimensions)
-        , fOrigin(origin)
         , fTextureSwizzle(textureSwizzle)
         , fFit(fit)
         , fBudgeted(budgeted)
@@ -73,7 +71,6 @@
                                const GrBackendFormat& format,
                                SkISize dimensions,
                                GrRenderable renderable,
-                               GrSurfaceOrigin origin,
                                const GrSwizzle& textureSwizzle,
                                SkBackingFit fit,
                                SkBudgeted budgeted,
@@ -83,7 +80,6 @@
         : fSurfaceFlags(surfaceFlags)
         , fFormat(format)
         , fDimensions(dimensions)
-        , fOrigin(origin)
         , fTextureSwizzle(textureSwizzle)
         , fFit(fit)
         , fBudgeted(budgeted)
@@ -98,7 +94,6 @@
 
 // Wrapped version
 GrSurfaceProxy::GrSurfaceProxy(sk_sp<GrSurface> surface,
-                               GrSurfaceOrigin origin,
                                const GrSwizzle& textureSwizzle,
                                SkBackingFit fit,
                                UseAllocator useAllocator)
@@ -106,7 +101,6 @@
         , fSurfaceFlags(fTarget->surfacePriv().flags())
         , fFormat(fTarget->backendFormat())
         , fDimensions(fTarget->dimensions())
-        , fOrigin(origin)
         , fTextureSwizzle(textureSwizzle)
         , fFit(fit)
         , fBudgeted(fTarget->resourcePriv().budgetedType() == GrBudgetedType::kBudgeted
diff --git a/src/gpu/GrSurfaceProxy.h b/src/gpu/GrSurfaceProxy.h
index 495e3e8..92c357b 100644
--- a/src/gpu/GrSurfaceProxy.h
+++ b/src/gpu/GrSurfaceProxy.h
@@ -326,7 +326,6 @@
     GrSurfaceProxy(const GrBackendFormat&,
                    SkISize,
                    GrRenderable,
-                   GrSurfaceOrigin,
                    const GrSwizzle& textureSwizzle,
                    SkBackingFit,
                    SkBudgeted,
@@ -338,7 +337,6 @@
                    const GrBackendFormat&,
                    SkISize,
                    GrRenderable,
-                   GrSurfaceOrigin,
                    const GrSwizzle& textureSwizzle,
                    SkBackingFit,
                    SkBudgeted,
@@ -351,7 +349,6 @@
     // in allocation by having its backing resource recycled to other uninstantiated proxies or
     // not depending on UseAllocator.
     GrSurfaceProxy(sk_sp<GrSurface>,
-                   GrSurfaceOrigin,
                    const GrSwizzle& textureSwizzle,
                    SkBackingFit,
                    UseAllocator);
@@ -396,11 +393,10 @@
     GrInternalSurfaceFlags fSurfaceFlags;
 
 private:
-    // For wrapped resources, 'fFormat', 'fWidth', 'fHeight', and 'fOrigin; will always
-    // be filled in from the wrapped resource.
+    // For wrapped resources, 'fFormat', 'fWidth', and 'fHeight'; will always be filled in from the
+    // wrapped resource.
     const GrBackendFormat  fFormat;
     SkISize                fDimensions;
-    const GrSurfaceOrigin  fOrigin;
     const GrSwizzle        fTextureSwizzle;
 
     SkBackingFit           fFit;      // always kApprox for lazy-callback resources
diff --git a/src/gpu/GrTextureAdjuster.cpp b/src/gpu/GrTextureAdjuster.cpp
index d6bead7..96b0b64 100644
--- a/src/gpu/GrTextureAdjuster.cpp
+++ b/src/gpu/GrTextureAdjuster.cpp
@@ -42,8 +42,7 @@
     sk_sp<GrTextureProxy> cachedCopy;
     const GrSurfaceProxyView& originalView = this->originalProxyView();
     if (key.isValid()) {
-        cachedCopy = proxyProvider->findOrCreateProxyByUniqueKey(key, this->colorType(),
-                                                                 originalView.origin());
+        cachedCopy = proxyProvider->findOrCreateProxyByUniqueKey(key, this->colorType());
         if (cachedCopy && (!willBeMipped || GrMipMapped::kYes == cachedCopy->mipMapped())) {
             // TODO: Once we no longer use CopyOnGpu which can fallback to arbitrary formats and
             // colorTypes, we can use the swizzle of the originalView.
diff --git a/src/gpu/GrTextureMaker.cpp b/src/gpu/GrTextureMaker.cpp
index 2275179..17200f2 100644
--- a/src/gpu/GrTextureMaker.cpp
+++ b/src/gpu/GrTextureMaker.cpp
@@ -56,8 +56,7 @@
     this->makeCopyKey(copyParams, &copyKey);
     GrSurfaceProxyView cachedView;
     if (copyKey.isValid()) {
-        auto cachedProxy =
-                proxyProvider->findOrCreateProxyByUniqueKey(copyKey, this->colorType(), origOrigin);
+        auto cachedProxy = proxyProvider->findOrCreateProxyByUniqueKey(copyKey, this->colorType());
         if (cachedProxy) {
             GrMipMapped mipped = cachedProxy->mipMapped();
             // TODO: Once we no longer use CopyOnGpu which can fallback to arbitrary formats and
diff --git a/src/gpu/GrTextureProxy.cpp b/src/gpu/GrTextureProxy.cpp
index d15e2f0..00c74e1 100644
--- a/src/gpu/GrTextureProxy.cpp
+++ b/src/gpu/GrTextureProxy.cpp
@@ -18,7 +18,6 @@
 // Deferred version - no data
 GrTextureProxy::GrTextureProxy(const GrBackendFormat& format,
                                SkISize dimensions,
-                               GrSurfaceOrigin origin,
                                GrMipMapped mipMapped,
                                GrMipMapsStatus mipMapsStatus,
                                const GrSwizzle& textureSwizzle,
@@ -27,7 +26,7 @@
                                GrProtected isProtected,
                                GrInternalSurfaceFlags surfaceFlags,
                                UseAllocator useAllocator)
-        : INHERITED(format, dimensions, GrRenderable::kNo, origin, textureSwizzle, fit, budgeted,
+        : INHERITED(format, dimensions, GrRenderable::kNo, textureSwizzle, fit, budgeted,
                     isProtected, surfaceFlags, useAllocator)
         , fMipMapped(mipMapped)
         , fMipMapsStatus(mipMapsStatus) SkDEBUGCODE(, fInitialMipMapsStatus(fMipMapsStatus))
@@ -40,7 +39,6 @@
 GrTextureProxy::GrTextureProxy(LazyInstantiateCallback&& callback,
                                const GrBackendFormat& format,
                                SkISize dimensions,
-                               GrSurfaceOrigin origin,
                                GrMipMapped mipMapped,
                                GrMipMapsStatus mipMapsStatus,
                                const GrSwizzle& texSwizzle,
@@ -49,8 +47,8 @@
                                GrProtected isProtected,
                                GrInternalSurfaceFlags surfaceFlags,
                                UseAllocator useAllocator)
-        : INHERITED(std::move(callback), format, dimensions, GrRenderable::kNo, origin, texSwizzle,
-                    fit, budgeted, isProtected, surfaceFlags, useAllocator)
+        : INHERITED(std::move(callback), format, dimensions, GrRenderable::kNo, texSwizzle, fit,
+                    budgeted, isProtected, surfaceFlags, useAllocator)
         , fMipMapped(mipMapped)
         , fMipMapsStatus(mipMapsStatus) SkDEBUGCODE(, fInitialMipMapsStatus(fMipMapsStatus))
         , fProxyProvider(nullptr)
@@ -60,10 +58,9 @@
 
 // Wrapped version
 GrTextureProxy::GrTextureProxy(sk_sp<GrSurface> surf,
-                               GrSurfaceOrigin origin,
                                const GrSwizzle& textureSwizzle,
                                UseAllocator useAllocator)
-        : INHERITED(std::move(surf), origin, textureSwizzle, SkBackingFit::kExact, useAllocator)
+        : INHERITED(std::move(surf), textureSwizzle, SkBackingFit::kExact, useAllocator)
         , fMipMapped(fTarget->asTexture()->texturePriv().mipMapped())
         , fMipMapsStatus(fTarget->asTexture()->texturePriv().mipMapsStatus())
                   SkDEBUGCODE(, fInitialMipMapsStatus(fMipMapsStatus))
diff --git a/src/gpu/GrTextureProxy.h b/src/gpu/GrTextureProxy.h
index 186e2a0..fed523d 100644
--- a/src/gpu/GrTextureProxy.h
+++ b/src/gpu/GrTextureProxy.h
@@ -110,7 +110,6 @@
     // Deferred version - no data.
     GrTextureProxy(const GrBackendFormat&,
                    SkISize,
-                   GrSurfaceOrigin,
                    GrMipMapped,
                    GrMipMapsStatus,
                    const GrSwizzle& textureSwizzle,
@@ -133,7 +132,6 @@
     GrTextureProxy(LazyInstantiateCallback&&,
                    const GrBackendFormat&,
                    SkISize,
-                   GrSurfaceOrigin,
                    GrMipMapped,
                    GrMipMapsStatus,
                    const GrSwizzle& textureSwizzle,
@@ -144,7 +142,7 @@
                    UseAllocator);
 
     // Wrapped version
-    GrTextureProxy(sk_sp<GrSurface>, GrSurfaceOrigin, const GrSwizzle&, UseAllocator);
+    GrTextureProxy(sk_sp<GrSurface>, const GrSwizzle&, UseAllocator);
 
     ~GrTextureProxy() override;
 
diff --git a/src/gpu/GrTextureRenderTargetProxy.cpp b/src/gpu/GrTextureRenderTargetProxy.cpp
index 1fa3da1..be766e2 100644
--- a/src/gpu/GrTextureRenderTargetProxy.cpp
+++ b/src/gpu/GrTextureRenderTargetProxy.cpp
@@ -24,7 +24,6 @@
                                                        const GrBackendFormat& format,
                                                        SkISize dimensions,
                                                        int sampleCnt,
-                                                       GrSurfaceOrigin origin,
                                                        GrMipMapped mipMapped,
                                                        GrMipMapsStatus mipMapsStatus,
                                                        const GrSwizzle& texSwizzle,
@@ -33,13 +32,13 @@
                                                        GrProtected isProtected,
                                                        GrInternalSurfaceFlags surfaceFlags,
                                                        UseAllocator useAllocator)
-        : GrSurfaceProxy(format, dimensions, GrRenderable::kYes, origin, texSwizzle, fit, budgeted,
+        : GrSurfaceProxy(format, dimensions, GrRenderable::kYes, texSwizzle, fit, budgeted,
                          isProtected, surfaceFlags, useAllocator)
         // for now textures w/ data are always wrapped
-        , GrRenderTargetProxy(caps, format, dimensions, sampleCnt, origin, texSwizzle, fit,
-                              budgeted, isProtected, surfaceFlags, useAllocator)
-        , GrTextureProxy(format, dimensions, origin, mipMapped, mipMapsStatus, texSwizzle, fit,
-                         budgeted, isProtected, surfaceFlags, useAllocator) {
+        , GrRenderTargetProxy(caps, format, dimensions, sampleCnt, texSwizzle, fit, budgeted,
+                              isProtected, surfaceFlags, useAllocator)
+        , GrTextureProxy(format, dimensions, mipMapped, mipMapsStatus, texSwizzle, fit, budgeted,
+                         isProtected, surfaceFlags, useAllocator) {
     this->initSurfaceFlags(caps);
 }
 
@@ -49,7 +48,6 @@
                                                        const GrBackendFormat& format,
                                                        SkISize dimensions,
                                                        int sampleCnt,
-                                                       GrSurfaceOrigin origin,
                                                        GrMipMapped mipMapped,
                                                        GrMipMapsStatus mipMapsStatus,
                                                        const GrSwizzle& texSwizzle,
@@ -58,16 +56,15 @@
                                                        GrProtected isProtected,
                                                        GrInternalSurfaceFlags surfaceFlags,
                                                        UseAllocator useAllocator)
-        : GrSurfaceProxy(std::move(callback), format, dimensions, GrRenderable::kYes, origin,
-                         texSwizzle, fit, budgeted, isProtected, surfaceFlags, useAllocator)
+        : GrSurfaceProxy(std::move(callback), format, dimensions, GrRenderable::kYes, texSwizzle,
+                         fit, budgeted, isProtected, surfaceFlags, useAllocator)
         // Since we have virtual inheritance, we initialize GrSurfaceProxy directly. Send null
         // callbacks to the texture and RT proxies simply to route to the appropriate constructors.
-        , GrRenderTargetProxy(LazyInstantiateCallback(), format, dimensions, sampleCnt, origin,
-                              texSwizzle, fit, budgeted, isProtected, surfaceFlags, useAllocator,
+        , GrRenderTargetProxy(LazyInstantiateCallback(), format, dimensions, sampleCnt, texSwizzle,
+                              fit, budgeted, isProtected, surfaceFlags, useAllocator,
                               WrapsVkSecondaryCB::kNo)
-        , GrTextureProxy(LazyInstantiateCallback(), format, dimensions, origin, mipMapped,
-                         mipMapsStatus, texSwizzle, fit, budgeted, isProtected, surfaceFlags,
-                         useAllocator) {
+        , GrTextureProxy(LazyInstantiateCallback(), format, dimensions, mipMapped, mipMapsStatus,
+                         texSwizzle, fit, budgeted, isProtected, surfaceFlags, useAllocator) {
     this->initSurfaceFlags(caps);
 }
 
@@ -75,12 +72,11 @@
 // This class is virtually derived from GrSurfaceProxy (via both GrTextureProxy and
 // GrRenderTargetProxy) so its constructor must be explicitly called.
 GrTextureRenderTargetProxy::GrTextureRenderTargetProxy(sk_sp<GrSurface> surf,
-                                                       GrSurfaceOrigin origin,
                                                        const GrSwizzle& texSwizzle,
                                                        UseAllocator useAllocator)
-        : GrSurfaceProxy(surf, origin, texSwizzle, SkBackingFit::kExact, useAllocator)
-        , GrRenderTargetProxy(surf, origin, texSwizzle, useAllocator)
-        , GrTextureProxy(surf, origin, texSwizzle, useAllocator) {
+        : GrSurfaceProxy(surf, texSwizzle, SkBackingFit::kExact, useAllocator)
+        , GrRenderTargetProxy(surf, texSwizzle, useAllocator)
+        , GrTextureProxy(surf, texSwizzle, useAllocator) {
     SkASSERT(surf->asTexture());
     SkASSERT(surf->asRenderTarget());
     SkASSERT(fSurfaceFlags == fTarget->surfacePriv().flags());
diff --git a/src/gpu/GrTextureRenderTargetProxy.h b/src/gpu/GrTextureRenderTargetProxy.h
index d795685..f096fe2 100644
--- a/src/gpu/GrTextureRenderTargetProxy.h
+++ b/src/gpu/GrTextureRenderTargetProxy.h
@@ -32,7 +32,6 @@
                                const GrBackendFormat&,
                                SkISize,
                                int sampleCnt,
-                               GrSurfaceOrigin,
                                GrMipMapped,
                                GrMipMapsStatus,
                                const GrSwizzle& textureSwizzle,
@@ -48,7 +47,6 @@
                                const GrBackendFormat&,
                                SkISize,
                                int sampleCnt,
-                               GrSurfaceOrigin,
                                GrMipMapped,
                                GrMipMapsStatus,
                                const GrSwizzle& textureSwizzle,
@@ -60,7 +58,6 @@
 
     // Wrapped version
     GrTextureRenderTargetProxy(sk_sp<GrSurface>,
-                               GrSurfaceOrigin,
                                const GrSwizzle& textureSwizzle,
                                UseAllocator);
 
diff --git a/src/gpu/ccpr/GrCCPathCache.cpp b/src/gpu/ccpr/GrCCPathCache.cpp
index 8e01456..d51d3eb 100644
--- a/src/gpu/ccpr/GrCCPathCache.cpp
+++ b/src/gpu/ccpr/GrCCPathCache.cpp
@@ -233,7 +233,7 @@
             if (!entry->fCachedAtlas->getOnFlushProxy()) {
                 auto ct = GrCCAtlas::CoverageTypeToColorType(entry->fCachedAtlas->coverageType());
                 if (sk_sp<GrTextureProxy> onFlushProxy = onFlushRP->findOrCreateProxyByUniqueKey(
-                            entry->fCachedAtlas->textureKey(), ct, GrCCAtlas::kTextureOrigin,
+                            entry->fCachedAtlas->textureKey(), ct,
                             GrSurfaceProxy::UseAllocator::kNo)) {
                     entry->fCachedAtlas->setOnFlushProxy(std::move(onFlushProxy));
                 }
diff --git a/src/gpu/effects/GrCircleBlurFragmentProcessor.fp b/src/gpu/effects/GrCircleBlurFragmentProcessor.fp
index 0a24cee..eefb3f5 100644
--- a/src/gpu/effects/GrCircleBlurFragmentProcessor.fp
+++ b/src/gpu/effects/GrCircleBlurFragmentProcessor.fp
@@ -232,7 +232,7 @@
 
         GrProxyProvider* proxyProvider = context->priv().proxyProvider();
         if (sk_sp<GrTextureProxy> blurProfile = proxyProvider->findOrCreateProxyByUniqueKey(
-                key, GrColorType::kAlpha_8, kTopLeft_GrSurfaceOrigin)) {
+                key, GrColorType::kAlpha_8)) {
             GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(blurProfile->backendFormat(),
                                                                        GrColorType::kAlpha_8);
             return {std::move(blurProfile), kTopLeft_GrSurfaceOrigin, swizzle};
diff --git a/src/gpu/effects/GrRRectBlurEffect.fp b/src/gpu/effects/GrRRectBlurEffect.fp
index 3505878..ce40fb2 100644
--- a/src/gpu/effects/GrRRectBlurEffect.fp
+++ b/src/gpu/effects/GrRRectBlurEffect.fp
@@ -50,7 +50,7 @@
         GrProxyProvider* proxyProvider = context->priv().proxyProvider();
 
         if (sk_sp<GrTextureProxy> mask = proxyProvider->findOrCreateProxyByUniqueKey(
-                key, GrColorType::kAlpha_8, kBottomLeft_GrSurfaceOrigin)) {
+                key, GrColorType::kAlpha_8)) {
             GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(mask->backendFormat(),
                                                                        GrColorType::kAlpha_8);
             return {std::move(mask), kBottomLeft_GrSurfaceOrigin, swizzle};
diff --git a/src/gpu/effects/GrRectBlurEffect.fp b/src/gpu/effects/GrRectBlurEffect.fp
index d74c1e2..1cabeb8 100644
--- a/src/gpu/effects/GrRectBlurEffect.fp
+++ b/src/gpu/effects/GrRectBlurEffect.fp
@@ -63,7 +63,7 @@
 
     GrProxyProvider* proxyProvider = context->priv().proxyProvider();
     if (sk_sp<GrTextureProxy> proxy = proxyProvider->findOrCreateProxyByUniqueKey(
-            key, GrColorType::kAlpha_8, kTopLeft_GrSurfaceOrigin)) {
+            key, GrColorType::kAlpha_8)) {
         GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(proxy->backendFormat(),
                                                                    GrColorType::kAlpha_8);
         return {std::move(proxy), kTopLeft_GrSurfaceOrigin, swizzle};
diff --git a/src/gpu/effects/generated/GrCircleBlurFragmentProcessor.cpp b/src/gpu/effects/generated/GrCircleBlurFragmentProcessor.cpp
index 86ef9c1..bb6767f 100644
--- a/src/gpu/effects/generated/GrCircleBlurFragmentProcessor.cpp
+++ b/src/gpu/effects/generated/GrCircleBlurFragmentProcessor.cpp
@@ -208,8 +208,8 @@
     builder.finish();
 
     GrProxyProvider* proxyProvider = context->priv().proxyProvider();
-    if (sk_sp<GrTextureProxy> blurProfile = proxyProvider->findOrCreateProxyByUniqueKey(
-                key, GrColorType::kAlpha_8, kTopLeft_GrSurfaceOrigin)) {
+    if (sk_sp<GrTextureProxy> blurProfile =
+                proxyProvider->findOrCreateProxyByUniqueKey(key, GrColorType::kAlpha_8)) {
         GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(blurProfile->backendFormat(),
                                                                    GrColorType::kAlpha_8);
         return {std::move(blurProfile), kTopLeft_GrSurfaceOrigin, swizzle};
diff --git a/src/gpu/effects/generated/GrRRectBlurEffect.h b/src/gpu/effects/generated/GrRRectBlurEffect.h
index c078a83..14dcd15 100644
--- a/src/gpu/effects/generated/GrRRectBlurEffect.h
+++ b/src/gpu/effects/generated/GrRRectBlurEffect.h
@@ -51,8 +51,8 @@
 
         GrProxyProvider* proxyProvider = context->priv().proxyProvider();
 
-        if (sk_sp<GrTextureProxy> mask = proxyProvider->findOrCreateProxyByUniqueKey(
-                    key, GrColorType::kAlpha_8, kBottomLeft_GrSurfaceOrigin)) {
+        if (sk_sp<GrTextureProxy> mask =
+                    proxyProvider->findOrCreateProxyByUniqueKey(key, GrColorType::kAlpha_8)) {
             GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(mask->backendFormat(),
                                                                        GrColorType::kAlpha_8);
             return {std::move(mask), kBottomLeft_GrSurfaceOrigin, swizzle};
diff --git a/src/gpu/effects/generated/GrRectBlurEffect.h b/src/gpu/effects/generated/GrRectBlurEffect.h
index 75cb512..51094e6 100644
--- a/src/gpu/effects/generated/GrRectBlurEffect.h
+++ b/src/gpu/effects/generated/GrRectBlurEffect.h
@@ -45,8 +45,8 @@
         builder.finish();
 
         GrProxyProvider* proxyProvider = context->priv().proxyProvider();
-        if (sk_sp<GrTextureProxy> proxy = proxyProvider->findOrCreateProxyByUniqueKey(
-                    key, GrColorType::kAlpha_8, kTopLeft_GrSurfaceOrigin)) {
+        if (sk_sp<GrTextureProxy> proxy =
+                    proxyProvider->findOrCreateProxyByUniqueKey(key, GrColorType::kAlpha_8)) {
             GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(proxy->backendFormat(),
                                                                        GrColorType::kAlpha_8);
             return {std::move(proxy), kTopLeft_GrSurfaceOrigin, swizzle};
diff --git a/src/gpu/ops/GrLatticeOp.cpp b/src/gpu/ops/GrLatticeOp.cpp
index 77f60ee..216240b 100644
--- a/src/gpu/ops/GrLatticeOp.cpp
+++ b/src/gpu/ops/GrLatticeOp.cpp
@@ -417,7 +417,6 @@
                                                               swizzle,
                                                               GrRenderable::kNo,
                                                               1,
-                                                              origin,
                                                               GrMipMapped::kNo,
                                                               SkBackingFit::kExact,
                                                               SkBudgeted::kYes,
diff --git a/src/gpu/ops/GrShadowRRectOp.cpp b/src/gpu/ops/GrShadowRRectOp.cpp
index e1209ee..6d1a36b 100644
--- a/src/gpu/ops/GrShadowRRectOp.cpp
+++ b/src/gpu/ops/GrShadowRRectOp.cpp
@@ -646,8 +646,8 @@
 
     GrProxyProvider* proxyProvider = context->priv().proxyProvider();
 
-    if (sk_sp<GrTextureProxy> falloffTexture = proxyProvider->findOrCreateProxyByUniqueKey(
-                key, GrColorType::kAlpha_8, kTopLeft_GrSurfaceOrigin)) {
+    if (sk_sp<GrTextureProxy> falloffTexture =
+                proxyProvider->findOrCreateProxyByUniqueKey(key, GrColorType::kAlpha_8)) {
         GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(falloffTexture->backendFormat(),
                                                                    GrColorType::kAlpha_8);
         return {std::move(falloffTexture), kTopLeft_GrSurfaceOrigin, swizzle};
diff --git a/src/gpu/ops/GrTextureOp.cpp b/src/gpu/ops/GrTextureOp.cpp
index cc0df06..80298b6 100644
--- a/src/gpu/ops/GrTextureOp.cpp
+++ b/src/gpu/ops/GrTextureOp.cpp
@@ -1294,7 +1294,7 @@
 
     GrProxyProvider* proxyProvider = context->priv().proxyProvider();
     sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
-            format, dims, swizzle, GrRenderable::kNo, 1, origin, mipMapped, fit, SkBudgeted::kNo,
+            format, dims, swizzle, GrRenderable::kNo, 1, mipMapped, fit, SkBudgeted::kNo,
             GrProtected::kNo, GrInternalSurfaceFlags::kNone);
 
     SkRect rect = GrTest::TestRect(random);
diff --git a/src/image/SkImage_Gpu.cpp b/src/image/SkImage_Gpu.cpp
index aae109cb..fcb882c 100644
--- a/src/image/SkImage_Gpu.cpp
+++ b/src/image/SkImage_Gpu.cpp
@@ -131,10 +131,9 @@
     }
 
     GrProxyProvider* proxyProvider = ctx->priv().proxyProvider();
-    sk_sp<GrTextureProxy> proxy =
-            proxyProvider->wrapBackendTexture(backendTex, colorType, origin, ownership,
-                                              GrWrapCacheable::kNo, kRead_GrIOType,
-                                              releaseProc, releaseCtx);
+    sk_sp<GrTextureProxy> proxy = proxyProvider->wrapBackendTexture(
+            backendTex, colorType, ownership, GrWrapCacheable::kNo, kRead_GrIOType, releaseProc,
+            releaseCtx);
     if (!proxy) {
         return nullptr;
     }
@@ -163,9 +162,8 @@
     }
 
     GrProxyProvider* proxyProvider = ctx->priv().proxyProvider();
-    sk_sp<GrTextureProxy> proxy =
-        proxyProvider->wrapCompressedBackendTexture(tex, origin, kBorrow_GrWrapOwnership,
-                                                    GrWrapCacheable::kNo, releaseP, releaseC);
+    sk_sp<GrTextureProxy> proxy = proxyProvider->wrapCompressedBackendTexture(
+            tex, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, releaseP, releaseC);
     if (!proxy) {
         return nullptr;
     }
@@ -496,8 +494,7 @@
     }
 
     callDone.clear();
-    auto proxy = MakePromiseImageLazyProxy(context, width, height, origin,
-                                           grColorType, backendFormat,
+    auto proxy = MakePromiseImageLazyProxy(context, width, height, grColorType, backendFormat,
                                            mipMapped, textureFulfillProc, textureReleaseProc,
                                            textureDoneProc, textureContext, version);
     if (!proxy) {
@@ -625,9 +622,9 @@
     }
 
     sk_sp<GrTextureProxy> proxy =
-            proxyProvider->wrapBackendTexture(backendTexture, grColorType, surfaceOrigin,
-                                              kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
-                                              kRW_GrIOType, deleteImageProc, deleteImageCtx);
+            proxyProvider->wrapBackendTexture(backendTexture, grColorType, kBorrow_GrWrapOwnership,
+                                              GrWrapCacheable::kNo, kRW_GrIOType, deleteImageProc,
+                                              deleteImageCtx);
     if (!proxy) {
         deleteImageProc(deleteImageCtx);
         return nullptr;
diff --git a/src/image/SkImage_GpuBase.cpp b/src/image/SkImage_GpuBase.cpp
index d757a64..95002e0 100644
--- a/src/image/SkImage_GpuBase.cpp
+++ b/src/image/SkImage_GpuBase.cpp
@@ -288,7 +288,7 @@
         SkASSERT(yuvaTextures[textureIndex].isValid());
 
         auto proxy = proxyProvider->wrapBackendTexture(yuvaTextures[textureIndex], grColorType,
-                                                       imageOrigin,  kBorrow_GrWrapOwnership,
+                                                       kBorrow_GrWrapOwnership,
                                                        GrWrapCacheable::kNo, kRead_GrIOType);
         if (!proxy) {
             return false;
@@ -357,7 +357,7 @@
 }
 
 sk_sp<GrTextureProxy> SkImage_GpuBase::MakePromiseImageLazyProxy(
-        GrContext* context, int width, int height, GrSurfaceOrigin origin, GrColorType colorType,
+        GrContext* context, int width, int height, GrColorType colorType,
         GrBackendFormat backendFormat, GrMipMapped mipMapped,
         PromiseImageTextureFulfillProc fulfillProc, PromiseImageTextureReleaseProc releaseProc,
         PromiseImageTextureDoneProc doneProc, PromiseImageTextureContext textureContext,
@@ -531,9 +531,8 @@
 
     // We pass kReadOnly here since we should treat content of the client's texture as immutable.
     // The promise API provides no way for the client to indicated that the texture is protected.
-    return proxyProvider->createLazyProxy(std::move(callback), backendFormat, {width, height},
-                                          readSwizzle, GrRenderable::kNo, 1, origin, mipMapped,
-                                          mipMapsStatus, GrInternalSurfaceFlags::kReadOnly,
-                                          SkBackingFit::kExact, SkBudgeted::kNo, GrProtected::kNo,
-                                          GrSurfaceProxy::UseAllocator::kYes);
+    return proxyProvider->createLazyProxy(
+            std::move(callback), backendFormat, {width, height}, readSwizzle, GrRenderable::kNo, 1,
+            mipMapped, mipMapsStatus, GrInternalSurfaceFlags::kReadOnly, SkBackingFit::kExact,
+            SkBudgeted::kNo, GrProtected::kNo, GrSurfaceProxy::UseAllocator::kYes);
 }
diff --git a/src/image/SkImage_GpuBase.h b/src/image/SkImage_GpuBase.h
index cc59705..05fc48f 100644
--- a/src/image/SkImage_GpuBase.h
+++ b/src/image/SkImage_GpuBase.h
@@ -80,8 +80,8 @@
     // proxy along with the TextureFulfillProc and TextureReleaseProc. PromiseDoneProc must not
     // be null.
     static sk_sp<GrTextureProxy> MakePromiseImageLazyProxy(
-            GrContext*, int width, int height, GrSurfaceOrigin, GrColorType, GrBackendFormat,
-            GrMipMapped, PromiseImageTextureFulfillProc, PromiseImageTextureReleaseProc,
+            GrContext*, int width, int height, GrColorType, GrBackendFormat, GrMipMapped,
+            PromiseImageTextureFulfillProc, PromiseImageTextureReleaseProc,
             PromiseImageTextureDoneProc, PromiseImageTextureContext, PromiseImageApiVersion);
 
     static bool RenderYUVAToRGBA(GrContext* ctx, GrRenderTargetContext* renderTargetContext,
diff --git a/src/image/SkImage_GpuYUVA.cpp b/src/image/SkImage_GpuYUVA.cpp
index 2f7ced0..eedd399 100644
--- a/src/image/SkImage_GpuYUVA.cpp
+++ b/src/image/SkImage_GpuYUVA.cpp
@@ -382,9 +382,9 @@
         }
 
         auto proxy = MakePromiseImageLazyProxy(
-                context, yuvaSizes[texIdx].width(), yuvaSizes[texIdx].height(), imageOrigin,
-                colorType, yuvaFormats[texIdx], GrMipMapped::kNo, textureFulfillProc,
-                textureReleaseProc, promiseDoneProc, textureContexts[texIdx], version);
+                context, yuvaSizes[texIdx].width(), yuvaSizes[texIdx].height(), colorType,
+                yuvaFormats[texIdx], GrMipMapped::kNo, textureFulfillProc, textureReleaseProc,
+                promiseDoneProc, textureContexts[texIdx], version);
         ++proxiesCreated;
         if (!proxy) {
             return nullptr;
diff --git a/src/image/SkImage_Lazy.cpp b/src/image/SkImage_Lazy.cpp
index e3d000d..81a874d 100644
--- a/src/image/SkImage_Lazy.cpp
+++ b/src/image/SkImage_Lazy.cpp
@@ -455,7 +455,7 @@
 
     // 1. Check the cache for a pre-existing one
     if (key.isValid()) {
-        auto proxy = proxyProvider->findOrCreateProxyByUniqueKey(key, ct, kTopLeft_GrSurfaceOrigin);
+        auto proxy = proxyProvider->findOrCreateProxyByUniqueKey(key, ct);
         if (proxy) {
             SK_HISTOGRAM_ENUMERATION("LockTexturePath", kPreExisting_LockTexturePath,
                                      kLockTexturePathCount);
diff --git a/src/image/SkSurface_GpuMtl.mm b/src/image/SkSurface_GpuMtl.mm
index d42fa54..8015948 100644
--- a/src/image/SkSurface_GpuMtl.mm
+++ b/src/image/SkSurface_GpuMtl.mm
@@ -79,7 +79,6 @@
             dims,
             readSwizzle,
             sampleCnt,
-            origin,
             sampleCnt > 1 ? GrInternalSurfaceFlags::kRequiresManualMSAAResolve
                           : GrInternalSurfaceFlags::kNone,
             metalLayer.framebufferOnly ? nullptr : &texInfo,
@@ -152,7 +151,6 @@
             dims,
             readSwizzle,
             sampleCnt,
-            origin,
             sampleCnt > 1 ? GrInternalSurfaceFlags::kRequiresManualMSAAResolve
                           : GrInternalSurfaceFlags::kNone,
             mtkView.framebufferOnly ? nullptr : &texInfo,
diff --git a/tests/BulkRectTest.cpp b/tests/BulkRectTest.cpp
index fb8ae62..fd3fb02 100644
--- a/tests/BulkRectTest.cpp
+++ b/tests/BulkRectTest.cpp
@@ -26,9 +26,8 @@
     GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(format, GrColorType::kRGBA_8888);
 
     return context->priv().proxyProvider()->createProxy(
-            format, kDimensions, swizzle, GrRenderable::kYes, 1, kTopLeft_GrSurfaceOrigin,
-            GrMipMapped::kNo, SkBackingFit::kExact, SkBudgeted::kNo, GrProtected::kNo,
-            GrInternalSurfaceFlags::kNone);
+            format, kDimensions, swizzle, GrRenderable::kYes, 1, GrMipMapped::kNo,
+            SkBackingFit::kExact, SkBudgeted::kNo, GrProtected::kNo, GrInternalSurfaceFlags::kNone);
 }
 
 typedef GrQuadAAFlags (*PerQuadAAFunc)(int i);
diff --git a/tests/DetermineDomainModeTest.cpp b/tests/DetermineDomainModeTest.cpp
index d59258d..62fc973 100644
--- a/tests/DetermineDomainModeTest.cpp
+++ b/tests/DetermineDomainModeTest.cpp
@@ -146,8 +146,7 @@
     GrSwizzle swizzle = caps->getReadSwizzle(format, GrColorType::kRGBA_8888);
 
     return proxyProvider->createProxy(format, {size, size}, swizzle, GrRenderable::kNo, 1,
-                                      kTopLeft_GrSurfaceOrigin, GrMipMapped::kNo, fit,
-                                      SkBudgeted::kYes, GrProtected::kNo);
+                                      GrMipMapped::kNo, fit, SkBudgeted::kYes, GrProtected::kNo);
 }
 
 static RectInfo::EdgeType compute_inset_edgetype(RectInfo::EdgeType previous,
diff --git a/tests/EGLImageTest.cpp b/tests/EGLImageTest.cpp
index 6d7901c..b61a08b 100644
--- a/tests/EGLImageTest.cpp
+++ b/tests/EGLImageTest.cpp
@@ -161,8 +161,7 @@
     // fails on the Nexus5. Why?
     GrSurfaceOrigin origin = kBottomLeft_GrSurfaceOrigin;
     sk_sp<GrSurfaceProxy> texProxy = context0->priv().proxyProvider()->wrapBackendTexture(
-            backendTex, colorType, origin, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
-            kRW_GrIOType);
+            backendTex, colorType, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, kRW_GrIOType);
     if (!texProxy) {
         ERRORF(reporter, "Error wrapping external texture in GrTextureProxy.");
         cleanup(glCtx0, externalTexture.fID, glCtx1.get(), context1, &backendTexture1, image);
diff --git a/tests/GrMipMappedTest.cpp b/tests/GrMipMappedTest.cpp
index 3ba8ba0..1005d7b 100644
--- a/tests/GrMipMappedTest.cpp
+++ b/tests/GrMipMappedTest.cpp
@@ -351,8 +351,7 @@
         SkAlphaType alphaType, GrSurfaceProxyView mipmapView, GrSamplerState::Filter filter) {
     sk_sp<GrSurfaceProxy> renderTarget = proxyProvider->createProxy(
             mipmapView.proxy()->backendFormat(), {1, 1}, mipmapView.swizzle(), GrRenderable::kYes,
-            1, mipmapView.origin(), GrMipMapped::kNo, SkBackingFit::kApprox, SkBudgeted::kYes,
-            GrProtected::kNo);
+            1, GrMipMapped::kNo, SkBackingFit::kApprox, SkBudgeted::kYes, GrProtected::kNo);
 
     auto rtc = GrRenderTargetContext::Make(
             context, colorType, nullptr, std::move(renderTarget), kTopLeft_GrSurfaceOrigin,
@@ -397,8 +396,8 @@
         GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(format, colorType);
 
         sk_sp<GrTextureProxy> mipmapProxy = proxyProvider->createProxy(
-                format, {4, 4}, swizzle, GrRenderable::kYes, 1, kTopLeft_GrSurfaceOrigin,
-                GrMipMapped::kYes, SkBackingFit::kExact, SkBudgeted::kYes, GrProtected::kNo);
+                format, {4, 4}, swizzle, GrRenderable::kYes, 1, GrMipMapped::kYes,
+                SkBackingFit::kExact, SkBudgeted::kYes, GrProtected::kNo);
 
         // Mark the mipmaps clean to ensure things still work properly when they won't be marked
         // dirty again until GrRenderTask::makeClosed().
diff --git a/tests/GrPorterDuffTest.cpp b/tests/GrPorterDuffTest.cpp
index 1219e6b..6f70933 100644
--- a/tests/GrPorterDuffTest.cpp
+++ b/tests/GrPorterDuffTest.cpp
@@ -1004,8 +1004,8 @@
     GrXferProcessor::DstProxyView fakeDstProxyView;
     {
         sk_sp<GrTextureProxy> proxy = proxyProvider->wrapBackendTexture(
-                backendTex, GrColorType::kRGBA_8888, kTopLeft_GrSurfaceOrigin,
-                kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, kRead_GrIOType);
+                backendTex, GrColorType::kRGBA_8888, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
+                kRead_GrIOType);
         GrSwizzle swizzle = caps.getReadSwizzle(backendTex.getBackendFormat(),
                                                    GrColorType::kRGBA_8888);
         fakeDstProxyView.setProxyView({std::move(proxy), kTopLeft_GrSurfaceOrigin, swizzle});
diff --git a/tests/GrSurfaceTest.cpp b/tests/GrSurfaceTest.cpp
index 29b7c29..65288c4 100644
--- a/tests/GrSurfaceTest.cpp
+++ b/tests/GrSurfaceTest.cpp
@@ -119,73 +119,64 @@
             continue;
         }
 
-        for (GrSurfaceOrigin origin : { kTopLeft_GrSurfaceOrigin, kBottomLeft_GrSurfaceOrigin }) {
-
-            // Check if 'isFormatTexturable' agrees with 'createTexture' and that the mipmap
-            // support check is working
-            {
-
-                bool isCompressed = caps->isFormatCompressed(combo.fFormat);
-                bool isTexturable;
-                if (isCompressed) {
-                    isTexturable = caps->isFormatTexturable(combo.fFormat);
-                } else {
-                    isTexturable = caps->isFormatTexturableAndUploadable(combo.fColorType,
-                                                                         combo.fFormat);
-                }
-
-                sk_sp<GrSurface> tex = createTexture(kDims, combo.fColorType, combo.fFormat,
-                                                     GrRenderable::kNo, resourceProvider);
-                REPORTER_ASSERT(reporter, SkToBool(tex) == isTexturable,
-                                "ct:%s format:%s, tex:%d, isTexturable:%d",
-                                GrColorTypeToStr(combo.fColorType),
-                                combo.fFormat.toStr().c_str(),
-                                SkToBool(tex), isTexturable);
-
-                // Check that the lack of mipmap support blocks the creation of mipmapped
-                // proxies
-                bool expectedMipMapability = isTexturable && caps->mipMapSupport() &&
-                                                !isCompressed;
-
-                GrSwizzle swizzle = caps->getReadSwizzle(combo.fFormat, combo.fColorType);
-
-                sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
-                        combo.fFormat, kDims, swizzle, GrRenderable::kNo, 1, origin,
-                        GrMipMapped::kYes, SkBackingFit::kExact, SkBudgeted::kNo, GrProtected::kNo);
-                REPORTER_ASSERT(reporter, SkToBool(proxy.get()) == expectedMipMapability,
-                                "ct:%s format:%s, tex:%d, expectedMipMapability:%d",
-                                GrColorTypeToStr(combo.fColorType),
-                                combo.fFormat.toStr().c_str(),
-                                SkToBool(proxy.get()), expectedMipMapability);
+        // Check if 'isFormatTexturable' agrees with 'createTexture' and that the mipmap
+        // support check is working
+        {
+            bool isCompressed = caps->isFormatCompressed(combo.fFormat);
+            bool isTexturable;
+            if (isCompressed) {
+                isTexturable = caps->isFormatTexturable(combo.fFormat);
+            } else {
+                isTexturable =
+                        caps->isFormatTexturableAndUploadable(combo.fColorType, combo.fFormat);
             }
 
-            // Check if 'isFormatAsColorTypeRenderable' agrees with 'createTexture' (w/o MSAA)
-            {
-                bool isRenderable = caps->isFormatRenderable(combo.fFormat, 1);
+            sk_sp<GrSurface> tex = createTexture(kDims, combo.fColorType, combo.fFormat,
+                                                 GrRenderable::kNo, resourceProvider);
+            REPORTER_ASSERT(reporter, SkToBool(tex) == isTexturable,
+                            "ct:%s format:%s, tex:%d, isTexturable:%d",
+                            GrColorTypeToStr(combo.fColorType), combo.fFormat.toStr().c_str(),
+                            SkToBool(tex), isTexturable);
 
-                sk_sp<GrSurface> tex = resourceProvider->createTexture(
-                        kDims, combo.fFormat, GrRenderable::kYes, 1, GrMipMapped::kNo,
-                        SkBudgeted::kNo, GrProtected::kNo);
-                REPORTER_ASSERT(reporter, SkToBool(tex) == isRenderable,
-                                "ct:%s format:%s, tex:%d, isRenderable:%d",
-                                GrColorTypeToStr(combo.fColorType),
-                                combo.fFormat.toStr().c_str(),
-                                SkToBool(tex), isRenderable);
-            }
+            // Check that the lack of mipmap support blocks the creation of mipmapped
+            // proxies
+            bool expectedMipMapability = isTexturable && caps->mipMapSupport() && !isCompressed;
 
-            // Check if 'isFormatAsColorTypeRenderable' agrees with 'createTexture' w/ MSAA
-            {
-                bool isRenderable = caps->isFormatRenderable(combo.fFormat, 2);
+            GrSwizzle swizzle = caps->getReadSwizzle(combo.fFormat, combo.fColorType);
 
-                sk_sp<GrSurface> tex = resourceProvider->createTexture(
-                        kDims, combo.fFormat, GrRenderable::kYes, 2, GrMipMapped::kNo,
-                        SkBudgeted::kNo, GrProtected::kNo);
-                REPORTER_ASSERT(reporter, SkToBool(tex) == isRenderable,
-                                "ct:%s format:%s, tex:%d, isRenderable:%d",
-                                GrColorTypeToStr(combo.fColorType),
-                                combo.fFormat.toStr().c_str(),
-                                SkToBool(tex), isRenderable);
-            }
+            sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
+                    combo.fFormat, kDims, swizzle, GrRenderable::kNo, 1, GrMipMapped::kYes,
+                    SkBackingFit::kExact, SkBudgeted::kNo, GrProtected::kNo);
+            REPORTER_ASSERT(reporter, SkToBool(proxy.get()) == expectedMipMapability,
+                            "ct:%s format:%s, tex:%d, expectedMipMapability:%d",
+                            GrColorTypeToStr(combo.fColorType), combo.fFormat.toStr().c_str(),
+                            SkToBool(proxy.get()), expectedMipMapability);
+        }
+
+        // Check if 'isFormatAsColorTypeRenderable' agrees with 'createTexture' (w/o MSAA)
+        {
+            bool isRenderable = caps->isFormatRenderable(combo.fFormat, 1);
+
+            sk_sp<GrSurface> tex = resourceProvider->createTexture(
+                    kDims, combo.fFormat, GrRenderable::kYes, 1, GrMipMapped::kNo, SkBudgeted::kNo,
+                    GrProtected::kNo);
+            REPORTER_ASSERT(reporter, SkToBool(tex) == isRenderable,
+                            "ct:%s format:%s, tex:%d, isRenderable:%d",
+                            GrColorTypeToStr(combo.fColorType), combo.fFormat.toStr().c_str(),
+                            SkToBool(tex), isRenderable);
+        }
+
+        // Check if 'isFormatAsColorTypeRenderable' agrees with 'createTexture' w/ MSAA
+        {
+            bool isRenderable = caps->isFormatRenderable(combo.fFormat, 2);
+
+            sk_sp<GrSurface> tex = resourceProvider->createTexture(
+                    kDims, combo.fFormat, GrRenderable::kYes, 2, GrMipMapped::kNo, SkBudgeted::kNo,
+                    GrProtected::kNo);
+            REPORTER_ASSERT(reporter, SkToBool(tex) == isRenderable,
+                            "ct:%s format:%s, tex:%d, isRenderable:%d",
+                            GrColorTypeToStr(combo.fColorType), combo.fFormat.toStr().c_str(),
+                            SkToBool(tex), isRenderable);
         }
     }
 }
@@ -275,8 +266,8 @@
                     // Does directly allocating a texture clear it?
                     {
                         auto proxy = proxyProvider->testingOnly_createInstantiatedProxy(
-                                {kSize, kSize}, combo.fColorType, combo.fFormat, renderable, 1,
-                                kTopLeft_GrSurfaceOrigin, fit, SkBudgeted::kYes, GrProtected::kNo);
+                                {kSize, kSize}, combo.fColorType, combo.fFormat, renderable, 1, fit,
+                                SkBudgeted::kYes, GrProtected::kNo);
                         if (proxy) {
                             GrSwizzle swizzle = caps->getReadSwizzle(combo.fFormat,
                                                                      combo.fColorType);
@@ -377,7 +368,6 @@
                                                         GrRenderable::kYes, GrProtected::kNo);
 
         auto proxy = proxyProvider->wrapBackendTexture(backendTex, GrColorType::kRGBA_8888,
-                                                       kTopLeft_GrSurfaceOrigin,
                                                        kBorrow_GrWrapOwnership,
                                                        GrWrapCacheable::kNo, ioType);
         GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(proxy->backendFormat(),
@@ -437,7 +427,6 @@
                     SkColors::kTransparent, GrMipMapped::kYes, GrRenderable::kYes,
                     GrProtected::kNo);
             proxy = proxyProvider->wrapBackendTexture(backendTex, GrColorType::kRGBA_8888,
-                                                      kTopLeft_GrSurfaceOrigin,
                                                       kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
                                                       ioType);
             context->flush();
@@ -586,10 +575,9 @@
                         backendFormat, GrColorType::kRGBA_8888);
                 auto proxy = context->priv().proxyProvider()->createLazyProxy(
                         singleUseLazyCB, backendFormat, desc, readSwizzle, renderable, 1,
-                        kTopLeft_GrSurfaceOrigin, GrMipMapped::kNo,
-                        GrMipMapsStatus::kNotAllocated, GrInternalSurfaceFlags ::kNone,
-                        SkBackingFit::kExact, budgeted, GrProtected::kNo,
-                        GrSurfaceProxy::UseAllocator::kYes);
+                        GrMipMapped::kNo, GrMipMapsStatus::kNotAllocated,
+                        GrInternalSurfaceFlags ::kNone, SkBackingFit::kExact, budgeted,
+                        GrProtected::kNo, GrSurfaceProxy::UseAllocator::kYes);
                 GrSurfaceProxyView view(std::move(proxy), kTopLeft_GrSurfaceOrigin, readSwizzle);
                 rtc->drawTexture(GrNoClip(), view, kPremul_SkAlphaType,
                                  GrSamplerState::Filter::kNearest, SkBlendMode::kSrcOver,
@@ -650,7 +638,7 @@
                             auto rtc = rt->getCanvas()
                                             ->internal_private_accessTopLayerRenderTargetContext();
                             auto proxy = context->priv().proxyProvider()->testingOnly_createWrapped(
-                                    texture, GrColorType::kRGBA_8888, kTopLeft_GrSurfaceOrigin);
+                                    texture, GrColorType::kRGBA_8888);
                             GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(
                                     proxy->backendFormat(), GrColorType::kRGBA_8888);
                             GrSurfaceProxyView view(std::move(proxy), kTopLeft_GrSurfaceOrigin,
@@ -813,7 +801,7 @@
         auto rt = SkSurface::MakeRenderTarget(context, SkBudgeted::kNo, info, 0, nullptr);
         auto rtc = rt->getCanvas()->internal_private_accessTopLayerRenderTargetContext();
         auto proxy = context->priv().proxyProvider()->testingOnly_createWrapped(
-                std::move(idleTexture), GrColorType::kRGBA_8888, rtc->origin());
+                std::move(idleTexture), GrColorType::kRGBA_8888);
         context->flush();
         SkAssertResult(rtc->testCopy(proxy.get(), rtc->origin()));
         proxy.reset();
diff --git a/tests/GrTestingBackendTextureUploadTest.cpp b/tests/GrTestingBackendTextureUploadTest.cpp
index 884ed88..126f72d 100644
--- a/tests/GrTestingBackendTextureUploadTest.cpp
+++ b/tests/GrTestingBackendTextureUploadTest.cpp
@@ -63,12 +63,11 @@
     sk_sp<GrTextureProxy> wrappedProxy;
     if (GrRenderable::kYes == renderable) {
         wrappedProxy = context->priv().proxyProvider()->wrapRenderableBackendTexture(
-                backendTex, kTopLeft_GrSurfaceOrigin, 1, grCT, kAdopt_GrWrapOwnership,
-                GrWrapCacheable::kNo);
+                backendTex, 1, grCT, kAdopt_GrWrapOwnership, GrWrapCacheable::kNo);
     } else {
         wrappedProxy = context->priv().proxyProvider()->wrapBackendTexture(
-                backendTex, grCT, kTopLeft_GrSurfaceOrigin, kAdopt_GrWrapOwnership,
-                GrWrapCacheable::kNo, GrIOType::kRW_GrIOType);
+                backendTex, grCT, kAdopt_GrWrapOwnership, GrWrapCacheable::kNo,
+                GrIOType::kRW_GrIOType);
     }
     REPORTER_ASSERT(reporter, wrappedProxy);
 
diff --git a/tests/LazyProxyTest.cpp b/tests/LazyProxyTest.cpp
index 341286e..819e2b9 100644
--- a/tests/LazyProxyTest.cpp
+++ b/tests/LazyProxyTest.cpp
@@ -101,8 +101,7 @@
                         }
                     },
                     format, readSwizzle, GrRenderable::kNo, 1, GrProtected::kNo,
-                    kTopLeft_GrSurfaceOrigin, *proxyProvider->caps(),
-                    GrSurfaceProxy::UseAllocator::kYes);
+                    *proxyProvider->caps(), GrSurfaceProxy::UseAllocator::kYes);
 
             this->setBounds(SkRectPriv::MakeLargest(), GrOp::HasAABloat::kNo,
                             GrOp::IsHairline::kNo);
@@ -141,7 +140,7 @@
                         fAtlas->instantiate(rp);
                         return sk_ref_sp(fAtlas->peekTexture());
                     },
-                    format, readSwizzle, GrRenderable::kYes, 1, GrProtected::kNo, kOrigin,
+                    format, readSwizzle, GrRenderable::kYes, 1, GrProtected::kNo,
                     *proxyProvider->caps(), GrSurfaceProxy::UseAllocator::kYes);
             fAccess.set(GrSurfaceProxyView(fLazyProxy, kOrigin, readSwizzle),
                         GrSamplerState::Filter::kNearest);
@@ -275,7 +274,7 @@
             GrSwizzle readSwizzle = caps->getReadSwizzle(format, GrColorType::kRGBA_8888);
             sk_sp<GrTextureProxy> proxy = proxyProvider->createLazyProxy(
                     TestCallback(&testCount, releaseCallback, tex), format, {kSize, kSize},
-                    readSwizzle, GrRenderable::kNo, 1, kTopLeft_GrSurfaceOrigin, GrMipMapped::kNo,
+                    readSwizzle, GrRenderable::kNo, 1, GrMipMapped::kNo,
                     GrMipMapsStatus::kNotAllocated, GrInternalSurfaceFlags::kNone,
                     SkBackingFit::kExact, SkBudgeted::kNo, GrProtected::kNo,
                     GrSurfaceProxy::UseAllocator::kYes);
@@ -348,10 +347,9 @@
                                               SkBudgeted::kNo, GrProtected::kNo),
                             true, GrSurfaceProxy::LazyInstantiationKeyMode::kUnsynced};
                 },
-                format, desc, readSwizzle, GrRenderable::kNo, 1, kTopLeft_GrSurfaceOrigin,
-                GrMipMapped::kNo, GrMipMapsStatus::kNotAllocated, GrInternalSurfaceFlags::kNone,
-                SkBackingFit::kExact, SkBudgeted::kNo, GrProtected::kNo,
-                GrSurfaceProxy::UseAllocator::kYes);
+                format, desc, readSwizzle, GrRenderable::kNo, 1, GrMipMapped::kNo,
+                GrMipMapsStatus::kNotAllocated, GrInternalSurfaceFlags::kNone, SkBackingFit::kExact,
+                SkBudgeted::kNo, GrProtected::kNo, GrSurfaceProxy::UseAllocator::kYes);
 
         SkASSERT(fLazyProxy.get());
 
diff --git a/tests/MtlCopySurfaceTest.mm b/tests/MtlCopySurfaceTest.mm
index 9a716f1..a151593 100644
--- a/tests/MtlCopySurfaceTest.mm
+++ b/tests/MtlCopySurfaceTest.mm
@@ -42,8 +42,7 @@
 
     GrProxyProvider* proxyProvider = context->priv().proxyProvider();
     sk_sp<GrSurfaceProxy> srcProxy = proxyProvider->wrapBackendRenderTarget(
-                                             backendRT, GrColorType::kBGRA_8888,
-                                             kTopLeft_GrSurfaceOrigin);
+                                             backendRT, GrColorType::kBGRA_8888);
 
     GrSurfaceProxyView dstView = GrSurfaceProxy::Copy(context, srcProxy.get(),
                                                       kTopLeft_GrSurfaceOrigin,
diff --git a/tests/OnFlushCallbackTest.cpp b/tests/OnFlushCallbackTest.cpp
index bc0e8a1..96cfa6b 100644
--- a/tests/OnFlushCallbackTest.cpp
+++ b/tests/OnFlushCallbackTest.cpp
@@ -330,7 +330,6 @@
                 GrRenderable::kYes,
                 1,
                 GrProtected::kNo,
-                kBottomLeft_GrSurfaceOrigin,
                 *proxyProvider->caps(),
                 GrSurfaceProxy::UseAllocator::kNo);
 
diff --git a/tests/OpChainTest.cpp b/tests/OpChainTest.cpp
index dcce574..366894b 100644
--- a/tests/OpChainTest.cpp
+++ b/tests/OpChainTest.cpp
@@ -175,8 +175,8 @@
 
     static const GrSurfaceOrigin kOrigin = kTopLeft_GrSurfaceOrigin;
     auto proxy = context->priv().proxyProvider()->createProxy(
-            format, kDims, swizzle, GrRenderable::kYes, 1, kOrigin, GrMipMapped::kNo,
-            SkBackingFit::kExact, SkBudgeted::kNo, GrProtected::kNo, GrInternalSurfaceFlags::kNone);
+            format, kDims, swizzle, GrRenderable::kYes, 1, GrMipMapped::kNo, SkBackingFit::kExact,
+            SkBudgeted::kNo, GrProtected::kNo, GrInternalSurfaceFlags::kNone);
     SkASSERT(proxy);
     proxy->instantiate(context->priv().resourceProvider());
 
diff --git a/tests/ProcessorTest.cpp b/tests/ProcessorTest.cpp
index 7ed9fe9..c89a750 100644
--- a/tests/ProcessorTest.cpp
+++ b/tests/ProcessorTest.cpp
@@ -162,8 +162,8 @@
                     context, GrColorType::kRGBA_8888, nullptr, SkBackingFit::kApprox, {1, 1});
             {
                 sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
-                        format, kDims, swizzle, GrRenderable::kNo, 1, kTopLeft_GrSurfaceOrigin,
-                        GrMipMapped::kNo, SkBackingFit::kExact, SkBudgeted::kYes, GrProtected::kNo);
+                        format, kDims, swizzle, GrRenderable::kNo, 1, GrMipMapped::kNo,
+                        SkBackingFit::kExact, SkBudgeted::kYes, GrProtected::kNo);
 
                 {
                     SkTArray<GrSurfaceProxyView> views;
diff --git a/tests/ProgramsTest.cpp b/tests/ProgramsTest.cpp
index b12ec52..dd69a0c 100644
--- a/tests/ProgramsTest.cpp
+++ b/tests/ProgramsTest.cpp
@@ -268,8 +268,7 @@
                                                             GrRenderable::kYes);
         GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(format, GrColorType::kRGBA_8888);
         auto proxy = proxyProvider->createProxy(format, kDummyDims, swizzle, GrRenderable::kYes, 1,
-                                                kBottomLeft_GrSurfaceOrigin, mipMapped,
-                                                SkBackingFit::kExact, SkBudgeted::kNo,
+                                                mipMapped, SkBackingFit::kExact, SkBudgeted::kNo,
                                                 GrProtected::kNo, GrInternalSurfaceFlags::kNone);
         views[0] = {{std::move(proxy), kBottomLeft_GrSurfaceOrigin, swizzle},
                     GrColorType::kRGBA_8888, kPremul_SkAlphaType};
@@ -281,8 +280,7 @@
                                                             GrRenderable::kNo);
         GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(format, GrColorType::kAlpha_8);
         auto proxy = proxyProvider->createProxy(format, kDummyDims, swizzle, GrRenderable::kNo, 1,
-                                                kTopLeft_GrSurfaceOrigin, mipMapped,
-                                                SkBackingFit::kExact, SkBudgeted::kNo,
+                                                mipMapped, SkBackingFit::kExact, SkBudgeted::kNo,
                                                 GrProtected::kNo, GrInternalSurfaceFlags::kNone);
         views[1] = {{std::move(proxy), kTopLeft_GrSurfaceOrigin, swizzle},
                       GrColorType::kAlpha_8, kPremul_SkAlphaType};
diff --git a/tests/ProxyConversionTest.cpp b/tests/ProxyConversionTest.cpp
index fb0fdfa..169bb09 100644
--- a/tests/ProxyConversionTest.cpp
+++ b/tests/ProxyConversionTest.cpp
@@ -23,11 +23,10 @@
                                              GrGpu* gpu,
                                              skiatest::Reporter* reporter,
                                              const SkISize& size,
-                                             GrColorType colorType,
-                                             GrSurfaceOrigin origin) {
+                                             GrColorType colorType) {
     auto backendRT =
             gpu->createTestingOnlyBackendRenderTarget(size.width(), size.height(), colorType);
-    return provider->wrapBackendRenderTarget(backendRT, colorType, origin, nullptr, nullptr);
+    return provider->wrapBackendRenderTarget(backendRT, colorType, nullptr, nullptr);
 }
 
 void clean_up_wrapped_rt(GrGpu* gpu, sk_sp<GrSurfaceProxy> proxy) {
@@ -40,21 +39,19 @@
 
 static sk_sp<GrSurfaceProxy> make_offscreen_rt(GrProxyProvider* provider,
                                                SkISize dimensions,
-                                               GrColorType colorType,
-                                               GrSurfaceOrigin origin) {
+                                               GrColorType colorType) {
     return provider->testingOnly_createInstantiatedProxy(dimensions, colorType, GrRenderable::kYes,
-                                                         1, origin, SkBackingFit::kExact,
-                                                         SkBudgeted::kYes, GrProtected::kNo);
+                                                         1, SkBackingFit::kExact, SkBudgeted::kYes,
+                                                         GrProtected::kNo);
 }
 
 static sk_sp<GrSurfaceProxy> make_texture(GrProxyProvider* provider,
                                           SkISize dimensions,
                                           GrColorType colorType,
-                                          GrRenderable renderable,
-                                          GrSurfaceOrigin origin) {
+                                          GrRenderable renderable) {
     return provider->testingOnly_createInstantiatedProxy(dimensions, colorType, renderable, 1,
-                                                         origin, SkBackingFit::kExact,
-                                                         SkBudgeted::kYes, GrProtected::kNo);
+                                                         SkBackingFit::kExact, SkBudgeted::kYes,
+                                                         GrProtected::kNo);
 }
 
 // Test converting between RenderTargetProxies and TextureProxies for preinstantiated Proxies
@@ -67,8 +64,8 @@
 
     {
         // External on-screen render target.
-        sk_sp<GrSurfaceProxy> sProxy(make_wrapped_rt(proxyProvider, gpu, reporter, kSize,
-                                                     kColorType, kBottomLeft_GrSurfaceOrigin));
+        sk_sp<GrSurfaceProxy> sProxy(
+                make_wrapped_rt(proxyProvider, gpu, reporter, kSize, kColorType));
         if (sProxy) {
             // RenderTarget-only
             GrRenderTargetProxy* rtProxy = sProxy->asRenderTargetProxy();
@@ -81,8 +78,7 @@
 
     {
         // Internal offscreen render target.
-        sk_sp<GrSurfaceProxy> sProxy(
-                make_offscreen_rt(proxyProvider, kSize, kColorType, kBottomLeft_GrSurfaceOrigin));
+        sk_sp<GrSurfaceProxy> sProxy(make_offscreen_rt(proxyProvider, kSize, kColorType));
         if (sProxy) {
             // Both RenderTarget and Texture
             GrRenderTargetProxy* rtProxy = sProxy->asRenderTargetProxy();
@@ -96,8 +92,8 @@
 
     {
         // Internal offscreen render target - but through GrTextureProxy
-        sk_sp<GrSurfaceProxy> sProxy(make_texture(proxyProvider, kSize, kColorType,
-                                                  GrRenderable::kYes, kBottomLeft_GrSurfaceOrigin));
+        sk_sp<GrSurfaceProxy> sProxy(
+                make_texture(proxyProvider, kSize, kColorType, GrRenderable::kYes));
         if (sProxy) {
             // Both RenderTarget and Texture
             GrTextureProxy* tProxy = sProxy->asTextureProxy();
@@ -111,8 +107,8 @@
 
     {
         // force no-RT
-        sk_sp<GrSurfaceProxy> sProxy(make_texture(proxyProvider, kSize, kColorType,
-                                                  GrRenderable::kNo, kBottomLeft_GrSurfaceOrigin));
+        sk_sp<GrSurfaceProxy> sProxy(
+                make_texture(proxyProvider, kSize, kColorType, GrRenderable::kNo));
         if (sProxy) {
             // Texture-only
             GrTextureProxy* tProxy = sProxy->asTextureProxy();
@@ -138,8 +134,8 @@
 
     {
         sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
-                format, kDims, swizzle, GrRenderable::kYes, 1, kBottomLeft_GrSurfaceOrigin,
-                GrMipMapped::kNo, SkBackingFit::kApprox, SkBudgeted::kYes, GrProtected::kNo);
+                format, kDims, swizzle, GrRenderable::kYes, 1, GrMipMapped::kNo,
+                SkBackingFit::kApprox, SkBudgeted::kYes, GrProtected::kNo);
 
         // Both RenderTarget and Texture
         GrRenderTargetProxy* rtProxy = proxy->asRenderTargetProxy();
@@ -152,8 +148,8 @@
 
     {
         sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
-                format, kDims, swizzle, GrRenderable::kYes, 1, kBottomLeft_GrSurfaceOrigin,
-                GrMipMapped::kNo, SkBackingFit::kApprox, SkBudgeted::kYes, GrProtected::kNo);
+                format, kDims, swizzle, GrRenderable::kYes, 1, GrMipMapped::kNo,
+                SkBackingFit::kApprox, SkBudgeted::kYes, GrProtected::kNo);
 
         // Both RenderTarget and Texture - but via GrTextureProxy
         GrTextureProxy* tProxy = proxy->asTextureProxy();
@@ -166,8 +162,8 @@
 
     {
         sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
-                format, kDims, swizzle, GrRenderable::kNo, 1, kTopLeft_GrSurfaceOrigin,
-                GrMipMapped::kNo, SkBackingFit::kApprox, SkBudgeted::kYes, GrProtected::kNo);
+                format, kDims, swizzle, GrRenderable::kNo, 1, GrMipMapped::kNo,
+                SkBackingFit::kApprox, SkBudgeted::kYes, GrProtected::kNo);
         // Texture-only
         GrTextureProxy* tProxy = proxy->asTextureProxy();
         REPORTER_ASSERT(reporter, tProxy);
diff --git a/tests/ProxyRefTest.cpp b/tests/ProxyRefTest.cpp
index 4354378..9e1dd4d 100644
--- a/tests/ProxyRefTest.cpp
+++ b/tests/ProxyRefTest.cpp
@@ -28,9 +28,8 @@
                                                                  GrRenderable::kYes);
     GrSwizzle swizzle = caps->getReadSwizzle(format, GrColorType::kRGBA_8888);
     return proxyProvider->createProxy(format, {kWidthHeight, kWidthHeight}, swizzle,
-                                      GrRenderable::kYes, 1, kBottomLeft_GrSurfaceOrigin,
-                                      GrMipMapped::kNo, SkBackingFit::kApprox, SkBudgeted::kYes,
-                                      GrProtected::kNo);
+                                      GrRenderable::kYes, 1, GrMipMapped::kNo,
+                                      SkBackingFit::kApprox, SkBudgeted::kYes, GrProtected::kNo);
 }
 
 static sk_sp<GrTextureProxy> make_wrapped(GrContext* context) {
@@ -38,7 +37,7 @@
 
     return proxyProvider->testingOnly_createInstantiatedProxy(
             {kWidthHeight, kWidthHeight}, GrColorType::kRGBA_8888, GrRenderable::kYes, 1,
-            kBottomLeft_GrSurfaceOrigin, SkBackingFit::kExact, SkBudgeted::kNo, GrProtected::kNo);
+            SkBackingFit::kExact, SkBudgeted::kNo, GrProtected::kNo);
 }
 
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ProxyRefTest, reporter, ctxInfo) {
diff --git a/tests/ProxyTest.cpp b/tests/ProxyTest.cpp
index 368961c..27a0db0 100644
--- a/tests/ProxyTest.cpp
+++ b/tests/ProxyTest.cpp
@@ -113,92 +113,89 @@
 
     int attempt = 0; // useful for debugging
 
-    for (auto origin : { kBottomLeft_GrSurfaceOrigin, kTopLeft_GrSurfaceOrigin }) {
-        for (auto widthHeight : { 100, 128, 1048576 }) {
-            for (auto ct : { GrColorType::kAlpha_8, GrColorType::kBGR_565,
-                             GrColorType::kRGBA_8888, GrColorType::kRGBA_1010102 } ) {
-                for (auto fit : { SkBackingFit::kExact, SkBackingFit::kApprox }) {
-                    for (auto budgeted : { SkBudgeted::kYes, SkBudgeted::kNo }) {
-                        for (auto numSamples : {1, 4, 16, 128}) {
-                            SkISize dims = {widthHeight, widthHeight};
+    for (auto widthHeight : {100, 128, 1048576}) {
+        for (auto ct : {GrColorType::kAlpha_8, GrColorType::kBGR_565, GrColorType::kRGBA_8888,
+                        GrColorType::kRGBA_1010102}) {
+            for (auto fit : {SkBackingFit::kExact, SkBackingFit::kApprox}) {
+                for (auto budgeted : {SkBudgeted::kYes, SkBudgeted::kNo}) {
+                    for (auto numSamples : {1, 4, 16, 128}) {
+                        SkISize dims = {widthHeight, widthHeight};
 
-                            auto format = caps.getDefaultBackendFormat(ct, GrRenderable::kYes);
-                            if (!format.isValid()) {
-                                continue;
-                            }
-                            GrSwizzle swizzle = caps.getReadSwizzle(format, ct);
-
-                            // Renderable
-                            {
-                                sk_sp<GrTexture> tex;
-                                if (SkBackingFit::kApprox == fit) {
-                                    tex = resourceProvider->createApproxTexture(
-                                            dims, format, GrRenderable::kYes, numSamples,
-                                            GrProtected::kNo);
-                                } else {
-                                    tex = resourceProvider->createTexture(
-                                            dims, format, GrRenderable::kYes, numSamples,
-                                            GrMipMapped::kNo, budgeted, GrProtected::kNo);
-                                }
-
-                                sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
-                                        format, dims, swizzle, GrRenderable::kYes, numSamples,
-                                        origin, GrMipMapped::kNo, fit, budgeted, GrProtected::kNo);
-                                REPORTER_ASSERT(reporter, SkToBool(tex) == SkToBool(proxy));
-                                if (proxy) {
-                                    REPORTER_ASSERT(reporter, proxy->asRenderTargetProxy());
-                                    // This forces the proxy to compute and cache its
-                                    // pre-instantiation size guess. Later, when it is actually
-                                    // instantiated, it checks that the instantiated size is <= to
-                                    // the pre-computation. If the proxy never computed its
-                                    // pre-instantiation size then the check is skipped.
-                                    proxy->gpuMemorySize(caps);
-
-                                    check_surface(reporter, proxy.get(), widthHeight, widthHeight,
-                                                  budgeted);
-                                    int supportedSamples =
-                                            caps.getRenderTargetSampleCount(numSamples, format);
-                                    check_rendertarget(reporter, caps, resourceProvider,
-                                                       proxy->asRenderTargetProxy(),
-                                                       supportedSamples,
-                                                       fit, caps.maxWindowRectangles());
-                                }
-                            }
-
-                            // Not renderable
-                            {
-                                sk_sp<GrTexture> tex;
-                                if (SkBackingFit::kApprox == fit) {
-                                    tex = resourceProvider->createApproxTexture(
-                                            dims, format, GrRenderable::kNo, numSamples,
-                                            GrProtected::kNo);
-                                } else {
-                                    tex = resourceProvider->createTexture(
-                                            dims, format, GrRenderable::kNo, numSamples,
-                                            GrMipMapped::kNo, budgeted, GrProtected::kNo);
-                                }
-
-                                sk_sp<GrTextureProxy> proxy(proxyProvider->createProxy(
-                                        format, dims, swizzle, GrRenderable::kNo, numSamples,
-                                        origin, GrMipMapped::kNo, fit, budgeted, GrProtected::kNo));
-                                REPORTER_ASSERT(reporter, SkToBool(tex) == SkToBool(proxy));
-                                if (proxy) {
-                                    // This forces the proxy to compute and cache its
-                                    // pre-instantiation size guess. Later, when it is actually
-                                    // instantiated, it checks that the instantiated size is <= to
-                                    // the pre-computation. If the proxy never computed its
-                                    // pre-instantiation size then the check is skipped.
-                                    proxy->gpuMemorySize(caps);
-
-                                    check_surface(reporter, proxy.get(), widthHeight, widthHeight,
-                                                  budgeted);
-                                    check_texture(reporter, resourceProvider,
-                                                  proxy->asTextureProxy(), fit);
-                                }
-                            }
-
-                            attempt++;
+                        auto format = caps.getDefaultBackendFormat(ct, GrRenderable::kYes);
+                        if (!format.isValid()) {
+                            continue;
                         }
+                        GrSwizzle swizzle = caps.getReadSwizzle(format, ct);
+
+                        // Renderable
+                        {
+                            sk_sp<GrTexture> tex;
+                            if (SkBackingFit::kApprox == fit) {
+                                tex = resourceProvider->createApproxTexture(
+                                        dims, format, GrRenderable::kYes, numSamples,
+                                        GrProtected::kNo);
+                            } else {
+                                tex = resourceProvider->createTexture(
+                                        dims, format, GrRenderable::kYes, numSamples,
+                                        GrMipMapped::kNo, budgeted, GrProtected::kNo);
+                            }
+
+                            sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
+                                    format, dims, swizzle, GrRenderable::kYes, numSamples,
+                                    GrMipMapped::kNo, fit, budgeted, GrProtected::kNo);
+                            REPORTER_ASSERT(reporter, SkToBool(tex) == SkToBool(proxy));
+                            if (proxy) {
+                                REPORTER_ASSERT(reporter, proxy->asRenderTargetProxy());
+                                // This forces the proxy to compute and cache its
+                                // pre-instantiation size guess. Later, when it is actually
+                                // instantiated, it checks that the instantiated size is <= to
+                                // the pre-computation. If the proxy never computed its
+                                // pre-instantiation size then the check is skipped.
+                                proxy->gpuMemorySize(caps);
+
+                                check_surface(reporter, proxy.get(), widthHeight, widthHeight,
+                                              budgeted);
+                                int supportedSamples =
+                                        caps.getRenderTargetSampleCount(numSamples, format);
+                                check_rendertarget(reporter, caps, resourceProvider,
+                                                   proxy->asRenderTargetProxy(), supportedSamples,
+                                                   fit, caps.maxWindowRectangles());
+                            }
+                        }
+
+                        // Not renderable
+                        {
+                            sk_sp<GrTexture> tex;
+                            if (SkBackingFit::kApprox == fit) {
+                                tex = resourceProvider->createApproxTexture(
+                                        dims, format, GrRenderable::kNo, numSamples,
+                                        GrProtected::kNo);
+                            } else {
+                                tex = resourceProvider->createTexture(
+                                        dims, format, GrRenderable::kNo, numSamples,
+                                        GrMipMapped::kNo, budgeted, GrProtected::kNo);
+                            }
+
+                            sk_sp<GrTextureProxy> proxy(proxyProvider->createProxy(
+                                    format, dims, swizzle, GrRenderable::kNo, numSamples,
+                                    GrMipMapped::kNo, fit, budgeted, GrProtected::kNo));
+                            REPORTER_ASSERT(reporter, SkToBool(tex) == SkToBool(proxy));
+                            if (proxy) {
+                                // This forces the proxy to compute and cache its
+                                // pre-instantiation size guess. Later, when it is actually
+                                // instantiated, it checks that the instantiated size is <= to
+                                // the pre-computation. If the proxy never computed its
+                                // pre-instantiation size then the check is skipped.
+                                proxy->gpuMemorySize(caps);
+
+                                check_surface(reporter, proxy.get(), widthHeight, widthHeight,
+                                              budgeted);
+                                check_texture(reporter, resourceProvider, proxy->asTextureProxy(),
+                                              fit);
+                            }
+                        }
+
+                        attempt++;
                     }
                 }
             }
@@ -215,139 +212,115 @@
 
     static const int kWidthHeight = 100;
 
-    for (auto origin : { kBottomLeft_GrSurfaceOrigin, kTopLeft_GrSurfaceOrigin }) {
-        for (auto colorType : { kAlpha_8_SkColorType, kRGBA_8888_SkColorType,
-                                kRGBA_1010102_SkColorType }) {
-            GrColorType grColorType = SkColorTypeToGrColorType(colorType);
+    for (auto colorType :
+         {kAlpha_8_SkColorType, kRGBA_8888_SkColorType, kRGBA_1010102_SkColorType}) {
+        GrColorType grColorType = SkColorTypeToGrColorType(colorType);
 
-            // External on-screen render target.
-            // Tests wrapBackendRenderTarget with a GrBackendRenderTarget
-            // Our test-only function that creates a backend render target doesn't currently support
-            // sample counts :(.
-            if (ctxInfo.grContext()->colorTypeSupportedAsSurface(colorType)) {
-                GrBackendRenderTarget backendRT = gpu->createTestingOnlyBackendRenderTarget(
-                        kWidthHeight, kWidthHeight, grColorType);
-                sk_sp<GrSurfaceProxy> sProxy(
-                        proxyProvider->wrapBackendRenderTarget(backendRT, grColorType,
-                                                               origin, nullptr, nullptr));
-                check_surface(reporter, sProxy.get(), kWidthHeight, kWidthHeight, SkBudgeted::kNo);
-                static constexpr int kExpectedNumSamples = 1;
-                check_rendertarget(reporter, caps, resourceProvider, sProxy->asRenderTargetProxy(),
-                                   kExpectedNumSamples, SkBackingFit::kExact,
-                                   caps.maxWindowRectangles());
-                gpu->deleteTestingOnlyBackendRenderTarget(backendRT);
+        // External on-screen render target.
+        // Tests wrapBackendRenderTarget with a GrBackendRenderTarget
+        // Our test-only function that creates a backend render target doesn't currently support
+        // sample counts :(.
+        if (ctxInfo.grContext()->colorTypeSupportedAsSurface(colorType)) {
+            GrBackendRenderTarget backendRT = gpu->createTestingOnlyBackendRenderTarget(
+                    kWidthHeight, kWidthHeight, grColorType);
+            sk_sp<GrSurfaceProxy> sProxy(proxyProvider->wrapBackendRenderTarget(
+                    backendRT, grColorType, nullptr, nullptr));
+            check_surface(reporter, sProxy.get(), kWidthHeight, kWidthHeight, SkBudgeted::kNo);
+            static constexpr int kExpectedNumSamples = 1;
+            check_rendertarget(reporter, caps, resourceProvider, sProxy->asRenderTargetProxy(),
+                               kExpectedNumSamples, SkBackingFit::kExact,
+                               caps.maxWindowRectangles());
+            gpu->deleteTestingOnlyBackendRenderTarget(backendRT);
+        }
+
+        for (auto numSamples : {1, 4}) {
+            auto beFormat = caps.getDefaultBackendFormat(grColorType, GrRenderable::kYes);
+            int supportedNumSamples = caps.getRenderTargetSampleCount(numSamples, beFormat);
+            if (!supportedNumSamples) {
+                continue;
             }
 
-            for (auto numSamples : {1, 4}) {
-                auto beFormat = caps.getDefaultBackendFormat(grColorType, GrRenderable::kYes);
-                int supportedNumSamples = caps.getRenderTargetSampleCount(numSamples, beFormat);
-                if (!supportedNumSamples) {
+#ifdef SK_GL
+            // Test wrapping FBO 0 (with made up properties). This tests sample count and the
+            // special case where FBO 0 doesn't support window rectangles.
+            if (GrBackendApi::kOpenGL == ctxInfo.backend()) {
+                GrGLFramebufferInfo fboInfo;
+                fboInfo.fFBOID = 0;
+                fboInfo.fFormat = GrGLFormatToEnum(beFormat.asGLFormat());
+                SkASSERT(fboInfo.fFormat);
+                static constexpr int kStencilBits = 8;
+                GrBackendRenderTarget backendRT(kWidthHeight, kWidthHeight, numSamples,
+                                                kStencilBits, fboInfo);
+                sk_sp<GrSurfaceProxy> sProxy(proxyProvider->wrapBackendRenderTarget(
+                        backendRT, grColorType, nullptr, nullptr));
+                check_surface(reporter, sProxy.get(), kWidthHeight, kWidthHeight, SkBudgeted::kNo);
+                check_rendertarget(reporter, caps, resourceProvider, sProxy->asRenderTargetProxy(),
+                                   supportedNumSamples, SkBackingFit::kExact, 0);
+            }
+#endif
+
+            // Tests wrapBackendRenderTarget with a GrBackendTexture
+            {
+                GrBackendTexture backendTex = context->createBackendTexture(
+                        kWidthHeight, kWidthHeight, colorType, SkColors::kTransparent,
+                        GrMipMapped::kNo, GrRenderable::kYes, GrProtected::kNo);
+                sk_sp<GrSurfaceProxy> sProxy = proxyProvider->wrapBackendTextureAsRenderTarget(
+                        backendTex, grColorType, supportedNumSamples);
+                if (!sProxy) {
+                    context->deleteBackendTexture(backendTex);
+                    continue;  // This can fail on Mesa
+                }
+
+                check_surface(reporter, sProxy.get(), kWidthHeight, kWidthHeight, SkBudgeted::kNo);
+                check_rendertarget(reporter, caps, resourceProvider, sProxy->asRenderTargetProxy(),
+                                   supportedNumSamples, SkBackingFit::kExact,
+                                   caps.maxWindowRectangles());
+
+                context->deleteBackendTexture(backendTex);
+            }
+
+            // Tests wrapBackendTexture that is only renderable
+            {
+                GrBackendTexture backendTex = context->createBackendTexture(
+                        kWidthHeight, kWidthHeight, colorType, SkColors::kTransparent,
+                        GrMipMapped::kNo, GrRenderable::kYes, GrProtected::kNo);
+
+                sk_sp<GrSurfaceProxy> sProxy = proxyProvider->wrapRenderableBackendTexture(
+                        backendTex, supportedNumSamples, grColorType, kBorrow_GrWrapOwnership,
+                        GrWrapCacheable::kNo, nullptr, nullptr);
+                if (!sProxy) {
+                    context->deleteBackendTexture(backendTex);
+                    continue;  // This can fail on Mesa
+                }
+
+                check_surface(reporter, sProxy.get(), kWidthHeight, kWidthHeight, SkBudgeted::kNo);
+                check_rendertarget(reporter, caps, resourceProvider, sProxy->asRenderTargetProxy(),
+                                   supportedNumSamples, SkBackingFit::kExact,
+                                   caps.maxWindowRectangles());
+
+                context->deleteBackendTexture(backendTex);
+            }
+
+            // Tests wrapBackendTexture that is only textureable
+            {
+                // Internal offscreen texture
+                GrBackendTexture backendTex = context->createBackendTexture(
+                        kWidthHeight, kWidthHeight, colorType, SkColors::kTransparent,
+                        GrMipMapped::kNo, GrRenderable::kNo, GrProtected::kNo);
+
+                sk_sp<GrSurfaceProxy> sProxy = proxyProvider->wrapBackendTexture(
+                        backendTex, grColorType, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
+                        kRead_GrIOType);
+                if (!sProxy) {
+                    context->deleteBackendTexture(backendTex);
                     continue;
                 }
 
-#ifdef SK_GL
-                // Test wrapping FBO 0 (with made up properties). This tests sample count and the
-                // special case where FBO 0 doesn't support window rectangles.
-                if (GrBackendApi::kOpenGL == ctxInfo.backend()) {
-                    GrGLFramebufferInfo fboInfo;
-                    fboInfo.fFBOID = 0;
-                    fboInfo.fFormat = GrGLFormatToEnum(beFormat.asGLFormat());
-                    SkASSERT(fboInfo.fFormat);
-                    static constexpr int kStencilBits = 8;
-                    GrBackendRenderTarget backendRT(kWidthHeight, kWidthHeight, numSamples,
-                                                    kStencilBits, fboInfo);
-                    sk_sp<GrSurfaceProxy> sProxy(
-                            proxyProvider->wrapBackendRenderTarget(backendRT, grColorType,
-                                                                   origin, nullptr, nullptr));
-                    check_surface(reporter, sProxy.get(), kWidthHeight, kWidthHeight,
-                                  SkBudgeted::kNo);
-                    check_rendertarget(reporter, caps, resourceProvider,
-                                       sProxy->asRenderTargetProxy(),
-                                       supportedNumSamples, SkBackingFit::kExact, 0);
-                }
-#endif
+                check_surface(reporter, sProxy.get(), kWidthHeight, kWidthHeight, SkBudgeted::kNo);
+                check_texture(reporter, resourceProvider, sProxy->asTextureProxy(),
+                              SkBackingFit::kExact);
 
-                // Tests wrapBackendRenderTarget with a GrBackendTexture
-                {
-                    GrBackendTexture backendTex =
-                            context->createBackendTexture(kWidthHeight, kWidthHeight,
-                                                          colorType,
-                                                          SkColors::kTransparent,
-                                                          GrMipMapped::kNo,
-                                                          GrRenderable::kYes,
-                                                          GrProtected::kNo);
-                    sk_sp<GrSurfaceProxy> sProxy = proxyProvider->wrapBackendTextureAsRenderTarget(
-                            backendTex, grColorType, origin, supportedNumSamples);
-                    if (!sProxy) {
-                        context->deleteBackendTexture(backendTex);
-                        continue;  // This can fail on Mesa
-                    }
-
-                    check_surface(reporter, sProxy.get(), kWidthHeight, kWidthHeight,
-                                  SkBudgeted::kNo);
-                    check_rendertarget(reporter, caps, resourceProvider,
-                                       sProxy->asRenderTargetProxy(),
-                                       supportedNumSamples, SkBackingFit::kExact,
-                                       caps.maxWindowRectangles());
-
-                    context->deleteBackendTexture(backendTex);
-                }
-
-                // Tests wrapBackendTexture that is only renderable
-                {
-                    GrBackendTexture backendTex =
-                            context->createBackendTexture(kWidthHeight, kWidthHeight,
-                                                          colorType,
-                                                          SkColors::kTransparent,
-                                                          GrMipMapped::kNo,
-                                                          GrRenderable::kYes,
-                                                          GrProtected::kNo);
-
-                    sk_sp<GrSurfaceProxy> sProxy = proxyProvider->wrapRenderableBackendTexture(
-                            backendTex, origin, supportedNumSamples,
-                            grColorType, kBorrow_GrWrapOwnership,
-                            GrWrapCacheable::kNo, nullptr, nullptr);
-                    if (!sProxy) {
-                        context->deleteBackendTexture(backendTex);
-                        continue;  // This can fail on Mesa
-                    }
-
-                    check_surface(reporter, sProxy.get(), kWidthHeight, kWidthHeight,
-                                  SkBudgeted::kNo);
-                    check_rendertarget(reporter, caps, resourceProvider,
-                                       sProxy->asRenderTargetProxy(),
-                                       supportedNumSamples, SkBackingFit::kExact,
-                                       caps.maxWindowRectangles());
-
-                    context->deleteBackendTexture(backendTex);
-                }
-
-                // Tests wrapBackendTexture that is only textureable
-                {
-                    // Internal offscreen texture
-                    GrBackendTexture backendTex =
-                            context->createBackendTexture(kWidthHeight, kWidthHeight,
-                                                          colorType,
-                                                          SkColors::kTransparent,
-                                                          GrMipMapped::kNo,
-                                                          GrRenderable::kNo,
-                                                          GrProtected::kNo);
-
-                    sk_sp<GrSurfaceProxy> sProxy = proxyProvider->wrapBackendTexture(
-                            backendTex, grColorType, origin, kBorrow_GrWrapOwnership,
-                            GrWrapCacheable::kNo, kRead_GrIOType);
-                    if (!sProxy) {
-                        context->deleteBackendTexture(backendTex);
-                        continue;
-                    }
-
-                    check_surface(reporter, sProxy.get(), kWidthHeight, kWidthHeight,
-                                  SkBudgeted::kNo);
-                    check_texture(reporter, resourceProvider, sProxy->asTextureProxy(),
-                                  SkBackingFit::kExact);
-
-                    context->deleteBackendTexture(backendTex);
-                }
+                context->deleteBackendTexture(backendTex);
             }
         }
     }
@@ -372,10 +345,9 @@
                     GrSwizzle swizzle = context->priv().caps()->getReadSwizzle(
                             format, GrColorType::kRGBA_8888);
 
-                    sk_sp<GrTextureProxy> proxy =
-                            provider->createProxy(format, {width, height}, swizzle, renderable, 1,
-                                                  kBottomLeft_GrSurfaceOrigin, GrMipMapped::kNo,
-                                                  fit, SkBudgeted::kNo, GrProtected::kNo);
+                    sk_sp<GrTextureProxy> proxy = provider->createProxy(
+                            format, {width, height}, swizzle, renderable, 1, GrMipMapped::kNo, fit,
+                            SkBudgeted::kNo, GrProtected::kNo);
                     REPORTER_ASSERT(reporter, !proxy);
                 }
             }
diff --git a/tests/RectangleTextureTest.cpp b/tests/RectangleTextureTest.cpp
index 2070d53..d30cf89 100644
--- a/tests/RectangleTextureTest.cpp
+++ b/tests/RectangleTextureTest.cpp
@@ -167,8 +167,8 @@
         }
 
         sk_sp<GrTextureProxy> rectProxy = proxyProvider->wrapBackendTexture(
-                rectangleTex, GrColorType::kRGBA_8888, origin,
-                kBorrow_GrWrapOwnership, GrWrapCacheable::kNo, kRW_GrIOType);
+                rectangleTex, GrColorType::kRGBA_8888, kBorrow_GrWrapOwnership,
+                GrWrapCacheable::kNo, kRW_GrIOType);
 
         if (!rectProxy) {
             ERRORF(reporter, "Error creating proxy for rectangle texture.");
diff --git a/tests/ResourceAllocatorTest.cpp b/tests/ResourceAllocatorTest.cpp
index ef9039a..af24b24 100644
--- a/tests/ResourceAllocatorTest.cpp
+++ b/tests/ResourceAllocatorTest.cpp
@@ -26,7 +26,6 @@
     GrColorType     fColorType;
     SkBackingFit    fFit;
     int             fSampleCnt;
-    GrSurfaceOrigin fOrigin;
     SkBudgeted      fBudgeted;
     // TODO: do we care about mipmapping
 };
@@ -37,8 +36,8 @@
     GrSwizzle swizzle = caps->getReadSwizzle(format, p.fColorType);
 
     return proxyProvider->createProxy(format, {p.fSize, p.fSize}, swizzle, p.fRenderable,
-                                      p.fSampleCnt, p.fOrigin, GrMipMapped::kNo, p.fFit,
-                                      p.fBudgeted, GrProtected::kNo);
+                                      p.fSampleCnt, GrMipMapped::kNo, p.fFit, p.fBudgeted,
+                                      GrProtected::kNo);
 }
 
 static sk_sp<GrSurfaceProxy> make_backend(GrContext* context, const ProxyParams& p,
@@ -56,9 +55,8 @@
         return nullptr;
     }
 
-    return proxyProvider->wrapBackendTexture(*backendTex, p.fColorType, p.fOrigin,
-                                             kBorrow_GrWrapOwnership, GrWrapCacheable::kNo,
-                                             kRead_GrIOType);
+    return proxyProvider->wrapBackendTexture(*backendTex, p.fColorType, kBorrow_GrWrapOwnership,
+                                             GrWrapCacheable::kNo, kRead_GrIOType);
 }
 
 static void cleanup_backend(GrContext* context, const GrBackendTexture& backendTex) {
@@ -147,19 +145,16 @@
     const SkBackingFit kE = SkBackingFit::kExact;
     const SkBackingFit kA = SkBackingFit::kApprox;
 
-    const GrSurfaceOrigin kTL = kTopLeft_GrSurfaceOrigin;
-    const GrSurfaceOrigin kBL = kBottomLeft_GrSurfaceOrigin;
-
     const SkBudgeted kNotB = SkBudgeted::kNo;
 
     //--------------------------------------------------------------------------------------------
     TestCase gOverlappingTests[] = {
-        //----------------------------------------------------------------------------------------
-        // Two proxies with overlapping intervals and compatible descriptors should never share
-        // RT version
-        { { 64,    kRT, kRGBA, kA, 1, kTL, kNotB }, { 64,    kRT, kRGBA, kA, 1, kTL, kNotB }, kDontShare },
-        // non-RT version
-        { { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, kDontShare },
+            //----------------------------------------------------------------------------------------
+            // Two proxies with overlapping intervals and compatible descriptors should never share
+            // RT version
+            {{64, kRT, kRGBA, kA, 1, kNotB}, {64, kRT, kRGBA, kA, 1, kNotB}, kDontShare},
+            // non-RT version
+            {{64, kNotRT, kRGBA, kA, 1, kNotB}, {64, kNotRT, kRGBA, kA, 1, kNotB}, kDontShare},
     };
 
     for (auto test : gOverlappingTests) {
@@ -174,31 +169,37 @@
 
     //--------------------------------------------------------------------------------------------
     TestCase gNonOverlappingTests[] = {
-        //----------------------------------------------------------------------------------------
-        // Two non-overlapping intervals w/ compatible proxies should share
-        // both same size & approx
-        { { 64,    kRT, kRGBA, kA, 1, kTL, kNotB }, { 64,    kRT, kRGBA, kA, 1, kTL, kNotB }, kShare },
-        { { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, kConditionallyShare },
-        // diffs sizes but still approx
-        { { 64,    kRT, kRGBA, kA, 1, kTL, kNotB }, { 50,    kRT, kRGBA, kA, 1, kTL, kNotB }, kShare },
-        { { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, { 50, kNotRT, kRGBA, kA, 1, kTL, kNotB }, kConditionallyShare },
-        // sames sizes but exact
-        { { 64,    kRT, kRGBA, kE, 1, kTL, kNotB }, { 64,    kRT, kRGBA, kE, 1, kTL, kNotB }, kShare },
-        { { 64, kNotRT, kRGBA, kE, 1, kTL, kNotB }, { 64, kNotRT, kRGBA, kE, 1, kTL, kNotB }, kConditionallyShare },
-        //----------------------------------------------------------------------------------------
-        // Two non-overlapping intervals w/ different exact sizes should not share
-        { { 56,    kRT, kRGBA, kE, 1, kTL, kNotB }, { 54,    kRT, kRGBA, kE, 1, kTL, kNotB }, kDontShare },
-        // Two non-overlapping intervals w/ _very different_ approx sizes should not share
-        { { 255,   kRT, kRGBA, kA, 1, kTL, kNotB }, { 127,   kRT, kRGBA, kA, 1, kTL, kNotB }, kDontShare },
-        // Two non-overlapping intervals w/ different MSAA sample counts should not share
-        { { 64,    kRT, kRGBA, kA, k2, kTL, kNotB },{ 64,    kRT, kRGBA, kA, k4,kTL, kNotB}, k2 == k4 },
-        // Two non-overlapping intervals w/ different configs should not share
-        { { 64,    kRT, kRGBA, kA, 1, kTL, kNotB }, { 64,    kRT, kAlpha, kA, 1, kTL, kNotB }, kDontShare },
-        // Two non-overlapping intervals w/ different RT classifications should never share
-        { { 64,    kRT, kRGBA, kA, 1, kTL, kNotB }, { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, kDontShare },
-        { { 64, kNotRT, kRGBA, kA, 1, kTL, kNotB }, { 64,    kRT, kRGBA, kA, 1, kTL, kNotB }, kDontShare },
-        // Two non-overlapping intervals w/ different origins should share
-        { { 64,    kRT, kRGBA, kA, 1, kTL, kNotB }, { 64,    kRT, kRGBA, kA, 1, kBL, kNotB }, kShare },
+            //----------------------------------------------------------------------------------------
+            // Two non-overlapping intervals w/ compatible proxies should share
+            // both same size & approx
+            {{64, kRT, kRGBA, kA, 1, kNotB}, {64, kRT, kRGBA, kA, 1, kNotB}, kShare},
+            {{64, kNotRT, kRGBA, kA, 1, kNotB},
+             {64, kNotRT, kRGBA, kA, 1, kNotB},
+             kConditionallyShare},
+            // diffs sizes but still approx
+            {{64, kRT, kRGBA, kA, 1, kNotB}, {50, kRT, kRGBA, kA, 1, kNotB}, kShare},
+            {{64, kNotRT, kRGBA, kA, 1, kNotB},
+             {50, kNotRT, kRGBA, kA, 1, kNotB},
+             kConditionallyShare},
+            // sames sizes but exact
+            {{64, kRT, kRGBA, kE, 1, kNotB}, {64, kRT, kRGBA, kE, 1, kNotB}, kShare},
+            {{64, kNotRT, kRGBA, kE, 1, kNotB},
+             {64, kNotRT, kRGBA, kE, 1, kNotB},
+             kConditionallyShare},
+            //----------------------------------------------------------------------------------------
+            // Two non-overlapping intervals w/ different exact sizes should not share
+            {{56, kRT, kRGBA, kE, 1, kNotB}, {54, kRT, kRGBA, kE, 1, kNotB}, kDontShare},
+            // Two non-overlapping intervals w/ _very different_ approx sizes should not share
+            {{255, kRT, kRGBA, kA, 1, kNotB}, {127, kRT, kRGBA, kA, 1, kNotB}, kDontShare},
+            // Two non-overlapping intervals w/ different MSAA sample counts should not share
+            {{64, kRT, kRGBA, kA, k2, kNotB}, {64, kRT, kRGBA, kA, k4, kNotB}, k2 == k4},
+            // Two non-overlapping intervals w/ different configs should not share
+            {{64, kRT, kRGBA, kA, 1, kNotB}, {64, kRT, kAlpha, kA, 1, kNotB}, kDontShare},
+            // Two non-overlapping intervals w/ different RT classifications should never share
+            {{64, kRT, kRGBA, kA, 1, kNotB}, {64, kNotRT, kRGBA, kA, 1, kNotB}, kDontShare},
+            {{64, kNotRT, kRGBA, kA, 1, kNotB}, {64, kRT, kRGBA, kA, 1, kNotB}, kDontShare},
+            // Two non-overlapping intervals w/ different origins should share
+            {{64, kRT, kRGBA, kA, 1, kNotB}, {64, kRT, kRGBA, kA, 1, kNotB}, kShare},
     };
 
     for (auto test : gNonOverlappingTests) {
@@ -216,8 +217,7 @@
     {
         // Wrapped backend textures should never be reused
         TestCase t[1] = {
-            { { 64, kNotRT, kRGBA, kE, 1, kTL, kNotB }, { 64, kNotRT, kRGBA, kE, 1, kTL, kNotB }, kDontShare }
-        };
+                {{64, kNotRT, kRGBA, kE, 1, kNotB}, {64, kNotRT, kRGBA, kE, 1, kNotB}, kDontShare}};
 
         GrBackendTexture backEndTex;
         sk_sp<GrSurfaceProxy> p1 = make_backend(ctxInfo.grContext(), t[0].fP1, &backEndTex);
@@ -279,9 +279,9 @@
     GrInternalSurfaceFlags flags = GrInternalSurfaceFlags::kNone;
     GrSwizzle readSwizzle = caps->getReadSwizzle(format, p.fColorType);
     return proxyProvider->createLazyProxy(
-            callback, format, dims, readSwizzle, p.fRenderable, p.fSampleCnt, p.fOrigin,
-            GrMipMapped::kNo, GrMipMapsStatus::kNotAllocated, flags, p.fFit, p.fBudgeted,
-            GrProtected::kNo, GrSurfaceProxy::UseAllocator::kYes);
+            callback, format, dims, readSwizzle, p.fRenderable, p.fSampleCnt, GrMipMapped::kNo,
+            GrMipMapsStatus::kNotAllocated, flags, p.fFit, p.fBudgeted, GrProtected::kNo,
+            GrSurfaceProxy::UseAllocator::kYes);
 }
 
 // Set up so there are two opsTasks that need to be flushed but the resource allocator thinks
@@ -298,9 +298,9 @@
     // Force the resource allocator to always believe it is over budget
     context->setResourceCacheLimit(0);
 
-    const ProxyParams params  = { 64, GrRenderable::kNo, GrColorType::kRGBA_8888,
-                                  SkBackingFit::kExact, 1, kTopLeft_GrSurfaceOrigin,
-                                  SkBudgeted::kYes };
+    const ProxyParams params = {
+            64, GrRenderable::kNo, GrColorType::kRGBA_8888, SkBackingFit::kExact,
+            1,  SkBudgeted::kYes};
 
     {
         sk_sp<GrSurfaceProxy> p1 = make_deferred(proxyProvider, caps, params);
@@ -358,7 +358,6 @@
 
     ProxyParams params;
     params.fFit = SkBackingFit::kExact;
-    params.fOrigin = kTopLeft_GrSurfaceOrigin;
     params.fColorType = GrColorType::kRGBA_8888;
     params.fRenderable = GrRenderable::kYes;
     params.fSampleCnt = 1;
diff --git a/tests/ResourceCacheTest.cpp b/tests/ResourceCacheTest.cpp
index 3eb5308..bc9bb18 100644
--- a/tests/ResourceCacheTest.cpp
+++ b/tests/ResourceCacheTest.cpp
@@ -1624,11 +1624,9 @@
 
     const GrBackendFormat format = caps->getDefaultBackendFormat(GrColorType::kRGBA_8888,
                                                                  GrRenderable::kNo);
-    auto origin = renderable == GrRenderable::kYes ? kBottomLeft_GrSurfaceOrigin
-                                                   : kTopLeft_GrSurfaceOrigin;
     GrSwizzle swizzle = caps->getReadSwizzle(format, GrColorType::kRGBA_8888);
 
-    return proxyProvider->createProxy(format, dims, swizzle, renderable, sampleCnt, origin,
+    return proxyProvider->createProxy(format, dims, swizzle, renderable, sampleCnt,
                                       GrMipMapped::kYes, SkBackingFit::kExact, SkBudgeted::kYes,
                                       GrProtected::kNo);
 }
diff --git a/tests/TextureProxyTest.cpp b/tests/TextureProxyTest.cpp
index 1a503eb..8f70e68 100644
--- a/tests/TextureProxyTest.cpp
+++ b/tests/TextureProxyTest.cpp
@@ -37,9 +37,9 @@
     GrBackendFormat format = caps->getDefaultBackendFormat(kColorType, GrRenderable::kNo);
     GrSwizzle swizzle = caps->getReadSwizzle(format, kColorType);
 
-    sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
-            format, kSize, swizzle, GrRenderable::kNo, 1, kBottomLeft_GrSurfaceOrigin,
-            GrMipMapped::kNo, fit, SkBudgeted::kYes, GrProtected::kNo);
+    sk_sp<GrTextureProxy> proxy =
+            proxyProvider->createProxy(format, kSize, swizzle, GrRenderable::kNo, 1,
+                                       GrMipMapped::kNo, fit, SkBudgeted::kYes, GrProtected::kNo);
     // Only budgeted & wrapped external proxies get to carry uniqueKeys
     REPORTER_ASSERT(reporter, !proxy->getUniqueKey().isValid());
     return proxy;
@@ -52,9 +52,9 @@
     GrBackendFormat format = caps->getDefaultBackendFormat(kColorType, GrRenderable::kYes);
     GrSwizzle swizzle = caps->getReadSwizzle(format, kColorType);
 
-    sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
-            format, kSize, swizzle, GrRenderable::kYes, 1, kBottomLeft_GrSurfaceOrigin,
-            GrMipMapped::kNo, fit, SkBudgeted::kYes, GrProtected::kNo);
+    sk_sp<GrTextureProxy> proxy =
+            proxyProvider->createProxy(format, kSize, swizzle, GrRenderable::kYes, 1,
+                                       GrMipMapped::kNo, fit, SkBudgeted::kYes, GrProtected::kNo);
     // Only budgeted & wrapped external proxies get to carry uniqueKeys
     REPORTER_ASSERT(reporter, !proxy->getUniqueKey().isValid());
     return proxy;
@@ -63,8 +63,7 @@
 static sk_sp<GrTextureProxy> wrapped(skiatest::Reporter* reporter, GrContext* ctx,
                                      GrProxyProvider* proxyProvider, SkBackingFit fit) {
     sk_sp<GrTextureProxy> proxy = proxyProvider->testingOnly_createInstantiatedProxy(
-            kSize, kColorType, GrRenderable::kNo, 1, kBottomLeft_GrSurfaceOrigin, fit,
-            SkBudgeted::kYes, GrProtected::kNo);
+            kSize, kColorType, GrRenderable::kNo, 1, fit, SkBudgeted::kYes, GrProtected::kNo);
     // Only budgeted & wrapped external proxies get to carry uniqueKeys
     REPORTER_ASSERT(reporter, !proxy->getUniqueKey().isValid());
     return proxy;
@@ -83,8 +82,7 @@
 
     // Only budgeted & wrapped external proxies get to carry uniqueKeys
     sk_sp<GrTextureProxy> proxy = proxyProvider->testingOnly_createInstantiatedProxy(
-            kSize, kColorType, GrRenderable::kNo, 1, kBottomLeft_GrSurfaceOrigin, fit,
-            SkBudgeted::kYes, GrProtected::kNo);
+            kSize, kColorType, GrRenderable::kNo, 1, fit, SkBudgeted::kYes, GrProtected::kNo);
     SkAssertResult(proxyProvider->assignUniqueKeyToProxy(key, proxy.get()));
     REPORTER_ASSERT(reporter, proxy->getUniqueKey().isValid());
     return proxy;
@@ -108,8 +106,8 @@
     GrBackendTexture backendTex = (*backingSurface)->getBackendTexture();
 
     return proxyProvider->wrapBackendTexture(backendTex, GrColorType::kRGBA_8888,
-                                             kBottomLeft_GrSurfaceOrigin, kBorrow_GrWrapOwnership,
-                                             GrWrapCacheable::kYes, kRead_GrIOType);
+                                             kBorrow_GrWrapOwnership, GrWrapCacheable::kYes,
+                                             kRead_GrIOType);
 }
 
 
@@ -145,8 +143,7 @@
     REPORTER_ASSERT(reporter, key == proxy->getUniqueKey());
 
     // We just added it, surely we can find it
-    REPORTER_ASSERT(reporter, proxyProvider->findOrCreateProxyByUniqueKey(
-                                      key, kColorType, kBottomLeft_GrSurfaceOrigin));
+    REPORTER_ASSERT(reporter, proxyProvider->findOrCreateProxyByUniqueKey(key, kColorType));
     REPORTER_ASSERT(reporter, 1 == proxyProvider->numUniqueKeyProxies_TestOnly());
 
     int expectedCacheCount = startCacheCount + (proxy->isInstantiated() ? 0 : 1);
@@ -177,8 +174,7 @@
     REPORTER_ASSERT(reporter, expectedCacheCount == cache->getResourceCount());
 
     // If the proxy was cached refinding it should bring it back to life
-    proxy = proxyProvider->findOrCreateProxyByUniqueKey(key, kColorType,
-                                                        kBottomLeft_GrSurfaceOrigin);
+    proxy = proxyProvider->findOrCreateProxyByUniqueKey(key, kColorType);
     REPORTER_ASSERT(reporter, proxy);
     REPORTER_ASSERT(reporter, 1 == proxyProvider->numUniqueKeyProxies_TestOnly());
     REPORTER_ASSERT(reporter, expectedCacheCount == cache->getResourceCount());
@@ -193,8 +189,7 @@
 
     // If the texture was deleted then the proxy should no longer be findable. Otherwise, it should
     // be.
-    proxy = proxyProvider->findOrCreateProxyByUniqueKey(key, kColorType,
-                                                        kBottomLeft_GrSurfaceOrigin);
+    proxy = proxyProvider->findOrCreateProxyByUniqueKey(key, kColorType);
     REPORTER_ASSERT(reporter, expectResourceToOutliveProxy ? (bool)proxy : !proxy);
     REPORTER_ASSERT(reporter, expectedCacheCount == cache->getResourceCount());
 
@@ -204,8 +199,7 @@
         SkMessageBus<GrUniqueKeyInvalidatedMessage>::Post(msg);
         cache->purgeAsNeeded();
         expectedCacheCount--;
-        proxy = proxyProvider->findOrCreateProxyByUniqueKey(key, kColorType,
-                                                            kBottomLeft_GrSurfaceOrigin);
+        proxy = proxyProvider->findOrCreateProxyByUniqueKey(key, kColorType);
         REPORTER_ASSERT(reporter, !proxy);
         REPORTER_ASSERT(reporter, expectedCacheCount == cache->getResourceCount());
     }
diff --git a/tests/WritePixelsTest.cpp b/tests/WritePixelsTest.cpp
index c11bd69..92cb71c 100644
--- a/tests/WritePixelsTest.cpp
+++ b/tests/WritePixelsTest.cpp
@@ -531,8 +531,8 @@
         GrSwizzle swizzle = caps->getReadSwizzle(format, GrColorType::kRGBA_8888);
 
         sk_sp<GrTextureProxy> temp = proxyProvider->createProxy(
-                format, kDims, swizzle, GrRenderable::kNo, 1, kTopLeft_GrSurfaceOrigin,
-                GrMipMapped::kNo, SkBackingFit::kApprox, SkBudgeted::kYes, GrProtected::kNo);
+                format, kDims, swizzle, GrRenderable::kNo, 1, GrMipMapped::kNo,
+                SkBackingFit::kApprox, SkBudgeted::kYes, GrProtected::kNo);
         temp->instantiate(context->priv().resourceProvider());
     }
 
diff --git a/tools/gpu/ProxyUtils.cpp b/tools/gpu/ProxyUtils.cpp
index 1a72f82..f5e93ed 100644
--- a/tools/gpu/ProxyUtils.cpp
+++ b/tools/gpu/ProxyUtils.cpp
@@ -38,7 +38,7 @@
 
     sk_sp<GrTextureProxy> proxy;
     proxy = context->priv().proxyProvider()->createProxy(
-            format, imageInfo.dimensions(), swizzle, renderable, 1, origin, GrMipMapped::kNo,
+            format, imageInfo.dimensions(), swizzle, renderable, 1, GrMipMapped::kNo,
             SkBackingFit::kExact, SkBudgeted::kYes, GrProtected::kNo);
     if (!proxy) {
         return nullptr;