Merge to XFA: Clean up misc nits found while fixing bugs.

core/src/fpdfapi/fpdf_edit/fpdf_edit_create.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 "editint.h"
+#include "core/src/fpdfapi/fpdf_edit/editint.h"
+
+#include <vector>
 
 #include "core/include/fxcrt/fx_ext.h"
 #include "core/include/fpdfapi/fpdf_serial.h"
 #include "core/include/fpdfapi/fpdf_parser.h"
 
 #define PDF_OBJECTSTREAM_MAXLENGTH (256 * 1024)
 #define PDF_XREFSTREAM_MAXSIZE 10000
 
+namespace {
+
 int32_t PDF_CreatorAppendObject(const CPDF_Object* pObj,
                                 CFX_FileBufferArchive* pFile,
                                 FX_FILESIZE& offset) {
   int32_t len = 0;
   if (!pObj) {
     if (pFile->AppendString(" null") < 0) {
       return -1;
     }
     offset += 5;
     return 1;
@@ skipping 136 matching lines @@
       }
       offset += len;
       break;
     }
     default:
       ASSERT(FALSE);
       break;
   }
   return 1;
 }
+
 int32_t PDF_CreatorWriteTrailer(CPDF_Document* pDocument,
                                 CFX_FileBufferArchive* pFile,
                                 CPDF_Array* pIDArray,
                                 FX_BOOL bCompress) {
   FX_FILESIZE offset = 0;
   int32_t len = 0;
   FXSYS_assert(pDocument && pFile);
   CPDF_Parser* pParser = (CPDF_Parser*)pDocument->GetParser();
   if (pParser) {
     CPDF_Dictionary* p = pParser->GetTrailer();
@@ skipping 70 matching lines @@
     if (pFile->AppendString(("/ID")) < 0) {
       return -1;
     }
     offset += 3;
     if (PDF_CreatorAppendObject(pIDArray, pFile, offset) < 0) {
       return -1;
     }
   }
   return offset;
 }
+
 int32_t PDF_CreatorWriteEncrypt(const CPDF_Dictionary* pEncryptDict,
                                 FX_DWORD dwObjNum,
                                 CFX_FileBufferArchive* pFile) {
   if (!pEncryptDict) {
     return 0;
   }
   FXSYS_assert(pFile);
   FX_FILESIZE offset = 0;
   int32_t len = 0;
   if (pFile->AppendString("/Encrypt") < 0) {
     return -1;
   }
   offset += 8;
   if (pFile->AppendString(" ") < 0) {
     return -1;
   }
   if ((len = pFile->AppendDWord(dwObjNum)) < 0) {
     return -1;
   }
   if (pFile->AppendString(" 0 R ") < 0) {
     return -1;
   }
   offset += len + 6;
   return offset;
 }
-FX_BOOL PDF_GenerateFileID(FX_DWORD dwSeed1,
-                           FX_DWORD dwSeed2,
-                           FX_DWORD* pBuffer) {
-  if (!pBuffer) {
-    return FALSE;
-  }
+
+std::vector<uint8_t> PDF_GenerateFileID(FX_DWORD dwSeed1, FX_DWORD dwSeed2) {
+  std::vector<uint8_t> buffer(sizeof(FX_DWORD) * 4);
+  FX_DWORD* pBuffer = reinterpret_cast<FX_DWORD*>(buffer.data());
   void* pContext = FX_Random_MT_Start(dwSeed1);
-  int32_t i = 0;
-  for (i = 0; i < 2; i++) {
+  for (int i = 0; i < 2; ++i)
     *pBuffer++ = FX_Random_MT_Generate(pContext);
-  }
   FX_Random_MT_Close(pContext);
   pContext = FX_Random_MT_Start(dwSeed2);
-  for (i = 0; i < 2; i++) {
+  for (int i = 0; i < 2; ++i)
     *pBuffer++ = FX_Random_MT_Generate(pContext);
+  FX_Random_MT_Close(pContext);
+  return buffer;
+}
+
+void AppendIndex0(CFX_ByteTextBuf& buffer, bool bFirstObject) {
+  buffer.AppendByte(0);
+  buffer.AppendByte(0);
+  buffer.AppendByte(0);
+  buffer.AppendByte(0);
+  buffer.AppendByte(0);
+  const uint8_t byte = bFirstObject ? 0xFF : 0;
+  buffer.AppendByte(byte);
+  buffer.AppendByte(byte);
+}
+
+void AppendIndex1(CFX_ByteTextBuf& buffer, FX_FILESIZE offset) {
+  buffer.AppendByte(1);
+  buffer.AppendByte(FX_GETBYTEOFFSET24(offset));
+  buffer.AppendByte(FX_GETBYTEOFFSET16(offset));
+  buffer.AppendByte(FX_GETBYTEOFFSET8(offset));
+  buffer.AppendByte(FX_GETBYTEOFFSET0(offset));
+  buffer.AppendByte(0);
+  buffer.AppendByte(0);
+}
+
+void AppendIndex2(CFX_ByteTextBuf& buffer, FX_DWORD objnum, int32_t index) {
+  buffer.AppendByte(2);
+  buffer.AppendByte(FX_GETBYTEOFFSET24(objnum));
+  buffer.AppendByte(FX_GETBYTEOFFSET16(objnum));
+  buffer.AppendByte(FX_GETBYTEOFFSET8(objnum));
+  buffer.AppendByte(FX_GETBYTEOFFSET0(objnum));
+  buffer.AppendByte(FX_GETBYTEOFFSET8(index));
+  buffer.AppendByte(FX_GETBYTEOFFSET0(index));
+}
+
+bool IsXRefNeedEnd(CPDF_XRefStream* pXRef, FX_DWORD flag) {
+  if (!(flag & FPDFCREATE_INCREMENTAL))
+    return false;
+
+  int32_t iSize = pXRef->m_IndexArray.GetSize() / 2;
+  int32_t iCount = 0;
+  for (int32_t i = 0; i < iSize; ++i)
+    iCount += pXRef->m_IndexArray.ElementAt(i * 2 + 1);
+  return iCount >= PDF_XREFSTREAM_MAXSIZE;
+}
+
+int32_t OutputIndex(CFX_FileBufferArchive* pFile, FX_FILESIZE offset) {
+  if (sizeof(offset) > 4) {
+    if (FX_GETBYTEOFFSET32(offset)) {
+      if (pFile->AppendByte(FX_GETBYTEOFFSET56(offset)) < 0)
+        return -1;
+      if (pFile->AppendByte(FX_GETBYTEOFFSET48(offset)) < 0)
+        return -1;
+      if (pFile->AppendByte(FX_GETBYTEOFFSET40(offset)) < 0)
+        return -1;
+      if (pFile->AppendByte(FX_GETBYTEOFFSET32(offset)) < 0)
+        return -1;
+    }
   }
-  FX_Random_MT_Close(pContext);
-  return TRUE;
+  if (pFile->AppendByte(FX_GETBYTEOFFSET24(offset)) < 0)
+    return -1;
+  if (pFile->AppendByte(FX_GETBYTEOFFSET16(offset)) < 0)
+    return -1;
+  if (pFile->AppendByte(FX_GETBYTEOFFSET8(offset)) < 0)
+    return -1;
+  if (pFile->AppendByte(FX_GETBYTEOFFSET0(offset)) < 0)
+    return -1;
+  if (pFile->AppendByte(0) < 0)
+    return -1;
+  return 0;
 }
+
 class CPDF_FlateEncoder {
  public:
   CPDF_FlateEncoder();
   ~CPDF_FlateEncoder();
   FX_BOOL Initialize(CPDF_Stream* pStream, FX_BOOL bFlateEncode);
   FX_BOOL Initialize(const uint8_t* pBuffer,
                      FX_DWORD size,
                      FX_BOOL bFlateEncode,
                      FX_BOOL bXRefStream = FALSE);
   void CloneDict();
@@ skipping 110 matching lines @@
   m_pData = FX_Alloc(uint8_t, m_dwSize);
   pHandler->EncryptContent(objnum, 0, src_data, src_size, m_pData, m_dwSize);
   m_bNewBuf = TRUE;
   return TRUE;
 }
 CPDF_Encryptor::~CPDF_Encryptor() {
   if (m_bNewBuf) {
     FX_Free(m_pData);
   }
 }
+
+}  // namespace
+
 CPDF_ObjectStream::CPDF_ObjectStream() : m_dwObjNum(0), m_index(0) {}
 FX_BOOL CPDF_ObjectStream::Start() {
   m_ObjNumArray.RemoveAll();
   m_OffsetArray.RemoveAll();
   m_Buffer.Clear();
   m_dwObjNum = 0;
   m_index = 0;
   return TRUE;
 }
 int32_t CPDF_ObjectStream::CompressIndirectObject(FX_DWORD dwObjNum,
@@ skipping 129 matching lines @@
   if (!pCreator) {
     return 0;
   }
   m_ObjStream.CompressIndirectObject(dwObjNum, pBuffer, dwSize);
   if (m_ObjStream.m_ObjNumArray.GetSize() < pCreator->m_ObjectStreamSize &&
       m_ObjStream.m_Buffer.GetLength() < PDF_OBJECTSTREAM_MAXLENGTH) {
     return 1;
   }
   return EndObjectStream(pCreator);
 }
-static void _AppendIndex0(CFX_ByteTextBuf& buffer,
-                          FX_BOOL bFirstObject = TRUE) {
-  buffer.AppendByte(0);
-  buffer.AppendByte(0);
-  buffer.AppendByte(0);
-  buffer.AppendByte(0);
-  buffer.AppendByte(0);
-  if (bFirstObject) {
-    buffer.AppendByte(0xFF);
-    buffer.AppendByte(0xFF);
-  } else {
-    buffer.AppendByte(0);
-    buffer.AppendByte(0);
-  }
-}
-static void _AppendIndex1(CFX_ByteTextBuf& buffer, FX_FILESIZE offset) {
-  buffer.AppendByte(1);
-  buffer.AppendByte(FX_GETBYTEOFFSET24(offset));
-  buffer.AppendByte(FX_GETBYTEOFFSET16(offset));
-  buffer.AppendByte(FX_GETBYTEOFFSET8(offset));
-  buffer.AppendByte(FX_GETBYTEOFFSET0(offset));
-  buffer.AppendByte(0);
-  buffer.AppendByte(0);
-}
-static void _AppendIndex2(CFX_ByteTextBuf& buffer,
-                          FX_DWORD objnum,
-                          int32_t index) {
-  buffer.AppendByte(2);
-  buffer.AppendByte(FX_GETBYTEOFFSET24(objnum));
-  buffer.AppendByte(FX_GETBYTEOFFSET16(objnum));
-  buffer.AppendByte(FX_GETBYTEOFFSET8(objnum));
-  buffer.AppendByte(FX_GETBYTEOFFSET0(objnum));
-  buffer.AppendByte(FX_GETBYTEOFFSET8(index));
-  buffer.AppendByte(FX_GETBYTEOFFSET0(index));
-}
+
 int32_t CPDF_XRefStream::EndObjectStream(CPDF_Creator* pCreator, FX_BOOL bEOF) {
   FX_FILESIZE objOffset = 0;
   if (bEOF) {
     objOffset = m_ObjStream.End(pCreator);
     if (objOffset < 0) {
       return -1;
     }
   }
   FX_DWORD& dwObjStmNum = m_ObjStream.m_dwObjNum;
   if (!dwObjStmNum) {
     dwObjStmNum = ++pCreator->m_dwLastObjNum;
   }
   int32_t iSize = m_ObjStream.m_ObjNumArray.GetSize();
   int32_t iSeg = m_IndexArray.GetSize() / 2;
   if (!(pCreator->m_dwFlags & FPDFCREATE_INCREMENTAL)) {
     if (m_dwTempObjNum == 0) {
-      _AppendIndex0(m_Buffer);
+      AppendIndex0(m_Buffer, true);
       m_dwTempObjNum++;
     }
     FX_DWORD end_num = m_IndexArray.GetAt((iSeg - 1) * 2) +
                        m_IndexArray.GetAt((iSeg - 1) * 2 + 1);
     int index = 0;
     for (; m_dwTempObjNum < end_num; m_dwTempObjNum++) {
       FX_FILESIZE* offset = pCreator->m_ObjectOffset.GetPtrAt(m_dwTempObjNum);
       if (offset) {
         if (index >= iSize ||
             m_dwTempObjNum != m_ObjStream.m_ObjNumArray[index]) {
-          _AppendIndex1(m_Buffer, *offset);
+          AppendIndex1(m_Buffer, *offset);
         } else {
-          _AppendIndex2(m_Buffer, dwObjStmNum, index++);
+          AppendIndex2(m_Buffer, dwObjStmNum, index++);
         }
       } else {
-        _AppendIndex0(m_Buffer, FALSE);
+        AppendIndex0(m_Buffer, false);
       }
     }
     if (iSize > 0 && bEOF) {
       pCreator->m_ObjectOffset.Add(dwObjStmNum, 1);
       pCreator->m_ObjectOffset[dwObjStmNum] = objOffset;
     }
     m_iSeg = iSeg;
     if (bEOF) {
       m_ObjStream.Start();
     }
     return 1;
   }
   int32_t& j = m_ObjStream.m_index;
   for (int i = m_iSeg; i < iSeg; i++) {
     FX_DWORD start = m_IndexArray.ElementAt(i * 2);
     FX_DWORD end = m_IndexArray.ElementAt(i * 2 + 1) + start;
     for (FX_DWORD m = start; m < end; m++) {
       if (j >= iSize || m != m_ObjStream.m_ObjNumArray.ElementAt(j)) {
-        _AppendIndex1(m_Buffer, pCreator->m_ObjectOffset[m]);
+        AppendIndex1(m_Buffer, pCreator->m_ObjectOffset[m]);
       } else {
-        _AppendIndex2(m_Buffer, dwObjStmNum, j++);
+        AppendIndex2(m_Buffer, dwObjStmNum, j++);
       }
     }
   }
   if (iSize > 0 && bEOF) {
-    _AppendIndex1(m_Buffer, objOffset);
+    AppendIndex1(m_Buffer, objOffset);
     m_IndexArray.Add(dwObjStmNum);
     m_IndexArray.Add(1);
     iSeg += 1;
   }
   m_iSeg = iSeg;
   if (bEOF) {
     m_ObjStream.Start();
   }
   return 1;
 }
 FX_BOOL CPDF_XRefStream::GenerateXRefStream(CPDF_Creator* pCreator,
                                             FX_BOOL bEOF) {
   FX_FILESIZE offset_tmp = pCreator->m_Offset;
   FX_DWORD objnum = ++pCreator->m_dwLastObjNum;
   CFX_FileBufferArchive* pFile = &pCreator->m_File;
   FX_BOOL bIncremental = (pCreator->m_dwFlags & FPDFCREATE_INCREMENTAL) != 0;
   if (bIncremental) {
     AddObjectNumberToIndexArray(objnum);
   } else {
     for (; m_dwTempObjNum < pCreator->m_dwLastObjNum; m_dwTempObjNum++) {
       FX_FILESIZE* offset = pCreator->m_ObjectOffset.GetPtrAt(m_dwTempObjNum);
       if (offset) {
-        _AppendIndex1(m_Buffer, *offset);
+        AppendIndex1(m_Buffer, *offset);
       } else {
-        _AppendIndex0(m_Buffer, FALSE);
+        AppendIndex0(m_Buffer, false);
       }
     }
   }
-  _AppendIndex1(m_Buffer, offset_tmp);
+  AppendIndex1(m_Buffer, offset_tmp);
   FX_FILESIZE& offset = pCreator->m_Offset;
   int32_t len = pFile->AppendDWord(objnum);
   if (len < 0) {
     return FALSE;
   }
   offset += len;
   if ((len = pFile->AppendString(" 0 obj\r\n<</Type /XRef/W[1 4 2]/Index[")) <
       0) {
     return FALSE;
   }
@@ skipping 107 matching lines @@
   return TRUE;
 }
 FX_BOOL CPDF_XRefStream::End(CPDF_Creator* pCreator, FX_BOOL bEOF) {
   if (EndObjectStream(pCreator, bEOF) < 0) {
     return FALSE;
   }
   return GenerateXRefStream(pCreator, bEOF);
 }
 FX_BOOL CPDF_XRefStream::EndXRefStream(CPDF_Creator* pCreator) {
   if (!(pCreator->m_dwFlags & FPDFCREATE_INCREMENTAL)) {
-    _AppendIndex0(m_Buffer);
+    AppendIndex0(m_Buffer, true);
     for (FX_DWORD i = 1; i < pCreator->m_dwLastObjNum + 1; i++) {
       FX_FILESIZE* offset = pCreator->m_ObjectOffset.GetPtrAt(i);
       if (offset) {
-        _AppendIndex1(m_Buffer, *offset);
+        AppendIndex1(m_Buffer, *offset);
       } else {
-        _AppendIndex0(m_Buffer, FALSE);
+        AppendIndex0(m_Buffer, false);
       }
     }
   } else {
     int32_t iSeg = m_IndexArray.GetSize() / 2;
     for (int i = 0; i < iSeg; i++) {
       FX_DWORD start = m_IndexArray.ElementAt(i * 2);
       FX_DWORD end = m_IndexArray.ElementAt(i * 2 + 1) + start;
       for (FX_DWORD j = start; j < end; j++) {
-        _AppendIndex1(m_Buffer, pCreator->m_ObjectOffset[j]);
+        AppendIndex1(m_Buffer, pCreator->m_ObjectOffset[j]);
       }
     }
   }
   return GenerateXRefStream(pCreator, FALSE);
 }
 FX_BOOL CPDF_XRefStream::AddObjectNumberToIndexArray(FX_DWORD objnum) {
   int32_t iSize = m_IndexArray.GetSize();
   if (iSize == 0) {
     m_IndexArray.Add(objnum);
     m_IndexArray.Add(1);
@@ skipping 40 matching lines @@
   m_bNewCrypto = FALSE;
 }
 CPDF_Creator::~CPDF_Creator() {
   ResetStandardSecurity();
   if (m_bEncryptCloned && m_pEncryptDict) {
     m_pEncryptDict->Release();
     m_pEncryptDict = NULL;
   }
   Clear();
 }
-static FX_BOOL _IsXRefNeedEnd(CPDF_XRefStream* pXRef, FX_DWORD flag) {
-  if (!(flag & FPDFCREATE_INCREMENTAL)) {
-    return FALSE;
-  }
-  int32_t iSize = pXRef->m_IndexArray.GetSize() / 2;
-  int32_t iCount = 0;
-  for (int32_t i = 0; i < iSize; i++) {
-    iCount += pXRef->m_IndexArray.ElementAt(i * 2 + 1);
-  }
-  return (iCount >= PDF_XREFSTREAM_MAXSIZE);
-}
+
 int32_t CPDF_Creator::WriteIndirectObjectToStream(const CPDF_Object* pObj) {
   if (!m_pXRefStream)
     return 1;
 
   FX_DWORD objnum = pObj->GetObjNum();
   if (m_pParser && m_pParser->m_ObjVersion.GetSize() > (int32_t)objnum &&
       m_pParser->m_ObjVersion[objnum] > 0) {
     return 1;
   }
 
   if (pObj->IsNumber())
     return 1;
 
   CPDF_Dictionary* pDict = pObj->GetDict();
-  if (pObj->IsStream())
+  if (pObj->IsStream()) {
     if (pDict && pDict->GetString("Type") == "XRef")
       return 0;
     return 1;
+  }
 
   if (pDict) {
     if (pDict == m_pDocument->m_pRootDict || pDict == m_pEncryptDict)
       return 1;
     if (IsSignatureDict(pDict))
       return 1;
     if (pDict->GetString("Type") == "Page")
       return 1;
   }
 
   m_pXRefStream->AddObjectNumberToIndexArray(objnum);
   if (m_pXRefStream->CompressIndirectObject(objnum, pObj, this) < 0)
     return -1;
-  if (!_IsXRefNeedEnd(m_pXRefStream, m_dwFlags))
+  if (!IsXRefNeedEnd(m_pXRefStream, m_dwFlags))
     return 0;
   if (!m_pXRefStream->End(this))
     return -1;
   if (!m_pXRefStream->Start())
     return -1;
   return 0;
 }
 int32_t CPDF_Creator::WriteIndirectObjectToStream(FX_DWORD objnum,
                                                   const uint8_t* pBuffer,
                                                   FX_DWORD dwSize) {
   if (!m_pXRefStream) {
     return 1;
   }
   m_pXRefStream->AddObjectNumberToIndexArray(objnum);
   int32_t iRet =
       m_pXRefStream->CompressIndirectObject(objnum, pBuffer, dwSize, this);
   if (iRet < 1) {
     return iRet;
   }
-  if (!_IsXRefNeedEnd(m_pXRefStream, m_dwFlags)) {
+  if (!IsXRefNeedEnd(m_pXRefStream, m_dwFlags)) {
     return 0;
   }
   if (!m_pXRefStream->End(this)) {
     return -1;
   }
   if (!m_pXRefStream->Start()) {
     return -1;
   }
   return 0;
 }
 int32_t CPDF_Creator::AppendObjectNumberToXRef(FX_DWORD objnum) {
   if (!m_pXRefStream) {
     return 1;
   }
   m_pXRefStream->AddObjectNumberToIndexArray(objnum);
-  if (!_IsXRefNeedEnd(m_pXRefStream, m_dwFlags)) {
+  if (!IsXRefNeedEnd(m_pXRefStream, m_dwFlags)) {
     return 0;
   }
   if (!m_pXRefStream->End(this)) {
     return -1;
   }
   if (!m_pXRefStream->Start()) {
     return -1;
   }
   return 0;
 }
@@ skipping 716 matching lines @@
       }
       if (pPause && (i % 100) == 0 && pPause->NeedToPauseNow()) {
         m_Pos = (void*)(uintptr_t)i;
         return 1;
       }
     }
     m_iStage = 90;
   }
   return m_iStage;
 }
