Switch from nonstd::unique_ptr to std::unique_ptr.

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 "core/src/fxcodec/jbig2/JBig2_Context.h"
 
 #include <algorithm>
 #include <list>
@@ skipping 120 matching lines @@
     }
   }
   return JBIG2_SUCCESS;
 }
 int32_t CJBig2_Context::decode_EmbedOrgnazation(IFX_Pause* pPause) {
   return decode_SquentialOrgnazation(pPause);
 }
 int32_t CJBig2_Context::decode_RandomOrgnazation_FirstPage(IFX_Pause* pPause) {
   int32_t nRet;
   while (m_pStream->getByteLeft() > JBIG2_MIN_SEGMENT_SIZE) {
-    nonstd::unique_ptr<CJBig2_Segment> pSegment(new CJBig2_Segment);
+    std::unique_ptr<CJBig2_Segment> pSegment(new CJBig2_Segment);
     nRet = parseSegmentHeader(pSegment.get());
     if (nRet != JBIG2_SUCCESS) {
       return nRet;
     } else if (pSegment->m_cFlags.s.type == 51) {
       break;
     }
     m_SegmentList.push_back(pSegment.release());
     if (pPause && m_pPause && pPause->NeedToPauseNow()) {
       m_PauseStep = 3;
       m_ProcessingStatus = FXCODEC_STATUS_DECODE_TOBECONTINUE;
@@ skipping 218 matching lines @@
         return JBIG2_ERROR_FATAL;
       return parseGenericRegion(pSegment, pPause);
     case 40:
     case 42:
     case 43:
       if (!m_bInPage)
         return JBIG2_ERROR_FATAL;
       return parseGenericRefinementRegion(pSegment);
     case 48: {
       FX_WORD wTemp;
-      nonstd::unique_ptr<JBig2PageInfo> pPageInfo(new JBig2PageInfo);
+      std::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 & 0x8000);
       pPageInfo->m_wMaxStripeSize = wTemp & 0x7fff;
@@ skipping 38 matching lines @@
   }
   return JBIG2_SUCCESS;
 }
 
 int32_t CJBig2_Context::parseSymbolDict(CJBig2_Segment* pSegment,
                                         IFX_Pause* pPause) {
   FX_WORD wFlags;
   if (m_pStream->readShortInteger(&wFlags) != 0)
     return JBIG2_ERROR_TOO_SHORT;
 
-  nonstd::unique_ptr<CJBig2_SDDProc> pSymbolDictDecoder(new CJBig2_SDDProc);
+  std::unique_ptr<CJBig2_SDDProc> pSymbolDictDecoder(new CJBig2_SDDProc);
   pSymbolDictDecoder->SDHUFF = wFlags & 0x0001;
   pSymbolDictDecoder->SDREFAGG = (wFlags >> 1) & 0x0001;
   pSymbolDictDecoder->SDTEMPLATE = (wFlags >> 10) & 0x0003;
   pSymbolDictDecoder->SDRTEMPLATE = (wFlags >> 12) & 0x0003;
   uint8_t cSDHUFFDH = (wFlags >> 2) & 0x0003;
   uint8_t cSDHUFFDW = (wFlags >> 4) & 0x0003;
   uint8_t cSDHUFFBMSIZE = (wFlags >> 6) & 0x0001;
   uint8_t cSDHUFFAGGINST = (wFlags >> 7) & 0x0001;
   if (pSymbolDictDecoder->SDHUFF == 0) {
     const FX_DWORD dwTemp = (pSymbolDictDecoder->SDTEMPLATE == 0) ? 8 : 2;
@@ skipping 25 matching lines @@
   pSymbolDictDecoder->SDNUMINSYMS = 0;
   for (int32_t i = 0; i < pSegment->m_nReferred_to_segment_count; ++i) {
     CJBig2_Segment* pSeg =
         findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]);
     if (pSeg->m_cFlags.s.type == 0) {
       pSymbolDictDecoder->SDNUMINSYMS += pSeg->m_Result.sd->NumImages();
       pLRSeg = pSeg;
     }
   }
 
-  nonstd::unique_ptr<CJBig2_Image*, FxFreeDeleter> SDINSYMS;
+  std::unique_ptr<CJBig2_Image*, FxFreeDeleter> SDINSYMS;
   if (pSymbolDictDecoder->SDNUMINSYMS != 0) {
     SDINSYMS.reset(FX_Alloc(CJBig2_Image*, pSymbolDictDecoder->SDNUMINSYMS));
     FX_DWORD dwTemp = 0;
     for (int32_t i = 0; i < pSegment->m_nReferred_to_segment_count; ++i) {
       CJBig2_Segment* pSeg =
           findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]);
       if (pSeg->m_cFlags.s.type == 0) {
         const CJBig2_SymbolDict& dict = *pSeg->m_Result.sd;
         for (size_t j = 0; j < dict.NumImages(); ++j)
           SDINSYMS.get()[dwTemp + j] = dict.GetImage(j);
         dwTemp += dict.NumImages();
       }
     }
   }
   pSymbolDictDecoder->SDINSYMS = SDINSYMS.get();
 
