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 |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 76 | FPDF_FILEWRITE::version = 1; |
| 77 | FPDF_FILEWRITE::WriteBlock = WriteBlockCallback; |
Tom Sepez | f288bb1 | 2015-11-20 12:12:46 -0800 | [diff] [blame] | 78 | } |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 79 | |
jochen | 38a1f0a | 2016-05-31 12:07:40 -0700 | [diff] [blame] | 80 | EmbedderTest::~EmbedderTest() { |
| 81 | #ifdef PDF_ENABLE_V8 |
| 82 | v8::V8::ShutdownPlatform(); |
| 83 | delete platform_; |
| 84 | #endif // PDF_ENABLE_V8 |
| 85 | } |
Tom Sepez | f288bb1 | 2015-11-20 12:12:46 -0800 | [diff] [blame] | 86 | |
| 87 | void EmbedderTest::SetUp() { |
Tom Sepez | a72e8e2 | 2015-10-07 10:17:53 -0700 | [diff] [blame] | 88 | FPDF_LIBRARY_CONFIG config; |
| 89 | config.version = 2; |
| 90 | config.m_pUserFontPaths = nullptr; |
Tom Sepez | a72e8e2 | 2015-10-07 10:17:53 -0700 | [diff] [blame] | 91 | config.m_v8EmbedderSlot = 0; |
Tom Sepez | 452b4f3 | 2015-10-13 09:27:27 -0700 | [diff] [blame] | 92 | config.m_pIsolate = external_isolate_; |
Tom Sepez | a72e8e2 | 2015-10-07 10:17:53 -0700 | [diff] [blame] | 93 | FPDF_InitLibraryWithConfig(&config); |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 94 | |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 95 | UNSUPPORT_INFO* info = static_cast<UNSUPPORT_INFO*>(this); |
| 96 | memset(info, 0, sizeof(UNSUPPORT_INFO)); |
| 97 | info->version = 1; |
| 98 | info->FSDK_UnSupport_Handler = UnsupportedHandlerTrampoline; |
| 99 | FSDK_SetUnSpObjProcessHandler(info); |
| 100 | } |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 101 | |
| 102 | void EmbedderTest::TearDown() { |
Tom Sepez | da8189e | 2015-01-30 14:41:50 -0800 | [diff] [blame] | 103 | if (document_) { |
Lei Zhang | d27acae | 2015-05-15 15:36:02 -0700 | [diff] [blame] | 104 | FORM_DoDocumentAAction(form_handle_, FPDFDOC_AACTION_WC); |
Tom Sepez | c46d000 | 2015-11-30 15:46:36 -0800 | [diff] [blame] | 105 | FPDFDOC_ExitFormFillEnvironment(form_handle_); |
| 106 | FPDF_CloseDocument(document_); |
Tom Sepez | da8189e | 2015-01-30 14:41:50 -0800 | [diff] [blame] | 107 | } |
Tom Sepez | c46d000 | 2015-11-30 15:46:36 -0800 | [diff] [blame] | 108 | |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 109 | FPDFAvail_Destroy(avail_); |
| 110 | FPDF_DestroyLibrary(); |
Lei Zhang | d27acae | 2015-05-15 15:36:02 -0700 | [diff] [blame] | 111 | delete loader_; |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 112 | } |
| 113 | |
Tom Sepez | d483eb4 | 2016-01-06 10:03:59 -0800 | [diff] [blame] | 114 | bool EmbedderTest::CreateEmptyDocument() { |
| 115 | document_ = FPDF_CreateNewDocument(); |
| 116 | if (!document_) |
| 117 | return false; |
| 118 | |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 119 | form_handle_ = SetupFormFillEnvironment(document_); |
Tom Sepez | d483eb4 | 2016-01-06 10:03:59 -0800 | [diff] [blame] | 120 | return true; |
| 121 | } |
| 122 | |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 123 | bool EmbedderTest::OpenDocument(const std::string& filename, |
thestig | 27ddf16 | 2016-05-23 15:06:59 -0700 | [diff] [blame] | 124 | const char* password, |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 125 | bool must_linearize) { |
Wei Li | 091f7a0 | 2015-11-09 12:09:55 -0800 | [diff] [blame] | 126 | std::string file_path; |
| 127 | if (!PathService::GetTestFilePath(filename, &file_path)) |
| 128 | return false; |
| 129 | file_contents_ = GetFileContents(file_path.c_str(), &file_length_); |
Dan Sinclair | 6be2aab | 2015-10-28 13:58:49 -0400 | [diff] [blame] | 130 | if (!file_contents_) |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 131 | return false; |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 132 | |
thestig | 29ce923 | 2016-06-22 07:03:23 -0700 | [diff] [blame] | 133 | EXPECT_TRUE(!loader_); |
Tom Sepez | 0aa3531 | 2016-01-06 10:16:32 -0800 | [diff] [blame] | 134 | loader_ = new TestLoader(file_contents_.get(), file_length_); |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 135 | file_access_.m_FileLen = static_cast<unsigned long>(file_length_); |
Tom Sepez | d831dc7 | 2015-10-19 16:04:22 -0700 | [diff] [blame] | 136 | file_access_.m_GetBlock = TestLoader::GetBlock; |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 137 | file_access_.m_Param = loader_; |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 138 | return OpenDocumentHelper(password, must_linearize, &file_avail_, &hints_, |
| 139 | &file_access_, &document_, &avail_, &form_handle_); |
| 140 | } |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 141 | |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 142 | bool EmbedderTest::OpenDocumentHelper(const char* password, |
| 143 | bool must_linearize, |
| 144 | FX_FILEAVAIL* file_avail, |
| 145 | FX_DOWNLOADHINTS* hints, |
| 146 | FPDF_FILEACCESS* file_access, |
| 147 | FPDF_DOCUMENT* document, |
| 148 | FPDF_AVAIL* avail, |
| 149 | FPDF_FORMHANDLE* form_handle) { |
| 150 | file_avail->version = 1; |
| 151 | file_avail->IsDataAvail = Is_Data_Avail; |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 152 | |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 153 | hints->version = 1; |
| 154 | hints->AddSegment = Add_Segment; |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 155 | |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 156 | *avail = FPDFAvail_Create(file_avail, file_access); |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 157 | |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 158 | if (FPDFAvail_IsLinearized(*avail) == PDF_LINEARIZED) { |
| 159 | *document = FPDFAvail_GetDocument(*avail, password); |
| 160 | if (!*document) |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 161 | return false; |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 162 | |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 163 | int32_t nRet = PDF_DATA_NOTAVAIL; |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 164 | while (nRet == PDF_DATA_NOTAVAIL) |
| 165 | nRet = FPDFAvail_IsDocAvail(*avail, hints); |
| 166 | if (nRet == PDF_DATA_ERROR) |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 167 | return false; |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 168 | |
| 169 | nRet = FPDFAvail_IsFormAvail(*avail, hints); |
| 170 | if (nRet == PDF_FORM_ERROR || nRet == PDF_FORM_NOTAVAIL) |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 171 | return false; |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 172 | |
| 173 | int page_count = FPDF_GetPageCount(*document); |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 174 | for (int i = 0; i < page_count; ++i) { |
| 175 | nRet = PDF_DATA_NOTAVAIL; |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 176 | while (nRet == PDF_DATA_NOTAVAIL) |
| 177 | nRet = FPDFAvail_IsPageAvail(*avail, i, hints); |
| 178 | |
| 179 | if (nRet == PDF_DATA_ERROR) |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 180 | return false; |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 181 | } |
| 182 | } else { |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 183 | if (must_linearize) |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 184 | return false; |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 185 | |
| 186 | *document = FPDF_LoadCustomDocument(file_access, password); |
| 187 | if (!*document) |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 188 | return false; |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 189 | } |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 190 | *form_handle = SetupFormFillEnvironment(*document); |
Tom Sepez | c46d000 | 2015-11-30 15:46:36 -0800 | [diff] [blame] | 191 | #ifdef PDF_ENABLE_XFA |
JUN FANG | 827a172 | 2015-03-05 13:39:21 -0800 | [diff] [blame] | 192 | int docType = DOCTYPE_PDF; |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 193 | if (FPDF_HasXFAField(*document, &docType)) { |
JUN FANG | 827a172 | 2015-03-05 13:39:21 -0800 | [diff] [blame] | 194 | if (docType != DOCTYPE_PDF) |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 195 | (void)FPDF_LoadXFA(*document); |
JUN FANG | 827a172 | 2015-03-05 13:39:21 -0800 | [diff] [blame] | 196 | } |
Tom Sepez | c46d000 | 2015-11-30 15:46:36 -0800 | [diff] [blame] | 197 | #endif // PDF_ENABLE_XFA |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 198 | (void)FPDF_GetDocPermissions(*document); |
Tom Sepez | d483eb4 | 2016-01-06 10:03:59 -0800 | [diff] [blame] | 199 | return true; |
| 200 | } |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 201 | |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 202 | FPDF_FORMHANDLE EmbedderTest::SetupFormFillEnvironment(FPDF_DOCUMENT doc) { |
Tom Sepez | 4cb0fa7 | 2015-02-25 16:08:18 -0800 | [diff] [blame] | 203 | IPDF_JSPLATFORM* platform = static_cast<IPDF_JSPLATFORM*>(this); |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 204 | memset(platform, '\0', sizeof(IPDF_JSPLATFORM)); |
Jochen Eisinger | 06b6002 | 2015-07-30 17:44:35 +0200 | [diff] [blame] | 205 | platform->version = 2; |
Tom Sepez | 4cb0fa7 | 2015-02-25 16:08:18 -0800 | [diff] [blame] | 206 | platform->app_alert = AlertTrampoline; |
Dan Sinclair | 14aacd5 | 2017-05-18 14:11:29 -0400 | [diff] [blame] | 207 | platform->m_isolate = external_isolate_; |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 208 | |
Tom Sepez | 4cb0fa7 | 2015-02-25 16:08:18 -0800 | [diff] [blame] | 209 | FPDF_FORMFILLINFO* formfillinfo = static_cast<FPDF_FORMFILLINFO*>(this); |
| 210 | memset(formfillinfo, 0, sizeof(FPDF_FORMFILLINFO)); |
Lei Zhang | cd39695 | 2015-11-04 20:26:50 -0800 | [diff] [blame] | 211 | #ifdef PDF_ENABLE_XFA |
| 212 | formfillinfo->version = 2; |
Tom Sepez | c46d000 | 2015-11-30 15:46:36 -0800 | [diff] [blame] | 213 | #else // PDF_ENABLE_XFA |
Tom Sepez | 4cb0fa7 | 2015-02-25 16:08:18 -0800 | [diff] [blame] | 214 | formfillinfo->version = 1; |
Tom Sepez | c46d000 | 2015-11-30 15:46:36 -0800 | [diff] [blame] | 215 | #endif // PDF_ENABLE_XFA |
Tom Sepez | 6efc0ad | 2015-06-02 17:11:18 -0700 | [diff] [blame] | 216 | formfillinfo->FFI_SetTimer = SetTimerTrampoline; |
| 217 | formfillinfo->FFI_KillTimer = KillTimerTrampoline; |
Tom Sepez | 396e872 | 2015-09-09 10:16:08 -0700 | [diff] [blame] | 218 | formfillinfo->FFI_GetPage = GetPageTrampoline; |
Tom Sepez | 4cb0fa7 | 2015-02-25 16:08:18 -0800 | [diff] [blame] | 219 | formfillinfo->m_pJsPlatform = platform; |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 220 | FPDF_FORMHANDLE form_handle = |
| 221 | FPDFDOC_InitFormFillEnvironment(doc, formfillinfo); |
| 222 | FPDF_SetFormFieldHighlightColor(form_handle, 0, 0xFFE4DD); |
| 223 | FPDF_SetFormFieldHighlightAlpha(form_handle, 100); |
| 224 | return form_handle; |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 225 | } |
| 226 | |
Tom Sepez | da8189e | 2015-01-30 14:41:50 -0800 | [diff] [blame] | 227 | void EmbedderTest::DoOpenActions() { |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 228 | ASSERT(form_handle_); |
Tom Sepez | da8189e | 2015-01-30 14:41:50 -0800 | [diff] [blame] | 229 | FORM_DoDocumentJSAction(form_handle_); |
| 230 | FORM_DoDocumentOpenAction(form_handle_); |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 231 | } |
| 232 | |
| 233 | int EmbedderTest::GetFirstPageNum() { |
| 234 | int first_page = FPDFAvail_GetFirstPageNum(document_); |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 235 | (void)FPDFAvail_IsPageAvail(avail_, first_page, &hints_); |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 236 | return first_page; |
| 237 | } |
| 238 | |
| 239 | int EmbedderTest::GetPageCount() { |
| 240 | int page_count = FPDF_GetPageCount(document_); |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 241 | for (int i = 0; i < page_count; ++i) |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 242 | (void)FPDFAvail_IsPageAvail(avail_, i, &hints_); |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 243 | return page_count; |
| 244 | } |
| 245 | |
Tom Sepez | da8189e | 2015-01-30 14:41:50 -0800 | [diff] [blame] | 246 | FPDF_PAGE EmbedderTest::LoadPage(int page_number) { |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 247 | ASSERT(form_handle_); |
weili | 0dadcc6 | 2016-08-23 21:10:57 -0700 | [diff] [blame] | 248 | // First check whether it is loaded already. |
| 249 | auto it = page_map_.find(page_number); |
| 250 | if (it != page_map_.end()) |
| 251 | return it->second; |
| 252 | |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 253 | FPDF_PAGE page = FPDF_LoadPage(document_, page_number); |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 254 | if (!page) |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 255 | return nullptr; |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 256 | |
Tom Sepez | da8189e | 2015-01-30 14:41:50 -0800 | [diff] [blame] | 257 | FORM_OnAfterLoadPage(page, form_handle_); |
| 258 | FORM_DoPageAAction(page, form_handle_, FPDFPAGE_AACTION_OPEN); |
weili | 0dadcc6 | 2016-08-23 21:10:57 -0700 | [diff] [blame] | 259 | // Cache the page. |
| 260 | page_map_[page_number] = page; |
dsinclair | cb92dc7 | 2016-09-07 09:02:48 -0700 | [diff] [blame] | 261 | page_reverse_map_[page] = page_number; |
Tom Sepez | 396e872 | 2015-09-09 10:16:08 -0700 | [diff] [blame] | 262 | return page; |
| 263 | } |
| 264 | |
Tom Sepez | da8189e | 2015-01-30 14:41:50 -0800 | [diff] [blame] | 265 | FPDF_BITMAP EmbedderTest::RenderPage(FPDF_PAGE page) { |
Jane Liu | baa7ff4 | 2017-06-29 19:18:23 -0400 | [diff] [blame] | 266 | return RenderPageWithFlags(page, form_handle_, 0); |
Jane Liu | c533f4b | 2017-06-19 11:13:00 -0400 | [diff] [blame] | 267 | } |
| 268 | |
Jane Liu | baa7ff4 | 2017-06-29 19:18:23 -0400 | [diff] [blame] | 269 | FPDF_BITMAP EmbedderTest::RenderPageWithFlags(FPDF_PAGE page, |
| 270 | FPDF_FORMHANDLE handle, |
| 271 | int flags) { |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 272 | int width = static_cast<int>(FPDF_GetPageWidth(page)); |
| 273 | int height = static_cast<int>(FPDF_GetPageHeight(page)); |
Lei Zhang | 453d96b | 2015-12-31 13:13:10 -0800 | [diff] [blame] | 274 | int alpha = FPDFPage_HasTransparency(page) ? 1 : 0; |
| 275 | FPDF_BITMAP bitmap = FPDFBitmap_Create(width, height, alpha); |
| 276 | FPDF_DWORD fill_color = alpha ? 0x00000000 : 0xFFFFFFFF; |
| 277 | FPDFBitmap_FillRect(bitmap, 0, 0, width, height, fill_color); |
Jane Liu | c533f4b | 2017-06-19 11:13:00 -0400 | [diff] [blame] | 278 | FPDF_RenderPageBitmap(bitmap, page, 0, 0, width, height, 0, flags); |
Jane Liu | baa7ff4 | 2017-06-29 19:18:23 -0400 | [diff] [blame] | 279 | FPDF_FFLDraw(handle, bitmap, page, 0, 0, width, height, 0, flags); |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 280 | return bitmap; |
| 281 | } |
| 282 | |
Tom Sepez | da8189e | 2015-01-30 14:41:50 -0800 | [diff] [blame] | 283 | void EmbedderTest::UnloadPage(FPDF_PAGE page) { |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 284 | ASSERT(form_handle_); |
Tom Sepez | da8189e | 2015-01-30 14:41:50 -0800 | [diff] [blame] | 285 | FORM_DoPageAAction(page, form_handle_, FPDFPAGE_AACTION_CLOSE); |
| 286 | FORM_OnBeforeClosePage(page, form_handle_); |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 287 | FPDF_ClosePage(page); |
dsinclair | cb92dc7 | 2016-09-07 09:02:48 -0700 | [diff] [blame] | 288 | |
| 289 | auto it = page_reverse_map_.find(page); |
| 290 | if (it == page_reverse_map_.end()) |
| 291 | return; |
| 292 | |
| 293 | page_map_.erase(it->second); |
| 294 | page_reverse_map_.erase(it); |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 295 | } |
Tom Sepez | 1b1bb49 | 2015-01-22 17:36:32 -0800 | [diff] [blame] | 296 | |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 297 | void EmbedderTest::TestSaved(int width, |
| 298 | int height, |
| 299 | const char* md5, |
| 300 | const char* password) { |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 301 | FPDF_FILEACCESS file_access; |
| 302 | memset(&file_access, 0, sizeof(file_access)); |
| 303 | file_access.m_FileLen = m_String.size(); |
| 304 | file_access.m_GetBlock = GetBlockFromString; |
| 305 | file_access.m_Param = &m_String; |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 306 | FX_FILEAVAIL file_avail; |
| 307 | FX_DOWNLOADHINTS hints; |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 308 | |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 309 | ASSERT_TRUE(OpenDocumentHelper(password, false, &file_avail, &hints, |
| 310 | &file_access, &m_SavedDocument, &m_SavedAvail, |
| 311 | &m_SavedForm)); |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 312 | EXPECT_EQ(1, FPDF_GetPageCount(m_SavedDocument)); |
| 313 | m_SavedPage = FPDF_LoadPage(m_SavedDocument, 0); |
| 314 | ASSERT_TRUE(m_SavedPage); |
| 315 | FPDF_BITMAP new_bitmap = |
| 316 | RenderPageWithFlags(m_SavedPage, m_SavedForm, FPDF_ANNOT); |
| 317 | CompareBitmap(new_bitmap, width, height, md5); |
| 318 | FPDFBitmap_Destroy(new_bitmap); |
| 319 | } |
| 320 | |
| 321 | void EmbedderTest::CloseSaved() { |
| 322 | FPDF_ClosePage(m_SavedPage); |
| 323 | FPDFDOC_ExitFormFillEnvironment(m_SavedForm); |
| 324 | FPDF_CloseDocument(m_SavedDocument); |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 325 | FPDFAvail_Destroy(m_SavedAvail); |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 326 | } |
| 327 | |
| 328 | void EmbedderTest::TestAndCloseSaved(int width, int height, const char* md5) { |
| 329 | TestSaved(width, height, md5); |
| 330 | CloseSaved(); |
| 331 | } |
| 332 | |
weili | 0dadcc6 | 2016-08-23 21:10:57 -0700 | [diff] [blame] | 333 | FPDF_PAGE EmbedderTest::Delegate::GetPage(FPDF_FORMFILLINFO* info, |
Tom Sepez | 396e872 | 2015-09-09 10:16:08 -0700 | [diff] [blame] | 334 | FPDF_DOCUMENT document, |
| 335 | int page_index) { |
weili | 0dadcc6 | 2016-08-23 21:10:57 -0700 | [diff] [blame] | 336 | EmbedderTest* test = static_cast<EmbedderTest*>(info); |
| 337 | auto it = test->page_map_.find(page_index); |
| 338 | return it != test->page_map_.end() ? it->second : nullptr; |
Tom Sepez | 396e872 | 2015-09-09 10:16:08 -0700 | [diff] [blame] | 339 | } |
| 340 | |
Tom Sepez | 4cb0fa7 | 2015-02-25 16:08:18 -0800 | [diff] [blame] | 341 | // static |
| 342 | void EmbedderTest::UnsupportedHandlerTrampoline(UNSUPPORT_INFO* info, |
| 343 | int type) { |
| 344 | EmbedderTest* test = static_cast<EmbedderTest*>(info); |
| 345 | test->delegate_->UnsupportedHandler(type); |
| 346 | } |
| 347 | |
| 348 | // static |
| 349 | int EmbedderTest::AlertTrampoline(IPDF_JSPLATFORM* platform, |
| 350 | FPDF_WIDESTRING message, |
| 351 | FPDF_WIDESTRING title, |
| 352 | int type, |
| 353 | int icon) { |
| 354 | EmbedderTest* test = static_cast<EmbedderTest*>(platform); |
| 355 | return test->delegate_->Alert(message, title, type, icon); |
| 356 | } |
| 357 | |
Tom Sepez | 6efc0ad | 2015-06-02 17:11:18 -0700 | [diff] [blame] | 358 | // static |
| 359 | int EmbedderTest::SetTimerTrampoline(FPDF_FORMFILLINFO* info, |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 360 | int msecs, |
| 361 | TimerCallback fn) { |
Tom Sepez | 6efc0ad | 2015-06-02 17:11:18 -0700 | [diff] [blame] | 362 | EmbedderTest* test = static_cast<EmbedderTest*>(info); |
| 363 | return test->delegate_->SetTimer(msecs, fn); |
| 364 | } |
| 365 | |
| 366 | // static |
| 367 | void EmbedderTest::KillTimerTrampoline(FPDF_FORMFILLINFO* info, int id) { |
| 368 | EmbedderTest* test = static_cast<EmbedderTest*>(info); |
| 369 | return test->delegate_->KillTimer(id); |
| 370 | } |
| 371 | |
Tom Sepez | 396e872 | 2015-09-09 10:16:08 -0700 | [diff] [blame] | 372 | // static |
| 373 | FPDF_PAGE EmbedderTest::GetPageTrampoline(FPDF_FORMFILLINFO* info, |
| 374 | FPDF_DOCUMENT document, |
| 375 | int page_index) { |
weili | 0dadcc6 | 2016-08-23 21:10:57 -0700 | [diff] [blame] | 376 | return static_cast<EmbedderTest*>(info)->delegate_->GetPage(info, document, |
| 377 | page_index); |
Tom Sepez | 396e872 | 2015-09-09 10:16:08 -0700 | [diff] [blame] | 378 | } |
| 379 | |
Dan Sinclair | 957480c | 2017-06-13 15:21:14 -0400 | [diff] [blame] | 380 | std::string EmbedderTest::HashBitmap(FPDF_BITMAP bitmap, |
| 381 | int expected_width, |
| 382 | int expected_height) { |
| 383 | uint8_t digest[16]; |
| 384 | CRYPT_MD5Generate(static_cast<uint8_t*>(FPDFBitmap_GetBuffer(bitmap)), |
| 385 | expected_width * 4 * expected_height, digest); |
| 386 | return CryptToBase16(digest); |
| 387 | } |
| 388 | |
thestig | bcd3e53 | 2016-11-21 13:37:28 -0800 | [diff] [blame] | 389 | // static |
| 390 | void EmbedderTest::CompareBitmap(FPDF_BITMAP bitmap, |
| 391 | int expected_width, |
| 392 | int expected_height, |
| 393 | const char* expected_md5sum) { |
| 394 | ASSERT_EQ(expected_width, FPDFBitmap_GetWidth(bitmap)); |
| 395 | ASSERT_EQ(expected_height, FPDFBitmap_GetHeight(bitmap)); |
| 396 | const int expected_stride = expected_width * 4; |
| 397 | ASSERT_EQ(expected_stride, FPDFBitmap_GetStride(bitmap)); |
| 398 | |
| 399 | if (!expected_md5sum) |
| 400 | return; |
| 401 | |
Dan Sinclair | 957480c | 2017-06-13 15:21:14 -0400 | [diff] [blame] | 402 | EXPECT_EQ(expected_md5sum, |
| 403 | HashBitmap(bitmap, expected_width, expected_height)); |
thestig | bcd3e53 | 2016-11-21 13:37:28 -0800 | [diff] [blame] | 404 | } |
| 405 | |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 406 | // static |
| 407 | int EmbedderTest::WriteBlockCallback(FPDF_FILEWRITE* pFileWrite, |
| 408 | const void* data, |
| 409 | unsigned long size) { |
| 410 | EmbedderTest* pThis = static_cast<EmbedderTest*>(pFileWrite); |
| 411 | pThis->m_String.append(static_cast<const char*>(data), size); |
| 412 | return 1; |
| 413 | } |
| 414 | |
| 415 | // static |
| 416 | int EmbedderTest::GetBlockFromString(void* param, |
| 417 | unsigned long pos, |
| 418 | unsigned char* buf, |
| 419 | unsigned long size) { |
| 420 | std::string* new_file = static_cast<std::string*>(param); |
| 421 | if (!new_file || pos + size < pos) |
| 422 | return 0; |
| 423 | |
| 424 | unsigned long file_size = new_file->size(); |
| 425 | if (pos + size > file_size) |
| 426 | return 0; |
| 427 | |
| 428 | memcpy(buf, new_file->data() + pos, size); |
| 429 | return 1; |
| 430 | } |
| 431 | |
Tom Sepez | 1b1bb49 | 2015-01-22 17:36:32 -0800 | [diff] [blame] | 432 | // Can't use gtest-provided main since we need to stash the path to the |
| 433 | // executable in order to find the external V8 binary data files. |
| 434 | int main(int argc, char** argv) { |
thestig | c08cd7a | 2016-06-27 09:47:59 -0700 | [diff] [blame] | 435 | g_exe_path = argv[0]; |
Tom Sepez | 1b1bb49 | 2015-01-22 17:36:32 -0800 | [diff] [blame] | 436 | testing::InitGoogleTest(&argc, argv); |
Tom Sepez | a310e00 | 2015-02-27 13:03:07 -0800 | [diff] [blame] | 437 | testing::InitGoogleMock(&argc, argv); |
thestig | c08cd7a | 2016-06-27 09:47:59 -0700 | [diff] [blame] | 438 | int ret_val = RUN_ALL_TESTS(); |
| 439 | |
| 440 | #ifdef PDF_ENABLE_V8 |
| 441 | #ifdef V8_USE_EXTERNAL_STARTUP_DATA |
| 442 | if (g_v8_natives) |
| 443 | free(const_cast<char*>(g_v8_natives->data)); |
| 444 | if (g_v8_snapshot) |
| 445 | free(const_cast<char*>(g_v8_snapshot->data)); |
| 446 | #endif // V8_USE_EXTERNAL_STARTUP_DATA |
| 447 | #endif // PDF_ENABLE_V8 |
| 448 | |
| 449 | return ret_val; |
Tom Sepez | 1b1bb49 | 2015-01-22 17:36:32 -0800 | [diff] [blame] | 450 | } |