Add SkPngChunkReader.

src/codec/SkCodec_libpng.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 "SkCodec_libpng.h"
 #include "SkCodecPriv.h"
 #include "SkColorPriv.h"
@@ skipping 48 matching lines @@
     SkStream* stream = static_cast<SkStream*>(png_get_io_ptr(png_ptr));
     const size_t bytes = stream->read(data, length);
     if (bytes != length) {
         // FIXME: We want to report the fact that the stream was truncated.
         // One way to do that might be to pass a enum to longjmp so setjmp can
         // specify the failure.
         png_error(png_ptr, "Read Error!");
     }
 }
 
+#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
+static int sk_read_user_chunk(png_structp png_ptr, png_unknown_chunkp chunk) {
+    SkChunkReader* chunkReader = (SkChunkReader*)png_get_user_chunk_ptr(png_ptr);
+    // peek() returning true means continue decoding
+    return chunkReader->readChunk((const char*)chunk->name, chunk->data, chunk->size) ? 1 : -1;
+}
+#endif
+
 ///////////////////////////////////////////////////////////////////////////////
 // Helpers
 ///////////////////////////////////////////////////////////////////////////////
 
 class AutoCleanPng : public SkNoncopyable {
 public:
     AutoCleanPng(png_structp png_ptr)
         : fPng_ptr(png_ptr)
         , fInfo_ptr(NULL) {}
 
@@ skipping 115 matching lines @@
     char buf[PNG_BYTES_TO_CHECK];
     if (stream->read(buf, PNG_BYTES_TO_CHECK) != PNG_BYTES_TO_CHECK) {
         return false;
     }
     if (png_sig_cmp((png_bytep) buf, (png_size_t)0, PNG_BYTES_TO_CHECK)) {
         return false;
     }
     return true;
 }
 
-SkCodec* SkPngCodec::NewFromStream(SkStream* stream) {
+SkCodec* SkPngCodec::NewFromStream(SkStream* stream, SkChunkReader* chunkReader) {
     // The image is known to be a PNG. Decode enough to know the SkImageInfo.
     png_structp png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL,
                                                  sk_error_fn, sk_warning_fn);
     if (!png_ptr) {
         return NULL;
     }
 
     AutoCleanPng autoClean(png_ptr);
 
     png_infop info_ptr = png_create_info_struct(png_ptr);
     if (info_ptr == NULL) {
         return NULL;
     }
 
     autoClean.setInfoPtr(info_ptr);
 
     // FIXME: Could we use the return value of setjmp to specify the type of
     // error?
     if (setjmp(png_jmpbuf(png_ptr))) {
         return NULL;
     }
 
     png_set_read_fn(png_ptr, static_cast<void*>(stream), sk_read_fn);
 
-    // FIXME: This is where the old code hooks up the Peeker. Does it need to
-    // be set this early? (i.e. where are the user chunks? early in the stream,
-    // potentially?)
-    // If it does, we need to figure out a way to set it here.
+#ifdef PNG_READ_UNKNOWN_CHUNKS_SUPPORTED
+    // hookup our chunkReader so we can see any user-chunks the caller may be interested in
+    if (chunkReader) {
+        png_set_keep_unknown_chunks(png_ptr, PNG_HANDLE_CHUNK_ALWAYS, (png_byte*)"", 0);
+        png_set_read_user_chunk_fn(png_ptr, (png_voidp) chunkReader, sk_read_user_chunk);
+    }
+#endif
 
     // The call to png_read_info() gives us all of the information from the
     // PNG file before the first IDAT (image data chunk).
     png_read_info(png_ptr, info_ptr);
     png_uint_32 origWidth, origHeight;
     int bitDepth, colorType;
     png_get_IHDR(png_ptr, info_ptr, &origWidth, &origHeight, &bitDepth,
                  &colorType, int_p_NULL, int_p_NULL, int_p_NULL);
 
     // sanity check for size
@@ skipping 77 matching lines @@
         // FIXME: It seems like we could just use RGB as the SrcConfig here.
         if (colorType == PNG_COLOR_TYPE_RGB || convertGrayToRGB) {
             png_set_filler(png_ptr, 0xff, PNG_FILLER_AFTER);
         }
     }
 
     // FIXME: Also need to check for sRGB (skbug.com/3471).
 
     SkImageInfo info = SkImageInfo::Make(origWidth, origHeight, skColorType,
                                          skAlphaType);
-    SkCodec* codec = SkNEW_ARGS(SkPngCodec, (info, stream, png_ptr, info_ptr));
+    SkCodec* codec = SkNEW_ARGS(SkPngCodec, (info, stream, chunkReader, png_ptr, info_ptr));
     autoClean.detach();
     return codec;
 }
 
 #define INVALID_NUMBER_PASSES -1
-SkPngCodec::SkPngCodec(const SkImageInfo& info, SkStream* stream,
+SkPngCodec::SkPngCodec(const SkImageInfo& info, SkStream* stream, SkChunkReader* chunkReader,
                        png_structp png_ptr, png_infop info_ptr)
     : INHERITED(info, stream)
+    , fChunkReader(SkSafeRef(chunkReader))
     , fPng_ptr(png_ptr)
     , fInfo_ptr(info_ptr)
     , fSrcConfig(SkSwizzler::kUnknown)
     , fNumberPasses(INVALID_NUMBER_PASSES)
     , fReallyHasAlpha(false)
 {}
 
 SkPngCodec::~SkPngCodec() {
     png_destroy_read_struct(&fPng_ptr, &fInfo_ptr, png_infopp_NULL);
 }
@@ skipping 223 matching lines @@
 
     SkASSERT(fNumberPasses != INVALID_NUMBER_PASSES);
     if (fNumberPasses > 1) {
         // We cannot efficiently do scanline decoding.
         return NULL;
     }
 
     return SkNEW_ARGS(SkPngScanlineDecoder, (dstInfo, this));
 }