-  nonstd::unique_ptr<CJBig2_HuffmanTable> Table_B1;
-  nonstd::unique_ptr<CJBig2_HuffmanTable> Table_B2;
-  nonstd::unique_ptr<CJBig2_HuffmanTable> Table_B3;
-  nonstd::unique_ptr<CJBig2_HuffmanTable> Table_B4;
-  nonstd::unique_ptr<CJBig2_HuffmanTable> Table_B5;
+  std::unique_ptr<CJBig2_HuffmanTable> Table_B1;
+  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,
                                              FX_ArraySize(HuffmanTable_B4),
                                              HuffmanTable_HTOOB_B4));
       pSymbolDictDecoder->SDHUFFDH = Table_B4.get();
@@ skipping 83 matching lines @@
   }
 
   CJBig2_CacheKey key =
       CJBig2_CacheKey(pSegment->m_dwObjNum, pSegment->m_dwDataOffset);
   FX_BOOL cache_hit = false;
   pSegment->m_nResultType = JBIG2_SYMBOL_DICT_POINTER;
   if (m_bIsGlobal && key.first != 0) {
     for (auto it = m_pSymbolDictCache->begin(); it != m_pSymbolDictCache->end();
          ++it) {
       if (it->first == key) {
-        nonstd::unique_ptr<CJBig2_SymbolDict> copy(it->second->DeepCopy());
+        std::unique_ptr<CJBig2_SymbolDict> copy(it->second->DeepCopy());
         pSegment->m_Result.sd = copy.release();
         m_pSymbolDictCache->push_front(*it);
         m_pSymbolDictCache->erase(it);
         cache_hit = true;
         break;
       }
     }
   }
   if (!cache_hit) {
     if (bUseGbContext) {
-      nonstd::unique_ptr<CJBig2_ArithDecoder> pArithDecoder(
+      std::unique_ptr<CJBig2_ArithDecoder> pArithDecoder(
           new CJBig2_ArithDecoder(m_pStream.get()));
       pSegment->m_Result.sd = pSymbolDictDecoder->decode_Arith(
           pArithDecoder.get(), &gbContext, &grContext);
       if (!pSegment->m_Result.sd)
         return JBIG2_ERROR_FATAL;
 
       m_pStream->alignByte();
       m_pStream->offset(2);
     } else {
       pSegment->m_Result.sd = pSymbolDictDecoder->decode_Huffman(
           m_pStream.get(), &gbContext, &grContext, pPause);
       if (!pSegment->m_Result.sd)
         return JBIG2_ERROR_FATAL;
       m_pStream->alignByte();
     }
     if (m_bIsGlobal && kSymbolDictCacheMaxSize > 0) {
-      nonstd::unique_ptr<CJBig2_SymbolDict> value =
+      std::unique_ptr<CJBig2_SymbolDict> value =
           pSegment->m_Result.sd->DeepCopy();
       while (m_pSymbolDictCache->size() >= kSymbolDictCacheMaxSize) {
         delete m_pSymbolDictCache->back().second;
         m_pSymbolDictCache->pop_back();
       }
       m_pSymbolDictCache->push_front(CJBig2_CachePair(key, value.release()));
     }
   }
   if (wFlags & 0x0200) {
     if (bUseGbContext)
       pSegment->m_Result.sd->SetGbContext(gbContext);
     if (bUseGrContext)
       pSegment->m_Result.sd->SetGrContext(grContext);
   }
   return JBIG2_SUCCESS;
 }
 
 int32_t CJBig2_Context::parseTextRegion(CJBig2_Segment* pSegment) {
   FX_WORD wFlags;
   JBig2RegionInfo ri;
   if (parseRegionInfo(&ri) != JBIG2_SUCCESS ||
       m_pStream->readShortInteger(&wFlags) != 0) {
     return JBIG2_ERROR_TOO_SHORT;
   }
 
-  nonstd::unique_ptr<CJBig2_TRDProc> pTRD(new CJBig2_TRDProc);
+  std::unique_ptr<CJBig2_TRDProc> pTRD(new CJBig2_TRDProc);
   pTRD->SBW = ri.width;
   pTRD->SBH = ri.height;
   pTRD->SBHUFF = wFlags & 0x0001;
   pTRD->SBREFINE = (wFlags >> 1) & 0x0001;
   FX_DWORD dwTemp = (wFlags >> 2) & 0x0003;
   pTRD->SBSTRIPS = 1 << dwTemp;
   pTRD->REFCORNER = (JBig2Corner)((wFlags >> 4) & 0x0003);
   pTRD->TRANSPOSED = (wFlags >> 6) & 0x0001;
   pTRD->SBCOMBOP = (JBig2ComposeOp)((wFlags >> 7) & 0x0003);
   pTRD->SBDEFPIXEL = (wFlags >> 9) & 0x0001;
@@ skipping 40 matching lines @@
 
   pTRD->SBNUMSYMS = 0;
   for (int32_t i = 0; i < pSegment->m_nReferred_to_segment_count; ++i) {
     CJBig2_Segment* pSeg =
         findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]);
     if (pSeg->m_cFlags.s.type == 0) {
       pTRD->SBNUMSYMS += pSeg->m_Result.sd->NumImages();
     }
   }
 
