Move Budgeted enum out of SkSurface, use in GrTextureProvider

BUG=skia:
GOLD_TRYBOT_URL= https://gold.skia.org/search2?unt=true&query=source_type%3Dgm&master=false&issue=1728093005
DOCS_PREVIEW= https://skia.org/?cl=1728093005

Review URL: https://codereview.chromium.org/1728093005

28 files changed, 80 insertions, 75 deletions

diff --git a/tests/BitmapCopyTest.cpp b/tests/BitmapCopyTest.cpp
index 70998bd3f0..5793284e26 100644
--- a/tests/BitmapCopyTest.cpp
+++ b/tests/BitmapCopyTest.cpp
@@ -667,7 +667,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(BitmapCopy_Texture, reporter, ctx) {
             const void* srcData = (kSkia8888_GrPixelConfig == desc.fConfig) ? kData : swizData;
 
             SkAutoTUnref<GrTexture> texture(
-                ctx->textureProvider()->createTexture(desc, false, srcData, 0));
+                ctx->textureProvider()->createTexture(desc, SkBudgeted::kNo, srcData, 0));
 
             if (!texture) {
                 continue;
diff --git a/tests/BlurTest.cpp b/tests/BlurTest.cpp
index 9806611cfb..30f218aa92 100644
--- a/tests/BlurTest.cpp
+++ b/tests/BlurTest.cpp
@@ -565,7 +565,7 @@ DEF_TEST(BlurAsABlur, reporter) {
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SmallBoxBlurBug, reporter, ctx) {
 
     SkImageInfo info = SkImageInfo::MakeN32Premul(128, 128);
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(ctx, SkSurface::kNo_Budgeted, info));
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(ctx, SkBudgeted::kNo, info));
     SkCanvas* canvas = surface->getCanvas();
 
     SkRect r = SkRect::MakeXYWH(10, 10, 100, 100);
diff --git a/tests/ClearTest.cpp b/tests/ClearTest.cpp
index a36c4399b5..df152089fb 100644
--- a/tests/ClearTest.cpp
+++ b/tests/ClearTest.cpp
@@ -55,7 +55,7 @@ static bool reset_dc(SkAutoTUnref<GrDrawContext>* dc, SkAutoTUnref<GrSurface>* r
     desc.fConfig = kRGBA_8888_GrPixelConfig;
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
 
-    rtKeepAlive->reset(context->textureProvider()->createTexture(desc, true));
+    rtKeepAlive->reset(context->textureProvider()->createTexture(desc, SkBudgeted::kYes));
     if (!(*rtKeepAlive)) {
         return false;
     }
diff --git a/tests/ClipBoundsTest.cpp b/tests/ClipBoundsTest.cpp
index c59d5a55f8..b5b9cae8ba 100644
--- a/tests/ClipBoundsTest.cpp
+++ b/tests/ClipBoundsTest.cpp
@@ -25,7 +25,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(GrClipBounds, reporter, context) {
     desc.fHeight    = kYSize;
 
     SkAutoTUnref<GrTexture> texture(
-        context->textureProvider()->createTexture(desc, false, nullptr, 0));
+        context->textureProvider()->createTexture(desc, SkBudgeted::kYes, nullptr, 0));
     if (!texture) {
         return;
     }
diff --git a/tests/CopySurfaceTest.cpp b/tests/CopySurfaceTest.cpp
index 4b64537143..3740f6e87c 100644
--- a/tests/CopySurfaceTest.cpp
+++ b/tests/CopySurfaceTest.cpp
@@ -68,11 +68,11 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(CopySurface, reporter, context) {
                             dstDesc.fFlags = dFlags;
 
                             SkAutoTUnref<GrTexture> src(
-                                context->textureProvider()->createTexture(srcDesc, false,
+                                context->textureProvider()->createTexture(srcDesc, SkBudgeted::kNo,
                                                                           srcPixels.get(),
                                                                           kRowBytes));
                             SkAutoTUnref<GrTexture> dst(
-                                context->textureProvider()->createTexture(dstDesc, false,
+                                context->textureProvider()->createTexture(dstDesc, SkBudgeted::kNo,
                                                                           dstPixels.get(),
                                                                           kRowBytes));
                             if (!src || !dst) {
diff --git a/tests/EGLImageTest.cpp b/tests/EGLImageTest.cpp
index fdae3b32d1..637055ba72 100644
--- a/tests/EGLImageTest.cpp
+++ b/tests/EGLImageTest.cpp
@@ -73,7 +73,8 @@ static void test_copy_surface(skiatest::Reporter* reporter, GrContext* context,
     copyDesc.fWidth = externalTexture->width();
     copyDesc.fHeight = externalTexture->height();
     copyDesc.fFlags = kRenderTarget_GrSurfaceFlag;
-    SkAutoTUnref<GrTexture> copy(context->textureProvider()->createTexture(copyDesc, true));
+    SkAutoTUnref<GrTexture> copy(context->textureProvider()->createTexture(
+            copyDesc, SkBudgeted::kYes));
     context->copySurface(copy, externalTexture);
     test_read_pixels(reporter, context, copy, expectedPixelValues);
 }
diff --git a/tests/FloatingPointTextureTest.cpp b/tests/FloatingPointTextureTest.cpp
index 04f73c7cd9..3a8d63cae9 100644
--- a/tests/FloatingPointTextureTest.cpp
+++ b/tests/FloatingPointTextureTest.cpp
@@ -46,7 +46,7 @@ void runFPTest(skiatest::Reporter* reporter, GrContext* context,
         desc.fOrigin = 0 == origin ?
             kTopLeft_GrSurfaceOrigin : kBottomLeft_GrSurfaceOrigin;
         SkAutoTUnref<GrTexture> fpTexture(context->textureProvider()->createTexture(
-            desc, false, controlPixelData.begin(), 0));
+            desc, SkBudgeted::kNo, controlPixelData.begin(), 0));
         // Floating point textures are NOT supported everywhere
         if (nullptr == fpTexture) {
             continue;
diff --git a/tests/GLProgramsTest.cpp b/tests/GLProgramsTest.cpp
index 81d1013dd0..7440608d77 100644
--- a/tests/GLProgramsTest.cpp
+++ b/tests/GLProgramsTest.cpp
@@ -170,7 +170,7 @@ static GrRenderTarget* random_render_target(GrTextureProvider* textureProvider,
 
     GrTexture* texture = textureProvider->findAndRefTextureByUniqueKey(key);
     if (!texture) {
-        texture = textureProvider->createTexture(texDesc, true);
+        texture = textureProvider->createTexture(texDesc, SkBudgeted::kYes);
         if (texture) {
             textureProvider->assignUniqueKeyToTexture(key, texture);
         }
@@ -310,13 +310,13 @@ bool GrDrawingManager::ProgramUnitTest(GrContext* context, int maxStages) {
     dummyDesc.fWidth = 34;
     dummyDesc.fHeight = 18;
     SkAutoTUnref<GrTexture> dummyTexture1(
-        context->textureProvider()->createTexture(dummyDesc, false, nullptr, 0));
+        context->textureProvider()->createTexture(dummyDesc, SkBudgeted::kNo, nullptr, 0));
     dummyDesc.fFlags = kNone_GrSurfaceFlags;
     dummyDesc.fConfig = kAlpha_8_GrPixelConfig;
     dummyDesc.fWidth = 16;
     dummyDesc.fHeight = 22;
     SkAutoTUnref<GrTexture> dummyTexture2(
-        context->textureProvider()->createTexture(dummyDesc, false, nullptr, 0));
+        context->textureProvider()->createTexture(dummyDesc, SkBudgeted::kNo, nullptr, 0));
 
     if (!dummyTexture1 || ! dummyTexture2) {
         SkDebugf("Could not allocate dummy textures");
@@ -373,7 +373,7 @@ bool GrDrawingManager::ProgramUnitTest(GrContext* context, int maxStages) {
     rtDesc.fFlags = kRenderTarget_GrSurfaceFlag;
     rtDesc.fConfig = kRGBA_8888_GrPixelConfig;
     SkAutoTUnref<GrRenderTarget> rt(
-        context->textureProvider()->createTexture(rtDesc, false)->asRenderTarget());
+        context->textureProvider()->createTexture(rtDesc, SkBudgeted::kNo)->asRenderTarget());
     int fpFactoryCnt = GrProcessorTestFactory<GrFragmentProcessor>::Count();
     for (int i = 0; i < fpFactoryCnt; ++i) {
         // Since FP factories internally randomize, call each 10 times.
diff --git a/tests/GpuDrawPathTest.cpp b/tests/GpuDrawPathTest.cpp
index b0d483b8c4..d454d9bb67 100644
--- a/tests/GpuDrawPathTest.cpp
+++ b/tests/GpuDrawPathTest.cpp
@@ -82,7 +82,7 @@ DEF_GPUTEST_FOR_ALL_CONTEXTS(GpuDrawPath, reporter, context) {
         for (auto& sampleCount : {0, 4, 16}) {
             SkImageInfo info = SkImageInfo::MakeN32Premul(255, 255);
             SkAutoTUnref<SkSurface> surface(
-                SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info,
+                SkSurface::NewRenderTarget(context, SkBudgeted::kNo, info,
                                            sampleCount, nullptr));
             if (!surface) {
                 continue;
diff --git a/tests/GrSurfaceTest.cpp b/tests/GrSurfaceTest.cpp
index 4b7dbd30de..ac0b399b69 100644
--- a/tests/GrSurfaceTest.cpp
+++ b/tests/GrSurfaceTest.cpp
@@ -25,7 +25,8 @@ DEF_GPUTEST_FOR_NULL_CONTEXT(GrSurface, reporter, context) {
     desc.fWidth = 256;
     desc.fHeight = 256;
     desc.fSampleCnt = 0;
-    GrSurface* texRT1 = context->textureProvider()->createTexture(desc, false, nullptr, 0);
+    GrSurface* texRT1 = context->textureProvider()->createTexture(
+            desc, SkBudgeted::kNo, nullptr, 0);
 
     REPORTER_ASSERT(reporter, texRT1 == texRT1->asRenderTarget());
     REPORTER_ASSERT(reporter, texRT1 == texRT1->asTexture());
@@ -37,7 +38,7 @@ DEF_GPUTEST_FOR_NULL_CONTEXT(GrSurface, reporter, context) {
                     static_cast<GrSurface*>(texRT1->asTexture()));
 
     desc.fFlags = kNone_GrSurfaceFlags;
-    GrSurface* tex1 = context->textureProvider()->createTexture(desc, false, nullptr, 0);
+    GrSurface* tex1 = context->textureProvider()->createTexture(desc, SkBudgeted::kNo, nullptr, 0);
     REPORTER_ASSERT(reporter, nullptr == tex1->asRenderTarget());
     REPORTER_ASSERT(reporter, tex1 == tex1->asTexture());
     REPORTER_ASSERT(reporter, static_cast<GrSurface*>(tex1) == tex1->asTexture());
diff --git a/tests/GrTextureMipMapInvalidationTest.cpp b/tests/GrTextureMipMapInvalidationTest.cpp
index e0a12829cc..b047550e6d 100644
--- a/tests/GrTextureMipMapInvalidationTest.cpp
+++ b/tests/GrTextureMipMapInvalidationTest.cpp
@@ -26,8 +26,10 @@ DEF_GPUTEST_FOR_NULL_CONTEXT(GrTextureMipMapInvalidationTest, reporter, context)
     desc.fWidth = 256;
     desc.fHeight = 256;
     desc.fSampleCnt = 0;
-    GrSurface* texRT1 = context->textureProvider()->createTexture(desc, false, nullptr, 0);
-    GrSurface* texRT2 = context->textureProvider()->createTexture(desc, false, nullptr, 0);
+    GrSurface* texRT1 = context->textureProvider()->createTexture(
+        desc, SkBudgeted::kNo, nullptr, 0);
+    GrSurface* texRT2 = context->textureProvider()->createTexture(
+        desc, SkBudgeted::kNo, nullptr, 0);
     REPORTER_ASSERT(reporter, nullptr != texRT1);
     REPORTER_ASSERT(reporter, nullptr != texRT2);
     GrTexture* tex = texRT1->asTexture();
diff --git a/tests/ImageFilterCacheTest.cpp b/tests/ImageFilterCacheTest.cpp
index 74c56df3ed..3494011393 100644
--- a/tests/ImageFilterCacheTest.cpp
+++ b/tests/ImageFilterCacheTest.cpp
@@ -184,7 +184,7 @@ static GrTexture* create_texture(GrContext* context) {
     desc.fWidth  = kFullSize;
     desc.fHeight = kFullSize;
 
-    return context->textureProvider()->createTexture(desc, false, srcBM.getPixels(), 0);
+    return context->textureProvider()->createTexture(desc, SkBudgeted::kNo, srcBM.getPixels(), 0);
 }
 
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageFilterCache_ImageBackedGPU, reporter, context) {
diff --git a/tests/ImageFilterTest.cpp b/tests/ImageFilterTest.cpp
index 60480ec629..89c069cf86 100644
--- a/tests/ImageFilterTest.cpp
+++ b/tests/ImageFilterTest.cpp
@@ -1329,7 +1329,7 @@ DEF_GPUTEST_FOR_NATIVE_CONTEXT(ImageFilterCropRect_Gpu, reporter, context) {
     const SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType);
 
     SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context,
-                                                         SkSurface::kNo_Budgeted,
+                                                         SkBudgeted::kNo,
                                                          SkImageInfo::MakeN32Premul(100, 100),
                                                          0,
                                                          &props,
@@ -1343,7 +1343,7 @@ DEF_GPUTEST_FOR_NATIVE_CONTEXT(HugeBlurImageFilter_Gpu, reporter, context) {
     const SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType);
 
     SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context,
-                                                         SkSurface::kNo_Budgeted,
+                                                         SkBudgeted::kNo,
                                                          SkImageInfo::MakeN32Premul(100, 100),
                                                          0,
                                                          &props,
@@ -1357,7 +1357,7 @@ DEF_GPUTEST_FOR_NATIVE_CONTEXT(XfermodeImageFilterCroppedInput_Gpu, reporter, co
     const SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType);
 
     SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context,
-                                                         SkSurface::kNo_Budgeted,
+                                                         SkBudgeted::kNo,
                                                          SkImageInfo::MakeN32Premul(1, 1),
                                                          0,
                                                          &props,
@@ -1371,7 +1371,7 @@ DEF_GPUTEST_FOR_NATIVE_CONTEXT(TestNegativeBlurSigma_Gpu, reporter, context) {
     const SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType);
 
     SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(context,
-                                                         SkSurface::kNo_Budgeted,
+                                                         SkBudgeted::kNo,
                                                          SkImageInfo::MakeN32Premul(1, 1),
                                                          0,
                                                          &props,
@@ -1383,7 +1383,7 @@ DEF_GPUTEST_FOR_NATIVE_CONTEXT(TestNegativeBlurSigma_Gpu, reporter, context) {
 
 DEF_GPUTEST_FOR_ALL_CONTEXTS(BlurLargeImage_Gpu, reporter, context) {
     SkAutoTUnref<SkSurface> surface(
-        SkSurface::NewRenderTarget(context, SkSurface::kYes_Budgeted,
+        SkSurface::NewRenderTarget(context, SkBudgeted::kYes,
                                    SkImageInfo::MakeN32Premul(100, 100)));
     test_large_blur_input(reporter, surface->getCanvas());
 }
diff --git a/tests/ImageIsOpaqueTest.cpp b/tests/ImageIsOpaqueTest.cpp
index 5d7003f20b..739af2bd49 100644
--- a/tests/ImageIsOpaqueTest.cpp
+++ b/tests/ImageIsOpaqueTest.cpp
@@ -68,12 +68,12 @@ DEF_TEST(ImageIsOpaqueTest, reporter) {
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ImageIsOpaqueTest_Gpu, reporter, context) {
     SkImageInfo infoTransparent = SkImageInfo::MakeN32Premul(5, 5);
     SkAutoTUnref<SkSurface> surfaceTransparent(
-        SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, infoTransparent));
+        SkSurface::NewRenderTarget(context, SkBudgeted::kNo, infoTransparent));
     check_isopaque(reporter, surfaceTransparent, false);
 
     SkImageInfo infoOpaque = SkImageInfo::MakeN32(5, 5, kOpaque_SkAlphaType);
     SkAutoTUnref<SkSurface> surfaceOpaque(
-        SkSurface::NewRenderTarget(context,SkSurface::kNo_Budgeted, infoOpaque));
+        SkSurface::NewRenderTarget(context,SkBudgeted::kNo, infoOpaque));
 
     check_isopaque(reporter, surfaceOpaque, true);
 }
diff --git a/tests/ImageNewShaderTest.cpp b/tests/ImageNewShaderTest.cpp
index 2c25b90c69..7b7d80e477 100644
--- a/tests/ImageNewShaderTest.cpp
+++ b/tests/ImageNewShaderTest.cpp
@@ -116,9 +116,9 @@ void gpuToGpu(skiatest::Reporter* reporter, GrContext* context) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(5, 5);
 
     SkAutoTUnref<SkSurface> sourceSurface(
-        SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info));
+        SkSurface::NewRenderTarget(context, SkBudgeted::kNo, info));
     SkAutoTUnref<SkSurface> destinationSurface(
-        SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info));
+        SkSurface::NewRenderTarget(context, SkBudgeted::kNo, info));
 
     runShaderTest(reporter, sourceSurface.get(), destinationSurface.get(), info);
 }
@@ -127,7 +127,7 @@ void gpuToRaster(skiatest::Reporter* reporter, GrContext* context) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(5, 5);
 
     SkAutoTUnref<SkSurface> sourceSurface(SkSurface::NewRenderTarget(context,
-        SkSurface::kNo_Budgeted, info));
+        SkBudgeted::kNo, info));
     SkAutoTUnref<SkSurface> destinationSurface(SkSurface::NewRaster(info));
 
     runShaderTest(reporter, sourceSurface.get(), destinationSurface.get(), info);
@@ -138,7 +138,7 @@ void rasterToGpu(skiatest::Reporter* reporter, GrContext* context) {
 
     SkAutoTUnref<SkSurface> sourceSurface(SkSurface::NewRaster(info));
     SkAutoTUnref<SkSurface> destinationSurface(SkSurface::NewRenderTarget(context,
-        SkSurface::kNo_Budgeted, info));
+        SkBudgeted::kNo, info));
 
     runShaderTest(reporter, sourceSurface.get(), destinationSurface.get(), info);
 }
diff --git a/tests/ImageTest.cpp b/tests/ImageTest.cpp
index 1bf56c53a2..2ec1f342b3 100644
--- a/tests/ImageTest.cpp
+++ b/tests/ImageTest.cpp
@@ -124,7 +124,7 @@ static SkImage* create_codec_image() {
 #if SK_SUPPORT_GPU
 static SkImage* create_gpu_image(GrContext* context) {
     const SkImageInfo info = SkImageInfo::MakeN32(20, 20, kOpaque_SkAlphaType);
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted,
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(context, SkBudgeted::kNo,
                                                                info));
     draw_image_test_pattern(surface->getCanvas());
     return surface->newImageSnapshot();
@@ -696,7 +696,7 @@ DEF_GPUTEST_FOR_NATIVE_CONTEXT(SkImage_NewFromTexture, reporter, context) {
     desc.fHeight = h;
     desc.fConfig = kSkia8888_GrPixelConfig;
     desc.fSampleCnt = 0;
-    SkAutoTUnref<GrTexture> tex(provider->createTexture(desc, false, storage, w * 4));
+    SkAutoTUnref<GrTexture> tex(provider->createTexture(desc, SkBudgeted::kNo, storage, w * 4));
     if (!tex) {
         REPORTER_ASSERT(reporter, false);
         return;
diff --git a/tests/PremulAlphaRoundTripTest.cpp b/tests/PremulAlphaRoundTripTest.cpp
index 7f94485d46..e0060d62de 100644
--- a/tests/PremulAlphaRoundTripTest.cpp
+++ b/tests/PremulAlphaRoundTripTest.cpp
@@ -109,7 +109,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(PremulAlphaRoundTrip_Gpu, reporter, context)
     const SkImageInfo info = SkImageInfo::MakeN32Premul(256, 256);
     SkSurfaceProps props(SkSurfaceProps::kLegacyFontHost_InitType);
     SkAutoTUnref<SkBaseDevice> device(
-        SkGpuDevice::Create(context, SkSurface::kNo_Budgeted, info, 0, &props,
+        SkGpuDevice::Create(context, SkBudgeted::kNo, info, 0, &props,
                             SkGpuDevice::kUninit_InitContents));
     test_premul_alpha_roundtrip(reporter, device);
 }
diff --git a/tests/ReadPixelsTest.cpp b/tests/ReadPixelsTest.cpp
index 00cb12d93e..b87d2b8ad7 100644
--- a/tests/ReadPixelsTest.cpp
+++ b/tests/ReadPixelsTest.cpp
@@ -396,7 +396,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadPixels_Gpu, reporter, context) {
         desc.fConfig = kSkia8888_GrPixelConfig;
         desc.fOrigin = origin;
         SkAutoTUnref<GrTexture> surfaceTexture(
-            context->textureProvider()->createTexture(desc, false));
+            context->textureProvider()->createTexture(desc, SkBudgeted::kNo));
         SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTargetDirect(surfaceTexture->asRenderTarget()));
         desc.fFlags = kNone_GrSurfaceFlags;
         test_readpixels(reporter, surface, kLast_BitmapInit);
@@ -452,7 +452,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadPixels_Texture, reporter, context) {
         desc.fConfig = kSkia8888_GrPixelConfig;
         desc.fOrigin = origin;
         desc.fFlags = kNone_GrSurfaceFlags;
-        texture.reset(context->textureProvider()->createTexture(desc, false));
+        texture.reset(context->textureProvider()->createTexture(desc, SkBudgeted::kNo));
         test_readpixels_texture(reporter, texture);
     }
 }
@@ -603,8 +603,8 @@ DEF_GPUTEST_FOR_NATIVE_CONTEXT(ReadPixels_Subset_Gpu, reporter, context) {
 
     // do they draw the same?
     const SkImageInfo info = SkImageInfo::MakeN32Premul(128, 128);
-    SkAutoTUnref<SkSurface> surfA(SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info, 0));
-    SkAutoTUnref<SkSurface> surfB(SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info, 0));
+    SkAutoTUnref<SkSurface> surfA(SkSurface::NewRenderTarget(context, SkBudgeted::kNo, info, 0));
+    SkAutoTUnref<SkSurface> surfB(SkSurface::NewRenderTarget(context, SkBudgeted::kNo, info, 0));
 
     if (false) {
         //
diff --git a/tests/ReadWriteAlphaTest.cpp b/tests/ReadWriteAlphaTest.cpp
index d1c2f8c12d..1be775f8f3 100644
--- a/tests/ReadWriteAlphaTest.cpp
+++ b/tests/ReadWriteAlphaTest.cpp
@@ -50,7 +50,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadWriteAlpha, reporter, context) {
         // We are initializing the texture with zeros here
         memset(alphaData, 0, X_SIZE * Y_SIZE);
         SkAutoTUnref<GrTexture> texture(
-            context->textureProvider()->createTexture(desc, false, alphaData, 0));
+            context->textureProvider()->createTexture(desc, SkBudgeted::kNo , alphaData, 0));
         if (!texture) {
             if (!rt) {
                 ERRORF(reporter, "Could not create alpha texture.");
@@ -150,7 +150,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ReadWriteAlpha, reporter, context) {
                 }
             }
             SkAutoTUnref<GrTexture> texture(
-                context->textureProvider()->createTexture(desc, false, rgbaData, 0));
+                context->textureProvider()->createTexture(desc, SkBudgeted::kNo, rgbaData, 0));
             if (!texture) {
                 // We always expect to be able to create a RGBA texture
                 if (!rt  && kRGBA_8888_GrPixelConfig == desc.fConfig) {
diff --git a/tests/RecordReplaceDrawTest.cpp b/tests/RecordReplaceDrawTest.cpp
index fe8f347d26..216f1ca85d 100644
--- a/tests/RecordReplaceDrawTest.cpp
+++ b/tests/RecordReplaceDrawTest.cpp
@@ -124,7 +124,8 @@ void test_replacements(skiatest::Reporter* r, GrContext* context, bool doReplace
         desc.fHeight = kHeight;
         desc.fSampleCnt = 0;
 
-        texture.reset(context->textureProvider()->createTexture(desc, false, nullptr, 0));
+        texture.reset(context->textureProvider()->createTexture(
+                desc, SkBudgeted::kNo, nullptr, 0));
         layer->setTexture(texture, SkIRect::MakeWH(kWidth, kHeight), false);
     }
 
diff --git a/tests/RectangleTextureTest.cpp b/tests/RectangleTextureTest.cpp
index 168a573ea0..2943c258ea 100644
--- a/tests/RectangleTextureTest.cpp
+++ b/tests/RectangleTextureTest.cpp
@@ -58,7 +58,8 @@ static void test_copy_surface_src(skiatest::Reporter* reporter, GrContext* conte
     copyDstDesc.fWidth = rectangleTexture->width();
     copyDstDesc.fHeight = rectangleTexture->height();
     copyDstDesc.fFlags = kRenderTarget_GrSurfaceFlag;
-    SkAutoTUnref<GrTexture> dst(context->textureProvider()->createTexture(copyDstDesc, true));
+    SkAutoTUnref<GrTexture> dst(context->textureProvider()->createTexture(
+            copyDstDesc, SkBudgeted::kYes));
     context->copySurface(dst, rectangleTexture);
     test_read_pixels(reporter, context, dst, expectedPixelValues);
 }
@@ -78,8 +79,8 @@ static void test_copy_surface_dst(skiatest::Reporter* reporter, GrContext* conte
     copySrcDesc.fWidth = rectangleTexture->width();
     copySrcDesc.fHeight = rectangleTexture->height();
     copySrcDesc.fFlags = kRenderTarget_GrSurfaceFlag;
-    SkAutoTUnref<GrTexture> src(context->textureProvider()->createTexture(copySrcDesc, true,
-                                                                          pixels.get(), 0));
+    SkAutoTUnref<GrTexture> src(context->textureProvider()->createTexture(
+            copySrcDesc, SkBudgeted::kYes, pixels.get(), 0));
 
     context->copySurface(rectangleTexture, src);
     test_read_pixels(reporter, context, rectangleTexture, pixels.get());
diff --git a/tests/ResourceCacheTest.cpp b/tests/ResourceCacheTest.cpp
index c8613ad6cf..c715b2efcc 100644
--- a/tests/ResourceCacheTest.cpp
+++ b/tests/ResourceCacheTest.cpp
@@ -38,7 +38,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceCacheCache, reporter, context) {
     desc.fHeight = gHeight;
     SkImageInfo info = SkImageInfo::MakeN32Premul(gWidth, gHeight);
     SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(context,
-                                                               SkSurface::kNo_Budgeted, info));
+                                                               SkBudgeted::kNo, info));
     SkCanvas* canvas = surface->getCanvas();
 
     const SkIRect size = SkIRect::MakeWH(gWidth, gHeight);
