Move Budgeted enum out of SkSurface, use in GrTextureProvider

src/gpu/SkGpuDevice.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 "SkGpuDevice.h"
 
 #include "GrBlurUtils.h"
@@ skipping 129 matching lines @@
     if (!rt || rt->wasDestroyed()) {
         return nullptr;
     }
     unsigned flags;
     if (!CheckAlphaTypeAndGetFlags(nullptr, init, &flags)) {
         return nullptr;
     }
     return new SkGpuDevice(rt, width, height, props, flags);
 }
 
-SkGpuDevice* SkGpuDevice::Create(GrContext* context, SkSurface::Budgeted budgeted,
+SkGpuDevice* SkGpuDevice::Create(GrContext* context, SkBudgeted budgeted,
                                  const SkImageInfo& info, int sampleCount,
                                  const SkSurfaceProps* props, InitContents init,
                                  GrTextureStorageAllocator customAllocator) {
     unsigned flags;
     if (!CheckAlphaTypeAndGetFlags(&info, init, &flags)) {
         return nullptr;
     }
 
     SkAutoTUnref<GrRenderTarget> rt(CreateRenderTarget(
             context, budgeted, info, sampleCount, customAllocator));
@@ skipping 17 matching lines @@
     fLegacyBitmap.setInfo(info);
     fLegacyBitmap.setPixelRef(pr)->unref();
 
     fDrawContext.reset(this->context()->drawContext(rt, &this->surfaceProps()));
     if (flags & kNeedClear_Flag) {
         this->clearAll();
     }
 }
 
 GrRenderTarget* SkGpuDevice::CreateRenderTarget(
-        GrContext* context, SkSurface::Budgeted budgeted, const SkImageInfo& origInfo,
+        GrContext* context, SkBudgeted budgeted, const SkImageInfo& origInfo,
         int sampleCount, GrTextureStorageAllocator textureStorageAllocator) {
     if (kUnknown_SkColorType == origInfo.colorType() ||
         origInfo.width() < 0 || origInfo.height() < 0) {
         return nullptr;
     }
 
     if (!context) {
         return nullptr;
     }
 
@@ skipping 10 matching lines @@
     }
     const SkImageInfo info = SkImageInfo::Make(origInfo.width(), origInfo.height(), ct, at);
 
     GrSurfaceDesc desc;
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
     desc.fWidth = info.width();
     desc.fHeight = info.height();
     desc.fConfig = SkImageInfo2GrPixelConfig(info);
     desc.fSampleCnt = sampleCount;
     desc.fTextureStorageAllocator = textureStorageAllocator;
-    GrTexture* texture = context->textureProvider()->createTexture(
-        desc, SkToBool(budgeted), nullptr, 0);
+    GrTexture* texture = context->textureProvider()->createTexture(desc, budgeted, nullptr, 0);
     if (nullptr == texture) {
         return nullptr;
     }
     SkASSERT(nullptr != texture->asRenderTarget());
     return texture->asRenderTarget();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 bool SkGpuDevice::onReadPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
@@ skipping 83 matching lines @@
     ASSERT_SINGLE_OWNER
     GrColor color = 0;
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "clearAll", fContext);
     SkIRect rect = SkIRect::MakeWH(this->width(), this->height());
     fDrawContext->clear(&rect, color, true);
 }
 
 void SkGpuDevice::replaceRenderTarget(bool shouldRetainContent) {
     ASSERT_SINGLE_OWNER
 
-    SkSurface::Budgeted budgeted =
-            fRenderTarget->resourcePriv().isBudgeted() ? SkSurface::kYes_Budgeted
-                                                       : SkSurface::kNo_Budgeted;
+    SkBudgeted budgeted = fRenderTarget->resourcePriv().isBudgeted();
 
     SkAutoTUnref<GrRenderTarget> newRT(CreateRenderTarget(
         this->context(), budgeted, this->imageInfo(), fRenderTarget->desc().fSampleCnt,
         fRenderTarget->desc().fTextureStorageAllocator));
 
     if (nullptr == newRT) {
         return;
     }
 
     if (shouldRetainContent) {
@@ skipping 1440 matching lines @@
 
     SkAutoTUnref<GrTexture> texture;
     // Skia's convention is to only clear a device if it is non-opaque.
     InitContents init = cinfo.fInfo.isOpaque() ? kUninit_InitContents : kClear_InitContents;
 
     // layers are never draw in repeat modes, so we can request an approx
     // match and ignore any padding.
     if (kNever_TileUsage == cinfo.fTileUsage) {
         texture.reset(fContext->textureProvider()->createApproxTexture(desc));
     } else {
-        texture.reset(fContext->textureProvider()->createTexture(desc, true));
+        texture.reset(fContext->textureProvider()->createTexture(desc, SkBudgeted::kYes));
     }
 
     if (texture) {
         SkSurfaceProps props(this->surfaceProps().flags(), cinfo.fPixelGeometry);
         return SkGpuDevice::Create(
             texture->asRenderTarget(), cinfo.fInfo.width(), cinfo.fInfo.height(), &props, init);
     } else {
         SkErrorInternals::SetError( kInternalError_SkError,
                                     "---- failed to create gpu device texture [%d %d]\n",
                                     cinfo.fInfo.width(), cinfo.fInfo.height());
         return nullptr;
     }
 }
 
 SkSurface* SkGpuDevice::newSurface(const SkImageInfo& info, const SkSurfaceProps& props) {
     ASSERT_SINGLE_OWNER
     // TODO: Change the signature of newSurface to take a budgeted parameter.
-    static const SkSurface::Budgeted kBudgeted = SkSurface::kNo_Budgeted;
+    static const SkBudgeted kBudgeted = SkBudgeted::kNo;
     return SkSurface::NewRenderTarget(fContext, kBudgeted, info, fRenderTarget->desc().fSampleCnt,
                                       &props);
 }
 
 bool SkGpuDevice::EXPERIMENTAL_drawPicture(SkCanvas* mainCanvas, const SkPicture* mainPicture,
                                            const SkMatrix* matrix, const SkPaint* paint) {
     ASSERT_SINGLE_OWNER
 #ifndef SK_IGNORE_GPU_LAYER_HOISTING
     // todo: should handle this natively
     if (paint) {
@@ skipping 67 matching lines @@
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     ASSERT_SINGLE_OWNER
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkGpuDevice::NewImageFilterCache();
 }
 
 #endif