Avoid static initializers and global variables 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 36 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;
-
-// Hold a global pointer of FPDF_FORMHANDLE so that PDFium
-// app hooks can made use of it.
-FPDF_FORMHANDLE g_formHandle;
-
 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;
   std::string font_directory;
 };
 
+typedef struct {

[Tom Sepez, 2016/09/12 17:19:41]

nit: In C++, we can avoid "typedef" adn just write:
 
struct PDFiumTest_FPDF_FORMFILLINFO {

[tonikitoo, 2016/09/12 23:41:55]

Done.

+  FPDF_FORMFILLINFO formInfo;
+
+  // 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;
+} PDFiumTest_FPDF_FORMFILLINFO;
+
+static PDFiumTest_FPDF_FORMFILLINFO* ToPDFiumTestFormFillInfo(

[Tom Sepez, 2016/09/12 17:19:40]

It might be cleaner if PDFiumTest_FPDF_FORMFILLINFO inherited from
FPDF_FORMFILLINFO, then we can static_cast<> in one direction, and just rely on
the compiler to automatically promote in the other direction.

[tonikitoo, 2016/09/12 23:41:55]

Done.

+    FPDF_FORMFILLINFO* formFillInfo) {
+  return reinterpret_cast<PDFiumTest_FPDF_FORMFILLINFO*>(formFillInfo);
+}
+
+static FPDF_FORMFILLINFO* ToFormFillInfo(
+    PDFiumTest_FPDF_FORMFILLINFO* pdfiumTestFormFillInfo) {
+  return reinterpret_cast<FPDF_FORMFILLINFO*>(pdfiumTestFormFillInfo);
+}
+
 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 437 matching lines @@
       }
     } 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())
+  PDFiumTest_FPDF_FORMFILLINFO* formFillInfo = ToPDFiumTestFormFillInfo(param);
+  std::map<int, FPDF_PAGE>& loadedPages = formFillInfo->loadedPages;
+
+  auto iter = loadedPages.find(index);
+  if (iter != 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);
+  FPDF_FORMHANDLE& formHandle = formFillInfo->formHandle;
 
-  g_loadedPages[index] = page;
+  FORM_OnAfterLoadPage(page, formHandle);
+  FORM_DoPageAAction(page, formHandle, FPDFPAGE_AACTION_OPEN);
+
+  loadedPages[index] = page;
   return page;
 }
 
 bool RenderPage(const std::string& name,
                 FPDF_DOCUMENT doc,
                 FPDF_FORMHANDLE& form,
+                FPDF_FORMFILLINFO& formFillInfo,
                 const int page_index,
                 const Options& options,
                 const std::string& events) {
-  FPDF_PAGE page = GetPageForIndex(nullptr, doc, page_index);
+  FPDF_PAGE page = GetPageForIndex(&formFillInfo, doc, page_index);
   if (!page)
     return false;
 
   FPDF_TEXTPAGE text_page = FPDFText_LoadPage(page);
 
   if (options.send_events)
     SendPageEvents(form, page, events);
 
   double scale = 1.0;
   if (!options.scale_factor_as_string.empty())
@@ skipping 45 matching lines @@
 #endif
       default:
         break;
     }
 
     FPDFBitmap_Destroy(bitmap);
   } else {
     fprintf(stderr, "Page was too large to be rendered.\n");
   }
 
-  g_loadedPages.erase(page_index);
+  PDFiumTest_FPDF_FORMFILLINFO* pdfiumTestFormFillInfo =
+      ToPDFiumTestFormFillInfo(&formFillInfo);
+  pdfiumTestFormFillInfo->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,
@@ skipping 91 matching lines @@
         fprintf(stderr, "Unknown error %ld", err);
     }
     fprintf(stderr, ".\n");
 
     FPDFAvail_Destroy(pdf_avail);
     return;
   }
 
   (void)FPDF_GetDocPermissions(doc);
 
-  FPDF_FORMHANDLE form = g_formHandle =
-      FPDFDOC_InitFormFillEnvironment(doc, &form_callbacks);
+  std::unique_ptr<PDFiumTest_FPDF_FORMFILLINFO> pdfiumTestFormFillInfo(
+      new PDFiumTest_FPDF_FORMFILLINFO);
+  pdfiumTestFormFillInfo->formInfo = form_callbacks;
+
+  FPDF_FORMFILLINFO* formFillInfo =
+      ToFormFillInfo(pdfiumTestFormFillInfo.get());
+
+  FPDF_FORMHANDLE form = FPDFDOC_InitFormFillEnvironment(doc, formFillInfo);
+  pdfiumTestFormFillInfo->formHandle = form;
+
 #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);
 
   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);
         return;
       }
     }
-    if (RenderPage(name, doc, form, i, options, events))
+    if (RenderPage(name, doc, form, *formFillInfo, 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
@@ skipping 135 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;
 }