Clean up CPDF_Creator.

core/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/fpdfapi/fpdf_edit/editint.h"
 
 #include <vector>
 
@@ skipping 559 matching lines @@
     return -1;
   }
   if ((len = pFile->AppendDWord((uint32_t)tempBuffer.GetLength())) < 0) {
     return -1;
   }
   if (pFile->AppendString("/Length ") < 0) {
     return -1;
   }
   offset += len + 15;
 
   if (!pCreator->m_bCompress && !pCreator->m_pCryptoHandler) {

[Lei Zhang, 2016/05/13 06:36:42]

This always evals to false.

     if ((len = pFile->AppendDWord(
              (uint32_t)(tempBuffer.GetLength() + m_Buffer.GetLength()))) < 0) {
       return -1;
     }
     offset += len;
     if ((len = pFile->AppendString(">>stream\r\n")) < 0) {
       return -1;
     }
     if (pFile->AppendBlock(tempBuffer.GetBuffer(), tempBuffer.GetLength()) <
         0) {
@@ skipping 243 matching lines @@
   if (bEOF) {
     if ((len = PDF_CreatorWriteTrailer(pCreator->m_pDocument, pFile,
                                        pCreator->m_pIDArray,
                                        pCreator->m_bCompress)) < 0) {
       return FALSE;
     }
     offset += len;
     if (pCreator->m_pEncryptDict) {
       uint32_t dwEncryptObjNum = pCreator->m_pEncryptDict->GetObjNum();
       if (dwEncryptObjNum == 0) {
-        dwEncryptObjNum = pCreator->m_dwEnryptObjNum;
+        dwEncryptObjNum = pCreator->m_dwEncryptObjNum;
       }
       if ((len = PDF_CreatorWriteEncrypt(pCreator->m_pEncryptDict,
                                          dwEncryptObjNum, pFile)) < 0) {
         return FALSE;
       }
       offset += len;
     }
   }
   if ((len = pFile->AppendString(">>stream\r\n")) < 0) {
     return FALSE;
@@ skipping 38 matching lines @@
   if (m_IndexArray.empty()) {
     m_IndexArray.push_back({objnum, 1});
     return;
   }
   uint32_t next_objnum = m_IndexArray.back().objnum + m_IndexArray.back().count;
   if (objnum == next_objnum)
     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 = nullptr;
-    m_pCryptoHandler = nullptr;
-  }
-  m_bSecurityChanged = FALSE;
-  m_pMetadata = nullptr;
-  m_bEncryptCloned = FALSE;
-  m_bEncryptMetadata = FALSE;

[Lei Zhang, 2016/05/13 06:36:42]

I accidentally removed this. It's always false.

[Tom Sepez, 2016/05/13 20:05:11]

Accidentally? Otherwise, agreed its always false.

[Lei Zhang, 2016/05/14 01:06:33]

Accidentally removed in patch set 1. Should have been removed in patch set 2.

-  m_Offset = 0;
-  m_iStage = -1;
-  m_dwFlags = 0;
-  m_Pos = nullptr;
-  m_XrefStart = 0;
-  m_pXRefStream = nullptr;
-  m_ObjectStreamSize = 200;
-  m_dwLastObjNum = m_pDocument->GetLastObjNum();
-  m_pIDArray = nullptr;
-  m_FileVersion = 0;
-  m_dwEnryptObjNum = 0;
-  m_bLocalCryptoHandler = FALSE;
-}
+
+CPDF_Creator::CPDF_Creator(CPDF_Document* pDoc)
+    : m_pDocument(pDoc),
+      m_pParser(pDoc->GetParser()),
+      m_bCompress(TRUE),
+      m_bSecurityChanged(FALSE),
+      m_pEncryptDict(m_pParser ? m_pParser->GetEncryptDict() : nullptr),
+      m_dwEncryptObjNum(0),
+      m_pCryptoHandler(m_pParser ? m_pParser->GetCryptoHandler() : nullptr),
+      m_pMetadata(nullptr),
+      m_ObjectStreamSize(200),
+      m_dwLastObjNum(m_pDocument->GetLastObjNum()),
+      m_Offset(0),
+      m_iStage(-1),
+      m_dwFlags(0),
+      m_Pos(nullptr),
+      m_XrefStart(0),
+      m_pIDArray(nullptr),
+      m_FileVersion(0) {}
+
 CPDF_Creator::~CPDF_Creator() {
   ResetStandardSecurity();
   if (m_bEncryptCloned && m_pEncryptDict) {
     m_pEncryptDict->Release();
     m_pEncryptDict = NULL;
   }
   Clear();
 }
 
 int32_t CPDF_Creator::WriteIndirectObjectToStream(const CPDF_Object* pObj) {
@@ skipping 19 matching lines @@
       return 1;
     if (pDict->IsSignatureDict())
       return 1;
     if (pDict->GetStringBy("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.get(), m_dwFlags))
     return 0;
   if (!m_pXRefStream->End(this))
     return -1;
   if (!m_pXRefStream->Start())
     return -1;
   return 0;
 }
 int32_t CPDF_Creator::WriteIndirectObjectToStream(uint32_t objnum,
                                                   const uint8_t* pBuffer,
                                                   uint32_t 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.get(), m_dwFlags)) {
     return 0;
   }
   if (!m_pXRefStream->End(this)) {
     return -1;
   }
   if (!m_pXRefStream->Start()) {
     return -1;
   }
   return 0;
 }
 int32_t CPDF_Creator::AppendObjectNumberToXRef(uint32_t objnum) {
   if (!m_pXRefStream) {
     return 1;
   }
   m_pXRefStream->AddObjectNumberToIndexArray(objnum);
-  if (!IsXRefNeedEnd(m_pXRefStream, m_dwFlags)) {
+  if (!IsXRefNeedEnd(m_pXRefStream.get(), m_dwFlags)) {
     return 0;
   }
   if (!m_pXRefStream->End(this)) {
     return -1;
   }
   if (!m_pXRefStream->Start()) {
     return -1;
   }
   return 0;
 }
@@ skipping 454 matching lines @@
   if (m_iStage == 0) {
     if (!m_pParser) {
       m_dwFlags &= ~FPDFCREATE_INCREMENTAL;
     }
     if (m_bSecurityChanged && (m_dwFlags & FPDFCREATE_NO_ORIGINAL) == 0) {
       m_dwFlags &= ~FPDFCREATE_INCREMENTAL;
     }
     CPDF_Dictionary* pDict = m_pDocument->GetRoot();
     m_pMetadata = pDict ? pDict->GetDirectObjectBy("Metadata") : NULL;
     if (m_dwFlags & FPDFCREATE_OBJECTSTREAM) {
-      m_pXRefStream = new CPDF_XRefStream;
+      m_pXRefStream.reset(new CPDF_XRefStream);
       m_pXRefStream->Start();
       if ((m_dwFlags & FPDFCREATE_INCREMENTAL) != 0 && m_pParser) {
         FX_FILESIZE prev = m_pParser->GetLastXRefOffset();
         m_pXRefStream->m_PrevOffset = prev;
       }
     }
     m_iStage = 10;
   }
   if (m_iStage == 10) {
     if ((m_dwFlags & FPDFCREATE_INCREMENTAL) == 0) {
@@ skipping 100 matching lines @@
   }
   if (m_iStage == 27) {
     if (NULL != m_pEncryptDict && 0 == m_pEncryptDict->GetObjNum()) {
       m_dwLastObjNum += 1;
       FX_FILESIZE saveOffset = m_Offset;
       if (WriteIndirectObj(m_dwLastObjNum, m_pEncryptDict) < 0) {
         return -1;
       }
       m_ObjectOffset.Add(m_dwLastObjNum, 1);
       m_ObjectOffset[m_dwLastObjNum] = saveOffset;
-      m_dwEnryptObjNum = m_dwLastObjNum;
+      m_dwEncryptObjNum = m_dwLastObjNum;
       if (m_dwFlags & FPDFCREATE_INCREMENTAL) {
         m_NewObjNumArray.Add(m_dwLastObjNum);
       }
     }
     m_iStage = 80;
   }
   return m_iStage;
 }
 int32_t CPDF_Creator::WriteDoc_Stage3(IFX_Pause* pPause) {
   ASSERT(m_iStage >= 80 || m_iStage < 90);
@@ skipping 309 matching lines @@
   if (m_File.AppendBlock(offset_buf, FXSYS_strlen(offset_buf)) < 0) {
     return -1;
   }
   if (m_File.AppendString("\r\n%%EOF\r\n") < 0) {
     return -1;
   }
   m_File.Flush();
   return m_iStage = 100;
 }
 void CPDF_Creator::Clear() {
-  delete m_pXRefStream;
-  m_pXRefStream = NULL;
+  m_pXRefStream.reset();
   m_File.Clear();
   m_NewObjNumArray.RemoveAll();
   if (m_pIDArray) {
     m_pIDArray->Release();
     m_pIDArray = NULL;
   }
 }
 
 bool CPDF_Creator::Create(IFX_StreamWrite* pFile, uint32_t flags) {
   m_File.AttachFile(pFile);
@@ skipping 101 matching lines @@
   m_pCryptoHandler = nullptr;
 }
 void CPDF_Creator::ResetStandardSecurity() {
   if (!m_bLocalCryptoHandler)
     return;
 
   delete m_pCryptoHandler;
   m_pCryptoHandler = nullptr;
   m_bLocalCryptoHandler = FALSE;
 }