Fix leaks in pdfium_test.

samples/pdfium_test.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include <map>
@@ skipping 59 matching lines @@
 struct FPDF_FORMFILLINFO_PDFiumTest : public FPDF_FORMFILLINFO {
   // Hold a map of the currently loaded pages in order to avoid them
   // to get loaded twice.
   std::map<int, FPDF_PAGE> loadedPages;
 
   // Hold a pointer of FPDF_FORMHANDLE so that PDFium app hooks can
   // make use of it.
   FPDF_FORMHANDLE formHandle;
 };
 
+struct AvailDeleter {
+  inline void operator()(FPDF_AVAIL avail) const { FPDFAvail_Destroy(avail); }
+};
+
 static FPDF_FORMFILLINFO_PDFiumTest* ToPDFiumTestFormFillInfo(
     FPDF_FORMFILLINFO* formFillInfo) {
   return static_cast<FPDF_FORMFILLINFO_PDFiumTest*>(formFillInfo);
 }
 
+static void CloseDocAndForm(FPDF_DOCUMENT doc, FPDF_FORMHANDLE form) {
+#ifdef PDF_ENABLE_XFA
+  // Note: The shut down order here is the reverse of the non-XFA branch order.
+  // Need to work out if this is required, and if it is, the lifetimes of
+  // objects owned by |doc| that |form| reference.
+  FPDF_CloseDocument(doc);
+  FPDFDOC_ExitFormFillEnvironment(form);
+#else   // PDF_ENABLE_XFA
+  FPDFDOC_ExitFormFillEnvironment(form);
+  FPDF_CloseDocument(doc);
+#endif  // PDF_ENABLE_XFA
+}
+
 static bool CheckDimensions(int stride, int width, int height) {
   if (stride < 0 || width < 0 || height < 0)
     return false;
   if (height > 0 && width > INT_MAX / height)
     return false;
   return true;
 }
 
 static void WritePpm(const char* pdf_name, int num, const void* buffer_void,
                      int stride, int width, int height) {
@@ skipping 154 matching lines @@
   Rectangle(dc, 0, 0, width + 1, height + 1);
 
   FPDF_RenderPage(dc, page, 0, 0, width, height, 0,
                   FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH);
 
   DeleteEnhMetaFile(CloseEnhMetaFile(dc));
 }
 #endif
 
 #ifdef PDF_ENABLE_SKIA
-void WriteSkp(const char* pdf_name, int num, const void* recorder) {
+void WriteSkp(const char* pdf_name, int num, SkPictureRecorder* recorder) {
   char filename[256];
   int chars_formatted =
       snprintf(filename, sizeof(filename), "%s.%d.skp", pdf_name, num);
 
   if (chars_formatted < 0 ||
       static_cast<size_t>(chars_formatted) >= sizeof(filename)) {
     fprintf(stderr, "Filename %s is too long\n", filename);
     return;
   }
 
-  SkPictureRecorder* r = (SkPictureRecorder*)recorder;
-  sk_sp<SkPicture> picture(r->finishRecordingAsPicture());
+  sk_sp<SkPicture> picture(recorder->finishRecordingAsPicture());
   SkFILEWStream wStream(filename);
   picture->serialize(&wStream);
 }
 #endif
 
 // These example JS platform callback handlers are entirely optional,
 // and exist here to show the flow of information from a document back
 // to the embedder.
 int ExampleAppAlert(IPDF_JSPLATFORM*,
                     FPDF_WIDESTRING msg,
@@ skipping 329 matching lines @@
         WritePng(name.c_str(), page_index, buffer, stride, width, height);
         break;
 
       case OUTPUT_PPM:
         WritePpm(name.c_str(), page_index, buffer, stride, width, height);
         break;
 
 #ifdef PDF_ENABLE_SKIA
       case OUTPUT_SKP: {
         std::unique_ptr<SkPictureRecorder> recorder(
-            (SkPictureRecorder*)FPDF_RenderPageSkp(page, width, height));
+            reinterpret_cast<SkPictureRecorder*>(
+                FPDF_RenderPageSkp(page, width, height)));
         FPDF_FFLRecord(form, recorder.get(), page, 0, 0, width, height, 0, 0);
         WriteSkp(name.c_str(), page_index, recorder.get());
       } break;
 #endif
       default:
         break;
     }
 
     FPDFBitmap_Destroy(bitmap);
   } else {
@@ skipping 45 matching lines @@
 
   FX_DOWNLOADHINTS hints;
   memset(&hints, '\0', sizeof(hints));
   hints.version = 1;
   hints.AddSegment = Add_Segment;
 
   FPDF_DOCUMENT doc;
   int nRet = PDF_DATA_NOTAVAIL;
   bool bIsLinearized = false;
   FPDF_AVAIL pdf_avail = FPDFAvail_Create(&file_avail, &file_access);
+  std::unique_ptr<void, AvailDeleter> scoped_pdf_avail_deleter(pdf_avail);
 
   if (FPDFAvail_IsLinearized(pdf_avail) == PDF_LINEARIZED) {
     doc = FPDFAvail_GetDocument(pdf_avail, nullptr);
     if (doc) {
       while (nRet == PDF_DATA_NOTAVAIL)
         nRet = FPDFAvail_IsDocAvail(pdf_avail, &hints);
 
       if (nRet == PDF_DATA_ERROR) {
         fprintf(stderr, "Unknown error in checking if doc was available.\n");
+        FPDF_CloseDocument(doc);
         return;
       }
       nRet = FPDFAvail_IsFormAvail(pdf_avail, &hints);
       if (nRet == PDF_FORM_ERROR || nRet == PDF_FORM_NOTAVAIL) {
         fprintf(stderr,
                 "Error %d was returned in checking if form was available.\n",
                 nRet);
+        FPDF_CloseDocument(doc);
         return;
       }
       bIsLinearized = true;
     }
   } else {
     doc = FPDF_LoadCustomDocument(&file_access, nullptr);
   }
 
   if (!doc) {
     unsigned long err = FPDF_GetLastError();
@@ skipping 18 matching lines @@
         fprintf(stderr, "Unsupported security scheme");
         break;
       case FPDF_ERR_PAGE:
         fprintf(stderr, "Page not found or content error");
         break;
       default:
         fprintf(stderr, "Unknown error %ld", err);
     }
     fprintf(stderr, ".\n");
 
-    FPDFAvail_Destroy(pdf_avail);
     return;
   }
 
   (void)FPDF_GetDocPermissions(doc);
 
   FPDF_FORMHANDLE form = FPDFDOC_InitFormFillEnvironment(doc, &form_callbacks);
   form_callbacks.formHandle = form;
 
 #ifdef PDF_ENABLE_XFA