-  nonstd::unique_ptr<CJBig2_Image*, FxFreeDeleter> SBSYMS;
+  std::unique_ptr<CJBig2_Image*, FxFreeDeleter> SBSYMS;
   if (pTRD->SBNUMSYMS > 0) {
     SBSYMS.reset(FX_Alloc(CJBig2_Image*, pTRD->SBNUMSYMS));
     dwTemp = 0;
     for (int32_t i = 0; i < pSegment->m_nReferred_to_segment_count; ++i) {
       CJBig2_Segment* pSeg =
           findSegmentByNumber(pSegment->m_pReferred_to_segment_numbers[i]);
       if (pSeg->m_cFlags.s.type == 0) {
         const CJBig2_SymbolDict& dict = *pSeg->m_Result.sd;
         for (size_t j = 0; j < dict.NumImages(); ++j)
           SBSYMS.get()[dwTemp + j] = dict.GetImage(j);
         dwTemp += dict.NumImages();
       }
     }
     pTRD->SBSYMS = SBSYMS.get();
   } else {
     pTRD->SBSYMS = NULL;
   }
 
-  nonstd::unique_ptr<JBig2HuffmanCode, FxFreeDeleter> SBSYMCODES;
+  std::unique_ptr<JBig2HuffmanCode, FxFreeDeleter> SBSYMCODES;
   if (pTRD->SBHUFF == 1) {
     SBSYMCODES.reset(
         decodeSymbolIDHuffmanTable(m_pStream.get(), pTRD->SBNUMSYMS));
     if (!SBSYMCODES)
       return JBIG2_ERROR_FATAL;
 
     m_pStream->alignByte();
     pTRD->SBSYMCODES = SBSYMCODES.get();
   } else {
     dwTemp = 0;
     while ((FX_DWORD)(1 << dwTemp) < pTRD->SBNUMSYMS) {
       ++dwTemp;
     }
     pTRD->SBSYMCODELEN = (uint8_t)dwTemp;
   }
 