-static int32_t _OutPutIndex(CFX_FileBufferArchive* pFile, FX_FILESIZE offset) {
-  FXSYS_assert(pFile);
-  if (sizeof(offset) > 4) {
-    if (FX_GETBYTEOFFSET32(offset)) {
-      if (pFile->AppendByte(FX_GETBYTEOFFSET56(offset)) < 0) {
-        return -1;
-      }
-      if (pFile->AppendByte(FX_GETBYTEOFFSET48(offset)) < 0) {
-        return -1;
-      }
-      if (pFile->AppendByte(FX_GETBYTEOFFSET40(offset)) < 0) {
-        return -1;
-      }
-      if (pFile->AppendByte(FX_GETBYTEOFFSET32(offset)) < 0) {
-        return -1;
-      }
-    }
-  }
-  if (pFile->AppendByte(FX_GETBYTEOFFSET24(offset)) < 0) {
-    return -1;
-  }
-  if (pFile->AppendByte(FX_GETBYTEOFFSET16(offset)) < 0) {
-    return -1;
-  }
-  if (pFile->AppendByte(FX_GETBYTEOFFSET8(offset)) < 0) {
-    return -1;
-  }
-  if (pFile->AppendByte(FX_GETBYTEOFFSET0(offset)) < 0) {
-    return -1;
-  }
-  if (pFile->AppendByte(0) < 0) {
-    return -1;
-  }
-  return 0;
-}
+
 int32_t CPDF_Creator::WriteDoc_Stage4(IFX_Pause* pPause) {
   FXSYS_assert(m_iStage >= 90);
   if ((m_dwFlags & FPDFCREATE_OBJECTSTREAM) == 0) {
     FX_BOOL bXRefStream =
         (m_dwFlags & FPDFCREATE_INCREMENTAL) != 0 && m_pParser->IsXRefStream();
     if (!bXRefStream) {
       if (m_File.AppendString("trailer\r\n<<") < 0) {
         return -1;
       }
     } else {
@@ skipping 136 matching lines @@
           return -1;
         }
         if (m_File.AppendString(">>stream\r\n") < 0) {
           return -1;
         }
         for (i = 0; i < m_dwLastObjNum; i++) {
           FX_FILESIZE* offset = m_ObjectOffset.GetPtrAt(i);
           if (!offset) {
             continue;
           }
-          _OutPutIndex(&m_File, *offset);
+          OutputIndex(&m_File, *offset);
         }
       } else {
         int count = m_NewObjNumArray.GetSize();
         int32_t i = 0;
         for (i = 0; i < count; i++) {
           FX_DWORD objnum = m_NewObjNumArray.ElementAt(i);
           if (m_File.AppendDWord(objnum) < 0) {
             return -1;
           }
           if (m_File.AppendString(" 1 ") < 0) {
             return -1;
           }
         }
         if (m_File.AppendString("]/Length ") < 0) {
           return -1;
         }
         if (m_File.AppendDWord(count * 5) < 0) {
           return -1;
         }
         if (m_File.AppendString(">>stream\r\n") < 0) {
           return -1;
         }
         for (i = 0; i < count; i++) {
           FX_DWORD objnum = m_NewObjNumArray.ElementAt(i);
           FX_FILESIZE offset = m_ObjectOffset[objnum];
-          _OutPutIndex(&m_File, offset);
+          OutputIndex(&m_File, offset);
         }
       }
       if (m_File.AppendString("\r\nendstream") < 0) {
         return -1;
       }
     }
   }
   if (m_File.AppendString("\r\nstartxref\r\n") < 0) {
     return -1;
   }
