Fix a leak in CJBig2_Context.

core/src/fxcodec/jbig2/JBig2_Context.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 <list>
 #include "JBig2_Context.h"
 
 // Implement a very small least recently used (LRU) cache. It is very
 // common for a JBIG2 dictionary to span multiple pages in a PDF file,
 // and we do not want to decode the same dictionary over and over
 // again. We key off of the memory location of the dictionary. The
 // list keeps track of the freshness of entries, with freshest ones
 // at the front. Even a tiny cache size like 2 makes a dramatic
 // difference for typical JBIG2 documents.
 const int kSymbolDictCacheMaxSize = 2;
 
 CJBig2_Context* CJBig2_Context::CreateContext(
     const uint8_t* pGlobalData,
     FX_DWORD dwGlobalLength,
     const uint8_t* pData,
     FX_DWORD dwLength,
-    int32_t nStreamType,
     std::list<CJBig2_CachePair>* pSymbolDictCache,
     IFX_Pause* pPause) {
   return new CJBig2_Context(pGlobalData, dwGlobalLength, pData, dwLength,
-                            nStreamType, pSymbolDictCache, pPause);
+                            pSymbolDictCache, pPause);
 }
+
 void CJBig2_Context::DestroyContext(CJBig2_Context* pContext) {
   delete pContext;
 }
+
 CJBig2_Context::CJBig2_Context(const uint8_t* pGlobalData,
                                FX_DWORD dwGlobalLength,
                                const uint8_t* pData,
                                FX_DWORD dwLength,
-                               int32_t nStreamType,
                                std::list<CJBig2_CachePair>* pSymbolDictCache,
-                               IFX_Pause* pPause) {
+                               IFX_Pause* pPause)
+    : m_bInPage(false), m_bBufSpecified(false) {
   if (pGlobalData && (dwGlobalLength > 0)) {
-    m_pGlobalContext =
-        new CJBig2_Context(NULL, 0, pGlobalData, dwGlobalLength,
-                           JBIG2_EMBED_STREAM, pSymbolDictCache, pPause);
+    m_pGlobalContext = new CJBig2_Context(
+        nullptr, 0, pGlobalData, dwGlobalLength, pSymbolDictCache, pPause);
   } else {
-    m_pGlobalContext = NULL;
+    m_pGlobalContext = nullptr;
   }
-  m_pStream = new CJBig2_BitStream(pData, dwLength);
-  m_nStreamType = nStreamType;
-  m_nState = JBIG2_OUT_OF_PAGE;
-  m_pPage = NULL;
-  m_bBufSpecified = FALSE;
+
+  m_pStream.reset(new CJBig2_BitStream(pData, dwLength));
   m_pPause = pPause;
   m_nSegmentDecoded = 0;
   m_PauseStep = 10;
   m_pArithDecoder = NULL;
-  m_pGRD = NULL;
   m_gbContext = NULL;
   m_dwOffset = 0;
   m_ProcessingStatus = FXCODEC_STATUS_FRAME_READY;
   m_pSymbolDictCache = pSymbolDictCache;
 }
