Nits 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 59 matching lines @@
         output_format(OUTPUT_NONE) {}
 
   bool show_config;
   bool send_events;
   bool pages;
   OutputFormat output_format;
   std::string scale_factor_as_string;
   std::string exe_path;
   std::string bin_directory;
   std::string font_directory;
-  int firstPage;
-  int lastPage;
+  // 0-based page numbers to be rendered.
+  int first_page;
+  int last_page;
 };
 
 struct FPDF_FORMFILLINFO_PDFiumTest : public FPDF_FORMFILLINFO {
   // Hold a map of the currently loaded pages in order to avoid them
   // to get loaded twice.
-  std::map<int, FPDF_PAGE> loadedPages;
+  std::map<int, FPDF_PAGE> loaded_pages;
 
   // Hold a pointer of FPDF_FORMHANDLE so that PDFium app hooks can
   // make use of it.
-  FPDF_FORMHANDLE formHandle;
+  FPDF_FORMHANDLE form_handle;
 };
 
 struct AvailDeleter {
   inline void operator()(FPDF_AVAIL avail) const { FPDFAvail_Destroy(avail); }
 };
 
 static FPDF_FORMFILLINFO_PDFiumTest* ToPDFiumTestFormFillInfo(
-    FPDF_FORMFILLINFO* formFillInfo) {
-  return static_cast<FPDF_FORMFILLINFO_PDFiumTest*>(formFillInfo);
+    FPDF_FORMFILLINFO* form_fill_info) {
+  return static_cast<FPDF_FORMFILLINFO_PDFiumTest*>(form_fill_info);
 }
 
 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;
 }
 
@@ skipping 179 matching lines @@
   picture->serialize(&wStream);
 }
 #endif
 
 // These example JS platform callback handlers are entirely optional,
 // and exist here to show the flow of information from a document back
 // to the embedder.
 int ExampleAppAlert(IPDF_JSPLATFORM*,
                     FPDF_WIDESTRING msg,
                     FPDF_WIDESTRING title,
-                    int nType,
-                    int nIcon) {
+                    int type,
+                    int icon) {
   printf("%ls", GetPlatformWString(title).c_str());
-  if (nIcon || nType)
-    printf("[icon=%d,type=%d]", nIcon, nType);
+  if (icon || type)
+    printf("[icon=%d,type=%d]", icon, type);
   printf(": %ls\n", GetPlatformWString(msg).c_str());
   return 0;
 }
 
 int ExampleAppResponse(IPDF_JSPLATFORM*,
                        FPDF_WIDESTRING question,
                        FPDF_WIDESTRING title,
-                       FPDF_WIDESTRING defaultValue,
+                       FPDF_WIDESTRING default_value,
                        FPDF_WIDESTRING label,
-                       FPDF_BOOL isPassword,
+                       FPDF_BOOL is_password,
                        void* response,
                        int length) {
   printf("%ls: %ls, defaultValue=%ls, label=%ls, isPassword=%d, length=%d\n",
          GetPlatformWString(title).c_str(),
          GetPlatformWString(question).c_str(),
-         GetPlatformWString(defaultValue).c_str(),
-         GetPlatformWString(label).c_str(), isPassword, length);
+         GetPlatformWString(default_value).c_str(),
+         GetPlatformWString(label).c_str(), is_password, length);
 
   // UTF-16, always LE regardless of platform.
   uint8_t* ptr = static_cast<uint8_t*>(response);
   ptr[0] = 'N';
   ptr[1] = 0;
   ptr[2] = 'o';
   ptr[3] = 0;
   return 4;
 }
 