@@ skipping 38 matching lines @@
   InitID();
   if (flags & FPDFCREATE_PROGRESSIVE) {
     return TRUE;
   }
   return Continue(NULL) > -1;
 }
 void CPDF_Creator::InitID(FX_BOOL bDefault) {
   CPDF_Array* pOldIDArray = m_pParser ? m_pParser->GetIDArray() : NULL;
   FX_BOOL bNewId = !m_pIDArray;
   if (!m_pIDArray) {
-    FX_DWORD* pBuffer = NULL;
     m_pIDArray = new CPDF_Array;
     CPDF_Object* pID1 = pOldIDArray ? pOldIDArray->GetElement(0) : NULL;
     if (pID1) {
       m_pIDArray->Add(pID1->Clone());
     } else {
-      pBuffer = FX_Alloc(FX_DWORD, 4);
-      PDF_GenerateFileID((FX_DWORD)(uintptr_t) this, m_dwLastObjNum, pBuffer);
-      CFX_ByteStringC bsBuffer((const uint8_t*)pBuffer, 4 * sizeof(FX_DWORD));
+      std::vector<uint8_t> buffer =
+          PDF_GenerateFileID((FX_DWORD)(uintptr_t) this, m_dwLastObjNum);
+      CFX_ByteStringC bsBuffer(buffer.data(), buffer.size());
       m_pIDArray->Add(new CPDF_String(bsBuffer, TRUE), m_pDocument);
     }
-    FX_Free(pBuffer);
   }
   if (!bDefault) {
     return;
   }
   if (pOldIDArray) {
     CPDF_Object* pID2 = pOldIDArray->GetElement(1);
     if ((m_dwFlags & FPDFCREATE_INCREMENTAL) && m_pEncryptDict && pID2) {
       m_pIDArray->Add(pID2->Clone());
       return;
     }
-    FX_DWORD* pBuffer = FX_Alloc(FX_DWORD, 4);
-    PDF_GenerateFileID((FX_DWORD)(uintptr_t) this, m_dwLastObjNum, pBuffer);
-    CFX_ByteStringC bsBuffer((const uint8_t*)pBuffer, 4 * sizeof(FX_DWORD));
+    std::vector<uint8_t> buffer =
+        PDF_GenerateFileID((FX_DWORD)(uintptr_t) this, m_dwLastObjNum);
+    CFX_ByteStringC bsBuffer(buffer.data(), buffer.size());
     m_pIDArray->Add(new CPDF_String(bsBuffer, TRUE), m_pDocument);
-    FX_Free(pBuffer);
     return;
   }
   m_pIDArray->Add(m_pIDArray->GetElement(0)->Clone());
   if (m_pEncryptDict && !pOldIDArray && m_pParser && bNewId) {
     if (m_pEncryptDict->GetString("Filter") == "Standard") {
       CPDF_StandardSecurityHandler handler;
       CFX_ByteString user_pass = m_pParser->GetPassword();
       FX_DWORD flag = PDF_ENCRYPT_CONTENT;
       handler.OnCreate(m_pEncryptDict, m_pIDArray, (const uint8_t*)user_pass,
                        user_pass.GetLength(), flag);
@@ skipping 54 matching lines @@
   m_bNewCrypto = FALSE;
   if (!m_bStandardSecurity) {
     return;
   }
   if (m_pEncryptDict) {
     m_pEncryptDict->Release();
     m_pEncryptDict = NULL;
   }
   m_bStandardSecurity = FALSE;
 }