Use smart pointers for various Jbig2 decoding contexts

core/fxge/dib/fx_dib_convert.cpp

 // Copyright 2014 PDFium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com
 
 #include "core/fxcodec/include/fx_codec.h"
 #include "core/fxge/include/fx_dib.h"
 #include "core/fxge/include/fx_ge.h"
 
@@ skipping 30 matching lines @@
     }
     if (l < r) {
       alut[r] = alut[l];
       clut[r--] = clut[l];
     }
   }
   alut[l] = p_a;
   clut[l] = p_c;
   return l;
 }
+
 void _Qsort(uint32_t* alut, uint32_t* clut, int l, int r) {
   if (l < r) {
     int pI = _Partition(alut, clut, l, r);
     _Qsort(alut, clut, l, pI - 1);
     _Qsort(alut, clut, pI + 1, r);
   }
 }
+
 void _ColorDecode(uint32_t pal_v, uint8_t& r, uint8_t& g, uint8_t& b) {
   r = (uint8_t)((pal_v & 0xf00) >> 4);
   g = (uint8_t)(pal_v & 0x0f0);
   b = (uint8_t)((pal_v & 0x00f) << 4);
 }
+
 void _Obtain_Pal(uint32_t* aLut,
                  uint32_t* cLut,
                  uint32_t* dest_pal,
                  uint32_t lut) {
   uint32_t lut_1 = lut - 1;
   for (int row = 0; row < 256; row++) {
     int lut_offset = lut_1 - row;
     if (lut_offset < 0) {
       lut_offset += 256;
     }
     uint32_t color = cLut[lut_offset];
     uint8_t r;
     uint8_t g;
     uint8_t b;
     _ColorDecode(color, r, g, b);
     dest_pal[row] = ((uint32_t)r << 16) | ((uint32_t)g << 8) | b | 0xff000000;
     aLut[lut_offset] = row;
   }
 }
 
 CFX_Palette::CFX_Palette() {
   m_pPalette = nullptr;
   m_cLut = nullptr;
   m_aLut = nullptr;
   m_lut = 0;
 }
+
 CFX_Palette::~CFX_Palette() {
   FX_Free(m_pPalette);
   FX_Free(m_cLut);
   FX_Free(m_aLut);
   m_lut = 0;
 }
+
 FX_BOOL CFX_Palette::BuildPalette(const CFX_DIBSource* pBitmap) {
   if (!pBitmap) {
     return FALSE;
   }
   FX_Free(m_pPalette);
   m_pPalette = FX_Alloc(uint32_t, 256);
   int bpp = pBitmap->GetBPP() / 8;
   int width = pBitmap->GetWidth();
   int height = pBitmap->GetHeight();
   FX_Free(m_cLut);
@@ skipping 19 matching lines @@
     if (m_aLut[row] != 0) {
       m_aLut[m_lut] = m_aLut[row];
       m_cLut[m_lut] = row;
       m_lut++;
     }
   }
   _Qsort(m_aLut, m_cLut, 0, m_lut - 1);
   _Obtain_Pal(m_aLut, m_cLut, m_pPalette, m_lut);
   return TRUE;
 }
+
 FX_BOOL ConvertBuffer_1bppMask2Gray(uint8_t* dest_buf,
                                     int dest_pitch,
                                     int width,
                                     int height,
                                     const CFX_DIBSource* pSrcBitmap,
                                     int src_left,
                                     int src_top) {
   uint8_t set_gray, reset_gray;
   set_gray = 0xff;
   reset_gray = 0x00;
   for (int row = 0; row < height; row++) {
     uint8_t* dest_scan = dest_buf + row * dest_pitch;
     FXSYS_memset(dest_scan, reset_gray, width);
     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row);
     for (int col = src_left; col < src_left + width; col++) {
       if (src_scan[col / 8] & (1 << (7 - col % 8))) {
         *dest_scan = set_gray;
       }
       dest_scan++;
     }
   }
   return TRUE;
 }
+
 FX_BOOL ConvertBuffer_8bppMask2Gray(uint8_t* dest_buf,
                                     int dest_pitch,
                                     int width,
                                     int height,
                                     const CFX_DIBSource* pSrcBitmap,
                                     int src_left,
                                     int src_top) {
   for (int row = 0; row < height; row++) {
     uint8_t* dest_scan = dest_buf + row * dest_pitch;
     const uint8_t* src_scan = pSrcBitmap->GetScanline(src_top + row) + src_left;
     FXSYS_memcpy(dest_scan, src_scan, width);
   }
   return TRUE;
 }
