Extend pdfium_test capability so that more Javascript can be executed

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>
 #include <sstream>
 #include <string>
 #include <utility>
 #include <vector>
 
 #if defined PDF_ENABLE_SKIA && !defined _SKIA_SUPPORT_
 #define _SKIA_SUPPORT_
 #endif
 
 #include "public/fpdf_dataavail.h"
@@ skipping 26 matching lines @@
   OUTPUT_PNG,
 #ifdef _WIN32
   OUTPUT_BMP,
   OUTPUT_EMF,
 #endif
 #ifdef PDF_ENABLE_SKIA
   OUTPUT_SKP,
 #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) {}
 
   bool show_config;
   bool send_events;
   OutputFormat output_format;
   std::string scale_factor_as_string;
   std::string exe_path;
   std::string bin_directory;
@@ skipping 447 matching lines @@
         FORM_OnMouseMove(form, page, 0, x, y);
       } else {
         fprintf(stderr, "mousemove: bad args\n");
       }
     } else {
       fprintf(stderr, "Unrecognized event: %s\n", tokens[0].c_str());
     }
   }
 }
 
+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);
 
   double scale = 1.0;
   if (!options.scale_factor_as_string.empty())
     std::stringstream(options.scale_factor_as_string) >> scale;
 
   int width = static_cast<int>(FPDF_GetPageWidth(page) * scale);
   int height = static_cast<int>(FPDF_GetPageHeight(page) * scale);
@@ skipping 40 matching lines @@
       } break;
 #endif
       default:
         break;
     }
 
     FPDFBitmap_Destroy(bitmap);
   } 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);
   FPDF_ClosePage(page);
   return !!bitmap;
 }
 
 void RenderPdf(const std::string& name,
                const char* pBuf,
                size_t len,
                const Options& options,
                const std::string& events) {
   IPDF_JSPLATFORM platform_callbacks;
   memset(&platform_callbacks, '\0', sizeof(platform_callbacks));
   platform_callbacks.version = 3;
   platform_callbacks.app_alert = ExampleAppAlert;
   platform_callbacks.app_response = ExampleAppResponse;
   platform_callbacks.Doc_gotoPage = ExampleDocGotoPage;
   platform_callbacks.Doc_mail = ExampleDocMail;
 
   FPDF_FORMFILLINFO form_callbacks;
   memset(&form_callbacks, '\0', sizeof(form_callbacks));
 #ifdef PDF_ENABLE_XFA
   form_callbacks.version = 2;
 #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);
   FPDF_FILEACCESS file_access;
   memset(&file_access, '\0', sizeof(file_access));
   file_access.m_FileLen = static_cast<unsigned long>(len);
   file_access.m_GetBlock = TestLoader::GetBlock;
   file_access.m_Param = &loader;
 
   FX_FILEAVAIL file_avail;
@@ skipping 63 matching lines @@
         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);
+  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 &&
       !FPDF_LoadXFA(doc)) {
     fprintf(stderr, "LoadXFA unsuccessful, continuing anyway.\n");
   }
 #endif  // PDF_ENABLE_XFA
   FPDF_SetFormFieldHighlightColor(form, 0, 0xFFE4DD);
   FPDF_SetFormFieldHighlightAlpha(form, 100);
 
@@ skipping 164 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;
 }