make allocPixels throw on failure

include/core/SkBitmap.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkBitmap_DEFINED
 #define SkBitmap_DEFINED
 
 #include "SkColor.h"
 #include "SkColorTable.h"
 #include "SkImageInfo.h"
 #include "SkPoint.h"
 #include "SkRefCnt.h"
 
+#ifdef SK_SUPPORT_LEGACY_ALLOCPIXELS_BOOL
+    #define SK_ALLOCPIXELS_RETURN_TYPE  bool
+    #define SK_ALLOCPIXELS_RETURN_TRUE  return true
+    #define SK_ALLOCPIXELS_RETURN_FAIL  return false
+#else
+    #define SK_ALLOCPIXELS_RETURN_TYPE  void
+    #define SK_ALLOCPIXELS_RETURN_TRUE  return
+    #define SK_ALLOCPIXELS_RETURN_FAIL  sk_throw()
+#endif
+
 struct SkMask;
 struct SkIRect;
 struct SkRect;
 class SkPaint;
 class SkPixelRef;
 class SkPixelRefFactory;
 class SkRegion;
 class SkString;
 class GrTexture;
 
@@ skipping 184 matching lines @@
     void getBounds(SkIRect* bounds) const;
 
     bool setInfo(const SkImageInfo&, size_t rowBytes = 0);
 
     /**
      *  Allocate the bitmap's pixels to match the requested image info. If the Factory
      *  is non-null, call it to allcoate the pixelref. If the ImageInfo requires
      *  a colortable, then ColorTable must be non-null, and will be ref'd.
      *  On failure, the bitmap will be set to empty and return false.
      */
-    bool allocPixels(const SkImageInfo&, SkPixelRefFactory*, SkColorTable*);
+    bool SK_WARN_UNUSED_RESULT tryAllocPixels(const SkImageInfo&, SkPixelRefFactory*, SkColorTable*);
+
+    SK_ALLOCPIXELS_RETURN_TYPE allocPixels(const SkImageInfo& info, SkPixelRefFactory* factory,
+                                           SkColorTable* ctable) {
+        if (!this->tryAllocPixels(info, factory, ctable)) {
+            SK_ALLOCPIXELS_RETURN_FAIL;
+        }
+        SK_ALLOCPIXELS_RETURN_TRUE;
+    }
 
     /**
      *  Allocate the bitmap's pixels to match the requested image info and
      *  rowBytes. If the request cannot be met (e.g. the info is invalid or
      *  the requested rowBytes are not compatible with the info
      *  (e.g. rowBytes < info.minRowBytes() or rowBytes is not aligned with
      *  the pixel size specified by info.colorType()) then false is returned
      *  and the bitmap is set to empty.
      */
-    bool allocPixels(const SkImageInfo& info, size_t rowBytes);
+    bool SK_WARN_UNUSED_RESULT tryAllocPixels(const SkImageInfo& info, size_t rowBytes);
 
-    /**
-     *  Allocate a pixelref to match the specified image info, using the default
-     *  allocator.
-     *  On success, the bitmap's pixels will be "locked", and return true.
-     *  On failure, the bitmap will be set to empty and return false.
-     */
-    bool allocPixels(const SkImageInfo& info) {
+    SK_ALLOCPIXELS_RETURN_TYPE allocPixels(const SkImageInfo& info, size_t rowBytes) {
+        if (!this->tryAllocPixels(info, rowBytes)) {
+            SK_ALLOCPIXELS_RETURN_FAIL;
+        }
+        SK_ALLOCPIXELS_RETURN_TRUE;
+    }
+
+    bool SK_WARN_UNUSED_RESULT tryAllocPixels(const SkImageInfo& info) {
+        return this->tryAllocPixels(info, info.minRowBytes());
+    }
+
+    SK_ALLOCPIXELS_RETURN_TYPE allocPixels(const SkImageInfo& info) {
         return this->allocPixels(info, info.minRowBytes());
     }
 
-    bool allocN32Pixels(int width, int height, bool isOpaque = false) {
+    bool SK_WARN_UNUSED_RESULT tryAllocN32Pixels(int width, int height, bool isOpaque = false) {
+        SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
+        if (isOpaque) {
+            info.fAlphaType = kOpaque_SkAlphaType;
+        }
+        return this->tryAllocPixels(info);
+    }
+    
+    SK_ALLOCPIXELS_RETURN_TYPE allocN32Pixels(int width, int height, bool isOpaque = false) {
         SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
         if (isOpaque) {
             info.fAlphaType = kOpaque_SkAlphaType;
         }
         return this->allocPixels(info);
     }
-
+    
     /**
      *  Install a pixelref that wraps the specified pixels and rowBytes, and
      *  optional ReleaseProc and context. When the pixels are no longer
      *  referenced, if releaseProc is not null, it will be called with the
      *  pixels and context as parameters.
      *  On failure, the bitmap will be set to empty and return false.
      */
     bool installPixels(const SkImageInfo&, void* pixels, size_t rowBytes, SkColorTable*,
                        void (*releaseProc)(void* addr, void* context), void* context);
 
@@ skipping 52 matching lines @@
         each time.
 
         If the bitmap retains a reference to the colortable (assuming it is
         not null) it will take care of incrementing the reference count.
 
         @param ctable   ColorTable (or null) to use with the pixels that will
                         be allocated. Only used if colortype == kIndex_8_SkColorType
         @return true if the allocation succeeds. If not the pixelref field of
                      the bitmap will be unchanged.
     */
-    bool allocPixels(SkColorTable* ctable = NULL) {
+    bool SK_WARN_UNUSED_RESULT tryAllocPixels(SkColorTable* ctable = NULL) {
+        return this->tryAllocPixels(NULL, ctable);
+    }
+
+    SK_ALLOCPIXELS_RETURN_TYPE allocPixels(SkColorTable* ctable = NULL) {
         return this->allocPixels(NULL, ctable);
     }
 
     /** Use the specified Allocator to create the pixelref that manages the
         pixel memory. It will be sized based on the current ImageInfo.
         If this is called multiple times, a new pixelref object will be created
         each time.
 
         If the bitmap retains a reference to the colortable (assuming it is
         not null) it will take care of incrementing the reference count.
 
         @param allocator The Allocator to use to create a pixelref that can
                          manage the pixel memory for the current ImageInfo.
                          If allocator is NULL, the standard HeapAllocator will be used.
         @param ctable   ColorTable (or null) to use with the pixels that will
                         be allocated. Only used if colortype == kIndex_8_SkColorType.
                         If it is non-null and the colortype is not indexed, it will
                         be ignored.
         @return true if the allocation succeeds. If not the pixelref field of
                      the bitmap will be unchanged.
     */
-    bool allocPixels(Allocator* allocator, SkColorTable* ctable);
+    bool SK_WARN_UNUSED_RESULT tryAllocPixels(Allocator* allocator, SkColorTable* ctable);
+
+    SK_ALLOCPIXELS_RETURN_TYPE allocPixels(Allocator* allocator, SkColorTable* ctable) {
+        if (!this->tryAllocPixels(allocator, ctable)) {
+            SK_ALLOCPIXELS_RETURN_FAIL;
+        }
+        SK_ALLOCPIXELS_RETURN_TRUE;
+    }
 
     /**
      *  Return the current pixelref object or NULL if there is none. This does
      *  not affect the refcount of the pixelref.
      */
     SkPixelRef* pixelRef() const { return fPixelRef; }
 
     /**
      *  A bitmap can reference a subset of a pixelref's pixels. That means the
      *  bitmap's width/height can be <= the dimensions of the pixelref. The
@@ skipping 480 matching lines @@
 
 inline SkPMColor SkBitmap::getIndex8Color(int x, int y) const {
     SkASSERT(fPixels);
     SkASSERT(kIndex_8_SkColorType == this->colorType());
     SkASSERT((unsigned)x < (unsigned)this->width() && (unsigned)y < (unsigned)this->height());
     SkASSERT(fColorTable);
     return (*fColorTable)[*((const uint8_t*)fPixels + y * fRowBytes + x)];
 }
 
 #endif