Avoid the ptr.reset(new XXX()) anti-pattern

core/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 "core/fxcodec/jbig2/JBig2_Context.h"
 
 #include <algorithm>
 #include <list>
 #include <utility>
 #include <vector>
 
 #include "core/fpdfapi/parser/cpdf_stream.h"
 #include "core/fpdfapi/parser/cpdf_stream_acc.h"
 #include "core/fxcodec/jbig2/JBig2_ArithDecoder.h"
 #include "core/fxcodec/jbig2/JBig2_BitStream.h"
 #include "core/fxcodec/jbig2/JBig2_GrdProc.h"
 #include "core/fxcodec/jbig2/JBig2_GrrdProc.h"
 #include "core/fxcodec/jbig2/JBig2_HtrdProc.h"
 #include "core/fxcodec/jbig2/JBig2_HuffmanTable_Standard.h"
 #include "core/fxcodec/jbig2/JBig2_PddProc.h"
 #include "core/fxcodec/jbig2/JBig2_SddProc.h"
 #include "core/fxcodec/jbig2/JBig2_TrdProc.h"
+#include "third_party/base/ptr_util.h"
 #include "third_party/base/stl_util.h"
 
 namespace {
 
 size_t GetHuffContextSize(uint8_t val) {
   return val == 0 ? 65536 : val == 1 ? 8192 : 1024;
 }
 
 size_t GetRefAggContextSize(bool val) {
   return val ? 1024 : 8192;
@@ skipping 18 matching lines @@
     : m_nSegmentDecoded(0),
       m_bInPage(false),
       m_bBufSpecified(false),
       m_PauseStep(10),
       m_pPause(pPause),
       m_ProcessingStatus(FXCODEC_STATUS_FRAME_READY),
       m_dwOffset(0),
       m_pSymbolDictCache(pSymbolDictCache),
       m_bIsGlobal(bIsGlobal) {
   if (pGlobalStream && (pGlobalStream->GetSize() > 0)) {
-    m_pGlobalContext.reset(new CJBig2_Context(nullptr, pGlobalStream,
-                                              pSymbolDictCache, pPause, true));
+    m_pGlobalContext = pdfium::MakeUnique<CJBig2_Context>(
+        nullptr, pGlobalStream, pSymbolDictCache, pPause, true);
   }
-  m_pStream.reset(new CJBig2_BitStream(pSrcStream));
+  m_pStream = pdfium::MakeUnique<CJBig2_BitStream>(pSrcStream);
 }
 
 CJBig2_Context::~CJBig2_Context() {}
 
 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);
+      m_pSegment = pdfium::MakeUnique<CJBig2_Segment>();
       nRet = parseSegmentHeader(m_pSegment.get());
       if (nRet != JBIG2_SUCCESS) {
         m_pSegment.reset();
         return nRet;
       }
       m_dwOffset = m_pStream->getOffset();
     }
     nRet = parseSegmentData(m_pSegment.get(), pPause);
     if (m_ProcessingStatus == FXCODEC_STATUS_DECODE_TOBECONTINUE) {
       m_ProcessingStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
@@ skipping 76 matching lines @@
                                      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_PauseStep = 0;
-  m_pPage.reset(new CJBig2_Image(width, height, stride, pBuf));
+  m_pPage = pdfium::MakeUnique<CJBig2_Image>(width, height, stride, pBuf);
   m_bBufSpecified = true;
   if (pPause && pPause->NeedToPauseNow()) {
     m_PauseStep = 1;
     m_ProcessingStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
     return nRet;
   }
   return Continue(pPause);
 }
 
 int32_t CJBig2_Context::Continue(IFX_Pause* pPause) {
@@ skipping 190 matching lines @@
       }
       pPageInfo->m_bIsStriped = !!(wTemp & 0x8000);
       pPageInfo->m_wMaxStripeSize = wTemp & 0x7fff;
       bool bMaxHeight = (pPageInfo->m_dwHeight == 0xffffffff);
       if (bMaxHeight && pPageInfo->m_bIsStriped != true)
         pPageInfo->m_bIsStriped = true;
 
       if (!m_bBufSpecified) {
         uint32_t height =
             bMaxHeight ? pPageInfo->m_wMaxStripeSize : pPageInfo->m_dwHeight;
-        m_pPage.reset(new CJBig2_Image(pPageInfo->m_dwWidth, height));
+        m_pPage =
+            pdfium::MakeUnique<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_bInPage = true;
@@ skipping 93 matching lines @@
   std::unique_ptr<CJBig2_HuffmanTable> Table_B2;
   std::unique_ptr<CJBig2_HuffmanTable> Table_B3;
   std::unique_ptr<CJBig2_HuffmanTable> Table_B4;
   std::unique_ptr<CJBig2_HuffmanTable> Table_B5;
   if (pSymbolDictDecoder->SDHUFF == 1) {
     if (cSDHUFFDH == 2 || cSDHUFFDW == 2)
       return JBIG2_ERROR_FATAL;
 
     int32_t nIndex = 0;
     if (cSDHUFFDH == 0) {
-      Table_B4.reset(new CJBig2_HuffmanTable(
-          HuffmanTable_B4, HuffmanTable_B4_Size, HuffmanTable_HTOOB_B4));
+      Table_B4 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+          HuffmanTable_B4, HuffmanTable_B4_Size, HuffmanTable_HTOOB_B4);
       pSymbolDictDecoder->SDHUFFDH = Table_B4.get();
     } else if (cSDHUFFDH == 1) {
-      Table_B5.reset(new CJBig2_HuffmanTable(
-          HuffmanTable_B5, HuffmanTable_B5_Size, HuffmanTable_HTOOB_B5));
+      Table_B5 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+          HuffmanTable_B5, HuffmanTable_B5_Size, HuffmanTable_HTOOB_B5);
       pSymbolDictDecoder->SDHUFFDH = Table_B5.get();
     } else {
       CJBig2_Segment* pSeg =
           findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg)
         return JBIG2_ERROR_FATAL;
       pSymbolDictDecoder->SDHUFFDH = pSeg->m_Result.ht;
     }
     if (cSDHUFFDW == 0) {
-      Table_B2.reset(new CJBig2_HuffmanTable(
-          HuffmanTable_B2, HuffmanTable_B2_Size, HuffmanTable_HTOOB_B2));
+      Table_B2 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+          HuffmanTable_B2, HuffmanTable_B2_Size, HuffmanTable_HTOOB_B2);
       pSymbolDictDecoder->SDHUFFDW = Table_B2.get();
     } else if (cSDHUFFDW == 1) {
-      Table_B3.reset(new CJBig2_HuffmanTable(
-          HuffmanTable_B3, HuffmanTable_B3_Size, HuffmanTable_HTOOB_B3));
+      Table_B3 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+          HuffmanTable_B3, HuffmanTable_B3_Size, HuffmanTable_HTOOB_B3);
       pSymbolDictDecoder->SDHUFFDW = Table_B3.get();
     } else {
       CJBig2_Segment* pSeg =
           findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg)
         return JBIG2_ERROR_FATAL;
       pSymbolDictDecoder->SDHUFFDW = pSeg->m_Result.ht;
     }
     if (cSDHUFFBMSIZE == 0) {
-      Table_B1.reset(new CJBig2_HuffmanTable(
-          HuffmanTable_B1, HuffmanTable_B1_Size, HuffmanTable_HTOOB_B1));
+      Table_B1 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+          HuffmanTable_B1, HuffmanTable_B1_Size, HuffmanTable_HTOOB_B1);
       pSymbolDictDecoder->SDHUFFBMSIZE = Table_B1.get();
     } else {
       CJBig2_Segment* pSeg =
           findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg)
         return JBIG2_ERROR_FATAL;
       pSymbolDictDecoder->SDHUFFBMSIZE = pSeg->m_Result.ht;
     }
     if (pSymbolDictDecoder->SDREFAGG == 1) {
       if (cSDHUFFAGGINST == 0) {
         if (!Table_B1) {
-          Table_B1.reset(new CJBig2_HuffmanTable(
-              HuffmanTable_B1, HuffmanTable_B1_Size, HuffmanTable_HTOOB_B1));
+          Table_B1 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+              HuffmanTable_B1, HuffmanTable_B1_Size, HuffmanTable_HTOOB_B1);
         }
         pSymbolDictDecoder->SDHUFFAGGINST = Table_B1.get();
       } else {
         CJBig2_Segment* pSeg =
             findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
         if (!pSeg)
           return JBIG2_ERROR_FATAL;
         pSymbolDictDecoder->SDHUFFAGGINST = pSeg->m_Result.ht;
       }
     }
