War on #defines - part 2

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 "core/include/fpdfapi/fpdf_parser.h"
 
 #include <algorithm>
 #include <memory>
@@ skipping 161 matching lines @@
   for (int32_t i = 0; i < iLen; ++i) {
     if (CPDF_Dictionary* trailer = m_Trailers.GetAt(i))
       trailer->Release();
   }
   m_Trailers.RemoveAll();
   if (m_pLinearized) {
     m_pLinearized->Release();
     m_pLinearized = NULL;
   }
 }
-CPDF_SecurityHandler* FPDF_CreateStandardSecurityHandler();
-CPDF_SecurityHandler* FPDF_CreatePubKeyHandler(void*);
-FX_DWORD CPDF_Parser::StartParse(IFX_FileRead* pFileAccess,
-                                 FX_BOOL bReParse,
-                                 FX_BOOL bOwnFileRead) {
+
+CPDF_Parser::Error CPDF_Parser::StartParse(IFX_FileRead* pFileAccess,
+                                           FX_BOOL bReParse,
+                                           FX_BOOL bOwnFileRead) {
   CloseParser(bReParse);
   m_bXRefStream = FALSE;
   m_LastXRefOffset = 0;
   m_bOwnFileRead = bOwnFileRead;
 
   int32_t offset = GetHeaderOffset(pFileAccess);
   if (offset == -1) {
     if (bOwnFileRead && pFileAccess)
       pFileAccess->Release();
-    return PDFPARSE_ERROR_FORMAT;
+    return FORMAT_ERROR;
   }
   m_Syntax.InitParser(pFileAccess, offset);
 
   uint8_t ch;
   if (!m_Syntax.GetCharAt(5, ch))
-    return PDFPARSE_ERROR_FORMAT;
+    return FORMAT_ERROR;
   if (std::isdigit(ch))
     m_FileVersion = FXSYS_toDecimalDigit(ch) * 10;
 
   if (!m_Syntax.GetCharAt(7, ch))
-    return PDFPARSE_ERROR_FORMAT;
+    return FORMAT_ERROR;
   if (std::isdigit(ch))
     m_FileVersion += FXSYS_toDecimalDigit(ch);
 
   if (m_Syntax.m_FileLen < m_Syntax.m_HeaderOffset + 9)
-    return PDFPARSE_ERROR_FORMAT;
+    return FORMAT_ERROR;
 
   m_Syntax.RestorePos(m_Syntax.m_FileLen - m_Syntax.m_HeaderOffset - 9);
   if (!bReParse)
     m_pDocument = new CPDF_Document(this);
 
   FX_BOOL bXRefRebuilt = FALSE;
   if (m_Syntax.SearchWord("startxref", TRUE, FALSE, 4096)) {
     FX_FILESIZE startxref_offset = m_Syntax.SavePos();
     void* pResult = FXSYS_bsearch(&startxref_offset, m_SortedOffset.GetData(),
                                   m_SortedOffset.GetSize(), sizeof(FX_FILESIZE),
                                   CompareFileSize);
     if (!pResult)
       m_SortedOffset.Add(startxref_offset);
 
     m_Syntax.GetKeyword();
     bool bNumber;
     CFX_ByteString xrefpos_str = m_Syntax.GetNextWord(&bNumber);
     if (!bNumber)
-      return PDFPARSE_ERROR_FORMAT;
+      return FORMAT_ERROR;
 
     m_LastXRefOffset = (FX_FILESIZE)FXSYS_atoi64(xrefpos_str);
     if (!LoadAllCrossRefV4(m_LastXRefOffset) &&
         !LoadAllCrossRefV5(m_LastXRefOffset)) {
       if (!RebuildCrossRef())
-        return PDFPARSE_ERROR_FORMAT;
+        return FORMAT_ERROR;
 
       bXRefRebuilt = TRUE;
       m_LastXRefOffset = 0;
     }
   } else {
     if (!RebuildCrossRef())
-      return PDFPARSE_ERROR_FORMAT;
+      return FORMAT_ERROR;
 
     bXRefRebuilt = TRUE;
   }
-  FX_DWORD dwRet = SetEncryptHandler();
-  if (dwRet != PDFPARSE_ERROR_SUCCESS)
-    return dwRet;
+  Error eRet = SetEncryptHandler();
+  if (eRet != SUCCESS)
+    return eRet;
 
   m_pDocument->LoadDoc();
   if (!m_pDocument->GetRoot() || m_pDocument->GetPageCount() == 0) {
     if (bXRefRebuilt)
-      return PDFPARSE_ERROR_FORMAT;
+      return FORMAT_ERROR;
 
     ReleaseEncryptHandler();
     if (!RebuildCrossRef())
-      return PDFPARSE_ERROR_FORMAT;
+      return FORMAT_ERROR;
 
-    dwRet = SetEncryptHandler();
-    if (dwRet != PDFPARSE_ERROR_SUCCESS)
-      return dwRet;
+    eRet = SetEncryptHandler();
+    if (eRet != SUCCESS)
+      return eRet;
 
     m_pDocument->LoadDoc();
     if (!m_pDocument->GetRoot())
-      return PDFPARSE_ERROR_FORMAT;
+      return FORMAT_ERROR;
   }
   FXSYS_qsort(m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
               sizeof(FX_FILESIZE), CompareFileSize);
   if (GetRootObjNum() == 0) {
     ReleaseEncryptHandler();
     if (!RebuildCrossRef() || GetRootObjNum() == 0)
-      return PDFPARSE_ERROR_FORMAT;
+      return FORMAT_ERROR;
 
-    dwRet = SetEncryptHandler();
-    if (dwRet != PDFPARSE_ERROR_SUCCESS)
-      return dwRet;
+    eRet = SetEncryptHandler();
+    if (eRet != SUCCESS)
+      return eRet;
   }
   if (m_pSecurityHandler && !m_pSecurityHandler->IsMetadataEncrypted()) {
     CPDF_Reference* pMetadata =
         ToReference(m_pDocument->GetRoot()->GetElement("Metadata"));
     if (pMetadata)
       m_Syntax.m_MetadataObjnum = pMetadata->GetRefObjNum();
   }
-  return PDFPARSE_ERROR_SUCCESS;
+  return SUCCESS;
 }
-FX_DWORD CPDF_Parser::SetEncryptHandler() {
+CPDF_Parser::Error CPDF_Parser::SetEncryptHandler() {
   ReleaseEncryptHandler();
   SetEncryptDictionary(NULL);
   if (!m_pTrailer) {
-    return PDFPARSE_ERROR_FORMAT;
+    return FORMAT_ERROR;
   }
   CPDF_Object* pEncryptObj = m_pTrailer->GetElement("Encrypt");
   if (pEncryptObj) {
     if (CPDF_Dictionary* pEncryptDict = pEncryptObj->AsDictionary()) {
       SetEncryptDictionary(pEncryptDict);
     } else if (CPDF_Reference* pRef = pEncryptObj->AsReference()) {
       pEncryptObj = m_pDocument->GetIndirectObject(pRef->GetRefObjNum());
       if (pEncryptObj)
         SetEncryptDictionary(pEncryptObj->GetDict());
     }
   }
   if (m_bForceUseSecurityHandler) {
-    FX_DWORD err = PDFPARSE_ERROR_HANDLER;
     if (!m_pSecurityHandler) {
-      return PDFPARSE_ERROR_HANDLER;
+      return HANDLER_ERROR;
     }
     if (!m_pSecurityHandler->OnInit(this, m_pEncryptDict)) {
-      return err;
+      return HANDLER_ERROR;
     }
     std::unique_ptr<CPDF_CryptoHandler> pCryptoHandler(
         m_pSecurityHandler->CreateCryptoHandler());
     if (!pCryptoHandler->Init(m_pEncryptDict, m_pSecurityHandler.get())) {
-      return PDFPARSE_ERROR_HANDLER;
+      return HANDLER_ERROR;
     }
     m_Syntax.SetEncrypt(pCryptoHandler.release());
   } else if (m_pEncryptDict) {
     CFX_ByteString filter = m_pEncryptDict->GetString("Filter");
     std::unique_ptr<CPDF_SecurityHandler> pSecurityHandler;
-    FX_DWORD err = PDFPARSE_ERROR_HANDLER;
+    Error err = HANDLER_ERROR;
     if (filter == "Standard") {
       pSecurityHandler.reset(FPDF_CreateStandardSecurityHandler());
-      err = PDFPARSE_ERROR_PASSWORD;
+      err = PASSWORD_ERROR;
     }
     if (!pSecurityHandler) {
-      return PDFPARSE_ERROR_HANDLER;
+      return HANDLER_ERROR;
     }
     if (!pSecurityHandler->OnInit(this, m_pEncryptDict)) {
       return err;
     }
     m_pSecurityHandler = std::move(pSecurityHandler);
     std::unique_ptr<CPDF_CryptoHandler> pCryptoHandler(
         m_pSecurityHandler->CreateCryptoHandler());
     if (!pCryptoHandler->Init(m_pEncryptDict, m_pSecurityHandler.get())) {
-      return PDFPARSE_ERROR_HANDLER;
+      return HANDLER_ERROR;
     }
     m_Syntax.SetEncrypt(pCryptoHandler.release());
   }
-  return PDFPARSE_ERROR_SUCCESS;
+  return SUCCESS;
 }
 void CPDF_Parser::ReleaseEncryptHandler() {
   m_Syntax.m_pCryptoHandler.reset();
   if (!m_bForceUseSecurityHandler) {
     m_pSecurityHandler.reset();
   }
 }
 
 FX_FILESIZE CPDF_Parser::GetObjectOffset(FX_DWORD objnum) const {
   if (!IsValidObjectNumber(objnum))
@@ skipping 1204 matching lines @@
 
     if (CPDF_Number* pTable = ToNumber(pDict->GetElement("T")))
       m_LastXRefOffset = pTable->GetInteger();
 
     return TRUE;
   }
   m_pLinearized->Release();
   m_pLinearized = NULL;
   return FALSE;
 }
-FX_DWORD CPDF_Parser::StartAsynParse(IFX_FileRead* pFileAccess,
-                                     FX_BOOL bReParse,
-                                     FX_BOOL bOwnFileRead) {
+CPDF_Parser::Error CPDF_Parser::StartAsynParse(IFX_FileRead* pFileAccess,
+                                               FX_BOOL bReParse,
+                                               FX_BOOL bOwnFileRead) {
   CloseParser(bReParse);
   m_bXRefStream = FALSE;
   m_LastXRefOffset = 0;
   m_bOwnFileRead = bOwnFileRead;
   int32_t offset = GetHeaderOffset(pFileAccess);
   if (offset == -1) {
-    return PDFPARSE_ERROR_FORMAT;
+    return FORMAT_ERROR;
   }
   if (!IsLinearizedFile(pFileAccess, offset)) {
     m_Syntax.m_pFileAccess = NULL;
     return StartParse(pFileAccess, bReParse, bOwnFileRead);
   }
   if (!bReParse) {
     m_pDocument = new CPDF_Document(this);
   }
   FX_FILESIZE dwFirstXRefOffset = m_Syntax.SavePos();
   FX_BOOL bXRefRebuilt = FALSE;
   FX_BOOL bLoadV4 = FALSE;
   if (!(bLoadV4 = LoadCrossRefV4(dwFirstXRefOffset, 0, FALSE)) &&
       !LoadCrossRefV5(&dwFirstXRefOffset, TRUE)) {
     if (!RebuildCrossRef()) {
-      return PDFPARSE_ERROR_FORMAT;
+      return FORMAT_ERROR;
     }
     bXRefRebuilt = TRUE;
     m_LastXRefOffset = 0;
   }
   if (bLoadV4) {
     m_pTrailer = LoadTrailerV4();
     if (!m_pTrailer) {
-      return PDFPARSE_ERROR_SUCCESS;
+      return SUCCESS;
     }
 
     int32_t xrefsize = GetDirectInteger(m_pTrailer, "Size");
     if (xrefsize > 0) {
       ShrinkObjectMap(xrefsize);
       m_V5Type.SetSize(xrefsize);
     }
   }
-  FX_DWORD dwRet = SetEncryptHandler();
-  if (dwRet != PDFPARSE_ERROR_SUCCESS) {
-    return dwRet;
+  Error eRet = SetEncryptHandler();
+  if (eRet != SUCCESS) {
+    return eRet;
   }
   m_pDocument->LoadAsynDoc(m_pLinearized->GetDict());
   if (!m_pDocument->GetRoot() || m_pDocument->GetPageCount() == 0) {
     if (bXRefRebuilt) {
-      return PDFPARSE_ERROR_FORMAT;
+      return FORMAT_ERROR;
     }
     ReleaseEncryptHandler();
     if (!RebuildCrossRef()) {
-      return PDFPARSE_ERROR_FORMAT;
+      return FORMAT_ERROR;
     }
-    dwRet = SetEncryptHandler();
-    if (dwRet != PDFPARSE_ERROR_SUCCESS) {
-      return dwRet;
+    eRet = SetEncryptHandler();
+    if (eRet != SUCCESS) {
+      return eRet;
     }
     m_pDocument->LoadAsynDoc(m_pLinearized->GetDict());
     if (!m_pDocument->GetRoot()) {
-      return PDFPARSE_ERROR_FORMAT;
+      return FORMAT_ERROR;
     }
   }
   FXSYS_qsort(m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
               sizeof(FX_FILESIZE), CompareFileSize);
   if (GetRootObjNum() == 0) {
     ReleaseEncryptHandler();
     if (!RebuildCrossRef() || GetRootObjNum() == 0)
-      return PDFPARSE_ERROR_FORMAT;
+      return FORMAT_ERROR;
 
-    dwRet = SetEncryptHandler();
-    if (dwRet != PDFPARSE_ERROR_SUCCESS) {
-      return dwRet;
+    eRet = SetEncryptHandler();
+    if (eRet != SUCCESS) {
+      return eRet;
     }
   }
   if (m_pSecurityHandler && m_pSecurityHandler->IsMetadataEncrypted()) {
     if (CPDF_Reference* pMetadata =
             ToReference(m_pDocument->GetRoot()->GetElement("Metadata")))
       m_Syntax.m_MetadataObjnum = pMetadata->GetRefObjNum();
   }
-  return PDFPARSE_ERROR_SUCCESS;
+  return SUCCESS;
 }
 FX_BOOL CPDF_Parser::LoadLinearizedAllCrossRefV5(FX_FILESIZE xrefpos) {
   if (!LoadCrossRefV5(&xrefpos, FALSE)) {
     return FALSE;
   }
   std::set<FX_FILESIZE> seen_xrefpos;
   while (xrefpos) {
     seen_xrefpos.insert(xrefpos);
     if (!LoadCrossRefV5(&xrefpos, FALSE)) {
       return FALSE;
     }
     // Check for circular references.
     if (pdfium::ContainsKey(seen_xrefpos, xrefpos)) {
       return FALSE;
     }
   }
   m_ObjectStreamMap.clear();
   m_bXRefStream = TRUE;
   return TRUE;
 }
-FX_DWORD CPDF_Parser::LoadLinearizedMainXRefTable() {
+
+CPDF_Parser::Error CPDF_Parser::LoadLinearizedMainXRefTable() {
   FX_DWORD dwSaveMetadataObjnum = m_Syntax.m_MetadataObjnum;
   m_Syntax.m_MetadataObjnum = 0;
   if (m_pTrailer) {
     m_pTrailer->Release();
     m_pTrailer = NULL;
   }
   m_Syntax.RestorePos(m_LastXRefOffset - m_Syntax.m_HeaderOffset);
   uint8_t ch = 0;
   FX_DWORD dwCount = 0;
   m_Syntax.GetNextChar(ch);
   while (PDFCharIsWhitespace(ch)) {
     ++dwCount;
     if (m_Syntax.m_FileLen >=
         (FX_FILESIZE)(m_Syntax.SavePos() + m_Syntax.m_HeaderOffset)) {
       break;
     }
     m_Syntax.GetNextChar(ch);
   }
   m_LastXRefOffset += dwCount;
   m_ObjectStreamMap.clear();
   m_ObjCache.clear();
 
   if (!LoadLinearizedAllCrossRefV4(m_LastXRefOffset, m_dwXrefStartObjNum) &&
       !LoadLinearizedAllCrossRefV5(m_LastXRefOffset)) {
     m_LastXRefOffset = 0;
     m_Syntax.m_MetadataObjnum = dwSaveMetadataObjnum;
-    return PDFPARSE_ERROR_FORMAT;
+    return FORMAT_ERROR;
   }
   FXSYS_qsort(m_SortedOffset.GetData(), m_SortedOffset.GetSize(),
               sizeof(FX_FILESIZE), CompareFileSize);
   m_Syntax.m_MetadataObjnum = dwSaveMetadataObjnum;
-  return PDFPARSE_ERROR_SUCCESS;
+  return SUCCESS;
 }
 
 // static
 int CPDF_SyntaxParser::s_CurrentRecursionDepth = 0;
 
 CPDF_SyntaxParser::CPDF_SyntaxParser() {
   m_pFileAccess = NULL;
   m_pFileBuf = NULL;
   m_BufSize = CPDF_ModuleMgr::kFileBufSize;
   m_pFileBuf = NULL;
@@ skipping 2492 matching lines @@
     FX_SAFE_DWORD data_size = m_dwFileLen;
     data_size -= m_dwLastXRefOffset;
     if (!data_size.IsValid()) {
       return DataError;
     }
     if (!m_pFileAvail->IsDataAvail(m_dwLastXRefOffset,
                                    data_size.ValueOrDie())) {
       pHints->AddSegment(m_dwLastXRefOffset, data_size.ValueOrDie());
       return DataNotAvailable;
     }
-    FX_DWORD dwRet = m_pDocument->GetParser()->LoadLinearizedMainXRefTable();
+    CPDF_Parser::Error eRet =
+        m_pDocument->GetParser()->LoadLinearizedMainXRefTable();
     m_bMainXRefLoadTried = TRUE;
-    if (dwRet != PDFPARSE_ERROR_SUCCESS) {
+    if (eRet != CPDF_Parser::SUCCESS) {
       return DataError;
     }
     if (!PreparePageItem()) {
       return DataNotAvailable;
     }
     m_bMainXRefLoadedOK = TRUE;
     m_bLinearedDataOK = TRUE;
   }
 
   return m_bLinearedDataOK ? DataAvailable : DataNotAvailable;
@@ skipping 663 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();
 }