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

9 files changed, 32 insertions, 36 deletions

diff --git a/src/image/SkImage.cpp b/src/image/SkImage.cpp
index e6ea9bd121..5521b6e305 100644
--- a/src/image/SkImage.cpp
+++ b/src/image/SkImage.cpp
@@ -288,8 +288,7 @@ SkImage* SkImage::NewFromBitmap(const SkBitmap& bm) {
     if (GrTexture* tex = pr->getTexture()) {
         SkAutoTUnref<GrTexture> unrefCopy;
         if (!bm.isImmutable()) {
-            const bool notBudgeted = false;
-            tex = GrDeepCopyTexture(tex, notBudgeted);
+            tex = GrDeepCopyTexture(tex, SkBudgeted::kNo);
             if (nullptr == tex) {
                 return nullptr;
             }
@@ -297,7 +296,7 @@ SkImage* SkImage::NewFromBitmap(const SkBitmap& bm) {
         }
         const SkImageInfo info = bm.info();
         return new SkImage_Gpu(info.width(), info.height(), bm.getGenerationID(), info.alphaType(),
-                               tex, SkSurface::kNo_Budgeted);
+                               tex, SkBudgeted::kNo);
     }
 #endif
 
diff --git a/src/image/SkImagePriv.h b/src/image/SkImagePriv.h
index 7518bbe808..acd0beb475 100644
--- a/src/image/SkImagePriv.h
+++ b/src/image/SkImagePriv.h
@@ -56,6 +56,6 @@ extern void SkTextureImageApplyBudgetedDecision(SkImage* textureImage);
 // surface needs to perform a copy-on-write
 extern void SkTextureImageSetTexture(SkImage* image, GrTexture* texture);
 
-GrTexture* GrDeepCopyTexture(GrTexture* src, bool isBudgeted);
+GrTexture* GrDeepCopyTexture(GrTexture* src, SkBudgeted);
 
 #endif
diff --git a/src/image/SkImage_Gpu.cpp b/src/image/SkImage_Gpu.cpp
index c502fc0092..e28a31d4bf 100644
--- a/src/image/SkImage_Gpu.cpp
+++ b/src/image/SkImage_Gpu.cpp
@@ -20,7 +20,7 @@
 #include "SkPixelRef.h"
 
 SkImage_Gpu::SkImage_Gpu(int w, int h, uint32_t uniqueID, SkAlphaType at, GrTexture* tex,
-                         SkSurface::Budgeted budgeted)
+                         SkBudgeted budgeted)
     : INHERITED(w, h, uniqueID)
     , fTexture(SkRef(tex))
     , fAlphaType(at)
@@ -140,8 +140,7 @@ SkImage* SkImage_Gpu::onNewSubset(const SkIRect& subset) const {
     desc.fWidth = subset.width();
     desc.fHeight = subset.height();
 
-    GrTexture* subTx = ctx->textureProvider()->createTexture(desc,
-                                                             SkSurface::kYes_Budgeted == fBudgeted);
+    GrTexture* subTx = ctx->textureProvider()->createTexture(desc, fBudgeted);
     if (!subTx) {
         return nullptr;
     }
@@ -167,7 +166,7 @@ static SkImage* new_wrapped_texture_common(GrContext* ctx, const GrBackendTextur
         tex->setRelease(releaseProc, releaseCtx);
     }
 
-    const SkSurface::Budgeted budgeted = SkSurface::kNo_Budgeted;
+    const SkBudgeted budgeted = SkBudgeted::kNo;
     return new SkImage_Gpu(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID, at, tex, budgeted);
 }
 
@@ -193,22 +192,20 @@ SkImage* SkImage::NewFromTextureCopy(GrContext* ctx, const GrBackendTextureDesc&
         return nullptr;
     }
 
-    const bool isBudgeted = true;
-    SkAutoTUnref<GrTexture> dst(GrDeepCopyTexture(src, isBudgeted));
+    SkAutoTUnref<GrTexture> dst(GrDeepCopyTexture(src, SkBudgeted::kYes));
     if (!dst) {
         return nullptr;
     }
 
