Add deferred texture upload API.

include/core/SkImage.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 SkImage_DEFINED
 #define SkImage_DEFINED
 
 #include "SkFilterQuality.h"
 #include "SkImageInfo.h"
 #include "SkImageEncoder.h"
 #include "SkRefCnt.h"
 #include "SkScalar.h"
 #include "SkShader.h"
 
 class SkData;
 class SkCanvas;
 class SkColorTable;
 class SkImageGenerator;
 class SkPaint;
 class SkPicture;
 class SkPixelSerializer;
 class SkString;
 class SkSurface;
 class GrContext;
+class GrContextThreadSafeProxy;
 class GrTexture;
 
 #define SK_SUPPORT_LEGACY_IMAGEFACTORY
 
 /**
  *  SkImage is an abstraction for drawing a rectagle of pixels, though the
  *  particular type of image could be actually storing its data on the GPU, or
  *  as drawing commands (picture or PDF or otherwise), ready to be played back
  *  into another canvas.
  *
@@ skipping 276 matching lines @@
      */
     sk_sp<SkImage> makeSubset(const SkIRect& subset) const;
 
     /**
      *  Ensures that an image is backed by a texture (when GrContext is non-null). If no
      *  transformation is required, the returned image may be the same as this image. If the this
      *  image is from a different GrContext, this will fail.
      */
     sk_sp<SkImage> makeTextureImage(GrContext*) const;
 
+    /** Drawing params for which a deferred texture image data should be optimized. */
+    struct DeferredTextureImageUsageParams {
+        SkMatrix        fMatrix;
+        SkFilterQuality fQuality;
+    };
+
+    /**
+     * This method allows clients to capture the data necessary to turn a SkImage into a texture-
+     * backed image. If the original image is codec-backed this will decode into a format optimized
+     * for the context represented by the proxy. This method is thread safe with respect to the
+     * GrContext whence the proxy came. Clients allocate and manage the storage of the deferred
+     * texture data and control its lifetime. No cleanup is required, thus it is safe to simply free
+     * the memory out from under the data.
+     *
+     * The same method is used both for getting the size necessary for pre-uploaded texture data
+     * and for retrieving the data. The params array represents the set of draws over which to
+     * optimize the pre-upload data.
+     *
+     * When called with a null buffer this returns the size that the client must allocate in order
+     * to create deferred texture data for this image (or zero if this is an inappropriate
+     * candidate). The buffer allocated by the client should be 8 byte aligned.
+     *
+     * When buffer is not null this fills in the deferred texture data for this image in the
+     * provided buffer (assuming this is an appropriate candidate image and the buffer is
+     * appropriately aligned). Upon success the size written is returned, otherwise 0.
+     */
+    size_t getDeferredTextureImageData(const GrContextThreadSafeProxy&,
+                                       const DeferredTextureImageUsageParams[],
+                                       int paramCnt,
+                                       void* buffer) const;
+
+    /**
+     * Returns a texture-backed image from data produced in SkImage::getDeferredTextureImageData.
+     * The context must be the context that provided the proxy passed to
+     * getDeferredTextureImageData.
+     */
+    static sk_sp<SkImage> MakeFromDeferredTextureImageData(GrContext*, const void*, SkBudgeted);
+
     // Helper functions to convert to SkBitmap
 
     enum LegacyBitmapMode {
         kRO_LegacyBitmapMode,
         kRW_LegacyBitmapMode,
     };
 
     /**
      *  Attempt to create a bitmap with the same pixels as the image. The result will always be
      *  a raster-backed bitmap (texture-backed bitmaps are DEPRECATED, and not supported here).
@@ skipping 34 matching lines @@
                                           SkAlphaType = kPremul_SkAlphaType);
     static SkImage* NewFromTextureCopy(GrContext*, const GrBackendTextureDesc&,
                                        SkAlphaType = kPremul_SkAlphaType);
     static SkImage* NewFromYUVTexturesCopy(GrContext*, SkYUVColorSpace,
                                            const GrBackendObject yuvTextureHandles[3],
                                            const SkISize yuvSizes[3],
                                            GrSurfaceOrigin);
     static SkImage* NewFromPicture(const SkPicture*, const SkISize& dimensions,
                                    const SkMatrix*, const SkPaint*);
     static SkImage* NewTextureFromPixmap(GrContext*, const SkPixmap&, SkBudgeted budgeted);
+    static SkImage* NewFromDeferredTextureImageData(GrContext*, const void*, SkBudgeted);
 
     SkImage* newSubset(const SkIRect& subset) const { return this->makeSubset(subset).release(); }
     SkImage* newTextureImage(GrContext* ctx) const { return this->makeTextureImage(ctx).release(); }
 #endif
 
 protected:
     SkImage(int width, int height, uint32_t uniqueID);
 
 private:
     const int       fWidth;
     const int       fHeight;
     const uint32_t  fUniqueID;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif