Use a wrapper for SkDebugf in SkCodec.

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 28 matching lines @@
 
 #ifndef png_flush_ptr_NULL
     #define png_flush_ptr_NULL NULL
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 // Callback functions
 ///////////////////////////////////////////////////////////////////////////////
 
 static void sk_error_fn(png_structp png_ptr, png_const_charp msg) {
-    SkDebugf("------ png error %s\n", msg);
+    SkCodecPrintf("------ png error %s\n", msg);
     longjmp(png_jmpbuf(png_ptr), 1);
 }
 
 static void sk_read_fn(png_structp png_ptr, png_bytep data,
                        png_size_t length) {
     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
@@ skipping 302 matching lines @@
     return kPremul_SkAlphaType == dst.alphaType() &&
             kUnpremul_SkAlphaType == src.alphaType();
 }
 
 SkCodec::Result SkPngCodec::initializeSwizzler(const SkImageInfo& requestedInfo,
                                                void* dst, size_t rowBytes,
                                                const Options& options) {
     // FIXME: Could we use the return value of setjmp to specify the type of
     // error?
     if (setjmp(png_jmpbuf(fPng_ptr))) {
-        SkDebugf("setjmp long jump!\n");
+        SkCodecPrintf("setjmp long jump!\n");
         return kInvalidInput;
     }
 
     // FIXME: We already retrieved this information. Store it in SkPngCodec?
     png_uint_32 origWidth, origHeight;
     int bitDepth, pngColorType, interlaceType;
     png_get_IHDR(fPng_ptr, fInfo_ptr, &origWidth, &origHeight, &bitDepth,
                  &pngColorType, &interlaceType, int_p_NULL, int_p_NULL);
 
     fNumberPasses = (interlaceType != PNG_INTERLACE_NONE) ?
@@ skipping 46 matching lines @@
 
     const Result result = this->initializeSwizzler(requestedInfo, dst, rowBytes,
                                                    options);
     if (result != kSuccess) {
         return result;
     }
 
     // FIXME: Could we use the return value of setjmp to specify the type of
     // error?
     if (setjmp(png_jmpbuf(fPng_ptr))) {
-        SkDebugf("setjmp long jump!\n");
+        SkCodecPrintf("setjmp long jump!\n");
         return kInvalidInput;
     }
 
     SkASSERT(fNumberPasses != INVALID_NUMBER_PASSES);
     SkAutoMalloc storage;
     if (fNumberPasses > 1) {
         const int width = requestedInfo.width();
         const int height = requestedInfo.height();
         const int bpp = SkSwizzler::BytesPerPixel(fSrcConfig);
         const size_t rowBytes = width * bpp;
@@ skipping 48 matching lines @@
         : INHERITED(dstInfo)
         , fCodec(codec)
         , fHasAlpha(false)
     {
         fStorage.reset(dstInfo.width() * SkSwizzler::BytesPerPixel(fCodec->fSrcConfig));
         fSrcRow = static_cast<uint8_t*>(fStorage.get());
     }
 
     SkImageGenerator::Result onGetScanlines(void* dst, int count, size_t rowBytes) override {
         if (setjmp(png_jmpbuf(fCodec->fPng_ptr))) {
-            SkDebugf("setjmp long jump!\n");
+            SkCodecPrintf("setjmp long jump!\n");
             return SkImageGenerator::kInvalidInput;
         }
 
         for (int i = 0; i < count; i++) {
             png_read_rows(fCodec->fPng_ptr, &fSrcRow, png_bytepp_NULL, 1);
             fCodec->fSwizzler->setDstRow(dst);
             fHasAlpha |= !SkSwizzler::IsOpaque(fCodec->fSwizzler->next(fSrcRow));
             dst = SkTAddOffset<void>(dst, rowBytes);
         }
         return SkImageGenerator::kSuccess;
     }
 
     SkImageGenerator::Result onSkipScanlines(int count) override {
         // FIXME: Could we use the return value of setjmp to specify the type of
         // error?
         if (setjmp(png_jmpbuf(fCodec->fPng_ptr))) {
-            SkDebugf("setjmp long jump!\n");
+            SkCodecPrintf("setjmp long jump!\n");
             return SkImageGenerator::kInvalidInput;
         }
 
         png_read_rows(fCodec->fPng_ptr, png_bytepp_NULL, png_bytepp_NULL, count);
         return SkImageGenerator::kSuccess;
     }
 
     void onFinish() override {
         fCodec->finish();
     }
 
     bool onReallyHasAlpha() const override { return fHasAlpha; }
 
 private:
     SkPngCodec*         fCodec;     // Unowned.
     bool                fHasAlpha;
     SkAutoMalloc        fStorage;
     uint8_t*            fSrcRow;
 
     typedef SkScanlineDecoder INHERITED;
 };
 
 SkScanlineDecoder* SkPngCodec::onGetScanlineDecoder(const SkImageInfo& dstInfo) {
     // Check to see if scaling was requested.
     if (dstInfo.dimensions() != this->getInfo().dimensions()) {
         return NULL;
     }
 
     if (!conversion_possible(dstInfo, this->getInfo())) {
-        SkDebugf("no conversion possible\n");
+        SkCodecPrintf("no conversion possible\n");
         return NULL;
     }
 
     // Note: We set dst to NULL since we do not know it yet. rowBytes is not needed,
     // since we'll be manually updating the dstRow, but the SkSwizzler requires it to
     // be at least dstInfo.minRowBytes.
     Options opts;
     // FIXME: Pass this in to getScanlineDecoder?
     opts.fZeroInitialized = kNo_ZeroInitialized;
     if (this->initializeSwizzler(dstInfo, NULL, dstInfo.minRowBytes(), opts) != kSuccess) {
-        SkDebugf("failed to initialize the swizzler.\n");
+        SkCodecPrintf("failed to initialize the swizzler.\n");
         return NULL;
     }
 
     SkASSERT(fNumberPasses != INVALID_NUMBER_PASSES);
     if (fNumberPasses > 1) {
         // We cannot efficiently do scanline decoding.
         return NULL;
     }
 
     return SkNEW_ARGS(SkPngScanlineDecoder, (dstInfo, this));
 }