add newImage API

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 106 matching lines @@
 
     /**
      *  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;
 
+    /**
+     *  Return an image that is a rescale of this image (using newWidth, newHeight).
+     *
+     *  If subset is NULL, then the entire original image is used as the src for the scaling.
+     *  If subset is not NULL, then it specifies subset of src-pixels used for scaling. If
+     *  subset extends beyond the bounds of the original image, then NULL is returned.
+     *
+     *  Note: it is legal for the returned image to be the same instance as the src image
+     *  (if the new dimensions == the src dimensions and any subset encloses the entire src).
+     */
+    SkImage* newImage(int newWidth, int newHeight, const SkIRect* subset = NULL) const;

[scroggo, 2014/12/22 22:08:27]

For use by Android, it might be nice to be able to have an option to supply the
memory for pixels - or, to let them know how much was used, if we can convince
them to let us use a native allocation (see
https://docs.google.com/document/d/1Axl4VtjxX5kAwX87mLFzni8Ii4Cnsr7BFMsaWY9vF...).
(I suppose in that case, they can use SkImageInfo::minRowBytes().)

[reed2, 2014/12/24 19:47:26]

For GPU images, it is hard to see how to supply the memory. For CPU images, I
guess we could add an optional allocator callback. It seems more uniform and
cleaner if we can augment the VM so we can annotate ALL of our large allocations
so that Android apps can know where their memory went (not just some images).

[scroggo, 2014/12/30 11:04:40]

Agreed. The more I think about it, the more I think annotating native
allocations is the right way to go. When I talked to Derek about it last week,
his plan was to work with the VM team to get something added, but at the time he
had not heard anything yet.

+
 protected:
     SkImage(int width, int height) :
         fWidth(width),
         fHeight(height),
         fUniqueID(NextUniqueID()) {
 
         SkASSERT(width >= 0);
         SkASSERT(height >= 0);
     }
 
@@ skipping 14 matching lines @@
      *  Draw the image, cropped to the src rect, to the dst rect of a canvas.
      *  If src is larger than the bounds of the image, the rest of the image is
      *  filled with transparent black pixels.
      *
      *  See SkCanvas::drawBitmapRectToRect for similar behavior.
      */
     void drawRect(SkCanvas*, const SkRect* src, const SkRect& dst, const SkPaint*) const;
 };
 
 #endif