@@ -91,12 +91,12 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceCacheStencilBuffers, reporter, contex
     GrTextureProvider* cache = context->textureProvider();
     GrResourceProvider* resourceProvider = context->resourceProvider();
     // Test that two budgeted RTs with the same desc share a stencil buffer.
-    SkAutoTUnref<GrTexture> smallRT0(cache->createTexture(smallDesc, true));
+    SkAutoTUnref<GrTexture> smallRT0(cache->createTexture(smallDesc, SkBudgeted::kYes));
     if (smallRT0 && smallRT0->asRenderTarget()) {
         resourceProvider->attachStencilAttachment(smallRT0->asRenderTarget());
     }
 
-    SkAutoTUnref<GrTexture> smallRT1(cache->createTexture(smallDesc, true));
+    SkAutoTUnref<GrTexture> smallRT1(cache->createTexture(smallDesc, SkBudgeted::kYes));
     if (smallRT1 && smallRT1->asRenderTarget()) {
         resourceProvider->attachStencilAttachment(smallRT1->asRenderTarget());
     }
@@ -108,7 +108,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceCacheStencilBuffers, reporter, contex
                     resourceProvider->attachStencilAttachment(smallRT1->asRenderTarget()));
 
     // An unbudgeted RT with the same desc should also share.
