1 // Copyright 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 "testing/embedder_test.h"
6
7 #include <limits.h>
8
9 #include <fstream>
10 #include <list>
11 #include <string>
12 #include <utility>
13 #include <vector>
14
15 #include "core/fdrm/crypto/fx_crypt.h"
16 #include "public/fpdf_dataavail.h"
17 #include "public/fpdf_edit.h"
18 #include "public/fpdf_text.h"
19 #include "public/fpdfview.h"
20 #include "testing/gmock/include/gmock/gmock.h"
21 #include "testing/image_diff/image_diff_png.h"
22 #include "testing/test_support.h"
23 #include "testing/utils/path_service.h"
24 #include "third_party/base/ptr_util.h"
25
26 #ifdef PDF_ENABLE_V8
27 #include "v8/include/v8-platform.h"
28 #include "v8/include/v8.h"
29 #endif // PDF_ENABLE_V8
30
31 namespace {
32
GetBitmapBytesPerPixel(FPDF_BITMAP bitmap)33 int GetBitmapBytesPerPixel(FPDF_BITMAP bitmap) {
34 const int format = FPDFBitmap_GetFormat(bitmap);
35 switch (format) {
36 case FPDFBitmap_Gray:
37 return 1;
38 case FPDFBitmap_BGR:
39 return 3;
40 case FPDFBitmap_BGRx:
41 case FPDFBitmap_BGRA:
42 return 4;
43 default:
44 ASSERT(false);
45 return 0;
46 }
47 }
48
49 } // namespace
50
EmbedderTest()51 EmbedderTest::EmbedderTest()
52 : default_delegate_(new EmbedderTest::Delegate()),
53 document_(nullptr),
54 form_handle_(nullptr),
55 avail_(nullptr),
56 external_isolate_(nullptr),
57 loader_(nullptr),
58 file_length_(0),
59 file_contents_(nullptr) {
60 memset(&file_access_, 0, sizeof(file_access_));
61 delegate_ = default_delegate_.get();
62
63 FPDF_FILEWRITE::version = 1;
64 FPDF_FILEWRITE::WriteBlock = WriteBlockCallback;
65 }
66
~EmbedderTest()67 EmbedderTest::~EmbedderTest() {}
68
SetUp()69 void EmbedderTest::SetUp() {
70 FPDF_LIBRARY_CONFIG config;
71 config.version = 2;
72 config.m_pUserFontPaths = nullptr;
73 config.m_v8EmbedderSlot = 0;
74 config.m_pIsolate = external_isolate_;
75 FPDF_InitLibraryWithConfig(&config);
76
77 UNSUPPORT_INFO* info = static_cast<UNSUPPORT_INFO*>(this);
78 memset(info, 0, sizeof(UNSUPPORT_INFO));
79 info->version = 1;
80 info->FSDK_UnSupport_Handler = UnsupportedHandlerTrampoline;
81 FSDK_SetUnSpObjProcessHandler(info);
82
83 m_SavedDocument = nullptr;
84 }
85
TearDown()86 void EmbedderTest::TearDown() {
87 if (document_) {
88 FORM_DoDocumentAAction(form_handle_, FPDFDOC_AACTION_WC);
89 FPDFDOC_ExitFormFillEnvironment(form_handle_);
90 FPDF_CloseDocument(document_);
91 }
92
93 FPDFAvail_Destroy(avail_);
94 FPDF_DestroyLibrary();
95 delete loader_;
96 }
97
CreateEmptyDocument()98 bool EmbedderTest::CreateEmptyDocument() {
99 document_ = FPDF_CreateNewDocument();
100 if (!document_)
101 return false;
102
103 form_handle_ = SetupFormFillEnvironment(document_);
104 return true;
105 }
106
OpenDocument(const std::string & filename)107 bool EmbedderTest::OpenDocument(const std::string& filename) {
108 return OpenDocumentWithOptions(filename, nullptr, false);
109 }
110
OpenDocumentLinearized(const std::string & filename)111 bool EmbedderTest::OpenDocumentLinearized(const std::string& filename) {
112 return OpenDocumentWithOptions(filename, nullptr, true);
113 }
114
OpenDocumentWithPassword(const std::string & filename,const char * password)115 bool EmbedderTest::OpenDocumentWithPassword(const std::string& filename,
116 const char* password) {
117 return OpenDocumentWithOptions(filename, password, false);
118 }
119
OpenDocumentWithOptions(const std::string & filename,const char * password,bool must_linearize)120 bool EmbedderTest::OpenDocumentWithOptions(const std::string& filename,
121 const char* password,
122 bool must_linearize) {
123 std::string file_path;
124 if (!PathService::GetTestFilePath(filename, &file_path))
125 return false;
126 file_contents_ = GetFileContents(file_path.c_str(), &file_length_);
127 if (!file_contents_)
128 return false;
129
130 EXPECT_TRUE(!loader_);
131 loader_ = new TestLoader(file_contents_.get(), file_length_);
132 file_access_.m_FileLen = static_cast<unsigned long>(file_length_);
133 file_access_.m_GetBlock = TestLoader::GetBlock;
134 file_access_.m_Param = loader_;
135 fake_file_access_ = pdfium::MakeUnique<FakeFileAccess>(&file_access_);
136 return OpenDocumentHelper(password, must_linearize, fake_file_access_.get(),
137 &document_, &avail_, &form_handle_);
138 }
139
OpenDocumentHelper(const char * password,bool must_linearize,FakeFileAccess * network_simulator,FPDF_DOCUMENT * document,FPDF_AVAIL * avail,FPDF_FORMHANDLE * form_handle)140 bool EmbedderTest::OpenDocumentHelper(const char* password,
141 bool must_linearize,
142 FakeFileAccess* network_simulator,
143 FPDF_DOCUMENT* document,
144 FPDF_AVAIL* avail,
145 FPDF_FORMHANDLE* form_handle) {
146 network_simulator->AddSegment(0, 1024);
147 network_simulator->SetRequestedDataAvailable();
148 *avail = FPDFAvail_Create(network_simulator->GetFileAvail(),
149 network_simulator->GetFileAccess());
150 if (FPDFAvail_IsLinearized(*avail) == PDF_LINEARIZED) {
151 int32_t nRet = PDF_DATA_NOTAVAIL;
152 while (nRet == PDF_DATA_NOTAVAIL) {
153 network_simulator->SetRequestedDataAvailable();
154 nRet =
155 FPDFAvail_IsDocAvail(*avail, network_simulator->GetDownloadHints());
156 }
157 if (nRet == PDF_DATA_ERROR)
158 return false;
159
160 *document = FPDFAvail_GetDocument(*avail, password);
161 if (!*document)
162 return false;
163
164 nRet = PDF_DATA_NOTAVAIL;
165 while (nRet == PDF_DATA_NOTAVAIL) {
166 network_simulator->SetRequestedDataAvailable();
167 nRet =
168 FPDFAvail_IsFormAvail(*avail, network_simulator->GetDownloadHints());
169 }
170 if (nRet == PDF_FORM_ERROR)
171 return false;
172
173 int page_count = FPDF_GetPageCount(*document);
174 for (int i = 0; i < page_count; ++i) {
175 nRet = PDF_DATA_NOTAVAIL;
176 while (nRet == PDF_DATA_NOTAVAIL) {
177 network_simulator->SetRequestedDataAvailable();
178 nRet = FPDFAvail_IsPageAvail(*avail, i,
179 network_simulator->GetDownloadHints());
180 }
181
182 if (nRet == PDF_DATA_ERROR)
183 return false;
184 }
185 } else {
186 if (must_linearize)
187 return false;
188 network_simulator->SetWholeFileAvailable();
189 *document =
190 FPDF_LoadCustomDocument(network_simulator->GetFileAccess(), password);
191 if (!*document)
192 return false;
193 }
194 *form_handle = SetupFormFillEnvironment(*document);
195 #ifdef PDF_ENABLE_XFA
196 int doc_type = FPDF_GetFormType(*document);
197 if (doc_type == FORMTYPE_XFA_FULL || doc_type == FORMTYPE_XFA_FOREGROUND)
198 FPDF_LoadXFA(*document);
199 #endif // PDF_ENABLE_XFA
200 (void)FPDF_GetDocPermissions(*document);
201 return true;
202 }
203
SetupFormFillEnvironment(FPDF_DOCUMENT doc)204 FPDF_FORMHANDLE EmbedderTest::SetupFormFillEnvironment(FPDF_DOCUMENT doc) {
205 IPDF_JSPLATFORM* platform = static_cast<IPDF_JSPLATFORM*>(this);
206 memset(platform, '\0', sizeof(IPDF_JSPLATFORM));
207 platform->version = 2;
208 platform->app_alert = AlertTrampoline;
209 platform->m_isolate = external_isolate_;
210
211 FPDF_FORMFILLINFO* formfillinfo = static_cast<FPDF_FORMFILLINFO*>(this);
212 memset(formfillinfo, 0, sizeof(FPDF_FORMFILLINFO));
213 #ifdef PDF_ENABLE_XFA
214 formfillinfo->version = 2;
215 #else // PDF_ENABLE_XFA
216 formfillinfo->version = 1;
217 #endif // PDF_ENABLE_XFA
218 formfillinfo->FFI_SetTimer = SetTimerTrampoline;
219 formfillinfo->FFI_KillTimer = KillTimerTrampoline;
220 formfillinfo->FFI_GetPage = GetPageTrampoline;
221 formfillinfo->m_pJsPlatform = platform;
222 FPDF_FORMHANDLE form_handle =
223 FPDFDOC_InitFormFillEnvironment(doc, formfillinfo);
224 FPDF_SetFormFieldHighlightColor(form_handle, FPDF_FORMFIELD_UNKNOWN,
225 0xFFE4DD);
226 FPDF_SetFormFieldHighlightAlpha(form_handle, 100);
227 return form_handle;
228 }
229
DoOpenActions()230 void EmbedderTest::DoOpenActions() {
231 ASSERT(form_handle_);
232 FORM_DoDocumentJSAction(form_handle_);
233 FORM_DoDocumentOpenAction(form_handle_);
234 }
235
GetFirstPageNum()236 int EmbedderTest::GetFirstPageNum() {
237 int first_page = FPDFAvail_GetFirstPageNum(document_);
238 (void)FPDFAvail_IsPageAvail(avail_, first_page,
239 fake_file_access_->GetDownloadHints());
240 return first_page;
241 }
242
GetPageCount()243 int EmbedderTest::GetPageCount() {
244 int page_count = FPDF_GetPageCount(document_);
245 for (int i = 0; i < page_count; ++i)
246 (void)FPDFAvail_IsPageAvail(avail_, i,
247 fake_file_access_->GetDownloadHints());
248 return page_count;
249 }
250
LoadPage(int page_number)251 FPDF_PAGE EmbedderTest::LoadPage(int page_number) {
252 ASSERT(form_handle_);
253 // First check whether it is loaded already.
254 auto it = page_map_.find(page_number);
255 if (it != page_map_.end())
256 return it->second;
257
258 FPDF_PAGE page = FPDF_LoadPage(document_, page_number);
259 if (!page)
260 return nullptr;
261
262 FORM_OnAfterLoadPage(page, form_handle_);
263 FORM_DoPageAAction(page, form_handle_, FPDFPAGE_AACTION_OPEN);
264 // Cache the page.
265 page_map_[page_number] = page;
266 page_reverse_map_[page] = page_number;
267 return page;
268 }
269
RenderPage(FPDF_PAGE page)270 FPDF_BITMAP EmbedderTest::RenderPage(FPDF_PAGE page) {
271 return RenderPageWithFlags(page, form_handle_, 0);
272 }
273
RenderPageWithFlags(FPDF_PAGE page,FPDF_FORMHANDLE handle,int flags)274 FPDF_BITMAP EmbedderTest::RenderPageWithFlags(FPDF_PAGE page,
275 FPDF_FORMHANDLE handle,
276 int flags) {
277 int width = static_cast<int>(FPDF_GetPageWidth(page));
278 int height = static_cast<int>(FPDF_GetPageHeight(page));
279 int alpha = FPDFPage_HasTransparency(page) ? 1 : 0;
280 FPDF_BITMAP bitmap = FPDFBitmap_Create(width, height, alpha);
281 FPDF_DWORD fill_color = alpha ? 0x00000000 : 0xFFFFFFFF;
282 FPDFBitmap_FillRect(bitmap, 0, 0, width, height, fill_color);
283 FPDF_RenderPageBitmap(bitmap, page, 0, 0, width, height, 0, flags);
284 FPDF_FFLDraw(handle, bitmap, page, 0, 0, width, height, 0, flags);
285 return bitmap;
286 }
287
UnloadPage(FPDF_PAGE page)288 void EmbedderTest::UnloadPage(FPDF_PAGE page) {
289 ASSERT(form_handle_);
290 FORM_DoPageAAction(page, form_handle_, FPDFPAGE_AACTION_CLOSE);
291 FORM_OnBeforeClosePage(page, form_handle_);
292 FPDF_ClosePage(page);
293
294 auto it = page_reverse_map_.find(page);
295 if (it == page_reverse_map_.end())
296 return;
297
298 page_map_.erase(it->second);
299 page_reverse_map_.erase(it);
300 }
301
OpenSavedDocument(const char * password)302 FPDF_DOCUMENT EmbedderTest::OpenSavedDocument(const char* password) {
303 memset(&saved_file_access_, 0, sizeof(saved_file_access_));
304 saved_file_access_.m_FileLen = m_String.size();
305 saved_file_access_.m_GetBlock = GetBlockFromString;
306 saved_file_access_.m_Param = &m_String;
307
308 saved_fake_file_access_ =
309 pdfium::MakeUnique<FakeFileAccess>(&saved_file_access_);
310
311 EXPECT_TRUE(OpenDocumentHelper(password, false, saved_fake_file_access_.get(),
312 &m_SavedDocument, &m_SavedAvail,
313 &m_SavedForm));
314 return m_SavedDocument;
315 }
316
CloseSavedDocument()317 void EmbedderTest::CloseSavedDocument() {
318 ASSERT(m_SavedDocument);
319
320 FPDFDOC_ExitFormFillEnvironment(m_SavedForm);
321 FPDF_CloseDocument(m_SavedDocument);
322 FPDFAvail_Destroy(m_SavedAvail);
323
324 m_SavedForm = nullptr;
325 m_SavedDocument = nullptr;
326 m_SavedAvail = nullptr;
327 }
328
LoadSavedPage(int page_number)329 FPDF_PAGE EmbedderTest::LoadSavedPage(int page_number) {
330 ASSERT(m_SavedDocument);
331
332 EXPECT_LT(page_number, FPDF_GetPageCount(m_SavedDocument));
333 FPDF_PAGE page = FPDF_LoadPage(m_SavedDocument, page_number);
334
335 ASSERT(page);
336 return page;
337 }
338
RenderSavedPage(FPDF_PAGE page)339 FPDF_BITMAP EmbedderTest::RenderSavedPage(FPDF_PAGE page) {
340 return RenderPageWithFlags(page, m_SavedForm, 0);
341 }
342
CloseSavedPage(FPDF_PAGE page)343 void EmbedderTest::CloseSavedPage(FPDF_PAGE page) {
344 ASSERT(page);
345 FPDF_ClosePage(page);
346 }
347
VerifySavedRendering(FPDF_PAGE page,int width,int height,const char * md5)348 void EmbedderTest::VerifySavedRendering(FPDF_PAGE page,
349 int width,
350 int height,
351 const char* md5) {
352 ASSERT(m_SavedDocument);
353 ASSERT(page);
354
355 FPDF_BITMAP new_bitmap = RenderPageWithFlags(page, m_SavedForm, FPDF_ANNOT);
356 CompareBitmap(new_bitmap, width, height, md5);
357 FPDFBitmap_Destroy(new_bitmap);
358 }
359
VerifySavedDocument(int width,int height,const char * md5)360 void EmbedderTest::VerifySavedDocument(int width, int height, const char* md5) {
361 OpenSavedDocument();
362 FPDF_PAGE page = LoadSavedPage(0);
363 VerifySavedRendering(page, width, height, md5);
364 CloseSavedPage(page);
365 CloseSavedDocument();
366 }
367
SetWholeFileAvailable()368 void EmbedderTest::SetWholeFileAvailable() {
369 ASSERT(fake_file_access_);
370 fake_file_access_->SetWholeFileAvailable();
371 }
372
GetPage(FPDF_FORMFILLINFO * info,FPDF_DOCUMENT document,int page_index)373 FPDF_PAGE EmbedderTest::Delegate::GetPage(FPDF_FORMFILLINFO* info,
374 FPDF_DOCUMENT document,
375 int page_index) {
376 EmbedderTest* test = static_cast<EmbedderTest*>(info);
377 auto it = test->page_map_.find(page_index);
378 return it != test->page_map_.end() ? it->second : nullptr;
379 }
380
381 // static
UnsupportedHandlerTrampoline(UNSUPPORT_INFO * info,int type)382 void EmbedderTest::UnsupportedHandlerTrampoline(UNSUPPORT_INFO* info,
383 int type) {
384 EmbedderTest* test = static_cast<EmbedderTest*>(info);
385 test->delegate_->UnsupportedHandler(type);
386 }
387
388 // static
AlertTrampoline(IPDF_JSPLATFORM * platform,FPDF_WIDESTRING message,FPDF_WIDESTRING title,int type,int icon)389 int EmbedderTest::AlertTrampoline(IPDF_JSPLATFORM* platform,
390 FPDF_WIDESTRING message,
391 FPDF_WIDESTRING title,
392 int type,
393 int icon) {
394 EmbedderTest* test = static_cast<EmbedderTest*>(platform);
395 return test->delegate_->Alert(message, title, type, icon);
396 }
397
398 // static
SetTimerTrampoline(FPDF_FORMFILLINFO * info,int msecs,TimerCallback fn)399 int EmbedderTest::SetTimerTrampoline(FPDF_FORMFILLINFO* info,
400 int msecs,
401 TimerCallback fn) {
402 EmbedderTest* test = static_cast<EmbedderTest*>(info);
403 return test->delegate_->SetTimer(msecs, fn);
404 }
405
406 // static
KillTimerTrampoline(FPDF_FORMFILLINFO * info,int id)407 void EmbedderTest::KillTimerTrampoline(FPDF_FORMFILLINFO* info, int id) {
408 EmbedderTest* test = static_cast<EmbedderTest*>(info);
409 return test->delegate_->KillTimer(id);
410 }
411
412 // static
GetPageTrampoline(FPDF_FORMFILLINFO * info,FPDF_DOCUMENT document,int page_index)413 FPDF_PAGE EmbedderTest::GetPageTrampoline(FPDF_FORMFILLINFO* info,
414 FPDF_DOCUMENT document,
415 int page_index) {
416 return static_cast<EmbedderTest*>(info)->delegate_->GetPage(info, document,
417 page_index);
418 }
419
420 // static
HashBitmap(FPDF_BITMAP bitmap)421 std::string EmbedderTest::HashBitmap(FPDF_BITMAP bitmap) {
422 uint8_t digest[16];
423 CRYPT_MD5Generate(static_cast<uint8_t*>(FPDFBitmap_GetBuffer(bitmap)),
424 FPDFBitmap_GetWidth(bitmap) *
425 GetBitmapBytesPerPixel(bitmap) *
426 FPDFBitmap_GetHeight(bitmap),
427 digest);
428 return CryptToBase16(digest);
429 }
430
431 #ifndef NDEBUG
432 // static
WriteBitmapToPng(FPDF_BITMAP bitmap,const std::string & filename)433 void EmbedderTest::WriteBitmapToPng(FPDF_BITMAP bitmap,
434 const std::string& filename) {
435 const int stride = FPDFBitmap_GetStride(bitmap);
436 const int width = FPDFBitmap_GetWidth(bitmap);
437 const int height = FPDFBitmap_GetHeight(bitmap);
438 const auto* buffer =
439 static_cast<const unsigned char*>(FPDFBitmap_GetBuffer(bitmap));
440
441 std::vector<unsigned char> png_encoding;
442 bool encoded = image_diff_png::EncodeBGRAPNG(buffer, width, height, stride,
443 false, &png_encoding);
444
445 ASSERT_TRUE(encoded);
446 ASSERT_LT(filename.size(), 256u);
447
448 std::ofstream png_file;
449 png_file.open(filename, std::ios_base::out | std::ios_base::binary);
450 png_file.write(reinterpret_cast<char*>(&png_encoding.front()),
451 png_encoding.size());
452 ASSERT_TRUE(png_file.good());
453 png_file.close();
454 }
455 #endif
456
457 // static
CompareBitmap(FPDF_BITMAP bitmap,int expected_width,int expected_height,const char * expected_md5sum)458 void EmbedderTest::CompareBitmap(FPDF_BITMAP bitmap,
459 int expected_width,
460 int expected_height,
461 const char* expected_md5sum) {
462 ASSERT_EQ(expected_width, FPDFBitmap_GetWidth(bitmap));
463 ASSERT_EQ(expected_height, FPDFBitmap_GetHeight(bitmap));
464
465 // The expected stride is calculated using the same formula as in
466 // CFX_DIBitmap::CalculatePitchAndSize(), which sets the bitmap stride.
467 const int expected_stride =
468 (expected_width * GetBitmapBytesPerPixel(bitmap) * 8 + 31) / 32 * 4;
469 ASSERT_EQ(expected_stride, FPDFBitmap_GetStride(bitmap));
470
471 if (!expected_md5sum)
472 return;
473
474 EXPECT_EQ(expected_md5sum, HashBitmap(bitmap));
475 }
476
477 // static
WriteBlockCallback(FPDF_FILEWRITE * pFileWrite,const void * data,unsigned long size)478 int EmbedderTest::WriteBlockCallback(FPDF_FILEWRITE* pFileWrite,
479 const void* data,
480 unsigned long size) {
481 EmbedderTest* pThis = static_cast<EmbedderTest*>(pFileWrite);
482 pThis->m_String.append(static_cast<const char*>(data), size);
483 return 1;
484 }
485
486 // static
GetBlockFromString(void * param,unsigned long pos,unsigned char * buf,unsigned long size)487 int EmbedderTest::GetBlockFromString(void* param,
488 unsigned long pos,
489 unsigned char* buf,
490 unsigned long size) {
491 std::string* new_file = static_cast<std::string*>(param);
492 if (!new_file || pos + size < pos)
493 return 0;
494
495 unsigned long file_size = new_file->size();
496 if (pos + size > file_size)
497 return 0;
498
499 memcpy(buf, new_file->data() + pos, size);
500 return 1;
501 }
502