diff --git a/src/gpu/GrGpu.cpp b/src/gpu/GrGpu.cpp
index a7a3bb1..efc000f 100644
--- a/src/gpu/GrGpu.cpp
+++ b/src/gpu/GrGpu.cpp
@@ -99,11 +99,12 @@
     return false;
 }
 
-static bool validate_texel_levels(int w, int h, const GrMipLevel* texels, int mipLevelCount,
-                                  int bpp, const GrCaps* caps) {
+static bool validate_texel_levels(int w, int h, GrColorType texelColorType,
+                                  const GrMipLevel* texels, int mipLevelCount, const GrCaps* caps) {
     SkASSERT(mipLevelCount > 0);
     bool hasBasePixels = texels[0].fPixels;
     int levelsWithPixelsCnt = 0;
+    auto bpp = GrColorTypeBytesPerPixel(texelColorType);
     for (int currentMipLevel = 0; currentMipLevel < mipLevelCount; ++currentMipLevel) {
         if (texels[currentMipLevel].fPixels) {
             const size_t minRowBytes = w * bpp;
@@ -141,21 +142,20 @@
     return levelsWithPixelsCnt == 1 || levelsWithPixelsCnt == mipLevelCount;
 }
 
-sk_sp<GrTexture> GrGpu::createTexture(const GrSurfaceDesc& desc,
-                                      const GrBackendFormat& format,
-                                      GrRenderable renderable,
-                                      int renderTargetSampleCnt,
-                                      SkBudgeted budgeted,
-                                      GrProtected isProtected,
-                                      const GrMipLevel texels[],
-                                      int texelLevelCount) {
-    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
+sk_sp<GrTexture> GrGpu::createTextureCommon(const GrSurfaceDesc& desc,
+                                            const GrBackendFormat& format,
+                                            GrRenderable renderable,
+                                            int renderTargetSampleCnt,
+                                            SkBudgeted budgeted,
+                                            GrProtected isProtected,
+                                            int mipLevelCount,
+                                            uint32_t levelClearMask) {
     if (this->caps()->isFormatCompressed(format)) {
         // Call GrGpu::createCompressedTexture.
         return nullptr;
     }
 
-    GrMipMapped mipMapped = texelLevelCount > 1 ? GrMipMapped::kYes : GrMipMapped::kNo;
+    GrMipMapped mipMapped = mipLevelCount > 1 ? GrMipMapped::kYes : GrMipMapped::kNo;
     if (!this->caps()->validateSurfaceParams({desc.fWidth, desc.fHeight}, format, desc.fConfig,
                                              renderable, renderTargetSampleCnt, mipMapped)) {
         return nullptr;
@@ -167,9 +167,64 @@
     }
     // Attempt to catch un- or wrongly initialized sample counts.
     SkASSERT(renderTargetSampleCnt > 0 && renderTargetSampleCnt <= 64);
+    this->handleDirtyContext();
+    auto tex = this->onCreateTexture(desc,
+                                     format,
+                                     renderable,
+                                     renderTargetSampleCnt,
+                                     budgeted,
+                                     isProtected,
+                                     mipLevelCount,
+                                     levelClearMask);
+    if (tex) {
+        SkASSERT(tex->backendFormat() == format);
+        SkASSERT(GrRenderable::kNo == renderable || tex->asRenderTarget());
+        if (!this->caps()->reuseScratchTextures() && renderable == GrRenderable::kNo) {
+            tex->resourcePriv().removeScratchKey();
+        }
+        fStats.incTextureCreates();
+        if (renderTargetSampleCnt > 1 && !this->caps()->msaaResolvesAutomatically()) {
+            SkASSERT(GrRenderable::kYes == renderable);
+            tex->asRenderTarget()->setRequiresManualMSAAResolve();
+        }
+    }
+    return tex;
+}
+
+sk_sp<GrTexture> GrGpu::createTexture(const GrSurfaceDesc& desc,
+                                      const GrBackendFormat& format,
+                                      GrRenderable renderable,
+                                      int renderTargetSampleCnt,
+                                      GrMipMapped mipMapped,
+                                      SkBudgeted budgeted,
+                                      GrProtected isProtected) {
+    int mipLevelCount = 1;
+    if (mipMapped == GrMipMapped::kYes) {
+        mipLevelCount = 32 - SkCLZ(static_cast<uint32_t>(SkTMax(desc.fWidth, desc.fHeight)));
+    }
+    uint32_t levelClearMask =
+            this->caps()->shouldInitializeTextures() ? (1 << mipLevelCount) - 1 : 0;
+    auto tex = this->createTextureCommon(desc, format, renderable, renderTargetSampleCnt, budgeted,
+                                         isProtected, mipLevelCount, levelClearMask);
+    if (tex && mipMapped == GrMipMapped::kYes && levelClearMask) {
+        tex->texturePriv().markMipMapsClean();
+    }
+    return tex;
+}
+
+sk_sp<GrTexture> GrGpu::createTexture(const GrSurfaceDesc& desc,
+                                      const GrBackendFormat& format,
+                                      GrRenderable renderable,
+                                      int renderTargetSampleCnt,
+                                      SkBudgeted budgeted,
+                                      GrProtected isProtected,
+                                      GrColorType textureColorType,
+                                      GrColorType srcColorType,
+                                      const GrMipLevel texels[],
+                                      int texelLevelCount) {
+    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
     if (texelLevelCount) {
-        int bpp = GrBytesPerPixel(desc.fConfig);
-        if (!validate_texel_levels(desc.fWidth, desc.fHeight, texels, texelLevelCount, bpp,
+        if (!validate_texel_levels(desc.fWidth, desc.fHeight, srcColorType, texels, texelLevelCount,
                                    this->caps())) {
             return nullptr;
         }
@@ -189,31 +244,15 @@
         }
     }
 
-    this->handleDirtyContext();
-    sk_sp<GrTexture> tex = this->onCreateTexture(desc,
-                                                 format,
-                                                 renderable,
-                                                 renderTargetSampleCnt,
-                                                 budgeted,
-                                                 isProtected,
-                                                 mipLevelCount,
-                                                 levelClearMask);
-
+    auto tex = this->createTextureCommon(desc, format, renderable, renderTargetSampleCnt, budgeted,
+                                         isProtected, texelLevelCount, levelClearMask);
     if (tex) {
-        SkASSERT(tex->backendFormat() == format);
-        SkASSERT(GrRenderable::kNo == renderable || tex->asRenderTarget());
-        if (!this->caps()->reuseScratchTextures() && renderable == GrRenderable::kNo) {
-            tex->resourcePriv().removeScratchKey();
-        }
-        fStats.incTextureCreates();
         bool markMipLevelsClean = false;
         // Currently if level 0 does not have pixels then no other level may, as enforced by
         // validate_texel_levels.
         if (texelLevelCount && texels[0].fPixels) {
-            auto textureColorType = GrPixelConfigToColorType(desc.fConfig);
-            auto dataColorType = textureColorType;
             if (!this->writePixels(tex.get(), 0, 0, desc.fWidth, desc.fHeight, textureColorType,
-                                   dataColorType, texels, texelLevelCount)) {
+                                   srcColorType, texels, texelLevelCount)) {
                 return nullptr;
             }
             // Currently if level[1] of mip map has pixel data then so must all other levels.
@@ -226,21 +265,10 @@
         if (markMipLevelsClean) {
             tex->texturePriv().markMipMapsClean();
         }
-        if (renderTargetSampleCnt > 1 && !this->caps()->msaaResolvesAutomatically()) {
-            SkASSERT(GrRenderable::kYes == renderable);
-            tex->asRenderTarget()->setRequiresManualMSAAResolve();
-        }
     }
     return tex;
 }
 
-sk_sp<GrTexture> GrGpu::createTexture(const GrSurfaceDesc& desc, const GrBackendFormat& format,
-                                      GrRenderable renderable, int renderTargetSampleCnt,
-                                      SkBudgeted budgeted, GrProtected isProtected) {
-    return this->createTexture(desc, format, renderable, renderTargetSampleCnt, budgeted,
-                               isProtected, nullptr, 0);
-}
-
 sk_sp<GrTexture> GrGpu::createCompressedTexture(int width, int height,
                                                 const GrBackendFormat& format,
                                                 SkImage::CompressionType compressionType,
@@ -454,8 +482,7 @@
         return false;
     }
 
-    size_t bpp = GrColorTypeBytesPerPixel(srcColorType);
-    if (!validate_texel_levels(width, height, texels, mipLevelCount, bpp, this->caps())) {
+    if (!validate_texel_levels(width, height, srcColorType, texels, mipLevelCount, this->caps())) {
         return false;
     }
 
diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h
index 80677b9..3ef00d5 100644
--- a/src/gpu/GrGpu.h
+++ b/src/gpu/GrGpu.h
@@ -103,22 +103,35 @@
      *                       If mipLevelCount > 1 and texels[i].fPixels != nullptr for any i > 0
      *                       then all levels must have non-null pixels. All levels must have
      *                       non-null pixels if GrCaps::createTextureMustSpecifyAllLevels() is true.
+     * @param textureColorType The color type interpretation of the texture for the purpose of
+     *                       of uploading texel data.
+     * @param srcColorType   The color type of data in texels[].
      * @param texelLevelCount the number of levels in 'texels'. May be 0, 1, or
      *                       floor(max((log2(desc.fWidth), log2(desc.fHeight)))). It must be the
      *                       latter if GrCaps::createTextureMustSpecifyAllLevels() is true.
      * @return  The texture object if successful, otherwise nullptr.
      */
-    sk_sp<GrTexture> createTexture(const GrSurfaceDesc& desc, const GrBackendFormat& format,
-                                   GrRenderable renderable, int renderTargetSampleCnt, SkBudgeted,
-                                   GrProtected isProtected, const GrMipLevel texels[],
+    sk_sp<GrTexture> createTexture(const GrSurfaceDesc& desc,
+                                   const GrBackendFormat& format,
+                                   GrRenderable renderable,
+                                   int renderTargetSampleCnt,
+                                   SkBudgeted,
+                                   GrProtected isProtected,
+                                   GrColorType textureColorType,
+                                   GrColorType srcColorType,
+                                   const GrMipLevel texels[],
                                    int texelLevelCount);
 
     /**
      * Simplified createTexture() interface for when there is no initial texel data to upload.
      */
-    sk_sp<GrTexture> createTexture(const GrSurfaceDesc& desc, const GrBackendFormat& format,
-                                   GrRenderable renderable, int renderTargetSampleCnt,
-                                   SkBudgeted budgeted, GrProtected isProtected);
+    sk_sp<GrTexture> createTexture(const GrSurfaceDesc& desc,
+                                   const GrBackendFormat& format,
+                                   GrRenderable renderable,
+                                   int renderTargetSampleCnt,
+                                   GrMipMapped,
+                                   SkBudgeted budgeted,
+                                   GrProtected isProtected);
 
     sk_sp<GrTexture> createCompressedTexture(int width, int height, const GrBackendFormat&,
                                              SkImage::CompressionType, SkBudgeted, const void* data,
@@ -615,6 +628,15 @@
     virtual void onDumpJSON(SkJSONWriter*) const {}
 #endif
 
+    sk_sp<GrTexture> createTextureCommon(const GrSurfaceDesc& desc,
+                                         const GrBackendFormat& format,
+                                         GrRenderable renderable,
+                                         int renderTargetSampleCnt,
+                                         SkBudgeted budgeted,
+                                         GrProtected isProtected,
+                                         int mipLevelCnt,
+                                         uint32_t levelClearMask);
+
     void resetContext() {
         this->onResetContext(fResetBits);
         fResetBits = 0;
diff --git a/src/gpu/GrProxyProvider.cpp b/src/gpu/GrProxyProvider.cpp
index 46ea7b7..e4e0e84 100644
--- a/src/gpu/GrProxyProvider.cpp
+++ b/src/gpu/GrProxyProvider.cpp
@@ -150,7 +150,7 @@
                                                     isProtected);
     } else {
         tex = resourceProvider->createTexture(desc, format, renderable, renderTargetSampleCnt,
-                                              budgeted, isProtected);
+                                              GrMipMapped::kNo, budgeted, isProtected);
     }
     if (!tex) {
         return nullptr;
@@ -297,8 +297,8 @@
                 GrMipLevel mipLevel = { pixMap.addr(), pixMap.rowBytes() };
 
                 return LazyCallbackResult(resourceProvider->createTexture(
-                        desc, format, GrRenderable::kNo, sampleCnt, budgeted, fit, GrProtected::kNo,
-                        ct, mipLevel));
+                        desc, format, ct, GrRenderable::kNo, sampleCnt, budgeted, fit,
+                        GrProtected::kNo, mipLevel));
             },
             format, desc, GrRenderable::kNo, sampleCnt, kTopLeft_GrSurfaceOrigin, GrMipMapped::kNo,
             GrMipMapsStatus::kNotAllocated, surfaceFlags, fit, budgeted, GrProtected::kNo,
@@ -360,8 +360,8 @@
 
     GrSurfaceDesc desc = GrImageInfoToSurfaceDesc(bitmap.info());
 
-    GrColorType grColorType = SkColorTypeToGrColorType(bitmap.info().colorType());
-    GrBackendFormat format = this->caps()->getDefaultBackendFormat(grColorType, GrRenderable::kNo);
+    GrBackendFormat format = this->caps()->getDefaultBackendFormat(
+            SkColorTypeToGrColorType(bitmap.info().colorType()), GrRenderable::kNo);
     if (!format.isValid()) {
         SkBitmap copy8888;
         if (!copy8888.tryAllocPixels(bitmap.info().makeColorType(kRGBA_8888_SkColorType)) ||
@@ -371,8 +371,7 @@
         copy8888.setImmutable();
         baseLevel = SkMakeImageFromRasterBitmap(copy8888, kNever_SkCopyPixelsMode);
         desc.fConfig = kRGBA_8888_GrPixelConfig;
-        grColorType = GrColorType::kRGBA_8888;
-        format = this->caps()->getDefaultBackendFormat(grColorType, GrRenderable::kNo);
+        format = this->caps()->getDefaultBackendFormat(GrColorType::kRGBA_8888, GrRenderable::kNo);
         if (!format.isValid()) {
             return nullptr;
         }
@@ -393,22 +392,21 @@
                 SkPixmap pixmap;
                 SkAssertResult(baseLevel->peekPixels(&pixmap));
 
-                // DDL TODO: Instead of copying all this info into GrMipLevels we should just plumb
-                // the use of SkMipMap down through Ganesh.
                 texels[0].fPixels = pixmap.addr();
                 texels[0].fRowBytes = pixmap.rowBytes();
 
+                auto colorType = SkColorTypeToGrColorType(pixmap.colorType());
                 for (int i = 1; i < mipLevelCount; ++i) {
                     SkMipMap::Level generatedMipLevel;
                     mipmaps->getLevel(i - 1, &generatedMipLevel);
                     texels[i].fPixels = generatedMipLevel.fPixmap.addr();
                     texels[i].fRowBytes = generatedMipLevel.fPixmap.rowBytes();
                     SkASSERT(texels[i].fPixels);
+                    SkASSERT(generatedMipLevel.fPixmap.colorType() == pixmap.colorType());
                 }
-
                 return LazyCallbackResult(resourceProvider->createTexture(
-                        desc, format, GrRenderable::kNo, 1, SkBudgeted::kYes, GrProtected::kNo,
-                        texels.get(), mipLevelCount));
+                        desc, format, colorType, GrRenderable::kNo, 1, SkBudgeted::kYes,
+                        GrProtected::kNo, texels.get(), mipLevelCount));
             },
             format, desc, GrRenderable::kNo, 1, kTopLeft_GrSurfaceOrigin, GrMipMapped::kYes,
             GrMipMapsStatus::kValid, GrInternalSurfaceFlags::kNone, SkBackingFit::kExact,
diff --git a/src/gpu/GrResourceProvider.cpp b/src/gpu/GrResourceProvider.cpp
index 6d6352f..8408873 100644
--- a/src/gpu/GrResourceProvider.cpp
+++ b/src/gpu/GrResourceProvider.cpp
@@ -44,33 +44,36 @@
 
 // Ensures the row bytes are populated (not 0) and makes a copy to a temporary
 // to make the row bytes tight if necessary. Returns false if the input row bytes are invalid.
-static bool prepare_level(const GrMipLevel& inLevel, size_t bpp, int w, int h, bool rowBytesSupport,
+static bool prepare_level(const GrMipLevel& inLevel, int w, int h, bool rowBytesSupport,
+                          GrColorType origColorType, GrColorType allowedColorType,
                           GrMipLevel* outLevel, std::unique_ptr<char[]>* data) {
-    size_t minRB = w * bpp;
     if (!inLevel.fPixels) {
         outLevel->fPixels = nullptr;
         outLevel->fRowBytes = 0;
         return true;
     }
+    size_t minRB = w * GrColorTypeBytesPerPixel(origColorType);
     size_t actualRB = inLevel.fRowBytes ? inLevel.fRowBytes : minRB;
     if (actualRB < minRB) {
         return false;
     }
-    if (actualRB == minRB || rowBytesSupport) {
+    if (origColorType == allowedColorType && (actualRB == minRB || rowBytesSupport)) {
         outLevel->fRowBytes = actualRB;
         outLevel->fPixels = inLevel.fPixels;
-    } else {
-        data->reset(new char[minRB * h]);
-        outLevel->fPixels = data->get();
-        outLevel->fRowBytes = minRB;
-        SkRectMemcpy(data->get(), outLevel->fRowBytes, inLevel.fPixels, inLevel.fRowBytes, minRB,
-                     h);
+        return true;
     }
-    return true;
+    auto tempRB = w * GrColorTypeBytesPerPixel(allowedColorType);
+    data->reset(new char[tempRB * h]);
+    outLevel->fPixels = data->get();
+    outLevel->fRowBytes = minRB;
+    GrPixelInfo srcInfo(origColorType,    kUnpremul_SkAlphaType, nullptr, w, h);
+    GrPixelInfo dstInfo(allowedColorType, kUnpremul_SkAlphaType, nullptr, w, h);
+    return GrConvertPixels(dstInfo, data->get(), tempRB, srcInfo, inLevel.fPixels, actualRB);
 }
 
 sk_sp<GrTexture> GrResourceProvider::createTexture(const GrSurfaceDesc& desc,
                                                    const GrBackendFormat& format,
+                                                   GrColorType colorType,
                                                    GrRenderable renderable,
                                                    int renderTargetSampleCnt,
                                                    SkBudgeted budgeted,
@@ -90,6 +93,11 @@
                                       renderTargetSampleCnt, mipMapped)) {
         return nullptr;
     }
+    auto allowedColorType =
+            this->caps()->supportedWritePixelsColorType(colorType, format, colorType).fColorType;
+    if (allowedColorType == GrColorType::kUnknown) {
+        return nullptr;
+    }
     bool rowBytesSupport = this->caps()->writePixelsRowBytesSupport();
     SkAutoSTMalloc<14, GrMipLevel> tmpTexels;
     SkAutoSTArray<14, std::unique_ptr<char[]>> tmpDatas;
@@ -98,10 +106,9 @@
         tmpDatas.reset(mipLevelCount);
         int w = desc.fWidth;
         int h = desc.fHeight;
-        size_t bpp = GrBytesPerPixel(desc.fConfig);
         for (int i = 0; i < mipLevelCount; ++i) {
-            if (!prepare_level(texels[i], bpp, w, h, rowBytesSupport, &tmpTexels[i],
-                               &tmpDatas[i])) {
+            if (!prepare_level(texels[i], w, h, rowBytesSupport, colorType, allowedColorType,
+                               &tmpTexels[i], &tmpDatas[i])) {
                 return nullptr;
             }
             w = std::max(w / 2, 1);
@@ -109,7 +116,7 @@
         }
     }
     return fGpu->createTexture(desc, format, renderable, renderTargetSampleCnt, budgeted,
-                               isProtected, tmpTexels.get(), mipLevelCount);
+                               isProtected, colorType, colorType, tmpTexels.get(), mipLevelCount);
 }
 
 sk_sp<GrTexture> GrResourceProvider::getExactScratch(const GrSurfaceDesc& desc,
@@ -129,12 +136,12 @@
 
 sk_sp<GrTexture> GrResourceProvider::createTexture(const GrSurfaceDesc& desc,
                                                    const GrBackendFormat& format,
+                                                   GrColorType colorType,
                                                    GrRenderable renderable,
                                                    int renderTargetSampleCnt,
                                                    SkBudgeted budgeted,
                                                    SkBackingFit fit,
                                                    GrProtected isProtected,
-                                                   GrColorType srcColorType,
                                                    const GrMipLevel& mipLevel) {
     ASSERT_SINGLE_OWNER
 
@@ -154,43 +161,35 @@
     GrContext* context = fGpu->getContext();
     GrProxyProvider* proxyProvider = context->priv().proxyProvider();
 
-    bool rowBytesSupport = this->caps()->writePixelsRowBytesSupport();
-
-    size_t bpp = GrBytesPerPixel(desc.fConfig);
-    std::unique_ptr<char[]> tmpData;
-    GrMipLevel tmpLevel;
-    if (!prepare_level(mipLevel, bpp, desc.fWidth, desc.fHeight, rowBytesSupport, &tmpLevel,
-                       &tmpData)) {
-        return nullptr;
+    sk_sp<GrTexture> tex;
+    if (SkBackingFit::kApprox == fit) {
+        tex = this->createApproxTexture(desc, format, renderable, renderTargetSampleCnt,
+                                        isProtected);
+        if (!tex) {
+            return nullptr;
+        }
+        sk_sp<GrTextureProxy> proxy = proxyProvider->createWrapped(
+                tex, colorType, kTopLeft_GrSurfaceOrigin, GrSurfaceProxy::UseAllocator::kYes);
+        if (!proxy) {
+            return nullptr;
+        }
+        // Here we don't really know the alpha type of the data we want to upload. All we really
+        // care about is that it is not converted. So we use the same alpha type for the data
+        // and the surface context.
+        static constexpr auto kAlphaType = kUnpremul_SkAlphaType;
+        auto sContext =
+                context->priv().makeWrappedSurfaceContext(std::move(proxy), colorType, kAlphaType);
+        if (!sContext) {
+            return nullptr;
+        }
+        GrPixelInfo srcInfo(colorType, kAlphaType, nullptr, desc.fWidth, desc.fHeight);
+        SkAssertResult(
+                sContext->writePixels(srcInfo, mipLevel.fPixels, mipLevel.fRowBytes, {0, 0}));
+        return tex;
+    } else {
+        return this->createTexture(desc, format, colorType, renderable, renderTargetSampleCnt,
+                                   budgeted, isProtected, &mipLevel, 1);
     }
-
-    sk_sp<GrTexture> tex =
-            (SkBackingFit::kApprox == fit)
-                    ? this->createApproxTexture(desc, format, renderable, renderTargetSampleCnt,
-                                                isProtected)
-                    : this->createTexture(desc, format, renderable, renderTargetSampleCnt, budgeted,
-                                          isProtected);
-    if (!tex) {
-        return nullptr;
-    }
-
-    sk_sp<GrTextureProxy> proxy = proxyProvider->createWrapped(
-            tex, srcColorType, kTopLeft_GrSurfaceOrigin, GrSurfaceProxy::UseAllocator::kYes);
-    if (!proxy) {
-        return nullptr;
-    }
-    // Here we don't really know the alpha type of the data we want to upload. All we really
-    // care about is that it is not converted. So we use the same alpha type for the data
-    // and the surface context.
-    static constexpr auto kAlphaType = kUnpremul_SkAlphaType;
-    auto sContext =
-            context->priv().makeWrappedSurfaceContext(std::move(proxy), srcColorType, kAlphaType);
-    if (!sContext) {
-        return nullptr;
-    }
-    GrPixelInfo srcInfo(srcColorType, kAlphaType, nullptr, desc.fWidth, desc.fHeight);
-    SkAssertResult(sContext->writePixels(srcInfo, tmpLevel.fPixels, tmpLevel.fRowBytes, {0, 0}));
-    return tex;
 }
 
 sk_sp<GrTexture> GrResourceProvider::createCompressedTexture(int width, int height,
@@ -209,6 +208,7 @@
                                                    const GrBackendFormat& format,
                                                    GrRenderable renderable,
                                                    int renderTargetSampleCnt,
+                                                   GrMipMapped mipMapped,
                                                    SkBudgeted budgeted,
                                                    GrProtected isProtected) {
     ASSERT_SINGLE_OWNER
@@ -217,12 +217,13 @@
     }
 
     if (!fCaps->validateSurfaceParams({desc.fWidth, desc.fHeight}, format, desc.fConfig, renderable,
-                                      renderTargetSampleCnt, GrMipMapped::kNo)) {
+                                      renderTargetSampleCnt, mipMapped)) {
         return nullptr;
     }
 
     // Compressed textures are read-only so they don't support re-use for scratch.
-    if (!GrPixelConfigIsCompressed(desc.fConfig)) {
+    // TODO: Support GrMipMapped::kYes in scratch texture lookup here.
+    if (!GrPixelConfigIsCompressed(desc.fConfig) && mipMapped == GrMipMapped::kNo) {
         sk_sp<GrTexture> tex = this->getExactScratch(
                 desc, format, renderable, renderTargetSampleCnt, budgeted, isProtected);
         if (tex) {
@@ -230,7 +231,7 @@
         }
     }
 
-    return fGpu->createTexture(desc, format, renderable, renderTargetSampleCnt, budgeted,
+    return fGpu->createTexture(desc, format, renderable, renderTargetSampleCnt, mipMapped, budgeted,
                                isProtected);
 }
 
@@ -292,7 +293,7 @@
     }
 
     return fGpu->createTexture(copyDesc, format, renderable, renderTargetSampleCnt,
-                               SkBudgeted::kYes, isProtected);
+                               GrMipMapped::kNo, SkBudgeted::kYes, isProtected);
 }
 
 sk_sp<GrTexture> GrResourceProvider::refScratchTexture(const GrSurfaceDesc& desc,
diff --git a/src/gpu/GrResourceProvider.h b/src/gpu/GrResourceProvider.h
index 7d77bbf..78ebe4e 100644
--- a/src/gpu/GrResourceProvider.h
+++ b/src/gpu/GrResourceProvider.h
@@ -70,11 +70,18 @@
                                    const GrBackendFormat& format,
                                    GrRenderable renderable,
                                    int renderTargetSampleCnt,
+                                   GrMipMapped mipMapped,
                                    SkBudgeted budgeted,
                                    GrProtected isProtected);
 
+    /**
+     * Create an exact fit texture with initial data to upload. The color type must be valid
+     * for the format and also describe the texel data. This will ensure any conversions that
+     * need to get applied to the data before upload are applied.
+     */
     sk_sp<GrTexture> createTexture(const GrSurfaceDesc& desc,
                                    const GrBackendFormat& format,
+                                   GrColorType colorType,
                                    GrRenderable renderable,
                                    int renderTargetSampleCnt,
                                    SkBudgeted budgeted,
@@ -82,15 +89,19 @@
                                    const GrMipLevel texels[],
                                    int mipLevelCount);
 
-    /** Create a potentially loose fit texture with the provided data */
+    /**
+     * Create a potentially loose fit texture with the provided data. The color type must be valid
+     * for the format and also describe the texel data. This will ensure any conversions that
+     * need to get applied to the data before upload are applied.
+     */
     sk_sp<GrTexture> createTexture(const GrSurfaceDesc& desc,
                                    const GrBackendFormat& format,
+                                   GrColorType srcColorType,
                                    GrRenderable renderable,
                                    int renderTargetSampleCnt,
                                    SkBudgeted budgeted,
                                    SkBackingFit fit,
                                    GrProtected isProtected,
-                                   GrColorType srcColorType,
                                    const GrMipLevel& mipLevel);
 
     /**
diff --git a/src/gpu/GrSurfaceProxy.cpp b/src/gpu/GrSurfaceProxy.cpp
index 7f2c963..03c7e61 100644
--- a/src/gpu/GrSurfaceProxy.cpp
+++ b/src/gpu/GrSurfaceProxy.cpp
@@ -162,6 +162,7 @@
                                                    int minStencilSampleCount,
                                                    GrRenderable renderable,
                                                    GrMipMapped mipMapped) const {
+    SkASSERT(mipMapped == GrMipMapped::kNo || fFit == SkBackingFit::kExact);
     SkASSERT(!this->isLazy());
     SkASSERT(!fTarget);
     GrSurfaceDesc desc;
@@ -170,44 +171,12 @@
     desc.fConfig = fConfig;
 
     sk_sp<GrSurface> surface;
-    if (GrMipMapped::kYes == mipMapped) {
-        SkASSERT(SkBackingFit::kExact == fFit);
-
-        // SkMipMap doesn't include the base level in the level count so we have to add 1
-        int mipCount = SkMipMap::ComputeLevelCount(desc.fWidth, desc.fHeight) + 1;
-        // We should have caught the case where mipCount == 1 when making the proxy and instead
-        // created a non-mipmapped proxy.
-        SkASSERT(mipCount > 1);
-        std::unique_ptr<GrMipLevel[]> texels(new GrMipLevel[mipCount]);
-
-        // We don't want to upload any texel data
-        for (int i = 0; i < mipCount; i++) {
-            texels[i].fPixels = nullptr;
-            texels[i].fRowBytes = 0;
-        }
-        surface = resourceProvider->createTexture(desc, fFormat, renderable, sampleCnt, fBudgeted,
-                                                  fIsProtected, texels.get(), mipCount);
-#ifdef SK_DEBUG
-        if (surface) {
-            const GrTextureProxy* thisTexProxy = this->asTextureProxy();
-            SkASSERT(thisTexProxy);
-
-            GrTexture* texture = surface->asTexture();
-            SkASSERT(texture);
-
-            SkASSERT(GrMipMapped::kYes == texture->texturePriv().mipMapped());
-            SkASSERT(thisTexProxy->fInitialMipMapsStatus == texture->texturePriv().mipMapsStatus());
-        }
-#endif
+    if (SkBackingFit::kApprox == fFit) {
+        surface = resourceProvider->createApproxTexture(desc, fFormat, renderable, sampleCnt,
+                                                        fIsProtected);
     } else {
-        if (SkBackingFit::kApprox == fFit) {
-            surface = resourceProvider->createApproxTexture(desc, fFormat, renderable, sampleCnt,
-                                                            fIsProtected);
-        } else {
-            surface =
-                    resourceProvider->createTexture(desc, fFormat, renderable, sampleCnt, fBudgeted,
-                                                    fIsProtected);
-        }
+        surface = resourceProvider->createTexture(desc, fFormat, renderable, sampleCnt, mipMapped,
+                                                  fBudgeted, fIsProtected);
     }
     if (!surface) {
         return nullptr;
diff --git a/src/gpu/ccpr/GrCCAtlas.cpp b/src/gpu/ccpr/GrCCAtlas.cpp
index 92fca8e..55d8f97 100644
--- a/src/gpu/ccpr/GrCCAtlas.cpp
+++ b/src/gpu/ccpr/GrCCAtlas.cpp
@@ -122,8 +122,8 @@
                     desc.fHeight = fHeight;
                     desc.fConfig = pixelConfig;
                     fBackingTexture = resourceProvider->createTexture(
-                            desc, format, GrRenderable::kYes, sampleCount, SkBudgeted::kYes,
-                            GrProtected::kNo);
+                            desc, format, GrRenderable::kYes, sampleCount, GrMipMapped::kNo,
+                            SkBudgeted::kYes, GrProtected::kNo);
                 }
                 return fBackingTexture;
             },