Merge to XFA: Fix leaks in the embedder tests themselves.

testing/embedder_test.cpp

 // Copyright (c) 2015 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.
 
 #include "embedder_test.h"
 
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 19 matching lines @@
 
 namespace {
 
 const char* g_exe_path_ = nullptr;
 
 // Reads the entire contents of a file into a newly malloc'd buffer.
 static char* GetFileContents(const char* filename, size_t* retlen) {
   FILE* file = fopen(filename, "rb");
   if (!file) {
     fprintf(stderr, "Failed to open: %s\n", filename);
-    return NULL;
+    return nullptr;
   }
   (void) fseek(file, 0, SEEK_END);
   size_t file_length = ftell(file);
   if (!file_length) {
-    return NULL;
+    return nullptr;
   }
   (void) fseek(file, 0, SEEK_SET);
   char* buffer = (char*) malloc(file_length);
   if (!buffer) {
-    return NULL;
+    return nullptr;
   }
   size_t bytes_read = fread(buffer, 1, file_length, file);
   (void) fclose(file);
   if (bytes_read != file_length) {
     fprintf(stderr, "Failed to read: %s\n", filename);
     free(buffer);
-    return NULL;
+    return nullptr;
   }
   *retlen = bytes_read;
   return buffer;
 }
 
 #ifdef V8_USE_EXTERNAL_STARTUP_DATA
 // Returns the full path for an external V8 data file based on either
 // the currect exectuable path or an explicit override.
 static std::string GetFullPathForSnapshotFile(const std::string& exe_path,
                                               const std::string& filename) {
@@ skipping 140 matching lines @@
     FPDF_InitLibrary();
 
     UNSUPPORT_INFO* info = static_cast<UNSUPPORT_INFO*>(this);
     memset(info, 0, sizeof(UNSUPPORT_INFO));
     info->version = 1;
     info->FSDK_UnSupport_Handler = UnsupportedHandlerTrampoline;
     FSDK_SetUnSpObjProcessHandler(info);
   }
 
 void EmbedderTest::TearDown() {
-  if (form_handle_) {
+  if (document_) {
     FORM_DoDocumentAAction(form_handle_, FPDFDOC_AACTION_WC);
+    FPDF_CloseDocument(document_);
     FPDFDOC_ExitFormFillEnvironment(form_handle_);
   }
-  if (document_) {
-    FPDF_CloseDocument(document_);
-  }
   FPDFAvail_Destroy(avail_);
   FPDF_DestroyLibrary();
-  if (loader_) {
-    delete loader_;
-  }
-  if (file_contents_) {
-    free(file_contents_);
-  }
+  delete loader_;
+  free(file_contents_);
   v8::V8::ShutdownPlatform();
 }
 
 bool EmbedderTest::OpenDocument(const std::string& filename) {
   file_contents_ = GetFileContents(filename.c_str(), &file_length_);
   if (!file_contents_) {
     return false;
   }
 
   loader_ = new TestLoader(file_contents_, file_length_);
   file_access_.m_FileLen = static_cast<unsigned long>(file_length_);
   file_access_.m_GetBlock = Get_Block;
   file_access_.m_Param = loader_;
 
   file_avail_.version = 1;
   file_avail_.IsDataAvail = Is_Data_Avail;
 
   hints_.version = 1;
   hints_.AddSegment = Add_Segment;
 
   avail_ = FPDFAvail_Create(&file_avail_, &file_access_);
   (void) FPDFAvail_IsDocAvail(avail_, &hints_);
 
   if (!FPDFAvail_IsLinearized(avail_)) {
-    document_ = FPDF_LoadCustomDocument(&file_access_, NULL);
+    document_ = FPDF_LoadCustomDocument(&file_access_, nullptr);
   } else {
-    document_ = FPDFAvail_GetDocument(avail_, NULL);
+    document_ = FPDFAvail_GetDocument(avail_, nullptr);
   }
   if (!document_) {
     return false;
   }
   int docType = DOCTYPE_PDF;
   if (FPDF_HasXFAField(document_, &docType))
   {
     if (docType != DOCTYPE_PDF)
       (void) FPDF_LoadXFA(document_);
   }
@@ skipping 80 matching lines @@
 }
 
 // Can't use gtest-provided main since we need to stash the path to the
 // executable in order to find the external V8 binary data files.
 int main(int argc, char** argv) {
   g_exe_path_ = argv[0];
   testing::InitGoogleTest(&argc, argv);
   testing::InitGoogleMock(&argc, argv);
   return RUN_ALL_TESTS();
 }