Run FXJS_V8 embedder tests against a shared isolate.
[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 "../public/fpdf_text.h"
18 #include "../public/fpdfview.h"
19 #include "testing/gmock/include/gmock/gmock.h"
20 #include "v8/include/libplatform/libplatform.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 nullptr;
40   }
41   (void)fseek(file, 0, SEEK_END);
42   size_t file_length = ftell(file);
43   if (!file_length) {
44     return nullptr;
45   }
46   (void)fseek(file, 0, SEEK_SET);
47   char* buffer = (char*)malloc(file_length);
48   if (!buffer) {
49     return nullptr;
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 nullptr;
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 TestLoader {
98  public:
99   TestLoader(const char* pBuf, size_t len);
100
101   const char* m_pBuf;
102   size_t m_Len;
103 };
104
105 TestLoader::TestLoader(const char* pBuf, size_t len)
106     : m_pBuf(pBuf), m_Len(len) {}
107
108 int Get_Block(void* param,
109               unsigned long pos,
110               unsigned char* pBuf,
111               unsigned long size) {
112   TestLoader* pLoader = (TestLoader*)param;
113   if (pos + size < pos || pos + size > pLoader->m_Len)
114     return 0;
115   memcpy(pBuf, pLoader->m_pBuf + pos, size);
116   return 1;
117 }
118
119 FPDF_BOOL Is_Data_Avail(FX_FILEAVAIL* pThis, size_t offset, size_t size) {
120   return true;
121 }
122
123 void Add_Segment(FX_DOWNLOADHINTS* pThis, size_t offset, size_t size) {}
124
125 EmbedderTest::EmbedderTest()
126     : default_delegate_(new EmbedderTest::Delegate()),
127       document_(nullptr),
128       form_handle_(nullptr),
129       avail_(nullptr),
130       external_isolate_(nullptr),
131       loader_(nullptr),
132       file_length_(0),
133       file_contents_(nullptr) {
134   memset(&hints_, 0, sizeof(hints_));
135   memset(&file_access_, 0, sizeof(file_access_));
136   memset(&file_avail_, 0, sizeof(file_avail_));
137   delegate_ = default_delegate_.get();
138 }
139
140 EmbedderTest::~EmbedderTest() {
141 }
142
143 void EmbedderTest::SetUp() {
144   v8::V8::InitializeICU();
145
146   platform_ = v8::platform::CreateDefaultPlatform();
147   v8::V8::InitializePlatform(platform_);
148   v8::V8::Initialize();
149
150   // By enabling predictable mode, V8 won't post any background tasks.
151   const char predictable_flag[] = "--predictable";
152   v8::V8::SetFlagsFromString(predictable_flag,
153                              static_cast<int>(strlen(predictable_flag)));
154
155 #ifdef V8_USE_EXTERNAL_STARTUP_DATA
156   ASSERT_TRUE(GetExternalData(g_exe_path_, "natives_blob.bin", &natives_));
157   ASSERT_TRUE(GetExternalData(g_exe_path_, "snapshot_blob.bin", &snapshot_));
158   v8::V8::SetNativesDataBlob(&natives_);
159   v8::V8::SetSnapshotDataBlob(&snapshot_);
160 #endif  // V8_USE_EXTERNAL_STARTUP_DATA
161
162   FPDF_LIBRARY_CONFIG config;
163   config.version = 2;
164   config.m_pUserFontPaths = nullptr;
165   config.m_pIsolate = external_isolate_;
166   config.m_v8EmbedderSlot = 0;
167   FPDF_InitLibraryWithConfig(&config);
168
169   UNSUPPORT_INFO* info = static_cast<UNSUPPORT_INFO*>(this);
170   memset(info, 0, sizeof(UNSUPPORT_INFO));
171   info->version = 1;
172   info->FSDK_UnSupport_Handler = UnsupportedHandlerTrampoline;
173   FSDK_SetUnSpObjProcessHandler(info);
174 }
175
176 void EmbedderTest::TearDown() {
177   if (document_) {
178     FORM_DoDocumentAAction(form_handle_, FPDFDOC_AACTION_WC);
179     FPDFDOC_ExitFormFillEnvironment(form_handle_);
180     FPDF_CloseDocument(document_);
181   }
182   FPDFAvail_Destroy(avail_);
183   FPDF_DestroyLibrary();
184   v8::V8::ShutdownPlatform();
185   delete platform_;
186   delete loader_;
187   free(file_contents_);
188 }
189
190 bool EmbedderTest::OpenDocument(const std::string& filename) {
191   file_contents_ = GetFileContents(filename.c_str(), &file_length_);
192   if (!file_contents_) {
193     return false;
194   }
195
196   loader_ = new TestLoader(file_contents_, file_length_);
197   file_access_.m_FileLen = static_cast<unsigned long>(file_length_);
198   file_access_.m_GetBlock = Get_Block;
199   file_access_.m_Param = loader_;
200
201   file_avail_.version = 1;
202   file_avail_.IsDataAvail = Is_Data_Avail;
203
204   hints_.version = 1;
205   hints_.AddSegment = Add_Segment;
206
207   avail_ = FPDFAvail_Create(&file_avail_, &file_access_);
208   (void)FPDFAvail_IsDocAvail(avail_, &hints_);
209
210   if (!FPDFAvail_IsLinearized(avail_)) {
211     document_ = FPDF_LoadCustomDocument(&file_access_, nullptr);
212   } else {
213     document_ = FPDFAvail_GetDocument(avail_, nullptr);
214   }
215
216   (void)FPDF_GetDocPermissions(document_);
217   (void)FPDFAvail_IsFormAvail(avail_, &hints_);
218
219   IPDF_JSPLATFORM* platform = static_cast<IPDF_JSPLATFORM*>(this);
220   memset(platform, 0, sizeof(IPDF_JSPLATFORM));
221   platform->version = 2;
222   platform->app_alert = AlertTrampoline;
223
224   FPDF_FORMFILLINFO* formfillinfo = static_cast<FPDF_FORMFILLINFO*>(this);
225   memset(formfillinfo, 0, sizeof(FPDF_FORMFILLINFO));
226   formfillinfo->version = 1;
227   formfillinfo->FFI_SetTimer = SetTimerTrampoline;
228   formfillinfo->FFI_KillTimer = KillTimerTrampoline;
229   formfillinfo->FFI_GetPage = GetPageTrampoline;
230   formfillinfo->m_pJsPlatform = platform;
231
232   form_handle_ = FPDFDOC_InitFormFillEnvironment(document_, formfillinfo);
233   FPDF_SetFormFieldHighlightColor(form_handle_, 0, 0xFFE4DD);
234   FPDF_SetFormFieldHighlightAlpha(form_handle_, 100);
235
236   return true;
237 }
238
239 void EmbedderTest::DoOpenActions() {
240   FORM_DoDocumentJSAction(form_handle_);
241   FORM_DoDocumentOpenAction(form_handle_);
242 }
243
244 int EmbedderTest::GetFirstPageNum() {
245   int first_page = FPDFAvail_GetFirstPageNum(document_);
246   (void)FPDFAvail_IsPageAvail(avail_, first_page, &hints_);
247   return first_page;
248 }
249
250 int EmbedderTest::GetPageCount() {
251   int page_count = FPDF_GetPageCount(document_);
252   for (int i = 0; i < page_count; ++i) {
253     (void)FPDFAvail_IsPageAvail(avail_, i, &hints_);
254   }
255   return page_count;
256 }
257
258 FPDF_PAGE EmbedderTest::LoadPage(int page_number) {
259   FPDF_PAGE page = FPDF_LoadPage(document_, page_number);
260   if (!page) {
261     return nullptr;
262   }
263   FORM_OnAfterLoadPage(page, form_handle_);
264   FORM_DoPageAAction(page, form_handle_, FPDFPAGE_AACTION_OPEN);
265   return page;
266 }
267
268 FPDF_PAGE EmbedderTest::LoadAndCachePage(int page_number) {
269   FPDF_PAGE page = delegate_->GetPage(form_handle_, document_, page_number);
270   if (!page) {
271     return nullptr;
272   }
273   FORM_DoPageAAction(page, form_handle_, FPDFPAGE_AACTION_OPEN);
274   return page;
275 }
276
277 FPDF_BITMAP EmbedderTest::RenderPage(FPDF_PAGE page) {
278   int width = static_cast<int>(FPDF_GetPageWidth(page));
279   int height = static_cast<int>(FPDF_GetPageHeight(page));
280   FPDF_BITMAP bitmap = FPDFBitmap_Create(width, height, 0);
281   FPDFBitmap_FillRect(bitmap, 0, 0, width, height, 0xFFFFFFFF);
282   FPDF_RenderPageBitmap(bitmap, page, 0, 0, width, height, 0, 0);
283   FPDF_FFLDraw(form_handle_, bitmap, page, 0, 0, width, height, 0, 0);
284   return bitmap;
285 }
286
287 void EmbedderTest::UnloadPage(FPDF_PAGE page) {
288   FORM_DoPageAAction(page, form_handle_, FPDFPAGE_AACTION_CLOSE);
289   FORM_OnBeforeClosePage(page, form_handle_);
290   FPDF_ClosePage(page);
291 }
292
293 FPDF_PAGE EmbedderTest::Delegate::GetPage(FPDF_FORMHANDLE form_handle,
294                                           FPDF_DOCUMENT document,
295                                           int page_index) {
296   auto it = m_pageMap.find(page_index);
297   if (it != m_pageMap.end()) {
298     return it->second;
299   }
300   FPDF_PAGE page = FPDF_LoadPage(document, page_index);
301   if (!page) {
302     return nullptr;
303   }
304   m_pageMap[page_index] = page;
305   FORM_OnAfterLoadPage(page, form_handle);
306   return page;
307 }
308
309 // static
310 void EmbedderTest::UnsupportedHandlerTrampoline(UNSUPPORT_INFO* info,
311                                                 int type) {
312   EmbedderTest* test = static_cast<EmbedderTest*>(info);
313   test->delegate_->UnsupportedHandler(type);
314 }
315
316 // static
317 int EmbedderTest::AlertTrampoline(IPDF_JSPLATFORM* platform,
318                                   FPDF_WIDESTRING message,
319                                   FPDF_WIDESTRING title,
320                                   int type,
321                                   int icon) {
322   EmbedderTest* test = static_cast<EmbedderTest*>(platform);
323   return test->delegate_->Alert(message, title, type, icon);
324 }
325
326 // static
327 int EmbedderTest::SetTimerTrampoline(FPDF_FORMFILLINFO* info,
328                                      int msecs,
329                                      TimerCallback fn) {
330   EmbedderTest* test = static_cast<EmbedderTest*>(info);
331   return test->delegate_->SetTimer(msecs, fn);
332 }
333
334 // static
335 void EmbedderTest::KillTimerTrampoline(FPDF_FORMFILLINFO* info, int id) {
336   EmbedderTest* test = static_cast<EmbedderTest*>(info);
337   return test->delegate_->KillTimer(id);
338 }
339
340 // static
341 FPDF_PAGE EmbedderTest::GetPageTrampoline(FPDF_FORMFILLINFO* info,
342                                           FPDF_DOCUMENT document,
343                                           int page_index) {
344   EmbedderTest* test = static_cast<EmbedderTest*>(info);
345   return test->delegate_->GetPage(test->form_handle(), document, page_index);
346 }
347
348 // Can't use gtest-provided main since we need to stash the path to the
349 // executable in order to find the external V8 binary data files.
350 int main(int argc, char** argv) {
351   g_exe_path_ = argv[0];
352   testing::InitGoogleTest(&argc, argv);
353   testing::InitGoogleMock(&argc, argv);
354   return RUN_ALL_TESTS();
355 }