-  nonstd::unique_ptr<CJBig2_HuffmanTable> Table_B1;
-  nonstd::unique_ptr<CJBig2_HuffmanTable> Table_B6;
-  nonstd::unique_ptr<CJBig2_HuffmanTable> Table_B7;
-  nonstd::unique_ptr<CJBig2_HuffmanTable> Table_B8;
-  nonstd::unique_ptr<CJBig2_HuffmanTable> Table_B9;
-  nonstd::unique_ptr<CJBig2_HuffmanTable> Table_B10;
-  nonstd::unique_ptr<CJBig2_HuffmanTable> Table_B11;
-  nonstd::unique_ptr<CJBig2_HuffmanTable> Table_B12;
-  nonstd::unique_ptr<CJBig2_HuffmanTable> Table_B13;
-  nonstd::unique_ptr<CJBig2_HuffmanTable> Table_B14;
-  nonstd::unique_ptr<CJBig2_HuffmanTable> Table_B15;
+  std::unique_ptr<CJBig2_HuffmanTable> Table_B1;
+  std::unique_ptr<CJBig2_HuffmanTable> Table_B6;
+  std::unique_ptr<CJBig2_HuffmanTable> Table_B7;
+  std::unique_ptr<CJBig2_HuffmanTable> Table_B8;
+  std::unique_ptr<CJBig2_HuffmanTable> Table_B9;
+  std::unique_ptr<CJBig2_HuffmanTable> Table_B10;
+  std::unique_ptr<CJBig2_HuffmanTable> Table_B11;
+  std::unique_ptr<CJBig2_HuffmanTable> Table_B12;
+  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,
                                              FX_ArraySize(HuffmanTable_B6),
                                              HuffmanTable_HTOOB_B6));
@@ skipping 140 matching lines @@
                                              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;
     }
   }
