Revert of 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 "DMGpuSupport.h"
@@ skipping 143 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 337 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 183 matching lines @@
             otherContextInfo.testContext()->makeCurrent();
             sk_sp<SkImage> otherContextImage = create_gpu_image(otherContextInfo.grContext());
             testContext->makeCurrent();
             return otherContextImage;
           }, false },
     };
 
 
     for (auto testCase : testCases) {
         sk_sp<SkImage> image(testCase.fImageFactory());
-        if (!image) {
-            ERRORF(reporter, "Failed to create image!");
-            continue;
-        }
 
         // This isn't currently used in the implementation, just set any old values.
         SkImage::DeferredTextureImageUsageParams params;
         params.fQuality = kLow_SkFilterQuality;
         params.fMatrix = SkMatrix::I();
 
         size_t size = image->getDeferredTextureImageData(*proxy, &params, 1, nullptr);
 
         static const char *const kFS[] = { "fail", "succeed" };
         if (SkToBool(size) != testCase.fExpectation) {
@@ skipping 22 matching lines @@
                         otherContextInfo.grContext(), buffer, budgeted));
                     REPORTER_ASSERT(reporter, !newImage2);
                     testContext->makeCurrent();
                 }
             }
             sk_free(buffer);
         }
     }
 }
 #endif