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

core/src/fpdfapi/fpdf_parser/fpdf_parser_parser.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 "parser_int.h"
 
+#include <memory>
 #include <set>
 #include <utility>
 #include <vector>
 
 #include "core/include/fpdfapi/fpdf_module.h"
 #include "core/include/fpdfapi/fpdf_page.h"
 #include "core/include/fpdfapi/fpdf_parser.h"
 #include "core/include/fxcrt/fx_ext.h"
 #include "core/include/fxcrt/fx_safe_types.h"
 #include "core/src/fpdfapi/fpdf_page/pageint.h"
-#include "third_party/base/nonstd_unique_ptr.h"
 #include "third_party/base/stl_util.h"
 
 namespace {
 
 // A limit on the size of the xref table. Theoretical limits are higher, but
 // this may be large enough in practice.
 const int32_t kMaxXRefSize = 1048576;
 
 // A limit on the maximum object number in the xref table. Theoretical limits
 // are higher, but this may be large enough in practice.
@@ skipping 57 matching lines @@
                           const FX_SAFE_DWORD& num_bits) {
   return (num_bits.IsValid() &&
           hStream->BitsRemaining() >= num_bits.ValueOrDie());
 }
 
 }  // namespace
 
 // TODO(thestig) Using unique_ptr with ReleaseDeleter is still not ideal.
 // Come up or wait for something better.
 using ScopedFileStream =
