Require budget decision when creating a RenderTarget SkSurface

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 "SkCanvas.h"
 #include "SkData.h"
 #include "SkImageEncoder.h"
@@ skipping 33 matching lines @@
         case kRaster_SurfaceType:
             return SkSurface::NewRaster(info);
         case kRasterDirect_SurfaceType: {
             const size_t rowBytes = info.minRowBytes();
             void* storage = sk_malloc_throw(info.getSafeSize(rowBytes));
             return SkSurface::NewRasterDirectReleaseProc(info, storage, rowBytes,
                                                          release_storage, storage);
         }
         case kGpu_SurfaceType:
 #if SK_SUPPORT_GPU
-            return context ? SkSurface::NewRenderTarget(context, info, 0, NULL) : NULL;
+            if (context) {
+                return SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info, 0, NULL);
+            }
+            return NULL;
 #endif
             break;
         case kGpuScratch_SurfaceType:
 #if SK_SUPPORT_GPU
-            return context ? SkSurface::NewScratchRenderTarget(context, info) : NULL;
+            if (context) {
+                return SkSurface::NewRenderTarget(context, SkSurface::kYes_Budgeted, info, 0, NULL);
+            }
+            return NULL;
 #endif
             break;
     }
     return NULL;
 }
 
 enum ImageType {
     kRasterCopy_ImageType,
     kRasterData_ImageType,
     kGpu_ImageType,
@@ skipping 17 matching lines @@
     REPORTER_ASSERT(reporter, NULL == SkImage::NewRasterData(info, NULL, 0));
     REPORTER_ASSERT(reporter, NULL == SkImage::NewFromGenerator(SkNEW(EmptyGenerator)));
 }
 
 static void test_empty_surface(skiatest::Reporter* reporter, GrContext* ctx) {
     const SkImageInfo info = SkImageInfo::Make(0, 0, kN32_SkColorType, kPremul_SkAlphaType);
     
     REPORTER_ASSERT(reporter, NULL == SkSurface::NewRaster(info));
     REPORTER_ASSERT(reporter, NULL == SkSurface::NewRasterDirect(info, NULL, 0));
     if (ctx) {
-        REPORTER_ASSERT(reporter, NULL == SkSurface::NewRenderTarget(ctx, info, 0, NULL));
-        REPORTER_ASSERT(reporter, NULL == SkSurface::NewScratchRenderTarget(ctx, info, 0, NULL));
+        REPORTER_ASSERT(reporter, NULL ==
+                        SkSurface::NewRenderTarget(ctx, SkSurface::kNo_Budgeted, info, 0, NULL));
     }
 }
 
 static void test_image(skiatest::Reporter* reporter) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(1, 1);
     size_t rowBytes = info.minRowBytes();
     size_t size = info.getSafeSize(rowBytes);
     SkData* data = SkData::NewUninitialized(size);
 
     REPORTER_ASSERT(reporter, data->unique());
@@ skipping 13 matching lines @@
     SkAutoTUnref<SkData> data(SkData::NewUninitialized(size));
     void* addr = data->writable_data();
     sk_memset32((SkPMColor*)addr, pmcolor, SkToInt(size >> 2));
 
     switch (imageType) {
         case kRasterCopy_ImageType:
             return SkImage::NewRasterCopy(info, addr, rowBytes);
         case kRasterData_ImageType:
             return SkImage::NewRasterData(info, data, rowBytes);
         case kGpu_ImageType: {
-            SkAutoTUnref<SkSurface> surf(SkSurface::NewRenderTarget(context, info, 0));
+            SkAutoTUnref<SkSurface> surf(
+                SkSurface::NewRenderTarget(context, SkSurface::kNo_Budgeted, info, 0));
             surf->getCanvas()->clear(color);
             return surf->newImageSnapshot();
         }
         case kCodec_ImageType: {
             SkBitmap bitmap;
             bitmap.installPixels(info, addr, rowBytes);
             SkAutoTUnref<SkData> src(
                  SkImageEncoder::EncodeData(bitmap, SkImageEncoder::kPNG_Type, 100));
             return SkImage::NewFromData(src);
         }
@@ skipping 386 matching lines @@
                 TestSurfaceNoCanvas(reporter, kGpu_SurfaceType, context, SkSurface::kRetain_ContentChangeMode);
                 TestSurfaceNoCanvas(reporter, kGpuScratch_SurfaceType, context, SkSurface::kRetain_ContentChangeMode);
                 TestGetTexture(reporter, kGpu_SurfaceType, context);
                 TestGetTexture(reporter, kGpuScratch_SurfaceType, context);
                 test_empty_surface(reporter, context);
             }
         }
     }
 #endif
 }