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