Cleanups from prior CLs.

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 369 matching lines @@
     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(CPDF_Stream* pStream, FX_BOOL bFlateEncode);
+  CPDF_FlateEncoder(const uint8_t* pBuffer,
+                    uint32_t size,
+                    FX_BOOL bFlateEncode,
+                    FX_BOOL bXRefStream = FALSE);
   ~CPDF_FlateEncoder();
-  FX_BOOL Initialize(CPDF_Stream* pStream, FX_BOOL bFlateEncode);
-  FX_BOOL Initialize(const uint8_t* pBuffer,
-                     uint32_t size,
-                     FX_BOOL bFlateEncode,
-                     FX_BOOL bXRefStream = FALSE);
+
   void CloneDict();
+
   uint8_t* m_pData;
   uint32_t m_dwSize;
   CPDF_Dictionary* m_pDict;
   FX_BOOL m_bCloned;
   FX_BOOL m_bNewData;
   CPDF_StreamAcc m_Acc;
 };
-CPDF_FlateEncoder::CPDF_FlateEncoder() {
-  m_pData = NULL;
-  m_dwSize = 0;
-  m_pDict = NULL;
-  m_bCloned = FALSE;
-  m_bNewData = FALSE;
-}
+
 void CPDF_FlateEncoder::CloneDict() {
   if (!m_bCloned) {
     m_pDict = ToDictionary(m_pDict->Clone());
     ASSERT(m_pDict);
     m_bCloned = TRUE;
   }
 }
