Store mipmap levels in deferred texture image

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
 
@@ skipping 347 matching lines @@
      *  If the result image cannot be created, or the result would be transparent black, null
      *  is returned, in which case the offset and outSubset parameters should be ignored by the
      *  caller.
      */
     sk_sp<SkImage> makeWithFilter(const SkImageFilter* filter, const SkIRect& subset,
                                   const SkIRect& clipBounds, SkIRect* outSubset,
                                   SkIPoint* offset) const;
 
     /** Drawing params for which a deferred texture image data should be optimized. */
     struct DeferredTextureImageUsageParams {
-        DeferredTextureImageUsageParams() : fPreScaleMipLevel(0) {}
-        DeferredTextureImageUsageParams(const SkMatrix matrix, const SkFilterQuality quality, 
+        DeferredTextureImageUsageParams(const SkMatrix matrix, const SkFilterQuality quality,
                                         int preScaleMipLevel)
             : fMatrix(matrix), fQuality(quality), fPreScaleMipLevel(preScaleMipLevel) {}
         SkMatrix        fMatrix;
         SkFilterQuality fQuality;
         int             fPreScaleMipLevel;
     };
 
     /**
      * 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
@@ skipping 10 matching lines @@
      * 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;
+                                       void* buffer,
+                                       SkSourceGammaTreatment treatment =
+                                       SkSourceGammaTreatment::kIgnore) 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
 
@@ skipping 52 matching lines @@
     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:
     static sk_sp<SkImage> MakeTextureFromMipMap(GrContext*, const SkImageInfo&,
                                                 const GrMipLevel* texels, int mipLevelCount,
-                                                SkBudgeted);
+                                                SkBudgeted, SkSourceGammaTreatment);
 
     const int       fWidth;
     const int       fHeight;
     const uint32_t  fUniqueID;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif