change old picture serialization to really handle images

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 47 matching lines @@
      *
      *  Returns NULL if the requested Info is unsupported.
      */
     static SkImage* NewFromRaster(const Info&, const void* pixels, size_t rowBytes,
                                   RasterReleaseProc, ReleaseContext);
 
     /**
      *  Construct a new SkImage based on the given ImageGenerator.
      *  This function will always take ownership of the passed
      *  ImageGenerator.  Returns NULL on error.
+     *
+     *  If a subset is specified, it must be contained within the generator's bounds.
      */
-    static SkImage* NewFromGenerator(SkImageGenerator*);
+    static SkImage* NewFromGenerator(SkImageGenerator*, const SkIRect* subset = NULL);
 
     /**
      *  Construct a new SkImage based on the specified encoded data. Returns NULL on failure,
      *  which can mean that the format of the encoded data was not recognized/supported.
      *
+     *  If a subset is specified, it must be contained within the encoded data's bounds.
+     *
      *  Regardless of success or failure, the caller is responsible for managing their ownership
      *  of the data.
      */
-    static SkImage* NewFromData(SkData* data);
+    static SkImage* NewFromEncoded(SkData* encoded, const SkIRect* subset = NULL);
+
+#ifdef SK_SUPPORT_LEGACY_IMAGE_NEWFROMDATA
+    static SkImage* NewFromData(SkData* data) {
+        return NewFromEncoded(data, NULL);
+    }
+#endif
 
     /**
      *  Create a new image from the specified descriptor. Note - the caller is responsible for
      *  managing the lifetime of the underlying platform texture.
      *
      *  Will return NULL if the specified descriptor is unsupported.
      */
     static SkImage* NewFromTexture(GrContext* ctx, const GrBackendTextureDesc& desc) {
         return NewFromTexture(ctx, desc, kPremul_SkAlphaType, NULL, NULL);
     }
@@ skipping 55 matching lines @@
      *  If the image has direct access to its pixels (i.e. they are in local
      *  RAM) return the (const) address of those pixels, and if not null, return
      *  the ImageInfo and rowBytes. The returned address is only valid while
      *  the image object is in scope.
      *
      *  On failure, returns NULL and the info and rowBytes parameters are
      *  ignored.
      */
     const void* peekPixels(SkImageInfo* info, size_t* rowBytes) const;
 
+    /**
+     *  If the image has direct access to its pixels (i.e. they are in local
+     *  RAM) return the (const) address of those pixels, and if not null, return
+     *  the true, and if pixmap is not NULL, set it to point into the image.

[scroggo, 2015/06/22 17:40:00]

nit: "the" at the beginning of the line is not needed.

[reed1, 2015/06/22 18:41:50]

Done.

+     *
+     *  On failure, return false and ignore the pixmap parameter.
+     */
+    bool peekPixels(SkPixmap* pixmap) const;
+
     // DEPRECATED
     GrTexture* getTexture() const;
 
     /**
      *  Returns true if the image is texture backed.
      */
     bool isTextureBacked() const;
 
     /** 
      *  Retrieves the backend API handle of the texture. If flushPendingGrContextReads then the
@@ skipping 16 matching lines @@
      *  corresponding src pixels, performing any colortype/alphatype transformations needed
      *  (in the case where the src and dst have different colortypes or alphatypes).
      *
      *  This call can fail, returning false, for several reasons:
      *  - If srcR does not intersect the image bounds.
      *  - If the requested colortype/alphatype cannot be converted from the image's types.
      */
     bool readPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
                     int srcX, int srcY) const;
 
+    bool readPixels(const SkPixmap& dst, int srcX, int srcY) const;
+
     /**
      *  Encode the image's pixels and return the result as a new SkData, which
      *  the caller must manage (i.e. call unref() when they are done).
      *
      *  If the image type cannot be encoded, or the requested encoder type is
      *  not supported, this will return NULL.
      */
-    SkData* encode(SkImageEncoder::Type t = SkImageEncoder::kPNG_Type,
-                   int quality = 80) const;
+    SkData* encode(SkImageEncoder::Type, int quality) const;
+
+    SkData* encode() const {
+        return this->encode(SkImageEncoder::kPNG_Type, 100);
+    }
+
+    /**
+     *  If the image already has its contents in encoded form (e.g. PNG or JPEG), return a ref
+     *  to that data (which the caller must call unref() on). The caller is responsible for calling
+     *  unref on the data when they are done.
+     *
+     *  If the image does not already has its contents in encoded form, return NULL.
+     *
+     *  Note: to force the image to return its contents as encoded data, try calling encode(...).
+     */
+    SkData* refEncoded() const;
 
     /**
      *  Return a new surface that is compatible with this image's internal representation
      *  (e.g. raster or gpu).
      *
      *  If no surfaceprops are specified, the image will attempt to match the props of when it
      *  was created (if it came from a surface).
      */
     SkSurface* newSurface(const SkImageInfo&, const SkSurfaceProps* = NULL) const;
 
@@ skipping 34 matching lines @@
     const int       fWidth;
     const int       fHeight;
     const uint32_t  fUniqueID;
 
     static uint32_t NextUniqueID();
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif