Extend pdfium_test capability so that more Javascript can be executed

samples/pdfium_test.cc

Index: samples/pdfium_test.cc
diff --git a/samples/pdfium_test.cc b/samples/pdfium_test.cc
index da2d1f6977fa45e71fdf72ea756e96a9426a68e3..421df39bf3cdfe30d56326dad52a585e444ea490 100644
--- a/samples/pdfium_test.cc
+++ b/samples/pdfium_test.cc
@@ -7,6 +7,7 @@
 #include <stdlib.h>
 #include <string.h>
 
+#include <map>
 #include <sstream>
 #include <string>
 #include <utility>
@@ -53,6 +54,14 @@ enum OutputFormat {
 #endif
 };
 
+// Hold a map of the currently loaded pages in order to avoid them
+// to get loaded twice.
+std::map<int, FPDF_PAGE> g_loadedPages;

[dsinclair, 2016/08/25 19:36:49]

It may actually be closer to what Chromium is doing by not keeping the map and
creating the pages on the fly.

Chromium will discard pages when they aren't in view in order to save memory.
This can at times trigger bugs in PDFium as we execute JS that access pages that
are no longer loaded.

(Correct me if I'm wrong Lei)

[tonikitoo, 2016/08/25 19:48:58]

Chromium keeps track of the pages in src/pdf/pdfium/pdfium_engine.h

44 class PDFiumEngine 
(..)
621   std::vector<PDFiumPage*> pages_; 

Then Chromium's FFI_GetPage hook looks like this:

3474 FPDF_PAGE PDFiumEngine::Form_GetPage(FPDF_FORMFILLINFO* param,
3475                                      FPDF_DOCUMENT document,
3476                                      int page_index) {
3477   PDFiumEngine* engine = static_cast<PDFiumEngine*>(param);
3478   if (page_index < 0 || page_index >=
static_cast<int>(engine->pages_.size()))
3479     return nullptr;
3480   return engine->pages_[page_index]->GetPage();
3481 }   

PDfiumPage::GetPage loads the page similarly to what GetPageForIndex is doing.
 
Please keep in mind that when the page is rendered (into PNG or whatever other
output format), it gets discarded afterwards. That part of the logic did not
change.

In summary, we'd load a page 'i' into memory if:

1) JS, for instance, needs it.

2) when RenderPage() is called

After (2) runs, page is discarded.
 
Thanks for looking, Dan. It'd be indeed great to have Lei's eyes too.

[Lei Zhang, 2016/08/27 01:03:23]

I believe this actually adds a static initializer, which is not ideal.

[Lei Zhang, 2016/08/27 01:03:23]

Form_GetPage() does reload the page as shown. The Chrome PDF Viewer does have
the choice to unload a page if it like to. The actual implementation is a bit
more complex because we need to avoid bonehead maneuvers like unloading while
unloading.

+
+// Hold a global pointer of FPDF_FORMHANDLE so that PDFium
+// app hooks can made use of it.
+FPDF_FORMHANDLE g_formHandle;

[Lei Zhang, 2016/08/27 01:03:23]

It would have been nice to use GetPageForIndex()'s |param| argument to pass this
around, instead of having a global. Maybe make the param a struct to pass in
|g_loadedPages| as well.

+
 struct Options {
   Options()
       : show_config(false), send_events(false), output_format(OUTPUT_NONE) {}
@@ -520,19 +529,35 @@ void SendPageEvents(const FPDF_FORMHANDLE& form,
   }
 }
 
+FPDF_PAGE GetPageForIndex(FPDF_FORMFILLINFO* param,
+                          FPDF_DOCUMENT doc,
+                          int index) {
+  auto iter = g_loadedPages.find(index);
+  if (iter != g_loadedPages.end())
+    return iter->second;
+
+  FPDF_PAGE page = FPDF_LoadPage(doc, index);
+  if (!page)
+    return nullptr;
+
+  FORM_OnAfterLoadPage(page, g_formHandle);
+  FORM_DoPageAAction(page, g_formHandle, FPDFPAGE_AACTION_OPEN);
+
+  g_loadedPages[index] = page;
+  return page;
+}
+
 bool RenderPage(const std::string& name,
-                const FPDF_DOCUMENT& doc,
-                const FPDF_FORMHANDLE& form,
+                FPDF_DOCUMENT doc,
+                FPDF_FORMHANDLE& form,
                 const int page_index,
                 const Options& options,
                 const std::string& events) {
-  FPDF_PAGE page = FPDF_LoadPage(doc, page_index);
+  FPDF_PAGE page = GetPageForIndex(nullptr, doc, page_index);
   if (!page)
     return false;
 
   FPDF_TEXTPAGE text_page = FPDFText_LoadPage(page);
-  FORM_OnAfterLoadPage(page, form);
-  FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_OPEN);
 
   if (options.send_events)
     SendPageEvents(form, page, events);
@@ -593,6 +618,8 @@ bool RenderPage(const std::string& name,
   } else {
     fprintf(stderr, "Page was too large to be rendered.\n");
   }
+
+  g_loadedPages.erase(page_index);
   FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_CLOSE);
   FORM_OnBeforeClosePage(page, form);
   FPDFText_ClosePage(text_page);
@@ -620,6 +647,7 @@ void RenderPdf(const std::string& name,
 #else   // PDF_ENABLE_XFA
   form_callbacks.version = 1;
 #endif  // PDF_ENABLE_XFA
+  form_callbacks.FFI_GetPage = GetPageForIndex;
   form_callbacks.m_pJsPlatform = &platform_callbacks;
 
   TestLoader loader(pBuf, len);
@@ -703,7 +731,8 @@ void RenderPdf(const std::string& name,
 
   (void)FPDF_GetDocPermissions(doc);
 
-  FPDF_FORMHANDLE form = FPDFDOC_InitFormFillEnvironment(doc, &form_callbacks);
+  FPDF_FORMHANDLE form = g_formHandle =
+      FPDFDOC_InitFormFillEnvironment(doc, &form_callbacks);
 #ifdef PDF_ENABLE_XFA
   int docType = DOCTYPE_PDF;
   if (FPDF_HasXFAField(doc, &docType) && docType != DOCTYPE_PDF &&