Focus SkScaledCodec on BitmapRegionDecoder

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 "SkBitmap.h"
 #include "SkCodec.h"
@@ skipping 108 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), SkCodec::kSuccess, nullptr);
         }
     }
 }
 
+// FIXME: SkScaledCodec is currently only supported for types used by BRD
+// skbug.com/4428
+static bool supports_scaled_codec(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;
+        }
+    }
+    return false;
+}
+
 static void check(skiatest::Reporter* r,
                   const char path[],
                   SkISize size,
                   bool supportsScanlineDecoding,
                   bool supportsSubsetDecoding,
                   bool supports565 = true) {
 
     SkAutoTDelete<SkStream> stream(resource(path));
     if (!stream) {
         SkDebugf("Missing resource '%s'\n", path);
@@ skipping 81 matching lines @@
             // 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){
+    if ((supportsScanlineDecoding || supportsSubsetDecoding) && supports_scaled_codec(path)) {
+
         SkAutoTDelete<SkStream> stream(resource(path));
         if (!stream) {
             SkDebugf("Missing resource '%s'\n", path);
             return;
         }
         SkAutoTDelete<SkCodec> codec(SkScaledCodec::NewFromStream(stream.detach()));
         if (!codec) {
             ERRORF(r, "Unable to decode '%s'", path);
             return;
         }
@@ skipping 137 matching lines @@
 
         result = codec->getScanlines(bm.getAddr(0, height - remainingLines),
                                      remainingLines, bm.rowBytes());
         REPORTER_ASSERT(r, result == SkCodec::kSuccess);
     }
 
     compare_to_good_digest(r, digest, bm);
 }
 
 static void test_invalid_stream(skiatest::Reporter* r, const void* stream, size_t len) {
+    // Neither of these calls should return a codec. Bots should catch us if we leaked anything.
     SkCodec* codec = SkCodec::NewFromStream(new SkMemoryStream(stream, len, false));
-    // We should not have gotten a codec. Bots should catch us if we leaked anything.
+    REPORTER_ASSERT(r, !codec);
+
+    codec = SkScaledCodec::NewFromStream(new SkMemoryStream(stream, len, false));
     REPORTER_ASSERT(r, !codec);
 }
 
 // Ensure that SkCodec::NewFromStream handles freeing the passed in SkStream,
 // even on failure. Test some bad streams.
 DEF_TEST(Codec_leaks, r) {
     // No codec should claim this as their format, so this tests SkCodec::NewFromStream.
     const char nonSupportedStream[] = "hello world";
     // The other strings should look like the beginning of a file type, so we'll call some
     // internal version of NewFromStream, which must also delete the stream on failure.
     const unsigned char emptyPng[] = { 0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a };
     const unsigned char emptyJpeg[] = { 0xFF, 0xD8, 0xFF };
     const char emptyWebp[] = "RIFF1234WEBPVP";
     const char emptyBmp[] = { 'B', 'M' };
     const char emptyIco[] = { '\x00', '\x00', '\x01', '\x00' };
     const char emptyGif[] = "GIFVER";
 
     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
+    // crash.
+    SkCodec* codec = SkCodec::NewFromStream(nullptr);
+    REPORTER_ASSERT(r, !codec);
+
+    codec = SkScaledCodec::NewFromStream(nullptr);
+    REPORTER_ASSERT(r, !codec);
+}
+
 static void test_dimensions(skiatest::Reporter* r, const char path[]) {
     // Create the codec from the resource file
     SkAutoTDelete<SkStream> stream(resource(path));
     if (!stream) {
         SkDebugf("Missing resource '%s'\n", path);
         return;
     }
     SkAutoTDelete<SkCodec> codec(SkScaledCodec::NewFromStream(stream.detach()));
     if (!codec) {
         ERRORF(r, "Unable to create codec '%s'", path);
@@ skipping 96 matching lines @@
     REPORTER_ASSERT(r, SkCodec::kInvalidParameters == result);
     result = decoder->startScanlineDecode(
         decoder->getInfo().makeColorType(kIndex_8_SkColorType));
     REPORTER_ASSERT(r, SkCodec::kInvalidParameters == result);
 }
 
 DEF_TEST(Codec_Params, r) {
     test_invalid_parameters(r, "index8.png");
     test_invalid_parameters(r, "mandrill.wbmp");
 }