Revert of Move Budgeted enum out of SkSurface, use in GrTextureProvider

tests/SurfaceTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <functional>
 #include "SkCanvas.h"
 #include "SkData.h"
@@ skipping 36 matching lines @@
                                                  release_direct_surface_storage,
                                                  storage);
 }
 #if SK_SUPPORT_GPU
 static SkSurface* create_gpu_surface(GrContext* context, SkAlphaType at = kPremul_SkAlphaType,
                                      SkImageInfo* requestedInfo = nullptr) {
     const SkImageInfo info = SkImageInfo::MakeN32(10, 10, at);
     if (requestedInfo) {
         *requestedInfo = info;
     }
-    return SkSurface::NewRenderTarget(context, SkBudgeted::kNo, info, 0, nullptr);
+    return SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info, 0, nullptr);
 }
 static SkSurface* create_gpu_scratch_surface(GrContext* context,
                                              SkAlphaType at = kPremul_SkAlphaType,
                                              SkImageInfo* requestedInfo = nullptr) {
     const SkImageInfo info = SkImageInfo::MakeN32(10, 10, at);
     if (requestedInfo) {
         *requestedInfo = info;
     }
-    return SkSurface::NewRenderTarget(context, SkBudgeted::kYes, info, 0, nullptr);
+    return SkSurface::NewRenderTarget(context, SkSurface::kYes_Budgeted, info, 0, nullptr);
 }
 #endif
 
 DEF_TEST(SurfaceEmpty, reporter) {
     const SkImageInfo info = SkImageInfo::Make(0, 0, kN32_SkColorType, kPremul_SkAlphaType);
     REPORTER_ASSERT(reporter, nullptr == SkSurface::NewRaster(info));
     REPORTER_ASSERT(reporter, nullptr == SkSurface::NewRasterDirect(info, nullptr, 0));
 
 }
 #if SK_SUPPORT_GPU
 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, SkBudgeted::kNo, info, 0, nullptr));
+                    SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info, 0, nullptr));
 }
 #endif
 
 #if SK_SUPPORT_GPU
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceWrappedTexture, reporter, context) {
     GrGpu* gpu = context->getGpu();
     if (!gpu) {
         return;
     }
 
@@ skipping 242 matching lines @@
                             std::function<intptr_t(SkSurface*)> getSurfaceBackingStore) {
     return getImageBackingStore(a) == getSurfaceBackingStore(b);
 }
 
 static void test_unique_image_snap(skiatest::Reporter* reporter, SkSurface* surface,
                                    bool surfaceIsDirect,
                                    std::function<intptr_t(SkImage*)> imageBackingStore,
                                    std::function<intptr_t(SkSurface*)> surfaceBackingStore) {
     std::function<intptr_t(SkImage*)> ibs = imageBackingStore;
     std::function<intptr_t(SkSurface*)> sbs = surfaceBackingStore;
-    static const SkBudgeted kB = SkBudgeted::kNo;
+    static const SkSurface::Budgeted kB = SkSurface::kNo_Budgeted;
     {
         SkAutoTUnref<SkImage> image(surface->newImageSnapshot(kB, SkSurface::kYes_ForceUnique));
         REPORTER_ASSERT(reporter, !same_image_surf(image, surface, ibs, sbs));
         REPORTER_ASSERT(reporter, image->unique());
     }
     {
         SkAutoTUnref<SkImage> image1(surface->newImageSnapshot(kB, SkSurface::kYes_ForceUnique));
         REPORTER_ASSERT(reporter, !same_image_surf(image1, surface, ibs, sbs));
         REPORTER_ASSERT(reporter, image1->unique());
         SkAutoTUnref<SkImage> image2(surface->newImageSnapshot(kB, SkSurface::kYes_ForceUnique));
@@ skipping 338 matching lines @@
     }
 }
 #endif
 
 #if SK_SUPPORT_GPU
 #include "GrGpuResourcePriv.h"
 #include "SkGpuDevice.h"
 #include "SkImage_Gpu.h"
 #include "SkSurface_Gpu.h"
 
-static SkBudgeted is_budgeted(SkSurface* surf) {
-    return ((SkSurface_Gpu*)surf)->getDevice()->accessRenderTarget()->resourcePriv().isBudgeted();
+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(SkImage* image) {
-    return ((SkImage_Gpu*)image)->getTexture()->resourcePriv().isBudgeted();
+static SkSurface::Budgeted is_budgeted(SkImage* image) {
+    return ((SkImage_Gpu*)image)->getTexture()->resourcePriv().isBudgeted() ?
+        SkSurface::kYes_Budgeted : SkSurface::kNo_Budgeted;
 }
 
 DEF_GPUTEST_FOR_RENDERING_CONTEXTS(SurfaceBudget, reporter, context) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(8,8);
-    for (auto sbudgeted : { SkBudgeted::kNo, SkBudgeted::kYes }) {
-        for (auto ibudgeted : { SkBudgeted::kNo, SkBudgeted::kYes }) {
+    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;
             SkAutoTUnref<SkSurface>
                 surface(SkSurface::NewRenderTarget(context, sbudgeted, info, 0));
             SkASSERT(surface);
             REPORTER_ASSERT(reporter, sbudgeted == is_budgeted(surface));
 
             SkAutoTUnref<SkImage> image(surface->newImageSnapshot(ibudgeted));
 
             // Initially the image shares a texture with the surface, and the surface decides
             // whether it is budgeted or not.
             REPORTER_ASSERT(reporter, sbudgeted == is_budgeted(surface));
@@ skipping 178 matching lines @@
         desc.fHeight = kHeight;
         desc.fFlags = kRenderTarget_GrBackendTextureFlag;
         desc.fTextureHandle = textureObject;
 
         SkSurface* surface = SkSurface::NewFromBackendTexture(context, desc, nullptr);
         test_surface_clear(reporter, surface, grSurfaceGetter, 0xABABABAB);
         context->getGpu()->deleteTestingOnlyBackendTexture(textureObject);
     }
 }
 #endif