@@ skipping 197 matching lines @@
   std::unique_ptr<CJBig2_HuffmanTable> Table_B13;
   std::unique_ptr<CJBig2_HuffmanTable> Table_B14;
   std::unique_ptr<CJBig2_HuffmanTable> Table_B15;
   if (pTRD->SBHUFF == 1) {
     if (cSBHUFFFS == 2 || cSBHUFFRDW == 2 || cSBHUFFRDH == 2 ||
         cSBHUFFRDX == 2 || cSBHUFFRDY == 2) {
       return JBIG2_ERROR_FATAL;
     }
     int32_t nIndex = 0;
     if (cSBHUFFFS == 0) {
-      Table_B6.reset(new CJBig2_HuffmanTable(
-          HuffmanTable_B6, HuffmanTable_B6_Size, HuffmanTable_HTOOB_B6));
+      Table_B6 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+          HuffmanTable_B6, HuffmanTable_B6_Size, HuffmanTable_HTOOB_B6);
       pTRD->SBHUFFFS = Table_B6.get();
     } else if (cSBHUFFFS == 1) {
-      Table_B7.reset(new CJBig2_HuffmanTable(
-          HuffmanTable_B7, HuffmanTable_B7_Size, HuffmanTable_HTOOB_B7));
+      Table_B7 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+          HuffmanTable_B7, HuffmanTable_B7_Size, HuffmanTable_HTOOB_B7);
       pTRD->SBHUFFFS = Table_B7.get();
     } else {
       CJBig2_Segment* pSeg =
           findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg)
         return JBIG2_ERROR_FATAL;
       pTRD->SBHUFFFS = pSeg->m_Result.ht;
     }
     if (cSBHUFFDS == 0) {
-      Table_B8.reset(new CJBig2_HuffmanTable(
-          HuffmanTable_B8, HuffmanTable_B8_Size, HuffmanTable_HTOOB_B8));
+      Table_B8 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+          HuffmanTable_B8, HuffmanTable_B8_Size, HuffmanTable_HTOOB_B8);
       pTRD->SBHUFFDS = Table_B8.get();
     } else if (cSBHUFFDS == 1) {
-      Table_B9.reset(new CJBig2_HuffmanTable(
-          HuffmanTable_B9, HuffmanTable_B9_Size, HuffmanTable_HTOOB_B9));
+      Table_B9 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+          HuffmanTable_B9, HuffmanTable_B9_Size, HuffmanTable_HTOOB_B9);
       pTRD->SBHUFFDS = Table_B9.get();
     } else if (cSBHUFFDS == 2) {
-      Table_B10.reset(new CJBig2_HuffmanTable(
-          HuffmanTable_B10, HuffmanTable_B10_Size, HuffmanTable_HTOOB_B10));
+      Table_B10 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+          HuffmanTable_B10, HuffmanTable_B10_Size, HuffmanTable_HTOOB_B10);
       pTRD->SBHUFFDS = Table_B10.get();
     } else {
       CJBig2_Segment* pSeg =
           findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg)
         return JBIG2_ERROR_FATAL;
       pTRD->SBHUFFDS = pSeg->m_Result.ht;
     }
     if (cSBHUFFDT == 0) {
-      Table_B11.reset(new CJBig2_HuffmanTable(
-          HuffmanTable_B11, HuffmanTable_B11_Size, HuffmanTable_HTOOB_B11));
+      Table_B11 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+          HuffmanTable_B11, HuffmanTable_B11_Size, HuffmanTable_HTOOB_B11);
       pTRD->SBHUFFDT = Table_B11.get();
     } else if (cSBHUFFDT == 1) {
-      Table_B12.reset(new CJBig2_HuffmanTable(
-          HuffmanTable_B12, HuffmanTable_B12_Size, HuffmanTable_HTOOB_B12));
+      Table_B12 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+          HuffmanTable_B12, HuffmanTable_B12_Size, HuffmanTable_HTOOB_B12);
       pTRD->SBHUFFDT = Table_B12.get();
     } else if (cSBHUFFDT == 2) {
-      Table_B13.reset(new CJBig2_HuffmanTable(
-          HuffmanTable_B13, HuffmanTable_B13_Size, HuffmanTable_HTOOB_B13));
+      Table_B13 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+          HuffmanTable_B13, HuffmanTable_B13_Size, HuffmanTable_HTOOB_B13);
       pTRD->SBHUFFDT = Table_B13.get();
     } else {
       CJBig2_Segment* pSeg =
           findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg)
         return JBIG2_ERROR_FATAL;
       pTRD->SBHUFFDT = pSeg->m_Result.ht;
     }
     if (cSBHUFFRDW == 0) {
-      Table_B14.reset(new CJBig2_HuffmanTable(
-          HuffmanTable_B14, HuffmanTable_B14_Size, HuffmanTable_HTOOB_B14));
+      Table_B14 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+          HuffmanTable_B14, HuffmanTable_B14_Size, HuffmanTable_HTOOB_B14);
       pTRD->SBHUFFRDW = Table_B14.get();
     } else if (cSBHUFFRDW == 1) {
-      Table_B15.reset(new CJBig2_HuffmanTable(
-          HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15));
+      Table_B15 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+          HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15);
       pTRD->SBHUFFRDW = Table_B15.get();
     } else {
       CJBig2_Segment* pSeg =
           findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg)
         return JBIG2_ERROR_FATAL;
       pTRD->SBHUFFRDW = pSeg->m_Result.ht;
     }
     if (cSBHUFFRDH == 0) {
       if (!Table_B14) {
-        Table_B14.reset(new CJBig2_HuffmanTable(
-            HuffmanTable_B14, HuffmanTable_B14_Size, HuffmanTable_HTOOB_B14));
+        Table_B14 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+            HuffmanTable_B14, HuffmanTable_B14_Size, HuffmanTable_HTOOB_B14);
       }
       pTRD->SBHUFFRDH = Table_B14.get();
     } else if (cSBHUFFRDH == 1) {
       if (!Table_B15) {
-        Table_B15.reset(new CJBig2_HuffmanTable(
-            HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15));
+        Table_B15 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+            HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15);
       }
       pTRD->SBHUFFRDH = Table_B15.get();
     } else {
       CJBig2_Segment* pSeg =
           findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg)
         return JBIG2_ERROR_FATAL;
       pTRD->SBHUFFRDH = pSeg->m_Result.ht;
     }
     if (cSBHUFFRDX == 0) {
       if (!Table_B14) {
-        Table_B14.reset(new CJBig2_HuffmanTable(
-            HuffmanTable_B14, HuffmanTable_B14_Size, HuffmanTable_HTOOB_B14));
+        Table_B14 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+            HuffmanTable_B14, HuffmanTable_B14_Size, HuffmanTable_HTOOB_B14);
       }
       pTRD->SBHUFFRDX = Table_B14.get();
     } else if (cSBHUFFRDX == 1) {
       if (!Table_B15) {
-        Table_B15.reset(new CJBig2_HuffmanTable(
-            HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15));
+        Table_B15 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+            HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15);
       }
       pTRD->SBHUFFRDX = Table_B15.get();
     } else {
       CJBig2_Segment* pSeg =
           findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg)
         return JBIG2_ERROR_FATAL;
       pTRD->SBHUFFRDX = pSeg->m_Result.ht;
     }
     if (cSBHUFFRDY == 0) {
       if (!Table_B14) {
-        Table_B14.reset(new CJBig2_HuffmanTable(
-            HuffmanTable_B14, HuffmanTable_B14_Size, HuffmanTable_HTOOB_B14));
+        Table_B14 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+            HuffmanTable_B14, HuffmanTable_B14_Size, HuffmanTable_HTOOB_B14);
       }
       pTRD->SBHUFFRDY = Table_B14.get();
     } else if (cSBHUFFRDY == 1) {
       if (!Table_B15) {
-        Table_B15.reset(new CJBig2_HuffmanTable(
-            HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15));
+        Table_B15 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+            HuffmanTable_B15, HuffmanTable_B15_Size, HuffmanTable_HTOOB_B15);
       }
       pTRD->SBHUFFRDY = Table_B15.get();
     } else {
       CJBig2_Segment* pSeg =
           findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg)
         return JBIG2_ERROR_FATAL;
       pTRD->SBHUFFRDY = pSeg->m_Result.ht;
     }
     if (cSBHUFFRSIZE == 0) {
-      Table_B1.reset(new CJBig2_HuffmanTable(
-          HuffmanTable_B1, HuffmanTable_B1_Size, HuffmanTable_HTOOB_B1));
+      Table_B1 = pdfium::MakeUnique<CJBig2_HuffmanTable>(
+          HuffmanTable_B1, HuffmanTable_B1_Size, HuffmanTable_HTOOB_B1);
       pTRD->SBHUFFRSIZE = Table_B1.get();
     } else {
       CJBig2_Segment* pSeg =
           findReferredSegmentByTypeAndIndex(pSegment, 53, nIndex++);
       if (!pSeg)
         return JBIG2_ERROR_FATAL;
       pTRD->SBHUFFRSIZE = pSeg->m_Result.ht;
     }
   }
   std::unique_ptr<JBig2ArithCtx, FxFreeDeleter> grContext;
@@ skipping 189 matching lines @@
     pGRD->USESKIP = 0;
     m_pGRD = std::move(pGRD);
   }
   pSegment->m_nResultType = JBIG2_IMAGE_POINTER;
   if (m_pGRD->MMR == 0) {
     if (m_gbContext.empty()) {
       const size_t size = GetHuffContextSize(m_pGRD->GBTEMPLATE);
       m_gbContext.resize(size);
     }
     if (!m_pArithDecoder) {
-      m_pArithDecoder.reset(new CJBig2_ArithDecoder(m_pStream.get()));
+      m_pArithDecoder =
+          pdfium::MakeUnique<CJBig2_ArithDecoder>(m_pStream.get());
       m_ProcessingStatus = m_pGRD->Start_decode_Arith(&pSegment->m_Result.im,
                                                       m_pArithDecoder.get(),
                                                       &m_gbContext[0], 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();
@@ skipping 277 matching lines @@
         SBSYMCODES[CURTEMP].code = CURCODE;
         CURCODE = CURCODE + 1;
       }
       CURTEMP = CURTEMP + 1;
     }
     CURLEN = CURLEN + 1;
   }
   FX_Free(LENCOUNT);
   FX_Free(FIRSTCODE);
 }