-    SkAutoTUnref<GrTexture> smallRT2(cache->createTexture(smallDesc, false));
+    SkAutoTUnref<GrTexture> smallRT2(cache->createTexture(smallDesc, SkBudgeted::kNo));
     if (smallRT2 && smallRT2->asRenderTarget()) {
         resourceProvider->attachStencilAttachment(smallRT2->asRenderTarget());
     }
@@ -125,7 +125,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceCacheStencilBuffers, reporter, contex
     bigDesc.fWidth = 400;
     bigDesc.fHeight = 200;
     bigDesc.fSampleCnt = 0;
-    SkAutoTUnref<GrTexture> bigRT(cache->createTexture(bigDesc, false));
+    SkAutoTUnref<GrTexture> bigRT(cache->createTexture(bigDesc, SkBudgeted::kNo));
     if (bigRT && bigRT->asRenderTarget()) {
         resourceProvider->attachStencilAttachment(bigRT->asRenderTarget());
     }
@@ -139,7 +139,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceCacheStencilBuffers, reporter, contex
         // An RT with a different sample count should not share. 
         GrSurfaceDesc smallMSAADesc = smallDesc;
         smallMSAADesc.fSampleCnt = 4;
-        SkAutoTUnref<GrTexture> smallMSAART0(cache->createTexture(smallMSAADesc, false));
+        SkAutoTUnref<GrTexture> smallMSAART0(cache->createTexture(smallMSAADesc, SkBudgeted::kNo));
         if (smallMSAART0 && smallMSAART0->asRenderTarget()) {
             resourceProvider->attachStencilAttachment(smallMSAART0->asRenderTarget());
         }
