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 Committed: https://skia.googlesource.com/skia/+/57599fe6c0336feaeeeb9b1996e77b70219b483c CQ_EXTRA_TRYBOTS=client.skia.compile:Build-Ubuntu-GCC-x86_64-Release-CMake-Trybot,Build-Mac-Clang-x86_64-Release-CMake-Trybot Review URL: https://codereview.chromium.org/1728093005
zstang · Feb 25, 2016 · 5ec26ae · 5ec26ae
1 parent f7e865a
commit 5ec26ae
Show file tree

Hide file tree

Showing 87 changed files with 221 additions and 212 deletions.
diff --git a/bench/nanobench.cpp b/bench/nanobench.cpp
@@ -185,7 +185,7 @@ struct GPUTarget : public Target {
         SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
         this->surface.reset(SkSurface::NewRenderTarget(gGrFactory->get(this->config.ctxType,
                                                                        this->config.ctxOptions),
-                                                         SkSurface::kNo_Budgeted, info,
+                                                         SkBudgeted::kNo, info,
                                                          this->config.samples, &props));
         this->gl = gGrFactory->getContextInfo(this->config.ctxType,
                                               this->config.ctxOptions).fGLContext;

diff --git a/cmake/example.cpp b/cmake/example.cpp
@@ -54,7 +54,7 @@ static std::shared_ptr<SkSurface> create_opengl_surface(int w, int h) {
     std::cout << "Using opengl surface" << std::endl;
     std::shared_ptr<GrContext> grContext = adopt(GrContext::Create(kOpenGL_GrBackend, 0));
     return adopt(SkSurface::NewRenderTarget(grContext.get(),
-                                            SkSurface::kNo_Budgeted,
+                                            SkBudgeted::kNo,
                                             SkImageInfo::MakeN32Premul(w,h)));
 }
 

diff --git a/dm/DMGpuSupport.h b/dm/DMGpuSupport.h
@@ -36,7 +36,7 @@ static inline SkSurface* NewGpuSurface(GrContextFactory* grFactory,
                                        bool useDIText) {
     uint32_t flags = useDIText ? SkSurfaceProps::kUseDeviceIndependentFonts_Flag : 0;
     SkSurfaceProps props(flags, SkSurfaceProps::kLegacyFontHost_InitType);
-    return SkSurface::NewRenderTarget(grFactory->get(type, options), SkSurface::kNo_Budgeted,
+    return SkSurface::NewRenderTarget(grFactory->get(type, options), SkBudgeted::kNo,
                                       info, samples, &props);
 }
 

diff --git a/experimental/fiddle/fiddle_main.cpp b/experimental/fiddle/fiddle_main.cpp
@@ -112,7 +112,7 @@ int main() {
             SkAutoTUnref<SkSurface> surface(
                     SkSurface::NewRenderTarget(
                             grContext,
-                            SkSurface::kNo_Budgeted,
+                            SkBudgeted::kNo,
                             SkImageInfo::MakeN32Premul(options.size)));
             if (!surface) {
                 fputs("Unable to get render surface.\n", stderr);

diff --git a/gm/bleed.cpp b/gm/bleed.cpp
@@ -236,8 +236,8 @@ bool make_oversized_texture_bitmap(GrContext* ctx, TestPixels* result, int width
     desc.fConfig = config;
     desc.fWidth = width + kXPad;
     desc.fHeight = height + kYPad;
-    SkAutoTUnref<GrTexture> texture(ctx->textureProvider()->createTexture(desc, true, pixels.get(),
-                                                                          rowBytes));
+    SkAutoTUnref<GrTexture> texture(ctx->textureProvider()->createTexture(
+            desc, SkBudgeted::kYes, pixels.get(), rowBytes));
 
     if (!texture) {
         return false;

diff --git a/gm/dftext.cpp b/gm/dftext.cpp
@@ -51,7 +51,7 @@ class DFTextGM : public skiagm::GM {
         SkImageInfo info = SkImageInfo::MakeN32Premul(onISize());
         SkSurfaceProps props(SkSurfaceProps::kUseDeviceIndependentFonts_Flag,
                              SkSurfaceProps::kLegacyFontHost_InitType);
-        SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(ctx, SkSurface::kNo_Budgeted,
+        SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(ctx, SkBudgeted::kNo,
                                                                    info, 0, &props));
         SkCanvas* canvas = surface.get() ? surface->getCanvas() : inputCanvas;
         // init our new canvas with the old canvas's matrix

diff --git a/gm/discard.cpp b/gm/discard.cpp
@@ -45,7 +45,7 @@ class DiscardGM : public GM {
         size.fWidth /= 10;
         size.fHeight /= 10;
         SkImageInfo info = SkImageInfo::MakeN32Premul(size);
-        SkSurface* surface = SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info);
+        SkSurface* surface = SkSurface::NewRenderTarget(context, SkBudgeted::kNo, info);
 
         if (nullptr == surface) {
             return;

diff --git a/gm/image.cpp b/gm/image.cpp
@@ -177,7 +177,7 @@ class ImageGM : public skiagm::GM {
 
 #if SK_SUPPORT_GPU
         surf2.reset(SkSurface::NewRenderTarget(canvas->getGrContext(),
-                                               SkSurface::kNo_Budgeted, info));
+                                               SkBudgeted::kNo, info));
 #endif
 
         test_surface(canvas, surf0, true);
@@ -262,7 +262,7 @@ static SkImage* make_codec(const SkImageInfo& info, GrContext*, void (*draw)(SkC
 
 static SkImage* make_gpu(const SkImageInfo& info, GrContext* ctx, void (*draw)(SkCanvas*)) {
     if (!ctx) { return nullptr; }
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(ctx, SkSurface::kNo_Budgeted, info));
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(ctx, SkBudgeted::kNo, info));
     draw(surface->getCanvas());
     return surface->newImageSnapshot();
 }
@@ -487,7 +487,7 @@ DEF_SIMPLE_GM(new_texture_image, canvas, 225, 60) {
         // Create a texture image
         [context, render_image]() -> SkImage* {
             SkAutoTUnref<SkSurface> surface(
-                SkSurface::NewRenderTarget(context, SkSurface::kYes_Budgeted,
+                SkSurface::NewRenderTarget(context, SkBudgeted::kYes,
                                            SkImageInfo::MakeN32Premul(kSize, kSize)));
             if (!surface) {
                 return nullptr;

diff --git a/gm/image_pict.cpp b/gm/image_pict.cpp
@@ -211,7 +211,7 @@ class TextureGenerator : public SkImageGenerator {
         : SkImageGenerator(info)
         , fCtx(SkRef(ctx))
     {
-        SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(ctx, SkSurface::kNo_Budgeted,
+        SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(ctx, SkBudgeted::kNo,
                                                                    info, 0));
         surface->getCanvas()->clear(0);
         surface->getCanvas()->translate(-100, -100);
@@ -233,7 +233,7 @@ class TextureGenerator : public SkImageGenerator {
         desc.fWidth = subset->width();
         desc.fHeight = subset->height();
 
-        GrTexture* dst = fCtx->textureProvider()->createTexture(desc, false);
+        GrTexture* dst = fCtx->textureProvider()->createTexture(desc, SkBudgeted::kNo);
         fCtx->copySurface(dst, fTexture, *subset, SkIPoint::Make(0, 0));
         return dst;
     }
@@ -326,7 +326,7 @@ class ImageCacheratorGM : public skiagm::GM {
         // No API to draw a GrTexture directly, so we cheat and create a private image subclass
         SkAutoTUnref<SkImage> image(new SkImage_Gpu(cache->info().width(), cache->info().height(),
                                                     cache->uniqueID(), kPremul_SkAlphaType, texture,
-                                                    SkSurface::kNo_Budgeted));
+                                                    SkBudgeted::kNo));
         canvas->drawImage(image, x, y);
 #endif
     }

diff --git a/gm/image_shader.cpp b/gm/image_shader.cpp
@@ -37,7 +37,7 @@ static SkImage* make_texture(GrContext* ctx, const SkPicture* pic, const SkImage
     if (!ctx) {
         return nullptr;
     }
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(ctx, SkSurface::kNo_Budgeted,
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(ctx, SkBudgeted::kNo,
                                                                info, 0));
     surface->getCanvas()->clear(0);
     surface->getCanvas()->drawPicture(pic);

diff --git a/gm/imagetoyuvplanes.cpp b/gm/imagetoyuvplanes.cpp
@@ -16,7 +16,7 @@ static SkImage* create_image(GrContext* context, int width, int height) {
     SkAutoTUnref<SkSurface> surface;
     SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
     if (context) {
-        surface.reset(SkSurface::NewRenderTarget(context,  SkSurface::kYes_Budgeted, info, 0));
+        surface.reset(SkSurface::NewRenderTarget(context,  SkBudgeted::kYes, info, 0));
     } else {
         surface.reset(SkSurface::NewRaster(info));
     }

diff --git a/gm/surface.cpp b/gm/surface.cpp
@@ -33,7 +33,7 @@ static SkSurface* make_surface(GrContext* ctx, const SkImageInfo& info, SkPixelG
 
     SkSurfaceProps props(flags, geo);
     if (ctx) {
-        return SkSurface::NewRenderTarget(ctx, SkSurface::kNo_Budgeted, info, 0, &props);
+        return SkSurface::NewRenderTarget(ctx, SkBudgeted::kNo, info, 0, &props);
     } else {
         return SkSurface::NewRaster(info, &props);
     }

diff --git a/gm/texdata.cpp b/gm/texdata.cpp
@@ -70,7 +70,7 @@ DEF_SIMPLE_GM_BG(texdata, canvas, 2 * S, 2 * S, SK_ColorBLACK) {
                 desc.fWidth     = 2 * S;
                 desc.fHeight    = 2 * S;
                 GrTexture* texture = ctx->textureProvider()->createTexture(
-                    desc, false, gTextureData.get(), 0);
+                    desc, SkBudgeted::kNo, gTextureData.get(), 0);
 
                 if (!texture) {
                     return;

diff --git a/gm/textblobmixedsizes.cpp b/gm/textblobmixedsizes.cpp
@@ -99,7 +99,7 @@ class TextBlobMixedSizes : public GM {
             SkImageInfo info = SkImageInfo::MakeN32Premul(onISize());
             SkSurfaceProps props(SkSurfaceProps::kUseDeviceIndependentFonts_Flag,
                                  SkSurfaceProps::kLegacyFontHost_InitType);
-            surface.reset(SkSurface::NewRenderTarget(ctx, SkSurface::kNo_Budgeted, info, 0,
+            surface.reset(SkSurface::NewRenderTarget(ctx, SkBudgeted::kNo, info, 0,
                                                      &props));
             canvas = surface.get() ? surface->getCanvas() : inputCanvas;
             // init our new canvas with the old canvas's matrix

diff --git a/gm/xfermodes3.cpp b/gm/xfermodes3.cpp
@@ -128,7 +128,7 @@ class Xfermodes3GM : public GM {
         SkImageInfo baseInfo = baseCanvas->imageInfo();
         SkImageInfo info = SkImageInfo::Make(w, h, baseInfo.colorType(), baseInfo.alphaType(),
                                              baseInfo.profileType());
-        return SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info, 0, nullptr);
+        return SkSurface::NewRenderTarget(context, SkBudgeted::kNo, info, 0, nullptr);
 #else
         return nullptr;
 #endif

diff --git a/include/core/SkSurface.h b/include/core/SkSurface.h
@@ -30,18 +30,10 @@ class GrRenderTarget;
  */
 class SK_API SkSurface : public SkRefCnt {
 public:
-    /**
-     *  Indicates whether a new surface or image should count against a cache budget. Currently this
-     *  is only used by the GPU backend (sw-raster surfaces and images are never counted against the
-     *  resource cache budget.)
-     */
-    enum Budgeted {
-        /** The surface or image does not count against the cache budget. */
-        kNo_Budgeted,
-        /** The surface or image counts against the cache budget. */
-        kYes_Budgeted
-    };
-
+    static const SkBudgeted kYes_Budgeted = SkBudgeted::kYes;
+    static const SkBudgeted kNo_Budgeted = SkBudgeted::kNo;
+    using Budgeted = SkBudgeted;
+
     /**
      *  Create a new surface, using the specified pixels/rowbytes as its
      *  backend.
@@ -135,10 +127,10 @@ class SK_API SkSurface : public SkRefCnt {
      *  additional textures.
      */
     static SkSurface* NewRenderTarget(
-            GrContext*, Budgeted, const SkImageInfo&, int sampleCount, const SkSurfaceProps* = NULL,
-            GrTextureStorageAllocator = GrTextureStorageAllocator());
+            GrContext*, SkBudgeted, const SkImageInfo&, int sampleCount,
+            const SkSurfaceProps* = NULL, GrTextureStorageAllocator = GrTextureStorageAllocator());
 
-    static SkSurface* NewRenderTarget(GrContext* gr, Budgeted b, const SkImageInfo& info) {
+    static SkSurface* NewRenderTarget(GrContext* gr, SkBudgeted b, const SkImageInfo& info) {
         return NewRenderTarget(gr, b, info, 0);
     }
 
@@ -244,7 +236,7 @@ class SK_API SkSurface : public SkRefCnt {
      *  parameter controls whether it counts against the resource budget
      *  (currently for the gpu backend only).
      */
-    SkImage* newImageSnapshot(Budgeted = kYes_Budgeted);
+    SkImage* newImageSnapshot(SkBudgeted = SkBudgeted::kYes);
 
     /**
      * In rare instances a client may want a unique copy of the SkSurface's contents in an image
@@ -256,7 +248,7 @@ class SK_API SkSurface : public SkRefCnt {
         kNo_ForceUnique,
         kYes_ForceUnique
     };
-    SkImage* newImageSnapshot(Budgeted, ForceUnique);
+    SkImage* newImageSnapshot(SkBudgeted, ForceUnique);
 
     /**
      *  Though the caller could get a snapshot image explicitly, and draw that,

diff --git a/include/core/SkTypes.h b/include/core/SkTypes.h
@@ -439,6 +439,17 @@ template <typename T> static inline const T& SkTPin(const T& value, const T& min
     return SkTMax(SkTMin(value, max), min);
 }
 
+
+///////////////////////////////////////////////////////////////////////////////
+
+/**
+ *  Indicates whether an allocation should count against a cache budget.
+ */
+enum class SkBudgeted : bool {
+    kNo  = false,
+    kYes = true
+};
+
 ///////////////////////////////////////////////////////////////////////////////
 
 /** Use to combine multiple bits in a bitmask in a type safe way.

diff --git a/include/gpu/GrTextureProvider.h b/include/gpu/GrTextureProvider.h
@@ -29,11 +29,11 @@ class SK_API GrTextureProvider {
      *                  implies tightly packed rows. For compressed pixel configs, this
      *                  field is ignored.
      */
-    GrTexture* createTexture(const GrSurfaceDesc& desc, bool budgeted, const void* srcData,
+    GrTexture* createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted, const void* srcData,
                              size_t rowBytes);
 
     /** Shortcut for creating a texture with no initial data to upload. */
-    GrTexture* createTexture(const GrSurfaceDesc& desc, bool budgeted) {
+    GrTexture* createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted) {
         return this->createTexture(desc, budgeted, NULL, 0);
     }
 
@@ -73,7 +73,7 @@ class SK_API GrTextureProvider {
         if (kApprox_ScratchTexMatch == match) {
             return this->createApproxTexture(desc);
         } else {
-            return this->createTexture(desc, true);
+            return this->createTexture(desc, SkBudgeted::kYes);
         }
     }
 

diff --git a/site/user/api/canvas.md b/site/user/api/canvas.md
@@ -90,7 +90,7 @@ example, we use a `GrContextFactory` to create a context.
         GrContext* context = grFactory.get(GrContextFactory::kNative_GLContextType);
         SkImageInfo info = SkImageInfo:: MakeN32Premul(width, height);
         SkAutoTUnref<SkSurface> gpuSurface(
-                SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info));
+                SkSurface::NewRenderTarget(context, SkBudgeted::kNo, info));
         if (!gpuSurface) {
             SkDebugf("SkSurface::NewRenderTarget returned null\n");
             return;

diff --git a/src/core/SkCanvas.cpp b/src/core/SkCanvas.cpp
@@ -1146,7 +1146,8 @@ static void draw_filter_into_device(SkBaseDevice* src, const SkImageFilter* filt
         // TODO: we should actually only copy the portion of the source needed to apply the image
         // filter
         GrContext* context = srcRT->getContext();
-        SkAutoTUnref<GrTexture> tex(context->textureProvider()->createTexture(srcRT->desc(), true));
+        SkAutoTUnref<GrTexture> tex(context->textureProvider()->createTexture(srcRT->desc(),
+                                                                              SkBudgeted::kYes));
 
         context->copySurface(tex, srcRT);
 

diff --git a/src/core/SkImageCacherator.cpp b/src/core/SkImageCacherator.cpp
@@ -203,7 +203,7 @@ static GrTexture* load_compressed_into_texture(GrContext* ctx, SkData* data, GrS
     }
 
     desc.fConfig = config;
-    return ctx->textureProvider()->createTexture(desc, true, rawStart, 0);
+    return ctx->textureProvider()->createTexture(desc, SkBudgeted::kYes, rawStart, 0);
 }
 
 class Generator_GrYUVProvider : public GrYUVProvider {

diff --git a/src/core/SkPictureImageGenerator.cpp b/src/core/SkPictureImageGenerator.cpp
@@ -138,8 +138,7 @@ GrTexture* SkPictureImageGenerator::onGenerateTexture(GrContext* ctx, const SkIR
     //
     // TODO: respect the usage, by possibly creating a different (pow2) surface
     //
-    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(ctx,
-                                                               SkSurface::kYes_Budgeted,
+    SkAutoTUnref<SkSurface> surface(SkSurface::NewRenderTarget(ctx, SkBudgeted::kYes,
                                                                surfaceInfo));
     if (!surface.get()) {
         return nullptr;

diff --git a/src/effects/GrCircleBlurFragmentProcessor.cpp b/src/effects/GrCircleBlurFragmentProcessor.cpp
@@ -247,7 +247,7 @@ GrTexture* GrCircleBlurFragmentProcessor::CreateCircleBlurProfileTexture(
     if (!blurProfile) {
         SkAutoTDeleteArray<uint8_t> profile(create_profile(halfWH, sigma));
 
-        blurProfile = textureProvider->createTexture(texDesc, true, profile.get(), 0);
+        blurProfile = textureProvider->createTexture(texDesc, SkBudgeted::kYes, profile.get(), 0);
         if (blurProfile) {
             textureProvider->assignUniqueKeyToTexture(key, blurProfile);
         }

diff --git a/src/effects/SkBlurMaskFilter.cpp b/src/effects/SkBlurMaskFilter.cpp
@@ -794,7 +794,7 @@ GrTexture* GrRectBlurEffect::CreateBlurProfileTexture(GrTextureProvider* texture
     if (!blurProfile) {
         SkAutoTDeleteArray<uint8_t> profile(SkBlurMask::ComputeBlurProfile(sigma));
 
-        blurProfile = textureProvider->createTexture(texDesc, true, profile.get(), 0);
+        blurProfile = textureProvider->createTexture(texDesc, SkBudgeted::kYes, profile.get(), 0);
         if (blurProfile) {
             textureProvider->assignUniqueKeyToTexture(key, blurProfile);
         }
@@ -999,7 +999,7 @@ const GrFragmentProcessor* GrRRectBlurEffect::Create(GrTextureProvider* texProvi
         texDesc.fConfig = kAlpha_8_GrPixelConfig;
 
         blurNinePatchTexture.reset(
-            texProvider->createTexture(texDesc, true, blurredMask.fImage, 0));
+            texProvider->createTexture(texDesc, SkBudgeted::kYes , blurredMask.fImage, 0));
         SkMask::FreeImage(blurredMask.fImage);
         if (!blurNinePatchTexture) {
             return nullptr;

diff --git a/src/effects/SkColorCubeFilter.cpp b/src/effects/SkColorCubeFilter.cpp
@@ -315,7 +315,7 @@ const GrFragmentProcessor* SkColorCubeFilter::asFragmentProcessor(GrContext* con
         context->textureProvider()->findAndRefTextureByUniqueKey(key));
     if (!textureCube) {
         textureCube.reset(context->textureProvider()->createTexture(
-            desc, true, fCubeData->data(), 0));
+            desc, SkBudgeted::kYes, fCubeData->data(), 0));
         if (textureCube) {
             context->textureProvider()->assignUniqueKeyToTexture(key, textureCube);
         } else {

diff --git a/src/gpu/GrContext.cpp b/src/gpu/GrContext.cpp
@@ -423,7 +423,8 @@ bool GrContext::readSurfacePixels(GrSurface* src,
         }
         SkAutoTUnref<GrTexture> temp;
         if (tempDrawInfo.fUseExactScratch) {
-            temp.reset(this->textureProvider()->createTexture(tempDrawInfo.fTempSurfaceDesc, true));
+            temp.reset(this->textureProvider()->createTexture(tempDrawInfo.fTempSurfaceDesc,
+                                                              SkBudgeted::kYes));
         } else {
             temp.reset(this->textureProvider()->createApproxTexture(tempDrawInfo.fTempSurfaceDesc));
         }

diff --git a/src/gpu/GrGpu.cpp b/src/gpu/GrGpu.cpp
@@ -88,7 +88,7 @@ static GrSurfaceOrigin resolve_origin(GrSurfaceOrigin origin, bool renderTarget)
     }
 }
 
-GrTexture* GrGpu::createTexture(const GrSurfaceDesc& origDesc, bool budgeted,
+GrTexture* GrGpu::createTexture(const GrSurfaceDesc& origDesc, SkBudgeted budgeted,
                                 const void* srcData, size_t rowBytes) {
     GrSurfaceDesc desc = origDesc;
 
@@ -120,8 +120,9 @@ GrTexture* GrGpu::createTexture(const GrSurfaceDesc& origDesc, bool budgeted,
         }
     }
 
-    GrGpuResource::LifeCycle lifeCycle = budgeted ? GrGpuResource::kCached_LifeCycle :
-                                                    GrGpuResource::kUncached_LifeCycle;
+    GrGpuResource::LifeCycle lifeCycle = SkBudgeted::kYes == budgeted ?
+                                            GrGpuResource::kCached_LifeCycle :
+                                            GrGpuResource::kUncached_LifeCycle;
 
     desc.fSampleCnt = SkTMin(desc.fSampleCnt, this->caps()->maxSampleCount());
     // Attempt to catch un- or wrongly initialized sample counts;

diff --git a/src/gpu/GrGpu.h b/src/gpu/GrGpu.h
@@ -93,7 +93,7 @@ class GrGpu : public SkRefCnt {
      *
      * @return    The texture object if successful, otherwise nullptr.
      */
-    GrTexture* createTexture(const GrSurfaceDesc& desc, bool budgeted,
+    GrTexture* createTexture(const GrSurfaceDesc& desc, SkBudgeted budgeted,
                              const void* srcData, size_t rowBytes);
 
     /**

diff --git a/src/gpu/GrGpuResource.cpp b/src/gpu/GrGpuResource.cpp
@@ -119,7 +119,7 @@ void GrGpuResource::setUniqueKey(const GrUniqueKey& key) {
     SkASSERT(key.isValid());
 
     // Wrapped and uncached resources can never have a unique key.
-    if (!this->resourcePriv().isBudgeted()) {
+    if (SkBudgeted::kNo == this->resourcePriv().isBudgeted()) {
         return;
     }