-    const SkSurface::Budgeted budgeted = SkSurface::kYes_Budgeted;
     return new SkImage_Gpu(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID, at, dst,
-                           budgeted);
+                           SkBudgeted::kYes);
 }
 
 SkImage* SkImage::NewFromYUVTexturesCopy(GrContext* ctx , SkYUVColorSpace colorSpace,
                                          const GrBackendObject yuvTextureHandles[3],
                                          const SkISize yuvSizes[3],
                                          GrSurfaceOrigin origin) {
-    const SkSurface::Budgeted budgeted = SkSurface::kYes_Budgeted;
+    const SkBudgeted budgeted = SkBudgeted::kYes;
 
     if (yuvSizes[0].fWidth <= 0 || yuvSizes[0].fHeight <= 0 ||
         yuvSizes[1].fWidth <= 0 || yuvSizes[1].fHeight <= 0 ||
@@ -259,7 +256,7 @@ SkImage* SkImage::NewFromYUVTexturesCopy(GrContext* ctx , SkYUVColorSpace colorS
     dstDesc.fConfig = kRGBA_8888_GrPixelConfig;
     dstDesc.fSampleCnt = 0;
 
-    SkAutoTUnref<GrTexture> dst(ctx->textureProvider()->createTexture(dstDesc, true));
+    SkAutoTUnref<GrTexture> dst(ctx->textureProvider()->createTexture(dstDesc, SkBudgeted::kYes));
     if (!dst) {
         return nullptr;
     }
@@ -288,7 +285,7 @@ static SkImage* create_image_from_maker(GrTextureMaker* maker, SkAlphaType at, u
         return nullptr;
     }
     return new SkImage_Gpu(texture->width(), texture->height(), id, at, texture,
-                           SkSurface::kNo_Budgeted);
+                           SkBudgeted::kNo);
 }
 
 SkImage* SkImage::newTextureImage(GrContext *context) const {
@@ -315,7 +312,7 @@ SkImage* SkImage::newTextureImage(GrContext *context) const {
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
-GrTexture* GrDeepCopyTexture(GrTexture* src, bool budgeted) {
+GrTexture* GrDeepCopyTexture(GrTexture* src, SkBudgeted budgeted) {
     GrContext* ctx = src->getContext();
 
     GrSurfaceDesc desc = src->desc();
diff --git a/src/image/SkImage_Gpu.h b/src/image/SkImage_Gpu.h
index a36c8ebc13..d4640d4afc 100644
--- a/src/image/SkImage_Gpu.h
+++ b/src/image/SkImage_Gpu.h
@@ -22,13 +22,13 @@ public:
      *  An "image" can be a subset/window into a larger texture, so we explicit take the
      *  width and height.
      */
-    SkImage_Gpu(int w, int h, uint32_t uniqueID, SkAlphaType, GrTexture*, SkSurface::Budgeted);
+    SkImage_Gpu(int w, int h, uint32_t uniqueID, SkAlphaType, GrTexture*, SkBudgeted);
     ~SkImage_Gpu() override;
 
     void applyBudgetDecision() const {
         GrTexture* tex = this->getTexture();
         SkASSERT(tex);
-        if (fBudgeted) {
+        if (SkBudgeted::kYes == fBudgeted) {
             tex->resourcePriv().makeBudgeted();
         } else {
             tex->resourcePriv().makeUnbudgeted();
@@ -45,7 +45,7 @@ public:
                       int srcX, int srcY, CachingHint) const override;
 
     SkSurface* onNewSurface(const SkImageInfo& info) const override {
-        return SkSurface::NewRenderTarget(fTexture->getContext(), SkSurface::kNo_Budgeted, info);
+        return SkSurface::NewRenderTarget(fTexture->getContext(), SkBudgeted::kNo, info);
     }
 
     bool asBitmapForImageFilters(SkBitmap* bitmap) const override;
@@ -53,7 +53,7 @@ public:
 private:
     SkAutoTUnref<GrTexture>     fTexture;
     const SkAlphaType           fAlphaType;
-    const SkSurface::Budgeted   fBudgeted;
+    const SkBudgeted            fBudgeted;
     mutable SkAtomic<bool>      fAddedRasterVersionToCache;
 
 
diff --git a/src/image/SkSurface.cpp b/src/image/SkSurface.cpp
index 4fc904539b..b018ef9756 100644
--- a/src/image/SkSurface.cpp
+++ b/src/image/SkSurface.cpp
@@ -79,7 +79,7 @@ SkSurface_Base::~SkSurface_Base() {
 }
 
 void SkSurface_Base::onDraw(SkCanvas* canvas, SkScalar x, SkScalar y, const SkPaint* paint) {
-    SkImage* image = this->newImageSnapshot(kYes_Budgeted);
+    SkImage* image = this->newImageSnapshot(SkBudgeted::kYes);
     if (image) {
         canvas->drawImage(image, x, y, paint);
         image->unref();
@@ -163,12 +163,12 @@ SkCanvas* SkSurface::getCanvas() {
     return asSB(this)->getCachedCanvas();
 }
 
-SkImage* SkSurface::newImageSnapshot(Budgeted budgeted) {
+SkImage* SkSurface::newImageSnapshot(SkBudgeted budgeted) {
     // the caller will call unref() to balance this
     return asSB(this)->refCachedImage(budgeted, kNo_ForceUnique);
 }
 
-SkImage* SkSurface::newImageSnapshot(Budgeted budgeted, ForceUnique unique) {
+SkImage* SkSurface::newImageSnapshot(SkBudgeted budgeted, ForceUnique unique) {
     // the caller will call unref() to balance this
     return asSB(this)->refCachedImage(budgeted, unique);
 }
@@ -211,7 +211,7 @@ SkSurface* SkSurface::NewRenderTargetDirect(GrRenderTarget*, const SkSurfaceProp
     return nullptr;
 }
 
-SkSurface* SkSurface::NewRenderTarget(GrContext*, Budgeted, const SkImageInfo&, int,
+SkSurface* SkSurface::NewRenderTarget(GrContext*, SkBudgeted, const SkImageInfo&, int,
                                       const SkSurfaceProps*, GrTextureStorageAllocator) {
     return nullptr;
 }
diff --git a/src/image/SkSurface_Base.h b/src/image/SkSurface_Base.h
index 159780b33a..0519a9b3c0 100644
--- a/src/image/SkSurface_Base.h
+++ b/src/image/SkSurface_Base.h
@@ -43,7 +43,7 @@ public:
      *  must faithfully represent the current contents, even if the surface
      *  is changed after this called (e.g. it is drawn to via its canvas).
      */
-    virtual SkImage* onNewImageSnapshot(Budgeted, ForceCopyMode) = 0;
+    virtual SkImage* onNewImageSnapshot(SkBudgeted, ForceCopyMode) = 0;
 
     /**
      *  Default implementation:
@@ -81,7 +81,7 @@ public:
     virtual void onPrepareForExternalIO() {}
 
     inline SkCanvas* getCachedCanvas();
-    inline SkImage* refCachedImage(Budgeted, ForceUnique);
+    inline SkImage* refCachedImage(SkBudgeted, ForceUnique);
 
     bool hasCachedImage() const { return fCachedImage != nullptr; }
 
@@ -114,7 +114,7 @@ SkCanvas* SkSurface_Base::getCachedCanvas() {
     return fCachedCanvas;
 }
 
-SkImage* SkSurface_Base::refCachedImage(Budgeted budgeted, ForceUnique unique) {
+SkImage* SkSurface_Base::refCachedImage(SkBudgeted budgeted, ForceUnique unique) {
     SkImage* snap = fCachedImage;
     if (kYes_ForceUnique == unique && snap && !snap->unique()) {
         snap = nullptr;
diff --git a/src/image/SkSurface_Gpu.cpp b/src/image/SkSurface_Gpu.cpp
index d1544630cc..5345ceee20 100644
--- a/src/image/SkSurface_Gpu.cpp
+++ b/src/image/SkSurface_Gpu.cpp
@@ -72,12 +72,12 @@ SkSurface* SkSurface_Gpu::onNewSurface(const SkImageInfo& info) {
     GrRenderTarget* rt = fDevice->accessRenderTarget();
     int sampleCount = rt->numColorSamples();
     // TODO: Make caller specify this (change virtual signature of onNewSurface).
-    static const Budgeted kBudgeted = kNo_Budgeted;
+    static const SkBudgeted kBudgeted = SkBudgeted::kNo;
     return SkSurface::NewRenderTarget(fDevice->context(), kBudgeted, info, sampleCount,
                                       &this->props());
 }
 
-SkImage* SkSurface_Gpu::onNewImageSnapshot(Budgeted budgeted, ForceCopyMode forceCopyMode) {
+SkImage* SkSurface_Gpu::onNewImageSnapshot(SkBudgeted budgeted, ForceCopyMode forceCopyMode) {
     GrRenderTarget* rt = fDevice->accessRenderTarget();
     SkASSERT(rt);
     GrTexture* tex = rt->asTexture();
@@ -87,7 +87,7 @@ SkImage* SkSurface_Gpu::onNewImageSnapshot(Budgeted budgeted, ForceCopyMode forc
         GrSurfaceDesc desc = fDevice->accessRenderTarget()->desc();
         GrContext* ctx = fDevice->context();
         desc.fFlags = desc.fFlags & ~kRenderTarget_GrSurfaceFlag;
-        copy.reset(ctx->textureProvider()->createTexture(desc, kYes_Budgeted == budgeted));
+        copy.reset(ctx->textureProvider()->createTexture(desc, budgeted));
         if (!copy) {
             return nullptr;
         }
@@ -112,7 +112,7 @@ void SkSurface_Gpu::onCopyOnWrite(ContentChangeMode mode) {
     GrRenderTarget* rt = fDevice->accessRenderTarget();
     // are we sharing our render target with the image? Note this call should never create a new
     // image because onCopyOnWrite is only called when there is a cached image.
-    SkAutoTUnref<SkImage> image(this->refCachedImage(kNo_Budgeted, kNo_ForceUnique));
+    SkAutoTUnref<SkImage> image(this->refCachedImage(SkBudgeted::kNo, kNo_ForceUnique));
     SkASSERT(image);
     if (rt->asTexture() == as_IB(image)->getTexture()) {
         this->fDevice->replaceRenderTarget(SkSurface::kRetain_ContentChangeMode == mode);
@@ -141,7 +141,7 @@ SkSurface* SkSurface::NewRenderTargetDirect(GrRenderTarget* target, const SkSurf
     return new SkSurface_Gpu(device);
 }
 
-SkSurface* SkSurface::NewRenderTarget(GrContext* ctx, Budgeted budgeted, const SkImageInfo& info,
+SkSurface* SkSurface::NewRenderTarget(GrContext* ctx, SkBudgeted budgeted, const SkImageInfo& info,
                                       int sampleCount, const SkSurfaceProps* props,
                                       GrTextureStorageAllocator customAllocator) {
     SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(
diff --git a/src/image/SkSurface_Gpu.h b/src/image/SkSurface_Gpu.h
index dff7970d46..72e9caf462 100644
--- a/src/image/SkSurface_Gpu.h
+++ b/src/image/SkSurface_Gpu.h
@@ -23,7 +23,7 @@ public:
     bool onGetRenderTargetHandle(GrBackendObject*, BackendHandleAccess) override;
     SkCanvas* onNewCanvas() override;
     SkSurface* onNewSurface(const SkImageInfo&) override;
-    SkImage* onNewImageSnapshot(Budgeted, ForceCopyMode) override;
+    SkImage* onNewImageSnapshot(SkBudgeted, ForceCopyMode) override;
     void onCopyOnWrite(ContentChangeMode) override;
     void onDiscard() override;
     void onPrepareForExternalIO() override;
diff --git a/src/image/SkSurface_Raster.cpp b/src/image/SkSurface_Raster.cpp
index 37790a0dd9..d07e94998f 100644
--- a/src/image/SkSurface_Raster.cpp
+++ b/src/image/SkSurface_Raster.cpp
@@ -24,7 +24,7 @@ public:
 
     SkCanvas* onNewCanvas() override;
     SkSurface* onNewSurface(const SkImageInfo&) override;
-    SkImage* onNewImageSnapshot(Budgeted, ForceCopyMode) override;
+    SkImage* onNewImageSnapshot(SkBudgeted, ForceCopyMode) override;
     void onDraw(SkCanvas*, SkScalar x, SkScalar y, const SkPaint*) override;
     void onCopyOnWrite(ContentChangeMode) override;
     void onRestoreBackingMutability() override;
@@ -118,7 +118,7 @@ void SkSurface_Raster::onDraw(SkCanvas* canvas, SkScalar x, SkScalar y,
     canvas->drawBitmap(fBitmap, x, y, paint);
 }
 
-SkImage* SkSurface_Raster::onNewImageSnapshot(Budgeted, ForceCopyMode forceCopyMode) {
+SkImage* SkSurface_Raster::onNewImageSnapshot(SkBudgeted, ForceCopyMode forceCopyMode) {
     if (fWeOwnThePixels) {
         // SkImage_raster requires these pixels are immutable for its full lifetime.
         // We'll undo this via onRestoreBackingMutability() if we can avoid the COW.
@@ -143,7 +143,7 @@ void SkSurface_Raster::onRestoreBackingMutability() {
 
 void SkSurface_Raster::onCopyOnWrite(ContentChangeMode mode) {
     // are we sharing pixelrefs with the image?
-    SkAutoTUnref<SkImage> cached(this->refCachedImage(kNo_Budgeted, kNo_ForceUnique));
+    SkAutoTUnref<SkImage> cached(this->refCachedImage(SkBudgeted::kNo, kNo_ForceUnique));
     SkASSERT(cached);
     if (SkBitmapImageGetPixelRef(cached) == fBitmap.pixelRef()) {
         SkASSERT(fWeOwnThePixels);