Remove unused PS generation code.

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 370 matching lines @@
   if (pFile->AppendByte(0) < 0)
     return -1;
   return 0;
 }
 
 class CPDF_FlateEncoder {
  public:
   CPDF_FlateEncoder(CPDF_Stream* pStream, FX_BOOL bFlateEncode);
   CPDF_FlateEncoder(const uint8_t* pBuffer,
                     uint32_t size,
-                    FX_BOOL bFlateEncode,
-                    FX_BOOL bXRefStream = FALSE);
+                    bool bFlateEncode,
+                    bool bXRefStream);
   ~CPDF_FlateEncoder();
 
   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;
@@ skipping 29 matching lines @@
     } else {
       m_pData = (uint8_t*)m_Acc.GetData();
       m_dwSize = m_Acc.GetSize();
       m_pDict = pStream->GetDict();
     }
     return;
   }
 
   m_bNewData = TRUE;
   m_bCloned = TRUE;
-  ::FlateEncode(m_Acc.GetData(), m_Acc.GetSize(), m_pData, m_dwSize);
+  // TODO(thestig): Move to Init() and check return value.
+  ::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");
 }
 
 CPDF_FlateEncoder::CPDF_FlateEncoder(const uint8_t* pBuffer,
                                      uint32_t size,
-                                     FX_BOOL bFlateEncode,
-                                     FX_BOOL bXRefStream)
+                                     bool bFlateEncode,
+                                     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;
   }
   m_bNewData = TRUE;
+  // TODO(thestig): Move to Init() and check return value.
   if (bXRefStream)
-    ::FlateEncode(pBuffer, size, 12, 1, 8, 7, m_pData, m_dwSize);
+    ::PngEncode(pBuffer, size, &m_pData, &m_dwSize);
   else
-    ::FlateEncode(pBuffer, size, m_pData, m_dwSize);
+    ::FlateEncode(pBuffer, size, &m_pData, &m_dwSize);
 }
 
 CPDF_FlateEncoder::~CPDF_FlateEncoder() {
   if (m_bCloned && m_pDict)
     m_pDict->Release();
   if (m_bNewData)
     FX_Free(m_pData);
 }
 
 class CPDF_Encryptor {
@@ skipping 92 matching lines @@
   if ((len = pFile->AppendDWord((uint32_t)tempBuffer.GetLength())) < 0) {
     return -1;
   }
   if (pFile->AppendString("/Length ") < 0) {
     return -1;
   }
   offset += len + 15;
 
   tempBuffer << m_Buffer;
   CPDF_FlateEncoder encoder(tempBuffer.GetBuffer(), tempBuffer.GetLength(),
-                            TRUE);
+                            true, false);
   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;
@@ 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 offset_len = (int32_t)FXSYS_strlen(offset_buf);
     if (pFile->AppendBlock(offset_buf, offset_len) < 0) {
       return FALSE;
     }
     offset += offset_len + 6;
   }