-  nonstd::unique_ptr<JBig2ArithCtx, FxFreeDeleter> grContext;
+  std::unique_ptr<JBig2ArithCtx, FxFreeDeleter> grContext;
   if (pTRD->SBREFINE == 1) {
     const size_t size = GetRefAggContextSize(pTRD->SBRTEMPLATE);
     grContext.reset(FX_Alloc(JBig2ArithCtx, size));
     JBIG2_memset(grContext.get(), 0, sizeof(JBig2ArithCtx) * size);
   }
   if (pTRD->SBHUFF == 0) {
-    nonstd::unique_ptr<CJBig2_ArithDecoder> pArithDecoder(
+    std::unique_ptr<CJBig2_ArithDecoder> pArithDecoder(
         new CJBig2_ArithDecoder(m_pStream.get()));
     pSegment->m_nResultType = JBIG2_IMAGE_POINTER;
     pSegment->m_Result.im =
         pTRD->decode_Arith(pArithDecoder.get(), grContext.get());
     if (!pSegment->m_Result.im)
       return JBIG2_ERROR_FATAL;
     m_pStream->alignByte();
     m_pStream->offset(2);
   } else {
     pSegment->m_nResultType = JBIG2_IMAGE_POINTER;
@@ skipping 15 matching lines @@
                          (JBig2ComposeOp)(ri.flags & 0x03));
     delete pSegment->m_Result.im;
     pSegment->m_Result.im = NULL;
   }
   return JBIG2_SUCCESS;
 }
 
 int32_t CJBig2_Context::parsePatternDict(CJBig2_Segment* pSegment,
                                          IFX_Pause* pPause) {
   uint8_t cFlags;
-  nonstd::unique_ptr<CJBig2_PDDProc> pPDD(new CJBig2_PDDProc);
+  std::unique_ptr<CJBig2_PDDProc> pPDD(new CJBig2_PDDProc);
   if (m_pStream->read1Byte(&cFlags) != 0 ||
       m_pStream->read1Byte(&pPDD->HDPW) != 0 ||
       m_pStream->read1Byte(&pPDD->HDPH) != 0 ||
       m_pStream->readInteger(&pPDD->GRAYMAX) != 0) {
     return JBIG2_ERROR_TOO_SHORT;
   }
   if (pPDD->GRAYMAX > JBIG2_MAX_PATTERN_INDEX)
     return JBIG2_ERROR_LIMIT;
 
   pPDD->HDMMR = cFlags & 0x01;
   pPDD->HDTEMPLATE = (cFlags >> 1) & 0x03;
   pSegment->m_nResultType = JBIG2_PATTERN_DICT_POINTER;
   if (pPDD->HDMMR == 0) {
     const size_t size = GetHuffContextSize(pPDD->HDTEMPLATE);
-    nonstd::unique_ptr<JBig2ArithCtx, FxFreeDeleter> gbContext(
+    std::unique_ptr<JBig2ArithCtx, FxFreeDeleter> gbContext(
         FX_Alloc(JBig2ArithCtx, size));
     JBIG2_memset(gbContext.get(), 0, sizeof(JBig2ArithCtx) * size);
-    nonstd::unique_ptr<CJBig2_ArithDecoder> pArithDecoder(
+    std::unique_ptr<CJBig2_ArithDecoder> pArithDecoder(
         new CJBig2_ArithDecoder(m_pStream.get()));
     pSegment->m_Result.pd =
         pPDD->decode_Arith(pArithDecoder.get(), gbContext.get(), pPause);
     if (!pSegment->m_Result.pd)
       return JBIG2_ERROR_FATAL;
 
     m_pStream->alignByte();
     m_pStream->offset(2);
   } else {
     pSegment->m_Result.pd = pPDD->decode_MMR(m_pStream.get(), pPause);
     if (!pSegment->m_Result.pd)
       return JBIG2_ERROR_FATAL;
     m_pStream->alignByte();
   }
   return JBIG2_SUCCESS;
 }
 
 int32_t CJBig2_Context::parseHalftoneRegion(CJBig2_Segment* pSegment,
                                             IFX_Pause* pPause) {
   uint8_t cFlags;
   JBig2RegionInfo ri;
-  nonstd::unique_ptr<CJBig2_HTRDProc> pHRD(new CJBig2_HTRDProc);
+  std::unique_ptr<CJBig2_HTRDProc> pHRD(new CJBig2_HTRDProc);
   if (parseRegionInfo(&ri) != JBIG2_SUCCESS ||
       m_pStream->read1Byte(&cFlags) != 0 ||
       m_pStream->readInteger(&pHRD->HGW) != 0 ||
       m_pStream->readInteger(&pHRD->HGH) != 0 ||
       m_pStream->readInteger((FX_DWORD*)&pHRD->HGX) != 0 ||
       m_pStream->readInteger((FX_DWORD*)&pHRD->HGY) != 0 ||
       m_pStream->readShortInteger(&pHRD->HRX) != 0 ||
       m_pStream->readShortInteger(&pHRD->HRY) != 0) {
     return JBIG2_ERROR_TOO_SHORT;
   }
@@ skipping 20 matching lines @@
   if (!pPatternDict || (pPatternDict->NUMPATS == 0))
     return JBIG2_ERROR_FATAL;
 
   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) {
     const size_t size = GetHuffContextSize(pHRD->HTEMPLATE);
-    nonstd::unique_ptr<JBig2ArithCtx, FxFreeDeleter> gbContext(
+    std::unique_ptr<JBig2ArithCtx, FxFreeDeleter> gbContext(
         FX_Alloc(JBig2ArithCtx, size));
     JBIG2_memset(gbContext.get(), 0, sizeof(JBig2ArithCtx) * size);
-    nonstd::unique_ptr<CJBig2_ArithDecoder> pArithDecoder(
+    std::unique_ptr<CJBig2_ArithDecoder> pArithDecoder(
         new CJBig2_ArithDecoder(m_pStream.get()));
     pSegment->m_Result.im =
         pHRD->decode_Arith(pArithDecoder.get(), gbContext.get(), pPause);
     if (!pSegment->m_Result.im)
       return JBIG2_ERROR_FATAL;
 
     m_pStream->alignByte();
     m_pStream->offset(2);
   } else {
     pSegment->m_Result.im = pHRD->decode_MMR(m_pStream.get(), pPause);
@@ skipping 13 matching lines @@
                          (JBig2ComposeOp)(ri.flags & 0x03));
     delete pSegment->m_Result.im;
     pSegment->m_Result.im = NULL;
   }
   return JBIG2_SUCCESS;
 }
 
 int32_t CJBig2_Context::parseGenericRegion(CJBig2_Segment* pSegment,
                                            IFX_Pause* pPause) {
   if (!m_pGRD) {
-    nonstd::unique_ptr<CJBig2_GRDProc> pGRD(new CJBig2_GRDProc);
+    std::unique_ptr<CJBig2_GRDProc> pGRD(new CJBig2_GRDProc);
     uint8_t cFlags;
     if (parseRegionInfo(&m_ri) != JBIG2_SUCCESS ||
         m_pStream->read1Byte(&cFlags) != 0) {
       return JBIG2_ERROR_TOO_SHORT;
     }
     if (m_ri.height < 0 || m_ri.width < 0)
       return JBIG2_FAILED;
 
     pGRD->GBW = m_ri.width;
     pGRD->GBH = m_ri.height;
@@ skipping 92 matching lines @@
   return JBIG2_SUCCESS;
 }
 
 int32_t CJBig2_Context::parseGenericRefinementRegion(CJBig2_Segment* pSegment) {
   JBig2RegionInfo ri;
   uint8_t cFlags;
   if (parseRegionInfo(&ri) != JBIG2_SUCCESS ||
       m_pStream->read1Byte(&cFlags) != 0) {
     return JBIG2_ERROR_TOO_SHORT;
   }
-  nonstd::unique_ptr<CJBig2_GRRDProc> pGRRD(new CJBig2_GRRDProc);
+  std::unique_ptr<CJBig2_GRRDProc> pGRRD(new CJBig2_GRRDProc);
   pGRRD->GRW = ri.width;
   pGRRD->GRH = ri.height;
   pGRRD->GRTEMPLATE = cFlags & 0x01;
   pGRRD->TPGRON = (cFlags >> 1) & 0x01;
   if (pGRRD->GRTEMPLATE == 0) {
     for (int32_t i = 0; i < 4; ++i) {
       if (m_pStream->read1Byte((uint8_t*)&pGRRD->GRAT[i]) != 0)
         return JBIG2_ERROR_TOO_SHORT;
     }
   }
@@ skipping 13 matching lines @@
     if (i >= pSegment->m_nReferred_to_segment_count)
       return JBIG2_ERROR_FATAL;
 
     pGRRD->GRREFERENCE = pSeg->m_Result.im;
   } else {
     pGRRD->GRREFERENCE = m_pPage.get();
   }
   pGRRD->GRREFERENCEDX = 0;
   pGRRD->GRREFERENCEDY = 0;
   const size_t size = GetRefAggContextSize(pGRRD->GRTEMPLATE);
-  nonstd::unique_ptr<JBig2ArithCtx, FxFreeDeleter> grContext(
+  std::unique_ptr<JBig2ArithCtx, FxFreeDeleter> grContext(
       FX_Alloc(JBig2ArithCtx, size));
   JBIG2_memset(grContext.get(), 0, sizeof(JBig2ArithCtx) * size);
-  nonstd::unique_ptr<CJBig2_ArithDecoder> pArithDecoder(
+  std::unique_ptr<CJBig2_ArithDecoder> pArithDecoder(
       new CJBig2_ArithDecoder(m_pStream.get()));
   pSegment->m_nResultType = JBIG2_IMAGE_POINTER;
   pSegment->m_Result.im = pGRRD->decode(pArithDecoder.get(), grContext.get());
   if (!pSegment->m_Result.im)
     return JBIG2_ERROR_FATAL;
 
   m_pStream->alignByte();
   m_pStream->offset(2);
   if (pSegment->m_cFlags.s.type != 40) {
     if (!m_bBufSpecified) {
       JBig2PageInfo* pPageInfo = m_PageInfoList.back();
       if ((pPageInfo->m_bIsStriped == 1) &&
           (ri.y + ri.height > m_pPage->m_nHeight)) {
         m_pPage->expand(ri.y + ri.height, (pPageInfo->m_cFlags & 4) ? 1 : 0);
       }
     }
     m_pPage->composeFrom(ri.x, ri.y, pSegment->m_Result.im,
                          (JBig2ComposeOp)(ri.flags & 0x03));
     delete pSegment->m_Result.im;
     pSegment->m_Result.im = NULL;
   }
   return JBIG2_SUCCESS;
 }
 
 int32_t CJBig2_Context::parseTable(CJBig2_Segment* pSegment) {
   pSegment->m_nResultType = JBIG2_HUFFMAN_TABLE_POINTER;
   pSegment->m_Result.ht = nullptr;
-  nonstd::unique_ptr<CJBig2_HuffmanTable> pHuff(
+  std::unique_ptr<CJBig2_HuffmanTable> pHuff(
       new CJBig2_HuffmanTable(m_pStream.get()));
   if (!pHuff->IsOK())
     return JBIG2_ERROR_FATAL;
 
   pSegment->m_Result.ht = pHuff.release();
   m_pStream->alignByte();
   return JBIG2_SUCCESS;
 }
 
 int32_t CJBig2_Context::parseRegionInfo(JBig2RegionInfo* pRI) {
@@ skipping 12 matching lines @@
     FX_DWORD SBNUMSYMS) {
   const size_t kRunCodesSize = 35;
   int32_t runcodes[kRunCodesSize];
   int32_t runcodes_len[kRunCodesSize];
   for (int32_t i = 0; i < kRunCodesSize; ++i) {
     if (pStream->readNBits(4, &runcodes_len[i]) != 0)
       return nullptr;
   }
   huffman_assign_code(runcodes, runcodes_len, kRunCodesSize);
 
-  nonstd::unique_ptr<JBig2HuffmanCode, FxFreeDeleter> SBSYMCODES(
+  std::unique_ptr<JBig2HuffmanCode, FxFreeDeleter> SBSYMCODES(
       FX_Alloc(JBig2HuffmanCode, SBNUMSYMS));
   int32_t run;
   int32_t i = 0;
   while (i < (int)SBNUMSYMS) {
     int32_t j;
     int32_t nVal = 0;
     int32_t nBits = 0;
     FX_DWORD nTemp;
     while (true) {
       if (pStream->read1Bit(&nTemp) != 0)
@@ skipping 111 matching lines @@
         SBSYMCODES[CURTEMP].code = CURCODE;
         CURCODE = CURCODE + 1;
       }
       CURTEMP = CURTEMP + 1;
     }
     CURLEN = CURLEN + 1;
   }
   FX_Free(LENCOUNT);
   FX_Free(FIRSTCODE);
 }