diff --git a/tests/BackendAllocationTest.cpp b/tests/BackendAllocationTest.cpp
index 64e42c6..4541640 100644
--- a/tests/BackendAllocationTest.cpp
+++ b/tests/BackendAllocationTest.cpp
@@ -56,10 +56,10 @@
 void test_wrapping(GrDirectContext* dContext,
                    skiatest::Reporter* reporter,
                    std::function<GrBackendTexture (GrDirectContext*,
-                                                   GrMipMapped,
+                                                   GrMipmapped,
                                                    GrRenderable)> create,
                    GrColorType grColorType,
-                   GrMipMapped mipMapped,
+                   GrMipmapped mipMapped,
                    GrRenderable renderable,
                    bool* finishedBECreate) {
     GrResourceCache* cache = dContext->priv().getResourceCache();
@@ -314,11 +314,11 @@
                      skiatest::Reporter* reporter,
                      std::function<GrBackendTexture (GrDirectContext*,
                                                      const SkColor4f&,
-                                                     GrMipMapped,
+                                                     GrMipmapped,
                                                      GrRenderable)> create,
                      GrColorType grColorType,
                      const SkColor4f& color,
-                     GrMipMapped mipMapped,
+                     GrMipmapped mipMapped,
                      GrRenderable renderable,
                      bool* finishedBECreate) {
     GrBackendTexture backendTex = create(dContext, color, mipMapped, renderable);
@@ -337,7 +337,7 @@
     }
 
     auto checkBackendTexture = [&](const SkColor4f& testColor) {
-        if (mipMapped == GrMipMapped::kYes) {
+        if (mipMapped == GrMipmapped::kYes) {
             SkColor4f expectedColor = get_expected_color(testColor, skColorType);
             SkColor4f expectedColors[6] = {expectedColor, expectedColor, expectedColor,
                                            expectedColor, expectedColor, expectedColor};
@@ -450,10 +450,10 @@
     }
 }
 
-static int make_pixmaps(SkColorType skColorType, GrMipMapped mipMapped,
+static int make_pixmaps(SkColorType skColorType, GrMipmapped mipMapped,
                         const SkColor4f colors[6], SkAutoPixmapStorage pixmaps[6]) {
     int levelSize = 32;
-    int numMipLevels = mipMapped == GrMipMapped::kYes ? 6 : 1;
+    int numMipLevels = mipMapped == GrMipmapped::kYes ? 6 : 1;
     SkAlphaType at = SkColorTypeIsAlwaysOpaque(skColorType) ? kOpaque_SkAlphaType
                                                             : kPremul_SkAlphaType;
     for (int level = 0; level < numMipLevels; ++level) {
@@ -473,7 +473,7 @@
                                                              int numLevels,
                                                              GrRenderable)> create,
                              SkColorType skColorType,
-                             GrMipMapped mipMapped,
+                             GrMipmapped mipMapped,
                              GrRenderable renderable,
                              bool* finishedBECreate) {
     SkAutoPixmapStorage pixmapMem[6];
@@ -508,7 +508,7 @@
     }
 
     auto checkBackendTexture = [&](SkColor4f colors[6]) {
-        if (mipMapped == GrMipMapped::kYes) {
+        if (mipMapped == GrMipmapped::kYes) {
             SkColor4f expectedColors[6] = {
                     get_expected_color(colors[0], skColorType),
                     get_expected_color(colors[1], skColorType),
@@ -721,8 +721,8 @@
             }
         }
 
-        for (auto mipMapped : { GrMipMapped::kNo, GrMipMapped::kYes }) {
-            if (GrMipMapped::kYes == mipMapped && !caps->mipMapSupport()) {
+        for (auto mipMapped : { GrMipmapped::kNo, GrMipmapped::kYes }) {
+            if (GrMipmapped::kYes == mipMapped && !caps->mipMapSupport()) {
                 continue;
             }
 
@@ -741,7 +741,7 @@
 
                 {
                     auto uninitCreateMtd = [colorType](GrDirectContext* dContext,
-                                                       GrMipMapped mipMapped,
+                                                       GrMipmapped mipMapped,
                                                        GrRenderable renderable) {
                         auto result = dContext->createBackendTexture(32, 32, colorType,
                                                                      mipMapped, renderable,
@@ -771,7 +771,7 @@
 
                     auto createWithColorMtd = [colorType, finishedPtr](GrDirectContext* dContext,
                                                                        const SkColor4f& color,
-                                                                       GrMipMapped mipMapped,
+                                                                       GrMipmapped mipMapped,
                                                                        GrRenderable renderable) {
                         auto result = dContext->createBackendTexture(32, 32, colorType, color,
                                                                      mipMapped, renderable,
@@ -905,8 +905,8 @@
                 }
             }
 
-            for (auto mipMapped : {GrMipMapped::kNo, GrMipMapped::kYes}) {
-                if (GrMipMapped::kYes == mipMapped &&
+            for (auto mipMapped : {GrMipmapped::kNo, GrMipmapped::kYes}) {
+                if (GrMipmapped::kYes == mipMapped &&
                     (!glCaps->mipMapSupport() || target == GR_GL_TEXTURE_RECTANGLE)) {
                     continue;
                 }
@@ -920,7 +920,7 @@
 
                     {
                         auto uninitCreateMtd = [format](GrDirectContext* dContext,
-                                                        GrMipMapped mipMapped,
+                                                        GrMipmapped mipMapped,
                                                         GrRenderable renderable) {
                             return dContext->createBackendTexture(32, 32, format, mipMapped,
                                                                   renderable, GrProtected::kNo);
@@ -960,7 +960,7 @@
                         auto createWithColorMtd = [format, swizzle, finishedPtr](
                                                           GrDirectContext* dContext,
                                                           const SkColor4f& color,
-                                                          GrMipMapped mipMapped,
+                                                          GrMipmapped mipMapped,
                                                           GrRenderable renderable) {
                             auto swizzledColor = swizzle.applyTo(color);
                             return dContext->createBackendTexture(
@@ -1055,8 +1055,8 @@
 
         GrBackendFormat format = GrBackendFormat::MakeVk(combo.fFormat);
 
-        for (auto mipMapped : { GrMipMapped::kNo, GrMipMapped::kYes }) {
-            if (GrMipMapped::kYes == mipMapped && !vkCaps->mipMapSupport()) {
+        for (auto mipMapped : { GrMipmapped::kNo, GrMipmapped::kYes }) {
+            if (GrMipmapped::kYes == mipMapped && !vkCaps->mipMapSupport()) {
                 continue;
             }
 
@@ -1073,7 +1073,7 @@
 
                 {
                     auto uninitCreateMtd = [format](GrDirectContext* dContext,
-                                                    GrMipMapped mipMapped,
+                                                    GrMipmapped mipMapped,
                                                     GrRenderable renderable) {
                         GrBackendTexture beTex = dContext->createBackendTexture(32, 32, format,
                                                                                 mipMapped,
@@ -1126,7 +1126,7 @@
                     auto createWithColorMtd = [format, swizzle, finishedPtr](
                             GrDirectContext* dContext,
                             const SkColor4f& color,
-                            GrMipMapped mipMapped,
+                            GrMipmapped mipMapped,
                             GrRenderable renderable) {
                         auto swizzledColor = swizzle.applyTo(color);
                         GrBackendTexture beTex = dContext->createBackendTexture(32, 32, format,
diff --git a/tests/BackendSurfaceMutableStateTest.cpp b/tests/BackendSurfaceMutableStateTest.cpp
index 4ae2ebe..9576c20 100644
--- a/tests/BackendSurfaceMutableStateTest.cpp
+++ b/tests/BackendSurfaceMutableStateTest.cpp
@@ -24,7 +24,7 @@
 
     GrBackendFormat format = GrBackendFormat::MakeVk(VK_FORMAT_R8G8B8A8_UNORM);
     GrBackendTexture backendTex = context->createBackendTexture(
-            32, 32, format, GrMipMapped::kNo, GrRenderable::kNo, GrProtected::kNo);
+            32, 32, format, GrMipmapped::kNo, GrRenderable::kNo, GrProtected::kNo);
 
     REPORTER_ASSERT(reporter, backendTex.isValid());
 
diff --git a/tests/BlendTest.cpp b/tests/BlendTest.cpp
index f0bfb93..0ed9d4c 100644
--- a/tests/BlendTest.cpp
+++ b/tests/BlendTest.cpp
@@ -98,7 +98,7 @@
 
     *backingSurface =
             resourceProvider->createTexture(dimensions, format, GrRenderable::kYes, sampleCnt,
-                                            GrMipMapped::kNo, SkBudgeted::kNo, GrProtected::kNo);
+                                            GrMipmapped::kNo, SkBudgeted::kNo, GrProtected::kNo);
     if (!(*backingSurface)) {
         return nullptr;
     }
diff --git a/tests/BulkRectTest.cpp b/tests/BulkRectTest.cpp
index db7510c..776625c 100644
--- a/tests/BulkRectTest.cpp
+++ b/tests/BulkRectTest.cpp
@@ -26,7 +26,7 @@
                                                                            GrColorType::kRGBA_8888,
                                                                            GrRenderable::kYes);
     return rContext->priv().proxyProvider()->createProxy(
-            format, kDimensions, GrRenderable::kYes, 1, GrMipMapped::kNo, SkBackingFit::kExact,
+            format, kDimensions, GrRenderable::kYes, 1, GrMipmapped::kNo, SkBackingFit::kExact,
             SkBudgeted::kNo, GrProtected::kNo, GrInternalSurfaceFlags::kNone);
 }
 
diff --git a/tests/CompressedBackendAllocationTest.cpp b/tests/CompressedBackendAllocationTest.cpp
index 974cf75..ce06ff7 100644
--- a/tests/CompressedBackendAllocationTest.cpp
+++ b/tests/CompressedBackendAllocationTest.cpp
@@ -55,7 +55,7 @@
 static void check_compressed_mipmaps(GrRecordingContext* rContext, sk_sp<SkImage> img,
                                      SkImage::CompressionType compressionType,
                                      const SkColor4f expectedColors[6],
-                                     GrMipMapped mipMapped,
+                                     GrMipmapped mipMapped,
                                      skiatest::Reporter* reporter, const char* label) {
 
     SkImageInfo readbackSurfaceII = SkImageInfo::Make(32, 32, kRGBA_8888_SkColorType,
@@ -77,7 +77,7 @@
     p.setBlendMode(SkBlendMode::kSrc);
 
     int numMipLevels = 1;
-    if (mipMapped == GrMipMapped::kYes) {
+    if (mipMapped == GrMipmapped::kYes) {
         numMipLevels = SkMipmap::ComputeLevelCount(32, 32)+1;
     }
 
@@ -140,10 +140,10 @@
                                        skiatest::Reporter* reporter,
                                        std::function<GrBackendTexture (GrDirectContext*,
                                                                        const SkColor4f&,
-                                                                       GrMipMapped)> create,
+                                                                       GrMipmapped)> create,
                                        const SkColor4f& color,
                                        SkImage::CompressionType compression,
-                                       GrMipMapped mipMapped) {
+                                       GrMipmapped mipMapped) {
     GrBackendTexture backendTex = create(dContext, color, mipMapped);
     if (!backendTex.isValid()) {
         return;
@@ -167,25 +167,25 @@
 // Create compressed data pulling the color for each mipmap level from 'levelColors'.
 static std::unique_ptr<const char[]> make_compressed_data(SkImage::CompressionType compression,
                                                           SkColor4f levelColors[6],
-                                                          GrMipMapped mipMapped) {
+                                                          GrMipmapped mipMapped) {
     SkISize dimensions { 32, 32 };
 
     int numMipLevels = 1;
-    if (mipMapped == GrMipMapped::kYes) {
+    if (mipMapped == GrMipmapped::kYes) {
         numMipLevels = SkMipmap::ComputeLevelCount(dimensions.width(), dimensions.height()) + 1;
     }
 
     SkTArray<size_t> mipMapOffsets(numMipLevels);
 
     size_t dataSize = SkCompressedDataSize(compression, dimensions, &mipMapOffsets,
-                                           mipMapped == GrMipMapped::kYes);
+                                           mipMapped == GrMipmapped::kYes);
     char* data = new char[dataSize];
 
     for (int level = 0; level < numMipLevels; ++level) {
         // We have to do this a level at a time bc we might have a different color for
         // each level
         GrFillInCompressedData(compression, dimensions,
-                               GrMipMapped::kNo, &data[mipMapOffsets[level]], levelColors[level]);
+                               GrMipmapped::kNo, &data[mipMapOffsets[level]], levelColors[level]);
 
         dimensions = {std::max(1, dimensions.width() /2), std::max(1, dimensions.height()/2)};
     }
@@ -200,9 +200,9 @@
                                       std::function<GrBackendTexture (GrDirectContext*,
                                                                       const char* data,
                                                                       size_t dataSize,
-                                                                      GrMipMapped)> create,
+                                                                      GrMipmapped)> create,
                                       SkImage::CompressionType compression,
-                                      GrMipMapped mipMapped) {
+                                      GrMipmapped mipMapped) {
 
     SkColor4f expectedColors[6] = {
         { 1.0f, 0.0f, 0.0f, 1.0f }, // R
@@ -216,7 +216,7 @@
     std::unique_ptr<const char[]> data(make_compressed_data(compression, expectedColors,
                                                             mipMapped));
     size_t dataSize = SkCompressedDataSize(compression, { 32, 32 }, nullptr,
-                                           mipMapped == GrMipMapped::kYes);
+                                           mipMapped == GrMipmapped::kYes);
 
     GrBackendTexture backendTex = create(dContext, data.get(), dataSize, mipMapped);
     if (!backendTex.isValid()) {
@@ -259,8 +259,8 @@
             continue;
         }
 
-        for (auto mipMapped : { GrMipMapped::kNo, GrMipMapped::kYes }) {
-            if (GrMipMapped::kYes == mipMapped && !caps->mipMapSupport()) {
+        for (auto mipMapped : { GrMipmapped::kNo, GrMipmapped::kYes }) {
+            if (GrMipmapped::kYes == mipMapped && !caps->mipMapSupport()) {
                 continue;
             }
 
@@ -268,7 +268,7 @@
             {
                 auto createWithColorMtd = [format](GrDirectContext* dContext,
                                                    const SkColor4f& color,
-                                                   GrMipMapped mipMapped) {
+                                                   GrMipmapped mipMapped) {
                     return dContext->createCompressedBackendTexture(32, 32, format, color,
                                                                     mipMapped, GrProtected::kNo);
                 };
@@ -281,7 +281,7 @@
             {
                 auto createWithDataMtd = [format](GrDirectContext* dContext,
                                                   const char* data, size_t dataSize,
-                                                  GrMipMapped mipMapped) {
+                                                  GrMipmapped mipMapped) {
                     return dContext->createCompressedBackendTexture(32, 32, format, data, dataSize,
                                                                     mipMapped, GrProtected::kNo);
                 };
diff --git a/tests/DeferredDisplayListTest.cpp b/tests/DeferredDisplayListTest.cpp
index 4e6dfda..a472431 100644
--- a/tests/DeferredDisplayListTest.cpp
+++ b/tests/DeferredDisplayListTest.cpp
@@ -186,9 +186,9 @@
     sk_sp<SkSurface> make(GrDirectContext* dContext, GrBackendTexture* backend) const {
         const SkSurfaceCharacterization c = this->createCharacterization(dContext);
 
-        GrMipMapped mipmapped = !fIsTextureable
-                                        ? GrMipMapped::kNo
-                                        : GrMipMapped(fShouldCreateMipMaps);
+        GrMipmapped mipmapped = !fIsTextureable
+                                        ? GrMipmapped::kNo
+                                        : GrMipmapped(fShouldCreateMipMaps);
 
 #ifdef SK_GL
         if (fUsesGLFBO0) {
@@ -881,7 +881,7 @@
 
     GrBackendTexture backendTex;
     CreateBackendTexture(context, &backendTex, kSize, kSize, kRGBA_8888_SkColorType,
-            SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kNo, GrProtected::kNo);
+            SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kNo, GrProtected::kNo);
     if (!backendTex.isValid()) {
         return;
     }
@@ -972,7 +972,7 @@
         SkASSERT(format.isValid());
 
         sk_sp<SkImage> image = recorder.makePromiseTexture(
-                format, 32, 32, GrMipMapped::kNo,
+                format, 32, 32, GrMipmapped::kNo,
                 kTopLeft_GrSurfaceOrigin,
                 kRGBA_8888_SkColorType,
                 kPremul_SkAlphaType, nullptr,
@@ -1042,7 +1042,7 @@
 
     GrBackendTexture backendTexture;
 
-    if (!CreateBackendTexture(context, &backendTexture, ii, SkColors::kCyan, GrMipMapped::kNo,
+    if (!CreateBackendTexture(context, &backendTexture, ii, SkColors::kCyan, GrMipmapped::kNo,
                               GrRenderable::kNo)) {
         REPORTER_ASSERT(reporter, false);
         return;
@@ -1061,7 +1061,7 @@
         SkASSERT(format.isValid());
 
         sk_sp<SkImage> promiseImage = recorder.makePromiseTexture(
-                format, 32, 32, GrMipMapped::kNo,
+                format, 32, 32, GrMipmapped::kNo,
                 kTopLeft_GrSurfaceOrigin,
                 kRGBA_8888_SkColorType,
                 kPremul_SkAlphaType, nullptr,
@@ -1176,7 +1176,7 @@
     SkDeferredDisplayListRecorder recorder(characterization);
 
     for (GrGLenum target : { GR_GL_TEXTURE_EXTERNAL, GR_GL_TEXTURE_RECTANGLE, GR_GL_TEXTURE_2D } ) {
-        for (auto mipMapped : { GrMipMapped::kNo, GrMipMapped::kYes }) {
+        for (auto mipMapped : { GrMipmapped::kNo, GrMipmapped::kYes }) {
             GrBackendFormat format = GrBackendFormat::MakeGL(GR_GL_RGBA8, target);
 
             sk_sp<SkImage> image = recorder.makePromiseTexture(
@@ -1189,7 +1189,7 @@
                     dummy_done_proc,
                     nullptr,
                     SkDeferredDisplayListRecorder::PromiseImageApiVersion::kNew);
-            if (GR_GL_TEXTURE_2D != target && mipMapped == GrMipMapped::kYes) {
+            if (GR_GL_TEXTURE_2D != target && mipMapped == GrMipmapped::kYes) {
                 REPORTER_ASSERT(reporter, !image);
                 continue;
             }
diff --git a/tests/DeviceTest.cpp b/tests/DeviceTest.cpp
index 32453a4..b7e72bf 100644
--- a/tests/DeviceTest.cpp
+++ b/tests/DeviceTest.cpp
@@ -87,7 +87,7 @@
 
     sk_sp<SkBaseDevice> gpuDev(SkGpuDevice::Make(context, SkBudgeted::kNo, ii,
                                                  1, kBottomLeft_GrSurfaceOrigin, nullptr,
-                                                 GrMipMapped::kNo,
+                                                 GrMipmapped::kNo,
                                                  SkGpuDevice::kClear_InitContents));
 
     SkBitmap bm;
diff --git a/tests/EGLImageTest.cpp b/tests/EGLImageTest.cpp
index ea52cab..33494ad 100644
--- a/tests/EGLImageTest.cpp
+++ b/tests/EGLImageTest.cpp
@@ -89,7 +89,7 @@
     static const int kSize = 100;
 
     CreateBackendTexture(context1.get(), &backendTexture1, kSize, kSize, kRGBA_8888_SkColorType,
-                         SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kNo,
+                         SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kNo,
                          GrProtected::kNo);
 
     if (!backendTexture1.isValid()) {
@@ -154,7 +154,7 @@
     }
 
     // Wrap this texture ID in a GrTexture
-    GrBackendTexture backendTex(kSize, kSize, GrMipMapped::kNo, externalTexture);
+    GrBackendTexture backendTex(kSize, kSize, GrMipmapped::kNo, externalTexture);
 
     GrColorType colorType = GrColorType::kRGBA_8888;
     SkAlphaType alphaType = kPremul_SkAlphaType;
@@ -181,8 +181,8 @@
     }
 
     GrTextureProxy* proxy = surfaceContext->asTextureProxy();
-    REPORTER_ASSERT(reporter, proxy->mipMapped() == GrMipMapped::kNo);
-    REPORTER_ASSERT(reporter, proxy->peekTexture()->texturePriv().mipMapped() == GrMipMapped::kNo);
+    REPORTER_ASSERT(reporter, proxy->mipMapped() == GrMipmapped::kNo);
+    REPORTER_ASSERT(reporter, proxy->peekTexture()->texturePriv().mipMapped() == GrMipmapped::kNo);
 
     REPORTER_ASSERT(reporter, proxy->textureType() == GrTextureType::kExternal);
     REPORTER_ASSERT(reporter,
diff --git a/tests/ExtendedSkColorTypeTests.cpp b/tests/ExtendedSkColorTypeTests.cpp
index 19369ff..3122f4e 100644
--- a/tests/ExtendedSkColorTypeTests.cpp
+++ b/tests/ExtendedSkColorTypeTests.cpp
@@ -208,7 +208,7 @@
                                                         markFinished, &finishedBECreate);
         } else {
             backendTex = dContext->createBackendTexture(kSize, kSize, test.fColorType,
-                                                        SkColors::kWhite, GrMipMapped::kNo,
+                                                        SkColors::kWhite, GrMipmapped::kNo,
                                                         GrRenderable::kNo, GrProtected::kNo,
                                                         markFinished, &finishedBECreate);
         }
diff --git a/tests/GLBackendSurfaceTest.cpp b/tests/GLBackendSurfaceTest.cpp
index f5a61e2..e748292 100644
--- a/tests/GLBackendSurfaceTest.cpp
+++ b/tests/GLBackendSurfaceTest.cpp
@@ -50,7 +50,7 @@
     auto context = ctxInfo.directContext();
 
     GrBackendTexture backendTex = context->createBackendTexture(
-            1, 1, kRGBA_8888_SkColorType, GrMipMapped::kNo, GrRenderable::kNo, GrProtected::kNo);
+            1, 1, kRGBA_8888_SkColorType, GrMipmapped::kNo, GrRenderable::kNo, GrProtected::kNo);
     REPORTER_ASSERT(reporter, backendTex.isValid());
 
     GrGLTextureInfo info;
diff --git a/tests/GrMipMappedTest.cpp b/tests/GrMipMappedTest.cpp
index e2ee1e1..82dcd80 100644
--- a/tests/GrMipMappedTest.cpp
+++ b/tests/GrMipMappedTest.cpp
@@ -39,7 +39,7 @@
         return;
     }
 
-    for (auto mipMapped : {GrMipMapped::kNo, GrMipMapped::kYes}) {
+    for (auto mipMapped : {GrMipmapped::kNo, GrMipmapped::kYes}) {
         for (auto renderable : {GrRenderable::kNo, GrRenderable::kYes}) {
             // createBackendTexture currently doesn't support uploading data to mip maps
             // so we don't send any. However, we pretend there is data for the checks below which is
@@ -91,15 +91,15 @@
                 return;
             }
 
-            if (GrMipMapped::kYes == mipMapped) {
-                REPORTER_ASSERT(reporter, GrMipMapped::kYes == texture->texturePriv().mipMapped());
+            if (GrMipmapped::kYes == mipMapped) {
+                REPORTER_ASSERT(reporter, GrMipmapped::kYes == texture->texturePriv().mipMapped());
                 if (GrRenderable::kYes == renderable) {
                     REPORTER_ASSERT(reporter, texture->texturePriv().mipMapsAreDirty());
                 } else {
                     REPORTER_ASSERT(reporter, !texture->texturePriv().mipMapsAreDirty());
                 }
             } else {
-                REPORTER_ASSERT(reporter, GrMipMapped::kNo == texture->texturePriv().mipMapped());
+                REPORTER_ASSERT(reporter, GrMipmapped::kNo == texture->texturePriv().mipMapped());
             }
             context->deleteBackendTexture(backendTex);
         }
@@ -114,8 +114,8 @@
         return;
     }
 
-    for (auto betMipMapped : {GrMipMapped::kNo, GrMipMapped::kYes}) {
-        for (auto requestMipMapped : {GrMipMapped::kNo, GrMipMapped::kYes}) {
+    for (auto betMipMapped : {GrMipmapped::kNo, GrMipmapped::kYes}) {
+        for (auto requestMipMapped : {GrMipmapped::kNo, GrMipmapped::kYes}) {
             GrBackendTexture backendTex;
             CreateBackendTexture(context, &backendTex, kSize, kSize, kRGBA_8888_SkColorType,
                                  SkColors::kTransparent, betMipMapped, GrRenderable::kNo);
@@ -190,7 +190,7 @@
                 GrGLTextureInfo origTexInfo;
                 if (genBackendTex.getGLTextureInfo(&genTexInfo) &&
                     backendTex.getGLTextureInfo(&origTexInfo)) {
-                    if (requestMipMapped == GrMipMapped::kYes && betMipMapped == GrMipMapped::kNo) {
+                    if (requestMipMapped == GrMipmapped::kYes && betMipMapped == GrMipmapped::kNo) {
                         // We did a copy so the texture IDs should be different
                         REPORTER_ASSERT(reporter, origTexInfo.fID != genTexInfo.fID);
                     } else {
@@ -205,7 +205,7 @@
                 GrVkImageInfo origImageInfo;
                 if (genBackendTex.getVkImageInfo(&genImageInfo) &&
                     backendTex.getVkImageInfo(&origImageInfo)) {
-                    if (requestMipMapped == GrMipMapped::kYes && betMipMapped == GrMipMapped::kNo) {
+                    if (requestMipMapped == GrMipmapped::kYes && betMipMapped == GrMipmapped::kNo) {
                         // We did a copy so the texture IDs should be different
                         REPORTER_ASSERT(reporter, origImageInfo.fImage != genImageInfo.fImage);
                     } else {
@@ -221,7 +221,7 @@
                 GrMtlTextureInfo origImageInfo;
                 if (genBackendTex.getMtlTextureInfo(&genImageInfo) &&
                     backendTex.getMtlTextureInfo(&origImageInfo)) {
-                    if (requestMipMapped == GrMipMapped::kYes && betMipMapped == GrMipMapped::kNo) {
+                    if (requestMipMapped == GrMipmapped::kYes && betMipMapped == GrMipmapped::kNo) {
                         // We did a copy so the texture IDs should be different
                         REPORTER_ASSERT(reporter, origImageInfo.fTexture != genImageInfo.fTexture);
                     } else {
@@ -258,7 +258,7 @@
 
     for (auto willUseMips : {false, true}) {
         for (auto isWrapped : {false, true}) {
-            GrMipMapped mipMapped = willUseMips ? GrMipMapped::kYes : GrMipMapped::kNo;
+            GrMipmapped mipMapped = willUseMips ? GrMipmapped::kYes : GrMipmapped::kNo;
             sk_sp<SkSurface> surface;
             GrBackendTexture backendTex;
             CreateBackendTexture(context, &backendTex, kSize, kSize, kRGBA_8888_SkColorType,
@@ -352,7 +352,7 @@
         GrRecordingContext* context, GrProxyProvider* proxyProvider, GrColorType colorType,
         SkAlphaType alphaType, GrSurfaceProxyView mipmapView, GrSamplerState::Filter filter) {
     sk_sp<GrSurfaceProxy> renderTarget = proxyProvider->createProxy(
-            mipmapView.proxy()->backendFormat(), {1, 1}, GrRenderable::kYes, 1, GrMipMapped::kNo,
+            mipmapView.proxy()->backendFormat(), {1, 1}, GrRenderable::kYes, 1, GrMipmapped::kNo,
             SkBackingFit::kApprox, SkBudgeted::kYes, GrProtected::kNo);
 
     auto rtc = GrRenderTargetContext::Make(
@@ -396,7 +396,7 @@
         // Create a mipmapped render target.
 
         sk_sp<GrTextureProxy> mipmapProxy = proxyProvider->createProxy(
-                format, {4, 4}, GrRenderable::kYes, 1, GrMipMapped::kYes, SkBackingFit::kExact,
+                format, {4, 4}, 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
diff --git a/tests/GrPorterDuffTest.cpp b/tests/GrPorterDuffTest.cpp
index c7112f8..8e9acd6 100644
--- a/tests/GrPorterDuffTest.cpp
+++ b/tests/GrPorterDuffTest.cpp
@@ -1001,7 +1001,7 @@
 
     GrBackendTexture backendTex;
     CreateBackendTexture(ctx, &backendTex, 100, 100, kRGBA_8888_SkColorType,
-                         SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kNo);
+                         SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kNo);
 
     GrXferProcessor::DstProxyView fakeDstProxyView;
     {
diff --git a/tests/GrSurfaceTest.cpp b/tests/GrSurfaceTest.cpp
index b366c07..41d67ae 100644
--- a/tests/GrSurfaceTest.cpp
+++ b/tests/GrSurfaceTest.cpp
@@ -34,7 +34,7 @@
     auto format = context->priv().caps()->getDefaultBackendFormat(GrColorType::kRGBA_8888,
                                                                   GrRenderable::kYes);
     sk_sp<GrSurface> texRT1 =
-            resourceProvider->createTexture(kDesc, format, GrRenderable::kYes, 1, GrMipMapped::kNo,
+            resourceProvider->createTexture(kDesc, format, GrRenderable::kYes, 1, GrMipmapped::kNo,
                                             SkBudgeted::kNo, GrProtected::kNo);
 
     REPORTER_ASSERT(reporter, texRT1.get() == texRT1->asRenderTarget());
@@ -47,7 +47,7 @@
                     static_cast<GrSurface*>(texRT1->asTexture()));
 
     sk_sp<GrTexture> tex1 =
-            resourceProvider->createTexture(kDesc, format, GrRenderable::kNo, 1, GrMipMapped::kNo,
+            resourceProvider->createTexture(kDesc, format, GrRenderable::kNo, 1, GrMipmapped::kNo,
                                             SkBudgeted::kNo, GrProtected::kNo);
     REPORTER_ASSERT(reporter, nullptr == tex1->asRenderTarget());
     REPORTER_ASSERT(reporter, tex1.get() == tex1->asTexture());
@@ -55,7 +55,7 @@
 
     GrBackendTexture backendTex = context->createBackendTexture(
         256, 256, kRGBA_8888_SkColorType,
-        SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kNo, GrProtected::kNo);
+        SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kNo, GrProtected::kNo);
 
     sk_sp<GrSurface> texRT2 = resourceProvider->wrapRenderableBackendTexture(
             backendTex, 1, kBorrow_GrWrapOwnership, GrWrapCacheable::kNo);
@@ -93,12 +93,12 @@
             auto size = SkCompressedDataSize(compression, dimensions, nullptr, false);
             auto data = SkData::MakeUninitialized(size);
             SkColor4f color = {0, 0, 0, 0};
-            GrFillInCompressedData(compression, dimensions, GrMipMapped::kNo,
+            GrFillInCompressedData(compression, dimensions, GrMipmapped::kNo,
                                    (char*)data->writable_data(), color);
             return rp->createCompressedTexture(dimensions, format, SkBudgeted::kNo,
-                                               GrMipMapped::kNo, GrProtected::kNo, data.get());
+                                               GrMipmapped::kNo, GrProtected::kNo, data.get());
         } else {
-            return rp->createTexture(dimensions, format, renderable, 1, GrMipMapped::kNo,
+            return rp->createTexture(dimensions, format, renderable, 1, GrMipmapped::kNo,
                                      SkBudgeted::kNo, GrProtected::kNo);
         }
     };
@@ -138,7 +138,7 @@
             bool expectedMipMapability = isTexturable && caps->mipMapSupport() && !isCompressed;
 
             sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
-                    combo.fFormat, kDims, GrRenderable::kNo, 1, GrMipMapped::kYes,
+                    combo.fFormat, kDims, 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",
@@ -151,7 +151,7 @@
             bool isRenderable = caps->isFormatRenderable(combo.fFormat, 1);
 
             sk_sp<GrSurface> tex = resourceProvider->createTexture(
-                    kDims, combo.fFormat, GrRenderable::kYes, 1, GrMipMapped::kNo, SkBudgeted::kNo,
+                    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",
@@ -164,7 +164,7 @@
             bool isRenderable = caps->isFormatRenderable(combo.fFormat, 2);
 
             sk_sp<GrSurface> tex = resourceProvider->createTexture(
-                    kDims, combo.fFormat, GrRenderable::kYes, 2, GrMipMapped::kNo, SkBudgeted::kNo,
+                    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",
@@ -290,12 +290,12 @@
                         if (renderable == GrRenderable::kYes) {
                             surfCtx = GrRenderTargetContext::Make(
                                     context, combo.fColorType, nullptr, fit,
-                                    {desc.fWidth, desc.fHeight}, 1, GrMipMapped::kNo,
+                                    {desc.fWidth, desc.fHeight}, 1, GrMipmapped::kNo,
                                     GrProtected::kNo, kTopLeft_GrSurfaceOrigin);
                         } else {
                             surfCtx = GrSurfaceContext::Make(
                                     context, {desc.fWidth, desc.fHeight}, combo.fFormat,
-                                    GrRenderable::kNo, 1, GrMipMapped::kNo, GrProtected::kNo,
+                                    GrRenderable::kNo, 1, GrMipmapped::kNo, GrProtected::kNo,
                                     kTopLeft_GrSurfaceOrigin, combo.fColorType,
                                     kUnknown_SkAlphaType, nullptr, fit, SkBudgeted::kYes);
                         }
@@ -400,7 +400,7 @@
 
         GrBitmapTextureMaker maker(context, copySrcBitmap,
                                    GrImageTexGenPolicy::kNew_Uncached_Budgeted);
-        auto copySrc = maker.view(GrMipMapped::kNo);
+        auto copySrc = maker.view(GrMipmapped::kNo);
 
         REPORTER_ASSERT(reporter, copySrc.proxy());
         auto copyResult = surfContext->testCopy(copySrc.proxy());
@@ -417,7 +417,7 @@
             DeleteBackendTexture(context, backendTex);
             backendTex = context->createBackendTexture(
                     kSize, kSize, kRGBA_8888_SkColorType,
-                    SkColors::kTransparent, GrMipMapped::kYes, GrRenderable::kYes,
+                    SkColors::kTransparent, GrMipmapped::kYes, GrRenderable::kYes,
                     GrProtected::kNo);
             proxy = proxyProvider->wrapBackendTexture(backendTex, kBorrow_GrWrapOwnership,
                                                       GrWrapCacheable::kNo, ioType);
@@ -436,7 +436,7 @@
 static sk_sp<GrTexture> make_wrapped_texture(GrDirectContext* dContext, GrRenderable renderable) {
     GrBackendTexture backendTexture;
     CreateBackendTexture(dContext, &backendTexture, kSurfSize, kSurfSize, kRGBA_8888_SkColorType,
-                         SkColors::kTransparent, GrMipMapped::kNo, renderable, GrProtected::kNo);
+                         SkColors::kTransparent, GrMipmapped::kNo, renderable, GrProtected::kNo);
     SkASSERT(backendTexture.isValid());
     sk_sp<GrTexture> texture;
     if (GrRenderable::kYes == renderable) {
@@ -467,7 +467,7 @@
     auto format = dContext->priv().caps()->getDefaultBackendFormat(GrColorType::kRGBA_8888,
                                                                    renderable);
     return dContext->priv().resourceProvider()->createTexture(
-            desc, format, renderable, 1, GrMipMapped::kNo, SkBudgeted::kNo, GrProtected::kNo);
+            desc, format, renderable, 1, GrMipmapped::kNo, SkBudgeted::kNo, GrProtected::kNo);
 }
 
 DEF_GPUTEST(TextureIdleProcTest, reporter, options) {
@@ -568,7 +568,7 @@
                     budgeted = SkBudgeted::kNo;
                 }
                 auto proxy = dContext->priv().proxyProvider()->createLazyProxy(
-                        singleUseLazyCB, backendFormat, desc, renderable, 1, GrMipMapped::kNo,
+                        singleUseLazyCB, backendFormat, desc, renderable, 1, GrMipmapped::kNo,
                         GrMipMapsStatus::kNotAllocated, GrInternalSurfaceFlags ::kNone,
                         SkBackingFit::kExact, budgeted, GrProtected::kNo,
                         GrSurfaceProxy::UseAllocator::kYes);
@@ -741,7 +741,7 @@
             GrBackendTexture backendTexture;
 
             if (!CreateBackendTexture(dContext, &backendTexture, info, SkColors::kBlack,
-                                      GrMipMapped::kNo, GrRenderable::kNo)) {
+                                      GrMipmapped::kNo, GrRenderable::kNo)) {
                 REPORTER_ASSERT(reporter, false);
                 continue;
             }
diff --git a/tests/GrTestingBackendTextureUploadTest.cpp b/tests/GrTestingBackendTextureUploadTest.cpp
index 2d6fbff..d57ffd7 100644
--- a/tests/GrTestingBackendTextureUploadTest.cpp
+++ b/tests/GrTestingBackendTextureUploadTest.cpp
@@ -15,7 +15,7 @@
 #include "tests/TestUtils.h"
 
 void testing_only_texture_test(skiatest::Reporter* reporter, GrContext* context, SkColorType ct,
-                               GrRenderable renderable, bool doDataUpload, GrMipMapped mipMapped) {
+                               GrRenderable renderable, bool doDataUpload, GrMipmapped mipMapped) {
     auto direct = context->asDirectContext();
     if (!direct) {
         return;
@@ -42,7 +42,7 @@
     GrBackendTexture backendTex;
 
     if (doDataUpload) {
-        SkASSERT(GrMipMapped::kNo == mipMapped);
+        SkASSERT(GrMipmapped::kNo == mipMapped);
 
         FillPixelData(kWidth, kHeight, expectedPixels.writable_addr32(0, 0));
 
@@ -98,11 +98,11 @@
         for (auto renderable: { GrRenderable::kYes, GrRenderable::kNo }) {
             for (bool doDataUpload: {true, false}) {
                 testing_only_texture_test(reporter, ctxInfo.directContext(), colorType,
-                                          renderable, doDataUpload, GrMipMapped::kNo);
+                                          renderable, doDataUpload, GrMipmapped::kNo);
 
                 if (!doDataUpload) {
                     testing_only_texture_test(reporter, ctxInfo.directContext(), colorType,
-                                              renderable, doDataUpload, GrMipMapped::kYes);
+                                              renderable, doDataUpload, GrMipmapped::kYes);
                 }
             }
         }
diff --git a/tests/GrTextureMipMapInvalidationTest.cpp b/tests/GrTextureMipMapInvalidationTest.cpp
index a01b887..8ddcbe0 100644
--- a/tests/GrTextureMipMapInvalidationTest.cpp
+++ b/tests/GrTextureMipMapInvalidationTest.cpp
@@ -24,7 +24,7 @@
     auto isMipped = [] (SkSurface* surf) {
         SkImage_GpuBase* image = static_cast<SkImage_GpuBase*>(as_IB(surf->makeImageSnapshot()));
         const GrTexture* texture = image->getTexture();
-        return GrMipMapped::kYes == texture->texturePriv().mipMapped();
+        return GrMipmapped::kYes == texture->texturePriv().mipMapped();
     };
 
     auto mipsAreDirty = [] (SkSurface* surf) {
diff --git a/tests/ImageFilterCacheTest.cpp b/tests/ImageFilterCacheTest.cpp
index 46aa8c3..160c0f7 100644
--- a/tests/ImageFilterCacheTest.cpp
+++ b/tests/ImageFilterCacheTest.cpp
@@ -210,7 +210,7 @@
 static GrSurfaceProxyView create_proxy_view(GrRecordingContext* context) {
     SkBitmap srcBM = create_bm();
     GrBitmapTextureMaker maker(context, srcBM, GrImageTexGenPolicy::kNew_Uncached_Budgeted);
-    return maker.view(GrMipMapped::kNo);
+    return maker.view(GrMipmapped::kNo);
 }
 
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_ImageBackedGPU, reporter, ctxInfo) {
diff --git a/tests/ImageTest.cpp b/tests/ImageTest.cpp
index 9f9e433..a0deb41 100644
--- a/tests/ImageTest.cpp
+++ b/tests/ImageTest.cpp
@@ -392,7 +392,7 @@
                 otherContextInfo.directContext()->flushAndSubmit();
                 return otherContextImage;
             }};
-    for (auto mipMapped : {GrMipMapped::kNo, GrMipMapped::kYes}) {
+    for (auto mipMapped : {GrMipmapped::kNo, GrMipmapped::kYes}) {
         for (auto factory : imageFactories) {
             sk_sp<SkImage> image(factory());
             if (!image) {
@@ -421,12 +421,12 @@
                 GrTextureProxy* copyProxy = as_IB(texImage)->peekProxy()->asTextureProxy();
                 SkASSERT(copyProxy);
                 bool shouldBeMipped =
-                        mipMapped == GrMipMapped::kYes && context->priv().caps()->mipMapSupport();
-                if (shouldBeMipped && copyProxy->mipMapped() == GrMipMapped::kNo) {
+                        mipMapped == GrMipmapped::kYes && context->priv().caps()->mipMapSupport();
+                if (shouldBeMipped && copyProxy->mipMapped() == GrMipmapped::kNo) {
                     ERRORF(reporter, "makeTextureImage returned non-mipmapped texture.");
                     continue;
                 }
-                bool origIsMipped = origProxy && origProxy->mipMapped() == GrMipMapped::kYes;
+                bool origIsMipped = origProxy && origProxy->mipMapped() == GrMipmapped::kYes;
                 if (image->isTextureBacked() && (!shouldBeMipped || origIsMipped)) {
                     if (origProxy->underlyingUniqueID() != copyProxy->underlyingUniqueID()) {
                         ERRORF(reporter, "makeTextureImage made unnecessary texture copy.");
@@ -486,7 +486,7 @@
 
         GrBackendTexture backendTex;
         CreateBackendTexture(context, &backendTex, kSize, kSize, colorType, SkColors::kTransparent,
-                             GrMipMapped::kNo, GrRenderable::kNo, GrProtected::kNo);
+                             GrMipmapped::kNo, GrRenderable::kNo, GrProtected::kNo);
 
         auto img = SkImage::MakeFromTexture(context, backendTex, kTopLeft_GrSurfaceOrigin,
                                             colorType, kOpaque_SkAlphaType, nullptr);
@@ -823,7 +823,7 @@
     SkImageInfo ii = SkImageInfo::Make(kWidth, kHeight, SkColorType::kRGBA_8888_SkColorType,
                                        kPremul_SkAlphaType);
     GrBackendTexture backendTex;
-    if (!CreateBackendTexture(ctx, &backendTex, ii, SkColors::kRed, GrMipMapped::kNo,
+    if (!CreateBackendTexture(ctx, &backendTex, ii, SkColors::kRed, GrMipmapped::kNo,
                               GrRenderable::kNo)) {
         ERRORF(reporter, "couldn't create backend texture\n");
     }
@@ -972,17 +972,17 @@
             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, GrMipMapped::kNo);
+            GrSurfaceProxyView view = as_IB(refImg)->refView(ctx, GrMipmapped::kNo);
             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, GrMipMapped::kNo);
+            GrSurfaceProxyView otherView = as_IB(refImg)->refView(otherCtx, GrMipmapped::kNo);
             REPORTER_ASSERT(reporter, !otherView);
 
             // Original context (that's already borrowing) should be okay
             testContext->makeCurrent();
-            GrSurfaceProxyView viewSecondRef = as_IB(refImg)->refView(ctx, GrMipMapped::kNo);
+            GrSurfaceProxyView viewSecondRef = as_IB(refImg)->refView(ctx, GrMipmapped::kNo);
             REPORTER_ASSERT(reporter, viewSecondRef);
 
             // Release first ref from the original context
@@ -991,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, GrMipMapped::kNo);
+            otherView = as_IB(refImg)->refView(otherCtx, GrMipmapped::kNo);
             REPORTER_ASSERT(reporter, !otherView);
 
             // Release second ref from the original context
@@ -1000,7 +1000,7 @@
 
             // Now we should be able to borrow the texture from the other context
             otherTestContext->makeCurrent();
-            otherView = as_IB(refImg)->refView(otherCtx, GrMipMapped::kNo);
+            otherView = as_IB(refImg)->refView(otherCtx, GrMipmapped::kNo);
             REPORTER_ASSERT(reporter, otherView);
 
             // Release everything
@@ -1041,7 +1041,7 @@
             sk_sp<SkImage> image = SkImage::MakeCrossContextFromPixmap(ctx, pixmap, false);
             REPORTER_ASSERT(reporter, image);
 
-            GrSurfaceProxyView view = as_IB(image)->refView(ctx, GrMipMapped::kNo);
+            GrSurfaceProxyView view = as_IB(image)->refView(ctx, GrMipmapped::kNo);
             REPORTER_ASSERT(reporter, view);
 
             bool expectAlpha = kAlpha_8_SkColorType == ct;
diff --git a/tests/LazyProxyTest.cpp b/tests/LazyProxyTest.cpp
index bde6739..cce8907 100644
--- a/tests/LazyProxyTest.cpp
+++ b/tests/LazyProxyTest.cpp
@@ -64,7 +64,7 @@
         }
 
         void visitProxies(const VisitProxyFunc& func) const override {
-            func(fProxy.get(), GrMipMapped::kNo);
+            func(fProxy.get(), GrMipmapped::kNo);
         }
 
         void onExecute(GrOpFlushState*, const SkRect& chainBounds) override {
@@ -231,7 +231,7 @@
                                                            GrRenderable::kNo);
 
     auto tex = ctx->priv().resourceProvider()->createTexture({kSize, kSize}, format,
-                                                             GrRenderable::kNo, 1, GrMipMapped::kNo,
+                                                             GrRenderable::kNo, 1, GrMipmapped::kNo,
                                                              SkBudgeted::kNo, GrProtected::kNo);
     using LazyInstantiationResult = GrSurfaceProxy::LazyCallbackResult;
     for (bool doInstantiate : {true, false}) {
@@ -273,7 +273,7 @@
             };
             sk_sp<GrTextureProxy> proxy = proxyProvider->createLazyProxy(
                     TestCallback(&testCount, releaseCallback, tex), format, {kSize, kSize},
-                    GrRenderable::kNo, 1, GrMipMapped::kNo, GrMipMapsStatus::kNotAllocated,
+                    GrRenderable::kNo, 1, GrMipmapped::kNo, GrMipMapsStatus::kNotAllocated,
                     GrInternalSurfaceFlags::kNone, SkBackingFit::kExact, SkBudgeted::kNo,
                     GrProtected::kNo, GrSurfaceProxy::UseAllocator::kYes);
 
@@ -315,7 +315,7 @@
     }
 
     void visitProxies(const VisitProxyFunc& func) const override {
-        func(fLazyProxy.get(), GrMipMapped::kNo);
+        func(fLazyProxy.get(), GrMipmapped::kNo);
     }
 
 private:
@@ -343,7 +343,7 @@
                                               desc.fProtected),
                             true, GrSurfaceProxy::LazyInstantiationKeyMode::kUnsynced};
                 },
-                format, dims, GrRenderable::kNo, 1, GrMipMapped::kNo,
+                format, dims, GrRenderable::kNo, 1, GrMipmapped::kNo,
                 GrMipMapsStatus::kNotAllocated, GrInternalSurfaceFlags::kNone, SkBackingFit::kExact,
                 SkBudgeted::kNo, GrProtected::kNo, GrSurfaceProxy::UseAllocator::kYes);
 
diff --git a/tests/MtlBackendAllocationTest.mm b/tests/MtlBackendAllocationTest.mm
index 8438dcf..dd6eaef 100644
--- a/tests/MtlBackendAllocationTest.mm
+++ b/tests/MtlBackendAllocationTest.mm
@@ -16,10 +16,10 @@
 void test_wrapping(GrDirectContext*,
                    skiatest::Reporter*,
                    std::function<GrBackendTexture (GrDirectContext*,
-                                                   GrMipMapped,
+                                                   GrMipmapped,
                                                    GrRenderable)> create,
                    GrColorType,
-                   GrMipMapped,
+                   GrMipmapped,
                    GrRenderable,
                    bool* finishedBackendCreation);
 
@@ -27,11 +27,11 @@
                      skiatest::Reporter*,
                      std::function<GrBackendTexture (GrDirectContext*,
                                                      const SkColor4f&,
-                                                     GrMipMapped,
+                                                     GrMipmapped,
                                                      GrRenderable)> create,
                      GrColorType,
                      const SkColor4f&,
-                     GrMipMapped,
+                     GrMipmapped,
                      GrRenderable,
                      bool* finishedBackendCreation);
 
@@ -101,8 +101,8 @@
             continue;
         }
 
-        for (auto mipMapped : { GrMipMapped::kNo, GrMipMapped::kYes }) {
-            if (GrMipMapped::kYes == mipMapped && !mtlCaps->mipMapSupport()) {
+        for (auto mipMapped : { GrMipmapped::kNo, GrMipmapped::kYes }) {
+            if (GrMipmapped::kYes == mipMapped && !mtlCaps->mipMapSupport()) {
                 continue;
             }
 
@@ -119,7 +119,7 @@
 
                 {
                     auto uninitCreateMtd = [format](GrDirectContext* dContext,
-                                                    GrMipMapped mipMapped,
+                                                    GrMipmapped mipMapped,
                                                     GrRenderable renderable) {
                         return dContext->createBackendTexture(32, 32, format,
                                                               mipMapped, renderable,
@@ -160,7 +160,7 @@
                     auto createWithColorMtd = [format, swizzle, finishedPtr](
                             GrDirectContext* dContext,
                             const SkColor4f& color,
-                            GrMipMapped mipMapped,
+                            GrMipmapped mipMapped,
                             GrRenderable renderable) {
                         auto swizzledColor = swizzle.applyTo(color);
                         return dContext->createBackendTexture(32, 32, format, swizzledColor,
diff --git a/tests/MtlCopySurfaceTest.mm b/tests/MtlCopySurfaceTest.mm
index 41a0f62..986e076 100644
--- a/tests/MtlCopySurfaceTest.mm
+++ b/tests/MtlCopySurfaceTest.mm
@@ -47,7 +47,7 @@
     auto dstProxy = GrSurfaceProxy::Copy(context,
                                          srcProxy.get(),
                                          kTopLeft_GrSurfaceOrigin,
-                                         GrMipMapped::kNo,
+                                         GrMipmapped::kNo,
                                          SkBackingFit::kExact,
                                          SkBudgeted::kYes);
 
@@ -62,7 +62,7 @@
     GrSurface* src = srcProxy->peekSurface();
     sk_sp<GrTexture> dst =
             gpu->createTexture({kWidth, kHeight}, backendFormat, GrRenderable::kNo, 1,
-                               GrMipMapped::kNo, SkBudgeted::kNo, GrProtected::kNo);
+                               GrMipmapped::kNo, SkBudgeted::kNo, GrProtected::kNo);
 
     bool result = gpu->copySurface(dst.get(), src, SkIRect::MakeXYWH(0, 0, kWidth, kHeight),
                                    SkIPoint::Make(0, 0));
diff --git a/tests/OpChainTest.cpp b/tests/OpChainTest.cpp
index 6aecafc..3f8885e 100644
--- a/tests/OpChainTest.cpp
+++ b/tests/OpChainTest.cpp
@@ -181,7 +181,7 @@
 
     static const GrSurfaceOrigin kOrigin = kTopLeft_GrSurfaceOrigin;
     auto proxy = dContext->priv().proxyProvider()->createProxy(
-            format, kDims, GrRenderable::kYes, 1, GrMipMapped::kNo, SkBackingFit::kExact,
+            format, kDims, GrRenderable::kYes, 1, GrMipmapped::kNo, SkBackingFit::kExact,
             SkBudgeted::kNo, GrProtected::kNo, GrInternalSurfaceFlags::kNone);
     SkASSERT(proxy);
     proxy->instantiate(dContext->priv().resourceProvider());
diff --git a/tests/PathRendererCacheTests.cpp b/tests/PathRendererCacheTests.cpp
index 097bee2..d09dc5f 100644
--- a/tests/PathRendererCacheTests.cpp
+++ b/tests/PathRendererCacheTests.cpp
@@ -85,7 +85,7 @@
 
     auto rtc = GrRenderTargetContext::Make(
             dContext.get(), GrColorType::kRGBA_8888, nullptr, SkBackingFit::kApprox, {800, 800}, 1,
-            GrMipMapped::kNo, GrProtected::kNo, kTopLeft_GrSurfaceOrigin);
+            GrMipmapped::kNo, GrProtected::kNo, kTopLeft_GrSurfaceOrigin);
     if (!rtc) {
         return;
     }
diff --git a/tests/ProcessorTest.cpp b/tests/ProcessorTest.cpp
index e80ec51..9292c12 100644
--- a/tests/ProcessorTest.cpp
+++ b/tests/ProcessorTest.cpp
@@ -160,7 +160,7 @@
                     context, GrColorType::kRGBA_8888, nullptr, SkBackingFit::kApprox, {1, 1});
             {
                 sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
-                        format, kDims, GrRenderable::kNo, 1, GrMipMapped::kNo, SkBackingFit::kExact,
+                        format, kDims, GrRenderable::kNo, 1, GrMipmapped::kNo, SkBackingFit::kExact,
                         SkBudgeted::kYes, GrProtected::kNo);
 
                 {
@@ -285,7 +285,7 @@
                 bitmap.setImmutable();
                 GrBitmapTextureMaker maker(fContext, bitmap,
                                            GrImageTexGenPolicy::kNew_Uncached_Budgeted);
-                GrSurfaceProxyView view = maker.view(GrMipMapped::kNo);
+                GrSurfaceProxyView view = maker.view(GrMipmapped::kNo);
                 if (!view.proxy() || !view.proxy()->instantiate(fResourceProvider)) {
                     SkDebugf("Unable to instantiate RGBA8888 test texture.");
                     return false;
@@ -312,7 +312,7 @@
                 bitmap.setImmutable();
                 GrBitmapTextureMaker maker(fContext, bitmap,
                                            GrImageTexGenPolicy::kNew_Uncached_Budgeted);
-                GrSurfaceProxyView view = maker.view(GrMipMapped::kNo);
+                GrSurfaceProxyView view = maker.view(GrMipmapped::kNo);
                 if (!view.proxy() || !view.proxy()->instantiate(fResourceProvider)) {
                     SkDebugf("Unable to instantiate A8 test texture.");
                     return false;
@@ -379,7 +379,7 @@
                          [](void* addr, void* context) { delete[] (GrColor*)addr; }, nullptr);
     bitmap.setImmutable();
     GrBitmapTextureMaker maker(context, bitmap, GrImageTexGenPolicy::kNew_Uncached_Budgeted);
-    return maker.view(GrMipMapped::kNo);
+    return maker.view(GrMipmapped::kNo);
 }
 
 // We tag logged data as unpremul to avoid conversion when encoding as PNG. The input texture
diff --git a/tests/ProgramsTest.cpp b/tests/ProgramsTest.cpp
index 89646e4..5e25f08 100644
--- a/tests/ProgramsTest.cpp
+++ b/tests/ProgramsTest.cpp
@@ -160,7 +160,7 @@
 
     return GrRenderTargetContext::Make(
             context, GrColorType::kRGBA_8888, nullptr, SkBackingFit::kExact,
-            {kRenderTargetWidth, kRenderTargetHeight}, sampleCnt, GrMipMapped::kNo,
+            {kRenderTargetWidth, kRenderTargetHeight}, sampleCnt, GrMipmapped::kNo,
             GrProtected::kNo, origin);
 }
 
@@ -262,7 +262,7 @@
     GrProcessorTestData::ViewInfo views[2];
 
     // setup dummy textures
-    GrMipMapped mipMapped = GrMipMapped(caps->mipMapSupport());
+    GrMipmapped mipMapped = GrMipmapped(caps->mipMapSupport());
     {
         static constexpr SkISize kDummyDims = {34, 18};
         const GrBackendFormat format = caps->getDefaultBackendFormat(GrColorType::kRGBA_8888,
diff --git a/tests/PromiseImageTest.cpp b/tests/PromiseImageTest.cpp
index 3aff519..6e0aeed 100644
--- a/tests/PromiseImageTest.cpp
+++ b/tests/PromiseImageTest.cpp
@@ -171,7 +171,7 @@
 
     GrBackendTexture backendTex = ctx->createBackendTexture(
             kWidth, kHeight, kRGBA_8888_SkColorType,
-            SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kYes, GrProtected::kNo);
+            SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kYes, GrProtected::kNo);
     REPORTER_ASSERT(reporter, backendTex.isValid());
 
     GrBackendFormat backendFormat = backendTex.getBackendFormat();
@@ -182,7 +182,7 @@
     sk_sp<SkImage> refImg(
             SkImage_Gpu::MakePromiseTexture(
                     ctx, backendFormat, kWidth, kHeight,
-                    GrMipMapped::kNo, texOrigin,
+                    GrMipmapped::kNo, texOrigin,
                     kRGBA_8888_SkColorType, kPremul_SkAlphaType,
                     nullptr,
                     PromiseTextureChecker::Fulfill,
@@ -272,7 +272,7 @@
 
             GrBackendTexture backendTex;
             CreateBackendTexture(ctx, &backendTex, kWidth, kHeight, kAlpha_8_SkColorType,
-                    SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kNo, GrProtected::kNo);
+                    SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kNo, GrProtected::kNo);
             REPORTER_ASSERT(reporter, backendTex.isValid());
 
             SkImageInfo info = SkImageInfo::Make(kWidth, kHeight, kRGBA_8888_SkColorType,
@@ -282,7 +282,7 @@
 
             PromiseTextureChecker promiseChecker(backendTex, reporter, false);
             sk_sp<SkImage> image(SkImage_Gpu::MakePromiseTexture(
-                    ctx, backendTex.getBackendFormat(), kWidth, kHeight, GrMipMapped::kNo,
+                    ctx, backendTex.getBackendFormat(), kWidth, kHeight, GrMipmapped::kNo,
                     kTopLeft_GrSurfaceOrigin, kAlpha_8_SkColorType, kPremul_SkAlphaType, nullptr,
                     PromiseTextureChecker::Fulfill, PromiseTextureChecker::Release,
                     PromiseTextureChecker::Done, &promiseChecker,
@@ -311,7 +311,7 @@
 
     GrBackendTexture backendTex = ctx->createBackendTexture(
             kWidth, kHeight, kAlpha_8_SkColorType,
-            SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kNo, GrProtected::kNo);
+            SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kNo, GrProtected::kNo);
     REPORTER_ASSERT(reporter, backendTex.isValid());
 
     SkImageInfo info =
@@ -321,7 +321,7 @@
 
     PromiseTextureChecker promiseChecker(backendTex, reporter, false);
     sk_sp<SkImage> image(SkImage_Gpu::MakePromiseTexture(
-            ctx, backendTex.getBackendFormat(), kWidth, kHeight, GrMipMapped::kNo,
+            ctx, backendTex.getBackendFormat(), kWidth, kHeight, GrMipmapped::kNo,
             kTopLeft_GrSurfaceOrigin, kAlpha_8_SkColorType, kPremul_SkAlphaType, nullptr,
             PromiseTextureChecker::Fulfill, PromiseTextureChecker::Release,
             PromiseTextureChecker::Done, &promiseChecker,
@@ -337,7 +337,7 @@
         auto format = ctx->priv().caps()->getDefaultBackendFormat(GrColorType::kRGBA_8888,
                                                                   GrRenderable::kNo);
         textures.emplace_back(ctx->priv().resourceProvider()->createTexture(
-                {100, 100}, format, GrRenderable::kNo, 1, GrMipMapped::kNo, SkBudgeted::kYes,
+                {100, 100}, format, GrRenderable::kNo, 1, GrMipmapped::kNo, SkBudgeted::kYes,
                 GrProtected::kNo));
         REPORTER_ASSERT(reporter, textures[i]);
     }
@@ -379,7 +379,7 @@
     // Do all this just to get a valid backend format for the image.
     GrBackendTexture backendTex;
     CreateBackendTexture(ctx, &backendTex, kWidth, kHeight, kRGBA_8888_SkColorType,
-                         SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kYes,
+                         SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kYes,
                          GrProtected::kNo);
     REPORTER_ASSERT(reporter, backendTex.isValid());
     GrBackendFormat backendFormat = backendTex.getBackendFormat();
@@ -403,7 +403,7 @@
     };
     GrSurfaceOrigin texOrigin = kTopLeft_GrSurfaceOrigin;
     sk_sp<SkImage> refImg(SkImage_Gpu::MakePromiseTexture(
-            ctx, backendFormat, kWidth, kHeight, GrMipMapped::kNo, texOrigin,
+            ctx, backendFormat, kWidth, kHeight, GrMipmapped::kNo, texOrigin,
             kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr, fulfill, release, done, &counts,
             SkDeferredDisplayListRecorder::PromiseImageApiVersion::kNew));
 
diff --git a/tests/ProxyConversionTest.cpp b/tests/ProxyConversionTest.cpp
index f370909..16ecad9 100644
--- a/tests/ProxyConversionTest.cpp
+++ b/tests/ProxyConversionTest.cpp
@@ -134,7 +134,7 @@
                                                                  GrRenderable::kYes);
     {
         sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
-                format, kDims, GrRenderable::kYes, 1, GrMipMapped::kNo, SkBackingFit::kApprox,
+                format, kDims, GrRenderable::kYes, 1, GrMipmapped::kNo, SkBackingFit::kApprox,
                 SkBudgeted::kYes, GrProtected::kNo);
 
         // Both RenderTarget and Texture
@@ -148,7 +148,7 @@
 
     {
         sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
-                format, kDims, GrRenderable::kYes, 1, GrMipMapped::kNo, SkBackingFit::kApprox,
+                format, kDims, GrRenderable::kYes, 1, GrMipmapped::kNo, SkBackingFit::kApprox,
                 SkBudgeted::kYes, GrProtected::kNo);
 
         // Both RenderTarget and Texture - but via GrTextureProxy
@@ -162,7 +162,7 @@
 
     {
         sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
-                format, kDims, GrRenderable::kNo, 1, GrMipMapped::kNo, SkBackingFit::kApprox,
+                format, kDims, GrRenderable::kNo, 1, GrMipmapped::kNo, SkBackingFit::kApprox,
                 SkBudgeted::kYes, GrProtected::kNo);
         // Texture-only
         GrTextureProxy* tProxy = proxy->asTextureProxy();
diff --git a/tests/ProxyRefTest.cpp b/tests/ProxyRefTest.cpp
index 6c846f9..3a460f0 100644
--- a/tests/ProxyRefTest.cpp
+++ b/tests/ProxyRefTest.cpp
@@ -28,7 +28,7 @@
     const GrBackendFormat format = caps->getDefaultBackendFormat(GrColorType::kRGBA_8888,
                                                                  GrRenderable::kYes);
     return proxyProvider->createProxy(format, {kWidthHeight, kWidthHeight}, GrRenderable::kYes, 1,
-                                      GrMipMapped::kNo, SkBackingFit::kApprox, SkBudgeted::kYes,
+                                      GrMipmapped::kNo, SkBackingFit::kApprox, SkBudgeted::kYes,
                                       GrProtected::kNo);
 }
 
diff --git a/tests/ProxyTest.cpp b/tests/ProxyTest.cpp
index 92a3cba..caf80c1 100644
--- a/tests/ProxyTest.cpp
+++ b/tests/ProxyTest.cpp
@@ -140,11 +140,11 @@
                             } else {
                                 tex = resourceProvider->createTexture(
                                         dims, format, GrRenderable::kYes, numSamples,
-                                        GrMipMapped::kNo, budgeted, GrProtected::kNo);
+                                        GrMipmapped::kNo, budgeted, GrProtected::kNo);
                             }
 
                             sk_sp<GrTextureProxy> proxy = proxyProvider->createProxy(
-                                    format, dims, GrRenderable::kYes, numSamples, GrMipMapped::kNo,
+                                    format, dims, GrRenderable::kYes, numSamples, GrMipmapped::kNo,
                                     fit, budgeted, GrProtected::kNo);
                             REPORTER_ASSERT(reporter, SkToBool(tex) == SkToBool(proxy));
                             if (proxy) {
@@ -176,11 +176,11 @@
                             } else {
                                 tex = resourceProvider->createTexture(
                                         dims, format, GrRenderable::kNo, numSamples,
-                                        GrMipMapped::kNo, budgeted, GrProtected::kNo);
+                                        GrMipmapped::kNo, budgeted, GrProtected::kNo);
                             }
 
                             sk_sp<GrTextureProxy> proxy(proxyProvider->createProxy(
-                                    format, dims, GrRenderable::kNo, numSamples, GrMipMapped::kNo,
+                                    format, dims, GrRenderable::kNo, numSamples, GrMipmapped::kNo,
                                     fit, budgeted, GrProtected::kNo));
                             REPORTER_ASSERT(reporter, SkToBool(tex) == SkToBool(proxy));
                             if (proxy) {
@@ -266,7 +266,7 @@
             {
                 GrBackendTexture backendTex;
                 CreateBackendTexture(direct, &backendTex, kWidthHeight, kWidthHeight, colorType,
-                                     SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kYes,
+                                     SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kYes,
                                      GrProtected::kNo);
                 sk_sp<GrSurfaceProxy> sProxy = proxyProvider->wrapBackendTextureAsRenderTarget(
                         backendTex, supportedNumSamples);
@@ -287,7 +287,7 @@
             {
                 GrBackendTexture backendTex;
                 CreateBackendTexture(direct, &backendTex, kWidthHeight, kWidthHeight, colorType,
-                                     SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kYes,
+                                     SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kYes,
                                      GrProtected::kNo);
 
                 sk_sp<GrSurfaceProxy> sProxy = proxyProvider->wrapRenderableBackendTexture(
@@ -311,7 +311,7 @@
                 // Internal offscreen texture
                 GrBackendTexture backendTex;
                 CreateBackendTexture(direct, &backendTex, kWidthHeight, kWidthHeight, colorType,
-                                     SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kNo,
+                                     SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kNo,
                                      GrProtected::kNo);
 
                 sk_sp<GrSurfaceProxy> sProxy = proxyProvider->wrapBackendTexture(
@@ -349,7 +349,7 @@
                                 renderable);
 
                     sk_sp<GrTextureProxy> proxy = provider->createProxy(
-                            format, {width, height}, renderable, 1, GrMipMapped::kNo, fit,
+                            format, {width, height}, renderable, 1, GrMipmapped::kNo, fit,
                             SkBudgeted::kNo, GrProtected::kNo);
                     REPORTER_ASSERT(reporter, !proxy);
                 }
diff --git a/tests/ReadWriteAlphaTest.cpp b/tests/ReadWriteAlphaTest.cpp
index bebccf0..eefa28a 100644
--- a/tests/ReadWriteAlphaTest.cpp
+++ b/tests/ReadWriteAlphaTest.cpp
@@ -68,7 +68,7 @@
         bitmap.installPixels(ii, alphaDataCopy, ii.minRowBytes());
         bitmap.setImmutable();
         GrBitmapTextureMaker maker(direct, bitmap, GrImageTexGenPolicy::kNew_Uncached_Budgeted);
-        auto view = maker.view(GrMipMapped::kNo);
+        auto view = maker.view(GrMipmapped::kNo);
         if (!view.proxy()) {
             ERRORF(reporter, "Could not create alpha texture.");
             return;
diff --git a/tests/RectangleTextureTest.cpp b/tests/RectangleTextureTest.cpp
index fb89561..0fa91f6 100644
--- a/tests/RectangleTextureTest.cpp
+++ b/tests/RectangleTextureTest.cpp
@@ -138,7 +138,7 @@
         GrBackendTexture rectangleTex = direct->createBackendTexture(kWidth,
                                                                      kHeight,
                                                                      format,
-                                                                     GrMipMapped::kNo,
+                                                                     GrMipmapped::kNo,
                                                                      GrRenderable::kYes);
         if (!rectangleTex.isValid()) {
             continue;
@@ -164,8 +164,8 @@
             continue;
         }
 
-        SkASSERT(rectProxy->mipMapped() == GrMipMapped::kNo);
-        SkASSERT(rectProxy->peekTexture()->texturePriv().mipMapped() == GrMipMapped::kNo);
+        SkASSERT(rectProxy->mipMapped() == GrMipmapped::kNo);
+        SkASSERT(rectProxy->peekTexture()->texturePriv().mipMapped() == GrMipmapped::kNo);
 
         SkASSERT(rectProxy->textureType() == GrTextureType::kRectangle);
         SkASSERT(rectProxy->peekTexture()->texturePriv().textureType() ==
diff --git a/tests/ResourceAllocatorTest.cpp b/tests/ResourceAllocatorTest.cpp
index 846a0c5..39523fe 100644
--- a/tests/ResourceAllocatorTest.cpp
+++ b/tests/ResourceAllocatorTest.cpp
@@ -33,7 +33,7 @@
                                            const ProxyParams& p) {
     const GrBackendFormat format = caps->getDefaultBackendFormat(p.fColorType, p.fRenderable);
     return proxyProvider->createProxy(format, {p.fSize, p.fSize}, p.fRenderable, p.fSampleCnt,
-                                      GrMipMapped::kNo, p.fFit, p.fBudgeted, GrProtected::kNo);
+                                      GrMipmapped::kNo, p.fFit, p.fBudgeted, GrProtected::kNo);
 }
 
 static sk_sp<GrSurfaceProxy> make_backend(GrDirectContext* dContext,
@@ -45,7 +45,7 @@
     SkASSERT(SkColorType::kUnknown_SkColorType != skColorType);
 
     CreateBackendTexture(dContext, backendTex, p.fSize, p.fSize, skColorType,
-                         SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kNo);
+                         SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kNo);
 
     if (!backendTex->isValid()) {
         return nullptr;
@@ -276,7 +276,7 @@
     GrInternalSurfaceFlags flags = GrInternalSurfaceFlags::kNone;
     SkISize dims = {p.fSize, p.fSize};
     return proxyProvider->createLazyProxy(callback, format, dims, p.fRenderable, p.fSampleCnt,
-                                          GrMipMapped::kNo, GrMipMapsStatus::kNotAllocated, flags,
+                                          GrMipmapped::kNo, GrMipMapsStatus::kNotAllocated, flags,
                                           p.fFit, p.fBudgeted, GrProtected::kNo,
                                           GrSurfaceProxy::UseAllocator::kYes);
 }
diff --git a/tests/ResourceCacheTest.cpp b/tests/ResourceCacheTest.cpp
index 71c1b2c..2f0546a 100644
--- a/tests/ResourceCacheTest.cpp
+++ b/tests/ResourceCacheTest.cpp
@@ -93,7 +93,7 @@
     auto format =
             provider->caps()->getDefaultBackendFormat(GrColorType::kRGBA_8888, GrRenderable::kYes);
     sk_sp<GrTexture> tex(provider->createTexture({size, size}, format, GrRenderable::kYes,
-                                                 sampleCount, GrMipMapped::kNo, budgeted,
+                                                 sampleCount, GrMipmapped::kNo, budgeted,
                                                  GrProtected::kNo));
     if (!tex || !tex->asRenderTarget()) {
         return nullptr;
@@ -197,10 +197,10 @@
     static const int kH = 100;
 
     CreateBackendTexture(context, &backendTextures[0], kW, kH, kRGBA_8888_SkColorType,
-                         SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kNo,
+                         SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kNo,
                          GrProtected::kNo);
     CreateBackendTexture(context, &backendTextures[1], kW, kH, kRGBA_8888_SkColorType,
-                         SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kNo,
+                         SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kNo,
                          GrProtected::kNo);
     REPORTER_ASSERT(reporter, backendTextures[0].isValid());
     REPORTER_ASSERT(reporter, backendTextures[1].isValid());
@@ -1469,7 +1469,7 @@
 
     for (int i = 0; i < 3; ++i) {
         backends[i] = dContext->createBackendTexture(16, 16, SkColorType::kRGBA_8888_SkColorType,
-                                                     GrMipMapped::kNo, GrRenderable::kNo);
+                                                     GrMipmapped::kNo, GrRenderable::kNo);
         wrapped[i] = gpu->wrapBackendTexture(backends[i],
                                              GrWrapOwnership::kBorrow_GrWrapOwnership,
                                              (i < 2) ? GrWrapCacheable::kYes : GrWrapCacheable::kNo,
@@ -1551,7 +1551,7 @@
 
     GrBackendTexture backend = context->createBackendTexture(16, 16,
                                                              SkColorType::kRGBA_8888_SkColorType,
-                                                             GrMipMapped::kNo, GrRenderable::kNo);
+                                                             GrMipmapped::kNo, GrRenderable::kNo);
     GrTexture* tex = gpu->wrapBackendTexture(backend,
                                              GrWrapOwnership::kBorrow_GrWrapOwnership,
                                              GrWrapCacheable::kYes,
@@ -1596,7 +1596,7 @@
                                             SkISize dims,
                                             int sampleCnt) {
     auto format = provider->caps()->getDefaultBackendFormat(GrColorType::kRGBA_8888, renderable);
-    return provider->createTexture(dims, format, renderable, sampleCnt, GrMipMapped::kNo,
+    return provider->createTexture(dims, format, renderable, sampleCnt, GrMipmapped::kNo,
                                    SkBudgeted::kYes, GrProtected::kNo);
 }
 
@@ -1611,7 +1611,7 @@
     const GrBackendFormat format = caps->getDefaultBackendFormat(GrColorType::kRGBA_8888,
                                                                  GrRenderable::kNo);
 
-    return proxyProvider->createProxy(format, dims, renderable, sampleCnt, GrMipMapped::kYes,
+    return proxyProvider->createProxy(format, dims, renderable, sampleCnt, GrMipmapped::kYes,
                                       SkBackingFit::kExact, SkBudgeted::kYes, GrProtected::kNo);
 }
 
diff --git a/tests/SRGBReadWritePixelsTest.cpp b/tests/SRGBReadWritePixelsTest.cpp
index 62b1aa8..f8b8759 100644
--- a/tests/SRGBReadWritePixelsTest.cpp
+++ b/tests/SRGBReadWritePixelsTest.cpp
@@ -192,7 +192,7 @@
                                                               skiatest::Reporter* reporter) {
     auto surfaceContext = GrRenderTargetContext::Make(
             rContext, GrColorType::kRGBA_8888, encoding_as_color_space(contextEncoding),
-            SkBackingFit::kExact, {kW, kH}, 1, GrMipMapped::kNo, GrProtected::kNo,
+            SkBackingFit::kExact, {kW, kH}, 1, GrMipmapped::kNo, GrProtected::kNo,
             kBottomLeft_GrSurfaceOrigin, SkBudgeted::kNo);
     if (!surfaceContext) {
         ERRORF(reporter, "Could not create %s surface context.", encoding_as_str(contextEncoding));
diff --git a/tests/SpecialImageTest.cpp b/tests/SpecialImageTest.cpp
index 45064e1..be0fcfb 100644
--- a/tests/SpecialImageTest.cpp
+++ b/tests/SpecialImageTest.cpp
@@ -187,7 +187,7 @@
     auto context = ctxInfo.directContext();
     SkBitmap bm = create_bm();
     GrBitmapTextureMaker maker(context, bm, GrImageTexGenPolicy::kNew_Uncached_Budgeted);
-    auto view = maker.view(GrMipMapped::kNo);
+    auto view = maker.view(GrMipmapped::kNo);
     if (!view.proxy()) {
         return;
     }
diff --git a/tests/SurfaceTest.cpp b/tests/SurfaceTest.cpp
index 41b8e52..cf88858 100644
--- a/tests/SurfaceTest.cpp
+++ b/tests/SurfaceTest.cpp
@@ -109,7 +109,7 @@
 
             GrBackendTexture backendTex;
             CreateBackendTexture(context, &backendTex, kSize, kSize, colorType,
-                                 SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kYes,
+                                 SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kYes,
                                  GrProtected::kNo);
             surf = SkSurface::MakeFromBackendTexture(context, backendTex,
                                                      kTopLeft_GrSurfaceOrigin, 0, colorType,
@@ -140,7 +140,7 @@
 
             GrBackendTexture backendTex;
             CreateBackendTexture(context, &backendTex, kSize, kSize, colorType,
-                                 SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kYes,
+                                 SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kYes,
                                  GrProtected::kNo);
             surf = SkSurface::MakeFromBackendTexture(context, backendTex,
                                                      kTopLeft_GrSurfaceOrigin, kSampleCnt,
@@ -216,7 +216,7 @@
 
         GrBackendTexture backendTex;
         CreateBackendTexture(context, &backendTex, kSize, kSize, colorType,
-                             SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kYes,
+                             SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kYes,
                              GrProtected::kNo);
         if (!backendTex.isValid()) {
             continue;
@@ -717,7 +717,7 @@
                                        kPremul_SkAlphaType);
 
     if (!CreateBackendTexture(dContext, outTexture, ii, color,
-                              GrMipMapped::kNo, GrRenderable::kYes)) {
+                              GrMipmapped::kNo, GrRenderable::kYes)) {
         return nullptr;
     }
 
@@ -757,7 +757,7 @@
                                        kPremul_SkAlphaType);
 
     if (!CreateBackendTexture(dContext, outTexture, ii, color,
-                              GrMipMapped::kNo, GrRenderable::kYes)) {
+                              GrMipmapped::kNo, GrRenderable::kYes)) {
         return nullptr;
     }
 
@@ -957,7 +957,7 @@
         if (useTexture) {
             SkImageInfo ii = SkImageInfo::Make(kWidth, kHeight, SkColorType::kRGBA_8888_SkColorType,
                                                kPremul_SkAlphaType);
-            if (!CreateBackendTexture(ctx, &backendTex, ii, SkColors::kRed, GrMipMapped::kNo,
+            if (!CreateBackendTexture(ctx, &backendTex, ii, SkColors::kRed, GrMipmapped::kNo,
                                       GrRenderable::kYes)) {
                 continue;
             }
@@ -1041,14 +1041,14 @@
         GrBackendTexture backendTexture1;
         auto ii = SkImageInfo::Make(10, 10, kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr);
         if (!CreateBackendTexture(context, &backendTexture1, ii, SkColors::kTransparent,
-                                  GrMipMapped::kNo, GrRenderable::kYes)) {
+                                  GrMipmapped::kNo, GrRenderable::kYes)) {
             continue;
         }
         SkScopeExit delete1(
                 [context, &backendTexture1] { DeleteBackendTexture(context, backendTexture1); });
         GrBackendTexture backendTexture2;
         if (!CreateBackendTexture(context, &backendTexture2, ii, SkColors::kTransparent,
-                                  GrMipMapped::kNo, GrRenderable::kYes)) {
+                                  GrMipmapped::kNo, GrRenderable::kYes)) {
             ERRORF(reporter, "Expected to be able to make second texture");
             continue;
         }
@@ -1057,7 +1057,7 @@
         auto ii2 = ii.makeWH(8, 8);
         GrBackendTexture backendTexture3;
         if (!CreateBackendTexture(context, &backendTexture3, ii2, SkColors::kTransparent,
-                                  GrMipMapped::kNo, GrRenderable::kYes)) {
+                                  GrMipmapped::kNo, GrRenderable::kYes)) {
             ERRORF(reporter, "Couldn't create different sized texture.");
             continue;
         }
diff --git a/tests/TestUtils.cpp b/tests/TestUtils.cpp
index 3b5fd91..1e3dc71 100644
--- a/tests/TestUtils.cpp
+++ b/tests/TestUtils.cpp
@@ -82,7 +82,7 @@
                          GrColorType colorType,
                          uint32_t expectedPixelValues[],
                          const char* testName) {
-    auto copy = GrSurfaceProxy::Copy(rContext, proxy, origin, GrMipMapped::kNo,
+    auto copy = GrSurfaceProxy::Copy(rContext, proxy, origin, GrMipmapped::kNo,
                                      SkBackingFit::kExact, SkBudgeted::kYes);
     SkASSERT(copy && copy->asTextureProxy());
     auto swizzle = rContext->priv().caps()->getReadSwizzle(copy->backendFormat(), colorType);
@@ -110,7 +110,7 @@
                           int width, int height,
                           SkColorType colorType,
                           const SkColor4f& color,
-                          GrMipMapped mipMapped,
+                          GrMipmapped mipMapped,
                           GrRenderable renderable,
                           GrProtected isProtected) {
     SkImageInfo info = SkImageInfo::Make(width, height, colorType, kPremul_SkAlphaType);
@@ -122,7 +122,7 @@
                           GrBackendTexture* backendTex,
                           const SkImageInfo& ii,
                           const SkColor4f& color,
-                          GrMipMapped mipMapped,
+                          GrMipmapped mipMapped,
                           GrRenderable renderable,
                           GrProtected isProtected) {
     bool finishedBECreate = false;
diff --git a/tests/TestUtils.h b/tests/TestUtils.h
index 91e740a..64dfcf1 100644
--- a/tests/TestUtils.h
+++ b/tests/TestUtils.h
@@ -37,7 +37,7 @@
                           int width, int height,
                           SkColorType colorType,
                           const SkColor4f& color,
-                          GrMipMapped,
+                          GrMipmapped,
                           GrRenderable,
                           GrProtected = GrProtected::kNo);
 
@@ -45,7 +45,7 @@
                           GrBackendTexture* backendTex,
                           const SkImageInfo& ii,
                           const SkColor4f& color,
-                          GrMipMapped,
+                          GrMipmapped,
                           GrRenderable,
                           GrProtected = GrProtected::kNo);
 
diff --git a/tests/TextureBindingsResetTest.cpp b/tests/TextureBindingsResetTest.cpp
index acfbae6..77dc86c 100644
--- a/tests/TextureBindingsResetTest.cpp
+++ b/tests/TextureBindingsResetTest.cpp
@@ -76,7 +76,7 @@
     // Test creating a texture and then resetting bindings.
     static constexpr SkISize kDims = {10, 10};
     auto format = gpu->caps()->getDefaultBackendFormat(GrColorType::kRGBA_8888, GrRenderable::kNo);
-    auto tex = gpu->createTexture(kDims, format, GrRenderable::kNo, 1, GrMipMapped::kNo,
+    auto tex = gpu->createTexture(kDims, format, GrRenderable::kNo, 1, GrMipmapped::kNo,
                                   SkBudgeted::kNo, GrProtected::kNo);
     REPORTER_ASSERT(reporter, tex);
     context->resetGLTextureBindings();
@@ -106,7 +106,7 @@
     if (supportExternal) {
         GrBackendTexture texture2D = context->createBackendTexture(
                 10, 10, kRGBA_8888_SkColorType,
-                SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kNo, GrProtected::kNo);
+                SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kNo, GrProtected::kNo);
         GrGLTextureInfo info2D;
         REPORTER_ASSERT(reporter, texture2D.getGLTextureInfo(&info2D));
         GrEGLImage eglImage = ctxInfo.glContext()->texture2DToEGLImage(info2D.fID);
@@ -116,7 +116,7 @@
         infoExternal.fTarget = GR_GL_TEXTURE_EXTERNAL;
         infoExternal.fFormat = info2D.fFormat;
         REPORTER_ASSERT(reporter, infoExternal.fID);
-        GrBackendTexture backendTexture(10, 10, GrMipMapped::kNo, infoExternal);
+        GrBackendTexture backendTexture(10, 10, GrMipmapped::kNo, infoExternal);
         // Above texture creation will have messed with GL state and bindings.
         resetBindings();
         context->resetContext();
@@ -138,7 +138,7 @@
     if (supportRectangle) {
         auto format = GrBackendFormat::MakeGL(GR_GL_RGBA8, GR_GL_TEXTURE_RECTANGLE);
         GrBackendTexture rectangleTexture =
-                context->createBackendTexture(10, 10, format, GrMipMapped::kNo, GrRenderable::kNo);
+                context->createBackendTexture(10, 10, format, GrMipmapped::kNo, GrRenderable::kNo);
         if (rectangleTexture.isValid()) {
             img = SkImage::MakeFromTexture(context, rectangleTexture, kTopLeft_GrSurfaceOrigin,
                                            kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr);
diff --git a/tests/TextureProxyTest.cpp b/tests/TextureProxyTest.cpp
index 4b2c786..dac069c 100644
--- a/tests/TextureProxyTest.cpp
+++ b/tests/TextureProxyTest.cpp
@@ -42,7 +42,7 @@
     GrBackendFormat format = caps->getDefaultBackendFormat(kColorType, GrRenderable::kNo);
 
     sk_sp<GrTextureProxy> proxy =
-            proxyProvider->createProxy(format, kSize, GrRenderable::kNo, 1, GrMipMapped::kNo, fit,
+            proxyProvider->createProxy(format, kSize, 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());
@@ -56,7 +56,7 @@
     GrBackendFormat format = caps->getDefaultBackendFormat(kColorType, GrRenderable::kYes);
 
     sk_sp<GrTextureProxy> proxy =
-            proxyProvider->createProxy(format, kSize, GrRenderable::kYes, 1, GrMipMapped::kNo, fit,
+            proxyProvider->createProxy(format, kSize, 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());
@@ -100,7 +100,7 @@
             proxyProvider->caps()->getDefaultBackendFormat(kColorType, GrRenderable::kYes);
 
     *backingSurface =
-            resourceProvider->createTexture(kSize, format, GrRenderable::kNo, 1, GrMipMapped::kNo,
+            resourceProvider->createTexture(kSize, format, GrRenderable::kNo, 1, GrMipmapped::kNo,
                                             SkBudgeted::kNo, GrProtected::kNo);
     if (!(*backingSurface)) {
         return nullptr;
diff --git a/tests/TransferPixelsTest.cpp b/tests/TransferPixelsTest.cpp
index 9685743..6ba0c12 100644
--- a/tests/TransferPixelsTest.cpp
+++ b/tests/TransferPixelsTest.cpp
@@ -116,7 +116,7 @@
 
     sk_sp<GrTexture> tex =
             resourceProvider->createTexture(kTexDims, backendFormat, renderable, 1,
-                                            GrMipMapped::kNo, SkBudgeted::kNo, GrProtected::kNo);
+                                            GrMipmapped::kNo, SkBudgeted::kNo, GrProtected::kNo);
     if (!tex) {
         ERRORF(reporter, "Could not create texture");
         return;
diff --git a/tests/TriangulatingPathRendererTests.cpp b/tests/TriangulatingPathRendererTests.cpp
index 99eaac6..6b7ff33 100644
--- a/tests/TriangulatingPathRendererTests.cpp
+++ b/tests/TriangulatingPathRendererTests.cpp
@@ -735,7 +735,7 @@
     auto ctx = ctxInfo.directContext();
     auto rtc = GrRenderTargetContext::Make(
             ctx, GrColorType::kRGBA_8888, nullptr, SkBackingFit::kApprox, {800, 800}, 1,
-            GrMipMapped::kNo, GrProtected::kNo, kTopLeft_GrSurfaceOrigin);
+            GrMipmapped::kNo, GrProtected::kNo, kTopLeft_GrSurfaceOrigin);
     if (!rtc) {
         return;
     }
diff --git a/tests/VkBackendSurfaceTest.cpp b/tests/VkBackendSurfaceTest.cpp
index 8508423..0791951 100644
--- a/tests/VkBackendSurfaceTest.cpp
+++ b/tests/VkBackendSurfaceTest.cpp
@@ -36,7 +36,7 @@
 
     GrBackendTexture backendTex;
     CreateBackendTexture(context, &backendTex, 1, 1, kRGBA_8888_SkColorType, SkColors::kTransparent,
-                         GrMipMapped::kNo, GrRenderable::kNo, GrProtected::kNo);
+                         GrMipmapped::kNo, GrRenderable::kNo, GrProtected::kNo);
     REPORTER_ASSERT(reporter, backendTex.isValid());
 
     GrVkImageInfo info;
@@ -138,7 +138,7 @@
 
     GrBackendTexture backendTex = context->createBackendTexture(
             1, 1, kRGBA_8888_SkColorType,
-            SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kNo);
+            SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kNo);
     sk_sp<SkImage> image;
     // Make a backend texture with an external queue family and general layout.
     GrVkImageInfo vkInfo;
diff --git a/tests/VkHardwareBufferTest.cpp b/tests/VkHardwareBufferTest.cpp
index 2e189ff..a17f67a 100644
--- a/tests/VkHardwareBufferTest.cpp
+++ b/tests/VkHardwareBufferTest.cpp
@@ -262,7 +262,7 @@
     textureInfo.fID = fTexID;
     textureInfo.fFormat = GR_GL_RGBA8;
 
-    GrBackendTexture backendTex(DEV_W, DEV_H, GrMipMapped::kNo, textureInfo);
+    GrBackendTexture backendTex(DEV_W, DEV_H, GrMipmapped::kNo, textureInfo);
     REPORTER_ASSERT(reporter, backendTex.isValid());
 
     sk_sp<SkImage> image = SkImage::MakeFromTexture(fDirectContext,
@@ -290,7 +290,7 @@
     textureInfo.fID = fTexID;
     textureInfo.fFormat = GR_GL_RGBA8;
 
-    GrBackendTexture backendTex(DEV_W, DEV_H, GrMipMapped::kNo, textureInfo);
+    GrBackendTexture backendTex(DEV_W, DEV_H, GrMipmapped::kNo, textureInfo);
     REPORTER_ASSERT(reporter, backendTex.isValid());
 
     sk_sp<SkSurface> surface = SkSurface::MakeFromBackendTexture(fDirectContext,
diff --git a/tests/VkProtectedContextTest.cpp b/tests/VkProtectedContextTest.cpp
index 25ece8c..a1eb1f0 100644
--- a/tests/VkProtectedContextTest.cpp
+++ b/tests/VkProtectedContextTest.cpp
@@ -27,7 +27,7 @@
     const int kW = 8;
     const int kH = 8;
     GrBackendTexture backendTex = dContext->createBackendTexture(
-        kW, kH, kRGBA_8888_SkColorType, GrMipMapped::kNo, GrRenderable::kYes, GrProtected::kYes);
+        kW, kH, kRGBA_8888_SkColorType, GrMipmapped::kNo, GrRenderable::kYes, GrProtected::kYes);
     REPORTER_ASSERT(reporter, backendTex.isValid());
     REPORTER_ASSERT(reporter, backendTex.isProtected());
 
@@ -63,7 +63,7 @@
     const int kW = 8;
     const int kH = 8;
     GrBackendTexture backendTex = dContext->createBackendTexture(kW, kH, kRGBA_8888_SkColorType,
-                                                                 GrMipMapped::kNo,
+                                                                 GrMipmapped::kNo,
                                                                  GrRenderable::kNo,
                                                                  GrProtected::kYes);
     REPORTER_ASSERT(reporter, backendTex.isValid());
@@ -89,7 +89,7 @@
     const int kH = 8;
     GrBackendTexture backendTex =
         protectedTestHelper->directContext()->createBackendTexture(
-            kW, kH, kRGBA_8888_SkColorType, GrMipMapped::kNo, GrRenderable::kNo,
+            kW, kH, kRGBA_8888_SkColorType, GrMipmapped::kNo, GrRenderable::kNo,
             GrProtected::kNo);
     REPORTER_ASSERT(reporter, !backendTex.isValid());
 }
@@ -105,7 +105,7 @@
     const int kH = 8;
     GrBackendTexture backendTex =
         protectedTestHelper->directContext()->createBackendTexture(
-            kW, kH, kRGBA_8888_SkColorType, GrMipMapped::kNo, GrRenderable::kNo,
+            kW, kH, kRGBA_8888_SkColorType, GrMipmapped::kNo, GrRenderable::kNo,
             GrProtected::kYes);
     REPORTER_ASSERT(reporter, !backendTex.isValid());
 }
diff --git a/tests/VkWrapTests.cpp b/tests/VkWrapTests.cpp
index 90e74b8..5ca3249 100644
--- a/tests/VkWrapTests.cpp
+++ b/tests/VkWrapTests.cpp
@@ -39,7 +39,7 @@
 
     GrBackendTexture origBackendTex;
     CreateBackendTexture(dContext, &origBackendTex, kW, kH, kColorType, SkColors::kTransparent,
-                         GrMipMapped::kNo, GrRenderable::kNo, GrProtected::kNo);
+                         GrMipmapped::kNo, GrRenderable::kNo, GrProtected::kNo);
 
     GrVkImageInfo imageInfo;
     SkAssertResult(origBackendTex.getVkImageInfo(&imageInfo));
@@ -90,7 +90,7 @@
 
     GrBackendTexture origBackendTex;
     CreateBackendTexture(dContext, &origBackendTex, kW, kH, kColorType, SkColors::kTransparent,
-                         GrMipMapped::kNo, GrRenderable::kYes, GrProtected::kNo);
+                         GrMipmapped::kNo, GrRenderable::kYes, GrProtected::kNo);
 
     GrVkImageInfo imageInfo;
     SkAssertResult(origBackendTex.getVkImageInfo(&imageInfo));
@@ -129,7 +129,7 @@
 
     GrBackendTexture origBackendTex;
     CreateBackendTexture(dContext, &origBackendTex, kW, kH, kColorType, SkColors::kTransparent,
-                         GrMipMapped::kNo, GrRenderable::kYes, GrProtected::kNo);
+                         GrMipmapped::kNo, GrRenderable::kYes, GrProtected::kNo);
 
     GrVkImageInfo imageInfo;
     SkAssertResult(origBackendTex.getVkImageInfo(&imageInfo));
diff --git a/tests/VkYcbcrSamplerTest.cpp b/tests/VkYcbcrSamplerTest.cpp
index cf732b1..6dc7507 100644
--- a/tests/VkYcbcrSamplerTest.cpp
+++ b/tests/VkYcbcrSamplerTest.cpp
@@ -130,7 +130,7 @@
 
     GrBackendTexture texture = testHelper.directContext()->createBackendTexture(
             kImageWidth, kImageHeight, GrBackendFormat::MakeVk(VK_FORMAT_G8_B8R8_2PLANE_420_UNORM),
-            GrMipMapped::kNo, GrRenderable::kNo, GrProtected::kNo);
+            GrMipmapped::kNo, GrRenderable::kNo, GrProtected::kNo);
     if (texture.isValid()) {
         ERRORF(reporter,
                "GrContext::createBackendTexture() didn't fail as expected for Ycbcr format.");
diff --git a/tests/WritePixelsTest.cpp b/tests/WritePixelsTest.cpp
index 2ec200c..b6837ef 100644
--- a/tests/WritePixelsTest.cpp
+++ b/tests/WritePixelsTest.cpp
@@ -464,7 +464,7 @@
     for (auto& origin : { kTopLeft_GrSurfaceOrigin, kBottomLeft_GrSurfaceOrigin }) {
         GrBackendTexture backendTex;
         CreateBackendTexture(dContext, &backendTex, DEV_W, DEV_H, kRGBA_8888_SkColorType,
-                             SkColors::kTransparent, GrMipMapped::kNo, GrRenderable::kYes,
+                             SkColors::kTransparent, GrMipmapped::kNo, GrRenderable::kYes,
                              GrProtected::kNo);
         if (!backendTex.isValid()) {
             continue;
@@ -537,7 +537,7 @@
                                                                      GrRenderable::kNo);
 
         sk_sp<GrTextureProxy> temp = proxyProvider->createProxy(
-                format, kDims, GrRenderable::kNo, 1, GrMipMapped::kNo, SkBackingFit::kApprox,
+                format, kDims, GrRenderable::kNo, 1, GrMipmapped::kNo, SkBackingFit::kApprox,
                 SkBudgeted::kYes, GrProtected::kNo);
         temp->instantiate(context->priv().resourceProvider());
     }