-    nonstd::unique_ptr<IFX_FileStream, ReleaseDeleter<IFX_FileStream>>;
+    std::unique_ptr<IFX_FileStream, ReleaseDeleter<IFX_FileStream>>;
 
 FX_BOOL IsSignatureDict(const CPDF_Dictionary* pDict) {
   CPDF_Object* pType = pDict->GetElementValue("Type");
   if (!pType) {
     pType = pDict->GetElementValue("FT");
     if (!pType) {
       return FALSE;
     }
   }
   if (pType->GetString() == "Sig") {
@@ skipping 192 matching lines @@
     }
   }
   if (m_bForceUseSecurityHandler) {
     FX_DWORD err = PDFPARSE_ERROR_HANDLER;
     if (!m_pSecurityHandler) {
       return PDFPARSE_ERROR_HANDLER;
     }
     if (!m_pSecurityHandler->OnInit(this, m_pEncryptDict)) {
       return err;
     }
-    nonstd::unique_ptr<CPDF_CryptoHandler> pCryptoHandler(
+    std::unique_ptr<CPDF_CryptoHandler> pCryptoHandler(
         m_pSecurityHandler->CreateCryptoHandler());
     if (!pCryptoHandler->Init(m_pEncryptDict, m_pSecurityHandler.get())) {
       return PDFPARSE_ERROR_HANDLER;
     }
     m_Syntax.SetEncrypt(pCryptoHandler.release());
   } else if (m_pEncryptDict) {
     CFX_ByteString filter = m_pEncryptDict->GetString("Filter");
-    nonstd::unique_ptr<CPDF_SecurityHandler> pSecurityHandler;
+    std::unique_ptr<CPDF_SecurityHandler> pSecurityHandler;
     FX_DWORD err = PDFPARSE_ERROR_HANDLER;
     if (filter == "Standard") {
       pSecurityHandler.reset(FPDF_CreateStandardSecurityHandler());
       err = PDFPARSE_ERROR_PASSWORD;
     }
     if (!pSecurityHandler) {
       return PDFPARSE_ERROR_HANDLER;
     }
     if (!pSecurityHandler->OnInit(this, m_pEncryptDict)) {
       return err;
     }
     m_pSecurityHandler = std::move(pSecurityHandler);
-    nonstd::unique_ptr<CPDF_CryptoHandler> pCryptoHandler(
+    std::unique_ptr<CPDF_CryptoHandler> pCryptoHandler(
         m_pSecurityHandler->CreateCryptoHandler());
     if (!pCryptoHandler->Init(m_pEncryptDict, m_pSecurityHandler.get())) {
       return PDFPARSE_ERROR_HANDLER;
     }
     m_Syntax.SetEncrypt(pCryptoHandler.release());
   }
   return PDFPARSE_ERROR_SUCCESS;
 }
 void CPDF_Parser::ReleaseEncryptHandler() {
   m_Syntax.m_pCryptoHandler.reset();
@@ skipping 36 matching lines @@
     return FALSE;
   }
   FX_FILESIZE newxrefpos = GetDirectInteger(m_pTrailer, "Prev");
   if (newxrefpos == xrefpos) {
     return FALSE;
   }
   xrefpos = newxrefpos;
   while (xrefpos) {
     CrossRefList.InsertAt(0, xrefpos);
     LoadCrossRefV4(xrefpos, 0, TRUE);
-    nonstd::unique_ptr<CPDF_Dictionary, ReleaseDeleter<CPDF_Dictionary>> pDict(
+    std::unique_ptr<CPDF_Dictionary, ReleaseDeleter<CPDF_Dictionary>> pDict(
         LoadTrailerV4());
     if (!pDict)
       return FALSE;
 
     if (!CheckDirectType(pDict.get(), "Prev", PDFOBJ_NUMBER))
       return FALSE;
 
     newxrefpos = GetDirectInteger(pDict.get(), "Prev");
     if (newxrefpos == xrefpos)
       return FALSE;
@@ skipping 1050 matching lines @@
     *pResultPos = m_Syntax.m_Pos;
   }
   m_Syntax.RestorePos(SavedPos);
   return pObj;
 }
 
 CPDF_Dictionary* CPDF_Parser::LoadTrailerV4() {
   if (m_Syntax.GetKeyword() != "trailer")
     return nullptr;
 
-  nonstd::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> pObj(
+  std::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> pObj(
       m_Syntax.GetObject(m_pDocument, 0, 0, 0));
   if (!ToDictionary(pObj.get()))
     return nullptr;
   return pObj.release()->AsDictionary();
 }
 
 FX_DWORD CPDF_Parser::GetPermissions(FX_BOOL bCheckRevision) {
   if (!m_pSecurityHandler) {
     return (FX_DWORD)-1;
   }
@@ skipping 618 matching lines @@
   }
   if (word == "<<") {
     if (bTypeOnly)
       return (CPDF_Object*)PDFOBJ_DICTIONARY;
 
     if (pContext)
       pContext->m_DictStart = SavedPos;
 
     int32_t nKeys = 0;
     FX_FILESIZE dwSignValuePos = 0;
-    nonstd::unique_ptr<CPDF_Dictionary, ReleaseDeleter<CPDF_Dictionary>> pDict(
+    std::unique_ptr<CPDF_Dictionary, ReleaseDeleter<CPDF_Dictionary>> pDict(
         new CPDF_Dictionary);
     while (1) {
       FX_BOOL bIsNumber;
       CFX_ByteString key = GetNextWord(bIsNumber);
       if (key.IsEmpty())
         return nullptr;
 
       FX_FILESIZE SavedPos = m_Pos - key.GetLength();
       if (key == ">>")
         break;
@@ skipping 117 matching lines @@
     if (bTypeOnly)
       return (CPDF_Object*)PDFOBJ_STRING;
     CFX_ByteString str = ReadHexString();
     if (m_pCryptoHandler)
       m_pCryptoHandler->Decrypt(objnum, gennum, str);
     return new CPDF_String(str, TRUE);
   }
   if (word == "[") {
     if (bTypeOnly)
       return (CPDF_Object*)PDFOBJ_ARRAY;
-    nonstd::unique_ptr<CPDF_Array, ReleaseDeleter<CPDF_Array>> pArray(
+    std::unique_ptr<CPDF_Array, ReleaseDeleter<CPDF_Array>> pArray(
         new CPDF_Array);
     while (CPDF_Object* pObj = GetObject(pObjList, objnum, gennum))
       pArray->Add(pObj);
     return m_WordBuffer[0] == ']' ? pArray.release() : nullptr;
   }
   if (word[0] == '/') {
     if (bTypeOnly)
       return (CPDF_Object*)PDFOBJ_NAME;
     return new CPDF_Name(
         PDF_NameDecode(CFX_ByteStringC(m_WordBuffer + 1, m_WordSize - 1)));
   }
   if (word == "<<") {
     if (bTypeOnly)
       return (CPDF_Object*)PDFOBJ_DICTIONARY;
     if (pContext)
       pContext->m_DictStart = SavedPos;
 
-    nonstd::unique_ptr<CPDF_Dictionary, ReleaseDeleter<CPDF_Dictionary>> pDict(
+    std::unique_ptr<CPDF_Dictionary, ReleaseDeleter<CPDF_Dictionary>> pDict(
         new CPDF_Dictionary);
     while (1) {
       FX_BOOL bIsNumber;
       FX_FILESIZE SavedPos = m_Pos;
       CFX_ByteString key = GetNextWord(bIsNumber);
       if (key.IsEmpty())
         return nullptr;
 
       if (key == ">>")
         break;
 
       if (key == "endobj") {
         m_Pos = SavedPos;
         break;
       }
       if (key[0] != '/')
         continue;
 
       key = PDF_NameDecode(key);
-      nonstd::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> obj(
+      std::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> obj(
           GetObject(pObjList, objnum, gennum));
       if (!obj) {
         uint8_t ch;
         while (GetNextChar(ch) && ch != 0x0A && ch != 0x0D) {
         }
         return nullptr;
       }
       if (key.GetLength() > 1) {
         pDict->AddValue(CFX_ByteStringC(key.c_str() + 1, key.GetLength() - 1),
                         obj.release());
@@ skipping 592 matching lines @@
 
   FX_BOOL m_bTotalLoadPageTree;
 
   FX_BOOL m_bCurPageDictLoadOK;
 
   CPDF_PageNode m_pageNodes;
 
   std::set<FX_DWORD> m_pageMapCheckState;
   std::set<FX_DWORD> m_pagesLoadState;
 
-  nonstd::unique_ptr<CPDF_HintTables> m_pHintTables;
+  std::unique_ptr<CPDF_HintTables> m_pHintTables;
   FX_BOOL m_bSupportHintTable;
 };
 
 IPDF_DataAvail::IPDF_DataAvail(IFX_FileAvail* pFileAvail,
                                IFX_FileRead* pFileRead)
     : m_pFileAvail(pFileAvail), m_pFileRead(pFileRead) {}
 
 // static
 IPDF_DataAvail* IPDF_DataAvail::Create(IFX_FileAvail* pFileAvail,
                                        IFX_FileRead* pFileRead) {
@@ skipping 694 matching lines @@
           ? pHintStreamRange->GetElementValue(1)->GetInteger()
           : 0;
   if (szHSStart < 0 || szHSLength <= 0) {
     m_docStatus = PDF_DATAAVAIL_ERROR;
     return FALSE;
   }
   if (!IsDataAvail(szHSStart, szHSLength, pHints)) {
     return FALSE;
   }
   m_syntaxParser.InitParser(m_pFileRead, m_dwHeaderOffset);
-  nonstd::unique_ptr<CPDF_HintTables> pHintTables(
+  std::unique_ptr<CPDF_HintTables> pHintTables(
       new CPDF_HintTables(this, pDict));
-  nonstd::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> pHintStream(
+  std::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> pHintStream(
       ParseIndirectObjectAt(szHSStart, 0));
   CPDF_Stream* pStream = ToStream(pHintStream.get());
   if (pStream && pHintTables->LoadHintStream(pStream))
     m_pHintTables = std::move(pHintTables);
 
   m_docStatus = PDF_DATAAVAIL_DONE;
   return TRUE;
 }
 CPDF_Object* CPDF_DataAvail::ParseIndirectObjectAt(
     FX_FILESIZE pos,
@@ skipping 359 matching lines @@
     uint8_t* pBuf = buf.GetBuffer();
     if (!pBuf) {
       m_docStatus = PDF_DATAAVAIL_ERROR;
       return FALSE;
     }
     if (!m_pFileRead->ReadBlock(pBuf, m_dwTrailerOffset, iSize)) {
       return FALSE;
     }
     ScopedFileStream file(FX_CreateMemoryStream(pBuf, (size_t)iSize, FALSE));
     m_syntaxParser.InitParser(file.get(), 0);
-    nonstd::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> pTrailer(
+    std::unique_ptr<CPDF_Object, ReleaseDeleter<CPDF_Object>> pTrailer(
         m_syntaxParser.GetObject(nullptr, 0, 0));
     if (!pTrailer) {
       m_Pos += m_syntaxParser.SavePos();
       pHints->AddSegment(m_Pos, iTrailerSize);
       return FALSE;
     }
     if (!pTrailer->IsDictionary())
       return FALSE;
 
     CPDF_Dictionary* pTrailerDict = pTrailer->GetDict();
@@ skipping 992 matching lines @@
   if (!m_pLinearizedDict)
     return -1;
   CPDF_Array* pRange = m_pLinearizedDict->GetArray("H");
   if (!pRange)
     return -1;
   CPDF_Object* pStreamLen = pRange->GetElementValue(1);
   if (!pStreamLen)
     return -1;
   return pStreamLen->GetInteger();
 }