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