testing/embedder_test.cpp

   1 // Copyright (c) 2015 PDFium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "embedder_test.h"
   6
   7 #include <limits.h>
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11
  12 #include <list>
  13 #include <string>
  14 #include <utility>
  15 #include <vector>
  16
  17 #include "../fpdfsdk/include/fpdftext.h"
  18 #include "../fpdfsdk/include/fpdfview.h"
  19 #include "../core/include/fxcrt/fx_system.h"
  20 #include "testing/gmock/include/gmock/gmock.h"
  21 #include "v8/include/v8.h"
  22 #include "v8/include/libplatform/libplatform.h"
  23
  24 #ifdef _WIN32
  25 #define snprintf _snprintf
  26 #define PATH_SEPARATOR '\\'
  27 #else
  28 #define PATH_SEPARATOR '/'
  29 #endif
  30
  31 namespace {
  32
  33 const char* g_exe_path_ = nullptr;
  34
  35 // Reads the entire contents of a file into a newly malloc'd buffer.
  36 static char* GetFileContents(const char* filename, size_t* retlen) {
  37   FILE* file = fopen(filename, "rb");
  38   if (!file) {
  39     fprintf(stderr, "Failed to open: %s\n", filename);
  40     return NULL;
  41   }
  42   (void) fseek(file, 0, SEEK_END);
  43   size_t file_length = ftell(file);
  44   if (!file_length) {
  45     return NULL;
  46   }
  47   (void) fseek(file, 0, SEEK_SET);
  48   char* buffer = (char*) malloc(file_length);
  49   if (!buffer) {
  50     return NULL;
  51   }
  52   size_t bytes_read = fread(buffer, 1, file_length, file);
  53   (void) fclose(file);
  54   if (bytes_read != file_length) {
  55     fprintf(stderr, "Failed to read: %s\n", filename);
  56     free(buffer);
  57     return NULL;
  58   }
  59   *retlen = bytes_read;
  60   return buffer;
  61 }
  62
  63 #ifdef V8_USE_EXTERNAL_STARTUP_DATA
  64 // Returns the full path for an external V8 data file based on either
  65 // the currect exectuable path or an explicit override.
  66 static std::string GetFullPathForSnapshotFile(const std::string& exe_path,
  67                                               const std::string& filename) {
  68   std::string result;
  69   if (!exe_path.empty()) {
  70     size_t last_separator = exe_path.rfind(PATH_SEPARATOR);
  71     if (last_separator != std::string::npos)  {
  72       result = exe_path.substr(0, last_separator + 1);
  73     }
  74   }
  75   result += filename;
  76   return result;
  77 }
  78
  79 // Reads an extenal V8 data file from the |options|-indicated location,
  80 // returing true on success and false on error.
  81 static bool GetExternalData(const std::string& exe_path,
  82                             const std::string& filename,
  83                             v8::StartupData* result_data) {
  84   std::string full_path = GetFullPathForSnapshotFile(exe_path, filename);
  85   size_t data_length = 0;
  86   char* data_buffer = GetFileContents(full_path.c_str(), &data_length);
  87   if (!data_buffer) {
  88     return false;
  89   }
  90   result_data->data = const_cast<const char*>(data_buffer);
  91   result_data->raw_size = data_length;
  92   return true;
  93 }
  94 #endif  // V8_USE_EXTERNAL_STARTUP_DATA
  95
  96 }  // namespace
  97
  98 class EmbedderTestDefaultDelegate : public EmbedderTest::Delegate {
  99  public:
 100   int Alert(FPDF_WIDESTRING, FPDF_WIDESTRING, int, int) override {
 101     printf("Form_Alert called.\n");
 102     return 0;
 103   }
 104
 105   void UnsupportedHandler(int type) {
 106     std::string feature = "Unknown";
 107     switch (type) {
 108       case FPDF_UNSP_DOC_XFAFORM:
 109         feature = "XFA";
 110         break;
 111       case FPDF_UNSP_DOC_PORTABLECOLLECTION:
 112         feature = "Portfolios_Packages";
 113         break;
 114       case FPDF_UNSP_DOC_ATTACHMENT:
 115       case FPDF_UNSP_ANNOT_ATTACHMENT:
 116         feature = "Attachment";
 117         break;
 118       case FPDF_UNSP_DOC_SECURITY:
 119         feature = "Rights_Management";
 120         break;
 121       case FPDF_UNSP_DOC_SHAREDREVIEW:
 122         feature = "Shared_Review";
 123         break;
 124       case FPDF_UNSP_DOC_SHAREDFORM_ACROBAT:
 125       case FPDF_UNSP_DOC_SHAREDFORM_FILESYSTEM:
 126       case FPDF_UNSP_DOC_SHAREDFORM_EMAIL:
 127         feature = "Shared_Form";
 128         break;
 129       case FPDF_UNSP_ANNOT_3DANNOT:
 130         feature = "3D";
 131         break;
 132       case FPDF_UNSP_ANNOT_MOVIE:
 133         feature = "Movie";
 134         break;
 135       case FPDF_UNSP_ANNOT_SOUND:
 136         feature = "Sound";
 137         break;
 138       case FPDF_UNSP_ANNOT_SCREEN_MEDIA:
 139       case FPDF_UNSP_ANNOT_SCREEN_RICHMEDIA:
 140         feature = "Screen";
 141         break;
 142       case FPDF_UNSP_ANNOT_SIG:
 143         feature = "Digital_Signature";
 144         break;
 145     }
 146     printf("Unsupported feature: %s.\n", feature.c_str());
 147   }
 148 };
 149
 150 class TestLoader {
 151  public:
 152   TestLoader(const char* pBuf, size_t len);
 153
 154   const char* m_pBuf;
 155   size_t m_Len;
 156 };
 157
 158 TestLoader::TestLoader(const char* pBuf, size_t len)
 159     : m_pBuf(pBuf), m_Len(len) {
 160 }
 161
 162 int Get_Block(void* param, unsigned long pos, unsigned char* pBuf,
 163               unsigned long size) {
 164   TestLoader* pLoader = (TestLoader*) param;
 165   if (pos + size < pos || pos + size > pLoader->m_Len) return 0;
 166   memcpy(pBuf, pLoader->m_pBuf + pos, size);
 167   return 1;
 168 }
 169
 170 bool Is_Data_Avail(FX_FILEAVAIL* pThis, size_t offset, size_t size) {
 171   return true;
 172 }
 173
 174 void Add_Segment(FX_DOWNLOADHINTS* pThis, size_t offset, size_t size) {
 175 }
 176
 177 EmbedderTest::EmbedderTest() :
 178       document_(nullptr),
 179       form_handle_(nullptr),
 180       avail_(nullptr),
 181       loader_(nullptr),
 182       file_length_(0),
 183       file_contents_(nullptr) {
 184   memset(&hints_, 0, sizeof(hints_));
 185   memset(&file_access_, 0, sizeof(file_access_));
 186   memset(&file_avail_, 0, sizeof(file_avail_));
 187   default_delegate_ = new EmbedderTestDefaultDelegate();
 188   delegate_ = default_delegate_;
 189 }
 190
 191 EmbedderTest::~EmbedderTest() {
 192   delete default_delegate_;
 193 }
 194
 195 void EmbedderTest::SetUp() {
 196     v8::V8::InitializeICU();
 197   v8::Platform* platform = v8::platform::CreateDefaultPlatform();
 198   v8::V8::InitializePlatform(platform);
 199   v8::V8::Initialize();
 200
 201 #ifdef V8_USE_EXTERNAL_STARTUP_DATA
 202     ASSERT_TRUE(GetExternalData(g_exe_path_, "natives_blob.bin", &natives_));
 203     ASSERT_TRUE(GetExternalData(g_exe_path_, "snapshot_blob.bin", &snapshot_));
 204     v8::V8::SetNativesDataBlob(&natives_);
 205     v8::V8::SetSnapshotDataBlob(&snapshot_);
 206 #endif  // V8_USE_EXTERNAL_STARTUP_DATA
 207
 208     FPDF_InitLibrary();
 209
 210     UNSUPPORT_INFO* info = static_cast<UNSUPPORT_INFO*>(this);
 211     memset(info, 0, sizeof(UNSUPPORT_INFO));
 212     info->version = 1;
 213     info->FSDK_UnSupport_Handler = UnsupportedHandlerTrampoline;
 214     FSDK_SetUnSpObjProcessHandler(info);
 215   }
 216
 217 void EmbedderTest::TearDown() {
 218   if (form_handle_) {
 219     FORM_DoDocumentAAction(form_handle_, FPDFDOC_AACTION_WC);
 220     FPDFDOC_ExitFormFillEnvironment(form_handle_);
 221   }
 222   if (document_) {
 223     FPDF_CloseDocument(document_);
 224   }
 225   FPDFAvail_Destroy(avail_);
 226   FPDF_DestroyLibrary();
 227   if (loader_) {
 228     delete loader_;
 229   }
 230   if (file_contents_) {
 231     free(file_contents_);
 232   }
 233   v8::V8::ShutdownPlatform();
 234 }
 235
 236 bool EmbedderTest::OpenDocument(const std::string& filename) {
 237   file_contents_ = GetFileContents(filename.c_str(), &file_length_);
 238   if (!file_contents_) {
 239     return false;
 240   }
 241
 242   loader_ = new TestLoader(file_contents_, file_length_);
 243   file_access_.m_FileLen = static_cast<unsigned long>(file_length_);
 244   file_access_.m_GetBlock = Get_Block;
 245   file_access_.m_Param = loader_;
 246
 247   file_avail_.version = 1;
 248   file_avail_.IsDataAvail = Is_Data_Avail;
 249
 250   hints_.version = 1;
 251   hints_.AddSegment = Add_Segment;
 252
 253   avail_ = FPDFAvail_Create(&file_avail_, &file_access_);
 254   (void) FPDFAvail_IsDocAvail(avail_, &hints_);
 255
 256   if (!FPDFAvail_IsLinearized(avail_)) {
 257     document_ = FPDF_LoadCustomDocument(&file_access_, NULL);
 258   } else {
 259     document_ = FPDFAvail_GetDocument(avail_, NULL);
 260   }
 261   if (!document_) {
 262     return false;
 263   }
 264   (void) FPDF_LoadXFA(document_);
 265   (void) FPDF_GetDocPermissions(document_);
 266   (void) FPDFAvail_IsFormAvail(avail_, &hints_);
 267
 268   IPDF_JSPLATFORM* platform = static_cast<IPDF_JSPLATFORM*>(this);
 269   memset(platform, 0, sizeof(IPDF_JSPLATFORM));
 270   platform->version = 1;
 271   platform->app_alert = AlertTrampoline;
 272
 273   FPDF_FORMFILLINFO* formfillinfo = static_cast<FPDF_FORMFILLINFO*>(this);
 274   memset(formfillinfo, 0, sizeof(FPDF_FORMFILLINFO));
 275   formfillinfo->version = 1;
 276   formfillinfo->m_pJsPlatform = platform;
 277
 278   form_handle_ = FPDFDOC_InitFormFillEnvironment(document_, formfillinfo);
 279   FPDF_SetFormFieldHighlightColor(form_handle_, 0, 0xFFE4DD);
 280   FPDF_SetFormFieldHighlightAlpha(form_handle_, 100);
 281
 282   return true;
 283 }
 284
 285 void EmbedderTest::DoOpenActions() {
 286   FORM_DoDocumentJSAction(form_handle_);
 287   FORM_DoDocumentOpenAction(form_handle_);
 288 }
 289
 290 int EmbedderTest::GetFirstPageNum() {
 291   int first_page = FPDFAvail_GetFirstPageNum(document_);
 292   (void) FPDFAvail_IsPageAvail(avail_, first_page, &hints_);
 293   return first_page;
 294 }
 295
 296 int EmbedderTest::GetPageCount() {
 297   int page_count = FPDF_GetPageCount(document_);
 298   for (int i = 0; i < page_count; ++i) {
 299     (void) FPDFAvail_IsPageAvail(avail_, i, &hints_);
 300   }
 301   return page_count;
 302 }
 303
 304 FPDF_PAGE EmbedderTest::LoadPage(int page_number) {
 305   FPDF_PAGE page = FPDF_LoadPage(document_, page_number);
 306   if (!page) {
 307     return nullptr;
 308   }
 309   FORM_OnAfterLoadPage(page, form_handle_);
 310   FORM_DoPageAAction(page, form_handle_, FPDFPAGE_AACTION_OPEN);
 311   return page;
 312 }
 313
 314 FPDF_BITMAP EmbedderTest::RenderPage(FPDF_PAGE page) {
 315   int width = static_cast<int>(FPDF_GetPageWidth(page));
 316   int height = static_cast<int>(FPDF_GetPageHeight(page));
 317   FPDF_BITMAP bitmap = FPDFBitmap_Create(width, height, 0);
 318   FPDFBitmap_FillRect(bitmap, 0, 0, width, height, 0xFFFFFFFF);
 319   FPDF_RenderPageBitmap(bitmap, page, 0, 0, width, height, 0, 0);
 320   FPDF_FFLDraw(form_handle_, bitmap, page, 0, 0, width, height, 0, 0);
 321   return bitmap;
 322 }
 323
 324 void EmbedderTest::UnloadPage(FPDF_PAGE page) {
 325   FORM_DoPageAAction(page, form_handle_, FPDFPAGE_AACTION_CLOSE);
 326   FORM_OnBeforeClosePage(page, form_handle_);
 327   FPDF_ClosePage(page);
 328 }
 329
 330 // static
 331 void EmbedderTest::UnsupportedHandlerTrampoline(UNSUPPORT_INFO* info,
 332                                                 int type) {
 333   EmbedderTest* test = static_cast<EmbedderTest*>(info);
 334   test->delegate_->UnsupportedHandler(type);
 335 }
 336
 337 // static
 338 int EmbedderTest::AlertTrampoline(IPDF_JSPLATFORM* platform,
 339                                   FPDF_WIDESTRING message,
 340                                   FPDF_WIDESTRING title,
 341                                   int type,
 342                                   int icon) {
 343   EmbedderTest* test = static_cast<EmbedderTest*>(platform);
 344   return test->delegate_->Alert(message, title, type, icon);
 345 }
 346
 347 // Can't use gtest-provided main since we need to stash the path to the
 348 // executable in order to find the external V8 binary data files.
 349 int main(int argc, char** argv) {
 350   g_exe_path_ = argv[0];
 351   testing::InitGoogleTest(&argc, argv);
 352   testing::InitGoogleMock(&argc, argv);
 353   return RUN_ALL_TESTS();
 354 }