-void ExampleDocGotoPage(IPDF_JSPLATFORM*, int pageNumber) {
-  printf("Goto Page: %d\n", pageNumber);
+void ExampleDocGotoPage(IPDF_JSPLATFORM*, int page_number) {
+  printf("Goto Page: %d\n", page_number);
 }
 
 void ExampleDocMail(IPDF_JSPLATFORM*,
                     void* mailData,
                     int length,
-                    FPDF_BOOL bUI,
+                    FPDF_BOOL UI,
                     FPDF_WIDESTRING To,
                     FPDF_WIDESTRING Subject,
                     FPDF_WIDESTRING CC,
                     FPDF_WIDESTRING BCC,
                     FPDF_WIDESTRING Msg) {
-  printf("Mail Msg: %d, to=%ls, cc=%ls, bcc=%ls, subject=%ls, body=%ls\n", bUI,
+  printf("Mail Msg: %d, to=%ls, cc=%ls, bcc=%ls, subject=%ls, body=%ls\n", UI,
          GetPlatformWString(To).c_str(), GetPlatformWString(CC).c_str(),
          GetPlatformWString(BCC).c_str(), GetPlatformWString(Subject).c_str(),
          GetPlatformWString(Msg).c_str());
 }
 
 void ExampleUnsupportedHandler(UNSUPPORT_INFO*, int type) {
   std::string feature = "Unknown";
   switch (type) {
     case FPDF_UNSP_DOC_XFAFORM:
       feature = "XFA";
@@ skipping 115 matching lines @@
         fprintf(stderr, "Duplicate --scale argument\n");
         return false;
       }
       options->scale_factor_as_string = cur_arg.substr(8);
     } else if (cur_arg.size() > 8 && cur_arg.compare(0, 8, "--pages=") == 0) {
       if (options->pages) {
         fprintf(stderr, "Duplicate --pages argument\n");
         return false;
       }
       options->pages = true;
-      const std::string pagesstring = cur_arg.substr(8);
-      size_t firstdash = pagesstring.find("-");
-      if (firstdash == std::string::npos) {
-        std::stringstream(pagesstring) >> options->firstPage;
-        options->lastPage = options->firstPage;
+      const std::string pages_string = cur_arg.substr(8);
+      size_t first_dash = pages_string.find("-");
+      if (first_dash == std::string::npos) {
+        std::stringstream(pages_string) >> options->first_page;
+        options->last_page = options->first_page;
       } else {
-        std::stringstream(pagesstring.substr(0, firstdash)) >>
-            options->firstPage;
-        std::stringstream(pagesstring.substr(firstdash + 1)) >>
-            options->lastPage;
+        std::stringstream(pages_string.substr(0, first_dash)) >>
+            options->first_page;
+        std::stringstream(pages_string.substr(first_dash + 1)) >>
+            options->last_page;
       }
     } else if (cur_arg.size() >= 2 && cur_arg[0] == '-' && cur_arg[1] == '-') {
       fprintf(stderr, "Unrecognized argument %s\n", cur_arg.c_str());
       return false;
     } else {
       break;
     }
   }
   for (size_t i = cur_idx; i < args.size(); i++)
     files->push_back(args[i]);
 
   return true;
 }
 
-FPDF_BOOL Is_Data_Avail(FX_FILEAVAIL* pThis, size_t offset, size_t size) {
+FPDF_BOOL Is_Data_Avail(FX_FILEAVAIL* avail, size_t offset, size_t size) {
   return true;
 }
 
-void Add_Segment(FX_DOWNLOADHINTS* pThis, size_t offset, size_t size) {
-}
+void Add_Segment(FX_DOWNLOADHINTS* hints, size_t offset, size_t size) {}
 
 void SendPageEvents(const FPDF_FORMHANDLE& form,
                     const FPDF_PAGE& page,
                     const std::string& events) {
   auto lines = StringSplit(events, '\n');
   for (auto line : lines) {
     auto command = StringSplit(line, '#');
     if (command[0].empty())
       continue;
     auto tokens = StringSplit(command[0], ',');
@@ skipping 45 matching lines @@
       }
     } else {
       fprintf(stderr, "Unrecognized event: %s\n", tokens[0].c_str());
     }
   }
 }
 
 FPDF_PAGE GetPageForIndex(FPDF_FORMFILLINFO* param,
                           FPDF_DOCUMENT doc,
                           int index) {
-  FPDF_FORMFILLINFO_PDFiumTest* formFillInfo = ToPDFiumTestFormFillInfo(param);
-  auto& loadedPages = formFillInfo->loadedPages;
+  FPDF_FORMFILLINFO_PDFiumTest* form_fill_info =
+      ToPDFiumTestFormFillInfo(param);
+  auto& loaded_pages = form_fill_info->loaded_pages;
 
-  auto iter = loadedPages.find(index);
-  if (iter != loadedPages.end())
+  auto iter = loaded_pages.find(index);
+  if (iter != loaded_pages.end())
     return iter->second;
 
   FPDF_PAGE page = FPDF_LoadPage(doc, index);
   if (!page)
     return nullptr;
 
-  FPDF_FORMHANDLE& formHandle = formFillInfo->formHandle;
+  FPDF_FORMHANDLE& form_handle = form_fill_info->form_handle;
 
-  FORM_OnAfterLoadPage(page, formHandle);
-  FORM_DoPageAAction(page, formHandle, FPDFPAGE_AACTION_OPEN);
+  FORM_OnAfterLoadPage(page, form_handle);
+  FORM_DoPageAAction(page, form_handle, FPDFPAGE_AACTION_OPEN);
 
-  loadedPages[index] = page;
+  loaded_pages[index] = page;
   return page;
 }
 
 bool RenderPage(const std::string& name,
                 FPDF_DOCUMENT doc,
                 FPDF_FORMHANDLE& form,
-                FPDF_FORMFILLINFO_PDFiumTest& formFillInfo,
+                FPDF_FORMFILLINFO_PDFiumTest& form_fill_info,
                 const int page_index,
                 const Options& options,
                 const std::string& events) {
-  FPDF_PAGE page = GetPageForIndex(&formFillInfo, doc, page_index);
+  FPDF_PAGE page = GetPageForIndex(&form_fill_info, 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 46 matching lines @@
 #endif
       default:
         break;
     }
 
     FPDFBitmap_Destroy(bitmap);
   } else {
     fprintf(stderr, "Page was too large to be rendered.\n");
   }
 
