Add SkPngChunkReader.

include/core/SkImageDecoder.h

 /*
  * Copyright 2006 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkImageDecoder_DEFINED
 #define SkImageDecoder_DEFINED
 
 #include "SkBitmap.h"
+#include "SkChunkReader.h"
 #include "SkImage.h"
 #include "SkRect.h"
 #include "SkRefCnt.h"
 #include "SkTRegistry.h"
 #include "SkTypes.h"
 
 class SkStream;
 class SkStreamRewindable;
 
 /** \class SkImageDecoder
@@ skipping 97 matching lines @@
     */
     void setRequireUnpremultipliedColors(bool request) {
         fRequireUnpremultipliedColors = request;
     }
 
     /** Returns true if the decoder will only return bitmaps with unpremultiplied
         colors.
     */
     bool getRequireUnpremultipliedColors() const { return fRequireUnpremultipliedColors; }
 
-    /** \class Peeker
-
-        Base class for optional callbacks to retrieve meta/chunk data out of
-        an image as it is being decoded.
-    */
-    class Peeker : public SkRefCnt {
-    public:
-        SK_DECLARE_INST_COUNT(Peeker)
-
-        /** Return true to continue decoding, or false to indicate an error, which
-            will cause the decoder to not return the image.
-        */
-        virtual bool peek(const char tag[], const void* data, size_t length) = 0;
-    private:
-        typedef SkRefCnt INHERITED;
-    };
-
-    Peeker* getPeeker() const { return fPeeker; }
-    Peeker* setPeeker(Peeker*);
+    SkChunkReader* getPeeker() const { return fPeeker; }
+    SkChunkReader* setPeeker(SkChunkReader*);
 
     /**
      *  By default, the codec will try to comply with the "pref" colortype
      *  that is passed to decode() or decodeSubset(). However, this can be called
      *  to override that, causing the codec to try to match the src depth instead
      *  (as shown below).
      *
      *      src_8Index  -> kIndex_8_SkColorType
      *      src_8Gray   -> kN32_SkColorType
      *      src_8bpc    -> kN32_SkColorType
@@ skipping 66 matching lines @@
     *   If the image cannot be decompressed, return kFailure. After the
     *   decoding, the function converts the decoded colortype in bitmap
     *   to pref if possible. Whether a conversion is feasible is
     *   tested by Bitmap::canCopyTo(pref).
 
         If an SkBitmap::Allocator is installed via setAllocator, it will be
         used to allocate the pixel memory. A clever allocator can be used
         to allocate the memory from a cache, volatile memory, or even from
         an existing bitmap's memory.
 
-        If a Peeker is installed via setPeeker, it may be used to peek into
+        If a SkChunkReader is installed via setPeeker, it may be used to peek into
         meta data during the decode.
     */
     Result decode(SkStream*, SkBitmap* bitmap, SkColorType pref, Mode);
     Result decode(SkStream* stream, SkBitmap* bitmap, Mode mode) {
         return this->decode(stream, bitmap, kUnknown_SkColorType, mode);
     }
 
     /**
      * Given a stream, build an index for doing tile-based decode.
      * The built index will be saved in the decoder, and the image size will
@@ skipping 149 matching lines @@
         k32Bit_SrcDepth,
     };
     /** The subclass, inside onDecode(), calls this to determine the colorType of
         the returned bitmap. SrcDepth and hasAlpha reflect the raw data of the
         src image. This routine returns the caller's preference given
         srcDepth and hasAlpha, or kUnknown_SkColorType if there is no preference.
      */
     SkColorType getPrefColorType(SrcDepth, bool hasAlpha) const;
 
 private:
-    Peeker*                 fPeeker;
+    SkChunkReader*          fPeeker;
     SkBitmap::Allocator*    fAllocator;
     int                     fSampleSize;
     SkColorType             fDefaultPref;   // use if fUsePrefTable is false
     bool                    fPreserveSrcDepth;
     bool                    fDitherImage;
     bool                    fSkipWritingZeroes;
     mutable bool            fShouldCancelDecode;
     bool                    fPreferQualityOverSpeed;
     bool                    fRequireUnpremultipliedColors;
 };
@@ skipping 46 matching lines @@
 DECLARE_DECODER_CREATOR(PKMImageDecoder);
 DECLARE_DECODER_CREATOR(KTXImageDecoder);
 DECLARE_DECODER_CREATOR(ASTCImageDecoder);
 
 // Typedefs to make registering decoder and formatter callbacks easier.
 // These have to be defined outside SkImageDecoder. :(
 typedef SkTRegistry<SkImageDecoder*(*)(SkStreamRewindable*)>        SkImageDecoder_DecodeReg;
 typedef SkTRegistry<SkImageDecoder::Format(*)(SkStreamRewindable*)> SkImageDecoder_FormatReg;
 
 #endif