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> |
Lei Zhang | 9f72c45 | 2018-02-08 21:49:54 +0000 | [diff] [blame] | 10 | #include <map> |
Lei Zhang | a98e366 | 2018-02-07 20:28:35 +0000 | [diff] [blame] | 11 | #include <memory> |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 12 | #include <string> |
| 13 | #include <utility> |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 14 | |
Lei Zhang | d145e4b | 2018-10-12 18:54:31 +0000 | [diff] [blame] | 15 | #include "core/fdrm/fx_crypt.h" |
Tom Sepez | e08d2b1 | 2018-04-25 18:49:32 +0000 | [diff] [blame] | 16 | #include "public/cpp/fpdf_scopers.h" |
Lei Zhang | b4e7f30 | 2015-11-06 15:52:32 -0800 | [diff] [blame] | 17 | #include "public/fpdf_dataavail.h" |
Lei Zhang | 453d96b | 2015-12-31 13:13:10 -0800 | [diff] [blame] | 18 | #include "public/fpdf_edit.h" |
Lei Zhang | b4e7f30 | 2015-11-06 15:52:32 -0800 | [diff] [blame] | 19 | #include "public/fpdf_text.h" |
| 20 | #include "public/fpdfview.h" |
Tom Sepez | a310e00 | 2015-02-27 13:03:07 -0800 | [diff] [blame] | 21 | #include "testing/gmock/include/gmock/gmock.h" |
Wei Li | 091f7a0 | 2015-11-09 12:09:55 -0800 | [diff] [blame] | 22 | #include "testing/test_support.h" |
Henrique Nakashima | f956bad | 2018-08-16 16:41:42 +0000 | [diff] [blame] | 23 | #include "testing/utils/bitmap_saver.h" |
Wei Li | 091f7a0 | 2015-11-09 12:09:55 -0800 | [diff] [blame] | 24 | #include "testing/utils/path_service.h" |
Lei Zhang | 75c8171 | 2018-02-08 17:22:39 +0000 | [diff] [blame] | 25 | #include "third_party/base/logging.h" |
Artem Strygin | 0e60b9e | 2017-09-28 18:46:03 +0300 | [diff] [blame] | 26 | #include "third_party/base/ptr_util.h" |
Lei Zhang | 75c8171 | 2018-02-08 17:22:39 +0000 | [diff] [blame] | 27 | #include "third_party/base/stl_util.h" |
Tom Sepez | 452b4f3 | 2015-10-13 09:27:27 -0700 | [diff] [blame] | 28 | |
| 29 | #ifdef PDF_ENABLE_V8 |
Lei Zhang | 8241df7 | 2015-11-06 14:38:48 -0800 | [diff] [blame] | 30 | #include "v8/include/v8-platform.h" |
Dan Sinclair | 61046b9 | 2016-02-18 14:48:48 -0500 | [diff] [blame] | 31 | #include "v8/include/v8.h" |
Tom Sepez | 452b4f3 | 2015-10-13 09:27:27 -0700 | [diff] [blame] | 32 | #endif // PDF_ENABLE_V8 |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 33 | |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 34 | namespace { |
thestig | c08cd7a | 2016-06-27 09:47:59 -0700 | [diff] [blame] | 35 | |
Jane Liu | 28fb7ba | 2017-08-02 21:45:57 -0400 | [diff] [blame] | 36 | int GetBitmapBytesPerPixel(FPDF_BITMAP bitmap) { |
| 37 | const int format = FPDFBitmap_GetFormat(bitmap); |
| 38 | switch (format) { |
| 39 | case FPDFBitmap_Gray: |
| 40 | return 1; |
| 41 | case FPDFBitmap_BGR: |
| 42 | return 3; |
| 43 | case FPDFBitmap_BGRx: |
| 44 | case FPDFBitmap_BGRA: |
| 45 | return 4; |
| 46 | default: |
| 47 | ASSERT(false); |
| 48 | return 0; |
| 49 | } |
| 50 | } |
| 51 | |
thestig | bcd3e53 | 2016-11-21 13:37:28 -0800 | [diff] [blame] | 52 | } // namespace |
| 53 | |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 54 | EmbedderTest::EmbedderTest() |
Lei Zhang | 0729be2 | 2018-02-05 21:13:51 +0000 | [diff] [blame] | 55 | : default_delegate_(pdfium::MakeUnique<EmbedderTest::Delegate>()), |
| 56 | delegate_(default_delegate_.get()) { |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 57 | FPDF_FILEWRITE::version = 1; |
| 58 | FPDF_FILEWRITE::WriteBlock = WriteBlockCallback; |
Tom Sepez | f288bb1 | 2015-11-20 12:12:46 -0800 | [diff] [blame] | 59 | } |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 60 | |
Dan Sinclair | 5553d8b | 2018-01-03 09:44:28 -0500 | [diff] [blame] | 61 | EmbedderTest::~EmbedderTest() {} |
Tom Sepez | f288bb1 | 2015-11-20 12:12:46 -0800 | [diff] [blame] | 62 | |
| 63 | void EmbedderTest::SetUp() { |
Tom Sepez | a72e8e2 | 2015-10-07 10:17:53 -0700 | [diff] [blame] | 64 | FPDF_LIBRARY_CONFIG config; |
| 65 | config.version = 2; |
| 66 | config.m_pUserFontPaths = nullptr; |
Tom Sepez | a72e8e2 | 2015-10-07 10:17:53 -0700 | [diff] [blame] | 67 | config.m_v8EmbedderSlot = 0; |
Tom Sepez | 452b4f3 | 2015-10-13 09:27:27 -0700 | [diff] [blame] | 68 | config.m_pIsolate = external_isolate_; |
Tom Sepez | a72e8e2 | 2015-10-07 10:17:53 -0700 | [diff] [blame] | 69 | FPDF_InitLibraryWithConfig(&config); |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 70 | |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 71 | UNSUPPORT_INFO* info = static_cast<UNSUPPORT_INFO*>(this); |
| 72 | memset(info, 0, sizeof(UNSUPPORT_INFO)); |
| 73 | info->version = 1; |
| 74 | info->FSDK_UnSupport_Handler = UnsupportedHandlerTrampoline; |
| 75 | FSDK_SetUnSpObjProcessHandler(info); |
Henrique Nakashima | 9fa5036 | 2017-11-10 22:40:44 +0000 | [diff] [blame] | 76 | |
Lei Zhang | 0729be2 | 2018-02-05 21:13:51 +0000 | [diff] [blame] | 77 | saved_document_ = nullptr; |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 78 | } |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 79 | |
| 80 | void EmbedderTest::TearDown() { |
Lei Zhang | 75c8171 | 2018-02-08 17:22:39 +0000 | [diff] [blame] | 81 | // Use an EXPECT_EQ() here and continue to let TearDown() finish as cleanly as |
| 82 | // possible. This can fail when an ASSERT test fails in a test case. |
| 83 | EXPECT_EQ(0U, page_map_.size()); |
Lei Zhang | 9f72c45 | 2018-02-08 21:49:54 +0000 | [diff] [blame] | 84 | EXPECT_EQ(0U, saved_page_map_.size()); |
Lei Zhang | 75c8171 | 2018-02-08 17:22:39 +0000 | [diff] [blame] | 85 | |
Tom Sepez | da8189e | 2015-01-30 14:41:50 -0800 | [diff] [blame] | 86 | if (document_) { |
Lei Zhang | d27acae | 2015-05-15 15:36:02 -0700 | [diff] [blame] | 87 | FORM_DoDocumentAAction(form_handle_, FPDFDOC_AACTION_WC); |
Tom Sepez | c46d000 | 2015-11-30 15:46:36 -0800 | [diff] [blame] | 88 | FPDFDOC_ExitFormFillEnvironment(form_handle_); |
| 89 | FPDF_CloseDocument(document_); |
Tom Sepez | da8189e | 2015-01-30 14:41:50 -0800 | [diff] [blame] | 90 | } |
Tom Sepez | c46d000 | 2015-11-30 15:46:36 -0800 | [diff] [blame] | 91 | |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 92 | FPDFAvail_Destroy(avail_); |
| 93 | FPDF_DestroyLibrary(); |
Lei Zhang | d27acae | 2015-05-15 15:36:02 -0700 | [diff] [blame] | 94 | delete loader_; |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 95 | } |
| 96 | |
Lei Zhang | 378ec54 | 2018-10-18 19:15:47 +0000 | [diff] [blame] | 97 | #ifdef PDF_ENABLE_V8 |
| 98 | void EmbedderTest::SetExternalIsolate(void* isolate) { |
| 99 | external_isolate_ = static_cast<v8::Isolate*>(isolate); |
| 100 | } |
| 101 | #endif // PDF_ENABLE_V8 |
| 102 | |
Tom Sepez | d483eb4 | 2016-01-06 10:03:59 -0800 | [diff] [blame] | 103 | bool EmbedderTest::CreateEmptyDocument() { |
| 104 | document_ = FPDF_CreateNewDocument(); |
| 105 | if (!document_) |
| 106 | return false; |
| 107 | |
Tom Sepez | 0784c73 | 2018-04-23 18:02:57 +0000 | [diff] [blame] | 108 | form_handle_ = |
| 109 | SetupFormFillEnvironment(document_, JavaScriptOption::kEnableJavaScript); |
Tom Sepez | d483eb4 | 2016-01-06 10:03:59 -0800 | [diff] [blame] | 110 | return true; |
| 111 | } |
| 112 | |
Lei Zhang | 208eecf | 2017-12-20 19:40:50 +0000 | [diff] [blame] | 113 | bool EmbedderTest::OpenDocument(const std::string& filename) { |
Tom Sepez | 0784c73 | 2018-04-23 18:02:57 +0000 | [diff] [blame] | 114 | return OpenDocumentWithOptions(filename, nullptr, |
| 115 | LinearizeOption::kDefaultLinearize, |
| 116 | JavaScriptOption::kEnableJavaScript); |
Lei Zhang | 208eecf | 2017-12-20 19:40:50 +0000 | [diff] [blame] | 117 | } |
| 118 | |
| 119 | bool EmbedderTest::OpenDocumentLinearized(const std::string& filename) { |
Tom Sepez | 0784c73 | 2018-04-23 18:02:57 +0000 | [diff] [blame] | 120 | return OpenDocumentWithOptions(filename, nullptr, |
| 121 | LinearizeOption::kMustLinearize, |
| 122 | JavaScriptOption::kEnableJavaScript); |
Lei Zhang | 208eecf | 2017-12-20 19:40:50 +0000 | [diff] [blame] | 123 | } |
| 124 | |
| 125 | bool EmbedderTest::OpenDocumentWithPassword(const std::string& filename, |
| 126 | const char* password) { |
Tom Sepez | 0784c73 | 2018-04-23 18:02:57 +0000 | [diff] [blame] | 127 | return OpenDocumentWithOptions(filename, password, |
| 128 | LinearizeOption::kDefaultLinearize, |
| 129 | JavaScriptOption::kEnableJavaScript); |
| 130 | } |
| 131 | |
| 132 | bool EmbedderTest::OpenDocumentWithoutJavaScript(const std::string& filename) { |
| 133 | return OpenDocumentWithOptions(filename, nullptr, |
| 134 | LinearizeOption::kDefaultLinearize, |
| 135 | JavaScriptOption::kDisableJavaScript); |
Lei Zhang | 208eecf | 2017-12-20 19:40:50 +0000 | [diff] [blame] | 136 | } |
| 137 | |
| 138 | bool EmbedderTest::OpenDocumentWithOptions(const std::string& filename, |
| 139 | const char* password, |
Tom Sepez | 0784c73 | 2018-04-23 18:02:57 +0000 | [diff] [blame] | 140 | LinearizeOption linearize_option, |
| 141 | JavaScriptOption javascript_option) { |
Wei Li | 091f7a0 | 2015-11-09 12:09:55 -0800 | [diff] [blame] | 142 | std::string file_path; |
| 143 | if (!PathService::GetTestFilePath(filename, &file_path)) |
| 144 | return false; |
Tom Sepez | 0784c73 | 2018-04-23 18:02:57 +0000 | [diff] [blame] | 145 | |
Wei Li | 091f7a0 | 2015-11-09 12:09:55 -0800 | [diff] [blame] | 146 | file_contents_ = GetFileContents(file_path.c_str(), &file_length_); |
Dan Sinclair | 6be2aab | 2015-10-28 13:58:49 -0400 | [diff] [blame] | 147 | if (!file_contents_) |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 148 | return false; |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 149 | |
thestig | 29ce923 | 2016-06-22 07:03:23 -0700 | [diff] [blame] | 150 | EXPECT_TRUE(!loader_); |
Tom Sepez | 0aa3531 | 2016-01-06 10:16:32 -0800 | [diff] [blame] | 151 | loader_ = new TestLoader(file_contents_.get(), file_length_); |
Lei Zhang | 0729be2 | 2018-02-05 21:13:51 +0000 | [diff] [blame] | 152 | |
| 153 | memset(&file_access_, 0, sizeof(file_access_)); |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 154 | file_access_.m_FileLen = static_cast<unsigned long>(file_length_); |
Tom Sepez | d831dc7 | 2015-10-19 16:04:22 -0700 | [diff] [blame] | 155 | file_access_.m_GetBlock = TestLoader::GetBlock; |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 156 | file_access_.m_Param = loader_; |
Lei Zhang | 0729be2 | 2018-02-05 21:13:51 +0000 | [diff] [blame] | 157 | |
Artem Strygin | 0e60b9e | 2017-09-28 18:46:03 +0300 | [diff] [blame] | 158 | fake_file_access_ = pdfium::MakeUnique<FakeFileAccess>(&file_access_); |
Tom Sepez | 0784c73 | 2018-04-23 18:02:57 +0000 | [diff] [blame] | 159 | return OpenDocumentHelper(password, linearize_option, javascript_option, |
| 160 | fake_file_access_.get(), &document_, &avail_, |
| 161 | &form_handle_); |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 162 | } |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 163 | |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 164 | bool EmbedderTest::OpenDocumentHelper(const char* password, |
Tom Sepez | 0784c73 | 2018-04-23 18:02:57 +0000 | [diff] [blame] | 165 | LinearizeOption linearize_option, |
| 166 | JavaScriptOption javascript_option, |
Artem Strygin | 0e60b9e | 2017-09-28 18:46:03 +0300 | [diff] [blame] | 167 | FakeFileAccess* network_simulator, |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 168 | FPDF_DOCUMENT* document, |
| 169 | FPDF_AVAIL* avail, |
| 170 | FPDF_FORMHANDLE* form_handle) { |
Artem Strygin | 0e60b9e | 2017-09-28 18:46:03 +0300 | [diff] [blame] | 171 | network_simulator->AddSegment(0, 1024); |
| 172 | network_simulator->SetRequestedDataAvailable(); |
| 173 | *avail = FPDFAvail_Create(network_simulator->GetFileAvail(), |
| 174 | network_simulator->GetFileAccess()); |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 175 | if (FPDFAvail_IsLinearized(*avail) == PDF_LINEARIZED) { |
Artem Strygin | 0e60b9e | 2017-09-28 18:46:03 +0300 | [diff] [blame] | 176 | int32_t nRet = PDF_DATA_NOTAVAIL; |
| 177 | while (nRet == PDF_DATA_NOTAVAIL) { |
| 178 | network_simulator->SetRequestedDataAvailable(); |
| 179 | nRet = |
| 180 | FPDFAvail_IsDocAvail(*avail, network_simulator->GetDownloadHints()); |
| 181 | } |
| 182 | if (nRet == PDF_DATA_ERROR) |
| 183 | return false; |
| 184 | |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 185 | *document = FPDFAvail_GetDocument(*avail, password); |
| 186 | if (!*document) |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 187 | return false; |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 188 | |
Artem Strygin | 0e60b9e | 2017-09-28 18:46:03 +0300 | [diff] [blame] | 189 | nRet = PDF_DATA_NOTAVAIL; |
| 190 | while (nRet == PDF_DATA_NOTAVAIL) { |
| 191 | network_simulator->SetRequestedDataAvailable(); |
| 192 | nRet = |
| 193 | FPDFAvail_IsFormAvail(*avail, network_simulator->GetDownloadHints()); |
| 194 | } |
| 195 | if (nRet == PDF_FORM_ERROR) |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 196 | return false; |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 197 | |
| 198 | int page_count = FPDF_GetPageCount(*document); |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 199 | for (int i = 0; i < page_count; ++i) { |
| 200 | nRet = PDF_DATA_NOTAVAIL; |
Artem Strygin | 0e60b9e | 2017-09-28 18:46:03 +0300 | [diff] [blame] | 201 | while (nRet == PDF_DATA_NOTAVAIL) { |
| 202 | network_simulator->SetRequestedDataAvailable(); |
| 203 | nRet = FPDFAvail_IsPageAvail(*avail, i, |
| 204 | network_simulator->GetDownloadHints()); |
| 205 | } |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 206 | |
| 207 | if (nRet == PDF_DATA_ERROR) |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 208 | return false; |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 209 | } |
| 210 | } else { |
Tom Sepez | 0784c73 | 2018-04-23 18:02:57 +0000 | [diff] [blame] | 211 | if (linearize_option == LinearizeOption::kMustLinearize) |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 212 | return false; |
Artem Strygin | 0e60b9e | 2017-09-28 18:46:03 +0300 | [diff] [blame] | 213 | network_simulator->SetWholeFileAvailable(); |
| 214 | *document = |
| 215 | FPDF_LoadCustomDocument(network_simulator->GetFileAccess(), password); |
Nicolas Pena | 56fc972 | 2017-07-13 16:31:34 -0400 | [diff] [blame] | 216 | if (!*document) |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 217 | return false; |
Jun Fang | df7f366 | 2015-11-10 18:29:18 +0800 | [diff] [blame] | 218 | } |
Tom Sepez | 0784c73 | 2018-04-23 18:02:57 +0000 | [diff] [blame] | 219 | *form_handle = SetupFormFillEnvironment(*document, javascript_option); |
| 220 | |
Tom Sepez | c46d000 | 2015-11-30 15:46:36 -0800 | [diff] [blame] | 221 | #ifdef PDF_ENABLE_XFA |
Ryan Harrison | 854d71c | 2017-10-18 12:28:14 -0400 | [diff] [blame] | 222 | int doc_type = FPDF_GetFormType(*document); |
| 223 | if (doc_type == FORMTYPE_XFA_FULL || doc_type == FORMTYPE_XFA_FOREGROUND) |
| 224 | FPDF_LoadXFA(*document); |
Tom Sepez | c46d000 | 2015-11-30 15:46:36 -0800 | [diff] [blame] | 225 | #endif // PDF_ENABLE_XFA |
Tom Sepez | 0784c73 | 2018-04-23 18:02:57 +0000 | [diff] [blame] | 226 | |
Ryan Harrison | 6cec70a | 2018-06-05 14:06:10 +0000 | [diff] [blame] | 227 | (void)FPDF_GetDocPermissions(*document); |
Tom Sepez | d483eb4 | 2016-01-06 10:03:59 -0800 | [diff] [blame] | 228 | return true; |
| 229 | } |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 230 | |
Tom Sepez | 0784c73 | 2018-04-23 18:02:57 +0000 | [diff] [blame] | 231 | FPDF_FORMHANDLE EmbedderTest::SetupFormFillEnvironment( |
| 232 | FPDF_DOCUMENT doc, |
| 233 | JavaScriptOption javascript_option) { |
Tom Sepez | 4cb0fa7 | 2015-02-25 16:08:18 -0800 | [diff] [blame] | 234 | IPDF_JSPLATFORM* platform = static_cast<IPDF_JSPLATFORM*>(this); |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 235 | memset(platform, '\0', sizeof(IPDF_JSPLATFORM)); |
Jochen Eisinger | 06b6002 | 2015-07-30 17:44:35 +0200 | [diff] [blame] | 236 | platform->version = 2; |
Tom Sepez | 4cb0fa7 | 2015-02-25 16:08:18 -0800 | [diff] [blame] | 237 | platform->app_alert = AlertTrampoline; |
Dan Sinclair | 14aacd5 | 2017-05-18 14:11:29 -0400 | [diff] [blame] | 238 | platform->m_isolate = external_isolate_; |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 239 | |
Tom Sepez | 4cb0fa7 | 2015-02-25 16:08:18 -0800 | [diff] [blame] | 240 | FPDF_FORMFILLINFO* formfillinfo = static_cast<FPDF_FORMFILLINFO*>(this); |
| 241 | memset(formfillinfo, 0, sizeof(FPDF_FORMFILLINFO)); |
Lei Zhang | cd39695 | 2015-11-04 20:26:50 -0800 | [diff] [blame] | 242 | #ifdef PDF_ENABLE_XFA |
| 243 | formfillinfo->version = 2; |
Tom Sepez | c46d000 | 2015-11-30 15:46:36 -0800 | [diff] [blame] | 244 | #else // PDF_ENABLE_XFA |
Tom Sepez | 4cb0fa7 | 2015-02-25 16:08:18 -0800 | [diff] [blame] | 245 | formfillinfo->version = 1; |
Tom Sepez | c46d000 | 2015-11-30 15:46:36 -0800 | [diff] [blame] | 246 | #endif // PDF_ENABLE_XFA |
Tom Sepez | 6efc0ad | 2015-06-02 17:11:18 -0700 | [diff] [blame] | 247 | formfillinfo->FFI_SetTimer = SetTimerTrampoline; |
| 248 | formfillinfo->FFI_KillTimer = KillTimerTrampoline; |
Tom Sepez | 396e872 | 2015-09-09 10:16:08 -0700 | [diff] [blame] | 249 | formfillinfo->FFI_GetPage = GetPageTrampoline; |
Henrique Nakashima | 9ef93d0 | 2018-10-03 18:41:03 +0000 | [diff] [blame] | 250 | formfillinfo->FFI_DoURIAction = DoURIActionTrampoline; |
| 251 | |
Tom Sepez | 0784c73 | 2018-04-23 18:02:57 +0000 | [diff] [blame] | 252 | if (javascript_option == JavaScriptOption::kEnableJavaScript) |
| 253 | formfillinfo->m_pJsPlatform = platform; |
| 254 | |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 255 | FPDF_FORMHANDLE form_handle = |
| 256 | FPDFDOC_InitFormFillEnvironment(doc, formfillinfo); |
Ryan Harrison | 9baf31f | 2018-01-12 18:36:30 +0000 | [diff] [blame] | 257 | FPDF_SetFormFieldHighlightColor(form_handle, FPDF_FORMFIELD_UNKNOWN, |
| 258 | 0xFFE4DD); |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 259 | FPDF_SetFormFieldHighlightAlpha(form_handle, 100); |
| 260 | return form_handle; |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 261 | } |
| 262 | |
Tom Sepez | da8189e | 2015-01-30 14:41:50 -0800 | [diff] [blame] | 263 | void EmbedderTest::DoOpenActions() { |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 264 | ASSERT(form_handle_); |
Tom Sepez | da8189e | 2015-01-30 14:41:50 -0800 | [diff] [blame] | 265 | FORM_DoDocumentJSAction(form_handle_); |
| 266 | FORM_DoDocumentOpenAction(form_handle_); |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 267 | } |
| 268 | |
| 269 | int EmbedderTest::GetFirstPageNum() { |
| 270 | int first_page = FPDFAvail_GetFirstPageNum(document_); |
Ryan Harrison | 6cec70a | 2018-06-05 14:06:10 +0000 | [diff] [blame] | 271 | (void)FPDFAvail_IsPageAvail(avail_, first_page, |
| 272 | fake_file_access_->GetDownloadHints()); |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 273 | return first_page; |
| 274 | } |
| 275 | |
| 276 | int EmbedderTest::GetPageCount() { |
| 277 | int page_count = FPDF_GetPageCount(document_); |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 278 | for (int i = 0; i < page_count; ++i) |
Ryan Harrison | 6cec70a | 2018-06-05 14:06:10 +0000 | [diff] [blame] | 279 | (void)FPDFAvail_IsPageAvail(avail_, i, |
| 280 | fake_file_access_->GetDownloadHints()); |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 281 | return page_count; |
| 282 | } |
| 283 | |
Tom Sepez | da8189e | 2015-01-30 14:41:50 -0800 | [diff] [blame] | 284 | FPDF_PAGE EmbedderTest::LoadPage(int page_number) { |
Tom Sepez | 507d019 | 2018-11-07 16:37:51 +0000 | [diff] [blame] | 285 | return LoadPageCommon(page_number, true); |
| 286 | } |
| 287 | |
| 288 | FPDF_PAGE EmbedderTest::LoadPageNoEvents(int page_number) { |
| 289 | return LoadPageCommon(page_number, false); |
| 290 | } |
| 291 | |
| 292 | FPDF_PAGE EmbedderTest::LoadPageCommon(int page_number, bool do_events) { |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 293 | ASSERT(form_handle_); |
Lei Zhang | 75c8171 | 2018-02-08 17:22:39 +0000 | [diff] [blame] | 294 | ASSERT(page_number >= 0); |
| 295 | ASSERT(!pdfium::ContainsKey(page_map_, page_number)); |
weili | 0dadcc6 | 2016-08-23 21:10:57 -0700 | [diff] [blame] | 296 | |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 297 | FPDF_PAGE page = FPDF_LoadPage(document_, page_number); |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 298 | if (!page) |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 299 | return nullptr; |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 300 | |
Tom Sepez | 507d019 | 2018-11-07 16:37:51 +0000 | [diff] [blame] | 301 | if (do_events) { |
| 302 | FORM_OnAfterLoadPage(page, form_handle_); |
| 303 | FORM_DoPageAAction(page, form_handle_, FPDFPAGE_AACTION_OPEN); |
| 304 | } |
weili | 0dadcc6 | 2016-08-23 21:10:57 -0700 | [diff] [blame] | 305 | page_map_[page_number] = page; |
Tom Sepez | 396e872 | 2015-09-09 10:16:08 -0700 | [diff] [blame] | 306 | return page; |
| 307 | } |
| 308 | |
Tom Sepez | da8189e | 2015-01-30 14:41:50 -0800 | [diff] [blame] | 309 | void EmbedderTest::UnloadPage(FPDF_PAGE page) { |
Tom Sepez | 507d019 | 2018-11-07 16:37:51 +0000 | [diff] [blame] | 310 | UnloadPageCommon(page, true); |
| 311 | } |
Lei Zhang | 75c8171 | 2018-02-08 17:22:39 +0000 | [diff] [blame] | 312 | |
Tom Sepez | 507d019 | 2018-11-07 16:37:51 +0000 | [diff] [blame] | 313 | void EmbedderTest::UnloadPageNoEvents(FPDF_PAGE page) { |
| 314 | UnloadPageCommon(page, false); |
| 315 | } |
| 316 | |
| 317 | void EmbedderTest::UnloadPageCommon(FPDF_PAGE page, bool do_events) { |
| 318 | ASSERT(form_handle_); |
Lei Zhang | 75c8171 | 2018-02-08 17:22:39 +0000 | [diff] [blame] | 319 | int page_number = GetPageNumberForLoadedPage(page); |
| 320 | if (page_number < 0) { |
| 321 | NOTREACHED(); |
| 322 | return; |
| 323 | } |
Tom Sepez | 507d019 | 2018-11-07 16:37:51 +0000 | [diff] [blame] | 324 | if (do_events) { |
| 325 | FORM_DoPageAAction(page, form_handle_, FPDFPAGE_AACTION_CLOSE); |
| 326 | FORM_OnBeforeClosePage(page, form_handle_); |
| 327 | } |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 328 | FPDF_ClosePage(page); |
Lei Zhang | 75c8171 | 2018-02-08 17:22:39 +0000 | [diff] [blame] | 329 | page_map_.erase(page_number); |
Tom Sepez | 96d1334 | 2015-01-16 14:59:26 -0800 | [diff] [blame] | 330 | } |
Tom Sepez | 1b1bb49 | 2015-01-22 17:36:32 -0800 | [diff] [blame] | 331 | |
Tom Sepez | e08d2b1 | 2018-04-25 18:49:32 +0000 | [diff] [blame] | 332 | ScopedFPDFBitmap EmbedderTest::RenderLoadedPage(FPDF_PAGE page) { |
Lei Zhang | a98e366 | 2018-02-07 20:28:35 +0000 | [diff] [blame] | 333 | return RenderLoadedPageWithFlags(page, 0); |
| 334 | } |
| 335 | |
Tom Sepez | e08d2b1 | 2018-04-25 18:49:32 +0000 | [diff] [blame] | 336 | ScopedFPDFBitmap EmbedderTest::RenderLoadedPageWithFlags(FPDF_PAGE page, |
| 337 | int flags) { |
Lei Zhang | 75c8171 | 2018-02-08 17:22:39 +0000 | [diff] [blame] | 338 | if (GetPageNumberForLoadedPage(page) < 0) { |
| 339 | NOTREACHED(); |
| 340 | return nullptr; |
| 341 | } |
Lei Zhang | a98e366 | 2018-02-07 20:28:35 +0000 | [diff] [blame] | 342 | return RenderPageWithFlags(page, form_handle_, flags); |
| 343 | } |
| 344 | |
Tom Sepez | e08d2b1 | 2018-04-25 18:49:32 +0000 | [diff] [blame] | 345 | ScopedFPDFBitmap EmbedderTest::RenderSavedPage(FPDF_PAGE page) { |
Lei Zhang | a98e366 | 2018-02-07 20:28:35 +0000 | [diff] [blame] | 346 | return RenderSavedPageWithFlags(page, 0); |
| 347 | } |
| 348 | |
Tom Sepez | e08d2b1 | 2018-04-25 18:49:32 +0000 | [diff] [blame] | 349 | ScopedFPDFBitmap EmbedderTest::RenderSavedPageWithFlags(FPDF_PAGE page, |
| 350 | int flags) { |
Lei Zhang | 9f72c45 | 2018-02-08 21:49:54 +0000 | [diff] [blame] | 351 | if (GetPageNumberForSavedPage(page) < 0) { |
| 352 | NOTREACHED(); |
| 353 | return nullptr; |
| 354 | } |
Lei Zhang | a98e366 | 2018-02-07 20:28:35 +0000 | [diff] [blame] | 355 | return RenderPageWithFlags(page, saved_form_handle_, flags); |
| 356 | } |
| 357 | |
| 358 | // static |
Tom Sepez | e08d2b1 | 2018-04-25 18:49:32 +0000 | [diff] [blame] | 359 | ScopedFPDFBitmap EmbedderTest::RenderPageWithFlags(FPDF_PAGE page, |
| 360 | FPDF_FORMHANDLE handle, |
| 361 | int flags) { |
Lei Zhang | a98e366 | 2018-02-07 20:28:35 +0000 | [diff] [blame] | 362 | int width = static_cast<int>(FPDF_GetPageWidth(page)); |
| 363 | int height = static_cast<int>(FPDF_GetPageHeight(page)); |
| 364 | int alpha = FPDFPage_HasTransparency(page) ? 1 : 0; |
Tom Sepez | e08d2b1 | 2018-04-25 18:49:32 +0000 | [diff] [blame] | 365 | ScopedFPDFBitmap bitmap(FPDFBitmap_Create(width, height, alpha)); |
Lei Zhang | a98e366 | 2018-02-07 20:28:35 +0000 | [diff] [blame] | 366 | FPDF_DWORD fill_color = alpha ? 0x00000000 : 0xFFFFFFFF; |
| 367 | FPDFBitmap_FillRect(bitmap.get(), 0, 0, width, height, fill_color); |
| 368 | FPDF_RenderPageBitmap(bitmap.get(), page, 0, 0, width, height, 0, flags); |
| 369 | FPDF_FFLDraw(handle, bitmap.get(), page, 0, 0, width, height, 0, flags); |
| 370 | return bitmap; |
| 371 | } |
| 372 | |
Dan Sinclair | 04e4dc8 | 2017-10-18 12:17:14 -0400 | [diff] [blame] | 373 | FPDF_DOCUMENT EmbedderTest::OpenSavedDocument(const char* password) { |
Artem Strygin | 0e60b9e | 2017-09-28 18:46:03 +0300 | [diff] [blame] | 374 | memset(&saved_file_access_, 0, sizeof(saved_file_access_)); |
Lei Zhang | 0729be2 | 2018-02-05 21:13:51 +0000 | [diff] [blame] | 375 | saved_file_access_.m_FileLen = data_string_.size(); |
Artem Strygin | 0e60b9e | 2017-09-28 18:46:03 +0300 | [diff] [blame] | 376 | saved_file_access_.m_GetBlock = GetBlockFromString; |
Artem Strygin | 68d04f2 | 2018-07-12 09:18:19 +0000 | [diff] [blame] | 377 | // Copy data to prevent clearing it before saved document close. |
| 378 | saved_document_file_data_ = data_string_; |
| 379 | saved_file_access_.m_Param = &saved_document_file_data_; |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 380 | |
Artem Strygin | 0e60b9e | 2017-09-28 18:46:03 +0300 | [diff] [blame] | 381 | saved_fake_file_access_ = |
| 382 | pdfium::MakeUnique<FakeFileAccess>(&saved_file_access_); |
| 383 | |
Tom Sepez | 0784c73 | 2018-04-23 18:02:57 +0000 | [diff] [blame] | 384 | EXPECT_TRUE(OpenDocumentHelper( |
| 385 | password, LinearizeOption::kDefaultLinearize, |
| 386 | JavaScriptOption::kEnableJavaScript, saved_fake_file_access_.get(), |
| 387 | &saved_document_, &saved_avail_, &saved_form_handle_)); |
Lei Zhang | 0729be2 | 2018-02-05 21:13:51 +0000 | [diff] [blame] | 388 | return saved_document_; |
Dan Sinclair | 04e4dc8 | 2017-10-18 12:17:14 -0400 | [diff] [blame] | 389 | } |
| 390 | |
| 391 | void EmbedderTest::CloseSavedDocument() { |
Lei Zhang | 0729be2 | 2018-02-05 21:13:51 +0000 | [diff] [blame] | 392 | ASSERT(saved_document_); |
Dan Sinclair | 04e4dc8 | 2017-10-18 12:17:14 -0400 | [diff] [blame] | 393 | |
Lei Zhang | 0729be2 | 2018-02-05 21:13:51 +0000 | [diff] [blame] | 394 | FPDFDOC_ExitFormFillEnvironment(saved_form_handle_); |
| 395 | FPDF_CloseDocument(saved_document_); |
| 396 | FPDFAvail_Destroy(saved_avail_); |
Dan Sinclair | 04e4dc8 | 2017-10-18 12:17:14 -0400 | [diff] [blame] | 397 | |
Lei Zhang | 0729be2 | 2018-02-05 21:13:51 +0000 | [diff] [blame] | 398 | saved_form_handle_ = nullptr; |
| 399 | saved_document_ = nullptr; |
| 400 | saved_avail_ = nullptr; |
Dan Sinclair | 04e4dc8 | 2017-10-18 12:17:14 -0400 | [diff] [blame] | 401 | } |
| 402 | |
Henrique Nakashima | 8baea3c | 2017-11-10 20:27:23 +0000 | [diff] [blame] | 403 | FPDF_PAGE EmbedderTest::LoadSavedPage(int page_number) { |
Lei Zhang | 9f72c45 | 2018-02-08 21:49:54 +0000 | [diff] [blame] | 404 | ASSERT(saved_form_handle_); |
| 405 | ASSERT(page_number >= 0); |
| 406 | ASSERT(!pdfium::ContainsKey(saved_page_map_, page_number)); |
Dan Sinclair | 04e4dc8 | 2017-10-18 12:17:14 -0400 | [diff] [blame] | 407 | |
Lei Zhang | 0729be2 | 2018-02-05 21:13:51 +0000 | [diff] [blame] | 408 | FPDF_PAGE page = FPDF_LoadPage(saved_document_, page_number); |
Lei Zhang | 9f72c45 | 2018-02-08 21:49:54 +0000 | [diff] [blame] | 409 | if (!page) |
| 410 | return nullptr; |
Dan Sinclair | 04e4dc8 | 2017-10-18 12:17:14 -0400 | [diff] [blame] | 411 | |
Lei Zhang | 9f72c45 | 2018-02-08 21:49:54 +0000 | [diff] [blame] | 412 | FORM_OnAfterLoadPage(page, saved_form_handle_); |
| 413 | FORM_DoPageAAction(page, saved_form_handle_, FPDFPAGE_AACTION_OPEN); |
| 414 | saved_page_map_[page_number] = page; |
Henrique Nakashima | 8baea3c | 2017-11-10 20:27:23 +0000 | [diff] [blame] | 415 | return page; |
Dan Sinclair | 04e4dc8 | 2017-10-18 12:17:14 -0400 | [diff] [blame] | 416 | } |
| 417 | |
Henrique Nakashima | 8baea3c | 2017-11-10 20:27:23 +0000 | [diff] [blame] | 418 | void EmbedderTest::CloseSavedPage(FPDF_PAGE page) { |
Lei Zhang | 9f72c45 | 2018-02-08 21:49:54 +0000 | [diff] [blame] | 419 | ASSERT(saved_form_handle_); |
| 420 | |
| 421 | int page_number = GetPageNumberForSavedPage(page); |
| 422 | if (page_number < 0) { |
| 423 | NOTREACHED(); |
| 424 | return; |
| 425 | } |
| 426 | |
| 427 | FORM_DoPageAAction(page, saved_form_handle_, FPDFPAGE_AACTION_CLOSE); |
| 428 | FORM_OnBeforeClosePage(page, saved_form_handle_); |
Henrique Nakashima | 8baea3c | 2017-11-10 20:27:23 +0000 | [diff] [blame] | 429 | FPDF_ClosePage(page); |
Lei Zhang | 9f72c45 | 2018-02-08 21:49:54 +0000 | [diff] [blame] | 430 | |
| 431 | saved_page_map_.erase(page_number); |
Dan Sinclair | 04e4dc8 | 2017-10-18 12:17:14 -0400 | [diff] [blame] | 432 | } |
| 433 | |
Henrique Nakashima | 8baea3c | 2017-11-10 20:27:23 +0000 | [diff] [blame] | 434 | void EmbedderTest::VerifySavedRendering(FPDF_PAGE page, |
| 435 | int width, |
Dan Sinclair | 04e4dc8 | 2017-10-18 12:17:14 -0400 | [diff] [blame] | 436 | int height, |
| 437 | const char* md5) { |
Lei Zhang | 0729be2 | 2018-02-05 21:13:51 +0000 | [diff] [blame] | 438 | ASSERT(saved_document_); |
Henrique Nakashima | 8baea3c | 2017-11-10 20:27:23 +0000 | [diff] [blame] | 439 | ASSERT(page); |
Dan Sinclair | 04e4dc8 | 2017-10-18 12:17:14 -0400 | [diff] [blame] | 440 | |
Tom Sepez | e08d2b1 | 2018-04-25 18:49:32 +0000 | [diff] [blame] | 441 | ScopedFPDFBitmap bitmap = RenderSavedPageWithFlags(page, FPDF_ANNOT); |
Lei Zhang | a98e366 | 2018-02-07 20:28:35 +0000 | [diff] [blame] | 442 | CompareBitmap(bitmap.get(), width, height, md5); |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 443 | } |
| 444 | |
Dan Sinclair | 04e4dc8 | 2017-10-18 12:17:14 -0400 | [diff] [blame] | 445 | void EmbedderTest::VerifySavedDocument(int width, int height, const char* md5) { |
Tom Sepez | b9c3e27 | 2018-08-14 18:22:06 +0000 | [diff] [blame] | 446 | OpenSavedDocument(nullptr); |
Henrique Nakashima | 8baea3c | 2017-11-10 20:27:23 +0000 | [diff] [blame] | 447 | FPDF_PAGE page = LoadSavedPage(0); |
| 448 | VerifySavedRendering(page, width, height, md5); |
| 449 | CloseSavedPage(page); |
Dan Sinclair | 04e4dc8 | 2017-10-18 12:17:14 -0400 | [diff] [blame] | 450 | CloseSavedDocument(); |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 451 | } |
| 452 | |
Artem Strygin | 0e60b9e | 2017-09-28 18:46:03 +0300 | [diff] [blame] | 453 | void EmbedderTest::SetWholeFileAvailable() { |
| 454 | ASSERT(fake_file_access_); |
| 455 | fake_file_access_->SetWholeFileAvailable(); |
| 456 | } |
| 457 | |
weili | 0dadcc6 | 2016-08-23 21:10:57 -0700 | [diff] [blame] | 458 | FPDF_PAGE EmbedderTest::Delegate::GetPage(FPDF_FORMFILLINFO* info, |
Tom Sepez | 396e872 | 2015-09-09 10:16:08 -0700 | [diff] [blame] | 459 | FPDF_DOCUMENT document, |
| 460 | int page_index) { |
weili | 0dadcc6 | 2016-08-23 21:10:57 -0700 | [diff] [blame] | 461 | EmbedderTest* test = static_cast<EmbedderTest*>(info); |
| 462 | auto it = test->page_map_.find(page_index); |
| 463 | return it != test->page_map_.end() ? it->second : nullptr; |
Tom Sepez | 396e872 | 2015-09-09 10:16:08 -0700 | [diff] [blame] | 464 | } |
| 465 | |
Tom Sepez | 4cb0fa7 | 2015-02-25 16:08:18 -0800 | [diff] [blame] | 466 | // static |
| 467 | void EmbedderTest::UnsupportedHandlerTrampoline(UNSUPPORT_INFO* info, |
| 468 | int type) { |
| 469 | EmbedderTest* test = static_cast<EmbedderTest*>(info); |
| 470 | test->delegate_->UnsupportedHandler(type); |
| 471 | } |
| 472 | |
| 473 | // static |
| 474 | int EmbedderTest::AlertTrampoline(IPDF_JSPLATFORM* platform, |
| 475 | FPDF_WIDESTRING message, |
| 476 | FPDF_WIDESTRING title, |
| 477 | int type, |
| 478 | int icon) { |
| 479 | EmbedderTest* test = static_cast<EmbedderTest*>(platform); |
| 480 | return test->delegate_->Alert(message, title, type, icon); |
| 481 | } |
| 482 | |
Tom Sepez | 6efc0ad | 2015-06-02 17:11:18 -0700 | [diff] [blame] | 483 | // static |
| 484 | int EmbedderTest::SetTimerTrampoline(FPDF_FORMFILLINFO* info, |
Nico Weber | 9d8ec5a | 2015-08-04 13:00:21 -0700 | [diff] [blame] | 485 | int msecs, |
| 486 | TimerCallback fn) { |
Tom Sepez | 6efc0ad | 2015-06-02 17:11:18 -0700 | [diff] [blame] | 487 | EmbedderTest* test = static_cast<EmbedderTest*>(info); |
| 488 | return test->delegate_->SetTimer(msecs, fn); |
| 489 | } |
| 490 | |
| 491 | // static |
| 492 | void EmbedderTest::KillTimerTrampoline(FPDF_FORMFILLINFO* info, int id) { |
| 493 | EmbedderTest* test = static_cast<EmbedderTest*>(info); |
| 494 | return test->delegate_->KillTimer(id); |
| 495 | } |
| 496 | |
Tom Sepez | 396e872 | 2015-09-09 10:16:08 -0700 | [diff] [blame] | 497 | // static |
| 498 | FPDF_PAGE EmbedderTest::GetPageTrampoline(FPDF_FORMFILLINFO* info, |
| 499 | FPDF_DOCUMENT document, |
| 500 | int page_index) { |
weili | 0dadcc6 | 2016-08-23 21:10:57 -0700 | [diff] [blame] | 501 | return static_cast<EmbedderTest*>(info)->delegate_->GetPage(info, document, |
| 502 | page_index); |
Tom Sepez | 396e872 | 2015-09-09 10:16:08 -0700 | [diff] [blame] | 503 | } |
| 504 | |
Henrique Nakashima | 9fa5036 | 2017-11-10 22:40:44 +0000 | [diff] [blame] | 505 | // static |
Henrique Nakashima | 9ef93d0 | 2018-10-03 18:41:03 +0000 | [diff] [blame] | 506 | void EmbedderTest::DoURIActionTrampoline(FPDF_FORMFILLINFO* info, |
| 507 | FPDF_BYTESTRING uri) { |
| 508 | EmbedderTest* test = static_cast<EmbedderTest*>(info); |
| 509 | return test->delegate_->DoURIAction(uri); |
| 510 | } |
| 511 | |
| 512 | // static |
Henrique Nakashima | 9fa5036 | 2017-11-10 22:40:44 +0000 | [diff] [blame] | 513 | std::string EmbedderTest::HashBitmap(FPDF_BITMAP bitmap) { |
Dan Sinclair | 957480c | 2017-06-13 15:21:14 -0400 | [diff] [blame] | 514 | uint8_t digest[16]; |
Henrique Nakashima | 9fa5036 | 2017-11-10 22:40:44 +0000 | [diff] [blame] | 515 | CRYPT_MD5Generate(static_cast<uint8_t*>(FPDFBitmap_GetBuffer(bitmap)), |
| 516 | FPDFBitmap_GetWidth(bitmap) * |
| 517 | GetBitmapBytesPerPixel(bitmap) * |
| 518 | FPDFBitmap_GetHeight(bitmap), |
| 519 | digest); |
Dan Sinclair | 957480c | 2017-06-13 15:21:14 -0400 | [diff] [blame] | 520 | return CryptToBase16(digest); |
| 521 | } |
| 522 | |
Henrique Nakashima | db26957 | 2018-01-16 19:02:15 +0000 | [diff] [blame] | 523 | #ifndef NDEBUG |
| 524 | // static |
| 525 | void EmbedderTest::WriteBitmapToPng(FPDF_BITMAP bitmap, |
| 526 | const std::string& filename) { |
Henrique Nakashima | f956bad | 2018-08-16 16:41:42 +0000 | [diff] [blame] | 527 | BitmapSaver::WriteBitmapToPng(bitmap, filename); |
Henrique Nakashima | db26957 | 2018-01-16 19:02:15 +0000 | [diff] [blame] | 528 | } |
| 529 | #endif |
| 530 | |
thestig | bcd3e53 | 2016-11-21 13:37:28 -0800 | [diff] [blame] | 531 | // static |
| 532 | void EmbedderTest::CompareBitmap(FPDF_BITMAP bitmap, |
| 533 | int expected_width, |
| 534 | int expected_height, |
| 535 | const char* expected_md5sum) { |
| 536 | ASSERT_EQ(expected_width, FPDFBitmap_GetWidth(bitmap)); |
| 537 | ASSERT_EQ(expected_height, FPDFBitmap_GetHeight(bitmap)); |
Jane Liu | 28fb7ba | 2017-08-02 21:45:57 -0400 | [diff] [blame] | 538 | |
| 539 | // The expected stride is calculated using the same formula as in |
| 540 | // CFX_DIBitmap::CalculatePitchAndSize(), which sets the bitmap stride. |
| 541 | const int expected_stride = |
| 542 | (expected_width * GetBitmapBytesPerPixel(bitmap) * 8 + 31) / 32 * 4; |
thestig | bcd3e53 | 2016-11-21 13:37:28 -0800 | [diff] [blame] | 543 | ASSERT_EQ(expected_stride, FPDFBitmap_GetStride(bitmap)); |
| 544 | |
| 545 | if (!expected_md5sum) |
| 546 | return; |
| 547 | |
Henrique Nakashima | 9fa5036 | 2017-11-10 22:40:44 +0000 | [diff] [blame] | 548 | EXPECT_EQ(expected_md5sum, HashBitmap(bitmap)); |
thestig | bcd3e53 | 2016-11-21 13:37:28 -0800 | [diff] [blame] | 549 | } |
| 550 | |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 551 | // static |
| 552 | int EmbedderTest::WriteBlockCallback(FPDF_FILEWRITE* pFileWrite, |
| 553 | const void* data, |
| 554 | unsigned long size) { |
| 555 | EmbedderTest* pThis = static_cast<EmbedderTest*>(pFileWrite); |
Henrique Nakashima | 7c2e8a3 | 2018-06-06 19:17:34 +0000 | [diff] [blame] | 556 | |
Lei Zhang | 0729be2 | 2018-02-05 21:13:51 +0000 | [diff] [blame] | 557 | pThis->data_string_.append(static_cast<const char*>(data), size); |
Henrique Nakashima | 7c2e8a3 | 2018-06-06 19:17:34 +0000 | [diff] [blame] | 558 | |
| 559 | if (pThis->filestream_.is_open()) |
| 560 | pThis->filestream_.write(static_cast<const char*>(data), size); |
| 561 | |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 562 | return 1; |
| 563 | } |
| 564 | |
| 565 | // static |
| 566 | int EmbedderTest::GetBlockFromString(void* param, |
| 567 | unsigned long pos, |
| 568 | unsigned char* buf, |
| 569 | unsigned long size) { |
| 570 | std::string* new_file = static_cast<std::string*>(param); |
Lei Zhang | cef91f1 | 2019-01-08 21:32:51 +0000 | [diff] [blame] | 571 | if (!new_file || pos + size < pos) { |
| 572 | NOTREACHED(); |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 573 | return 0; |
Lei Zhang | cef91f1 | 2019-01-08 21:32:51 +0000 | [diff] [blame] | 574 | } |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 575 | |
Lei Zhang | cef91f1 | 2019-01-08 21:32:51 +0000 | [diff] [blame] | 576 | if (pos + size > new_file->size()) { |
| 577 | NOTREACHED(); |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 578 | return 0; |
Lei Zhang | cef91f1 | 2019-01-08 21:32:51 +0000 | [diff] [blame] | 579 | } |
Nicolas Pena | 3ff5400 | 2017-07-05 11:55:35 -0400 | [diff] [blame] | 580 | |
| 581 | memcpy(buf, new_file->data() + pos, size); |
| 582 | return 1; |
| 583 | } |
Lei Zhang | 75c8171 | 2018-02-08 17:22:39 +0000 | [diff] [blame] | 584 | |
Lei Zhang | 9f72c45 | 2018-02-08 21:49:54 +0000 | [diff] [blame] | 585 | // static |
| 586 | int EmbedderTest::GetPageNumberForPage(const PageNumberToHandleMap& page_map, |
| 587 | FPDF_PAGE page) { |
| 588 | for (const auto& it : page_map) { |
Lei Zhang | 75c8171 | 2018-02-08 17:22:39 +0000 | [diff] [blame] | 589 | if (it.second == page) { |
| 590 | int page_number = it.first; |
| 591 | ASSERT(page_number >= 0); |
| 592 | return page_number; |
| 593 | } |
| 594 | } |
| 595 | return -1; |
| 596 | } |
Lei Zhang | 9f72c45 | 2018-02-08 21:49:54 +0000 | [diff] [blame] | 597 | |
| 598 | int EmbedderTest::GetPageNumberForLoadedPage(FPDF_PAGE page) const { |
| 599 | return GetPageNumberForPage(page_map_, page); |
| 600 | } |
| 601 | |
| 602 | int EmbedderTest::GetPageNumberForSavedPage(FPDF_PAGE page) const { |
| 603 | return GetPageNumberForPage(saved_page_map_, page); |
| 604 | } |
Henrique Nakashima | 7c2e8a3 | 2018-06-06 19:17:34 +0000 | [diff] [blame] | 605 | |
| 606 | void EmbedderTest::OpenPDFFileForWrite(const char* filename) { |
| 607 | filestream_.open(filename, std::ios_base::binary); |
| 608 | } |
| 609 | |
| 610 | void EmbedderTest::ClosePDFFileForWrite() { |
| 611 | filestream_.close(); |
| 612 | } |