Split off IPDF_CryptoHandler into its own .cpp/.h files

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>
 
 #include "core/include/fpdfapi/cpdf_document.h"
 #include "core/include/fpdfapi/cpdf_parser.h"
 #include "core/include/fpdfapi/fpdf_parser.h"
 #include "core/include/fpdfapi/fpdf_serial.h"
+#include "core/include/fpdfapi/ipdf_crypto_handler.h"
 #include "core/include/fxcrt/fx_ext.h"
+#include "core/src/fpdfapi/fpdf_parser/cpdf_standard_crypto_handler.h"
 #include "core/src/fpdfapi/fpdf_parser/cpdf_standard_security_handler.h"
 #include "third_party/base/stl_util.h"
 
 #define PDF_OBJECTSTREAM_MAXLENGTH (256 * 1024)
 #define PDF_XREFSTREAM_MAXSIZE 10000
 
 // TODO(ochang): Make helper for appending "objnum 0 R ".
 
 namespace {
 
@@ skipping 437 matching lines @@
     m_pDict->Release();
   }
   if (m_bNewData) {
     FX_Free(m_pData);
   }
 }
 class CPDF_Encryptor {
  public:
   CPDF_Encryptor();
   ~CPDF_Encryptor();
-  FX_BOOL Initialize(CPDF_CryptoHandler* pHandler,
+  FX_BOOL Initialize(IPDF_CryptoHandler* pHandler,
                      int objnum,
                      uint8_t* src_data,
                      FX_DWORD src_size);
   uint8_t* m_pData;
   FX_DWORD 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,
+FX_BOOL CPDF_Encryptor::Initialize(IPDF_CryptoHandler* pHandler,
                                    int objnum,
                                    uint8_t* src_data,
                                    FX_DWORD src_size) {
   if (src_size == 0) {
     return TRUE;
   }
   if (!pHandler) {
     m_pData = (uint8_t*)src_data;
     m_dwSize = src_size;
     m_bNewBuf = FALSE;
@@ skipping 36 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;
+  IPDF_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 455 matching lines @@
   if (!m_pXRefStream->End(this)) {
     return -1;
   }
   if (!m_pXRefStream->Start()) {
     return -1;
   }
   return 0;
 }
 int32_t CPDF_Creator::WriteStream(const CPDF_Object* pStream,
                                   FX_DWORD objnum,
-                                  CPDF_CryptoHandler* pCrypto) {
+                                  IPDF_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;
   }
   if ((FX_DWORD)encoder.m_pDict->GetIntegerBy("Length") != encryptor.m_dwSize) {
     encoder.CloneDict();
@@ skipping 22 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;
+    IPDF_CryptoHandler* pHandler = nullptr;
     pHandler =
         (pObj == m_pMetadata && !m_bEncryptMetadata) ? NULL : 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;
@@ skipping 59 matching lines @@
         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;
+      IPDF_CryptoHandler* pHandler = m_pCryptoHandler;
       encryptor.Initialize(pHandler, objnum, encoder.m_pData, encoder.m_dwSize);
       if ((FX_DWORD)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) {
@@ skipping 906 matching lines @@
   m_bNewCrypto = FALSE;
   if (!m_bStandardSecurity) {
     return;
   }
   if (m_pEncryptDict) {
     m_pEncryptDict->Release();
     m_pEncryptDict = NULL;
   }
   m_bStandardSecurity = FALSE;
 }