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

include/core/SkSurface.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkSurface_DEFINED
 #define SkSurface_DEFINED
 
@@ skipping 13 matching lines @@
  *
  *  To draw into a canvas, first create the appropriate type of Surface, and
  *  then request the canvas from the surface.
  *
  *  SkSurface always has non-zero dimensions. If there is a request for a new surface, and either
  *  of the requested dimensions are zero, then NULL will be returned.
  */
 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
+    };
+
+    /**
      *  Create a new surface, using the specified pixels/rowbytes as its
      *  backend.
      *
      *  If the requested surface cannot be created, or the request is not a
      *  supported configuration, NULL will be returned.
      */
     static SkSurface* NewRasterDirect(const SkImageInfo&, void* pixels, size_t rowBytes,
                                       const SkSurfaceProps* = NULL);
 
     /**
@@ skipping 72 matching lines @@
             GrContext*, const GrBackendTextureDesc&, const SkSurfaceProps*);
 
     /**
      *  Return a new surface whose contents will be drawn to an offscreen
      *  render target, allocated by the surface.
      *
      *  The GrTextureStorageAllocator will be reused if SkImage snapshots create
      *  additional textures.
      */
     static SkSurface* NewRenderTarget(
-            GrContext*, SkBudgeted, const SkImageInfo&, int sampleCount,
-            const SkSurfaceProps* = NULL, GrTextureStorageAllocator = GrTextureStorageAllocator());
+            GrContext*, Budgeted, const SkImageInfo&, int sampleCount, const SkSurfaceProps* = NULL,
+            GrTextureStorageAllocator = GrTextureStorageAllocator());
 
-    static SkSurface* NewRenderTarget(GrContext* gr, SkBudgeted b, const SkImageInfo& info) {
+    static SkSurface* NewRenderTarget(GrContext* gr, Budgeted b, const SkImageInfo& info) {
         return NewRenderTarget(gr, b, info, 0);
     }
 
     int width() const { return fWidth; }
     int height() const { return fHeight; }
 
     /**
      *  Returns a unique non-zero, unique value identifying the content of this
      *  surface. Each time the content is changed changed, either by drawing
      *  into this surface, or explicitly calling notifyContentChanged()) this
@@ skipping 85 matching lines @@
      */
     SkSurface* newSurface(const SkImageInfo&);
 
     /**
      *  Returns an image of the current state of the surface pixels up to this
      *  point. Subsequent changes to the surface (by drawing into its canvas)
      *  will not be reflected in this image. If a copy must be made the Budgeted
      *  parameter controls whether it counts against the resource budget
      *  (currently for the gpu backend only).
      */
-    SkImage* newImageSnapshot(SkBudgeted = SkBudgeted::kYes);
+    SkImage* newImageSnapshot(Budgeted = kYes_Budgeted);
 
     /**
      * In rare instances a client may want a unique copy of the SkSurface's contents in an image
      * snapshot. This enum can be used to enforce that the image snapshot's backing store is not
      * shared with another image snapshot or the surface's backing store. This is generally more
      * expensive. This was added for Chromium bug 585250.
      */
     enum ForceUnique {
         kNo_ForceUnique,
         kYes_ForceUnique
     };
-    SkImage* newImageSnapshot(SkBudgeted, ForceUnique);
+    SkImage* newImageSnapshot(Budgeted, ForceUnique);
 
     /**
      *  Though the caller could get a snapshot image explicitly, and draw that,
      *  it seems that directly drawing a surface into another canvas might be
      *  a common pattern, and that we could possibly be more efficient, since
      *  we'd know that the "snapshot" need only live until we've handed it off
      *  to the canvas.
      */
     void draw(SkCanvas*, SkScalar x, SkScalar y, const SkPaint*);
 
@@ skipping 49 matching lines @@
 private:
     const SkSurfaceProps fProps;
     const int            fWidth;
     const int            fHeight;
     uint32_t             fGenerationID;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif