Tidy fpdfsave.cpp

fpdfsdk/src/fpdfsave.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 "public/fpdf_save.h"
 
+#include "core/include/fpdfapi/fpdf_parser.h"
 #include "core/include/fpdfapi/fpdf_serial.h"
 #include "fpdfsdk/include/fsdk_define.h"
 #include "public/fpdf_edit.h"
 
 #ifdef PDF_ENABLE_XFA
 #include "fpdfsdk/include/fpdfxfa/fpdfxfa_app.h"
 #include "fpdfsdk/include/fpdfxfa/fpdfxfa_doc.h"
 #include "fpdfsdk/include/fpdfxfa/fpdfxfa_util.h"
 #include "public/fpdf_formfill.h"
 #endif
@@ skipping 34 matching lines @@
     return FALSE;
 
   m_pFileWriteStruct->WriteBlock(m_pFileWriteStruct, pData, size);
   return TRUE;
 }
 
 void CFX_IFileWrite::Release() {
   delete this;
 }
 
+namespace {
+
 #ifdef PDF_ENABLE_XFA
-FX_BOOL _SaveXFADocumentData(CPDFXFA_Document* pDocument,
-                             CFX_PtrArray& fileList) {
+bool SaveXFADocumentData(CPDFXFA_Document* pDocument,
+                         std::vector<ScopedFileStream>* fileList) {
   if (!pDocument)
-    return FALSE;
+    return false;
+
   if (pDocument->GetDocType() != DOCTYPE_DYNAMIC_XFA &&
       pDocument->GetDocType() != DOCTYPE_STATIC_XFA)
-    return TRUE;
+    return true;
+
   if (!CPDFXFA_App::GetInstance()->GetXFAApp())
-    return TRUE;
+    return true;
 
   IXFA_DocView* pXFADocView = pDocument->GetXFADocView();
-  if (NULL == pXFADocView)
-    return TRUE;
+  if (!pXFADocView)
+    return true;
 
   IXFA_DocHandler* pXFADocHandler =
       CPDFXFA_App::GetInstance()->GetXFAApp()->GetDocHandler();
   CPDF_Document* pPDFDocument = pDocument->GetPDFDoc();
-  if (pDocument == NULL)
-    return FALSE;
+  if (!pDocument)
+    return false;
 
   CPDF_Dictionary* pRoot = pPDFDocument->GetRoot();
-  if (pRoot == NULL)
-    return FALSE;
+  if (!pRoot)
+    return false;
+
   CPDF_Dictionary* pAcroForm = pRoot->GetDictBy("AcroForm");
-  if (NULL == pAcroForm)
-    return FALSE;
+  if (!pAcroForm)
+    return false;
+
   CPDF_Object* pXFA = pAcroForm->GetElement("XFA");
-  if (pXFA == NULL)
-    return TRUE;
+  if (!pXFA)
+    return true;
+
   if (!pXFA->IsArray())
-    return FALSE;
+    return false;
+
   CPDF_Array* pArray = pXFA->GetArray();
-  if (NULL == pArray)
-    return FALSE;
+  if (!pArray)
+    return false;
+
   int size = pArray->GetCount();
   int iFormIndex = -1;
   int iDataSetsIndex = -1;
   int iTemplate = -1;
   int iLast = size - 2;
   for (int i = 0; i < size - 1; i++) {
     CPDF_Object* pPDFObj = pArray->GetElement(i);
     if (!pPDFObj->IsString())
       continue;
     if (pPDFObj->GetString() == "form")
       iFormIndex = i + 1;
     else if (pPDFObj->GetString() == "datasets")
       iDataSetsIndex = i + 1;
     else if (pPDFObj->GetString() == "template")
       iTemplate = i + 1;
   }
-  IXFA_ChecksumContext* pContext = NULL;
-  // Checksum
-  pContext = XFA_Checksum_Create();
-  FXSYS_assert(pContext);
+  std::unique_ptr<IXFA_ChecksumContext, ReleaseDeleter<IXFA_ChecksumContext>>
+      pContext(XFA_Checksum_Create());
   pContext->StartChecksum();
 
   // template
   if (iTemplate > -1) {
     CPDF_Stream* pTemplateStream = pArray->GetStreamAt(iTemplate);
     CPDF_StreamAcc streamAcc;
     streamAcc.LoadAllData(pTemplateStream);
     uint8_t* pData = (uint8_t*)streamAcc.GetData();
     FX_DWORD dwSize2 = streamAcc.GetSize();
-    IFX_FileStream* pTemplate = FX_CreateMemoryStream(pData, dwSize2);
-    pContext->UpdateChecksum((IFX_FileRead*)pTemplate);
-    pTemplate->Release();
+    ScopedFileStream pTemplate(FX_CreateMemoryStream(pData, dwSize2));
+    pContext->UpdateChecksum(pTemplate.get());
   }
   CPDF_Stream* pFormStream = NULL;
   CPDF_Stream* pDataSetsStream = NULL;
   if (iFormIndex != -1) {
     // Get form CPDF_Stream
     CPDF_Object* pFormPDFObj = pArray->GetElement(iFormIndex);
     if (pFormPDFObj->IsReference()) {
       CPDF_Object* pFormDirectObj = pFormPDFObj->GetDirect();
       if (pFormDirectObj && pFormDirectObj->IsStream()) {
         pFormStream = (CPDF_Stream*)pFormDirectObj;
       }
     } else if (pFormPDFObj->IsStream()) {
       pFormStream = (CPDF_Stream*)pFormPDFObj;
     }
   }
 
   if (iDataSetsIndex != -1) {
     // Get datasets CPDF_Stream
     CPDF_Object* pDataSetsPDFObj = pArray->GetElement(iDataSetsIndex);
     if (pDataSetsPDFObj->IsReference()) {
       CPDF_Reference* pDataSetsRefObj = (CPDF_Reference*)pDataSetsPDFObj;
       CPDF_Object* pDataSetsDirectObj = pDataSetsRefObj->GetDirect();
       if (pDataSetsDirectObj && pDataSetsDirectObj->IsStream()) {
         pDataSetsStream = (CPDF_Stream*)pDataSetsDirectObj;
       }
     } else if (pDataSetsPDFObj->IsStream()) {
       pDataSetsStream = (CPDF_Stream*)pDataSetsPDFObj;
     }
   }
-  // end
   // L"datasets"
   {
-    IFX_FileStream* pDsfileWrite = FX_CreateMemoryStream();
-    if (NULL == pDsfileWrite) {
-      pContext->Release();
-      pDsfileWrite->Release();
-      return FALSE;
-    }
+    ScopedFileStream pDsfileWrite(FX_CreateMemoryStream());
     if (pXFADocHandler->SavePackage(pXFADocView->GetDoc(),
                                     CFX_WideStringC(L"datasets"),
-                                    pDsfileWrite) &&
+                                    pDsfileWrite.get()) &&
         pDsfileWrite->GetSize() > 0) {
       // Datasets
-      pContext->UpdateChecksum((IFX_FileRead*)pDsfileWrite);
+      pContext->UpdateChecksum(pDsfileWrite.get());
       pContext->FinishChecksum();
       CPDF_Dictionary* pDataDict = new CPDF_Dictionary;
       if (iDataSetsIndex != -1) {
         if (pDataSetsStream)
-          pDataSetsStream->InitStreamFromFile(pDsfileWrite, pDataDict);
+          pDataSetsStream->InitStreamFromFile(pDsfileWrite.get(), pDataDict);
       } else {
         CPDF_Stream* pData = new CPDF_Stream(NULL, 0, NULL);
-        pData->InitStreamFromFile(pDsfileWrite, pDataDict);
+        pData->InitStreamFromFile(pDsfileWrite.get(), pDataDict);
         pPDFDocument->AddIndirectObject(pData);
         iLast = pArray->GetCount() - 2;
         pArray->InsertAt(iLast, new CPDF_String("datasets", FALSE));
         pArray->InsertAt(iLast + 1, pData, pPDFDocument);
       }
-      fileList.Add(pDsfileWrite);
+      fileList->push_back(std::move(pDsfileWrite));
     }
   }
-
   // L"form"
   {
-    IFX_FileStream* pfileWrite = FX_CreateMemoryStream();
-    if (NULL == pfileWrite) {
-      pContext->Release();
-      return FALSE;
-    }
+    ScopedFileStream pfileWrite(FX_CreateMemoryStream());
     if (pXFADocHandler->SavePackage(pXFADocView->GetDoc(),
-                                    CFX_WideStringC(L"form"), pfileWrite,
-                                    pContext) &&
-        pfileWrite > 0) {

[Tom Sepez, 2016/02/05 22:49:45]

This had to be wrong. Comparing a pointer greater than 0 ?  I've duplicated the
logic from above.  Yay cut n paste.

+                                    CFX_WideStringC(L"form"), pfileWrite.get(),
+                                    pContext.get()) &&
+        pfileWrite->GetSize() > 0) {
       CPDF_Dictionary* pDataDict = new CPDF_Dictionary;
       if (iFormIndex != -1) {
         if (pFormStream)
-          pFormStream->InitStreamFromFile(pfileWrite, pDataDict);
+          pFormStream->InitStreamFromFile(pfileWrite.get(), pDataDict);
       } else {
         CPDF_Stream* pData = new CPDF_Stream(NULL, 0, NULL);
-        pData->InitStreamFromFile(pfileWrite, pDataDict);
+        pData->InitStreamFromFile(pfileWrite.get(), pDataDict);
         pPDFDocument->AddIndirectObject(pData);
         iLast = pArray->GetCount() - 2;
         pArray->InsertAt(iLast, new CPDF_String("form", FALSE));
         pArray->InsertAt(iLast + 1, pData, pPDFDocument);
       }
-      fileList.Add(pfileWrite);
+      fileList->push_back(std::move(pfileWrite));
     }
   }
-  pContext->Release();
-  return TRUE;
+  return true;
 }
 
-FX_BOOL _SendPostSaveToXFADoc(CPDFXFA_Document* pDocument) {
+bool SendPostSaveToXFADoc(CPDFXFA_Document* pDocument) {
   if (!pDocument)
-    return FALSE;
+    return false;
 
   if (pDocument->GetDocType() != DOCTYPE_DYNAMIC_XFA &&
       pDocument->GetDocType() != DOCTYPE_STATIC_XFA)
-    return TRUE;
+    return true;
 
   IXFA_DocView* pXFADocView = pDocument->GetXFADocView();
-  if (NULL == pXFADocView)
-    return FALSE;
+  if (!pXFADocView)
+    return false;
+
   IXFA_WidgetHandler* pWidgetHander = pXFADocView->GetWidgetHandler();
-
   CXFA_WidgetAcc* pWidgetAcc = NULL;
   IXFA_WidgetAccIterator* pWidgetAccIterator =
       pXFADocView->CreateWidgetAccIterator();
   pWidgetAcc = pWidgetAccIterator->MoveToNext();
   while (pWidgetAcc) {
     CXFA_EventParam preParam;
     preParam.m_eType = XFA_EVENT_PostSave;
     pWidgetHander->ProcessEvent(pWidgetAcc, &preParam);
     pWidgetAcc = pWidgetAccIterator->MoveToNext();
   }
   pWidgetAccIterator->Release();
   pXFADocView->UpdateDocView();
   pDocument->_ClearChangeMark();
-  return TRUE;
+  return true;
 }
 
-FX_BOOL _SendPreSaveToXFADoc(CPDFXFA_Document* pDocument,
-                             CFX_PtrArray& fileList) {
+bool SendPreSaveToXFADoc(CPDFXFA_Document* pDocument,
+                         std::vector<ScopedFileStream>* fileList) {
   if (pDocument->GetDocType() != DOCTYPE_DYNAMIC_XFA &&
       pDocument->GetDocType() != DOCTYPE_STATIC_XFA)
-    return TRUE;
+    return true;
+
   IXFA_DocView* pXFADocView = pDocument->GetXFADocView();
-  if (NULL == pXFADocView)
-    return TRUE;
+  if (!pXFADocView)
+    return true;
+
   IXFA_WidgetHandler* pWidgetHander = pXFADocView->GetWidgetHandler();
   CXFA_WidgetAcc* pWidgetAcc = NULL;
   IXFA_WidgetAccIterator* pWidgetAccIterator =
       pXFADocView->CreateWidgetAccIterator();
   pWidgetAcc = pWidgetAccIterator->MoveToNext();
   while (pWidgetAcc) {
     CXFA_EventParam preParam;
     preParam.m_eType = XFA_EVENT_PreSave;
     pWidgetHander->ProcessEvent(pWidgetAcc, &preParam);
     pWidgetAcc = pWidgetAccIterator->MoveToNext();
   }
   pWidgetAccIterator->Release();
   pXFADocView->UpdateDocView();
-  return _SaveXFADocumentData(pDocument, fileList);
+  return SaveXFADocumentData(pDocument, fileList);
 }
 #endif  // PDF_ENABLE_XFA
 
-FPDF_BOOL _FPDF_Doc_Save(FPDF_DOCUMENT document,
-                         FPDF_FILEWRITE* pFileWrite,
-                         FPDF_DWORD flags,
-                         FPDF_BOOL bSetVersion,
-                         int fileVerion) {
+bool FPDF_Doc_Save(FPDF_DOCUMENT document,
+                   FPDF_FILEWRITE* pFileWrite,
+                   FPDF_DWORD flags,
+                   FPDF_BOOL bSetVersion,
+                   int fileVerion) {
   CPDF_Document* pPDFDoc = CPDFDocumentFromFPDFDocument(document);
   if (!pPDFDoc)
     return 0;
 
 #ifdef PDF_ENABLE_XFA
-  CPDFXFA_Document* pDoc = (CPDFXFA_Document*)document;
-  CFX_PtrArray fileList;
-  _SendPreSaveToXFADoc(pDoc, fileList);
+  CPDFXFA_Document* pDoc = static_cast<CPDFXFA_Document*>(document);
+  std::vector<ScopedFileStream> fileList;

[Lei Zhang, 2016/02/05 23:32:49]

Do we actually need to hold on to the file streams?

[Tom Sepez, 2016/02/08 17:10:20]

I didn't think so ... given the loop at old line 309 that released them all ...

[Lei Zhang, 2016/02/08 20:10:29]

What I was wonder is, do we need to hold on to the file streams for the entire
duration. I'm guessing the answer is probably yes, so the code is fine as is.

+  SendPreSaveToXFADoc(pDoc, &fileList);
 #endif  // PDF_ENABLE_XFA
 
-  if (flags < FPDF_INCREMENTAL || flags > FPDF_REMOVE_SECURITY) {
+  if (flags < FPDF_INCREMENTAL || flags > FPDF_REMOVE_SECURITY)
     flags = 0;
-  }
 
   CPDF_Creator FileMaker(pPDFDoc);
   if (bSetVersion)
     FileMaker.SetFileVersion(fileVerion);
   if (flags == FPDF_REMOVE_SECURITY) {
     flags = 0;
     FileMaker.RemoveSecurity();
   }
 
   CFX_IFileWrite* pStreamWrite = NULL;
   FX_BOOL bRet;
   pStreamWrite = new CFX_IFileWrite;
   pStreamWrite->Init(pFileWrite);
   bRet = FileMaker.Create(pStreamWrite, flags);
 #ifdef PDF_ENABLE_XFA
-  _SendPostSaveToXFADoc(pDoc);
-  for (int i = 0; i < fileList.GetSize(); i++) {
-    IFX_FileStream* pFile = (IFX_FileStream*)fileList.GetAt(i);
-    pFile->Release();
-  }
-  fileList.RemoveAll();
+  SendPostSaveToXFADoc(pDoc);
 #endif  // PDF_ENABLE_XFA
   pStreamWrite->Release();
   return bRet;
 }
 
+}  // namespace
+
 DLLEXPORT FPDF_BOOL STDCALL FPDF_SaveAsCopy(FPDF_DOCUMENT document,
                                             FPDF_FILEWRITE* pFileWrite,
                                             FPDF_DWORD flags) {
-  return _FPDF_Doc_Save(document, pFileWrite, flags, FALSE, 0);
+  return FPDF_Doc_Save(document, pFileWrite, flags, FALSE, 0);
 }
 
 DLLEXPORT FPDF_BOOL STDCALL FPDF_SaveWithVersion(FPDF_DOCUMENT document,
                                                  FPDF_FILEWRITE* pFileWrite,
                                                  FPDF_DWORD flags,
                                                  int fileVersion) {
-  return _FPDF_Doc_Save(document, pFileWrite, flags, TRUE, fileVersion);
+  return FPDF_Doc_Save(document, pFileWrite, flags, TRUE, fileVersion);
 }