@@ -155,7 +155,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceCacheStencilBuffers, reporter, contex
                         resourceProvider->attachStencilAttachment(smallRT0->asRenderTarget()) !=
                         resourceProvider->attachStencilAttachment(smallMSAART0->asRenderTarget()));
         // A second MSAA RT should share with the first MSAA RT.
-        SkAutoTUnref<GrTexture> smallMSAART1(cache->createTexture(smallMSAADesc, false));
+        SkAutoTUnref<GrTexture> smallMSAART1(cache->createTexture(smallMSAADesc, SkBudgeted::kNo));
         if (smallMSAART1 && smallMSAART1->asRenderTarget()) {
             resourceProvider->attachStencilAttachment(smallMSAART1->asRenderTarget());
         }
@@ -171,8 +171,9 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(ResourceCacheStencilBuffers, reporter, contex
             smallMSAART0 && smallMSAART0->asRenderTarget() &&
             smallMSAART0->asRenderTarget()->numColorSamples() < 8) {
             smallMSAADesc.fSampleCnt = 8;
-            smallMSAART1.reset(cache->createTexture(smallMSAADesc, false));
-            SkAutoTUnref<GrTexture> smallMSAART1(cache->createTexture(smallMSAADesc, false));
+            smallMSAART1.reset(cache->createTexture(smallMSAADesc, SkBudgeted::kNo));
+            SkAutoTUnref<GrTexture> smallMSAART1(
+                    cache->createTexture(smallMSAADesc, SkBudgeted::kNo));
             if (smallMSAART1 && smallMSAART1->asRenderTarget()) {
                 resourceProvider->attachStencilAttachment(smallMSAART1->asRenderTarget());
             }
@@ -569,7 +570,7 @@ void test_unbudgeted_to_scratch(skiatest::Reporter* reporter);
         // Since this resource is unbudgeted, it should not be reachable as scratch.
         REPORTER_ASSERT(reporter, resource->resourcePriv().getScratchKey() == key);
         REPORTER_ASSERT(reporter, !resource->cacheAccess().isScratch());
-        REPORTER_ASSERT(reporter, !resource->resourcePriv().isBudgeted());
+        REPORTER_ASSERT(reporter, SkBudgeted::kNo == resource->resourcePriv().isBudgeted());
         REPORTER_ASSERT(reporter, nullptr == cache->findAndRefScratchResource(key, TestResource::kDefaultSize, 0));
         REPORTER_ASSERT(reporter, 1 == cache->getResourceCount());
         REPORTER_ASSERT(reporter, size == cache->getResourceBytes());
@@ -586,7 +587,7 @@ void test_unbudgeted_to_scratch(skiatest::Reporter* reporter);
         REPORTER_ASSERT(reporter, resource);
         REPORTER_ASSERT(reporter, resource->resourcePriv().getScratchKey() == key);
         REPORTER_ASSERT(reporter, resource->cacheAccess().isScratch());
-        REPORTER_ASSERT(reporter, resource->resourcePriv().isBudgeted());
+        REPORTER_ASSERT(reporter, SkBudgeted::kYes == resource->resourcePriv().isBudgeted());
 
         if (0 == i) {
             // If made unbudgeted, it should return to original state: ref'ed and unbudgeted. Try 
@@ -601,7 +602,7 @@ void test_unbudgeted_to_scratch(skiatest::Reporter* reporter);
             REPORTER_ASSERT(reporter, size == cache->getBudgetedResourceBytes());
             REPORTER_ASSERT(reporter, !resource->resourcePriv().getScratchKey().isValid());
             REPORTER_ASSERT(reporter, !resource->cacheAccess().isScratch());
-            REPORTER_ASSERT(reporter, resource->resourcePriv().isBudgeted());
+            REPORTER_ASSERT(reporter, SkBudgeted::kYes == resource->resourcePriv().isBudgeted());
 
             // now when it is unrefed it should die since it has no key.
             resource->unref();
diff --git a/tests/SRGBReadWritePixelsTest.cpp b/tests/SRGBReadWritePixelsTest.cpp
index 20b2783e52..1446d7d0ac 100644
--- a/tests/SRGBReadWritePixelsTest.cpp
+++ b/tests/SRGBReadWritePixelsTest.cpp
@@ -161,7 +161,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SRGBReadWritePixels, reporter, context) {
     desc.fConfig = kSRGBA_8888_GrPixelConfig;
     if (context->caps()->isConfigRenderable(desc.fConfig, false) &&
         context->caps()->isConfigTexturable(desc.fConfig)) {
-        SkAutoTUnref<GrTexture> tex(context->textureProvider()->createTexture(desc, false));
+        SkAutoTUnref<GrTexture> tex(context->textureProvider()->createTexture(
+                desc, SkBudgeted::kNo));
         if (!tex) {
             ERRORF(reporter, "Could not create SRGBA texture.");
             return;
@@ -200,7 +201,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SRGBReadWritePixels, reporter, context) {
         }
 
         desc.fConfig = kRGBA_8888_GrPixelConfig;
-        tex.reset(context->textureProvider()->createTexture(desc, false));
+        tex.reset(context->textureProvider()->createTexture(desc, SkBudgeted::kNo));
         if (!tex) {
             ERRORF(reporter, "Could not create RGBA texture.");
             return;
diff --git a/tests/SpecialImageTest.cpp b/tests/SpecialImageTest.cpp
index 049453d302..bde140d2ce 100644
--- a/tests/SpecialImageTest.cpp
+++ b/tests/SpecialImageTest.cpp
@@ -135,7 +135,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SpecialImage_Gpu, reporter, context) {
     desc.fWidth  = kFullSize;
     desc.fHeight = kFullSize;
 
-    SkAutoTUnref<GrTexture> texture(context->textureProvider()->createTexture(desc, false,
+    SkAutoTUnref<GrTexture> texture(context->textureProvider()->createTexture(desc, SkBudgeted::kNo,
                                                                               bm.getPixels(), 0));
     if (!texture) {
         return;
diff --git a/tests/SurfaceTest.cpp b/tests/SurfaceTest.cpp
index 41fef617bc..7449f211b5 100644
--- a/tests/SurfaceTest.cpp
+++ b/tests/SurfaceTest.cpp
@@ -54,7 +54,7 @@ static SkSurface* create_gpu_surface(GrContext* context, SkAlphaType at = kPremu
     if (requestedInfo) {
         *requestedInfo = info;
     }
-    return SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info, 0, nullptr);
+    return SkSurface::NewRenderTarget(context, SkBudgeted::kNo, info, 0, nullptr);
 }
 static SkSurface* create_gpu_scratch_surface(GrContext* context,
                                              SkAlphaType at = kPremul_SkAlphaType,
@@ -63,7 +63,7 @@ static SkSurface* create_gpu_scratch_surface(GrContext* context,
     if (requestedInfo) {
         *requestedInfo = info;
     }
-    return SkSurface::NewRenderTarget(context, SkSurface::kYes_Budgeted, info, 0, nullptr);
+    return SkSurface::NewRenderTarget(context, SkBudgeted::kYes, info, 0, nullptr);
 }
 #endif
 
@@ -77,7 +77,7 @@ DEF_TEST(SurfaceEmpty, reporter) {
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceEmpty_Gpu, reporter, context) {
     const SkImageInfo info = SkImageInfo::Make(0, 0, kN32_SkColorType, kPremul_SkAlphaType);
     REPORTER_ASSERT(reporter, nullptr ==
-                    SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info, 0, nullptr));
+                    SkSurface::NewRenderTarget(context, SkBudgeted::kNo, info, 0, nullptr));
 }
 #endif
 
@@ -340,7 +340,7 @@ static void test_unique_image_snap(skiatest::Reporter* reporter, SkSurface* surf
                                    std::function<intptr_t(SkSurface*)> surfaceBackingStore) {
     std::function<intptr_t(SkImage*)> ibs = imageBackingStore;
     std::function<intptr_t(SkSurface*)> sbs = surfaceBackingStore;
-    static const SkSurface::Budgeted kB = SkSurface::kNo_Budgeted;
+    static const SkBudgeted kB = SkBudgeted::kNo;
     {
         SkAutoTUnref<SkImage> image(surface->newImageSnapshot(kB, SkSurface::kYes_ForceUnique));
         REPORTER_ASSERT(reporter, !same_image_surf(image, surface, ibs, sbs));
@@ -699,22 +699,18 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceGetTexture_Gpu, reporter, context) {
 #include "SkImage_Gpu.h"
 #include "SkSurface_Gpu.h"
 
-static SkSurface::Budgeted is_budgeted(SkSurface* surf) {
-    return ((SkSurface_Gpu*)surf)->getDevice()->accessRenderTarget()->resourcePriv().isBudgeted() ?
-        SkSurface::kYes_Budgeted : SkSurface::kNo_Budgeted;
+static SkBudgeted is_budgeted(SkSurface* surf) {
+    return ((SkSurface_Gpu*)surf)->getDevice()->accessRenderTarget()->resourcePriv().isBudgeted();
 }
 
-static SkSurface::Budgeted is_budgeted(SkImage* image) {
-    return ((SkImage_Gpu*)image)->getTexture()->resourcePriv().isBudgeted() ?
-        SkSurface::kYes_Budgeted : SkSurface::kNo_Budgeted;
+static SkBudgeted is_budgeted(SkImage* image) {
+    return ((SkImage_Gpu*)image)->getTexture()->resourcePriv().isBudgeted();
 }
 
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceBudget, reporter, context) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(8,8);
-    for (int i = 0; i < 2; ++i) {
-        SkSurface::Budgeted sbudgeted = i ? SkSurface::kYes_Budgeted : SkSurface::kNo_Budgeted;
-        for (int j = 0; j < 2; ++j) {
-            SkSurface::Budgeted ibudgeted = j ? SkSurface::kYes_Budgeted : SkSurface::kNo_Budgeted;
+    for (auto sbudgeted : { SkBudgeted::kNo, SkBudgeted::kYes }) {
+        for (auto ibudgeted : { SkBudgeted::kNo, SkBudgeted::kYes }) {
             SkAutoTUnref<SkSurface>
                 surface(SkSurface::NewRenderTarget(context, sbudgeted, info, 0));
             SkASSERT(surface);
diff --git a/tests/TextBlobCacheTest.cpp b/tests/TextBlobCacheTest.cpp
index c2907fc6c7..b7456d6b39 100644
--- a/tests/TextBlobCacheTest.cpp
+++ b/tests/TextBlobCacheTest.cpp
@@ -66,7 +66,7 @@ static void text_blob_cache_inner(skiatest::Reporter* reporter, GrContext* conte
     }
 
     SkImageInfo info = SkImageInfo::Make(kWidth, kHeight, kN32_SkColorType, kPremul_SkAlphaType);
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info,
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(context, SkBudgeted::kNo, info,
                                                                0, &props));
     REPORTER_ASSERT(reporter, surface);
     if (!surface) {
diff --git a/tests/TextureStorageAllocator.cpp b/tests/TextureStorageAllocator.cpp
index 122839ca59..73d9dc0ed9 100644
--- a/tests/TextureStorageAllocator.cpp
+++ b/tests/TextureStorageAllocator.cpp
@@ -67,7 +67,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(CustomTexture, reporter, context, glContext)
     grAllocator.fCtx = &allocator;
 
     SkAutoTUnref<SkSurface> surface(SkSurface_Gpu::NewRenderTarget(
-            context, SkSurface_Gpu::kNo_Budgeted, SkImageInfo::MakeN32Premul(kWidth, kHeight), 0,
+            context, SkBudgeted::kNo, SkImageInfo::MakeN32Premul(kWidth, kHeight), 0,
             NULL, grAllocator));
     REPORTER_ASSERT(reporter, surface);
     GrGLuint id = allocator.m_mostRecentlyAllocatedStorage;
@@ -101,7 +101,7 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(CustomTextureFailure, reporter, context, glCo
     grAllocator.fDeallocateTextureStorage= &TestStorageAllocator::deallocateTextureStorage;
     grAllocator.fCtx = &allocator;
     SkAutoTUnref<SkSurface> surface(SkSurface_Gpu::NewRenderTarget(
-            context, SkSurface_Gpu::kNo_Budgeted, SkImageInfo::MakeN32Premul(kWidth, kHeight), 0,
+            context, SkBudgeted::kNo, SkImageInfo::MakeN32Premul(kWidth, kHeight), 0,
             NULL, grAllocator));
     REPORTER_ASSERT(reporter, !surface);
 }
diff --git a/tests/WritePixelsTest.cpp b/tests/WritePixelsTest.cpp
index 6d672f7d16..0141bf351f 100644
--- a/tests/WritePixelsTest.cpp
+++ b/tests/WritePixelsTest.cpp
@@ -413,7 +413,8 @@ DEF_GPUTEST_FOR_RENDERING_CONTEXTS(WritePixels_Gpu, reporter, context) {
         desc.fHeight = DEV_H;
         desc.fConfig = kSkia8888_GrPixelConfig;
         desc.fOrigin = origin;
-        SkAutoTUnref<GrTexture> texture(context->textureProvider()->createTexture(desc, false));
+        SkAutoTUnref<GrTexture> texture(context->textureProvider()->createTexture(desc,
+                                                                                  SkBudgeted::kNo));
         SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTargetDirect(texture->asRenderTarget()));
         test_write_pixels(reporter, surface);
     }