-  int docType = DOCTYPE_PDF;
-  if (FPDF_HasXFAField(doc, &docType) && docType != DOCTYPE_PDF &&
+  int doc_type = DOCTYPE_PDF;
+  if (FPDF_HasXFAField(doc, &doc_type) && doc_type != DOCTYPE_PDF &&
       !FPDF_LoadXFA(doc)) {
     fprintf(stderr, "LoadXFA unsuccessful, continuing anyway.\n");
   }
 #endif  // PDF_ENABLE_XFA
   FPDF_SetFormFieldHighlightColor(form, 0, 0xFFE4DD);
   FPDF_SetFormFieldHighlightAlpha(form, 100);
 
   FORM_DoDocumentJSAction(form);
   FORM_DoDocumentOpenAction(form);
 
   int page_count = FPDF_GetPageCount(doc);
   int rendered_pages = 0;
   int bad_pages = 0;
   for (int i = 0; i < page_count; ++i) {
     if (bIsLinearized) {
       nRet = PDF_DATA_NOTAVAIL;
       while (nRet == PDF_DATA_NOTAVAIL)
         nRet = FPDFAvail_IsPageAvail(pdf_avail, i, &hints);
 
       if (nRet == PDF_DATA_ERROR) {
         fprintf(stderr, "Unknown error in checking if page %d is available.\n",
                 i);
+        CloseDocAndForm(doc, form);
         return;
       }
     }
     if (RenderPage(name, doc, form, form_callbacks, i, options, events))
       ++rendered_pages;
     else
       ++bad_pages;
   }
 
   FORM_DoDocumentAAction(form, FPDFDOC_AACTION_WC);
 
-#ifdef PDF_ENABLE_XFA
-  // Note: The shut down order here is the reverse of the non-XFA branch order.
-  // Need to work out if this is required, and if it is, the lifetimes of
-  // objects owned by |doc| that |form| reference.
-  FPDF_CloseDocument(doc);
-  FPDFDOC_ExitFormFillEnvironment(form);
-#else  // PDF_ENABLE_XFA
-  FPDFDOC_ExitFormFillEnvironment(form);
-  FPDF_CloseDocument(doc);
-#endif  // PDF_ENABLE_XFA
-
-  FPDFAvail_Destroy(pdf_avail);
+  CloseDocAndForm(doc, form);
 
   fprintf(stderr, "Rendered %d pages.\n", rendered_pages);
   if (bad_pages)
     fprintf(stderr, "Skipped %d bad pages.\n", bad_pages);
 }
 
 static void ShowConfig() {
   std::string config;
   std::string maybe_comma;
 #if PDF_ENABLE_V8
@@ skipping 116 matching lines @@
   delete platform;
 
 #ifdef V8_USE_EXTERNAL_STARTUP_DATA
   free(const_cast<char*>(natives.data));
   free(const_cast<char*>(snapshot.data));
 #endif  // V8_USE_EXTERNAL_STARTUP_DATA
 #endif  // PDF_ENABLE_V8
 
   return 0;
 }