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 171 matching lines @@
     }
     default:
       ASSERT(FALSE);
       break;
   }
   return 1;
 }
 
 int32_t PDF_CreatorWriteTrailer(CPDF_Document* pDocument,
                                 CFX_FileBufferArchive* pFile,
-                                CPDF_Array* pIDArray,
-                                FX_BOOL bCompress) {
+                                CPDF_Array* pIDArray) {
   FX_FILESIZE offset = 0;
   int32_t len = 0;
-  ASSERT(pDocument && pFile);
-  CPDF_Parser* pParser = (CPDF_Parser*)pDocument->GetParser();
+  CPDF_Parser* pParser = pDocument->GetParser();
   if (pParser) {
     CPDF_Dictionary* p = pParser->GetTrailer();
     for (const auto& it : *p) {
       const CFX_ByteString& key = it.first;
       CPDF_Object* pValue = it.second;
       if (key == "Encrypt" || key == "Size" || key == "Filter" ||
           key == "Index" || key == "Length" || key == "Prev" || key == "W" ||
           key == "XRefStm" || key == "Type" || key == "ID") {
         continue;
       }
-      if (bCompress && key == "DecodeParms") {
+      if (key == "DecodeParms")
         continue;
-      }
+
       if (pFile->AppendString(("/")) < 0) {
         return -1;
       }
       if ((len = pFile->AppendString(PDF_NameEncode(key).AsStringC())) < 0) {
         return -1;
       }
       offset += len + 1;
       if (pValue->GetObjNum()) {
         if (pFile->AppendString(" ") < 0) {
           return -1;
@@ skipping 349 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) {
-    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) {
-      return -1;
-    }
-    if (pFile->AppendBlock(m_Buffer.GetBuffer(), m_Buffer.GetLength()) < 0) {
-      return -1;
-    }
-    offset += len + tempBuffer.GetLength() + m_Buffer.GetLength();
-  } else {
-    tempBuffer << m_Buffer;
-    CPDF_FlateEncoder encoder(tempBuffer.GetBuffer(), tempBuffer.GetLength(),
-                              pCreator->m_bCompress);
-    CPDF_Encryptor encryptor(pCreator->m_pCryptoHandler, m_dwObjNum,
-                             encoder.m_pData, encoder.m_dwSize);
-    if ((len = pFile->AppendDWord(encryptor.m_dwSize)) < 0) {
-      return -1;
-    }
-    offset += len;
-    if (pCreator->m_bCompress) {
-      if (pFile->AppendString("/Filter /FlateDecode") < 0) {
-        return -1;
-      }
-      offset += 20;
-    }
-    if ((len = pFile->AppendString(">>stream\r\n")) < 0) {
-      return -1;
-    }
-    if (pFile->AppendBlock(encryptor.m_pData, encryptor.m_dwSize) < 0) {
-      return -1;
-    }
-    offset += len + encryptor.m_dwSize;
+  tempBuffer << m_Buffer;
+  CPDF_FlateEncoder encoder(tempBuffer.GetBuffer(), tempBuffer.GetLength(),
+                            TRUE);
+  CPDF_Encryptor encryptor(pCreator->m_pCryptoHandler, m_dwObjNum,
+                           encoder.m_pData, encoder.m_dwSize);
+  if ((len = pFile->AppendDWord(encryptor.m_dwSize)) < 0) {
+    return -1;
   }
+  offset += len;
+  if (pFile->AppendString("/Filter /FlateDecode") < 0) {
+    return -1;
+  }
+  offset += 20;
+  if ((len = pFile->AppendString(">>stream\r\n")) < 0) {
+    return -1;
+  }
+  if (pFile->AppendBlock(encryptor.m_pData, encryptor.m_dwSize) < 0) {
+    return -1;
+  }
+  offset += len + encryptor.m_dwSize;
   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.clear();
@@ skipping 171 matching lines @@
     FX_CHAR offset_buf[20];
     FXSYS_memset(offset_buf, 0, sizeof(offset_buf));
     FXSYS_i64toa(m_PrevOffset, offset_buf, 10);
     int32_t len = (int32_t)FXSYS_strlen(offset_buf);
     if (pFile->AppendBlock(offset_buf, len) < 0) {
       return FALSE;
     }
     offset += len + 6;
   }
   FX_BOOL bPredictor = TRUE;
-  CPDF_FlateEncoder encoder(m_Buffer.GetBuffer(), m_Buffer.GetLength(),
-                            pCreator->m_bCompress, bPredictor);
-  if (pCreator->m_bCompress) {
-    if (pFile->AppendString("/Filter /FlateDecode") < 0) {
+  CPDF_FlateEncoder encoder(m_Buffer.GetBuffer(), m_Buffer.GetLength(), TRUE,
+                            bPredictor);
+  if (pFile->AppendString("/Filter /FlateDecode") < 0) {
+    return FALSE;
+  }
+  offset += 20;
+  if (bPredictor) {
+    if ((len = pFile->AppendString("/DecodeParms<</Columns 7/Predictor 12>>")) <
+        0) {
       return FALSE;
     }
-    offset += 20;
-    if (bPredictor) {
-      if ((len = pFile->AppendString(
-               "/DecodeParms<</Columns 7/Predictor 12>>")) < 0) {
-        return FALSE;
-      }
-      offset += len;
-    }
+    offset += len;
   }
   if (pFile->AppendString("/Length ") < 0) {
     return FALSE;
   }
   if ((len = pFile->AppendDWord(encoder.m_dwSize)) < 0) {
     return FALSE;
   }
   offset += len + 8;
   if (bEOF) {
     if ((len = PDF_CreatorWriteTrailer(pCreator->m_pDocument, pFile,
-                                       pCreator->m_pIDArray,
-                                       pCreator->m_bCompress)) < 0) {
+                                       pCreator->m_pIDArray)) < 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;
-  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_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;
 }
 int32_t CPDF_Creator::WriteStream(const CPDF_Object* pStream,
                                   uint32_t objnum,
                                   CPDF_CryptoHandler* pCrypto) {
   CPDF_FlateEncoder encoder(const_cast<CPDF_Stream*>(pStream->AsStream()),
-                            pStream == m_pMetadata ? FALSE : m_bCompress);
+                            pStream != m_pMetadata);
   CPDF_Encryptor encryptor(pCrypto, objnum, encoder.m_pData, encoder.m_dwSize);
   if ((uint32_t)encoder.m_pDict->GetIntegerBy("Length") != encryptor.m_dwSize) {
     encoder.CloneDict();
     encoder.m_pDict->SetAtInteger("Length", encryptor.m_dwSize);
   }
   if (WriteDirectObj(objnum, encoder.m_pDict) < 0) {
     return -1;
   }
   int len = m_File.AppendString("stream\r\n");
   if (len < 0) {
@@ skipping 15 matching lines @@
   int32_t len = m_File.AppendDWord(objnum);
   if (len < 0)
     return -1;
 
   m_Offset += len;
   if ((len = m_File.AppendString(" 0 obj\r\n")) < 0)
     return -1;
 
   m_Offset += len;
   if (pObj->IsStream()) {
-    CPDF_CryptoHandler* pHandler = (pObj == m_pMetadata && !m_bEncryptMetadata)
-                                       ? nullptr
-                                       : m_pCryptoHandler;
+    CPDF_CryptoHandler* pHandler =
+        pObj != m_pMetadata ? m_pCryptoHandler : nullptr;
     if (WriteStream(pObj, objnum, pHandler) < 0)
       return -1;
   } else {
     if (WriteDirectObj(objnum, pObj) < 0)
       return -1;
   }
   if ((len = m_File.AppendString("\r\nendobj\r\n")) < 0)
     return -1;
 
   m_Offset += len;
@@ skipping 53 matching lines @@
           CFX_ByteString((const FX_CHAR*)encryptor.m_pData, encryptor.m_dwSize),
           bHex);
       if ((len = m_File.AppendString(content.AsStringC())) < 0) {
         return -1;
       }
       m_Offset += len;
       break;
     }
     case CPDF_Object::STREAM: {
       CPDF_FlateEncoder encoder(const_cast<CPDF_Stream*>(pObj->AsStream()),
-                                m_bCompress);
+                                TRUE);
       CPDF_Encryptor encryptor(m_pCryptoHandler, objnum, encoder.m_pData,
                                encoder.m_dwSize);
       if ((uint32_t)encoder.m_pDict->GetIntegerBy("Length") !=
           encryptor.m_dwSize) {
         encoder.CloneDict();
         encoder.m_pDict->SetAtInteger("Length", encryptor.m_dwSize);
       }
       if (WriteDirectObj(objnum, encoder.m_pDict) < 0) {
         return -1;
       }
@@ skipping 327 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;
 }