Make m_IndexArray sane.

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 "core/src/fpdfapi/fpdf_edit/editint.h"
 
 #include <vector>
 
@@ skipping 323 matching lines @@
   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;

[Lei Zhang, 2016/02/03 00:03:28]

FX_DWORD

[Tom Sepez, 2016/02/03 00:12:16]

Done.

-  for (int32_t i = 0; i < iSize; ++i)
-    iCount += pXRef->m_IndexArray.ElementAt(i * 2 + 1);
+  for (const auto& pair : pXRef->m_IndexArray)
+    iCount += pair.count;
+
   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;
@@ skipping 259 matching lines @@
   }
   if ((len = pFile->AppendString("\r\nendstream\r\nendobj\r\n")) < 0) {
     return -1;
   }
   offset += len;
   return ObjOffset;
 }
 CPDF_XRefStream::CPDF_XRefStream()
     : m_PrevOffset(0), m_dwTempObjNum(0), m_iSeg(0) {}
 FX_BOOL CPDF_XRefStream::Start() {
-  m_IndexArray.RemoveAll();
+  m_IndexArray.clear();
   m_Buffer.Clear();
   m_iSeg = 0;
   return TRUE;
 }
 int32_t CPDF_XRefStream::CompressIndirectObject(FX_DWORD dwObjNum,
                                                 const CPDF_Object* pObj,
                                                 CPDF_Creator* pCreator) {
   if (!pCreator) {
     return 0;
   }
@@ skipping 25 matching lines @@
     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;
+  int32_t iSeg = m_IndexArray.size();

[Lei Zhang, 2016/02/03 00:03:28]

Is it easy to change this and |m_iSeg| to size_t?

[Tom Sepez, 2016/02/03 00:12:16]

Let's try.

   if (!(pCreator->m_dwFlags & FPDFCREATE_INCREMENTAL)) {
     if (m_dwTempObjNum == 0) {
       AppendIndex0(m_Buffer, true);
       m_dwTempObjNum++;
     }
-    FX_DWORD end_num = m_IndexArray.GetAt((iSeg - 1) * 2) +
-                       m_IndexArray.GetAt((iSeg - 1) * 2 + 1);
+    FX_DWORD end_num = m_IndexArray.back().objnum + m_IndexArray.back().count;
     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);
         } else {
           AppendIndex2(m_Buffer, dwObjStmNum, index++);
         }
       } else {
         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)) {
+  for (auto it = m_IndexArray.begin() + m_iSeg; it != m_IndexArray.end();
+       ++it) {
+    for (FX_DWORD m = it->objnum; m < it->objnum + it->count; ++m) {
+      if (m_ObjStream.m_index >= iSize ||
+          m != m_ObjStream.m_ObjNumArray.ElementAt(it - m_IndexArray.begin())) {
         AppendIndex1(m_Buffer, pCreator->m_ObjectOffset[m]);
       } else {
-        AppendIndex2(m_Buffer, dwObjStmNum, j++);
+        AppendIndex2(m_Buffer, dwObjStmNum, m_ObjStream.m_index++);
       }
     }
   }
   if (iSize > 0 && bEOF) {
     AppendIndex1(m_Buffer, objOffset);
-    m_IndexArray.Add(dwObjStmNum);
-    m_IndexArray.Add(1);
+    m_IndexArray.push_back({dwObjStmNum, 1});
     iSeg += 1;
   }
   m_iSeg = iSeg;
   if (bEOF) {
     m_ObjStream.Start();
   }
   return 1;
 }
 FX_BOOL CPDF_XRefStream::GenerateXRefStream(CPDF_Creator* pCreator,
                                             FX_BOOL bEOF) {
@@ skipping 31 matching lines @@
     }
     if ((len = pFile->AppendString(" ")) < 0) {
       return FALSE;
     }
     offset += len + 1;
     if ((len = pFile->AppendDWord(objnum + 1)) < 0) {
       return FALSE;
     }
     offset += len;
   } else {
-    int32_t iSeg = m_IndexArray.GetSize() / 2;
-    for (int32_t i = 0; i < iSeg; i++) {
-      if ((len = pFile->AppendDWord(m_IndexArray.ElementAt(i * 2))) < 0) {
+    for (const auto& pair : m_IndexArray) {
+      if ((len = pFile->AppendDWord(pair.objnum)) < 0) {
         return FALSE;
       }
       if (pFile->AppendString(" ") < 0) {
         return FALSE;
       }
       offset += len + 1;
-      if ((len = pFile->AppendDWord(m_IndexArray.ElementAt(i * 2 + 1))) < 0) {
+      if ((len = pFile->AppendDWord(pair.count)) < 0) {
         return FALSE;
       }
       if (pFile->AppendString(" ") < 0) {
         return FALSE;
       }
       offset += len + 1;
     }
   }
   if (pFile->AppendString("]/Size ") < 0) {
     return FALSE;
@@ skipping 83 matching lines @@
     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);
       } else {
         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++) {
+    for (const auto& pair : m_IndexArray) {
+      for (FX_DWORD j = pair.objnum; j < pair.objnum + pair.count; ++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);
-  } else {
-    FXSYS_assert(iSize > 1);
-    FX_DWORD startobjnum = m_IndexArray.ElementAt(iSize - 2);
-    int32_t iCount = m_IndexArray.ElementAt(iSize - 1);
-    if (objnum == startobjnum + iCount) {
-      m_IndexArray[iSize - 1] = iCount + 1;
-    } else {
-      m_IndexArray.Add(objnum);
-      m_IndexArray.Add(1);
-    }
+void CPDF_XRefStream::AddObjectNumberToIndexArray(FX_DWORD objnum) {
+  if (m_IndexArray.empty()) {
+    m_IndexArray.push_back({objnum, 1});
+    return;
   }
-  return TRUE;
+  FX_DWORD nextobjnum = m_IndexArray.back().objnum + m_IndexArray.back().count;

[Lei Zhang, 2016/02/03 00:03:28]

nit: next_objnum

+  if (objnum == nextobjnum)
+    m_IndexArray.back().count += 1;
+  else
+    m_IndexArray.push_back({objnum, 1});
 }
 CPDF_Creator::CPDF_Creator(CPDF_Document* pDoc) {
   m_pDocument = pDoc;
   m_pParser = (CPDF_Parser*)pDoc->m_pParser;
   m_bCompress = TRUE;
   if (m_pParser) {
     m_pEncryptDict = m_pParser->GetEncryptDict();
     m_pCryptoHandler = m_pParser->GetCryptoHandler();
   } else {
     m_pEncryptDict = NULL;
@@ skipping 1153 matching lines @@
   m_bNewCrypto = FALSE;
   if (!m_bStandardSecurity) {
     return;
   }
   if (m_pEncryptDict) {
     m_pEncryptDict->Release();
     m_pEncryptDict = NULL;
   }
   m_bStandardSecurity = FALSE;
 }