Use SkError for a bitmap that could not be decoded.

tests/PictureTest.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 #include "Test.h"
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkData.h"
+#include "SkError.h"
 #include "SkPaint.h"
 #include "SkPicture.h"
 #include "SkRandom.h"
 #include "SkRRect.h"
 #include "SkShader.h"
 #include "SkStream.h"
 
 #include "SkPictureUtils.h"
 
 static void make_bm(SkBitmap* bm, int w, int h, SkColor color, bool immutable) {
@@ skipping 343 matching lines @@
 
 static SkData* serialized_picture_from_bitmap(const SkBitmap& bitmap) {
     SkPicture picture;
     SkCanvas* canvas = picture.beginRecording(bitmap.width(), bitmap.height());
     canvas->drawBitmap(bitmap, 0, 0);
     SkDynamicMemoryWStream wStream;
     picture.serialize(&wStream, &PNGEncodeBitmapToStream);
     return wStream.copyToData();
 }
 
+static void error_callback(SkError, void*) {
+    // Do nothing.
+}
+
 static void test_bitmap_with_encoded_data(skiatest::Reporter* reporter) {
     // Create a bitmap that will be encoded.
     SkBitmap original;
     make_bm(&original, 100, 100, SK_ColorBLUE, true);
     SkDynamicMemoryWStream wStream;
     if (!SkImageEncoder::EncodeStream(&wStream, original, SkImageEncoder::kPNG_Type, 100)) {
         return;
     }
     SkAutoDataUnref data(wStream.copyToData());
     SkMemoryStream memStream;
     memStream.setData(data);
 
     // Use the encoded bitmap as the data for an image ref.
     SkBitmap bm;
     SkAutoTUnref<SkDataImageRef> imageRef(SkNEW_ARGS(SkDataImageRef, (&memStream)));
     imageRef->getInfo(&bm);
     bm.setPixelRef(imageRef);
 
     // Write both bitmaps to pictures, and ensure that the resulting data streams are the same.
     // Flattening original will follow the old path of performing an encode, while flattening bm
     // will use the already encoded data.
     SkAutoDataUnref picture1(serialized_picture_from_bitmap(original));
     SkAutoDataUnref picture2(serialized_picture_from_bitmap(bm));
     REPORTER_ASSERT(reporter, picture1->equals(picture2));
+    // Now test that a parse error was generated when trying to create a new SkPicture without
+    // providing a function to decode the bitmap.
+    SkSetErrorCallback(error_callback, NULL);

[humper, 2013/04/25 17:07:08]

Is the idea here to silence the built-in default callback?  Maybe if all tests
are going to have to do that this should either get bumped up to the testing
infrastructure classes, or we should extend the error API to have a "shut up"
method?

+    SkMemoryStream pictureStream(picture1);
+    bool success;
+    SkClearLastError();
+    SkPicture pictureFromStream(&pictureStream, &success, NULL);
+    REPORTER_ASSERT(reporter, success);
+    REPORTER_ASSERT(reporter, SkGetLastError() == kParseError_SkError);
+    SkClearLastError();
 }
 
 static void test_clone_empty(skiatest::Reporter* reporter) {
     // This is a regression test for crbug.com/172062
     // Before the fix, we used to crash accessing a null pointer when we
     // had a picture with no paints. This test passes by not crashing.
     {
         SkPicture picture;
         picture.beginRecording(1, 1);
         picture.endRecording();
@@ skipping 19 matching lines @@
     test_bad_bitmap();
 #endif
     test_peephole();
     test_gatherpixelrefs(reporter);
     test_bitmap_with_encoded_data(reporter);
     test_clone_empty(reporter);
 }
 
 #include "TestClassDef.h"
 DEFINE_TESTCLASS("Pictures", PictureTestClass, TestPicture)