Add whitelist parameter to refEncodedData

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 "SkBitmap.h"
 #include "SkColor.h"
+#include "SkEncodedFormat.h"
 #include "SkImageInfo.h"
 #include "SkYUVSizeInfo.h"
 
 class GrContext;
 class GrTexture;
 class GrTextureParams;
 class SkBitmap;
 class SkData;
 class SkImageGenerator;
 class SkMatrix;
 class SkPaint;
 class SkPicture;
 
 #ifdef SK_SUPPORT_LEGACY_REFENCODEDDATA_NOCTX
     #define SK_REFENCODEDDATA_CTXPARAM
 #else
-    #define SK_REFENCODEDDATA_CTXPARAM  GrContext* ctx
+    #define SK_REFENCODEDDATA_CTXPARAM  RefEncodedWhitelist* whitelist
 #endif
 
 /**
  *  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.
  *
  *  If generator is NULL, will safely return false.
  *
@@ skipping 23 matching lines @@
 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 the GrContext is non-null, then the caller is only interested in
-     *  gpu-specific formats, so the impl may return null even if they have encoded data,
-     *  assuming they know it is not suitable for the gpu.
+     *  A callback object passed to refEncodedData to determine whether the caller wants its format.
+     */
+    class RefEncodedWhitelist {
+    public:
+        virtual ~RefEncodedWhitelist() {}
+
+        /**
+         *  An implementation of onRefEncodedData may call this with the SkEncodedFormat representing
+         *  its encoded data. If the method returns false, the implementation need not return its data.
+         */
+        virtual bool includes(SkEncodedFormat) = 0;
+    };
+
+    /**
+     *  Return a ref to the encoded (i.e. compressed) representation of the image, or null if
+     *  no such encoded form is readily available. This is not meant to trigger a full-blown
+     *  encoding step, as the caller can always perform that itself. This is meant to give the
+     *  caller quick access to the encoded version iff it is already available.
      *
-     *  If non-NULL is returned, the caller is responsible for calling
-     *  unref() on the data when it is finished.
+     *  If whitelist is non-null, then the implementation may call it to preflight if the client
+     *  wants its format. If the generator readily has the encoded data available, it may ignore
+     *  the whitelist and just return its data. However, if there is a performance or other
+     *  constraint on returning the encoded data (e.g. the encoded data already exists, but is
+     *  not contiguous), calling the whitelist allows the generator to discover if its format is
+     *  not whitelisted, in which case the generator should just return null.
      */
-    SkData* refEncodedData(GrContext* ctx = nullptr) {
+    SkData* refEncodedData(RefEncodedWhitelist* whitelist = nullptr) {
 #ifdef SK_SUPPORT_LEGACY_REFENCODEDDATA_NOCTX
         return this->onRefEncodedData();
 #else
-        return this->onRefEncodedData(ctx);
+        return this->onRefEncodedData(whitelist);
 #endif
     }
 
     /**
      *  Return the ImageInfo associated with this generator.
      */
     const SkImageInfo& getInfo() const { return fInfo; }
 
     /**
      *  Decode into the given pixels, a block of memory of size at
@@ skipping 186 matching lines @@
     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