Test SkAndroidCodec for more types

tests/CodexTest.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 "Resources.h"
 #include "SkAndroidCodec.h"
 #include "SkBitmap.h"
@@ skipping 119 matching lines @@
                 otherAt = kUnpremul_SkAlphaType;
             } else {
                 otherAt = kPremul_SkAlphaType;
             }
             // The other non-opaque alpha type should always succeed, but not match.
             test_info(r, codec, info.makeAlphaType(otherAt), expectedResult, nullptr);
         }
     }
 }
 
-// FIXME: SkScaledCodec is currently only supported for types used by BRD
-// https://bug.skia.org/4428
-static bool supports_scaled_codec(const char path[]) {
+static bool supports_partial_scanlines(const char path[]) {
     static const char* const exts[] = {
         "jpg", "jpeg", "png", "webp"
         "JPG", "JPEG", "PNG", "WEBP"
     };
 
     for (uint32_t i = 0; i < SK_ARRAY_COUNT(exts); i++) {
         if (SkStrEndsWith(path, exts[i])) {
             return true;
         }
     }
@@ skipping 70 matching lines @@
             REPORTER_ASSERT(r, lines == 1);
         }
         REPORTER_ASSERT(r, codec->getPixels(bm.info(), bm.getPixels(), bm.rowBytes())
                 == expectedResult);
         REPORTER_ASSERT(r, codec->getScanlines(bm.getAddr(0, 0), 1, 0)
                 == 0);
         REPORTER_ASSERT(r, codec->skipScanlines(1)
                 == 0);
 
         // Test partial scanline decodes
-        if (supports_scaled_codec(path) && info.width() >= 3) {
+        if (supports_partial_scanlines(path) && info.width() >= 3) {
             SkCodec::Options options;
             int width = info.width();
             int height = info.height();
             SkIRect subset = SkIRect::MakeXYWH(2 * (width / 3), 0, width / 3, height);
             options.fSubset = &subset;
 
             const SkCodec::Result partialStartResult = codec->startScanlineDecode(info, &options,
                     nullptr, nullptr);
             REPORTER_ASSERT(r, partialStartResult == SkCodec::kSuccess);
 
@@ skipping 36 matching lines @@
             REPORTER_ASSERT(r, result == expectedResult);
             // Webp is the only codec that supports subsets, and it will have modified the subset
             // to have even left/top.
             REPORTER_ASSERT(r, SkIsAlign2(subset.fLeft) && SkIsAlign2(subset.fTop));
         } else {
             // No subsets will work.
             REPORTER_ASSERT(r, result == SkCodec::kUnimplemented);
         }
     }
 
-    // SkScaledCodec tests
-    if ((supportsScanlineDecoding || supportsSubsetDecoding) && supports_scaled_codec(path)) {
+    // SkAndroidCodec tests
+    if (supportsScanlineDecoding || supportsSubsetDecoding) {
 
         SkAutoTDelete<SkStream> stream(resource(path));
         if (!stream) {
             SkDebugf("Missing resource '%s'\n", path);
             return;
         }
 
         SkAutoTDelete<SkAndroidCodec> androidCodec(nullptr);
         if (isIncomplete) {
             size_t size = stream->getLength();
             SkAutoTUnref<SkData> data((SkData::NewFromStream(stream, 2 * size / 3)));
             androidCodec.reset(SkAndroidCodec::NewFromData(data));
         } else {
             androidCodec.reset(SkAndroidCodec::NewFromStream(stream.detach()));
         }
         if (!androidCodec) {
             ERRORF(r, "Unable to decode '%s'", path);
             return;
         }
 
         SkBitmap bm;
-        SkMD5::Digest scaledCodecDigest;
-        test_codec(r, androidCodec.get(), bm, info, size, expectedResult, &scaledCodecDigest,
+        SkMD5::Digest androidCodecDigest;
+        test_codec(r, androidCodec.get(), bm, info, size, expectedResult, &androidCodecDigest,
                    &codecDigest);
     }
 
     // Test SkCodecImageGenerator
     if (!isIncomplete) {
         SkAutoTDelete<SkStream> stream(resource(path));
         SkAutoTUnref<SkData> fullData(SkData::NewFromStream(stream, stream->getLength()));
         SkAutoTDelete<SkImageGenerator> gen(SkCodecImageGenerator::NewFromEncodedCodec(fullData));
         SkBitmap bm;
         bm.allocPixels(info);
@@ skipping 186 matching lines @@
     test_invalid_stream(r, nonSupportedStream, sizeof(nonSupportedStream));
     test_invalid_stream(r, emptyPng, sizeof(emptyPng));
     test_invalid_stream(r, emptyJpeg, sizeof(emptyJpeg));
     test_invalid_stream(r, emptyWebp, sizeof(emptyWebp));
     test_invalid_stream(r, emptyBmp, sizeof(emptyBmp));
     test_invalid_stream(r, emptyIco, sizeof(emptyIco));
     test_invalid_stream(r, emptyGif, sizeof(emptyGif));
 }
 
 DEF_TEST(Codec_null, r) {
-    // Attempting to create an SkCodec or an SkScaledCodec with null should not
+    // Attempting to create an SkCodec or an SkAndroidCodec with null should not
     // crash.
     SkCodec* codec = SkCodec::NewFromStream(nullptr);
     REPORTER_ASSERT(r, !codec);
 
     SkAndroidCodec* androidCodec = SkAndroidCodec::NewFromStream(nullptr);
     REPORTER_ASSERT(r, !androidCodec);
 }
 
 static void test_dimensions(skiatest::Reporter* r, const char path[]) {
     // Create the codec from the resource file
@@ skipping 422 matching lines @@
     // Now test an image which is too big. Any image with a larger header (i.e.
     // has bigger width/height) is also too big.
     const unsigned char tooBigWbmp[] = { 0x00, 0x00,           // Header
                                          0x84, 0x80, 0x00,     // W: 65536
                                          0x84, 0x80, 0x00 };   // H: 65536
     stream.reset(new SkMemoryStream(tooBigWbmp, sizeof(tooBigWbmp), false));
     codec.reset(SkCodec::NewFromStream(stream.detach()));
 
     REPORTER_ASSERT(r, !codec);
 }