Add tests to exercise FPDF_SaveAsCopy().

testing/embedder_test.cpp

 // Copyright 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 "testing/embedder_test.h"
 
 #include <limits.h>
 
 #include <list>
 #include <string>
@@ skipping 41 matching lines @@
   InitializeV8ForPDFium(g_exe_path_, std::string(), &natives_, &snapshot_,
                         &platform_);
 #else
   InitializeV8ForPDFium(&platform_);
 #endif  // V8_USE_EXTERNAL_STARTUP_DATA
 #endif  // FPDF_ENABLE_V8
 }
 
 EmbedderTest::~EmbedderTest() {}
 
+//  static
+bool EmbedderTest::LoadDocument(const char* data,
+                                size_t data_size,
+                                bool must_linearize,
+                                TestLoader* loader,
+                                EmbedderTest* embedder_test,
+                                LoadDocumentData* out_data) {
+  out_data->file_access->m_FileLen = static_cast<unsigned long>(data_size);
+  out_data->file_access->m_GetBlock = TestLoader::GetBlock;
+  out_data->file_access->m_Param = loader;
+
+  out_data->file_avail->version = 1;
+  out_data->file_avail->IsDataAvail = Is_Data_Avail;
+
+  out_data->hints->version = 1;
+  out_data->hints->AddSegment = Add_Segment;
+
+  *out_data->avail =
+      FPDFAvail_Create(out_data->file_avail, out_data->file_access);
+
+  if (FPDFAvail_IsLinearized(*out_data->avail) == PDF_LINEARIZED) {
+    *out_data->document = FPDFAvail_GetDocument(*out_data->avail, nullptr);
+    if (!*out_data->document) {
+      return false;
+    }
+    int32_t nRet = PDF_DATA_NOTAVAIL;
+    while (nRet == PDF_DATA_NOTAVAIL) {
+      nRet = FPDFAvail_IsDocAvail(*out_data->avail, out_data->hints);
+    }
+    if (nRet == PDF_DATA_ERROR) {
+      return false;
+    }
+    nRet = FPDFAvail_IsFormAvail(*out_data->avail, out_data->hints);
+    if (nRet == PDF_FORM_ERROR || nRet == PDF_FORM_NOTAVAIL) {
+      return false;
+    }
+    int page_count = FPDF_GetPageCount(*out_data->document);
+    for (int i = 0; i < page_count; ++i) {
+      nRet = PDF_DATA_NOTAVAIL;
+      while (nRet == PDF_DATA_NOTAVAIL) {
+        nRet = FPDFAvail_IsPageAvail(*out_data->avail, i, out_data->hints);

[Wei Li, 2016/01/04 19:01:13]

I know this is from the original code, but worth checking. Will this enter
infinite loop if page load failed? For example, PreparePageItem may return false
while setting status as error (fpdf_parser_parser.cpp:3337).

[Lei Zhang, 2016/01/07 02:50:58]

Maybe. If you can create a test case that does that, you can change
FPDFAvail_IsPageAvail() to detect the infinite loop and return PDF_DATA_ERROR.
samples/pdfium_test.cc has this pattern as well.

+      }
+      if (nRet == PDF_DATA_ERROR) {
+        return false;
+      }
+    }
+  } else {
+    if (must_linearize) {
+      return false;
+    }
+    *out_data->document =
+        FPDF_LoadCustomDocument(out_data->file_access, nullptr);
+    if (!*out_data->document) {
+      return false;
+    }
+  }
+
+  (void)FPDF_GetDocPermissions(*out_data->document);
+
+  if (embedder_test) {
+    IPDF_JSPLATFORM* platform = static_cast<IPDF_JSPLATFORM*>(embedder_test);
+    memset(platform, 0, sizeof(IPDF_JSPLATFORM));
+    platform->version = 2;
+    platform->app_alert = AlertTrampoline;
+
+    FPDF_FORMFILLINFO* formfillinfo =
+        static_cast<FPDF_FORMFILLINFO*>(embedder_test);
+    memset(formfillinfo, 0, sizeof(FPDF_FORMFILLINFO));
+    formfillinfo->version = 1;
+    formfillinfo->FFI_SetTimer = SetTimerTrampoline;
+    formfillinfo->FFI_KillTimer = KillTimerTrampoline;
+    formfillinfo->FFI_GetPage = GetPageTrampoline;
+    formfillinfo->m_pJsPlatform = platform;
+
+    *out_data->form_handle =
+        FPDFDOC_InitFormFillEnvironment(*out_data->document, formfillinfo);
+    FPDF_SetFormFieldHighlightColor(*out_data->form_handle, 0, 0xFFE4DD);
+    FPDF_SetFormFieldHighlightAlpha(*out_data->form_handle, 100);
+  } else {
+    *out_data->form_handle = nullptr;
+  }
+
+  return true;
+}
+
 void EmbedderTest::SetUp() {
   FPDF_LIBRARY_CONFIG config;
   config.version = 2;
   config.m_pUserFontPaths = nullptr;
   config.m_v8EmbedderSlot = 0;
   config.m_pIsolate = external_isolate_;
   FPDF_InitLibraryWithConfig(&config);
 
   UNSUPPORT_INFO* info = static_cast<UNSUPPORT_INFO*>(this);
   memset(info, 0, sizeof(UNSUPPORT_INFO));
@@ skipping 23 matching lines @@
 bool EmbedderTest::OpenDocument(const std::string& filename,
                                 bool must_linearize) {
   std::string file_path;
   if (!PathService::GetTestFilePath(filename, &file_path))
     return false;
   file_contents_ = GetFileContents(file_path.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 = TestLoader::GetBlock;
-  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_);
-
-  if (FPDFAvail_IsLinearized(avail_) == PDF_LINEARIZED) {
-    document_ = FPDFAvail_GetDocument(avail_, nullptr);
-    if (!document_) {
-      return false;
-    }
-    int32_t nRet = PDF_DATA_NOTAVAIL;
-    while (nRet == PDF_DATA_NOTAVAIL) {
-      nRet = FPDFAvail_IsDocAvail(avail_, &hints_);
-    }
-    if (nRet == PDF_DATA_ERROR) {
-      return false;
-    }
-    nRet = FPDFAvail_IsFormAvail(avail_, &hints_);
-    if (nRet == PDF_FORM_ERROR || nRet == PDF_FORM_NOTAVAIL) {
-      return false;
-    }
-    int page_count = FPDF_GetPageCount(document_);
-    for (int i = 0; i < page_count; ++i) {
-      nRet = PDF_DATA_NOTAVAIL;
-      while (nRet == PDF_DATA_NOTAVAIL) {
-        nRet = FPDFAvail_IsPageAvail(avail_, i, &hints_);
-      }
-      if (nRet == PDF_DATA_ERROR) {
-        return false;
-      }
-    }
-  } else {
-    if (must_linearize) {
-      return false;
-    }
-    document_ = FPDF_LoadCustomDocument(&file_access_, nullptr);
-    if (!document_) {
-      return false;
-    }
-  }
-
-  (void)FPDF_GetDocPermissions(document_);
-
-  IPDF_JSPLATFORM* platform = static_cast<IPDF_JSPLATFORM*>(this);
-  memset(platform, 0, sizeof(IPDF_JSPLATFORM));
-  platform->version = 2;
-  platform->app_alert = AlertTrampoline;
-
-  FPDF_FORMFILLINFO* formfillinfo = static_cast<FPDF_FORMFILLINFO*>(this);
-  memset(formfillinfo, 0, sizeof(FPDF_FORMFILLINFO));
-  formfillinfo->version = 1;
-  formfillinfo->FFI_SetTimer = SetTimerTrampoline;
-  formfillinfo->FFI_KillTimer = KillTimerTrampoline;
-  formfillinfo->FFI_GetPage = GetPageTrampoline;
-  formfillinfo->m_pJsPlatform = platform;
-
-  form_handle_ = FPDFDOC_InitFormFillEnvironment(document_, formfillinfo);
-  FPDF_SetFormFieldHighlightColor(form_handle_, 0, 0xFFE4DD);
-  FPDF_SetFormFieldHighlightAlpha(form_handle_, 100);
-
-  return true;
+  LoadDocumentData load_data;
+  load_data.document = &document_;
+  load_data.file_access = &file_access_;
+  load_data.file_avail = &file_avail_;
+  load_data.avail = &avail_;
+  load_data.hints = &hints_;
+  load_data.form_handle = &form_handle_;
+  return LoadDocument(file_contents_, file_length_, must_linearize, loader_,
+                      this, &load_data);
 }
 
 void EmbedderTest::DoOpenActions() {
   FORM_DoDocumentJSAction(form_handle_);
   FORM_DoDocumentOpenAction(form_handle_);
 }
 
 int EmbedderTest::GetFirstPageNum() {
   int first_page = FPDFAvail_GetFirstPageNum(document_);
   (void)FPDFAvail_IsPageAvail(avail_, first_page, &hints_);
@@ skipping 99 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();
 }