-FX_BOOL CPDF_FlateEncoder::Initialize(CPDF_Stream* pStream,
-                                      FX_BOOL bFlateEncode) {
+
+CPDF_FlateEncoder::CPDF_FlateEncoder(CPDF_Stream* pStream, FX_BOOL bFlateEncode)
+    : m_pData(nullptr),
+      m_dwSize(0),
+      m_pDict(nullptr),
+      m_bCloned(FALSE),
+      m_bNewData(FALSE) {
   m_Acc.LoadAllData(pStream, TRUE);
   if ((pStream && pStream->GetDict() &&
        pStream->GetDict()->KeyExist("Filter")) ||
       !bFlateEncode) {
     if (pStream->GetDict()->KeyExist("Filter") && !bFlateEncode) {
       CPDF_StreamAcc destAcc;
       destAcc.LoadAllData(pStream);
       m_dwSize = destAcc.GetSize();
       m_pData = (uint8_t*)destAcc.DetachData();
       m_pDict = ToDictionary(pStream->GetDict()->Clone());
       m_pDict->RemoveAt("Filter");
       m_bNewData = TRUE;
       m_bCloned = TRUE;
     } else {
       m_pData = (uint8_t*)m_Acc.GetData();
       m_dwSize = m_Acc.GetSize();
       m_pDict = pStream->GetDict();
     }
-    return TRUE;
+    return;
   }
-  m_pData = NULL;
-  m_dwSize = 0;
+
   m_bNewData = TRUE;
   m_bCloned = TRUE;
   ::FlateEncode(m_Acc.GetData(), m_Acc.GetSize(), m_pData, m_dwSize);
   m_pDict = ToDictionary(pStream->GetDict()->Clone());
   m_pDict->SetAtInteger("Length", m_dwSize);
   m_pDict->SetAtName("Filter", "FlateDecode");
   m_pDict->RemoveAt("DecodeParms");
-  return TRUE;
 }
-FX_BOOL CPDF_FlateEncoder::Initialize(const uint8_t* pBuffer,
-                                      uint32_t size,
-                                      FX_BOOL bFlateEncode,
-                                      FX_BOOL bXRefStream) {
+
+CPDF_FlateEncoder::CPDF_FlateEncoder(const uint8_t* pBuffer,
+                                     uint32_t size,
+                                     FX_BOOL bFlateEncode,
+                                     FX_BOOL bXRefStream)
+    : m_pData(nullptr),
+      m_dwSize(0),
+      m_pDict(nullptr),
+      m_bCloned(FALSE),
+      m_bNewData(FALSE) {
   if (!bFlateEncode) {
     m_pData = (uint8_t*)pBuffer;
     m_dwSize = size;
-    return TRUE;
+    return;
   }
   m_bNewData = TRUE;
-  if (bXRefStream) {
+  if (bXRefStream)
     ::FlateEncode(pBuffer, size, 12, 1, 8, 7, m_pData, m_dwSize);
-  } else {
+  else
     ::FlateEncode(pBuffer, size, m_pData, m_dwSize);
-  }
-  return TRUE;
 }
+
 CPDF_FlateEncoder::~CPDF_FlateEncoder() {
-  if (m_bCloned && m_pDict) {
+  if (m_bCloned && m_pDict)
     m_pDict->Release();
-  }
-  if (m_bNewData) {
+  if (m_bNewData)
     FX_Free(m_pData);
-  }
 }
+
 class CPDF_Encryptor {
  public:
-  CPDF_Encryptor();
+  CPDF_Encryptor(CPDF_CryptoHandler* pHandler,
+                 int objnum,
+                 uint8_t* src_data,
+                 uint32_t src_size);
   ~CPDF_Encryptor();
-  FX_BOOL Initialize(CPDF_CryptoHandler* pHandler,
-                     int objnum,
-                     uint8_t* src_data,
-                     uint32_t src_size);
+
   uint8_t* m_pData;
   uint32_t m_dwSize;
   FX_BOOL m_bNewBuf;
 };
-CPDF_Encryptor::CPDF_Encryptor() {
-  m_pData = NULL;
-  m_dwSize = 0;
-  m_bNewBuf = FALSE;
-}
-FX_BOOL CPDF_Encryptor::Initialize(CPDF_CryptoHandler* pHandler,
-                                   int objnum,
-                                   uint8_t* src_data,
-                                   uint32_t src_size) {
-  if (src_size == 0) {
-    return TRUE;
-  }
+
+CPDF_Encryptor::CPDF_Encryptor(CPDF_CryptoHandler* pHandler,
+                               int objnum,
+                               uint8_t* src_data,
+                               uint32_t src_size)
+    : m_pData(nullptr), m_dwSize(0), m_bNewBuf(FALSE) {
+  if (src_size == 0)
+    return;
+
   if (!pHandler) {
     m_pData = (uint8_t*)src_data;
     m_dwSize = src_size;
-    m_bNewBuf = FALSE;
-    return TRUE;
+    return;
   }
   m_dwSize = pHandler->EncryptGetSize(objnum, 0, src_data, src_size);
   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) {
+  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;
@@ skipping 14 matching lines @@
   m_OffsetArray.Add(m_Buffer.GetLength());
   m_Buffer.AppendBlock(pBuffer, dwSize);
   return 1;
 }
 FX_FILESIZE CPDF_ObjectStream::End(CPDF_Creator* pCreator) {
   FXSYS_assert(pCreator);
   if (m_ObjNumArray.GetSize() == 0) {
     return 0;
   }
   CFX_FileBufferArchive* pFile = &pCreator->m_File;
-  CPDF_CryptoHandler* pHandler = pCreator->m_pCryptoHandler;
   FX_FILESIZE ObjOffset = pCreator->m_Offset;
   if (!m_dwObjNum) {
     m_dwObjNum = ++pCreator->m_dwLastObjNum;
   }
   CFX_ByteTextBuf tempBuffer;
   int32_t iCount = m_ObjNumArray.GetSize();
   for (int32_t i = 0; i < iCount; i++) {
     tempBuffer << m_ObjNumArray.ElementAt(i) << " "
                << m_OffsetArray.ElementAt(i) << " ";
   }
@@ skipping 14 matching lines @@
   if (pFile->AppendString("/First ") < 0) {
     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 && !pHandler) {
+
+  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;
-    encoder.Initialize(tempBuffer.GetBuffer(), tempBuffer.GetLength(),
-                       pCreator->m_bCompress);
-    CPDF_Encryptor encryptor;
-    encryptor.Initialize(pHandler, m_dwObjNum, encoder.m_pData,
-                         encoder.m_dwSize);
+    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;
     }
@@ skipping 187 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;
-  encoder.Initialize(m_Buffer.GetBuffer(), m_Buffer.GetLength(),
-                     pCreator->m_bCompress, bPredictor);
+  CPDF_FlateEncoder encoder(m_Buffer.GetBuffer(), m_Buffer.GetLength(),
+                            pCreator->m_bCompress, bPredictor);
   if (pCreator->m_bCompress) {
     if (pFile->AppendString("/Filter /FlateDecode") < 0) {
       return FALSE;
     }
     offset += 20;
     if (bPredictor) {
       if ((len = pFile->AppendString(
                "/DecodeParms<</Columns 7/Predictor 12>>")) < 0) {
         return FALSE;
       }
@@ skipping 77 matching lines @@
     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;
-    m_pCryptoHandler = NULL;
+    m_pEncryptDict = nullptr;
+    m_pCryptoHandler = nullptr;
   }
   m_bSecurityChanged = FALSE;
-  m_bStandardSecurity = FALSE;
-  m_pMetadata = NULL;
+  m_pMetadata = nullptr;
   m_bEncryptCloned = FALSE;
   m_bEncryptMetadata = FALSE;
   m_Offset = 0;
   m_iStage = -1;
   m_dwFlags = 0;
-  m_Pos = NULL;
+  m_Pos = nullptr;
   m_XrefStart = 0;
-  m_pXRefStream = NULL;
+  m_pXRefStream = nullptr;
   m_ObjectStreamSize = 200;
   m_dwLastObjNum = m_pDocument->GetLastObjNum();
-  m_pIDArray = NULL;
+  m_pIDArray = nullptr;
   m_FileVersion = 0;
   m_dwEnryptObjNum = 0;
-  m_bNewCrypto = FALSE;
+  m_bLocalCryptoHandler = FALSE;
 }
 CPDF_Creator::~CPDF_Creator() {
   ResetStandardSecurity();
   if (m_bEncryptCloned && m_pEncryptDict) {
     m_pEncryptDict->Release();
     m_pEncryptDict = NULL;
   }
   Clear();
 }
 
@@ skipping 70 matching lines @@
     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;
-  encoder.Initialize(const_cast<CPDF_Stream*>(pStream->AsStream()),
-                     pStream == m_pMetadata ? FALSE : m_bCompress);
-  CPDF_Encryptor encryptor;
-  if (!encryptor.Initialize(pCrypto, objnum, encoder.m_pData,
-                            encoder.m_dwSize)) {
-    return -1;
-  }
+  CPDF_FlateEncoder encoder(const_cast<CPDF_Stream*>(pStream->AsStream()),
+                            pStream == m_pMetadata ? FALSE : m_bCompress);
+  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) {
     return -1;
@@ skipping 14 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 = nullptr;
-    pHandler =
-        (pObj == m_pMetadata && !m_bEncryptMetadata) ? NULL : m_pCryptoHandler;
+    CPDF_CryptoHandler* pHandler = (pObj == m_pMetadata && !m_bEncryptMetadata)
+                                       ? nullptr
+                                       : m_pCryptoHandler;
     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 40 matching lines @@
       CFX_ByteString str = pObj->GetString();
       FX_BOOL bHex = pObj->AsString()->IsHex();
       if (!m_pCryptoHandler || !bEncrypt) {
         CFX_ByteString content = PDF_EncodeString(str, bHex);
         if ((len = m_File.AppendString(content.AsStringC())) < 0) {
           return -1;
         }
         m_Offset += len;
         break;
       }
-      CPDF_Encryptor encryptor;
-      encryptor.Initialize(m_pCryptoHandler, objnum, (uint8_t*)str.c_str(),
-                           str.GetLength());
+      CPDF_Encryptor encryptor(m_pCryptoHandler, objnum, (uint8_t*)str.c_str(),
+                               str.GetLength());
       CFX_ByteString content = PDF_EncodeString(
           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;
-      encoder.Initialize(const_cast<CPDF_Stream*>(pObj->AsStream()),
-                         m_bCompress);
-      CPDF_Encryptor encryptor;
-      CPDF_CryptoHandler* pHandler = m_pCryptoHandler;
-      encryptor.Initialize(pHandler, objnum, encoder.m_pData, encoder.m_dwSize);
+      CPDF_FlateEncoder encoder(const_cast<CPDF_Stream*>(pObj->AsStream()),
+                                m_bCompress);
+      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;
       }
       if ((len = m_File.AppendString("stream\r\n")) < 0) {
         return -1;
@@ skipping 55 matching lines @@
           }
         }
       }
       if (m_File.AppendString("]") < 0) {
         return -1;
       }
       m_Offset += 1;
       break;
     }
     case CPDF_Object::DICTIONARY: {
-      if (!m_pCryptoHandler || pObj == m_pEncryptDict) {
+      if (!m_pCryptoHandler || pObj == m_pEncryptDict)
         return PDF_CreatorAppendObject(pObj, &m_File, m_Offset);
-      }
-      if (m_File.AppendString("<<") < 0) {
+      if (m_File.AppendString("<<") < 0)
         return -1;
-      }
+
       m_Offset += 2;
       const CPDF_Dictionary* p = pObj->AsDictionary();
       bool bSignDict = p->IsSignatureDict();
       for (const auto& it : *p) {
         FX_BOOL bSignValue = FALSE;
         const CFX_ByteString& key = it.first;
         CPDF_Object* pValue = it.second;
         if (m_File.AppendString("/") < 0) {
           return -1;
         }
@@ skipping 763 matching lines @@
   }
   m_pIDArray->Add(m_pIDArray->GetObjectAt(0)->Clone());
   if (m_pEncryptDict && !pOldIDArray && m_pParser && bNewId) {
     if (m_pEncryptDict->GetStringBy("Filter") == "Standard") {
       CFX_ByteString user_pass = m_pParser->GetPassword();
       uint32_t flag = PDF_ENCRYPT_CONTENT;
 
       CPDF_SecurityHandler handler;
       handler.OnCreate(m_pEncryptDict, m_pIDArray, user_pass.raw_str(),
                        user_pass.GetLength(), flag);
-      if (m_bNewCrypto) {
+      if (m_bLocalCryptoHandler)
         delete m_pCryptoHandler;
-      }
       m_pCryptoHandler = new CPDF_CryptoHandler;
       m_pCryptoHandler->Init(m_pEncryptDict, &handler);
-      m_bNewCrypto = TRUE;
+      m_bLocalCryptoHandler = TRUE;
       m_bSecurityChanged = TRUE;
     }
   }
 }
 int32_t CPDF_Creator::Continue(IFX_Pause* pPause) {
   if (m_iStage < 0) {
     return m_iStage;
   }
   int32_t iRet = 0;
   while (m_iStage < 100) {
@@ skipping 20 matching lines @@
 FX_BOOL CPDF_Creator::SetFileVersion(int32_t fileVersion) {
   if (fileVersion < 10 || fileVersion > 17) {
     return FALSE;
   }
   m_FileVersion = fileVersion;
   return TRUE;
 }
 void CPDF_Creator::RemoveSecurity() {
   ResetStandardSecurity();
   m_bSecurityChanged = TRUE;
-  m_pEncryptDict = NULL;
-  m_pCryptoHandler = NULL;
+  m_pEncryptDict = nullptr;
+  m_pCryptoHandler = nullptr;
 }
 void CPDF_Creator::ResetStandardSecurity() {
-  if (m_bStandardSecurity || m_bNewCrypto) {
-    delete m_pCryptoHandler;
-    m_pCryptoHandler = NULL;
-  }
-  m_bNewCrypto = FALSE;
-  if (!m_bStandardSecurity) {
+  if (!m_bLocalCryptoHandler)
     return;
-  }
-  if (m_pEncryptDict) {
-    m_pEncryptDict->Release();
-    m_pEncryptDict = NULL;
-  }
-  m_bStandardSecurity = FALSE;
+
+  delete m_pCryptoHandler;
+  m_pCryptoHandler = nullptr;
+  m_bLocalCryptoHandler = FALSE;
 }