diff --git a/gm/image_pict.cpp b/gm/image_pict.cpp
index 28e0bac..ee610f3 100644
--- a/gm/image_pict.cpp
+++ b/gm/image_pict.cpp
@@ -273,8 +273,8 @@
     }
 
     static void draw_as_tex(SkCanvas* canvas, SkImage* image, SkScalar x, SkScalar y) {
-        GrSurfaceProxyView view = as_IB(image)->refView(canvas->getGrContext(),
-                                                        GrSamplerState::Filter::kBilerp, nullptr);
+        GrSurfaceProxyView view =
+                as_IB(image)->refView(canvas->getGrContext(), GrSamplerState::Filter::kBilerp);
         if (!view) {
             // show placeholder if we have no texture
             SkPaint paint;
diff --git a/src/gpu/GrBitmapTextureMaker.cpp b/src/gpu/GrBitmapTextureMaker.cpp
index e3a9eb5..957aebb 100644
--- a/src/gpu/GrBitmapTextureMaker.cpp
+++ b/src/gpu/GrBitmapTextureMaker.cpp
@@ -122,13 +122,14 @@
     return {};
 }
 
-void GrBitmapTextureMaker::makeCopyKey(const CopyParams& copyParams, GrUniqueKey* copyKey) {
+void GrBitmapTextureMaker::makeMipMappedKey(GrUniqueKey* mipMappedKey) {
     // Destination color space is irrelevant - we always upload the bitmap's contents as-is
     if (fOriginalKey.isValid()) {
-        MakeCopyKeyFromOrigKey(fOriginalKey, copyParams, copyKey);
+        MakeMipMappedKeyFromOriginalKey(fOriginalKey, mipMappedKey);
     }
 }
 
-void GrBitmapTextureMaker::didCacheCopy(const GrUniqueKey& copyKey, uint32_t contextUniqueID) {
-    GrInstallBitmapUniqueKeyInvalidator(copyKey, contextUniqueID, fBitmap.pixelRef());
+void GrBitmapTextureMaker::didCacheMipMappedCopy(const GrUniqueKey& mipMappedKey,
+                                                 uint32_t contextUniqueID) {
+    GrInstallBitmapUniqueKeyInvalidator(mipMappedKey, contextUniqueID, fBitmap.pixelRef());
 }
diff --git a/src/gpu/GrBitmapTextureMaker.h b/src/gpu/GrBitmapTextureMaker.h
index 1090a75..72475ca 100644
--- a/src/gpu/GrBitmapTextureMaker.h
+++ b/src/gpu/GrBitmapTextureMaker.h
@@ -26,8 +26,8 @@
     GrSurfaceProxyView refOriginalTextureProxyView(bool willBeMipped,
                                                    AllowedTexGenType onlyIfFast) override;
 
-    void makeCopyKey(const CopyParams& copyParams, GrUniqueKey* copyKey) override;
-    void didCacheCopy(const GrUniqueKey& copyKey, uint32_t contextUniqueID) override;
+    void makeMipMappedKey(GrUniqueKey* mipMappedKey) override;
+    void didCacheMipMappedCopy(const GrUniqueKey& mipMappedKey, uint32_t contextUniqueID) override;
 
     const SkBitmap     fBitmap;
     const SkBackingFit fFit;
diff --git a/src/gpu/GrGpu.cpp b/src/gpu/GrGpu.cpp
index 65829eb..0eca489 100644
--- a/src/gpu/GrGpu.cpp
+++ b/src/gpu/GrGpu.cpp
@@ -45,61 +45,14 @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
-bool GrGpu::IsACopyNeededForRepeatWrapMode(const GrCaps* caps,
-                                           GrTextureProxy* texProxy,
-                                           SkISize dimensions,
-                                           GrSamplerState::Filter filter,
-                                           GrTextureProducer::CopyParams* copyParams,
-                                           SkScalar scaleAdjust[2]) {
-    if (!caps->npotTextureTileSupport() &&
-        (!SkIsPow2(dimensions.width()) || !SkIsPow2(dimensions.height()))) {
-        SkASSERT(scaleAdjust);
-        copyParams->fDimensions = {SkNextPow2(dimensions.width()), SkNextPow2(dimensions.height())};
-        SkASSERT(scaleAdjust);
-        scaleAdjust[0] = ((SkScalar)copyParams->fDimensions.width()) / dimensions.width();
-        scaleAdjust[1] = ((SkScalar)copyParams->fDimensions.height()) / dimensions.height();
-        switch (filter) {
-        case GrSamplerState::Filter::kNearest:
-            copyParams->fFilter = GrSamplerState::Filter::kNearest;
-            break;
-        case GrSamplerState::Filter::kBilerp:
-        case GrSamplerState::Filter::kMipMap:
-            // We are only ever scaling up so no reason to ever indicate kMipMap.
-            copyParams->fFilter = GrSamplerState::Filter::kBilerp;
-            break;
-        }
-        return true;
-    }
-
-    if (texProxy) {
-        // If the texture format itself doesn't support repeat wrap mode or mipmapping (and
-        // those capabilities are required) force a copy.
-        if (texProxy->hasRestrictedSampling()) {
-            copyParams->fFilter = GrSamplerState::Filter::kNearest;
-            copyParams->fDimensions = texProxy->dimensions();
-            return true;
-        }
-    }
-
-    return false;
-}
-
 bool GrGpu::IsACopyNeededForMips(const GrCaps* caps, const GrTextureProxy* texProxy,
-                                 GrSamplerState::Filter filter,
-                                 GrTextureProducer::CopyParams* copyParams) {
+                                 GrSamplerState::Filter filter) {
     SkASSERT(texProxy);
-    int mipCount = SkMipMap::ComputeLevelCount(texProxy->width(), texProxy->height());
-    bool willNeedMips = GrSamplerState::Filter::kMipMap == filter && caps->mipMapSupport() &&
-            mipCount;
-    // If the texture format itself doesn't support mipmapping (and those capabilities are required)
-    // force a copy.
-    if (willNeedMips && texProxy->mipMapped() == GrMipMapped::kNo) {
-        copyParams->fFilter = GrSamplerState::Filter::kNearest;
-        copyParams->fDimensions = texProxy->dimensions();
-        return true;
+    if (filter != GrSamplerState::Filter::kMipMap || texProxy->mipMapped() == GrMipMapped::kYes ||
+        !caps->mipMapSupport()) {
+        return false;
     }
-
-    return false;
+    return SkMipMap::ComputeLevelCount(texProxy->width(), texProxy->height()) > 0;
 }
 
 static bool validate_texel_levels(SkISize dimensions, GrColorType texelColorType,
diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h
index 5551e6e..6969d41 100644
--- a/src/gpu/GrGpu.h
+++ b/src/gpu/GrGpu.h
@@ -594,22 +594,12 @@
     virtual GrStencilAttachment* createStencilAttachmentForRenderTarget(
             const GrRenderTarget*, int width, int height, int numStencilSamples) = 0;
 
-    // Determines whether a texture will need to be rescaled in order to be used with the
-    // GrSamplerState.
-    static bool IsACopyNeededForRepeatWrapMode(const GrCaps*,
-                                               GrTextureProxy* texProxy,
-                                               SkISize dimensions,
-                                               GrSamplerState::Filter,
-                                               GrTextureProducer::CopyParams*,
-                                               SkScalar scaleAdjust[2]);
-
     // Determines whether a texture will need to be copied because the draw requires mips but the
     // texutre doesn't have any. This call should be only checked if IsACopyNeededForTextureParams
     // fails. If the previous call succeeds, then a copy should be done using those params and the
     // mip mapping requirements will be handled there.
     static bool IsACopyNeededForMips(const GrCaps* caps, const GrTextureProxy* texProxy,
-                                     GrSamplerState::Filter filter,
-                                     GrTextureProducer::CopyParams* copyParams);
+                                     GrSamplerState::Filter filter);
 
     void handleDirtyContext() {
         if (fResetBits) {
diff --git a/src/gpu/GrImageTextureMaker.cpp b/src/gpu/GrImageTextureMaker.cpp
index 8361f6a..f531fed 100644
--- a/src/gpu/GrImageTextureMaker.cpp
+++ b/src/gpu/GrImageTextureMaker.cpp
@@ -39,15 +39,14 @@
                                         onlyIfFast);
 }
 
-void GrImageTextureMaker::makeCopyKey(const CopyParams& stretch, GrUniqueKey* paramsCopyKey) {
+void GrImageTextureMaker::makeMipMappedKey(GrUniqueKey* mipMappedKey) {
     if (fOriginalKey.isValid() && SkImage::kAllow_CachingHint == fCachingHint) {
         GrUniqueKey cacheKey;
         fImage->makeCacheKeyFromOrigKey(fOriginalKey, &cacheKey);
-        MakeCopyKeyFromOrigKey(cacheKey, stretch, paramsCopyKey);
+        MakeMipMappedKeyFromOriginalKey(cacheKey, mipMappedKey);
     }
 }
 
-
 /////////////////////////////////////////////////////////////////////////////////////////////////
 
 GrYUVAImageTextureMaker::GrYUVAImageTextureMaker(GrContext* context, const SkImage* client,
@@ -75,13 +74,13 @@
     }
 }
 
-void GrYUVAImageTextureMaker::makeCopyKey(const CopyParams& stretch, GrUniqueKey* paramsCopyKey) {
+void GrYUVAImageTextureMaker::makeMipMappedKey(GrUniqueKey* mipMappedKey) {
     // TODO: Do we ever want to disable caching?
     if (fOriginalKey.isValid()) {
         GrUniqueKey cacheKey;
         static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
         GrUniqueKey::Builder builder(&cacheKey, fOriginalKey, kDomain, 0, "Image");
-        MakeCopyKeyFromOrigKey(cacheKey, stretch, paramsCopyKey);
+        MakeMipMappedKeyFromOriginalKey(cacheKey, mipMappedKey);
     }
 }
 
diff --git a/src/gpu/GrImageTextureMaker.h b/src/gpu/GrImageTextureMaker.h
index 1bfea5a..87e505d 100644
--- a/src/gpu/GrImageTextureMaker.h
+++ b/src/gpu/GrImageTextureMaker.h
@@ -22,14 +22,12 @@
                         SkImage::CachingHint chint, bool useDecal = false);
 
 private:
-    // TODO: consider overriding this, for the case where the underlying generator might be
-    //       able to efficiently produce a "stretched" texture natively (e.g. picture-backed)
-    //          GrTexture* generateTextureForParams(const CopyParams&) override;
     GrSurfaceProxyView refOriginalTextureProxyView(bool willBeMipped,
                                                    AllowedTexGenType onlyIfFast) override;
 
-    void makeCopyKey(const CopyParams& stretch, GrUniqueKey* paramsCopyKey) override;
-    void didCacheCopy(const GrUniqueKey& copyKey, uint32_t contextUniqueID) override {}
+    void makeMipMappedKey(GrUniqueKey* mipMappedKey) override;
+    void didCacheMipMappedCopy(const GrUniqueKey& mipMappedKey, uint32_t contextUniqueID) override {
+    }
 
     const SkImage_Lazy*     fImage;
     GrUniqueKey             fOriginalKey;
@@ -53,8 +51,9 @@
     GrSurfaceProxyView refOriginalTextureProxyView(bool willBeMipped,
                                                    AllowedTexGenType onlyIfFast) override;
 
-    void makeCopyKey(const CopyParams& stretch, GrUniqueKey* paramsCopyKey) override;
-    void didCacheCopy(const GrUniqueKey& copyKey, uint32_t contextUniqueID) override {}
+    void makeMipMappedKey(GrUniqueKey* mipMappedKey) override;
+    void didCacheMipMappedCopy(const GrUniqueKey& mipMappedKey, uint32_t contextUniqueID) override {
+    }
 
     std::unique_ptr<GrFragmentProcessor> createFragmentProcessor(
         const SkMatrix& textureMatrix,
diff --git a/src/gpu/GrTextureAdjuster.cpp b/src/gpu/GrTextureAdjuster.cpp
index 96b0b64..6d4628a 100644
--- a/src/gpu/GrTextureAdjuster.cpp
+++ b/src/gpu/GrTextureAdjuster.cpp
@@ -22,65 +22,47 @@
         , fOriginal(std::move(original))
         , fUniqueID(uniqueID) {}
 
-void GrTextureAdjuster::makeCopyKey(const CopyParams& params, GrUniqueKey* copyKey) {
+void GrTextureAdjuster::makeMipMappedKey(GrUniqueKey* mipMappedKey) {
     // Destination color space is irrelevant - we already have a texture so we're just sub-setting
     GrUniqueKey baseKey;
     GrMakeKeyFromImageID(&baseKey, fUniqueID, SkIRect::MakeSize(this->dimensions()));
-    MakeCopyKeyFromOrigKey(baseKey, params, copyKey);
+    MakeMipMappedKeyFromOriginalKey(baseKey, mipMappedKey);
 }
 
-void GrTextureAdjuster::didCacheCopy(const GrUniqueKey& copyKey, uint32_t contextUniqueID) {
+void GrTextureAdjuster::didCacheMipMappedCopy(const GrUniqueKey& mipMappedKey,
+                                              uint32_t contextUniqueID) {
     // We don't currently have a mechanism for notifications on Images!
 }
 
-GrSurfaceProxyView GrTextureAdjuster::copy(const CopyParams& copyParams, bool willBeMipped,
-                                           bool copyForMipsOnly) {
+GrSurfaceProxyView GrTextureAdjuster::makeMippedCopy() {
     GrProxyProvider* proxyProvider = this->context()->priv().proxyProvider();
 
     GrUniqueKey key;
-    this->makeCopyKey(copyParams, &key);
+    this->makeMipMappedKey(&key);
     sk_sp<GrTextureProxy> cachedCopy;
     const GrSurfaceProxyView& originalView = this->originalProxyView();
     if (key.isValid()) {
         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.
-            GrSwizzle swizzle = cachedCopy->textureSwizzleDoNotUse();
-            return GrSurfaceProxyView(std::move(cachedCopy), originalView.origin(), swizzle);
+        if (cachedCopy) {
+            return {std::move(cachedCopy), originalView.origin(), originalView.swizzle()};
         }
     }
 
-    GrSurfaceProxyView copyView;
-    if (copyForMipsOnly) {
-        copyView = GrCopyBaseMipMapToTextureProxy(this->context(), originalView.proxy(),
-                                                  originalView.origin(), this->colorType());
-    } else {
-        copyView = CopyOnGpu(this->context(), this->originalProxyViewRef(), this->colorType(),
-                             copyParams, willBeMipped);
+    GrSurfaceProxyView copyView = GrCopyBaseMipMapToTextureProxy(
+            this->context(), originalView.proxy(), originalView.origin(), this->colorType());
+    if (!copyView) {
+        return {};
     }
-    if (copyView.proxy()) {
-        if (key.isValid()) {
-            SkASSERT(copyView.origin() == originalView.origin());
-            if (cachedCopy) {
-                SkASSERT(GrMipMapped::kYes == copyView.asTextureProxy()->mipMapped() &&
-                         GrMipMapped::kNo == cachedCopy->mipMapped());
-                // If we had a cachedProxy, that means there already is a proxy in the cache which
-                // matches the key, but it does not have mip levels and we require them. Thus we
-                // must remove the unique key from that proxy.
-                SkASSERT(cachedCopy->getUniqueKey() == key);
-                proxyProvider->removeUniqueKeyFromProxy(cachedCopy.get());
-            }
-            proxyProvider->assignUniqueKeyToProxy(key, copyView.asTextureProxy());
-            this->didCacheCopy(key, proxyProvider->contextID());
-        }
+    if (key.isValid()) {
+        SkASSERT(copyView.origin() == originalView.origin());
+        proxyProvider->assignUniqueKeyToProxy(key, copyView.asTextureProxy());
+        this->didCacheMipMappedCopy(key, proxyProvider->contextID());
     }
     return copyView;
 }
 
 GrSurfaceProxyView GrTextureAdjuster::onRefTextureProxyViewForParams(GrSamplerState params,
-                                                                     bool willBeMipped,
-                                                                     SkScalar scaleAdjust[2]) {
+                                                                     bool willBeMipped) {
     if (this->context()->priv().abandoned()) {
         // The texture was abandoned.
         return {};
@@ -92,51 +74,32 @@
     GrSurfaceProxyView view = this->originalProxyViewRef();
     GrTextureProxy* texProxy = view.asTextureProxy();
     SkASSERT(texProxy);
-    CopyParams copyParams;
-
-    bool needsCopyForMipsOnly = false;
-    if (!params.isRepeated() ||
-        !GrGpu::IsACopyNeededForRepeatWrapMode(this->context()->priv().caps(), texProxy,
-                                               texProxy->dimensions(), params.filter(), &copyParams,
-                                               scaleAdjust)) {
-        needsCopyForMipsOnly = GrGpu::IsACopyNeededForMips(this->context()->priv().caps(),
-                                                           texProxy, params.filter(),
-                                                           &copyParams);
-        if (!needsCopyForMipsOnly) {
-            return view;
-        }
+    if (!GrGpu::IsACopyNeededForMips(this->context()->priv().caps(), texProxy, params.filter())) {
+        return view;
     }
 
-    GrSurfaceProxyView result = this->copy(copyParams, willBeMipped, needsCopyForMipsOnly);
-    if (!result.proxy() && needsCopyForMipsOnly) {
+    GrSurfaceProxyView copy = this->makeMippedCopy();
+    if (!copy) {
         // If we were unable to make a copy and we only needed a copy for mips, then we will return
         // the source texture here and require that the GPU backend is able to fall back to using
         // bilerp if mips are required.
         return view;
     }
-    SkASSERT(result.asTextureProxy());
-    return result;
+    SkASSERT(copy.asTextureProxy());
+    return copy;
 }
 
 std::unique_ptr<GrFragmentProcessor> GrTextureAdjuster::createFragmentProcessor(
-        const SkMatrix& origTextureMatrix,
+        const SkMatrix& textureMatrix,
         const SkRect& constraintRect,
         FilterConstraint filterConstraint,
         bool coordsLimitedToConstraintRect,
         const GrSamplerState::Filter* filterOrNullForBicubic) {
-    SkMatrix textureMatrix = origTextureMatrix;
-
-    SkScalar scaleAdjust[2] = { 1.0f, 1.0f };
-    GrSurfaceProxyView view = this->viewForParams(filterOrNullForBicubic, scaleAdjust);
-    if (!view.proxy()) {
+    GrSurfaceProxyView view = this->viewForParams(filterOrNullForBicubic);
+    if (!view) {
         return nullptr;
     }
     SkASSERT(view.asTextureProxy());
-    // If we made a copy then we only copied the contentArea, in which case the new texture is all
-    // content.
-    if (view.proxy() != this->originalProxyView().proxy()) {
-        textureMatrix.postScale(scaleAdjust[0], scaleAdjust[1]);
-    }
 
     SkRect domain;
     DomainMode domainMode =
diff --git a/src/gpu/GrTextureAdjuster.h b/src/gpu/GrTextureAdjuster.h
index bb34c5d..d52e517 100644
--- a/src/gpu/GrTextureAdjuster.h
+++ b/src/gpu/GrTextureAdjuster.h
@@ -33,17 +33,16 @@
                       uint32_t uniqueID, bool useDecal = false);
 
 protected:
-    void makeCopyKey(const CopyParams& params, GrUniqueKey* copyKey) override;
-    void didCacheCopy(const GrUniqueKey& copyKey, uint32_t contextUniqueID) override;
+    void makeMipMappedKey(GrUniqueKey* mipMappedKey) override;
+    void didCacheMipMappedCopy(const GrUniqueKey& mipMappedKey, uint32_t contextUniqueID) override;
 
     const GrSurfaceProxyView& originalProxyView() const { return fOriginal; }
     GrSurfaceProxyView originalProxyViewRef() const { return fOriginal; }
 
 private:
-    GrSurfaceProxyView onRefTextureProxyViewForParams(GrSamplerState, bool willBeMipped,
-                                                      SkScalar scaleAdjust[2]) override;
+    GrSurfaceProxyView onRefTextureProxyViewForParams(GrSamplerState, bool willBeMipped) override;
 
-    GrSurfaceProxyView copy(const CopyParams& copyParams, bool willBeMipped, bool copyOnlyForMips);
+    GrSurfaceProxyView makeMippedCopy();
 
     GrSurfaceProxyView fOriginal;
     uint32_t fUniqueID;
diff --git a/src/gpu/GrTextureMaker.cpp b/src/gpu/GrTextureMaker.cpp
index 17200f2..d9e89c2 100644
--- a/src/gpu/GrTextureMaker.cpp
+++ b/src/gpu/GrTextureMaker.cpp
@@ -14,102 +14,66 @@
 #include "src/gpu/GrRecordingContextPriv.h"
 
 GrSurfaceProxyView GrTextureMaker::onRefTextureProxyViewForParams(GrSamplerState params,
-                                                                  bool willBeMipped,
-                                                                  SkScalar scaleAdjust[2]) {
+                                                                  bool willBeMipped) {
     if (this->width() > this->context()->priv().caps()->maxTextureSize() ||
         this->height() > this->context()->priv().caps()->maxTextureSize()) {
         return {};
     }
 
-    CopyParams copyParams;
-
     GrSurfaceProxyView original = this->refOriginalTextureProxyView(willBeMipped,
                                                                     AllowedTexGenType::kCheap);
-    bool needsCopyForMipsOnly = false;
-    if (original.proxy()) {
-        GrTextureProxy* texProxy = original.asTextureProxy();
-        SkASSERT(texProxy);
-        if (!params.isRepeated() ||
-            !GrGpu::IsACopyNeededForRepeatWrapMode(this->context()->priv().caps(), texProxy,
-                                                   texProxy->dimensions(), params.filter(),
-                                                   &copyParams, scaleAdjust)) {
-            needsCopyForMipsOnly = GrGpu::IsACopyNeededForMips(this->context()->priv().caps(),
-                                                               texProxy, params.filter(),
-                                                               &copyParams);
-            if (!needsCopyForMipsOnly) {
-                return original;
-            }
-        }
-    } else {
-        if (!params.isRepeated() ||
-            !GrGpu::IsACopyNeededForRepeatWrapMode(this->context()->priv().caps(), nullptr,
-                                                   this->dimensions(), params.filter(), &copyParams,
-                                                   scaleAdjust)) {
-            return this->refOriginalTextureProxyView(willBeMipped, AllowedTexGenType::kAny);
-        }
+    if (!original) {
+        return this->refOriginalTextureProxyView(willBeMipped, AllowedTexGenType::kAny);
+    }
+
+    GrTextureProxy* texProxy = original.asTextureProxy();
+    if (!GrGpu::IsACopyNeededForMips(this->context()->priv().caps(), texProxy, params.filter())) {
+        return original;
     }
 
     GrProxyProvider* proxyProvider = this->context()->priv().proxyProvider();
 
     GrSurfaceOrigin origOrigin = original.proxy() ? original.origin() : kTopLeft_GrSurfaceOrigin;
-    GrUniqueKey copyKey;
-    this->makeCopyKey(copyParams, &copyKey);
-    GrSurfaceProxyView cachedView;
-    if (copyKey.isValid()) {
-        auto cachedProxy = proxyProvider->findOrCreateProxyByUniqueKey(copyKey, this->colorType());
+    GrUniqueKey mipMappedKey;
+    this->makeMipMappedKey(&mipMappedKey);
+    if (mipMappedKey.isValid()) {
+        auto cachedProxy =
+                proxyProvider->findOrCreateProxyByUniqueKey(mipMappedKey, this->colorType());
         if (cachedProxy) {
-            GrMipMapped mipped = cachedProxy->mipMapped();
-            // TODO: Once we no longer use CopyOnGpu which can fallback to arbitrary formats and
-            // colorTypes, we can use the swizzle of the originalView.
+            SkASSERT(cachedProxy->mipMapped() == GrMipMapped::kYes);
+            // TODO: Once we no longer use MakeMipMappedCopy which can fallback to arbitrary formats
+            // and colorTypes, we can use the swizzle of the originalView.
             GrSwizzle swizzle = cachedProxy->textureSwizzleDoNotUse();
-            cachedView = GrSurfaceProxyView(std::move(cachedProxy), origOrigin, swizzle);
-            if (!willBeMipped || GrMipMapped::kYes == mipped) {
-                return cachedView;
-            }
+            return GrSurfaceProxyView(std::move(cachedProxy), origOrigin, swizzle);
         }
     }
 
     GrSurfaceProxyView source;
-    if (original.proxy()) {
+    if (original) {
         source = std::move(original);
-    } else if (cachedView.proxy()) {
-        source = cachedView;
     } else {
         // Since we will be copying this texture there is no reason to make it mipped
         source = this->refOriginalTextureProxyView(false, AllowedTexGenType::kAny);
+        if (!source) {
+            return {};
+        }
     }
 
-    if (!source.proxy()) {
-        return {};
-    }
     SkASSERT(source.asTextureProxy());
 
-    GrSurfaceProxyView result =
-            CopyOnGpu(this->context(), source, this->colorType(), copyParams, willBeMipped);
+    GrSurfaceProxyView result = MakeMipMappedCopy(this->context(), source, this->colorType());
 
-    if (!result.proxy()) {
+    if (!result) {
         // If we were unable to make a copy and we only needed a copy for mips, then we will return
         // the source texture here and require that the GPU backend is able to fall back to using
         // bilerp if mips are required.
-        if (needsCopyForMipsOnly) {
-            return source;
-        }
-        return {};
+        return source;
     }
 
-    if (copyKey.isValid()) {
+    if (mipMappedKey.isValid()) {
         SkASSERT(result.origin() == origOrigin);
-        if (cachedView.proxy()) {
-            SkASSERT(GrMipMapped::kYes == result.asTextureProxy()->mipMapped() &&
-                     GrMipMapped::kNo == cachedView.asTextureProxy()->mipMapped());
-            // If we had a cachedProxy, that means there already is a proxy in the cache which
-            // matches the key, but it does not have mip levels and we require them. Thus we must
-            // remove the unique key from that proxy.
-            SkASSERT(cachedView.asTextureProxy()->getUniqueKey() == copyKey);
-            proxyProvider->removeUniqueKeyFromProxy(cachedView.asTextureProxy());
-        }
-        proxyProvider->assignUniqueKeyToProxy(copyKey, result.asTextureProxy());
-        this->didCacheCopy(copyKey, proxyProvider->contextID());
+        proxyProvider->assignUniqueKeyToProxy(mipMappedKey, result.asTextureProxy());
+        this->didCacheMipMappedCopy(mipMappedKey, proxyProvider->contextID());
     }
     return result;
 }
@@ -132,13 +96,10 @@
         fmForDetermineDomain = &kBilerp;
     }
 
-    SkScalar scaleAdjust[2] = { 1.0f, 1.0f };
-    GrSurfaceProxyView view = this->viewForParams(filterOrNullForBicubic, scaleAdjust);
-    if (!view.proxy()) {
+    GrSurfaceProxyView view = this->viewForParams(filterOrNullForBicubic);
+    if (!view) {
         return nullptr;
     }
-    SkMatrix adjustedMatrix = textureMatrix;
-    adjustedMatrix.postScale(scaleAdjust[0], scaleAdjust[1]);
 
     SkRect domain;
     DomainMode domainMode =
@@ -146,5 +107,5 @@
                             view.proxy(), fmForDetermineDomain, &domain);
     SkASSERT(kTightCopy_DomainMode != domainMode);
     return this->createFragmentProcessorForDomainAndFilter(
-            std::move(view), adjustedMatrix, domainMode, domain, filterOrNullForBicubic);
+            std::move(view), textureMatrix, domainMode, domain, filterOrNullForBicubic);
 }
diff --git a/src/gpu/GrTextureMaker.h b/src/gpu/GrTextureMaker.h
index 22aaced..6296964 100644
--- a/src/gpu/GrTextureMaker.h
+++ b/src/gpu/GrTextureMaker.h
@@ -40,9 +40,7 @@
                                                            AllowedTexGenType genType) = 0;
 
 private:
-    GrSurfaceProxyView onRefTextureProxyViewForParams(GrSamplerState,
-                                                      bool willBeMipped,
-                                                      SkScalar scaleAdjust[2]) override;
+    GrSurfaceProxyView onRefTextureProxyViewForParams(GrSamplerState, bool willBeMipped) override;
 
     typedef GrTextureProducer INHERITED;
 };
diff --git a/src/gpu/GrTextureProducer.cpp b/src/gpu/GrTextureProducer.cpp
index 0e2f908..55fccc0 100644
--- a/src/gpu/GrTextureProducer.cpp
+++ b/src/gpu/GrTextureProducer.cpp
@@ -21,53 +21,35 @@
 #include "src/gpu/effects/GrTextureDomain.h"
 #include "src/gpu/effects/GrTextureEffect.h"
 
-GrSurfaceProxyView GrTextureProducer::CopyOnGpu(GrRecordingContext* context,
-                                                GrSurfaceProxyView inputView,
-                                                GrColorType colorType,
-                                                const CopyParams& copyParams,
-                                                bool dstWillRequireMipMaps) {
+GrSurfaceProxyView GrTextureProducer::MakeMipMappedCopy(GrRecordingContext* context,
+                                                        GrSurfaceProxyView inputView,
+                                                        GrColorType colorType) {
     SkASSERT(context);
     SkASSERT(inputView.asTextureProxy());
 
-    const SkRect dstRect = SkRect::Make(copyParams.fDimensions);
-    GrMipMapped mipMapped = dstWillRequireMipMaps ? GrMipMapped::kYes : GrMipMapped::kNo;
-
     GrSurfaceProxy* proxy = inputView.proxy();
-    SkRect localRect = proxy->getBoundsRect();
+    SkRect proxyRect = proxy->getBoundsRect();
 
-    bool resizing = false;
-    if (copyParams.fFilter != GrSamplerState::Filter::kNearest) {
-        resizing = localRect.width() != dstRect.width() || localRect.height() != dstRect.height();
-    }
-
-    if (copyParams.fFilter == GrSamplerState::Filter::kNearest && !resizing &&
-        dstWillRequireMipMaps) {
-        GrSurfaceProxyView view = GrCopyBaseMipMapToTextureProxy(context, proxy, inputView.origin(),
-                                                                 colorType);
-        if (view.proxy()) {
-            return view;
-        }
+    GrSurfaceProxyView view =
+            GrCopyBaseMipMapToTextureProxy(context, proxy, inputView.origin(), colorType);
+    if (view) {
+        return view;
     }
 
     auto copyRTC = GrRenderTargetContext::MakeWithFallback(
-            context, colorType, nullptr, SkBackingFit::kExact, copyParams.fDimensions, 1,
-            mipMapped, proxy->isProtected(), inputView.origin());
+            context, colorType, nullptr, SkBackingFit::kExact, inputView.dimensions(), 1,
+            GrMipMapped::kYes, proxy->isProtected(), inputView.origin());
     if (!copyRTC) {
         return {};
     }
 
-    const auto& caps = *context->priv().caps();
     GrPaint paint;
-
-    GrSamplerState sampler(GrSamplerState::WrapMode::kClamp, copyParams.fFilter);
-    auto boundsRect = SkRect::Make(proxy->dimensions());
-    auto fp = GrTextureEffect::MakeSubset(std::move(inputView), kUnknown_SkAlphaType, SkMatrix::I(),
-                                          sampler, boundsRect, localRect, caps);
+    auto fp = GrTextureEffect::Make(std::move(inputView), kUnknown_SkAlphaType, SkMatrix::I(),
+                                    GrSamplerState::Filter::kNearest);
     paint.addColorFragmentProcessor(std::move(fp));
     paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
 
-    copyRTC->fillRectToRect(GrNoClip(), std::move(paint), GrAA::kNo, SkMatrix::I(), dstRect,
-                            localRect);
+    copyRTC->drawRect(GrNoClip(), std::move(paint), GrAA::kNo, SkMatrix::I(), proxyRect);
     return copyRTC->readSurfaceView();
 }
 
@@ -218,7 +200,7 @@
 }
 
 GrSurfaceProxyView GrTextureProducer::viewForParams(
-        const GrSamplerState::Filter* filterOrNullForBicubic, SkScalar scaleAdjust[2]) {
+        const GrSamplerState::Filter* filterOrNullForBicubic) {
     GrSamplerState sampler; // Default is nearest + clamp
     if (filterOrNullForBicubic) {
         sampler.setFilterMode(*filterOrNullForBicubic);
@@ -230,36 +212,29 @@
             sampler.setWrapModeY(GrSamplerState::WrapMode::kClampToBorder);
         }
     }
-    return this->viewForParams(sampler, scaleAdjust);
+    return this->viewForParams(sampler);
 }
 
-GrSurfaceProxyView GrTextureProducer::viewForParams(GrSamplerState sampler,
-                                                    SkScalar scaleAdjust[2]) {
-    // Check that the caller pre-initialized scaleAdjust
-    SkASSERT(!scaleAdjust || (scaleAdjust[0] == 1 && scaleAdjust[1] == 1));
-
+GrSurfaceProxyView GrTextureProducer::viewForParams(GrSamplerState sampler) {
     const GrCaps* caps = this->context()->priv().caps();
 
     int mipCount = SkMipMap::ComputeLevelCount(this->width(), this->height());
     bool willBeMipped = GrSamplerState::Filter::kMipMap == sampler.filter() && mipCount &&
                         caps->mipMapSupport();
 
-    auto result = this->onRefTextureProxyViewForParams(sampler, willBeMipped, scaleAdjust);
+    auto result = this->onRefTextureProxyViewForParams(sampler, willBeMipped);
+    if (!result) {
+        return {};
+    }
+
+    SkASSERT(result.asTextureProxy());
 
     // Check to make sure that if we say the texture willBeMipped that the returned texture has mip
     // maps, unless the config is not copyable.
-    SkASSERT(!result.proxy() || !willBeMipped ||
-             result.asTextureProxy()->mipMapped() == GrMipMapped::kYes ||
+    SkASSERT(!willBeMipped || result.asTextureProxy()->mipMapped() == GrMipMapped::kYes ||
              !caps->isFormatCopyable(result.proxy()->backendFormat()));
 
-    SkASSERT(!result.proxy() || result.asTextureProxy());
-
-    SkDEBUGCODE(bool expectNoScale = (sampler.filter() != GrSamplerState::Filter::kMipMap &&
-                                      !sampler.isRepeated()));
-    // Check that the "no scaling expected" case always returns a proxy of the same size as the
-    // producer.
-    SkASSERT(!result.proxy() || !expectNoScale ||
-             result.proxy()->dimensions() == this->dimensions());
+    SkASSERT(result.proxy()->dimensions() == this->dimensions());
 
     return result;
 }
@@ -270,7 +245,7 @@
                                              : GrSamplerState::Filter::kMipMap;
     GrSamplerState sampler(GrSamplerState::WrapMode::kClamp, filter);
 
-    auto result = this->viewForParams(sampler, nullptr);
+    auto result = this->viewForParams(sampler);
 
 #ifdef SK_DEBUG
     const GrCaps* caps = this->context()->priv().caps();
diff --git a/src/gpu/GrTextureProducer.h b/src/gpu/GrTextureProducer.h
index 39944d9..a1a9a02 100644
--- a/src/gpu/GrTextureProducer.h
+++ b/src/gpu/GrTextureProducer.h
@@ -32,11 +32,6 @@
  */
 class GrTextureProducer : public SkNoncopyable {
 public:
-    struct CopyParams {
-        GrSamplerState::Filter fFilter;
-        SkISize fDimensions;
-    };
-
     enum FilterConstraint {
         kYes_FilterConstraint,
         kNo_FilterConstraint,
@@ -71,21 +66,10 @@
 
     /**
      *  Returns a texture that is safe for use with the params.
-     *
-     * If the size of the returned texture does not match width()/height() then the contents of the
-     * original may have been scaled to fit the texture or the original may have been copied into
-     * a subrect of the copy. 'scaleAdjust' must be  applied to the normalized texture coordinates
-     * in order to correct for the latter case.
-     *
-     * If the GrSamplerState is known to clamp and use kNearest or kBilerp filter mode then the
-     * proxy will always be unscaled and nullptr can be passed for scaleAdjust. There is a weird
-     * contract that if scaleAdjust is not null it must be initialized to {1, 1} before calling
-     * this method. (TODO: Fix this and make this function always initialize scaleAdjust).
      */
-    GrSurfaceProxyView viewForParams(GrSamplerState, SkScalar scaleAdjust[2]);
+    GrSurfaceProxyView viewForParams(GrSamplerState);
 
-    GrSurfaceProxyView viewForParams(const GrSamplerState::Filter* filterOrNullForBicubic,
-                                     SkScalar scaleAdjust[2]);
+    GrSurfaceProxyView viewForParams(const GrSamplerState::Filter* filterOrNullForBicubic);
 
     /**
      * Returns a texture. If willNeedMips is true then the returned texture is guaranteed to have
@@ -121,35 +105,29 @@
     GrColorType colorType() const { return fImageInfo.colorType(); }
 
     /** Helper for creating a key for a copy from an original key. */
-    static void MakeCopyKeyFromOrigKey(const GrUniqueKey& origKey,
-                                       const CopyParams& copyParams,
-                                       GrUniqueKey* copyKey) {
-        SkASSERT(!copyKey->isValid());
+    static void MakeMipMappedKeyFromOriginalKey(const GrUniqueKey& origKey,
+                                                GrUniqueKey* mipMappedKey) {
+        SkASSERT(!mipMappedKey->isValid());
         if (origKey.isValid()) {
             static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain();
-            GrUniqueKey::Builder builder(copyKey, origKey, kDomain, 3);
-            builder[0] = static_cast<uint32_t>(copyParams.fFilter);
-            builder[1] = copyParams.fDimensions.width();
-            builder[2] = copyParams.fDimensions.height();
+            GrUniqueKey::Builder builder(mipMappedKey, origKey, kDomain, 0);
         }
     }
 
     /**
-    *  If we need to make a copy in order to be compatible with GrTextureParams producer is asked to
-    *  return a key that identifies its original content + the CopyParms parameter. If the producer
-    *  does not want to cache the stretched version (e.g. the producer is volatile), this should
-    *  simply return without initializing the copyKey. If the texture generated by this producer
-    *  depends on the destination color space, then that information should also be incorporated
-    *  in the key.
-    */
-    virtual void makeCopyKey(const CopyParams&, GrUniqueKey* copyKey) = 0;
+     * If we need to make a copy with MIP maps the producer is asked to return a key that identifies
+     * the original conteny + the addition of MIP map levels. If the producer does not want to cache
+     * the copy it can simply leave the key uninitialized.
+     */
+    virtual void makeMipMappedKey(GrUniqueKey* mipMappedKey) = 0;
 
     /**
-    *  If a stretched version of the texture is generated, it may be cached (assuming that
-    *  makeCopyKey() returns true). In that case, the maker is notified in case it
-    *  wants to note that for when the maker is destroyed.
-    */
-    virtual void didCacheCopy(const GrUniqueKey& copyKey, uint32_t contextUniqueID) = 0;
+     *  If a stretched version of the texture is generated, it may be cached (assuming that
+     *  makeMipMappedKey() returns true). In that case, the maker is notified in case it
+     *  wants to note that for when the maker is destroyed.
+     */
+    virtual void didCacheMipMappedCopy(const GrUniqueKey& mipMappedKey,
+                                       uint32_t contextUniqueID) = 0;
 
     enum DomainMode {
         kNoDomain_DomainMode,
@@ -157,12 +135,11 @@
         kTightCopy_DomainMode
     };
 
-    // This can draw to accomplish the copy, thus the recording context is needed
-    static GrSurfaceProxyView CopyOnGpu(GrRecordingContext*,
-                                        GrSurfaceProxyView inputView,
-                                        GrColorType,
-                                        const CopyParams& copyParams,
-                                        bool dstWillRequireMipMaps);
+    // TODO: Try to remove the draw fallback and directly use GrCopyBaseMipMapToTextureProxy
+    // instead.
+    static GrSurfaceProxyView MakeMipMappedCopy(GrRecordingContext*,
+                                                GrSurfaceProxyView,
+                                                GrColorType colorType);
 
     static DomainMode DetermineDomainMode(const SkRect& constraintRect,
                                           FilterConstraint filterConstraint,
@@ -181,8 +158,8 @@
     GrRecordingContext* context() const { return fContext; }
 
 private:
-    virtual GrSurfaceProxyView onRefTextureProxyViewForParams(GrSamplerState, bool willBeMipped,
-                                                              SkScalar scaleAdjust[2]) = 0;
+    virtual GrSurfaceProxyView onRefTextureProxyViewForParams(GrSamplerState,
+                                                              bool willBeMipped) = 0;
 
     GrRecordingContext* fContext;
     const GrImageInfo fImageInfo;
diff --git a/src/gpu/SkGpuDevice.cpp b/src/gpu/SkGpuDevice.cpp
index d52787e..9deaff9 100644
--- a/src/gpu/SkGpuDevice.cpp
+++ b/src/gpu/SkGpuDevice.cpp
@@ -918,15 +918,13 @@
              bitmap.height() <= this->caps()->maxTileSize());
     SkASSERT(!samplerState.isRepeated());
 
-    SkScalar scales[2] = {1.f, 1.f};
-    GrSurfaceProxyView view = GrRefCachedBitmapView(fContext.get(), bitmap, samplerState, scales);
+    GrSurfaceProxyView view = GrRefCachedBitmapView(fContext.get(), bitmap, samplerState);
     if (!view) {
         return;
     }
 
     // Compute a matrix that maps the rect we will draw to the src rect.
     SkMatrix texMatrix = SkMatrix::MakeRectToRect(dstRect, srcRect, SkMatrix::kFill_ScaleToFit);
-    texMatrix.postScale(scales[0], scales[1]);
 
     SkAlphaType srcAlphaType = bitmap.alphaType();
 
@@ -1052,7 +1050,7 @@
         auto filter = paint.getFilterQuality() > kNone_SkFilterQuality
                               ? GrSamplerState::Filter::kBilerp
                               : GrSamplerState::Filter::kNearest;
-        GrSurfaceProxyView clipView = as_IB(clipImage)->refView(this->context(), filter, nullptr);
+        GrSurfaceProxyView clipView = as_IB(clipImage)->refView(this->context(), filter);
         // Fold clip matrix into ctm
         ctm.preConcat(clipMatrix);
         SkMatrix inverseClipMatrix;
@@ -1345,7 +1343,7 @@
 
     auto dstColorSpace = fRenderTargetContext->colorInfo().colorSpace();
     const GrSamplerState::Filter filter = compute_lattice_filter_mode(*paint);
-    auto view = producer->viewForParams(&filter, nullptr);
+    auto view = producer->viewForParams(&filter);
     if (!view) {
         return;
     }
diff --git a/src/gpu/SkGpuDevice_drawTexture.cpp b/src/gpu/SkGpuDevice_drawTexture.cpp
index edd3469..7b2b1a9 100644
--- a/src/gpu/SkGpuDevice_drawTexture.cpp
+++ b/src/gpu/SkGpuDevice_drawTexture.cpp
@@ -537,7 +537,7 @@
             uint32_t uniqueID;
             view = image->refPinnedView(this->context(), &uniqueID);
             if (!view) {
-                view = image->refView(this->context(), GrSamplerState::Filter::kBilerp, nullptr);
+                view = image->refView(this->context(), GrSamplerState::Filter::kBilerp);
             }
         }
 
diff --git a/src/gpu/SkGr.cpp b/src/gpu/SkGr.cpp
index c6fb7b7..0b20bb7 100644
--- a/src/gpu/SkGr.cpp
+++ b/src/gpu/SkGr.cpp
@@ -134,9 +134,9 @@
 }
 
 GrSurfaceProxyView GrRefCachedBitmapView(GrRecordingContext* ctx, const SkBitmap& bitmap,
-                                         GrSamplerState params, SkScalar scaleAdjust[2]) {
+                                         GrSamplerState params) {
     GrBitmapTextureMaker maker(ctx, bitmap, GrBitmapTextureMaker::Cached::kYes);
-    return maker.viewForParams(params, scaleAdjust);
+    return maker.viewForParams(params);
 }
 
 GrSurfaceProxyView GrMakeCachedBitmapProxyView(GrRecordingContext* context, const SkBitmap& bitmap,
diff --git a/src/gpu/SkGr.h b/src/gpu/SkGr.h
index 0d97169..36daae1 100644
--- a/src/gpu/SkGr.h
+++ b/src/gpu/SkGr.h
@@ -163,15 +163,12 @@
 ////////////////////////////////////////////////////////////////////////////////
 // Texture management
 
-/** Returns a view that wraps a texture representing the bitmap that is compatible with the
- *  GrSamplerState. The texture is inserted into the cache (unless the bitmap is marked volatile)
- *  and can be retrieved again via this function.
- *  The 'scaleAdjust' in/out parameter will be updated to hold any rescaling that needs to be
- *  performed on the absolute texture coordinates (e.g., if the texture is resized out to
- *  the next power of two). It can be null if the caller is sure the bitmap won't be resized.
+/**
+ * Returns a view that wraps a texture representing the bitmap that is compatible with the
+ * GrSamplerState. The texture is inserted into the cache (unless the bitmap is marked volatile)
+ * and can be retrieved again via this function.
  */
-GrSurfaceProxyView GrRefCachedBitmapView(GrRecordingContext*, const SkBitmap&, GrSamplerState,
-                                         SkScalar scaleAdjust[2]);
+GrSurfaceProxyView GrRefCachedBitmapView(GrRecordingContext*, const SkBitmap&, GrSamplerState);
 
 /**
  * Creates a new texture with mipmap levels and copies the baseProxy into the base layer.
diff --git a/src/image/SkImage_Base.h b/src/image/SkImage_Base.h
index a4abb60..9dfcc7c 100644
--- a/src/image/SkImage_Base.h
+++ b/src/image/SkImage_Base.h
@@ -64,8 +64,7 @@
     // this call will flatten a SkImage_GpuYUV to a single texture.
     virtual const GrSurfaceProxyView* view(GrRecordingContext*) const { return nullptr; }
 
-    virtual GrSurfaceProxyView refView(GrRecordingContext*, GrSamplerState,
-                                       SkScalar scaleAdjust[2]) const = 0;
+    virtual GrSurfaceProxyView refView(GrRecordingContext*, GrSamplerState) const = 0;
     virtual GrSurfaceProxyView refPinnedView(GrRecordingContext*, uint32_t* uniqueID) const {
         return {};
     }
diff --git a/src/image/SkImage_GpuBase.cpp b/src/image/SkImage_GpuBase.cpp
index 95002e0..7bd05ba 100644
--- a/src/image/SkImage_GpuBase.cpp
+++ b/src/image/SkImage_GpuBase.cpp
@@ -186,8 +186,8 @@
     return sContext->readPixels(dstInfo, dstPixels, dstRB, {srcX, srcY});
 }
 
-GrSurfaceProxyView SkImage_GpuBase::refView(GrRecordingContext* context, GrSamplerState params,
-                                            SkScalar scaleAdjust[2]) const {
+GrSurfaceProxyView SkImage_GpuBase::refView(GrRecordingContext* context,
+                                            GrSamplerState params) const {
     if (!context || !fContext->priv().matches(context)) {
         SkASSERT(0);
         return {};
@@ -195,7 +195,7 @@
 
     GrTextureAdjuster adjuster(fContext.get(), *this->view(context), this->imageInfo().colorInfo(),
                                this->uniqueID());
-    return adjuster.viewForParams(params, scaleAdjust);
+    return adjuster.viewForParams(params);
 }
 
 GrBackendTexture SkImage_GpuBase::onGetBackendTexture(bool flushPendingGrContextIO,
diff --git a/src/image/SkImage_GpuBase.h b/src/image/SkImage_GpuBase.h
index 05fc48f..3f4fa52 100644
--- a/src/image/SkImage_GpuBase.h
+++ b/src/image/SkImage_GpuBase.h
@@ -28,8 +28,7 @@
     bool onReadPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRB,
                       int srcX, int srcY, CachingHint) const override;
 
-    GrSurfaceProxyView refView(GrRecordingContext*, GrSamplerState,
-                               SkScalar scaleAdjust[2]) const final;
+    GrSurfaceProxyView refView(GrRecordingContext*, GrSamplerState) const final;
 
     GrSurfaceProxyView refPinnedView(GrRecordingContext* context, uint32_t* uniqueID) const final {
         *uniqueID = this->uniqueID();
diff --git a/src/image/SkImage_GpuYUVA.cpp b/src/image/SkImage_GpuYUVA.cpp
index eedd399..43ab458 100644
--- a/src/image/SkImage_GpuYUVA.cpp
+++ b/src/image/SkImage_GpuYUVA.cpp
@@ -92,13 +92,11 @@
     }
 
     for (int i = 0; i < fNumViews; ++i) {
-        GrTextureProducer::CopyParams copyParams;
         int mipCount = SkMipMap::ComputeLevelCount(fViews[i].proxy()->width(),
                                                    fViews[i].proxy()->height());
         if (mipCount && GrGpu::IsACopyNeededForMips(fContext->priv().caps(),
                                                     fViews[i].asTextureProxy(),
-                                                    GrSamplerState::Filter::kMipMap,
-                                                    &copyParams)) {
+                                                    GrSamplerState::Filter::kMipMap)) {
             auto mippedView = GrCopyBaseMipMapToTextureProxy(context, fViews[i].asTextureProxy(),
                                                              fOrigin, fProxyColorTypes[i]);
             if (!mippedView.proxy()) {
diff --git a/src/image/SkImage_Lazy.cpp b/src/image/SkImage_Lazy.cpp
index 81a874d..50b9041 100644
--- a/src/image/SkImage_Lazy.cpp
+++ b/src/image/SkImage_Lazy.cpp
@@ -238,14 +238,13 @@
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
-GrSurfaceProxyView SkImage_Lazy::refView(GrRecordingContext* context, GrSamplerState params,
-                                         SkScalar scaleAdjust[2]) const {
+GrSurfaceProxyView SkImage_Lazy::refView(GrRecordingContext* context, GrSamplerState params) const {
     if (!context) {
         return {};
     }
 
     GrImageTextureMaker textureMaker(context, this, kAllow_CachingHint);
-    return textureMaker.viewForParams(params, scaleAdjust);
+    return textureMaker.viewForParams(params);
 }
 #endif
 
diff --git a/src/image/SkImage_Lazy.h b/src/image/SkImage_Lazy.h
index 224eaf0..dce367b 100644
--- a/src/image/SkImage_Lazy.h
+++ b/src/image/SkImage_Lazy.h
@@ -42,8 +42,7 @@
     bool onReadPixels(const SkImageInfo&, void*, size_t, int srcX, int srcY,
                       CachingHint) const override;
 #if SK_SUPPORT_GPU
-    GrSurfaceProxyView refView(GrRecordingContext*, GrSamplerState,
-                               SkScalar scaleAdjust[2]) const override;
+    GrSurfaceProxyView refView(GrRecordingContext*, GrSamplerState) const override;
     sk_sp<SkCachedData> getPlanes(SkYUVASizeInfo*, SkYUVAIndex[4],
                                   SkYUVColorSpace*, const void* planes[4]) override;
 #endif
diff --git a/src/image/SkImage_Raster.cpp b/src/image/SkImage_Raster.cpp
index 0764a4d..e1e8b4c 100644
--- a/src/image/SkImage_Raster.cpp
+++ b/src/image/SkImage_Raster.cpp
@@ -85,8 +85,7 @@
     const SkBitmap* onPeekBitmap() const override { return &fBitmap; }
 
 #if SK_SUPPORT_GPU
-    GrSurfaceProxyView refView(GrRecordingContext*, GrSamplerState,
-                               SkScalar scaleAdjust[2]) const override;
+    GrSurfaceProxyView refView(GrRecordingContext*, GrSamplerState) const override;
 #endif
 
     bool getROPixels(SkBitmap*, CachingHint) const override;
@@ -174,8 +173,8 @@
 }
 
 #if SK_SUPPORT_GPU
-GrSurfaceProxyView SkImage_Raster::refView(GrRecordingContext* context, GrSamplerState params,
-                                           SkScalar scaleAdjust[2]) const {
+GrSurfaceProxyView SkImage_Raster::refView(GrRecordingContext* context,
+                                           GrSamplerState params) const {
     if (!context) {
         return {};
     }
@@ -184,10 +183,10 @@
     if (GrSurfaceProxyView view = this->refPinnedView(context, &uniqueID)) {
         GrTextureAdjuster adjuster(context, std::move(view), fBitmap.info().colorInfo(),
                                    fPinnedUniqueID);
-        return adjuster.viewForParams(params, scaleAdjust);
+        return adjuster.viewForParams(params);
     }
 
-    return GrRefCachedBitmapView(context, fBitmap, params, scaleAdjust);
+    return GrRefCachedBitmapView(context, fBitmap, params);
 }
 #endif
 
@@ -210,8 +209,7 @@
     } else {
         SkASSERT(fPinnedCount == 0);
         SkASSERT(fPinnedUniqueID == 0);
-        fPinnedView =
-                GrRefCachedBitmapView(ctx, fBitmap, GrSamplerState::Filter::kNearest, nullptr);
+        fPinnedView = GrRefCachedBitmapView(ctx, fBitmap, GrSamplerState::Filter::kNearest);
         if (!fPinnedView) {
             return false;
         }
diff --git a/src/shaders/SkImageShader.cpp b/src/shaders/SkImageShader.cpp
index b509e0b..9c31223 100755
--- a/src/shaders/SkImageShader.cpp
+++ b/src/shaders/SkImageShader.cpp
@@ -213,16 +213,13 @@
             fImage->width(), fImage->height(), args.fFilterQuality, *args.fViewMatrix, *lm,
             args.fContext->priv().options().fSharpenMipmappedTextures, &doBicubic);
     GrSamplerState samplerState(wm, textureFilterMode);
-    SkScalar scaleAdjust[2] = { 1.0f, 1.0f };
-    GrSurfaceProxyView view = as_IB(fImage)->refView(args.fContext, samplerState, scaleAdjust);
+    GrSurfaceProxyView view = as_IB(fImage)->refView(args.fContext, samplerState);
     if (!view) {
         return nullptr;
     }
 
     SkAlphaType srcAlphaType = fImage->alphaType();
 
-    lmInverse.postScale(scaleAdjust[0], scaleAdjust[1]);
-
     const auto& caps = *args.fContext->priv().caps();
 
     std::unique_ptr<GrFragmentProcessor> inner;
diff --git a/tests/ImageTest.cpp b/tests/ImageTest.cpp
index d908365..1a1969a 100644
--- a/tests/ImageTest.cpp
+++ b/tests/ImageTest.cpp
@@ -970,20 +970,19 @@
             sk_sp<SkImage> refImg(imageMaker(ctx));
 
             // Any context should be able to borrow the texture at this point
-            GrSurfaceProxyView view =
-                    as_IB(refImg)->refView(ctx, GrSamplerState::Filter::kNearest, nullptr);
+            GrSurfaceProxyView view = as_IB(refImg)->refView(ctx, GrSamplerState::Filter::kNearest);
             REPORTER_ASSERT(reporter, view);
 
             // But once it's borrowed, no other context should be able to borrow
             otherTestContext->makeCurrent();
             GrSurfaceProxyView otherView =
-                    as_IB(refImg)->refView(otherCtx, GrSamplerState::Filter::kNearest, nullptr);
+                    as_IB(refImg)->refView(otherCtx, GrSamplerState::Filter::kNearest);
             REPORTER_ASSERT(reporter, !otherView);
 
             // Original context (that's already borrowing) should be okay
             testContext->makeCurrent();
             GrSurfaceProxyView viewSecondRef =
-                    as_IB(refImg)->refView(ctx, GrSamplerState::Filter::kNearest, nullptr);
+                    as_IB(refImg)->refView(ctx, GrSamplerState::Filter::kNearest);
             REPORTER_ASSERT(reporter, viewSecondRef);
 
             // Release first ref from the original context
@@ -992,7 +991,7 @@
             // We released one proxy but not the other from the current borrowing context. Make sure
             // a new context is still not able to borrow the texture.
             otherTestContext->makeCurrent();
-            otherView = as_IB(refImg)->refView(otherCtx, GrSamplerState::Filter::kNearest, nullptr);
+            otherView = as_IB(refImg)->refView(otherCtx, GrSamplerState::Filter::kNearest);
             REPORTER_ASSERT(reporter, !otherView);
 
             // Release second ref from the original context
@@ -1001,7 +1000,7 @@
 
             // Now we should be able to borrow the texture from the other context
             otherTestContext->makeCurrent();
-            otherView = as_IB(refImg)->refView(otherCtx, GrSamplerState::Filter::kNearest, nullptr);
+            otherView = as_IB(refImg)->refView(otherCtx, GrSamplerState::Filter::kNearest);
             REPORTER_ASSERT(reporter, otherView);
 
             // Release everything
@@ -1042,8 +1041,7 @@
             sk_sp<SkImage> image = SkImage::MakeCrossContextFromPixmap(ctx, pixmap, false);
             REPORTER_ASSERT(reporter, image);
 
-            GrSurfaceProxyView view =
-                    as_IB(image)->refView(ctx, GrSamplerState::Filter::kNearest, nullptr);
+            GrSurfaceProxyView view = as_IB(image)->refView(ctx, GrSamplerState::Filter::kNearest);
             REPORTER_ASSERT(reporter, view);
 
             bool expectAlpha = kAlpha_8_SkColorType == ct;