Extend SkImageGenerator to support natively generated GrTextures

include/core/SkImageGenerator.h

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkImageGenerator_DEFINED
 #define SkImageGenerator_DEFINED
 
 #include "SkColor.h"
 #include "SkImageInfo.h"
 
+class GrContext;
 class SkBitmap;
 class SkData;
+class GrTexture;
 class SkImageGenerator;
 class SkMatrix;
 class SkPaint;
 class SkPicture;
 
 /**
  *  Takes ownership of SkImageGenerator.  If this method fails for
  *  whatever reason, it will return false and immediatetely delete
  *  the generator.  If it succeeds, it will modify destination
  *  bitmap.
@@ skipping 23 matching lines @@
  *  SkDiscardablePixelRef) to decode and re-decode an image as needed.
  */
 class SK_API SkImageGenerator : public SkNoncopyable {
 public:
     /**
      *  The PixelRef which takes ownership of this SkImageGenerator
      *  will call the image generator's destructor.
      */
     virtual ~SkImageGenerator() { }
 
+    uint32_t uniqueID() const { return fUniqueID; }
+
     /**
      *  Return a ref to the encoded (i.e. compressed) representation,
      *  of this data.
      *
      *  If non-NULL is returned, the caller is responsible for calling
      *  unref() on the data when it is finished.
      */
     SkData* refEncodedData() { return this->onRefEncodedData(); }
 
     /**
@@ skipping 47 matching lines @@
      *  entries only. Having only partial planes/rowBytes information is not supported.
      *
      *  If all planes and rowBytes entries are non NULL or non 0, then it should copy the
      *  associated YUV data into those planes of memory supplied by the caller. It should validate
      *  that the sizes match what it expected. If the sizes do not match, it should return false.
      */
     bool getYUV8Planes(SkISize sizes[3], void* planes[3], size_t rowBytes[3],
                        SkYUVColorSpace* colorSpace);
 
     /**
+     *  If the generator can natively/efficiently return its pixels as a GPU image (backed by a
+     *  texture) this will return that image. If not, this will return NULL.
+     *
+     *  Regarding the GrContext parameter:
+     *
+     *  The caller may pass NULL for the context. In that case the generator may assume that its
+     *  internal context is current. If it has no internal context, then it should just return
+     *  null.
+     *
+     *  If the caller passes a non-null context, then the generator should only succeed if:
+     *  - it has no intrinsic context, and will use the caller's
+     *  - its internal context is the same
+     *  - it can somehow convert its texture into one that is valid for the provided context.
+     *
+     *  Regarding the SkImageUsageType parameter:
+     *
+     *  If the context (the provided one or the generator's intrinsic one) determines that to
+     *  support the specified usage, it must return a different sized texture (from the generator's
+     *  native size) it may, so the caller must inspect the texture's width/height
+     *  (unless kUntiled_SkImageUsedType was specified).
+     */
+    GrTexture* generateTexture(GrContext*, SkImageUsageType);
+
+    /**
      *  If the default image decoder system can interpret the specified (encoded) data, then
      *  this returns a new ImageGenerator for it. Otherwise this returns NULL. Either way
      *  the caller is still responsible for managing their ownership of the data.
      */
     static SkImageGenerator* NewFromEncoded(SkData*);
 
     /** Return a new image generator backed by the specified picture.  If the size is empty or
      *  the picture is NULL, this returns NULL.
      *  The optional matrix and paint arguments are passed to drawPicture() at rasterization
      *  time.
      */
     static SkImageGenerator* NewFromPicture(const SkISize&, const SkPicture*, const SkMatrix*,
                                             const SkPaint*);
 
 protected:
-    SkImageGenerator(const SkImageInfo& info) : fInfo(info) {}
+    SkImageGenerator(const SkImageInfo& info);
 
     virtual SkData* onRefEncodedData();
 
     virtual bool onGetPixels(const SkImageInfo& info, void* pixels, size_t rowBytes,
                              SkPMColor ctable[], int* ctableCount);
     virtual bool onGetYUV8Planes(SkISize sizes[3], void* planes[3], size_t rowBytes[3]);
     virtual bool onGetYUV8Planes(SkISize sizes[3], void* planes[3], size_t rowBytes[3],
                                  SkYUVColorSpace* colorSpace);
 
+    virtual GrTexture* onGenerateTexture(GrContext*, SkImageUsageType) { return nullptr; }
+
 private:
     const SkImageInfo fInfo;
+    const uint32_t fUniqueID;
 
     // This is our default impl, which may be different on different platforms.
     // It is called from NewFromEncoded() after it has checked for any runtime factory.
     // The SkData will never be NULL, as that will have been checked by NewFromEncoded.
     static SkImageGenerator* NewFromEncodedImpl(SkData*);
 };
 
 #endif  // SkImageGenerator_DEFINED