make allocPixels throw on failure

tests/SerializationTest.cpp

 /*
  * Copyright 2013 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Resources.h"
 #include "SkBitmapSource.h"
 #include "SkCanvas.h"
@@ skipping 317 matching lines @@
     picture->serialize(&stream);
     SkAutoTUnref<SkStream> inputStream(stream.detachAsStream());
     SkAutoTUnref<SkPicture> loadedPicture(SkPicture::CreateFromStream(inputStream.get()));
 
     // Draw both original and clone picture and compare bitmaps -- they should be identical.
     SkBitmap origBitmap = draw_picture(*picture);
     SkBitmap destBitmap = draw_picture(*loadedPicture);
     compare_bitmaps(reporter, origBitmap, destBitmap);
 }
 
-static bool setup_bitmap_for_canvas(SkBitmap* bitmap) {
-    SkImageInfo info = SkImageInfo::Make(
-        kBitmapSize, kBitmapSize, kN32_SkColorType, kPremul_SkAlphaType);
-    return bitmap->allocPixels(info);
+static void setup_bitmap_for_canvas(SkBitmap* bitmap) {
+    bitmap->allocN32Pixels(kBitmapSize, kBitmapSize);
 }
 
-static bool make_checkerboard_bitmap(SkBitmap& bitmap) {
-    bool success = setup_bitmap_for_canvas(&bitmap);
+static void make_checkerboard_bitmap(SkBitmap& bitmap) {
+    setup_bitmap_for_canvas(&bitmap);
 
     SkCanvas canvas(bitmap);
     canvas.clear(0x00000000);
     SkPaint darkPaint;
     darkPaint.setColor(0xFF804020);
     SkPaint lightPaint;
     lightPaint.setColor(0xFF244484);
     const int i = kBitmapSize / 8;
     const SkScalar f = SkIntToScalar(i);
     for (int y = 0; y < kBitmapSize; y += i) {
         for (int x = 0; x < kBitmapSize; x += i) {
             canvas.save();
             canvas.translate(SkIntToScalar(x), SkIntToScalar(y));
             canvas.drawRect(SkRect::MakeXYWH(0, 0, f, f), darkPaint);
             canvas.drawRect(SkRect::MakeXYWH(f, 0, f, f), lightPaint);
             canvas.drawRect(SkRect::MakeXYWH(0, f, f, f), lightPaint);
             canvas.drawRect(SkRect::MakeXYWH(f, f, f, f), darkPaint);
             canvas.restore();
         }
     }
-
-    return success;
 }
 
-static bool draw_something(SkCanvas* canvas) {
+static void draw_something(SkCanvas* canvas) {
     SkPaint paint;
     SkBitmap bitmap;
-    bool success = make_checkerboard_bitmap(bitmap);
+    make_checkerboard_bitmap(bitmap);
 
     canvas->save();
     canvas->scale(0.5f, 0.5f);
     canvas->drawBitmap(bitmap, 0, 0, NULL);
     canvas->restore();
 
     const char beforeStr[] = "before circle";
     const char afterStr[] = "after circle";
 
     paint.setAntiAlias(true);
 
     paint.setColor(SK_ColorRED);
     canvas->drawData(beforeStr, sizeof(beforeStr));
     canvas->drawCircle(SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/3), paint);
     canvas->drawData(afterStr, sizeof(afterStr));
     paint.setColor(SK_ColorBLACK);
     paint.setTextSize(SkIntToScalar(kBitmapSize/3));
     canvas->drawText("Picture", 7, SkIntToScalar(kBitmapSize/2), SkIntToScalar(kBitmapSize/4), paint);
-
-    return success;
 }
 
 DEF_TEST(Serialization, reporter) {
     // Test matrix serialization
     {
         SkMatrix matrix = SkMatrix::I();
         TestObjectSerialization(&matrix, reporter);
     }
 
     // Test path serialization
@@ skipping 70 matching lines @@
         invalidBitmap.setInfo(info);
 
         // The deserialization should succeed, and the rendering shouldn't crash,
         // even when the device fails to initialize, due to its size
         TestBitmapSerialization(validBitmap, invalidBitmap, true, reporter);
     }
 
     // Test simple SkPicture serialization
     {
         SkPictureRecorder recorder;
-        bool didDraw = draw_something(recorder.beginRecording(SkIntToScalar(kBitmapSize), 
-                                                              SkIntToScalar(kBitmapSize), 
-                                                              NULL, 0));
-        REPORTER_ASSERT(reporter, didDraw);
+        draw_something(recorder.beginRecording(SkIntToScalar(kBitmapSize),
+                                               SkIntToScalar(kBitmapSize),
+                                               NULL, 0));
         SkAutoTUnref<SkPicture> pict(recorder.endRecording());
 
         // Serialize picture
         SkWriteBuffer writer(SkWriteBuffer::kValidation_Flag);
         pict->flatten(writer);
         size_t size = writer.bytesWritten();
         SkAutoTMalloc<unsigned char> data(size);
         writer.writeToMemory(static_cast<void*>(data.get()));
 
         // Deserialize picture
         SkValidatingReadBuffer reader(static_cast<void*>(data.get()), size);
         SkAutoTUnref<SkPicture> readPict(
             SkPicture::CreateFromBuffer(reader));
         REPORTER_ASSERT(reporter, NULL != readPict.get());
     }
 
     TestPictureTypefaceSerialization(reporter);
 }