Switch SkAutoMalloc to SkAutoTMalloc to avoid cast

src/images/SkImageDecoder_libjpeg.cpp

 /*
  * Copyright 2007 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.
  */
 
 
 #include "SkImageDecoder.h"
 #include "SkImageEncoder.h"
@@ skipping 478 matching lines @@
     int srcBytesPerPixel;
 
     if (!get_src_config(cinfo, &sc, &srcBytesPerPixel)) {
         return return_failure(cinfo, *bm, "jpeg colorspace");
     }
 
     if (!sampler.begin(bm, sc, *this)) {
         return return_failure(cinfo, *bm, "sampler.begin");
     }
 
-    SkAutoMalloc srcStorage(cinfo.output_width * srcBytesPerPixel);
-    uint8_t* srcRow = (uint8_t*)srcStorage.get();
+    SkAutoTMalloc<uint8_t> srcStorage(cinfo.output_width * srcBytesPerPixel);
+    uint8_t* srcRow = srcStorage.get();
 
     //  Possibly skip initial rows [sampler.srcY0]
     if (!skip_src_rows(&cinfo, srcRow, sampler.srcY0())) {
         return return_failure(cinfo, *bm, "skip rows");
     }
 
     // now loop through scanlines until y == bm->height() - 1
     for (int y = 0;; y++) {
         JSAMPLE* rowptr = (JSAMPLE*)srcRow;
         int row_count = jpeg_read_scanlines(&cinfo, &rowptr, 1);
@@ skipping 413 matching lines @@
         SkAutoLockPixels alp(bm);
         if (nullptr == bm.getPixels()) {
             return false;
         }
 
         jpeg_compress_struct    cinfo;
         skjpeg_error_mgr        sk_err;
         skjpeg_destination_mgr  sk_wstream(stream);
 
         // allocate these before set call setjmp
-        SkAutoMalloc    oneRow;
+        SkAutoTMalloc<uint8_t>  oneRow;
 
         cinfo.err = jpeg_std_error(&sk_err);
         sk_err.error_exit = skjpeg_error_exit;
         if (setjmp(sk_err.fJmpBuf)) {
             return false;
         }
 
         // Keep after setjmp or mark volatile.
         const WriteScanline writer = ChooseWriter(bm);
         if (nullptr == writer) {
@@ skipping 14 matching lines @@
 
         jpeg_set_defaults(&cinfo);
         jpeg_set_quality(&cinfo, quality, TRUE /* limit to baseline-JPEG values */);
 #ifdef DCT_IFAST_SUPPORTED
         cinfo.dct_method = JDCT_IFAST;
 #endif
 
         jpeg_start_compress(&cinfo, TRUE);
 
         const int       width = bm.width();
-        uint8_t*        oneRowP = (uint8_t*)oneRow.reset(width * 3);
+        oneRow.reset(width * 3);

[scroggo, 2015/12/10 15:53:34]

I could change SkAutoTMalloc::reset to return fPtr, like SkAutoMalloc,
SkAutoSMalloc, and SkAutoSTMalloc, so I do not need to split this into two
lines.

[mtklein, 2015/12/10 16:00:02]

Sure.  Seems fine either way.

+        uint8_t*        oneRowP = oneRow.get();
 
         const SkPMColor* colors = bm.getColorTable() ? bm.getColorTable()->readColors() : nullptr;
         const void*      srcRow = bm.getPixels();
 
         while (cinfo.next_scanline < cinfo.image_height) {
             JSAMPROW row_pointer[1];    /* pointer to JSAMPLE row[s] */
 
             writer(oneRowP, srcRow, width, colors);
             row_pointer[0] = oneRowP;
             (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
@@ skipping 43 matching lines @@
     return SkImageDecoder::kUnknown_Format;
 }
 
 static SkImageEncoder* sk_libjpeg_efactory(SkImageEncoder::Type t) {
     return (SkImageEncoder::kJPEG_Type == t) ? new SkJPEGImageEncoder : nullptr;
 }
 
 static SkImageDecoder_DecodeReg gDReg(sk_libjpeg_dfactory);
 static SkImageDecoder_FormatReg gFormatReg(get_format_jpeg);
 static SkImageEncoder_EncodeReg gEReg(sk_libjpeg_efactory);