Add type cast definitions for CPDF_Stream.

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 "../../../include/fxcrt/fx_ext.h"
 #include "../../../include/fpdfapi/fpdf_serial.h"
 #include "../../../include/fpdfapi/fpdf_parser.h"
 #include "editint.h"
@@ skipping 128 matching lines @@
           }
         }
       }
       if (pFile->AppendString(FX_BSTRC(">>")) < 0) {
         return -1;
       }
       offset += 2;
       break;
     }
     case PDFOBJ_STREAM: {
-      CPDF_Stream* p = (CPDF_Stream*)pObj;
+      const CPDF_Stream* p = pObj->AsStream();
       if (PDF_CreatorAppendObject(p->GetDict(), pFile, offset) < 0) {
         return -1;
       }
       if (pFile->AppendString(FX_BSTRC("stream\r\n")) < 0) {
         return -1;
       }
       offset += 8;
       CPDF_StreamAcc acc;
       acc.LoadAllData(p, TRUE);
       if (pFile->AppendBlock(acc.GetData(), acc.GetSize()) < 0) {
@@ skipping 762 matching lines @@
     return FALSE;
   }
   int32_t iSize = pXRef->m_IndexArray.GetSize() / 2;
   int32_t iCount = 0;
   for (int32_t i = 0; i < iSize; i++) {
     iCount += pXRef->m_IndexArray.ElementAt(i * 2 + 1);
   }
   return (iCount >= PDF_XREFSTREAM_MAXSIZE);
 }
 int32_t CPDF_Creator::WriteIndirectObjectToStream(const CPDF_Object* pObj) {
-  if (!m_pXRefStream) {
+  if (!m_pXRefStream)
     return 1;
-  }
+
   FX_DWORD objnum = pObj->GetObjNum();
   if (m_pParser && m_pParser->m_ObjVersion.GetSize() > (int32_t)objnum &&
       m_pParser->m_ObjVersion[objnum] > 0) {
     return 1;
   }
 
   if (pObj->IsNumber())
     return 1;
 
   CPDF_Dictionary* pDict = pObj->GetDict();
-  if (pObj->GetType() == PDFOBJ_STREAM) {
-    if (pDict && pDict->GetString(FX_BSTRC("Type")) == FX_BSTRC("XRef")) {
+  if (pObj->IsStream())
+    if (pDict && pDict->GetString(FX_BSTRC("Type")) == FX_BSTRC("XRef"))
       return 0;
-    }
     return 1;
+
+  if (pDict) {
+    if (pDict == m_pDocument->m_pRootDict || pDict == m_pEncryptDict)
+      return 1;
+    if (IsSignatureDict(pDict))
+      return 1;
+    if (pDict->GetString(FX_BSTRC("Type")) == FX_BSTRC("Page"))
+      return 1;
   }
-  if (pDict) {
-    if (pDict == m_pDocument->m_pRootDict || pDict == m_pEncryptDict) {
-      return 1;
-    }
-    if (IsSignatureDict(pDict)) {
-      return 1;
-    }
-    if (pDict->GetString(FX_BSTRC("Type")) == FX_BSTRC("Page")) {
-      return 1;
-    }
-  }
+
   m_pXRefStream->AddObjectNumberToIndexArray(objnum);
-  if (m_pXRefStream->CompressIndirectObject(objnum, pObj, this) < 0) {
+  if (m_pXRefStream->CompressIndirectObject(objnum, pObj, this) < 0)
     return -1;
-  }
-  if (!_IsXRefNeedEnd(m_pXRefStream, m_dwFlags)) {
+  if (!_IsXRefNeedEnd(m_pXRefStream, m_dwFlags))
     return 0;
-  }
-  if (!m_pXRefStream->End(this)) {
+  if (!m_pXRefStream->End(this))
     return -1;
-  }
-  if (!m_pXRefStream->Start()) {
+  if (!m_pXRefStream->Start())
     return -1;
-  }
   return 0;
 }
 int32_t CPDF_Creator::WriteIndirectObjectToStream(FX_DWORD objnum,
                                                   const uint8_t* pBuffer,
                                                   FX_DWORD dwSize) {
   if (!m_pXRefStream) {
     return 1;
   }
   m_pXRefStream->AddObjectNumberToIndexArray(objnum);
   int32_t iRet =
@@ skipping 25 matching lines @@
   }
   if (!m_pXRefStream->Start()) {
     return -1;
   }
   return 0;
 }
 int32_t CPDF_Creator::WriteStream(const CPDF_Object* pStream,
                                   FX_DWORD objnum,
                                   CPDF_CryptoHandler* pCrypto) {
   CPDF_FlateEncoder encoder;
-  encoder.Initialize((CPDF_Stream*)pStream,
+  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->GetInteger(FX_BSTRC("Length")) !=
       encryptor.m_dwSize) {
     encoder.CloneDict();
     encoder.m_pDict->SetAtInteger(FX_BSTRC("Length"), encryptor.m_dwSize);
@@ skipping 12 matching lines @@
   m_Offset += encryptor.m_dwSize;
   if ((len = m_File.AppendString(FX_BSTRC("\r\nendstream"))) < 0) {
     return -1;
   }
   m_Offset += len;
   return 1;
 }
 int32_t CPDF_Creator::WriteIndirectObj(FX_DWORD objnum,
                                        const CPDF_Object* pObj) {
   int32_t len = m_File.AppendDWord(objnum);
-  if (len < 0) {
+  if (len < 0)
     return -1;
-  }
+
   m_Offset += len;
-  if ((len = m_File.AppendString(FX_BSTRC(" 0 obj\r\n"))) < 0) {
+  if ((len = m_File.AppendString(FX_BSTRC(" 0 obj\r\n"))) < 0)
     return -1;
-  }
+
   m_Offset += len;
-  if (pObj->GetType() == PDFOBJ_STREAM) {
-    CPDF_CryptoHandler* pHandler = NULL;
+  if (pObj->IsStream()) {
+    CPDF_CryptoHandler* pHandler = nullptr;
     pHandler =
         (pObj == m_pMetadata && !m_bEncryptMetadata) ? NULL : m_pCryptoHandler;
-    if (WriteStream(pObj, objnum, pHandler) < 0) {
+    if (WriteStream(pObj, objnum, pHandler) < 0)
       return -1;
-    }
   } else {
-    if (WriteDirectObj(objnum, pObj) < 0) {
+    if (WriteDirectObj(objnum, pObj) < 0)
       return -1;
-    }
   }
-  if ((len = m_File.AppendString(FX_BSTRC("\r\nendobj\r\n"))) < 0) {
+  if ((len = m_File.AppendString(FX_BSTRC("\r\nendobj\r\n"))) < 0)
     return -1;
-  }
+
   m_Offset += len;
-  if (AppendObjectNumberToXRef(objnum) < 0) {
+  if (AppendObjectNumberToXRef(objnum) < 0)
     return -1;
-  }
   return 0;
 }
 int32_t CPDF_Creator::WriteIndirectObj(const CPDF_Object* pObj) {
   int32_t iRet = WriteIndirectObjectToStream(pObj);
   if (iRet < 1) {
     return iRet;
   }
   return WriteIndirectObj(pObj->GetObjNum(), pObj);
 }
 int32_t CPDF_Creator::WriteDirectObj(FX_DWORD objnum,
@@ skipping 42 matching lines @@
           CFX_ByteString((const FX_CHAR*)encryptor.m_pData, encryptor.m_dwSize),
           bHex);
       if ((len = m_File.AppendString(content)) < 0) {
         return -1;
       }
       m_Offset += len;
       break;
     }
     case PDFOBJ_STREAM: {
       CPDF_FlateEncoder encoder;
-      encoder.Initialize((CPDF_Stream*)pObj, m_bCompress);
+      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);
       if ((FX_DWORD)encoder.m_pDict->GetInteger(FX_BSTRC("Length")) !=
           encryptor.m_dwSize) {
         encoder.CloneDict();
         encoder.m_pDict->SetAtInteger(FX_BSTRC("Length"), encryptor.m_dwSize);
       }
       if (WriteDirectObj(objnum, encoder.m_pDict) < 0) {
         return -1;
@@ skipping 975 matching lines @@
   m_bNewCrypto = FALSE;
   if (!m_bStandardSecurity) {
     return;
   }
   if (m_pEncryptDict) {
     m_pEncryptDict->Release();
     m_pEncryptDict = NULL;
   }
   m_bStandardSecurity = FALSE;
 }