Make SkPngCodec decode progressively.

tests/ImageTest.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <functional>
 #include <initializer_list>
 #include <vector>
@@ skipping 153 matching lines @@
 }
 #endif
 
 static void test_encode(skiatest::Reporter* reporter, SkImage* image) {
     const SkIRect ir = SkIRect::MakeXYWH(5, 5, 10, 10);
     sk_sp<SkData> origEncoded(image->encode());
     REPORTER_ASSERT(reporter, origEncoded);
     REPORTER_ASSERT(reporter, origEncoded->size() > 0);
 
     sk_sp<SkImage> decoded(SkImage::MakeFromEncoded(origEncoded));
+    if (!decoded) {
+        ERRORF(reporter, "failed to decode image!");
+        return;
+    }
     REPORTER_ASSERT(reporter, decoded);
     assert_equal(reporter, image, nullptr, decoded.get());
 
     // Now see if we can instantiate an image from a subset of the surface/origEncoded
 
     decoded = SkImage::MakeFromEncoded(origEncoded, &ir);
     REPORTER_ASSERT(reporter, decoded);
     assert_equal(reporter, image, &ir, decoded.get());
 }
 
@@ skipping 408 matching lines @@
 static bool has_pixels(const SkPMColor pixels[], int count, SkPMColor expected) {
     for (int i = 0; i < count; ++i) {
         if (pixels[i] != expected) {
             return false;
         }
     }
     return true;
 }
 
 static void test_read_pixels(skiatest::Reporter* reporter, SkImage* image) {
+    if (!image) {
+        ERRORF(reporter, "Failed to create image!");
+        return;
+    }
     const SkPMColor expected = SkPreMultiplyColor(SK_ColorWHITE);
     const SkPMColor notExpected = ~expected;
 
     const int w = 2, h = 2;
     const size_t rowBytes = w * sizeof(SkPMColor);
     SkPMColor pixels[w*h];
 
     SkImageInfo info;
 
     info = SkImageInfo::MakeUnknown(w, h);
@@ skipping 65 matching lines @@
     SkAutoLockPixels alp(bitmap);
     REPORTER_ASSERT(reporter, bitmap.getPixels());
 
     const SkImageInfo info = SkImageInfo::MakeN32(1, 1, bitmap.alphaType());
     SkPMColor imageColor;
     REPORTER_ASSERT(reporter, image->readPixels(info, &imageColor, sizeof(SkPMColor), 0, 0));
     REPORTER_ASSERT(reporter, imageColor == *bitmap.getAddr32(0, 0));
 }
 
 static void test_legacy_bitmap(skiatest::Reporter* reporter, const SkImage* image, SkImage::LegacyBitmapMode mode) {
+    if (!image) {
+        ERRORF(reporter, "Failed to create image.");
+        return;
+    }
     SkBitmap bitmap;
     REPORTER_ASSERT(reporter, image->asLegacyBitmap(&bitmap, mode));
     check_legacy_bitmap(reporter, image, bitmap, mode);
 
     // Test subsetting to exercise the rowBytes logic.
     SkBitmap tmp;
     REPORTER_ASSERT(reporter, bitmap.extractSubset(&tmp, SkIRect::MakeWH(image->width() / 2,
                                                                          image->height() / 2)));
     sk_sp<SkImage> subsetImage(SkImage::MakeFromBitmap(tmp));
     REPORTER_ASSERT(reporter, subsetImage.get());
@@ skipping 31 matching lines @@
         SkImage::kRW_LegacyBitmapMode,
     };
     for (auto& mode : modes) {
         sk_sp<SkImage> image(create_gpu_image(ctxInfo.grContext()));
         test_legacy_bitmap(reporter, image.get(), mode);
     }
 }
 #endif
 
 static void test_peek(skiatest::Reporter* reporter, SkImage* image, bool expectPeekSuccess) {
+    if (!image) {
+        ERRORF(reporter, "Failed to create image!");
+        return;
+    }
     SkPixmap pm;
     bool success = image->peekPixels(&pm);
     REPORTER_ASSERT(reporter, expectPeekSuccess == success);
     if (success) {
         const SkImageInfo& info = pm.info();
         REPORTER_ASSERT(reporter, 20 == info.width());
         REPORTER_ASSERT(reporter, 20 == info.height());
         REPORTER_ASSERT(reporter, kN32_SkColorType == info.colorType());
         REPORTER_ASSERT(reporter, kPremul_SkAlphaType == info.alphaType() ||
                         kOpaque_SkAlphaType == info.alphaType());
@@ skipping 171 matching lines @@
           kMedium_SkFilterQuality, 16, true},
         // Create an image with multiple prescale levels, make sure we chose the minimum scale.
         { create_image_large, {{SkMatrix::I(), kMedium_SkFilterQuality, 5},
                                {SkMatrix::I(), kMedium_SkFilterQuality, 4}},
           kMedium_SkFilterQuality, 16, true},
     };
 
 
     for (auto testCase : testCases) {
         sk_sp<SkImage> image(testCase.fImageFactory());
+        if (!image) {
+            ERRORF(reporter, "Failed to create image!");
+            continue;
+        }
+
         size_t size = image->getDeferredTextureImageData(*proxy, testCase.fParams.data(),
                                                          static_cast<int>(testCase.fParams.size()),
                                                          nullptr, SkSourceGammaTreatment::kIgnore);
         static const char *const kFS[] = { "fail", "succeed" };
         if (SkToBool(size) != testCase.fExpectation) {
             ERRORF(reporter,  "This image was expected to %s but did not.",
                    kFS[testCase.fExpectation]);
         }
         if (size) {
             void* buffer = sk_malloc_throw(size);
@@ skipping 84 matching lines @@
     SkBitmap bm1;
     bm1.allocPixels(SkImageInfo::MakeN32(256, 256, kUnpremul_SkAlphaType));
     bm0.readPixels(bm1.info(), bm1.getPixels(), bm1.rowBytes(), 0, 0);
 
     SkBitmap bm2;
     bm2.allocPixels(SkImageInfo::MakeN32(256, 256, kPremul_SkAlphaType));
     bm1.readPixels(bm2.info(), bm2.getPixels(), bm2.rowBytes(), 0, 0);
 
     REPORTER_ASSERT(reporter, equal(bm0, bm2));
 }