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 <list> 10 #include <string> 11 #include <utility> 12 #include <vector> 13 14 #include "core/fdrm/crypto/fx_crypt.h" 15 #include "public/fpdf_dataavail.h" 16 #include "public/fpdf_edit.h" 17 #include "public/fpdf_text.h" 18 #include "public/fpdfview.h" 19 #include "testing/gmock/include/gmock/gmock.h" 20 #include "testing/test_support.h" 21 #include "testing/utils/path_service.h" 22 23 #ifdef PDF_ENABLE_V8 24 #include "v8/include/v8-platform.h" 25 #include "v8/include/v8.h" 26 #endif // PDF_ENABLE_V8 27 28 namespace { 29 30 const char* g_exe_path = nullptr; 31 32 #ifdef PDF_ENABLE_V8 33 #ifdef V8_USE_EXTERNAL_STARTUP_DATA 34 v8::StartupData* g_v8_natives = nullptr; 35 v8::StartupData* g_v8_snapshot = nullptr; 36 #endif // V8_USE_EXTERNAL_STARTUP_DATA 37 #endif // PDF_ENABLE_V8 38 39 FPDF_BOOL Is_Data_Avail(FX_FILEAVAIL* pThis, size_t offset, size_t size) { 40 return true; 41 } 42 43 void Add_Segment(FX_DOWNLOADHINTS* pThis, size_t offset, size_t size) {} 44 45 std::string CRYPT_ToBase16(const uint8_t* digest) { 46 static char const zEncode[] = "0123456789abcdef"; 47 std::string ret; 48 ret.resize(32); 49 for (int i = 0, j = 0; i < 16; i++, j += 2) { 50 uint8_t a = digest[i]; 51 ret[j] = zEncode[(a >> 4) & 0xf]; 52 ret[j + 1] = zEncode[a & 0xf]; 53 } 54 return ret; 55 } 56 57 } // namespace 58 59 EmbedderTest::EmbedderTest() 60 : default_delegate_(new EmbedderTest::Delegate()), 61 document_(nullptr), 62 form_handle_(nullptr), 63 avail_(nullptr), 64 external_isolate_(nullptr), 65 loader_(nullptr), 66 file_length_(0), 67 file_contents_(nullptr) { 68 memset(&hints_, 0, sizeof(hints_)); 69 memset(&file_access_, 0, sizeof(file_access_)); 70 memset(&file_avail_, 0, sizeof(file_avail_)); 71 delegate_ = default_delegate_.get(); 72 73 #ifdef PDF_ENABLE_V8 74 #ifdef V8_USE_EXTERNAL_STARTUP_DATA 75 if (g_v8_natives && g_v8_snapshot) { 76 InitializeV8ForPDFium(g_exe_path, std::string(), nullptr, nullptr, 77 &platform_); 78 } else { 79 g_v8_natives = new v8::StartupData; 80 g_v8_snapshot = new v8::StartupData; 81 InitializeV8ForPDFium(g_exe_path, std::string(), g_v8_natives, 82 g_v8_snapshot, &platform_); 83 } 84 #else 85 InitializeV8ForPDFium(g_exe_path, &platform_); 86 #endif // V8_USE_EXTERNAL_STARTUP_DATA 87 #endif // FPDF_ENABLE_V8 88 } 89 90 EmbedderTest::~EmbedderTest() { 91 #ifdef PDF_ENABLE_V8 92 v8::V8::ShutdownPlatform(); 93 delete platform_; 94 #endif // PDF_ENABLE_V8 95 } 96 97 void EmbedderTest::SetUp() { 98 FPDF_LIBRARY_CONFIG config; 99 config.version = 2; 100 config.m_pUserFontPaths = nullptr; 101 config.m_v8EmbedderSlot = 0; 102 config.m_pIsolate = external_isolate_; 103 FPDF_InitLibraryWithConfig(&config); 104 105 UNSUPPORT_INFO* info = static_cast<UNSUPPORT_INFO*>(this); 106 memset(info, 0, sizeof(UNSUPPORT_INFO)); 107 info->version = 1; 108 info->FSDK_UnSupport_Handler = UnsupportedHandlerTrampoline; 109 FSDK_SetUnSpObjProcessHandler(info); 110 } 111 112 void EmbedderTest::TearDown() { 113 if (document_) { 114 FORM_DoDocumentAAction(form_handle_, FPDFDOC_AACTION_WC); 115 FPDFDOC_ExitFormFillEnvironment(form_handle_); 116 FPDF_CloseDocument(document_); 117 } 118 119 FPDFAvail_Destroy(avail_); 120 FPDF_DestroyLibrary(); 121 122 delete loader_; 123 } 124 125 bool EmbedderTest::CreateEmptyDocument() { 126 document_ = FPDF_CreateNewDocument(); 127 if (!document_) 128 return false; 129 130 SetupFormFillEnvironment(); 131 return true; 132 } 133 134 bool EmbedderTest::OpenDocument(const std::string& filename, 135 const char* password, 136 bool must_linearize) { 137 std::string file_path; 138 if (!PathService::GetTestFilePath(filename, &file_path)) 139 return false; 140 file_contents_ = GetFileContents(file_path.c_str(), &file_length_); 141 if (!file_contents_) 142 return false; 143 144 EXPECT_TRUE(!loader_); 145 loader_ = new TestLoader(file_contents_.get(), file_length_); 146 file_access_.m_FileLen = static_cast<unsigned long>(file_length_); 147 file_access_.m_GetBlock = TestLoader::GetBlock; 148 file_access_.m_Param = loader_; 149 150 file_avail_.version = 1; 151 file_avail_.IsDataAvail = Is_Data_Avail; 152 153 hints_.version = 1; 154 hints_.AddSegment = Add_Segment; 155 156 avail_ = FPDFAvail_Create(&file_avail_, &file_access_); 157 158 if (FPDFAvail_IsLinearized(avail_) == PDF_LINEARIZED) { 159 document_ = FPDFAvail_GetDocument(avail_, password); 160 if (!document_) { 161 return false; 162 } 163 int32_t nRet = PDF_DATA_NOTAVAIL; 164 while (nRet == PDF_DATA_NOTAVAIL) { 165 nRet = FPDFAvail_IsDocAvail(avail_, &hints_); 166 } 167 if (nRet == PDF_DATA_ERROR) { 168 return false; 169 } 170 nRet = FPDFAvail_IsFormAvail(avail_, &hints_); 171 if (nRet == PDF_FORM_ERROR || nRet == PDF_FORM_NOTAVAIL) { 172 return false; 173 } 174 int page_count = FPDF_GetPageCount(document_); 175 for (int i = 0; i < page_count; ++i) { 176 nRet = PDF_DATA_NOTAVAIL; 177 while (nRet == PDF_DATA_NOTAVAIL) { 178 nRet = FPDFAvail_IsPageAvail(avail_, i, &hints_); 179 } 180 if (nRet == PDF_DATA_ERROR) { 181 return false; 182 } 183 } 184 } else { 185 if (must_linearize) { 186 return false; 187 } 188 document_ = FPDF_LoadCustomDocument(&file_access_, password); 189 if (!document_) { 190 return false; 191 } 192 } 193 194 #ifdef PDF_ENABLE_XFA 195 int docType = DOCTYPE_PDF; 196 if (FPDF_HasXFAField(document_, &docType)) { 197 if (docType != DOCTYPE_PDF) 198 (void)FPDF_LoadXFA(document_); 199 } 200 #endif // PDF_ENABLE_XFA 201 202 (void)FPDF_GetDocPermissions(document_); 203 SetupFormFillEnvironment(); 204 return true; 205 } 206 207 void EmbedderTest::SetupFormFillEnvironment() { 208 IPDF_JSPLATFORM* platform = static_cast<IPDF_JSPLATFORM*>(this); 209 memset(platform, 0, sizeof(IPDF_JSPLATFORM)); 210 platform->version = 2; 211 platform->app_alert = AlertTrampoline; 212 213 FPDF_FORMFILLINFO* formfillinfo = static_cast<FPDF_FORMFILLINFO*>(this); 214 memset(formfillinfo, 0, sizeof(FPDF_FORMFILLINFO)); 215 #ifdef PDF_ENABLE_XFA 216 formfillinfo->version = 2; 217 #else // PDF_ENABLE_XFA 218 formfillinfo->version = 1; 219 #endif // PDF_ENABLE_XFA 220 formfillinfo->FFI_SetTimer = SetTimerTrampoline; 221 formfillinfo->FFI_KillTimer = KillTimerTrampoline; 222 formfillinfo->FFI_GetPage = GetPageTrampoline; 223 formfillinfo->m_pJsPlatform = platform; 224 225 form_handle_ = FPDFDOC_InitFormFillEnvironment(document_, formfillinfo); 226 FPDF_SetFormFieldHighlightColor(form_handle_, 0, 0xFFE4DD); 227 FPDF_SetFormFieldHighlightAlpha(form_handle_, 100); 228 } 229 230 void EmbedderTest::DoOpenActions() { 231 FORM_DoDocumentJSAction(form_handle_); 232 FORM_DoDocumentOpenAction(form_handle_); 233 } 234 235 int EmbedderTest::GetFirstPageNum() { 236 int first_page = FPDFAvail_GetFirstPageNum(document_); 237 (void)FPDFAvail_IsPageAvail(avail_, first_page, &hints_); 238 return first_page; 239 } 240 241 int EmbedderTest::GetPageCount() { 242 int page_count = FPDF_GetPageCount(document_); 243 for (int i = 0; i < page_count; ++i) { 244 (void)FPDFAvail_IsPageAvail(avail_, i, &hints_); 245 } 246 return page_count; 247 } 248 249 FPDF_PAGE EmbedderTest::LoadPage(int page_number) { 250 // First check whether it is loaded already. 251 auto it = page_map_.find(page_number); 252 if (it != page_map_.end()) 253 return it->second; 254 255 FPDF_PAGE page = FPDF_LoadPage(document_, page_number); 256 if (!page) { 257 return nullptr; 258 } 259 FORM_OnAfterLoadPage(page, form_handle_); 260 FORM_DoPageAAction(page, form_handle_, FPDFPAGE_AACTION_OPEN); 261 // Cache the page. 262 page_map_[page_number] = page; 263 page_reverse_map_[page] = page_number; 264 return page; 265 } 266 267 FPDF_BITMAP EmbedderTest::RenderPage(FPDF_PAGE page) { 268 int width = static_cast<int>(FPDF_GetPageWidth(page)); 269 int height = static_cast<int>(FPDF_GetPageHeight(page)); 270 int alpha = FPDFPage_HasTransparency(page) ? 1 : 0; 271 FPDF_BITMAP bitmap = FPDFBitmap_Create(width, height, alpha); 272 FPDF_DWORD fill_color = alpha ? 0x00000000 : 0xFFFFFFFF; 273 FPDFBitmap_FillRect(bitmap, 0, 0, width, height, fill_color); 274 FPDF_RenderPageBitmap(bitmap, page, 0, 0, width, height, 0, 0); 275 FPDF_FFLDraw(form_handle_, bitmap, page, 0, 0, width, height, 0, 0); 276 return bitmap; 277 } 278 279 void EmbedderTest::UnloadPage(FPDF_PAGE page) { 280 FORM_DoPageAAction(page, form_handle_, FPDFPAGE_AACTION_CLOSE); 281 FORM_OnBeforeClosePage(page, form_handle_); 282 FPDF_ClosePage(page); 283 284 auto it = page_reverse_map_.find(page); 285 if (it == page_reverse_map_.end()) 286 return; 287 288 page_map_.erase(it->second); 289 page_reverse_map_.erase(it); 290 } 291 292 FPDF_PAGE EmbedderTest::Delegate::GetPage(FPDF_FORMFILLINFO* info, 293 FPDF_DOCUMENT document, 294 int page_index) { 295 EmbedderTest* test = static_cast<EmbedderTest*>(info); 296 auto it = test->page_map_.find(page_index); 297 return it != test->page_map_.end() ? it->second : nullptr; 298 } 299 300 // static 301 void EmbedderTest::UnsupportedHandlerTrampoline(UNSUPPORT_INFO* info, 302 int type) { 303 EmbedderTest* test = static_cast<EmbedderTest*>(info); 304 test->delegate_->UnsupportedHandler(type); 305 } 306 307 // static 308 int EmbedderTest::AlertTrampoline(IPDF_JSPLATFORM* platform, 309 FPDF_WIDESTRING message, 310 FPDF_WIDESTRING title, 311 int type, 312 int icon) { 313 EmbedderTest* test = static_cast<EmbedderTest*>(platform); 314 return test->delegate_->Alert(message, title, type, icon); 315 } 316 317 // static 318 int EmbedderTest::SetTimerTrampoline(FPDF_FORMFILLINFO* info, 319 int msecs, 320 TimerCallback fn) { 321 EmbedderTest* test = static_cast<EmbedderTest*>(info); 322 return test->delegate_->SetTimer(msecs, fn); 323 } 324 325 // static 326 void EmbedderTest::KillTimerTrampoline(FPDF_FORMFILLINFO* info, int id) { 327 EmbedderTest* test = static_cast<EmbedderTest*>(info); 328 return test->delegate_->KillTimer(id); 329 } 330 331 // static 332 FPDF_PAGE EmbedderTest::GetPageTrampoline(FPDF_FORMFILLINFO* info, 333 FPDF_DOCUMENT document, 334 int page_index) { 335 return static_cast<EmbedderTest*>(info)->delegate_->GetPage(info, document, 336 page_index); 337 } 338 339 // static 340 void EmbedderTest::CompareBitmap(FPDF_BITMAP bitmap, 341 int expected_width, 342 int expected_height, 343 const char* expected_md5sum) { 344 ASSERT_EQ(expected_width, FPDFBitmap_GetWidth(bitmap)); 345 ASSERT_EQ(expected_height, FPDFBitmap_GetHeight(bitmap)); 346 const int expected_stride = expected_width * 4; 347 ASSERT_EQ(expected_stride, FPDFBitmap_GetStride(bitmap)); 348 349 if (!expected_md5sum) 350 return; 351 352 uint8_t digest[16]; 353 CRYPT_MD5Generate(static_cast<uint8_t*>(FPDFBitmap_GetBuffer(bitmap)), 354 expected_stride * expected_height, digest); 355 EXPECT_EQ(expected_md5sum, CRYPT_ToBase16(digest)); 356 } 357 358 // Can't use gtest-provided main since we need to stash the path to the 359 // executable in order to find the external V8 binary data files. 360 int main(int argc, char** argv) { 361 g_exe_path = argv[0]; 362 testing::InitGoogleTest(&argc, argv); 363 testing::InitGoogleMock(&argc, argv); 364 int ret_val = RUN_ALL_TESTS(); 365 366 #ifdef PDF_ENABLE_V8 367 #ifdef V8_USE_EXTERNAL_STARTUP_DATA 368 if (g_v8_natives) 369 free(const_cast<char*>(g_v8_natives->data)); 370 if (g_v8_snapshot) 371 free(const_cast<char*>(g_v8_snapshot->data)); 372 #endif // V8_USE_EXTERNAL_STARTUP_DATA 373 #endif // PDF_ENABLE_V8 374 375 return ret_val; 376 } 377
