Use smart pointers for various Jbig2 decoding contexts

core/fpdfapi/fpdf_render/fpdf_render_loadimage.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/fpdfapi/fpdf_render/render_int.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 95 matching lines @@
       m_bLoadMask(FALSE),
       m_bDefaultDecode(TRUE),
       m_bImageMask(FALSE),
       m_bDoBpcCheck(TRUE),
       m_bColorKey(FALSE),
       m_bHasMask(FALSE),
       m_bStdCS(FALSE),
       m_pCompData(nullptr),
       m_pLineBuf(nullptr),
       m_pMaskedLine(nullptr),
-      m_pJbig2Context(nullptr),
       m_pMask(nullptr),
       m_pMaskStream(nullptr),
       m_Status(0) {}
 
 CPDF_DIBSource::~CPDF_DIBSource() {
   FX_Free(m_pMaskedLine);
   FX_Free(m_pLineBuf);
   m_pCachedBitmap.reset();
   FX_Free(m_pCompData);
   CPDF_ColorSpace* pCS = m_pColorSpace;
   if (pCS && m_pDocument) {
     m_pDocument->GetPageData()->ReleaseColorSpace(pCS->GetArray());
   }
-  if (m_pJbig2Context) {
-    CCodec_Jbig2Module* pJbig2Module = CPDF_ModuleMgr::Get()->GetJbig2Module();
-    pJbig2Module->DestroyJbig2Context(m_pJbig2Context);
-  }
 }
 
 CFX_DIBitmap* CPDF_DIBSource::GetBitmap() const {
   return m_pCachedBitmap ? m_pCachedBitmap.get() : Clone();
 }
 
 void CPDF_DIBSource::ReleaseBitmap(CFX_DIBitmap* pBitmap) const {
   if (pBitmap && pBitmap != m_pCachedBitmap.get()) {
     delete pBitmap;
   }
@@ skipping 194 matching lines @@
 
 int CPDF_DIBSource::ContinueLoadDIBSource(IFX_Pause* pPause) {
   FXCODEC_STATUS ret;
   if (m_Status == 1) {
     const CFX_ByteString& decoder = m_pStreamAcc->GetImageDecoder();
     if (decoder == "JPXDecode") {
       return 0;
     }
     CCodec_Jbig2Module* pJbig2Module = CPDF_ModuleMgr::Get()->GetJbig2Module();
     if (!m_pJbig2Context) {
-      m_pJbig2Context = pJbig2Module->CreateJbig2Context();
+      m_pJbig2Context.reset(new CCodec_Jbig2Context());
       if (m_pStreamAcc->GetImageParam()) {
         CPDF_Stream* pGlobals =
             m_pStreamAcc->GetImageParam()->GetStreamBy("JBIG2Globals");
         if (pGlobals) {
           m_pGlobalStream.reset(new CPDF_StreamAcc);
           m_pGlobalStream->LoadAllData(pGlobals, FALSE);
         }
       }
       ret = pJbig2Module->StartDecode(
-          m_pJbig2Context, m_pDocument->CodecContext(), m_Width, m_Height,
+          m_pJbig2Context.get(), m_pDocument->CodecContext(), m_Width, m_Height,
           m_pStreamAcc.get(), m_pGlobalStream.get(),
           m_pCachedBitmap->GetBuffer(), m_pCachedBitmap->GetPitch(), pPause);
       if (ret < 0) {
         m_pCachedBitmap.reset();
         m_pGlobalStream.reset();
-        pJbig2Module->DestroyJbig2Context(m_pJbig2Context);
-        m_pJbig2Context = nullptr;
+        m_pJbig2Context.reset();
         return 0;
       }
       if (ret == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
         return 2;
       }
       int ret1 = 1;
       if (m_bHasMask) {
         ret1 = ContinueLoadMaskDIB(pPause);
         m_Status = 2;
       }
       if (ret1 == 2) {
         return ret1;
       }
       if (m_pColorSpace && m_bStdCS) {
         m_pColorSpace->EnableStdConversion(FALSE);
       }
       return ret1;
     }
-    ret = pJbig2Module->ContinueDecode(m_pJbig2Context, pPause);
+    ret = pJbig2Module->ContinueDecode(m_pJbig2Context.get(), pPause);
     if (ret < 0) {
       m_pCachedBitmap.reset();
       m_pGlobalStream.reset();
-      pJbig2Module->DestroyJbig2Context(m_pJbig2Context);
-      m_pJbig2Context = nullptr;
+      m_pJbig2Context.reset();
       return 0;
     }
     if (ret == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
       return 2;
     }
     int ret1 = 1;
     if (m_bHasMask) {
       ret1 = ContinueLoadMaskDIB(pPause);
       m_Status = 2;
     }
@@ skipping 653 matching lines @@
     FXSYS_memset(pLineBuf, 0xFF, m_Pitch);
     return pLineBuf;
   }
   if (m_bpc * m_nComponents == 1) {
     if (m_bImageMask && m_bDefaultDecode) {
       for (uint32_t i = 0; i < src_pitch_value; i++) {
         m_pLineBuf[i] = ~pSrcLine[i];
       }
     } else if (m_bColorKey) {
       uint32_t reset_argb, set_argb;
-      reset_argb = m_pPalette ? m_pPalette[0] : 0xFF000000;
-      set_argb = m_pPalette ? m_pPalette[1] : 0xFFFFFFFF;
+      reset_argb = m_pPalette ? m_pPalette.get()[0] : 0xFF000000;
+      set_argb = m_pPalette ? m_pPalette.get()[1] : 0xFFFFFFFF;
       if (m_pCompData[0].m_ColorKeyMin == 0) {
         reset_argb = 0;
       }
       if (m_pCompData[0].m_ColorKeyMax == 1) {
         set_argb = 0;
       }
       set_argb = FXARGB_TODIB(set_argb);
       reset_argb = FXARGB_TODIB(reset_argb);
       uint32_t* dest_scan = reinterpret_cast<uint32_t*>(m_pMaskedLine);
       for (int col = 0; col < m_Width; col++) {
@@ skipping 24 matching lines @@
         }
         m_pLineBuf[col] = color_index;
       }
     }
     if (m_bColorKey) {
       uint8_t* pDestPixel = m_pMaskedLine;
       const uint8_t* pSrcPixel = m_pLineBuf;
       for (int col = 0; col < m_Width; col++) {
         uint8_t index = *pSrcPixel++;
         if (m_pPalette) {
-          *pDestPixel++ = FXARGB_B(m_pPalette[index]);
-          *pDestPixel++ = FXARGB_G(m_pPalette[index]);
-          *pDestPixel++ = FXARGB_R(m_pPalette[index]);
+          *pDestPixel++ = FXARGB_B(m_pPalette.get()[index]);
+          *pDestPixel++ = FXARGB_G(m_pPalette.get()[index]);
+          *pDestPixel++ = FXARGB_R(m_pPalette.get()[index]);
         } else {
           *pDestPixel++ = index;
           *pDestPixel++ = index;
           *pDestPixel++ = index;
         }
         *pDestPixel = (index < m_pCompData[0].m_ColorKeyMin ||
                        index > m_pCompData[0].m_ColorKeyMax)
                           ? 0xFF
                           : 0;
         pDestPixel++;
@@ skipping 111 matching lines @@
                                             int clip_left,
                                             int clip_width) const {
   uint32_t set_argb = (uint32_t)-1;
   uint32_t reset_argb = 0;
   if (m_bImageMask) {
     if (m_bDefaultDecode) {
       set_argb = 0;
       reset_argb = (uint32_t)-1;
     }
   } else if (m_bColorKey) {
-    reset_argb = m_pPalette ? m_pPalette[0] : 0xFF000000;
-    set_argb = m_pPalette ? m_pPalette[1] : 0xFFFFFFFF;
+    reset_argb = m_pPalette ? m_pPalette.get()[0] : 0xFF000000;
+    set_argb = m_pPalette ? m_pPalette.get()[1] : 0xFFFFFFFF;
     if (m_pCompData[0].m_ColorKeyMin == 0) {
       reset_argb = 0;
     }
     if (m_pCompData[0].m_ColorKeyMax == 1) {
       set_argb = 0;
     }
     set_argb = FXARGB_TODIB(set_argb);
     reset_argb = FXARGB_TODIB(reset_argb);
     uint32_t* dest_scan_dword = reinterpret_cast<uint32_t*>(dest_scan);
     for (int i = 0; i < clip_width; i++) {
       uint32_t src_x = (clip_left + i) * src_width / dest_width;
       if (bFlipX) {
         src_x = src_width - src_x - 1;
       }
       src_x %= src_width;
       if (pSrcLine[src_x / 8] & (1 << (7 - src_x % 8))) {
         dest_scan_dword[i] = set_argb;
       } else {
         dest_scan_dword[i] = reset_argb;
       }
     }
     return;
   } else {
     if (dest_Bpp == 1) {
     } else if (m_pPalette) {
-      reset_argb = m_pPalette[0];
-      set_argb = m_pPalette[1];
+      reset_argb = m_pPalette.get()[0];
+      set_argb = m_pPalette.get()[1];
     }
   }
   for (int i = 0; i < clip_width; i++) {
     uint32_t src_x = (clip_left + i) * src_width / dest_width;
     if (bFlipX) {
       src_x = src_width - src_x - 1;
     }
     src_x %= src_width;
     int dest_pos = i * dest_Bpp;
     if (pSrcLine[src_x / 8] & (1 << (7 - src_x % 8))) {
@@ skipping 45 matching lines @@
   if (m_bColorKey) {
     for (int i = 0; i < clip_width; i++) {
       uint32_t src_x = (clip_left + i) * src_width / dest_width;
       if (bFlipX) {
         src_x = src_width - src_x - 1;
       }
       src_x %= src_width;
       uint8_t* pDestPixel = dest_scan + i * 4;
       uint8_t index = pSrcLine[src_x];
       if (m_pPalette) {
-        *pDestPixel++ = FXARGB_B(m_pPalette[index]);
-        *pDestPixel++ = FXARGB_G(m_pPalette[index]);
-        *pDestPixel++ = FXARGB_R(m_pPalette[index]);
+        *pDestPixel++ = FXARGB_B(m_pPalette.get()[index]);
+        *pDestPixel++ = FXARGB_G(m_pPalette.get()[index]);
+        *pDestPixel++ = FXARGB_R(m_pPalette.get()[index]);
       } else {
         *pDestPixel++ = index;
         *pDestPixel++ = index;
         *pDestPixel++ = index;
       }
       *pDestPixel = (index < m_pCompData[0].m_ColorKeyMin ||
                      index > m_pCompData[0].m_ColorKeyMax)
                         ? 0xFF
                         : 0;
     }
     return;
   }
   for (int i = 0; i < clip_width; i++) {
     uint32_t src_x = (clip_left + i) * src_width / dest_width;
     if (bFlipX) {
       src_x = src_width - src_x - 1;
     }
     src_x %= src_width;
     uint8_t index = pSrcLine[src_x];
     if (dest_Bpp == 1) {
       dest_scan[i] = index;
     } else {
       int dest_pos = i * dest_Bpp;
-      FX_ARGB argb = m_pPalette[index];
+      FX_ARGB argb = m_pPalette.get()[index];
       dest_scan[dest_pos] = FXARGB_B(argb);
       dest_scan[dest_pos + 1] = FXARGB_G(argb);
       dest_scan[dest_pos + 2] = FXARGB_R(argb);
     }
   }
 }
 
 void CPDF_DIBSource::DownSampleScanline32Bit(int orig_Bpp,
                                              int dest_Bpp,
                                              uint32_t src_width,
@@ skipping 196 matching lines @@
                                    IFX_Pause* pPause) {
   return LoadHandle->Continue(pPause);
 }
 
 CPDF_ImageLoader::~CPDF_ImageLoader() {
   if (!m_bCached) {
     delete m_pBitmap;
     delete m_pMask;
   }
 }