Individually enable and disable SkCodecs

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 315 matching lines @@
     }
 
     // If we've just tested incomplete decodes, let's run the same test again on full decodes.
     if (isIncomplete) {
         check(r, path, size, supportsScanlineDecoding, supportsSubsetDecoding, false);
     }
 }
 
 DEF_TEST(Codec, r) {
     // WBMP
+#if defined(SK_CODEC_DECODES_WBMP)

[msarett, 2016/02/16 22:52:26]

Thinking about this a little further...

Maybe we don't need to clutter our test code with these #ifdefs, since we only
test on bots that have the required dependencies.  That would make this CL feel
a little cleaner.

In that case, we can move the defines into codec.gyp.

[mtklein, 2016/02/16 23:16:01]

Agree.

     check(r, "mandrill.wbmp", SkISize::Make(512, 512), true, false);
+#endif
 
     // WEBP
+#if defined(SK_CODEC_DECODES_WEBP)
     check(r, "baby_tux.webp", SkISize::Make(386, 395), false, true);
     check(r, "color_wheel.webp", SkISize::Make(128, 128), false, true);
     check(r, "yellow_rose.webp", SkISize::Make(400, 301), false, true);
+#endif
 
     // BMP
+#if defined(SK_CODEC_DECODES_BMP)
     check(r, "randPixels.bmp", SkISize::Make(8, 8), true, false);
     check(r, "rle.bmp", SkISize::Make(320, 240), true, false);
+#endif
 
     // ICO
+#if defined(SK_CODEC_DECODES_ICO)
     // FIXME: We are not ready to test incomplete ICOs
     // These two tests examine interestingly different behavior:
     // Decodes an embedded BMP image
     check(r, "color_wheel.ico", SkISize::Make(128, 128), true, false, false);
     // Decodes an embedded PNG image
     check(r, "google_chrome.ico", SkISize::Make(256, 256), true, false, false);
+#endif
 
     // GIF
+#if defined(SK_CODEC_DECODES_GIF)
     // FIXME: We are not ready to test incomplete GIFs
     check(r, "box.gif", SkISize::Make(200, 55), true, false, false);
     check(r, "color_wheel.gif", SkISize::Make(128, 128), true, false, false);
     // randPixels.gif is too small to test incomplete
     check(r, "randPixels.gif", SkISize::Make(8, 8), true, false, false);
+#endif
 
     // JPG
+#if defined(SK_CODEC_DECODES_JPEG)
     check(r, "CMYK.jpg", SkISize::Make(642, 516), true, false);
     check(r, "color_wheel.jpg", SkISize::Make(128, 128), true, false);
     // grayscale.jpg is too small to test incomplete
     check(r, "grayscale.jpg", SkISize::Make(128, 128), true, false, false);
     check(r, "mandrill_512_q075.jpg", SkISize::Make(512, 512), true, false);
     // randPixels.jpg is too small to test incomplete
     check(r, "randPixels.jpg", SkISize::Make(8, 8), true, false, false);
+#endif
 
     // PNG
+#if defined(SK_CODEC_DECODES_PNG)
     check(r, "arrow.png", SkISize::Make(187, 312), true, false, false);
     check(r, "baby_tux.png", SkISize::Make(240, 246), true, false, false);
     check(r, "color_wheel.png", SkISize::Make(128, 128), true, false, false);
     check(r, "half-transparent-white-pixel.png", SkISize::Make(1, 1), true, false, false);
     check(r, "mandrill_128.png", SkISize::Make(128, 128), true, false, false);
     check(r, "mandrill_16.png", SkISize::Make(16, 16), true, false, false);
     check(r, "mandrill_256.png", SkISize::Make(256, 256), true, false, false);
     check(r, "mandrill_32.png", SkISize::Make(32, 32), true, false, false);
     check(r, "mandrill_512.png", SkISize::Make(512, 512), true, false, false);
     check(r, "mandrill_64.png", SkISize::Make(64, 64), true, false, false);
     check(r, "plane.png", SkISize::Make(250, 126), true, false, false);
     // FIXME: We are not ready to test incomplete interlaced pngs
     check(r, "plane_interlaced.png", SkISize::Make(250, 126), true, false, false);
     check(r, "randPixels.png", SkISize::Make(8, 8), true, false, false);
     check(r, "yellow_rose.png", SkISize::Make(400, 301), true, false, false);
+#endif
 
     // RAW
 #if defined(SK_CODEC_DECODES_RAW)
     check(r, "sample_1mp.dng", SkISize::Make(600, 338), false, false, false);
     check(r, "dng_with_preview.dng", SkISize::Make(600, 338), true, false, false);
 #endif
 }
 
 // Test interlaced PNG in stripes, similar to DM's kStripe_Mode
 DEF_TEST(Codec_stripes, r) {
@@ skipping 159 matching lines @@
         options.fSampleSize = sampleSize;
         SkCodec::Result result =
                 codec->getAndroidPixels(scaledInfo, pixels.get(), rowBytes, &options);
         REPORTER_ASSERT(r, SkCodec::kSuccess == result);
     }
 }
 
 // Ensure that onGetScaledDimensions returns valid image dimensions to use for decodes
 DEF_TEST(Codec_Dimensions, r) {
     // JPG
+#if defined(SK_CODEC_DECODES_JPEG)
     test_dimensions(r, "CMYK.jpg");
     test_dimensions(r, "color_wheel.jpg");
     test_dimensions(r, "grayscale.jpg");
     test_dimensions(r, "mandrill_512_q075.jpg");
     test_dimensions(r, "randPixels.jpg");
+#endif
 
     // Decoding small images with very large scaling factors is a potential
     // source of bugs and crashes.  We disable these tests in Gold because
     // tiny images are not very useful to look at.
     // Here we make sure that we do not crash or access illegal memory when
     // performing scaled decodes on small images.
+#if defined(SK_CODEC_DECODES_PNG)
     test_dimensions(r, "1x1.png");
     test_dimensions(r, "2x2.png");
     test_dimensions(r, "3x3.png");
     test_dimensions(r, "3x1.png");
     test_dimensions(r, "1x1.png");
     test_dimensions(r, "16x1.png");
     test_dimensions(r, "1x16.png");
     test_dimensions(r, "mandrill_16.png");
+#endif
 
     // RAW
 #if defined(SK_CODEC_DECODES_RAW)
     test_dimensions(r, "sample_1mp.dng");
     test_dimensions(r, "dng_with_preview.dng");
 #endif
 }
 
 static void test_invalid(skiatest::Reporter* r, const char path[]) {
     SkAutoTDelete<SkStream> stream(resource(path));
@@ skipping 44 matching lines @@
     // colorPtr and a valid colorCountPtr.
     result = decoder->startScanlineDecode(
         decoder->getInfo().makeColorType(kIndex_8_SkColorType), nullptr, nullptr, nullptr);
     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) {
+#if defined(SK_CODEC_DECODES_PNG)
     test_invalid_parameters(r, "index8.png");
+#endif
+#if defined(SK_CODEC_DECODES_WBMP)
     test_invalid_parameters(r, "mandrill.wbmp");
+#endif
 }
 
 static void codex_test_write_fn(png_structp png_ptr, png_bytep data, png_size_t len) {
     SkWStream* sk_stream = (SkWStream*)png_get_io_ptr(png_ptr);
     if (!sk_stream->write(data, len)) {
         png_error(png_ptr, "sk_write_fn Error!");
     }
 }
 