+
 CJBig2_Context::~CJBig2_Context() {
   delete m_pArithDecoder;
   m_pArithDecoder = NULL;
-  delete m_pGRD;
-  m_pGRD = NULL;
   FX_Free(m_gbContext);
   m_gbContext = NULL;
   delete m_pGlobalContext;
   m_pGlobalContext = NULL;
-  if (m_bBufSpecified) {
-    delete m_pPage;
-  }
-  m_pPage = NULL;
-  delete m_pStream;
-  m_pStream = NULL;
-}
-
-int32_t CJBig2_Context::decodeFile(IFX_Pause* pPause) {
-  if (m_pStream->getByteLeft() < 8)
-    return JBIG2_ERROR_TOO_SHORT;
-
-  const uint8_t fileID[] = {0x97, 0x4A, 0x42, 0x32, 0x0D, 0x0A, 0x1A, 0x0A};
-  if (JBIG2_memcmp(m_pStream->getPointer(), fileID, 8) != 0)
-    return JBIG2_ERROR_FILE_FORMAT;
-
-  m_pStream->offset(8);
-
-  uint8_t cFlags;
-  if (m_pStream->read1Byte(&cFlags) != 0)
-    return JBIG2_ERROR_TOO_SHORT;
-
-  if (!(cFlags & 0x02)) {
-    FX_DWORD dwTemp;
-    if (m_pStream->readInteger(&dwTemp) != 0)
-      return JBIG2_ERROR_TOO_SHORT;
-
-    if (dwTemp > 0) {
-      m_PageInfoList.clear();
-      m_PageInfoList.resize(dwTemp);
-    }
-  }
-
-  if (cFlags & 0x01) {
-    m_nStreamType = JBIG2_SQUENTIAL_STREAM;
-    return decode_SquentialOrgnazation(pPause);
-  }
-
-  m_nStreamType = JBIG2_RANDOM_STREAM;
-  return decode_RandomOrgnazation_FirstPage(pPause);
 }
 
 int32_t CJBig2_Context::decode_SquentialOrgnazation(IFX_Pause* pPause) {
   int32_t nRet;
   if (m_pStream->getByteLeft() <= 0)
     return JBIG2_END_OF_FILE;
 
   while (m_pStream->getByteLeft() >= JBIG2_MIN_SEGMENT_SIZE) {
     if (!m_pSegment) {
       m_pSegment.reset(new CJBig2_Segment);
@@ skipping 12 matching lines @@
     }
     if ((nRet == JBIG2_END_OF_PAGE) || (nRet == JBIG2_END_OF_FILE)) {
       m_pSegment.reset();
       return JBIG2_SUCCESS;
     }
     if (nRet != JBIG2_SUCCESS) {
       m_pSegment.reset();
       return nRet;
     }
     if (m_pSegment->m_dwData_length != 0xffffffff) {
-      m_dwOffset = m_dwOffset + m_pSegment->m_dwData_length;
+      m_dwOffset += m_pSegment->m_dwData_length;
       m_pStream->setOffset(m_dwOffset);
     } else {
       m_pStream->offset(4);
     }
     m_SegmentList.push_back(m_pSegment.release());
     if (m_pStream->getByteLeft() > 0 && m_pPage && pPause &&
         pPause->NeedToPauseNow()) {
       m_ProcessingStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
       m_PauseStep = 2;
       return JBIG2_SUCCESS;
@@ skipping 48 matching lines @@
                                      int32_t stride,
                                      IFX_Pause* pPause) {
   int32_t nRet = 0;
   if (m_pGlobalContext) {
     nRet = m_pGlobalContext->decode_EmbedOrgnazation(pPause);
     if (nRet != JBIG2_SUCCESS) {
       m_ProcessingStatus = FXCODEC_STATUS_ERROR;
       return nRet;
     }
   }
-  m_bFirstPage = TRUE;
   m_PauseStep = 0;
-  delete m_pPage;
-  m_pPage = new CJBig2_Image(width, height, stride, pBuf);
-  m_bBufSpecified = TRUE;
-  if (m_pPage && pPause && pPause->NeedToPauseNow()) {
+  m_pPage.reset(new CJBig2_Image(width, height, stride, pBuf));
+  m_bBufSpecified = true;
+  if (pPause && pPause->NeedToPauseNow()) {
     m_PauseStep = 1;
     m_ProcessingStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
     return nRet;
   }
-  int ret = Continue(pPause);
-  return ret;
+  return Continue(pPause);
 }
 int32_t CJBig2_Context::Continue(IFX_Pause* pPause) {
   m_ProcessingStatus = FXCODEC_STATUS_DECODE_READY;
   int32_t nRet;
   if (m_PauseStep <= 1) {
-    switch (m_nStreamType) {
-      case JBIG2_FILE_STREAM:
-        nRet = decodeFile(pPause);
-        break;
-      case JBIG2_SQUENTIAL_STREAM:
-        nRet = decode_SquentialOrgnazation(pPause);
-        break;
-      case JBIG2_RANDOM_STREAM:
-        if (m_bFirstPage) {
-          nRet = decode_RandomOrgnazation_FirstPage(pPause);
-        } else {
-          nRet = decode_RandomOrgnazation(pPause);
-        }
-        break;
-      case JBIG2_EMBED_STREAM:
-        nRet = decode_EmbedOrgnazation(pPause);
-        break;
-      default:
-        m_ProcessingStatus = FXCODEC_STATUS_ERROR;
-        return JBIG2_ERROR_STREAM_TYPE;
-    }
+    nRet = decode_EmbedOrgnazation(pPause);
   } else if (m_PauseStep == 2) {
     nRet = decode_SquentialOrgnazation(pPause);
   } else if (m_PauseStep == 3) {
     nRet = decode_RandomOrgnazation_FirstPage(pPause);
   } else if (m_PauseStep == 4) {
     nRet = decode_RandomOrgnazation(pPause);
   } else if (m_PauseStep == 5) {
     m_ProcessingStatus = FXCODEC_STATUS_DECODE_FINISH;
     return JBIG2_SUCCESS;
   }
   if (m_ProcessingStatus == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
     return nRet;
   }
   m_PauseStep = 5;
   if (!m_bBufSpecified && nRet == JBIG2_SUCCESS) {
     m_ProcessingStatus = FXCODEC_STATUS_DECODE_FINISH;
     return JBIG2_SUCCESS;
   }
   if (nRet == JBIG2_SUCCESS) {
     m_ProcessingStatus = FXCODEC_STATUS_DECODE_FINISH;
   } else {
     m_ProcessingStatus = FXCODEC_STATUS_ERROR;
   }
   return nRet;
 }
-int32_t CJBig2_Context::getFirstPage(CJBig2_Image** image, IFX_Pause* pPause) {
-  int32_t nRet;
-  m_bFirstPage = TRUE;
-  m_PauseStep = 0;
-  if (m_pGlobalContext) {
-    nRet = m_pGlobalContext->decode_EmbedOrgnazation(pPause);
-    if (nRet != JBIG2_SUCCESS) {
-      return nRet;
-    }
-  }
-  m_bBufSpecified = FALSE;
-  return Continue(pPause);
-}
+
 CJBig2_Segment* CJBig2_Context::findSegmentByNumber(FX_DWORD dwNumber) {
   CJBig2_Segment* pSeg;
   if (m_pGlobalContext) {
     pSeg = m_pGlobalContext->findSegmentByNumber(dwNumber);
     if (pSeg) {
       return pSeg;
     }
   }
   for (size_t i = 0; i < m_SegmentList.size(); ++i) {
     pSeg = m_SegmentList.get(i);
@@ skipping 108 matching lines @@
 }
 
 int32_t CJBig2_Context::ProcessingParseSegmentData(CJBig2_Segment* pSegment,
                                                    IFX_Pause* pPause) {
   switch (pSegment->m_cFlags.s.type) {
     case 0:
       return parseSymbolDict(pSegment, pPause);
     case 4:
     case 6:
     case 7:
-      if (m_nState == JBIG2_OUT_OF_PAGE)
+      if (!m_bInPage)
         return JBIG2_ERROR_FATAL;
       return parseTextRegion(pSegment);
     case 16:
       return parsePatternDict(pSegment, pPause);
     case 20:
     case 22:
     case 23:
-      if (m_nState == JBIG2_OUT_OF_PAGE)
+      if (!m_bInPage)
         return JBIG2_ERROR_FATAL;
       return parseHalftoneRegion(pSegment, pPause);
     case 36:
     case 38:
     case 39:
-      if (m_nState == JBIG2_OUT_OF_PAGE)
+      if (!m_bInPage)
         return JBIG2_ERROR_FATAL;
       return parseGenericRegion(pSegment, pPause);
     case 40:
     case 42:
     case 43:
-      if (m_nState == JBIG2_OUT_OF_PAGE)
+      if (!m_bInPage)
         return JBIG2_ERROR_FATAL;
       return parseGenericRefinementRegion(pSegment);
     case 48: {
       FX_WORD wTemp;
       nonstd::unique_ptr<JBig2PageInfo> pPageInfo(new JBig2PageInfo);
       if ((m_pStream->readInteger(&pPageInfo->m_dwWidth) != 0) ||
           (m_pStream->readInteger(&pPageInfo->m_dwHeight) != 0) ||
           (m_pStream->readInteger(&pPageInfo->m_dwResolutionX) != 0) ||
           (m_pStream->readInteger(&pPageInfo->m_dwResolutionY) != 0) ||
           (m_pStream->read1Byte(&pPageInfo->m_cFlags) != 0) ||
           (m_pStream->readShortInteger(&wTemp) != 0)) {
         return JBIG2_ERROR_TOO_SHORT;
       }
       pPageInfo->m_bIsStriped = ((wTemp >> 15) & 1) ? TRUE : FALSE;
       pPageInfo->m_wMaxStripeSize = wTemp & 0x7fff;
       bool bMaxHeight = (pPageInfo->m_dwHeight == 0xffffffff);
       if (bMaxHeight && pPageInfo->m_bIsStriped != TRUE)
         pPageInfo->m_bIsStriped = TRUE;
 
       if (!m_bBufSpecified) {
-        delete m_pPage;
         FX_DWORD height =
             bMaxHeight ? pPageInfo->m_wMaxStripeSize : pPageInfo->m_dwHeight;
-        m_pPage = new CJBig2_Image(pPageInfo->m_dwWidth, height);
+        m_pPage.reset(new CJBig2_Image(pPageInfo->m_dwWidth, height));
       }
 
       if (!m_pPage->m_pData) {
         m_ProcessingStatus = FXCODEC_STATUS_ERROR;
         return JBIG2_ERROR_TOO_SHORT;
       }
 
       m_pPage->fill((pPageInfo->m_cFlags & 4) ? 1 : 0);
       m_PageInfoList.push_back(pPageInfo.release());
-      m_nState = JBIG2_IN_PAGE;
+      m_bInPage = true;
     } break;
     case 49:
-      m_nState = JBIG2_OUT_OF_PAGE;
+      m_bInPage = false;
       return JBIG2_END_OF_PAGE;
       break;
     case 50:
       m_pStream->offset(pSegment->m_dwData_length);
       break;
     case 51:
       return JBIG2_END_OF_FILE;
     case 52:
       m_pStream->offset(pSegment->m_dwData_length);
       break;
@@ skipping 205 matching lines @@
     if (it->first == key) {
       pSegment->m_Result.sd = it->second->DeepCopy();
       m_pSymbolDictCache->push_front(*it);
       m_pSymbolDictCache->erase(it);
       cache_hit = true;
       break;
     }
   }
   if (!cache_hit) {
     if (pSymbolDictDecoder->SDHUFF == 0) {
-      pArithDecoder = new CJBig2_ArithDecoder(m_pStream);
+      pArithDecoder = new CJBig2_ArithDecoder(m_pStream.get());
       pSegment->m_Result.sd =
           pSymbolDictDecoder->decode_Arith(pArithDecoder, gbContext, grContext);
       delete pArithDecoder;
       if (pSegment->m_Result.sd == NULL) {
         nRet = JBIG2_ERROR_FATAL;
         goto failed;
       }
       m_pStream->alignByte();
       m_pStream->offset(2);
     } else {
       pSegment->m_Result.sd = pSymbolDictDecoder->decode_Huffman(
-          m_pStream, gbContext, grContext, pPause);
+          m_pStream.get(), gbContext, grContext, pPause);
       if (pSegment->m_Result.sd == NULL) {
         nRet = JBIG2_ERROR_FATAL;
         goto failed;
       }
       m_pStream->alignByte();
     }
     CJBig2_SymbolDict* value = pSegment->m_Result.sd->DeepCopy();
     if (value && kSymbolDictCacheMaxSize > 0) {
       while (m_pSymbolDictCache->size() >= kSymbolDictCacheMaxSize) {
         delete m_pSymbolDictCache->back().second;
@@ skipping 124 matching lines @@
         JBIG2_memcpy(SBSYMS + dwTemp, pSeg->m_Result.sd->SDEXSYMS,
                      pSeg->m_Result.sd->SDNUMEXSYMS * sizeof(CJBig2_Image*));
         dwTemp += pSeg->m_Result.sd->SDNUMEXSYMS;
       }
     }
     pTRD->SBSYMS = SBSYMS;
   } else {
     pTRD->SBSYMS = NULL;
   }
   if (pTRD->SBHUFF == 1) {
-    SBSYMCODES = decodeSymbolIDHuffmanTable(m_pStream, pTRD->SBNUMSYMS);
+    SBSYMCODES = decodeSymbolIDHuffmanTable(m_pStream.get(), pTRD->SBNUMSYMS);
     if (SBSYMCODES == NULL) {
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
     }
     m_pStream->alignByte();
     pTRD->SBSYMCODES = SBSYMCODES;
   } else {
     dwTemp = 0;
     while ((FX_DWORD)(1 << dwTemp) < pTRD->SBNUMSYMS) {
       dwTemp++;
@@ skipping 168 matching lines @@
       }
       pTRD->SBHUFFRSIZE = pSeg->m_Result.ht;
     }
   }
   if (pTRD->SBREFINE == 1) {
     dwTemp = pTRD->SBRTEMPLATE ? 1 << 10 : 1 << 13;
     grContext = FX_Alloc(JBig2ArithCtx, dwTemp);
     JBIG2_memset(grContext, 0, sizeof(JBig2ArithCtx) * dwTemp);
   }
   if (pTRD->SBHUFF == 0) {
-    pArithDecoder = new CJBig2_ArithDecoder(m_pStream);
+    pArithDecoder = new CJBig2_ArithDecoder(m_pStream.get());
     pSegment->m_nResultType = JBIG2_IMAGE_POINTER;
     pSegment->m_Result.im = pTRD->decode_Arith(pArithDecoder, grContext);
     delete pArithDecoder;
     if (pSegment->m_Result.im == NULL) {
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
     }
     m_pStream->alignByte();
     m_pStream->offset(2);
   } else {
     pSegment->m_nResultType = JBIG2_IMAGE_POINTER;
-    pSegment->m_Result.im = pTRD->decode_Huffman(m_pStream, grContext);
+    pSegment->m_Result.im = pTRD->decode_Huffman(m_pStream.get(), grContext);
     if (pSegment->m_Result.im == NULL) {
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
     }
     m_pStream->alignByte();
   }
   if (pSegment->m_cFlags.s.type != 4) {
     if (!m_bBufSpecified) {
       JBig2PageInfo* pPageInfo = m_PageInfoList.back();
       if ((pPageInfo->m_bIsStriped == 1) &&
@@ skipping 61 matching lines @@
     goto failed;
   }
   pPDD->HDMMR = cFlags & 0x01;
   pPDD->HDTEMPLATE = (cFlags >> 1) & 0x03;
   pSegment->m_nResultType = JBIG2_PATTERN_DICT_POINTER;
   if (pPDD->HDMMR == 0) {
     dwTemp =
         pPDD->HDTEMPLATE == 0 ? 65536 : pPDD->HDTEMPLATE == 1 ? 8192 : 1024;
     gbContext = FX_Alloc(JBig2ArithCtx, dwTemp);
     JBIG2_memset(gbContext, 0, sizeof(JBig2ArithCtx) * dwTemp);
-    pArithDecoder = new CJBig2_ArithDecoder(m_pStream);
+    pArithDecoder = new CJBig2_ArithDecoder(m_pStream.get());
     pSegment->m_Result.pd =
         pPDD->decode_Arith(pArithDecoder, gbContext, pPause);
     delete pArithDecoder;
     if (pSegment->m_Result.pd == NULL) {
       FX_Free(gbContext);
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
     }
     FX_Free(gbContext);
     m_pStream->alignByte();
     m_pStream->offset(2);
   } else {
-    pSegment->m_Result.pd = pPDD->decode_MMR(m_pStream, pPause);
+    pSegment->m_Result.pd = pPDD->decode_MMR(m_pStream.get(), pPause);
     if (pSegment->m_Result.pd == NULL) {
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
     }
     m_pStream->alignByte();
   }
   delete pPDD;
   return JBIG2_SUCCESS;
 failed:
   delete pPDD;
@@ skipping 44 matching lines @@
   }
   pHRD->HNUMPATS = pPatternDict->NUMPATS;
   pHRD->HPATS = pPatternDict->HDPATS;
   pHRD->HPW = pPatternDict->HDPATS[0]->m_nWidth;
   pHRD->HPH = pPatternDict->HDPATS[0]->m_nHeight;
   pSegment->m_nResultType = JBIG2_IMAGE_POINTER;
   if (pHRD->HMMR == 0) {
     dwTemp = pHRD->HTEMPLATE == 0 ? 65536 : pHRD->HTEMPLATE == 1 ? 8192 : 1024;
     gbContext = FX_Alloc(JBig2ArithCtx, dwTemp);
     JBIG2_memset(gbContext, 0, sizeof(JBig2ArithCtx) * dwTemp);
-    pArithDecoder = new CJBig2_ArithDecoder(m_pStream);
+    pArithDecoder = new CJBig2_ArithDecoder(m_pStream.get());
     pSegment->m_Result.im =
         pHRD->decode_Arith(pArithDecoder, gbContext, pPause);
     delete pArithDecoder;
     if (pSegment->m_Result.im == NULL) {
       FX_Free(gbContext);
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
     }
     FX_Free(gbContext);
     m_pStream->alignByte();
     m_pStream->offset(2);
   } else {
-    pSegment->m_Result.im = pHRD->decode_MMR(m_pStream, pPause);
+    pSegment->m_Result.im = pHRD->decode_MMR(m_pStream.get(), pPause);
     if (pSegment->m_Result.im == NULL) {
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
     }
     m_pStream->alignByte();
   }
   if (pSegment->m_cFlags.s.type != 20) {
     if (!m_bBufSpecified) {
       JBig2PageInfo* pPageInfo = m_PageInfoList.back();
       if ((pPageInfo->m_bIsStriped == 1) &&
@@ skipping 11 matching lines @@
 failed:
   delete pHRD;
   return nRet;
 }
 
 int32_t CJBig2_Context::parseGenericRegion(CJBig2_Segment* pSegment,
                                            IFX_Pause* pPause) {
   FX_DWORD dwTemp;
   uint8_t cFlags;
   int32_t i, nRet;
-  if (m_pGRD == NULL) {
-    m_pGRD = new CJBig2_GRDProc();
+  if (!m_pGRD) {
+    m_pGRD.reset(new CJBig2_GRDProc);
     if ((parseRegionInfo(&m_ri) != JBIG2_SUCCESS) ||
         (m_pStream->read1Byte(&cFlags) != 0)) {
       nRet = JBIG2_ERROR_TOO_SHORT;
       goto failed;
     }
     if (m_ri.height < 0 || m_ri.width < 0) {
       nRet = JBIG2_FAILED;
       goto failed;
     }
     m_pGRD->GBW = m_ri.width;
@@ skipping 22 matching lines @@
   }
   pSegment->m_nResultType = JBIG2_IMAGE_POINTER;
   if (m_pGRD->MMR == 0) {
     dwTemp =
         m_pGRD->GBTEMPLATE == 0 ? 65536 : m_pGRD->GBTEMPLATE == 1 ? 8192 : 1024;
     if (m_gbContext == NULL) {
       m_gbContext = FX_Alloc(JBig2ArithCtx, dwTemp);
       JBIG2_memset(m_gbContext, 0, sizeof(JBig2ArithCtx) * dwTemp);
     }
     if (m_pArithDecoder == NULL) {
-      m_pArithDecoder = new CJBig2_ArithDecoder(m_pStream);
+      m_pArithDecoder = new CJBig2_ArithDecoder(m_pStream.get());
       m_ProcessingStatus = m_pGRD->Start_decode_Arith(
           &pSegment->m_Result.im, m_pArithDecoder, m_gbContext, pPause);
     } else {
       m_ProcessingStatus = m_pGRD->Continue_decode(pPause);
     }
     if (m_ProcessingStatus == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
       if (pSegment->m_cFlags.s.type != 36) {
         if (!m_bBufSpecified) {
           JBig2PageInfo* pPageInfo = m_PageInfoList.back();
           if ((pPageInfo->m_bIsStriped == 1) &&
@@ skipping 17 matching lines @@
         m_gbContext = NULL;
         m_ProcessingStatus = FXCODEC_STATUS_ERROR;
         goto failed;
       }
       FX_Free(m_gbContext);
       m_gbContext = NULL;
       m_pStream->alignByte();
       m_pStream->offset(2);
     }
   } else {
-    FXCODEC_STATUS status =
-        m_pGRD->Start_decode_MMR(&pSegment->m_Result.im, m_pStream, pPause);
+    FXCODEC_STATUS status = m_pGRD->Start_decode_MMR(&pSegment->m_Result.im,
+                                                     m_pStream.get(), pPause);
     while (status == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
       m_pGRD->Continue_decode(pPause);
     }
     if (pSegment->m_Result.im == NULL) {
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
     }
     m_pStream->alignByte();
   }
   if (pSegment->m_cFlags.s.type != 36) {
     if (!m_bBufSpecified) {
       JBig2PageInfo* pPageInfo = m_PageInfoList.back();
       if ((pPageInfo->m_bIsStriped == 1) &&
           (m_ri.y + m_ri.height > m_pPage->m_nHeight)) {
         m_pPage->expand(m_ri.y + m_ri.height,
                         (pPageInfo->m_cFlags & 4) ? 1 : 0);
       }
     }
     FX_RECT Rect = m_pGRD->GetReplaceRect();
     m_pPage->composeFrom(m_ri.x + Rect.left, m_ri.y + Rect.top,
                          pSegment->m_Result.im,
                          (JBig2ComposeOp)(m_ri.flags & 0x03), &Rect);
     delete pSegment->m_Result.im;
     pSegment->m_Result.im = NULL;
   }
-  delete m_pGRD;
-  m_pGRD = NULL;
+  m_pGRD.reset();
   return JBIG2_SUCCESS;
 failed:
-  delete m_pGRD;
-  m_pGRD = NULL;
+  m_pGRD.reset();
   return nRet;
 }
 
 int32_t CJBig2_Context::parseGenericRefinementRegion(CJBig2_Segment* pSegment) {
   FX_DWORD dwTemp;
   JBig2RegionInfo ri;
   CJBig2_Segment* pSeg;
   int32_t i, nRet;
   uint8_t cFlags;
   JBig2ArithCtx* grContext;
@@ skipping 28 matching lines @@
           (pSeg->m_cFlags.s.type == 36) || (pSeg->m_cFlags.s.type == 40)) {
         break;
       }
     }
     if (i >= pSegment->m_nReferred_to_segment_count) {
       nRet = JBIG2_ERROR_FATAL;
       goto failed;
     }
     pGRRD->GRREFERENCE = pSeg->m_Result.im;
   } else {
-    pGRRD->GRREFERENCE = m_pPage;
+    pGRRD->GRREFERENCE = m_pPage.get();
   }
   pGRRD->GRREFERENCEDX = 0;
   pGRRD->GRREFERENCEDY = 0;
   dwTemp = pGRRD->GRTEMPLATE ? 1 << 10 : 1 << 13;
   grContext = FX_Alloc(JBig2ArithCtx, dwTemp);
   JBIG2_memset(grContext, 0, sizeof(JBig2ArithCtx) * dwTemp);
-  pArithDecoder = new CJBig2_ArithDecoder(m_pStream);
+  pArithDecoder = new CJBig2_ArithDecoder(m_pStream.get());
   pSegment->m_nResultType = JBIG2_IMAGE_POINTER;
   pSegment->m_Result.im = pGRRD->decode(pArithDecoder, grContext);
   delete pArithDecoder;
   if (pSegment->m_Result.im == NULL) {
     FX_Free(grContext);
     nRet = JBIG2_ERROR_FATAL;
     goto failed;
   }
   FX_Free(grContext);
   m_pStream->alignByte();
@@ skipping 12 matching lines @@
     pSegment->m_Result.im = NULL;
   }
   delete pGRRD;
   return JBIG2_SUCCESS;
 failed:
   delete pGRRD;
   return nRet;
 }
 int32_t CJBig2_Context::parseTable(CJBig2_Segment* pSegment) {
   pSegment->m_nResultType = JBIG2_HUFFMAN_TABLE_POINTER;
-  pSegment->m_Result.ht = new CJBig2_HuffmanTable(m_pStream);
+  pSegment->m_Result.ht = new CJBig2_HuffmanTable(m_pStream.get());
   if (!pSegment->m_Result.ht->isOK()) {
     delete pSegment->m_Result.ht;
     pSegment->m_Result.ht = NULL;
     return JBIG2_ERROR_FATAL;
   }
   m_pStream->alignByte();
   return JBIG2_SUCCESS;
 }
 int32_t CJBig2_Context::parseRegionInfo(JBig2RegionInfo* pRI) {
   if ((m_pStream->readInteger((FX_DWORD*)&pRI->width) != 0) ||
@@ skipping 150 matching lines @@
         SBSYMCODES[CURTEMP].code = CURCODE;
         CURCODE = CURCODE + 1;
       }
       CURTEMP = CURTEMP + 1;
     }
     CURLEN = CURLEN + 1;
   }
   FX_Free(LENCOUNT);
   FX_Free(FIRSTCODE);
 }