remove unused (by the outside) SkImage::newSurface, and simplify newImage -> newSubset

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 252 matching lines @@
      *  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;
-
     const char* toString(SkString*) const;
 
+#ifdef SK_SUPPORT_LEGACY_NEWIMAGE
     /**
      *  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.
      *
      *  Notes:
      *  - newWidth and newHeight must be > 0 or NULL will be returned.
      *
      *  - it is legal for the returned image to be the same instance as the src image
      *    (if the new dimensions == the src dimensions and subset is NULL or == src dimensions).
      *
      *  - it is legal for the "scaled" image to have changed its SkAlphaType from unpremul
      *    to premul (as required by the impl). The image should draw (nearly) identically,
      *    since during drawing we will "apply the alpha" to the pixels. Future optimizations
      *    may take away this caveat, preserving unpremul.
      */
-    SkImage* newImage(int newWidth, int newHeight, const SkIRect* subset = NULL,
-                      SkFilterQuality = kNone_SkFilterQuality) const;
+    SkImage* newImage(int newWidth, int newHeight, const SkIRect* subset) const;
+#endif
+
+    /**
+     *  Return a new image that is a subset of this image. The underlying implementation may
+     *  share the pixels, or it may make a copy.
+     *
+     *  If subset does not intersect the bounds of this image, or the copy/share cannot be made,
+     *  NULL will be returned.
+     */
+    SkImage* newSubset(const SkIRect& subset) const;
 
     // Helper functions to convert to SkBitmap
 
     enum LegacyBitmapMode {
         kRO_LegacyBitmapMode,
         kRW_LegacyBitmapMode,
     };
 
     /**
      *  Attempt to create a bitmap with the same pixels as the image. The result will always be
@@ skipping 17 matching lines @@
 
 private:
     const int       fWidth;
     const int       fHeight;
     const uint32_t  fUniqueID;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif