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

gm/image.cpp

 /*
  * Copyright 2011 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 "gm.h"
 #include "SkData.h"
@@ skipping 159 matching lines @@
         // since we draw into this directly, we need to start fresh
         sk_bzero(fBuffer, fBufferSize);
 
         SkImageInfo info = SkImageInfo::MakeN32Premul(W, H);
         SkAutoTUnref<SkSurface> surf0(SkSurface::NewRasterDirect(info, fBuffer, RB));
         SkAutoTUnref<SkSurface> surf1(SkSurface::NewRaster(info));
         SkAutoTUnref<SkSurface> surf2;  // gpu
 
 #if SK_SUPPORT_GPU
         surf2.reset(SkSurface::NewRenderTarget(canvas->getGrContext(),
-                                               SkBudgeted::kNo, info));
+                                               SkSurface::kNo_Budgeted, info));
 #endif
 
         test_surface(canvas, surf0, true);
         canvas->translate(80, 0);
         test_surface(canvas, surf1, true);
         if (surf2) {
             canvas->translate(80, 0);
             test_surface(canvas, surf2, true);
         }
     }
@@ skipping 64 matching lines @@
 }
 
 static SkImage* make_codec(const SkImageInfo& info, GrContext*, void (*draw)(SkCanvas*)) {
     SkAutoTUnref<SkImage> image(make_raster(info, nullptr, draw));
     SkAutoTUnref<SkData> data(image->encode());
     return SkImage::NewFromEncoded(data);
 }
 
 static SkImage* make_gpu(const SkImageInfo& info, GrContext* ctx, void (*draw)(SkCanvas*)) {
     if (!ctx) { return nullptr; }
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(ctx, SkBudgeted::kNo, info));
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(ctx, SkSurface::kNo_Budgeted, info));
     draw(surface->getCanvas());
     return surface->newImageSnapshot();
 }
 
 typedef SkImage* (*ImageMakerProc)(const SkImageInfo&, GrContext*, void (*)(SkCanvas*));
 
 class ScalePixelsGM : public skiagm::GM {
 public:
     ScalePixelsGM() {}
 
@@ skipping 204 matching lines @@
         [render_image] {
             SkPictureRecorder recorder;
             SkCanvas* canvas = recorder.beginRecording(SkIntToScalar(kSize), SkIntToScalar(kSize));
             render_image(canvas);
             SkAutoTUnref<SkPicture> picture(recorder.endRecording());
             return SkImage::NewFromPicture(picture, SkISize::Make(kSize, kSize), nullptr, nullptr);
         },
         // Create a texture image
         [context, render_image]() -> SkImage* {
             SkAutoTUnref<SkSurface> surface(
-                SkSurface::NewRenderTarget(context, SkBudgeted::kYes,
+                SkSurface::NewRenderTarget(context, SkSurface::kYes_Budgeted,
                                            SkImageInfo::MakeN32Premul(kSize, kSize)));
             if (!surface) {
                 return nullptr;
             }
             render_image(surface->getCanvas());
             return surface->newImageSnapshot();
         }
     };
 
     static const SkScalar kPad = 5.f;
     canvas->translate(kPad, kPad);
     for (auto factory : imageFactories) {
         SkAutoTUnref<SkImage> image(factory());
         if (!image) {
             continue;
         }
         if (context) {
             SkAutoTUnref<SkImage> texImage(image->newTextureImage(context));
             if (texImage) {
                 canvas->drawImage(texImage, 0, 0);
             }
         }
         canvas->translate(image->width() + kPad, 0);
     }
 }