Gold support in PDFium

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 "core/fdrm/crypto/fx_crypt.h"
 #include "public/fpdf_dataavail.h"
 #include "public/fpdf_edit.h"
 #include "public/fpdf_ext.h"
 #include "public/fpdf_formfill.h"
 #include "public/fpdf_text.h"
 #include "public/fpdfview.h"
 #include "samples/image_diff_png.h"
 #include "testing/test_support.h"
 
 #ifdef _WIN32
@@ skipping 30 matching lines @@
 #ifdef PDF_ENABLE_SKIA
   OUTPUT_SKP,
 #endif
 };
 
 struct Options {
   Options()
       : show_config(false),
         send_events(false),
         pages(false),
+        md5(false),
         output_format(OUTPUT_NONE) {}
 
   bool show_config;
   bool send_events;
   bool pages;
+  bool md5;
   OutputFormat output_format;
   std::string scale_factor_as_string;
   std::string exe_path;
   std::string bin_directory;
   std::string font_directory;
   // 0-based page numbers to be rendered.
   int first_page;
   int last_page;
 };
 
@@ skipping 17 matching lines @@
 }
 
 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) {
+static void OutputMD5Hash(const char* file_name, const char* buffer, int len) {
+  // Get the MD5 hash and write it to stdout.
+  uint8_t digest[16];
+  CRYPT_MD5Generate(reinterpret_cast<const uint8_t*>(buffer), len, digest);
+  printf("MD5:%s:", file_name);
+  for (int i = 0; i < 16; i++)
+    printf("%02x", digest[i]);
+  printf("\n");
+}
+
+static std::string WritePpm(const char* pdf_name,
+                            int num,
+                            const void* buffer_void,
+                            int stride,
+                            int width,
+                            int height) {
   const char* buffer = reinterpret_cast<const char*>(buffer_void);
 
   if (!CheckDimensions(stride, width, height))
-    return;
+    return "";
 
   int out_len = width * height;
   if (out_len > INT_MAX / 3)
-    return;
+    return "";
   out_len *= 3;
 
   char filename[256];
   snprintf(filename, sizeof(filename), "%s.%d.ppm", pdf_name, num);
   FILE* fp = fopen(filename, "wb");
   if (!fp)
-    return;
+    return "";
   fprintf(fp, "P6\n# PDF test render\n%d %d\n255\n", width, height);
   // Source data is B, G, R, unused.
   // Dest data is R, G, B.
   std::vector<char> result(out_len);
   for (int h = 0; h < height; ++h) {
     const char* src_line = buffer + (stride * h);
     char* dest_line = result.data() + (width * h * 3);
     for (int w = 0; w < width; ++w) {
       // R
       dest_line[w * 3] = src_line[(w * 4) + 2];
       // G
       dest_line[(w * 3) + 1] = src_line[(w * 4) + 1];
       // B
       dest_line[(w * 3) + 2] = src_line[w * 4];
     }
   }
   fwrite(result.data(), out_len, 1, fp);
   fclose(fp);
+  return std::string(filename);
 }
 
 void WriteText(FPDF_PAGE page, const char* pdf_name, int num) {
   char filename[256];
   int chars_formatted =
       snprintf(filename, sizeof(filename), "%s.%d.txt", pdf_name, num);
   if (chars_formatted < 0 ||
       static_cast<size_t>(chars_formatted) >= sizeof(filename)) {
     fprintf(stderr, "Filename %s is too long\n", filename);
     return;
@@ skipping 13 matching lines @@
   for (int i = 0; i < FPDFText_CountChars(textpage); i++) {
     uint32_t c = FPDFText_GetUnicode(textpage, i);
     fwrite(&c, sizeof(c), 1, fp);
   }
 
   FPDFText_ClosePage(textpage);
 
   (void)fclose(fp);
 }
 
-static void WritePng(const char* pdf_name, int num, const void* buffer_void,
-                     int stride, int width, int height) {
+static std::string WritePng(const char* pdf_name,
+                            int num,
+                            const void* buffer_void,
+                            int stride,
+                            int width,
+                            int height) {
   if (!CheckDimensions(stride, width, height))
-    return;
+    return "";
 
   std::vector<unsigned char> png_encoding;
   const unsigned char* buffer = static_cast<const unsigned char*>(buffer_void);
   if (!image_diff_png::EncodeBGRAPNG(
           buffer, width, height, stride, false, &png_encoding)) {
     fprintf(stderr, "Failed to convert bitmap to PNG\n");
-    return;
+    return "";
   }
 
   char filename[256];
   int chars_formatted = snprintf(
       filename, sizeof(filename), "%s.%d.png", pdf_name, num);
   if (chars_formatted < 0 ||
       static_cast<size_t>(chars_formatted) >= sizeof(filename)) {
     fprintf(stderr, "Filename %s is too long\n", filename);
-    return;
+    return "";
   }
 
   FILE* fp = fopen(filename, "wb");
   if (!fp) {
     fprintf(stderr, "Failed to open %s for output\n", filename);
-    return;
+    return "";
   }
 
   size_t bytes_written = fwrite(
       &png_encoding.front(), 1, png_encoding.size(), fp);
   if (bytes_written != png_encoding.size())
     fprintf(stderr, "Failed to write to  %s\n", filename);
 
   (void)fclose(fp);
+  return std::string(filename);
 }
 
 #ifdef _WIN32
-static void WriteBmp(const char* pdf_name, int num, const void* buffer,
-                     int stride, int width, int height) {
+static std::string WriteBmp(const char* pdf_name,
+                            int num,
+                            const void* buffer,
+                            int stride,
+                            int width,
+                            int height) {
   if (!CheckDimensions(stride, width, height))
-    return;
+    return "";
 
   int out_len = stride * height;
   if (out_len > INT_MAX / 3)
-    return;
+    return "";
 
   char filename[256];
   snprintf(filename, sizeof(filename), "%s.%d.bmp", pdf_name, num);
   FILE* fp = fopen(filename, "wb");
   if (!fp)
-    return;
+    return "";
 
   BITMAPINFO bmi = {};
   bmi.bmiHeader.biSize = sizeof(bmi) - sizeof(RGBQUAD);
   bmi.bmiHeader.biWidth = width;
   bmi.bmiHeader.biHeight = -height;  // top-down image
   bmi.bmiHeader.biPlanes = 1;
   bmi.bmiHeader.biBitCount = 32;
   bmi.bmiHeader.biCompression = BI_RGB;
   bmi.bmiHeader.biSizeImage = 0;
 
   BITMAPFILEHEADER file_header = {};
   file_header.bfType = 0x4d42;
   file_header.bfSize = sizeof(file_header) + bmi.bmiHeader.biSize + out_len;
   file_header.bfOffBits = file_header.bfSize - out_len;
 
   fwrite(&file_header, sizeof(file_header), 1, fp);
   fwrite(&bmi, bmi.bmiHeader.biSize, 1, fp);
   fwrite(buffer, out_len, 1, fp);
   fclose(fp);
+  return std::string(filename);
 }
 
 void WriteEmf(FPDF_PAGE page, const char* pdf_name, int num) {
   int width = static_cast<int>(FPDF_GetPageWidth(page));
   int height = static_cast<int>(FPDF_GetPageHeight(page));
 
   char filename[256];
   snprintf(filename, sizeof(filename), "%s.%d.emf", pdf_name, num);
 
   HDC dc = CreateEnhMetaFileA(nullptr, filename, nullptr, nullptr);
 
   HRGN rgn = CreateRectRgn(0, 0, width, height);
   SelectClipRgn(dc, rgn);
   DeleteObject(rgn);
 
   SelectObject(dc, GetStockObject(NULL_PEN));
   SelectObject(dc, GetStockObject(WHITE_BRUSH));
   // If a PS_NULL pen is used, the dimensions of the rectangle are 1 pixel less.
   Rectangle(dc, 0, 0, width + 1, height + 1);
 
   FPDF_RenderPage(dc, page, 0, 0, width, height, 0,
                   FPDF_ANNOT | FPDF_PRINTING | FPDF_NO_CATCH);
 
   DeleteEnhMetaFile(CloseEnhMetaFile(dc));
 }
 #endif
 
 #ifdef PDF_ENABLE_SKIA
-void WriteSkp(const char* pdf_name, int num, SkPictureRecorder* recorder) {
+static std::string WriteSkp(const char* pdf_name,
+                            int num,
+                            SkPictureRecorder* recorder) {
   char filename[256];
   int chars_formatted =
       snprintf(filename, sizeof(filename), "%s.%d.skp", pdf_name, num);
 
   if (chars_formatted < 0 ||
       static_cast<size_t>(chars_formatted) >= sizeof(filename)) {
     fprintf(stderr, "Filename %s is too long\n", filename);
-    return;
+    return "";
   }
 
   sk_sp<SkPicture> picture(recorder->finishRecordingAsPicture());
   SkFILEWStream wStream(filename);
   picture->serialize(&wStream);
+  return std::string(filename);
 }
 #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 type,
@@ skipping 181 matching lines @@
       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(pages_string.substr(0, first_dash)) >>
             options->first_page;
         std::stringstream(pages_string.substr(first_dash + 1)) >>
             options->last_page;
       }
+    } else if (cur_arg == "--md5") {
+      options->md5 = true;
     } 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]);
 
@@ skipping 118 matching lines @@
   if (bitmap) {
     FPDF_DWORD fill_color = alpha ? 0x00000000 : 0xFFFFFFFF;
     FPDFBitmap_FillRect(bitmap, 0, 0, width, height, fill_color);
     FPDF_RenderPageBitmap(bitmap, page, 0, 0, width, height, 0, FPDF_ANNOT);
 
     FPDF_FFLDraw(form, bitmap, page, 0, 0, width, height, 0, FPDF_ANNOT);
     int stride = FPDFBitmap_GetStride(bitmap);
     const char* buffer =
         reinterpret_cast<const char*>(FPDFBitmap_GetBuffer(bitmap));
 
+    std::string&& image_file_name = "";
     switch (options.output_format) {
 #ifdef _WIN32
       case OUTPUT_BMP:
-        WriteBmp(name.c_str(), page_index, buffer, stride, width, height);
+        image_file_name =
+            WriteBmp(name.c_str(), page_index, buffer, stride, width, height);
         break;
 
       case OUTPUT_EMF:
         WriteEmf(page, name.c_str(), page_index);
         break;
 #endif
       case OUTPUT_TEXT:
         WriteText(page, name.c_str(), page_index);
         break;
 
       case OUTPUT_PNG:
-        WritePng(name.c_str(), page_index, buffer, stride, width, height);
+        image_file_name =
+            WritePng(name.c_str(), page_index, buffer, stride, width, height);
         break;
 
       case OUTPUT_PPM:
-        WritePpm(name.c_str(), page_index, buffer, stride, width, height);
+        image_file_name =
+            WritePpm(name.c_str(), page_index, buffer, stride, width, height);
         break;
 
 #ifdef PDF_ENABLE_SKIA
       case OUTPUT_SKP: {
         std::unique_ptr<SkPictureRecorder> recorder(
             reinterpret_cast<SkPictureRecorder*>(
                 FPDF_RenderPageSkp(page, width, height)));
         FPDF_FFLRecord(form, recorder.get(), page, 0, 0, width, height, 0, 0);
-        WriteSkp(name.c_str(), page_index, recorder.get());
+        image_file_name = WriteSkp(name.c_str(), page_index, recorder.get());
       } break;
 #endif
       default:
         break;
     }
 
+    // Write the filename and the MD5 of the buffer to stdout if we wrote a
+    // file.
+    if (options.md5 && image_file_name != "")
+      OutputMD5Hash(image_file_name.c_str(), buffer, stride * height);
+
     FPDFBitmap_Destroy(bitmap);
   } else {
     fprintf(stderr, "Page was too large to be rendered.\n");
   }
 
   form_fill_info.loaded_pages.erase(page_index);
 
   FORM_DoPageAAction(page, form, FPDFPAGE_AACTION_CLOSE);
   FORM_OnBeforeClosePage(page, form);
   FPDFText_ClosePage(text_page);
@@ skipping 189 matching lines @@
 #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
+    "  --md5 - write output image paths and their md5 hashes to stdout.\n"
     "";
 
 int main(int argc, const char* argv[]) {
   std::vector<std::string> args(argv, argv + argc);
   Options options;
   std::vector<std::string> files;
   if (!ParseCommandLine(args, &options, &files)) {
     fprintf(stderr, "%s", kUsageString);
     return 1;
   }
@@ skipping 76 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;
 }