-#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
+#if defined(SK_CODEC_DECODES_PNG) && defined(PNG_READ_UNKNOWN_CHUNKS_SUPPORTED)
 DEF_TEST(Codec_pngChunkReader, r) {
     // Create a dummy bitmap. Use unpremul RGBA for libpng.
     SkBitmap bm;
     const int w = 1;
     const int h = 1;
     const SkImageInfo bmInfo = SkImageInfo::Make(w, h, kRGBA_8888_SkColorType,
                                                  kUnpremul_SkAlphaType);
     bm.setInfo(bmInfo);
     bm.allocPixels();
     bm.eraseColor(SK_ColorBLUE);
@@ skipping 126 matching lines @@
     compare_to_good_digest(r, goodDigest, decodedBm);
     REPORTER_ASSERT(r, chunkReader.allHaveBeenSeen());
 
     // Decoding again will read the chunks again.
     chunkReader.reset();
     REPORTER_ASSERT(r, !chunkReader.allHaveBeenSeen());
     result = codec->getPixels(codec->getInfo(), decodedBm.getPixels(), decodedBm.rowBytes());
     REPORTER_ASSERT(r, SkCodec::kSuccess == result);
     REPORTER_ASSERT(r, chunkReader.allHaveBeenSeen());
 }
-#endif // PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
+#endif // SK_CODEC_DECODES_PNG && PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
 
 // Stream that can only peek up to a limit
 class LimitedPeekingMemStream : public SkStream {
 public:
     LimitedPeekingMemStream(SkData* data, size_t limit)
         : fStream(data)
         , fLimit(limit) {}
 
     size_t peek(void* buf, size_t bytes) const override {
         return fStream.peek(buf, SkTMin(bytes, fLimit));
@@ skipping 53 matching lines @@
         return;
     }
 
     SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(new NotAssetMemStream(data)));
     REPORTER_ASSERT(r, codec);
 
     test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr);
 }
 #endif
 
+#if defined(SK_CODEC_DECODES_WEBP)
 // Test that even if webp_parse_header fails to peek enough, it will fall back to read()
 // + rewind() and succeed.
 DEF_TEST(Codec_webp_peek, r) {
     const char* path = "baby_tux.webp";
     SkString fullPath(GetResourcePath(path));
     SkAutoTUnref<SkData> data(SkData::NewFromFileName(fullPath.c_str()));
     if (!data) {
         SkDebugf("Missing resource '%s'\n", path);
         return;
     }
 
     // The limit is less than webp needs to peek or read.
     SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(new LimitedPeekingMemStream(data, 25)));
     REPORTER_ASSERT(r, codec);
 
     test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr);
 
     // Similarly, a stream which does not peek should still succeed.
     codec.reset(SkCodec::NewFromStream(new LimitedPeekingMemStream(data, 0)));
     REPORTER_ASSERT(r, codec);
 
     test_info(r, codec.get(), codec->getInfo(), SkCodec::kSuccess, nullptr);
 }
+#endif
 
+#if defined(SK_CODEC_DECODES_WBMP)
 // SkCodec's wbmp decoder was initially more restrictive than SkImageDecoder.
 // It required the second byte to be zero. But SkImageDecoder allowed a couple
 // of bits to be 1 (so long as they do not overlap with 0x9F). Test that
 // SkCodec now supports an image with these bits set.
 DEF_TEST(Codec_wbmp, r) {
     const char* path = "mandrill.wbmp";
     SkAutoTDelete<SkStream> stream(resource(path));
     if (!stream) {
         SkDebugf("Missing resource '%s'\n", path);
         return;
@@ skipping 38 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);
 }
+#endif