+
 FX_BOOL ConvertBuffer_1bppPlt2Gray(uint8_t* dest_buf,
                                    int dest_pitch,
                                    int width,
                                    int height,
                                    const CFX_DIBSource* pSrcBitmap,
                                    int src_left,
                                    int src_top) {
   uint32_t* src_plt = pSrcBitmap->GetPalette();
   uint8_t gray[2];
   uint8_t reset_r;
@@ skipping 461 matching lines @@
 }
 
 FX_BOOL ConvertBuffer(FXDIB_Format dest_format,
                       uint8_t* dest_buf,
                       int dest_pitch,
                       int width,
                       int height,
                       const CFX_DIBSource* pSrcBitmap,
                       int src_left,
                       int src_top,
-                      uint32_t*& d_pal) {
+                      std::unique_ptr<uint32_t, FxFreeDeleter>* p_pal) {
   FXDIB_Format src_format = pSrcBitmap->GetFormat();
   switch (dest_format) {
     case FXDIB_Invalid:
     case FXDIB_1bppCmyk:
     case FXDIB_1bppMask:
     case FXDIB_1bppRgb:
       ASSERT(FALSE);
       return FALSE;
     case FXDIB_8bppMask: {
       if ((src_format & 0xff) == 1) {
@@ skipping 15 matching lines @@
       if ((src_format & 0xff) >= 24) {
         return ConvertBuffer_RgbOrCmyk2Gray(dest_buf, dest_pitch, width, height,
                                             pSrcBitmap, src_left, src_top);
       }
       return FALSE;
     }
     case FXDIB_8bppRgb:
     case FXDIB_8bppRgba: {
       if ((src_format & 0xff) == 8 && !pSrcBitmap->GetPalette()) {
         return ConvertBuffer(FXDIB_8bppMask, dest_buf, dest_pitch, width,
-                             height, pSrcBitmap, src_left, src_top, d_pal);
+                             height, pSrcBitmap, src_left, src_top, p_pal);
       }
-      d_pal = FX_Alloc(uint32_t, 256);
+      p_pal->reset(FX_Alloc(uint32_t, 256));
       if (((src_format & 0xff) == 1 || (src_format & 0xff) == 8) &&
           pSrcBitmap->GetPalette()) {
         return ConvertBuffer_Plt2PltRgb8(dest_buf, dest_pitch, width, height,
-                                         pSrcBitmap, src_left, src_top, d_pal);
+                                         pSrcBitmap, src_left, src_top,
+                                         p_pal->get());
       }
       if ((src_format & 0xff) >= 24) {
         return ConvertBuffer_Rgb2PltRgb8(dest_buf, dest_pitch, width, height,
-                                         pSrcBitmap, src_left, src_top, d_pal);
+                                         pSrcBitmap, src_left, src_top,
+                                         p_pal->get());
       }
       return FALSE;
     }
     case FXDIB_Rgb:
     case FXDIB_Rgba: {
       if ((src_format & 0xff) == 1) {
         if (pSrcBitmap->GetPalette()) {
           return ConvertBuffer_1bppPlt2Rgb(dest_format, dest_buf, dest_pitch,
                                            width, height, pSrcBitmap, src_left,
                                            src_top);
@@ skipping 84 matching lines @@
       ret = pClone->CopyAlphaMask(pSrcAlpha);
     }
   }
   if (pSrcAlpha && pSrcAlpha != m_pAlphaMask) {
     delete pSrcAlpha;
     pSrcAlpha = nullptr;
   }
   if (!ret)
     return nullptr;
 
-  uint32_t* pal_8bpp = nullptr;
+  std::unique_ptr<uint32_t, FxFreeDeleter> pal_8bpp;
   if (!ConvertBuffer(dest_format, pClone->GetBuffer(), pClone->GetPitch(),
-                     m_Width, m_Height, this, 0, 0, pal_8bpp)) {
-    FX_Free(pal_8bpp);
+                     m_Width, m_Height, this, 0, 0, &pal_8bpp)) {
     return nullptr;
   }
-  if (pal_8bpp) {
-    pClone->CopyPalette(pal_8bpp);
-    FX_Free(pal_8bpp);
-  }
+  if (pal_8bpp)
+    pClone->CopyPalette(pal_8bpp.get());
   return pClone.release();
 }
 
 FX_BOOL CFX_DIBitmap::ConvertFormat(FXDIB_Format dest_format) {
   FXDIB_Format src_format = GetFormat();
   if (dest_format == src_format)
     return TRUE;
 
   if (dest_format == FXDIB_8bppMask && src_format == FXDIB_8bppRgb &&
       !m_pPalette) {
@@ skipping 44 matching lines @@
           return FALSE;
         }
         pAlphaMask = m_pAlphaMask;
         m_pAlphaMask = nullptr;
       } else {
         pAlphaMask = m_pAlphaMask;
       }
     }
   }
   FX_BOOL ret = FALSE;
-  uint32_t* pal_8bpp = nullptr;
+  std::unique_ptr<uint32_t, FxFreeDeleter> pal_8bpp;
   ret = ConvertBuffer(dest_format, dest_buf, dest_pitch, m_Width, m_Height,
-                      this, 0, 0, pal_8bpp);
+                      this, 0, 0, &pal_8bpp);
   if (!ret) {
-    FX_Free(pal_8bpp);
-    if (pAlphaMask != m_pAlphaMask) {
+    if (pAlphaMask != m_pAlphaMask)
       delete pAlphaMask;
-    }
     FX_Free(dest_buf);
     return FALSE;
   }
-  if (m_pAlphaMask && pAlphaMask != m_pAlphaMask) {
+  if (m_pAlphaMask && pAlphaMask != m_pAlphaMask)
     delete m_pAlphaMask;
-  }
   m_pAlphaMask = pAlphaMask;
-  FX_Free(m_pPalette);
-  m_pPalette = pal_8bpp;
-  if (!m_bExtBuf) {
+  m_pPalette = std::move(pal_8bpp);
+  if (!m_bExtBuf)
     FX_Free(m_pBuffer);
-  }
   m_bExtBuf = FALSE;
   m_pBuffer = dest_buf;
   m_bpp = (uint8_t)dest_format;
   m_AlphaFlag = (uint8_t)(dest_format >> 8);
   m_Pitch = dest_pitch;
   return TRUE;
 }