-  formFillInfo.loadedPages.erase(page_index);
+  form_fill_info.loaded_pages.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,
@@ skipping 94 matching lines @@
         fprintf(stderr, "Unknown error %ld", err);
     }
     fprintf(stderr, ".\n");
 
     return;
   }
 
   (void)FPDF_GetDocPermissions(doc);
 
   FPDF_FORMHANDLE form = FPDFDOC_InitFormFillEnvironment(doc, &form_callbacks);
-  form_callbacks.formHandle = form;
+  form_callbacks.form_handle = form;
 
 #ifdef PDF_ENABLE_XFA
   int doc_type = DOCTYPE_PDF;
   if (FPDF_HasXFAField(doc, &doc_type) && doc_type != 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;
-  int firstPage = options.pages ? options.firstPage : 0;
-  int lastPage = options.pages ? options.lastPage + 1 : page_count;
-  for (int i = firstPage; i < lastPage; ++i) {
+  int first_page = options.pages ? options.first_page : 0;
+  int last_page = options.pages ? options.last_page + 1 : page_count;
+  for (int i = first_page; i < last_page; ++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);
         FPDFDOC_ExitFormFillEnvironment(form);
         FPDF_CloseDocument(doc);
@@ skipping 37 matching lines @@
   printf("%s\n", config.c_str());
 }
 
 static const char kUsageString[] =
     "Usage: pdfium_test [OPTION] [FILE]...\n"
     "  --show-config     - print build options and exit\n"
     "  --send-events     - send input described by .evt file\n"
     "  --bin-dir=<path>  - override path to v8 external data\n"
     "  --font-dir=<path> - override path to external fonts\n"
     "  --scale=<number>  - scale output size by number (e.g. 0.5)\n"
-    "  --pages=<number>(-<number>) - only render the given page(s)\n"
+    "  --pages=<number>(-<number>) - only render the given 0-based page(s)\n"
 #ifdef _WIN32
     "  --bmp - write page images <pdf-name>.<page-number>.bmp\n"
     "  --emf - write page meta files <pdf-name>.<page-number>.emf\n"
 #endif  // _WIN32
     "  --txt - write page text in UTF32-LE <pdf-name>.<page-number>.txt\n"
     "  --png - write page images <pdf-name>.<page-number>.png\n"
     "  --ppm - write page images <pdf-name>.<page-number>.ppm\n"
 #ifdef PDF_ENABLE_SKIA
     "  --skp - write page images <pdf-name>.<page-number>.skp\n"
 #endif
@@ skipping 37 matching lines @@
   config.m_v8EmbedderSlot = 0;
 
   const char* path_array[2];
   if (!options.font_directory.empty()) {
     path_array[0] = options.font_directory.c_str();
     path_array[1] = nullptr;
     config.m_pUserFontPaths = path_array;
   }
   FPDF_InitLibraryWithConfig(&config);
 
-  UNSUPPORT_INFO unsuppored_info;
-  memset(&unsuppored_info, '\0', sizeof(unsuppored_info));
-  unsuppored_info.version = 1;
-  unsuppored_info.FSDK_UnSupport_Handler = ExampleUnsupportedHandler;
+  UNSUPPORT_INFO unsupported_info;
+  memset(&unsupported_info, '\0', sizeof(unsupported_info));
+  unsupported_info.version = 1;
+  unsupported_info.FSDK_UnSupport_Handler = ExampleUnsupportedHandler;
 
-  FSDK_SetUnSpObjProcessHandler(&unsuppored_info);
+  FSDK_SetUnSpObjProcessHandler(&unsupported_info);
 
   for (const std::string& filename : files) {
     size_t file_length = 0;
     std::unique_ptr<char, pdfium::FreeDeleter> file_contents =
         GetFileContents(filename.c_str(), &file_length);
     if (!file_contents)
       continue;
     fprintf(stderr, "Rendering PDF file %s.\n", filename.c_str());
     std::string events;
     if (options.send_events) {
@@ skipping 23 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;
 }