-  FX_BOOL bPredictor = TRUE;
   CPDF_FlateEncoder encoder(m_Buffer.GetBuffer(), m_Buffer.GetLength(), TRUE,
-                            bPredictor);
-  if (pFile->AppendString("/Filter /FlateDecode") < 0) {
+                            TRUE);
+  if (pFile->AppendString("/Filter /FlateDecode") < 0)
+    return FALSE;
+
+  offset += 20;
+  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;
-  }
-  if (pFile->AppendString("/Length ") < 0) {
+
+  offset += len;
+  if (pFile->AppendString("/Length ") < 0)
     return FALSE;
-  }
-  if ((len = pFile->AppendDWord(encoder.m_dwSize)) < 0) {
+
+  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)) < 0) {
       return FALSE;
     }
     offset += len;
     if (pCreator->m_pEncryptDict) {
       uint32_t dwEncryptObjNum = pCreator->m_pEncryptDict->GetObjNum();
       if (dwEncryptObjNum == 0) {
@@ skipping 74 matching lines @@
       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;
+    m_pEncryptDict = nullptr;
   }
   Clear();
 }
 
 int32_t CPDF_Creator::WriteIndirectObjectToStream(const CPDF_Object* pObj) {
   if (!m_pXRefStream)
     return 1;
 
   uint32_t objnum = pObj->GetObjNum();
   if (m_pParser && m_pParser->GetObjectGenNum(objnum) > 0)
@@ skipping 521 matching lines @@
 int32_t CPDF_Creator::WriteDoc_Stage1(IFX_Pause* pPause) {
   ASSERT(m_iStage > -1 || m_iStage < 20);
   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;
+    m_pMetadata = pDict ? pDict->GetDirectObjectBy("Metadata") : nullptr;
     if (m_dwFlags & FPDFCREATE_OBJECTSTREAM) {
       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;
   }
@@ skipping 94 matching lines @@
   }
   if (m_iStage == 26) {
     int32_t iRet =
         WriteNewObjs((m_dwFlags & FPDFCREATE_INCREMENTAL) != 0, pPause);
     if (iRet) {
       return iRet;
     }
     m_iStage = 27;
   }
   if (m_iStage == 27) {
-    if (NULL != m_pEncryptDict && 0 == m_pEncryptDict->GetObjNum()) {
+    if (m_pEncryptDict && !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_dwEncryptObjNum = m_dwLastObjNum;
       if (m_dwFlags & FPDFCREATE_INCREMENTAL) {
         m_NewObjNumArray.Add(m_dwLastObjNum);
@@ skipping 316 matching lines @@
   FXSYS_i64toa(m_XrefStart, offset_buf, 10);
   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() {
   m_pXRefStream.reset();
   m_File.Clear();
   m_NewObjNumArray.RemoveAll();
   if (m_pIDArray) {
     m_pIDArray->Release();
-    m_pIDArray = NULL;
+    m_pIDArray = nullptr;
   }
 }
 
 bool CPDF_Creator::Create(IFX_StreamWrite* pFile, uint32_t flags) {
   m_File.AttachFile(pFile);
   return Create(flags);
 }
 
 bool CPDF_Creator::Create(uint32_t flags) {
   m_dwFlags = flags;
   m_iStage = 0;
   m_Offset = 0;
   m_dwLastObjNum = m_pDocument->GetLastObjNum();
   m_ObjectOffset.Clear();
   m_NewObjNumArray.RemoveAll();
   InitID();
-  if (flags & FPDFCREATE_PROGRESSIVE) {
+  if (flags & FPDFCREATE_PROGRESSIVE)
     return true;
-  }
-  return Continue(NULL) > -1;
+  return Continue(nullptr) > -1;
 }
+
 void CPDF_Creator::InitID(FX_BOOL bDefault) {
-  CPDF_Array* pOldIDArray = m_pParser ? m_pParser->GetIDArray() : NULL;
+  CPDF_Array* pOldIDArray = m_pParser ? m_pParser->GetIDArray() : nullptr;
   FX_BOOL bNewId = !m_pIDArray;
   if (!m_pIDArray) {
     m_pIDArray = new CPDF_Array;
-    CPDF_Object* pID1 = pOldIDArray ? pOldIDArray->GetObjectAt(0) : NULL;
+    CPDF_Object* pID1 = pOldIDArray ? pOldIDArray->GetObjectAt(0) : nullptr;
     if (pID1) {
       m_pIDArray->Add(pID1->Clone());
     } else {
       std::vector<uint8_t> buffer =
           PDF_GenerateFileID((uint32_t)(uintptr_t) this, m_dwLastObjNum);
       CFX_ByteString bsBuffer(buffer.data(), buffer.size());
       m_pIDArray->Add(new CPDF_String(bsBuffer, TRUE), m_pDocument);
     }
   }
   if (!bDefault) {
@@ skipping 69 matching lines @@
   m_pCryptoHandler = nullptr;
 }
 void CPDF_Creator::ResetStandardSecurity() {
   if (!m_bLocalCryptoHandler)
     return;
 
   delete m_pCryptoHandler;
   m_pCryptoHandler = nullptr;
   m_bLocalCryptoHandler = FALSE;
 }