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.
+     *
+     *  On failure, return false and ignore the pixmap parameter.
+     */
+    bool peekPixmap(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 27 matching lines @@
      *  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;
 
     /**
+     *  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) and return the X,Y offset from the
+     *  left-top pixels in the encoded data where this image begins.
+     *
+     *  If the image does not already has its contents in encoded form, return NULL and ignore
+     *  the origin parameter.
+     */
+    SkData* refEncodedData(SkIPoint* origin) 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;
 
     const char* toString(SkString*) const;
 
@@ skipping 32 matching lines @@
     const int       fWidth;
     const int       fHeight;
     const uint32_t  fUniqueID;
 
     static uint32_t NextUniqueID();
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif