1 // Copyright 2017 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include <cwchar>
6 #include <memory>
7 #include <string>
8 #include <vector>
9
10 #include "core/fxcrt/fx_system.h"
11 #include "public/fpdf_annot.h"
12 #include "public/fpdf_edit.h"
13 #include "public/fpdfview.h"
14 #include "testing/embedder_test.h"
15 #include "testing/gmock/include/gmock/gmock-matchers.h"
16 #include "testing/gtest/include/gtest/gtest.h"
17
18 static constexpr char kContentsKey[] = "Contents";
19
20 class FPDFAnnotEmbeddertest : public EmbedderTest {};
21
BufferToWString(const std::vector<char> & buf)22 std::wstring BufferToWString(const std::vector<char>& buf) {
23 return GetPlatformWString(reinterpret_cast<FPDF_WIDESTRING>(buf.data()));
24 }
25
BufferToString(const std::vector<char> & buf)26 std::string BufferToString(const std::vector<char>& buf) {
27 return GetPlatformString(reinterpret_cast<FPDF_WIDESTRING>(buf.data()));
28 }
29
TEST_F(FPDFAnnotEmbeddertest,RenderAnnotWithOnlyRolloverAP)30 TEST_F(FPDFAnnotEmbeddertest, RenderAnnotWithOnlyRolloverAP) {
31 // Open a file with one annotation and load its first page.
32 ASSERT_TRUE(OpenDocument("annotation_highlight_rollover_ap.pdf"));
33 FPDF_PAGE page = FPDF_LoadPage(document(), 0);
34 ASSERT_TRUE(page);
35
36 // This annotation has a malformed appearance stream, which does not have its
37 // normal appearance defined, only its rollover appearance. In this case, its
38 // normal appearance should be generated, allowing the highlight annotation to
39 // still display.
40 FPDF_BITMAP bitmap = RenderPageWithFlags(page, form_handle(), FPDF_ANNOT);
41 CompareBitmap(bitmap, 612, 792, "dc98f06da047bd8aabfa99562d2cbd1e");
42 FPDFBitmap_Destroy(bitmap);
43
44 UnloadPage(page);
45 }
46
TEST_F(FPDFAnnotEmbeddertest,ExtractHighlightLongContent)47 TEST_F(FPDFAnnotEmbeddertest, ExtractHighlightLongContent) {
48 // Open a file with one annotation and load its first page.
49 ASSERT_TRUE(OpenDocument("annotation_highlight_long_content.pdf"));
50 FPDF_PAGE page = FPDF_LoadPage(document(), 0);
51 ASSERT_TRUE(page);
52
53 // Check that there is a total of 1 annotation on its first page.
54 EXPECT_EQ(1, FPDFPage_GetAnnotCount(page));
55
56 // Check that the annotation is of type "highlight".
57 FPDF_ANNOTATION annot = FPDFPage_GetAnnot(page, 0);
58 ASSERT_TRUE(annot);
59 EXPECT_EQ(FPDF_ANNOT_HIGHLIGHT, FPDFAnnot_GetSubtype(annot));
60
61 // Check that the annotation color is yellow.
62 unsigned int R;
63 unsigned int G;
64 unsigned int B;
65 unsigned int A;
66 EXPECT_TRUE(
67 FPDFAnnot_GetColor(annot, FPDFANNOT_COLORTYPE_Color, &R, &G, &B, &A));
68 EXPECT_EQ(255u, R);
69 EXPECT_EQ(255u, G);
70 EXPECT_EQ(0u, B);
71 EXPECT_EQ(255u, A);
72
73 // Check that the author is correct.
74 static constexpr char kAuthorKey[] = "T";
75 EXPECT_EQ(FPDF_OBJECT_STRING, FPDFAnnot_GetValueType(annot, kAuthorKey));
76 unsigned long len = FPDFAnnot_GetStringValue(annot, kAuthorKey, nullptr, 0);
77 std::vector<char> buf(len);
78 EXPECT_EQ(28u, FPDFAnnot_GetStringValue(annot, kAuthorKey, buf.data(), len));
79 EXPECT_STREQ(L"Jae Hyun Park", BufferToWString(buf).c_str());
80
81 // Check that the content is correct.
82 EXPECT_EQ(FPDF_OBJECT_STRING, FPDFAnnot_GetValueType(annot, kContentsKey));
83 len = FPDFAnnot_GetStringValue(annot, kContentsKey, nullptr, 0);
84 buf.clear();
85 buf.resize(len);
86 EXPECT_EQ(2690u,
87 FPDFAnnot_GetStringValue(annot, kContentsKey, buf.data(), len));
88 const wchar_t contents[] =
89 L"This is a note for that highlight annotation. Very long highlight "
90 "annotation. Long long long Long long longLong long longLong long "
91 "longLong long longLong long longLong long longLong long longLong long "
92 "longLong long longLong long longLong long longLong long longLong long "
93 "longLong long longLong long longLong long longLong long longLong long "
94 "longLong long longLong long longLong long longLong long longLong long "
95 "longLong long longLong long longLong long longLong long longLong long "
96 "longLong long longLong long longLong long longLong long longLong long "
97 "longLong long longLong long longLong long longLong long longLong long "
98 "longLong long longLong long longLong long longLong long longLong long "
99 "longLong long longLong long longLong long longLong long longLong long "
100 "longLong long longLong long longLong long longLong long longLong long "
101 "longLong long longLong long longLong long longLong long longLong long "
102 "longLong long longLong long longLong long longLong long longLong long "
103 "longLong long longLong long longLong long longLong long longLong long "
104 "longLong long longLong long longLong long longLong long longLong long "
105 "longLong long longLong long longLong long longLong long longLong long "
106 "longLong long longLong long longLong long longLong long longLong long "
107 "longLong long longLong long longLong long longLong long longLong long "
108 "longLong long long. END";
109 EXPECT_STREQ(contents, BufferToWString(buf).c_str());
110
111 // Check that the quadpoints are correct.
112 FS_QUADPOINTSF quadpoints;
113 ASSERT_TRUE(FPDFAnnot_GetAttachmentPoints(annot, &quadpoints));
114 EXPECT_EQ(115.802643f, quadpoints.x1);
115 EXPECT_EQ(718.913940f, quadpoints.y1);
116 EXPECT_EQ(157.211182f, quadpoints.x4);
117 EXPECT_EQ(706.264465f, quadpoints.y4);
118
119 FPDFPage_CloseAnnot(annot);
120 UnloadPage(page);
121 }
122
TEST_F(FPDFAnnotEmbeddertest,ExtractInkMultiple)123 TEST_F(FPDFAnnotEmbeddertest, ExtractInkMultiple) {
124 // Open a file with three annotations and load its first page.
125 ASSERT_TRUE(OpenDocument("annotation_ink_multiple.pdf"));
126 FPDF_PAGE page = FPDF_LoadPage(document(), 0);
127 ASSERT_TRUE(page);
128
129 // Check that there is a total of 3 annotation on its first page.
130 EXPECT_EQ(3, FPDFPage_GetAnnotCount(page));
131
132 // Check that the third annotation is of type "ink".
133 FPDF_ANNOTATION annot = FPDFPage_GetAnnot(page, 2);
134 ASSERT_TRUE(annot);
135 EXPECT_EQ(FPDF_ANNOT_INK, FPDFAnnot_GetSubtype(annot));
136
137 // Check that the annotation color is blue with opacity.
138 unsigned int R;
139 unsigned int G;
140 unsigned int B;
141 unsigned int A;
142 EXPECT_TRUE(
143 FPDFAnnot_GetColor(annot, FPDFANNOT_COLORTYPE_Color, &R, &G, &B, &A));
144 EXPECT_EQ(0u, R);
145 EXPECT_EQ(0u, G);
146 EXPECT_EQ(255u, B);
147 EXPECT_EQ(76u, A);
148
149 // Check that there is no content.
150 EXPECT_EQ(2u, FPDFAnnot_GetStringValue(annot, kContentsKey, nullptr, 0));
151
152 // Check that the rectange coordinates are correct.
153 // Note that upon rendering, the rectangle coordinates will be adjusted.
154 FS_RECTF rect;
155 ASSERT_TRUE(FPDFAnnot_GetRect(annot, &rect));
156 EXPECT_EQ(351.820404f, rect.left);
157 EXPECT_EQ(583.830688f, rect.bottom);
158 EXPECT_EQ(475.336090f, rect.right);
159 EXPECT_EQ(681.535034f, rect.top);
160
161 FPDFPage_CloseAnnot(annot);
162 UnloadPage(page);
163 }
164
TEST_F(FPDFAnnotEmbeddertest,AddIllegalSubtypeAnnotation)165 TEST_F(FPDFAnnotEmbeddertest, AddIllegalSubtypeAnnotation) {
166 // Open a file with one annotation and load its first page.
167 ASSERT_TRUE(OpenDocument("annotation_highlight_long_content.pdf"));
168 FPDF_PAGE page = FPDF_LoadPage(document(), 0);
169 ASSERT_TRUE(page);
170
171 // Add an annotation with an illegal subtype.
172 ASSERT_FALSE(FPDFPage_CreateAnnot(page, -1));
173
174 UnloadPage(page);
175 }
176
TEST_F(FPDFAnnotEmbeddertest,AddFirstTextAnnotation)177 TEST_F(FPDFAnnotEmbeddertest, AddFirstTextAnnotation) {
178 // Open a file with no annotation and load its first page.
179 ASSERT_TRUE(OpenDocument("hello_world.pdf"));
180 FPDF_PAGE page = FPDF_LoadPage(document(), 0);
181 ASSERT_TRUE(page);
182 EXPECT_EQ(0, FPDFPage_GetAnnotCount(page));
183
184 // Add a text annotation to the page.
185 FPDF_ANNOTATION annot = FPDFPage_CreateAnnot(page, FPDF_ANNOT_TEXT);
186 ASSERT_TRUE(annot);
187
188 // Check that there is now 1 annotations on this page.
189 EXPECT_EQ(1, FPDFPage_GetAnnotCount(page));
190
191 // Check that the subtype of the annotation is correct.
192 EXPECT_EQ(FPDF_ANNOT_TEXT, FPDFAnnot_GetSubtype(annot));
193 FPDFPage_CloseAnnot(annot);
194
195 annot = FPDFPage_GetAnnot(page, 0);
196 ASSERT_TRUE(annot);
197 EXPECT_EQ(FPDF_ANNOT_TEXT, FPDFAnnot_GetSubtype(annot));
198
199 // Set the color of the annotation.
200 ASSERT_TRUE(
201 FPDFAnnot_SetColor(annot, FPDFANNOT_COLORTYPE_Color, 51, 102, 153, 204));
202 // Check that the color has been set correctly.
203 unsigned int R;
204 unsigned int G;
205 unsigned int B;
206 unsigned int A;
207 EXPECT_TRUE(
208 FPDFAnnot_GetColor(annot, FPDFANNOT_COLORTYPE_Color, &R, &G, &B, &A));
209 EXPECT_EQ(51u, R);
210 EXPECT_EQ(102u, G);
211 EXPECT_EQ(153u, B);
212 EXPECT_EQ(204u, A);
213
214 // Change the color of the annotation.
215 ASSERT_TRUE(
216 FPDFAnnot_SetColor(annot, FPDFANNOT_COLORTYPE_Color, 204, 153, 102, 51));
217 // Check that the color has been set correctly.
218 EXPECT_TRUE(
219 FPDFAnnot_GetColor(annot, FPDFANNOT_COLORTYPE_Color, &R, &G, &B, &A));
220 EXPECT_EQ(204u, R);
221 EXPECT_EQ(153u, G);
222 EXPECT_EQ(102u, B);
223 EXPECT_EQ(51u, A);
224
225 // Set the annotation rectangle.
226 FS_RECTF rect;
227 ASSERT_TRUE(FPDFAnnot_GetRect(annot, &rect));
228 EXPECT_EQ(0.f, rect.left);
229 EXPECT_EQ(0.f, rect.right);
230 rect.left = 35;
231 rect.bottom = 150;
232 rect.right = 53;
233 rect.top = 165;
234 ASSERT_TRUE(FPDFAnnot_SetRect(annot, &rect));
235 // Check that the annotation rectangle has been set correctly.
236 ASSERT_TRUE(FPDFAnnot_GetRect(annot, &rect));
237 EXPECT_EQ(35.f, rect.left);
238 EXPECT_EQ(150.f, rect.bottom);
239 EXPECT_EQ(53.f, rect.right);
240 EXPECT_EQ(165.f, rect.top);
241
242 // Set the content of the annotation.
243 static constexpr wchar_t contents[] = L"Hello! This is a customized content.";
244 std::unique_ptr<unsigned short, pdfium::FreeDeleter> text =
245 GetFPDFWideString(contents);
246 ASSERT_TRUE(FPDFAnnot_SetStringValue(annot, kContentsKey, text.get()));
247 // Check that the content has been set correctly.
248 unsigned long len = FPDFAnnot_GetStringValue(annot, kContentsKey, nullptr, 0);
249 std::vector<char> buf(len);
250 EXPECT_EQ(74u,
251 FPDFAnnot_GetStringValue(annot, kContentsKey, buf.data(), len));
252 EXPECT_STREQ(contents, BufferToWString(buf).c_str());
253
254 FPDFPage_CloseAnnot(annot);
255 UnloadPage(page);
256 }
257
TEST_F(FPDFAnnotEmbeddertest,AddAndSaveUnderlineAnnotation)258 TEST_F(FPDFAnnotEmbeddertest, AddAndSaveUnderlineAnnotation) {
259 // Open a file with one annotation and load its first page.
260 ASSERT_TRUE(OpenDocument("annotation_highlight_long_content.pdf"));
261 FPDF_PAGE page = FPDF_LoadPage(document(), 0);
262 ASSERT_TRUE(page);
263
264 // Check that there is a total of one annotation on its first page, and verify
265 // its quadpoints.
266 EXPECT_EQ(1, FPDFPage_GetAnnotCount(page));
267 FPDF_ANNOTATION annot = FPDFPage_GetAnnot(page, 0);
268 ASSERT_TRUE(annot);
269 FS_QUADPOINTSF quadpoints;
270 ASSERT_TRUE(FPDFAnnot_GetAttachmentPoints(annot, &quadpoints));
271 EXPECT_EQ(115.802643f, quadpoints.x1);
272 EXPECT_EQ(718.913940f, quadpoints.y1);
273 EXPECT_EQ(157.211182f, quadpoints.x4);
274 EXPECT_EQ(706.264465f, quadpoints.y4);
275 FPDFPage_CloseAnnot(annot);
276
277 // Add an underline annotation to the page and set its quadpoints.
278 annot = FPDFPage_CreateAnnot(page, FPDF_ANNOT_UNDERLINE);
279 ASSERT_TRUE(annot);
280 quadpoints.x1 = 140.802643f;
281 quadpoints.x3 = 140.802643f;
282 ASSERT_TRUE(FPDFAnnot_SetAttachmentPoints(annot, &quadpoints));
283 FPDFPage_CloseAnnot(annot);
284
285 // Save the document, closing the page and document.
286 EXPECT_TRUE(FPDF_SaveAsCopy(document(), this, 0));
287 FPDF_ClosePage(page);
288
289 // Open the saved document.
290 const char md5[] = "dba153419f67b7c0c0e3d22d3e8910d5";
291
292 OpenSavedDocument();
293 page = LoadSavedPage(0);
294 VerifySavedRendering(page, 612, 792, md5);
295
296 // Check that the saved document has 2 annotations on the first page
297 EXPECT_EQ(2, FPDFPage_GetAnnotCount(page));
298
299 // Check that the second annotation is an underline annotation and verify
300 // its quadpoints.
301 FPDF_ANNOTATION new_annot = FPDFPage_GetAnnot(page, 1);
302 ASSERT_TRUE(new_annot);
303 EXPECT_EQ(FPDF_ANNOT_UNDERLINE, FPDFAnnot_GetSubtype(new_annot));
304 FS_QUADPOINTSF new_quadpoints;
305 ASSERT_TRUE(FPDFAnnot_GetAttachmentPoints(new_annot, &new_quadpoints));
306 EXPECT_NEAR(quadpoints.x1, new_quadpoints.x1, 0.001f);
307 EXPECT_NEAR(quadpoints.y1, new_quadpoints.y1, 0.001f);
308 EXPECT_NEAR(quadpoints.x4, new_quadpoints.x4, 0.001f);
309 EXPECT_NEAR(quadpoints.y4, new_quadpoints.y4, 0.001f);
310
311 FPDFPage_CloseAnnot(new_annot);
312
313 CloseSavedPage(page);
314 CloseSavedDocument();
315 }
316
TEST_F(FPDFAnnotEmbeddertest,ModifyRectQuadpointsWithAP)317 TEST_F(FPDFAnnotEmbeddertest, ModifyRectQuadpointsWithAP) {
318 #if _FX_PLATFORM_ == _FX_PLATFORM_APPLE_
319 const char md5_original[] = "63af8432fab95a67cdebb7cd0e514941";
320 const char md5_modified_highlight[] = "aec26075011349dec9bace891856b5f2";
321 const char md5_modified_square[] = "057f57a32be95975775e5ec513fdcb56";
322 #elif _FX_PLATFORM_ == _FX_PLATFORM_WINDOWS_
323 const char md5_original[] = "0e27376094f11490f74c65f3dc3a42c5";
324 const char md5_modified_highlight[] = "66f3caef3a7d488a4fa1ad37fc06310e";
325 const char md5_modified_square[] = "a456dad0bc6801ee2d6408a4394af563";
326 #else
327 const char md5_original[] = "0e27376094f11490f74c65f3dc3a42c5";
328 const char md5_modified_highlight[] = "66f3caef3a7d488a4fa1ad37fc06310e";
329 const char md5_modified_square[] = "a456dad0bc6801ee2d6408a4394af563";
330 #endif
331
332 // Open a file with four annotations and load its first page.
333 ASSERT_TRUE(OpenDocument("annotation_highlight_square_with_ap.pdf"));
334 FPDF_PAGE page = FPDF_LoadPage(document(), 0);
335 ASSERT_TRUE(page);
336 EXPECT_EQ(4, FPDFPage_GetAnnotCount(page));
337
338 // Check that the original file renders correctly.
339 FPDF_BITMAP bitmap = RenderPageWithFlags(page, form_handle_, FPDF_ANNOT);
340 CompareBitmap(bitmap, 612, 792, md5_original);
341 FPDFBitmap_Destroy(bitmap);
342
343 // Retrieve the highlight annotation which has its AP stream already defined.
344 FPDF_ANNOTATION annot = FPDFPage_GetAnnot(page, 0);
345 ASSERT_TRUE(annot);
346 EXPECT_EQ(FPDF_ANNOT_HIGHLIGHT, FPDFAnnot_GetSubtype(annot));
347
348 // Check that color cannot be set when an AP stream is defined already.
349 EXPECT_FALSE(
350 FPDFAnnot_SetColor(annot, FPDFANNOT_COLORTYPE_Color, 51, 102, 153, 204));
351
352 // Verify its attachment points.
353 FS_QUADPOINTSF quadpoints;
354 ASSERT_TRUE(FPDFAnnot_GetAttachmentPoints(annot, &quadpoints));
355 EXPECT_NEAR(72.0000f, quadpoints.x1, 0.001f);
356 EXPECT_NEAR(720.792f, quadpoints.y1, 0.001f);
357 EXPECT_NEAR(132.055f, quadpoints.x4, 0.001f);
358 EXPECT_NEAR(704.796f, quadpoints.y4, 0.001f);
359
360 // Check that updating the attachment points would succeed.
361 quadpoints.x1 -= 50.f;
362 quadpoints.x2 -= 50.f;
363 quadpoints.x3 -= 50.f;
364 quadpoints.x4 -= 50.f;
365 ASSERT_TRUE(FPDFAnnot_SetAttachmentPoints(annot, &quadpoints));
366 FS_QUADPOINTSF new_quadpoints;
367 ASSERT_TRUE(FPDFAnnot_GetAttachmentPoints(annot, &new_quadpoints));
368 EXPECT_EQ(quadpoints.x1, new_quadpoints.x1);
369 EXPECT_EQ(quadpoints.y1, new_quadpoints.y1);
370 EXPECT_EQ(quadpoints.x4, new_quadpoints.x4);
371 EXPECT_EQ(quadpoints.y4, new_quadpoints.y4);
372
373 // Check that updating quadpoints does not change the annotation's position.
374 bitmap = RenderPageWithFlags(page, form_handle_, FPDF_ANNOT);
375 CompareBitmap(bitmap, 612, 792, md5_original);
376 FPDFBitmap_Destroy(bitmap);
377
378 // Verify its annotation rectangle.
379 FS_RECTF rect;
380 ASSERT_TRUE(FPDFAnnot_GetRect(annot, &rect));
381 EXPECT_NEAR(67.7299f, rect.left, 0.001f);
382 EXPECT_NEAR(704.296f, rect.bottom, 0.001f);
383 EXPECT_NEAR(136.325f, rect.right, 0.001f);
384 EXPECT_NEAR(721.292f, rect.top, 0.001f);
385
386 // Check that updating the rectangle would succeed.
387 rect.left -= 60.f;
388 rect.right -= 60.f;
389 ASSERT_TRUE(FPDFAnnot_SetRect(annot, &rect));
390 FS_RECTF new_rect;
391 ASSERT_TRUE(FPDFAnnot_GetRect(annot, &new_rect));
392 EXPECT_EQ(rect.right, new_rect.right);
393 FPDFPage_CloseAnnot(annot);
394
395 // Check that updating the rectangle changes the annotation's position.
396 bitmap = RenderPageWithFlags(page, form_handle_, FPDF_ANNOT);
397 CompareBitmap(bitmap, 612, 792, md5_modified_highlight);
398 FPDFBitmap_Destroy(bitmap);
399
400 // Retrieve the square annotation which has its AP stream already defined.
401 annot = FPDFPage_GetAnnot(page, 2);
402 ASSERT_TRUE(annot);
403 EXPECT_EQ(FPDF_ANNOT_SQUARE, FPDFAnnot_GetSubtype(annot));
404
405 // Check that updating the rectangle would succeed.
406 ASSERT_TRUE(FPDFAnnot_GetRect(annot, &rect));
407 rect.left += 70.f;
408 rect.right += 70.f;
409 ASSERT_TRUE(FPDFAnnot_SetRect(annot, &rect));
410 ASSERT_TRUE(FPDFAnnot_GetRect(annot, &new_rect));
411 EXPECT_EQ(rect.right, new_rect.right);
412
413 // Check that updating the rectangle changes the square annotation's position.
414 bitmap = RenderPageWithFlags(page, form_handle_, FPDF_ANNOT);
415 CompareBitmap(bitmap, 612, 792, md5_modified_square);
416 FPDFBitmap_Destroy(bitmap);
417
418 FPDFPage_CloseAnnot(annot);
419 UnloadPage(page);
420 }
421
TEST_F(FPDFAnnotEmbeddertest,RemoveAnnotation)422 TEST_F(FPDFAnnotEmbeddertest, RemoveAnnotation) {
423 // Open a file with 3 annotations on its first page.
424 ASSERT_TRUE(OpenDocument("annotation_ink_multiple.pdf"));
425 FPDF_PAGE page = FPDF_LoadPage(document(), 0);
426 ASSERT_TRUE(page);
427 EXPECT_EQ(3, FPDFPage_GetAnnotCount(page));
428
429 // Check that the annotations have the expected rectangle coordinates.
430 FPDF_ANNOTATION annot = FPDFPage_GetAnnot(page, 0);
431 FS_RECTF rect;
432 ASSERT_TRUE(FPDFAnnot_GetRect(annot, &rect));
433 EXPECT_NEAR(86.1971f, rect.left, 0.001f);
434 FPDFPage_CloseAnnot(annot);
435
436 annot = FPDFPage_GetAnnot(page, 1);
437 ASSERT_TRUE(FPDFAnnot_GetRect(annot, &rect));
438 EXPECT_NEAR(149.8127f, rect.left, 0.001f);
439 FPDFPage_CloseAnnot(annot);
440
441 annot = FPDFPage_GetAnnot(page, 2);
442 ASSERT_TRUE(FPDFAnnot_GetRect(annot, &rect));
443 EXPECT_NEAR(351.8204f, rect.left, 0.001f);
444 FPDFPage_CloseAnnot(annot);
445
446 // Check that nothing happens when attempting to remove an annotation with an
447 // out-of-bound index.
448 EXPECT_FALSE(FPDFPage_RemoveAnnot(page, 4));
449 EXPECT_FALSE(FPDFPage_RemoveAnnot(page, -1));
450 EXPECT_EQ(3, FPDFPage_GetAnnotCount(page));
451
452 // Remove the second annotation.
453 EXPECT_TRUE(FPDFPage_RemoveAnnot(page, 1));
454 EXPECT_EQ(2, FPDFPage_GetAnnotCount(page));
455 EXPECT_FALSE(FPDFPage_GetAnnot(page, 2));
456
457 // Save the document, closing the page and document.
458 EXPECT_TRUE(FPDF_SaveAsCopy(document(), this, 0));
459 FPDF_ClosePage(page);
460
461 // TODO(npm): VerifySavedRendering changes annot rect dimensions by 1??
462 // Open the saved document.
463 std::string new_file = GetString();
464 FPDF_FILEACCESS file_access;
465 memset(&file_access, 0, sizeof(file_access));
466 file_access.m_FileLen = new_file.size();
467 file_access.m_GetBlock = GetBlockFromString;
468 file_access.m_Param = &new_file;
469 FPDF_DOCUMENT new_doc = FPDF_LoadCustomDocument(&file_access, nullptr);
470 ASSERT_TRUE(new_doc);
471 FPDF_PAGE new_page = FPDF_LoadPage(new_doc, 0);
472 ASSERT_TRUE(new_page);
473
474 // Check that the saved document has 2 annotations on the first page.
475 EXPECT_EQ(2, FPDFPage_GetAnnotCount(new_page));
476
477 // Check that the remaining 2 annotations are the original 1st and 3rd ones by
478 // verifying their rectangle coordinates.
479 annot = FPDFPage_GetAnnot(new_page, 0);
480 ASSERT_TRUE(FPDFAnnot_GetRect(annot, &rect));
481 EXPECT_NEAR(86.1971f, rect.left, 0.001f);
482 FPDFPage_CloseAnnot(annot);
483
484 annot = FPDFPage_GetAnnot(new_page, 1);
485 ASSERT_TRUE(FPDFAnnot_GetRect(annot, &rect));
486 EXPECT_NEAR(351.8204f, rect.left, 0.001f);
487 FPDFPage_CloseAnnot(annot);
488 FPDF_ClosePage(new_page);
489 FPDF_CloseDocument(new_doc);
490 }
491
TEST_F(FPDFAnnotEmbeddertest,AddAndModifyPath)492 TEST_F(FPDFAnnotEmbeddertest, AddAndModifyPath) {
493 #if _FX_PLATFORM_ == _FX_PLATFORM_APPLE_
494 const char md5_original[] = "c35408717759562d1f8bf33d317483d2";
495 const char md5_modified_path[] = "cf3cea74bd46497520ff6c4d1ea228c8";
496 const char md5_two_paths[] = "e8994452fc4385337bae5522354e10ff";
497 const char md5_new_annot[] = "ee5372b31fede117fc83b9384598aa25";
498 #else
499 const char md5_original[] = "964f89bbe8911e540a465cf1a64b7f7e";
500 const char md5_modified_path[] = "3f77b88ce6048e08e636c9a03921b2e5";
501 const char md5_two_paths[] = "bffbf5ecd15862b9fe553c795400ff8e";
502 const char md5_new_annot[] = "e020534c7eeea76be537c70d6e359a40";
503 #endif
504
505 // Open a file with two annotations and load its first page.
506 ASSERT_TRUE(OpenDocument("annotation_stamp_with_ap.pdf"));
507 FPDF_PAGE page = FPDF_LoadPage(document(), 0);
508 ASSERT_TRUE(page);
509 EXPECT_EQ(2, FPDFPage_GetAnnotCount(page));
510
511 // Check that the page renders correctly.
512 FPDF_BITMAP bitmap = RenderPageWithFlags(page, form_handle_, FPDF_ANNOT);
513 CompareBitmap(bitmap, 595, 842, md5_original);
514 FPDFBitmap_Destroy(bitmap);
515
516 // Retrieve the stamp annotation which has its AP stream already defined.
517 FPDF_ANNOTATION annot = FPDFPage_GetAnnot(page, 0);
518 ASSERT_TRUE(annot);
519
520 // Check that this annotation has one path object and retrieve it.
521 EXPECT_EQ(1, FPDFAnnot_GetObjectCount(annot));
522 FPDF_PAGEOBJECT path = FPDFAnnot_GetObject(annot, 1);
523 EXPECT_FALSE(path);
524 path = FPDFAnnot_GetObject(annot, 0);
525 EXPECT_EQ(FPDF_PAGEOBJ_PATH, FPDFPageObj_GetType(path));
526 EXPECT_TRUE(path);
527
528 // Modify the color of the path object.
529 EXPECT_TRUE(FPDFPath_SetStrokeColor(path, 0, 0, 0, 255));
530 EXPECT_TRUE(FPDFAnnot_UpdateObject(annot, path));
531
532 // Check that the page with the modified annotation renders correctly.
533 bitmap = RenderPageWithFlags(page, form_handle_, FPDF_ANNOT);
534 CompareBitmap(bitmap, 595, 842, md5_modified_path);
535 FPDFBitmap_Destroy(bitmap);
536
537 // Add a second path object to the same annotation.
538 FPDF_PAGEOBJECT dot = FPDFPageObj_CreateNewPath(7, 84);
539 EXPECT_TRUE(FPDFPath_BezierTo(dot, 9, 86, 10, 87, 11, 88));
540 EXPECT_TRUE(FPDFPath_SetStrokeColor(dot, 255, 0, 0, 100));
541 EXPECT_TRUE(FPDFPath_SetStrokeWidth(dot, 14));
542 EXPECT_TRUE(FPDFPath_SetDrawMode(dot, 0, 1));
543 EXPECT_TRUE(FPDFAnnot_AppendObject(annot, dot));
544 EXPECT_EQ(2, FPDFAnnot_GetObjectCount(annot));
545
546 // Check that the page with an annotation with two paths renders correctly.
547 bitmap = RenderPageWithFlags(page, form_handle_, FPDF_ANNOT);
548 CompareBitmap(bitmap, 595, 842, md5_two_paths);
549 FPDFBitmap_Destroy(bitmap);
550
551 // Delete the newly added path object.
552 EXPECT_TRUE(FPDFAnnot_RemoveObject(annot, 1));
553 EXPECT_EQ(1, FPDFAnnot_GetObjectCount(annot));
554 FPDFPage_CloseAnnot(annot);
555
556 // Check that the page renders the same as before.
557 bitmap = RenderPageWithFlags(page, form_handle_, FPDF_ANNOT);
558 CompareBitmap(bitmap, 595, 842, md5_modified_path);
559 FPDFBitmap_Destroy(bitmap);
560
561 // Create another stamp annotation and set its annotation rectangle.
562 annot = FPDFPage_CreateAnnot(page, FPDF_ANNOT_STAMP);
563 ASSERT_TRUE(annot);
564 FS_RECTF rect;
565 rect.left = 200.f;
566 rect.bottom = 400.f;
567 rect.right = 500.f;
568 rect.top = 600.f;
569 EXPECT_TRUE(FPDFAnnot_SetRect(annot, &rect));
570
571 // Add a new path to the annotation.
572 FPDF_PAGEOBJECT check = FPDFPageObj_CreateNewPath(200, 500);
573 EXPECT_TRUE(FPDFPath_LineTo(check, 300, 400));
574 EXPECT_TRUE(FPDFPath_LineTo(check, 500, 600));
575 EXPECT_TRUE(FPDFPath_MoveTo(check, 350, 550));
576 EXPECT_TRUE(FPDFPath_LineTo(check, 450, 450));
577 EXPECT_TRUE(FPDFPath_SetStrokeColor(check, 0, 255, 255, 180));
578 EXPECT_TRUE(FPDFPath_SetStrokeWidth(check, 8.35f));
579 EXPECT_TRUE(FPDFPath_SetDrawMode(check, 0, 1));
580 EXPECT_TRUE(FPDFAnnot_AppendObject(annot, check));
581 EXPECT_EQ(1, FPDFAnnot_GetObjectCount(annot));
582
583 // Check that the annotation's bounding box came from its rectangle.
584 FS_RECTF new_rect;
585 ASSERT_TRUE(FPDFAnnot_GetRect(annot, &new_rect));
586 EXPECT_EQ(rect.left, new_rect.left);
587 EXPECT_EQ(rect.bottom, new_rect.bottom);
588 EXPECT_EQ(rect.right, new_rect.right);
589 EXPECT_EQ(rect.top, new_rect.top);
590
591 // Save the document, closing the page and document.
592 FPDFPage_CloseAnnot(annot);
593 EXPECT_TRUE(FPDF_SaveAsCopy(document(), this, 0));
594 FPDF_ClosePage(page);
595
596 // Open the saved document.
597 OpenSavedDocument();
598 page = LoadSavedPage(0);
599 VerifySavedRendering(page, 595, 842, md5_new_annot);
600
601 // Check that the document has a correct count of annotations and objects.
602 EXPECT_EQ(3, FPDFPage_GetAnnotCount(page));
603 annot = FPDFPage_GetAnnot(page, 2);
604 ASSERT_TRUE(annot);
605 EXPECT_EQ(1, FPDFAnnot_GetObjectCount(annot));
606
607 // Check that the new annotation's rectangle is as defined.
608 ASSERT_TRUE(FPDFAnnot_GetRect(annot, &new_rect));
609 EXPECT_EQ(rect.left, new_rect.left);
610 EXPECT_EQ(rect.bottom, new_rect.bottom);
611 EXPECT_EQ(rect.right, new_rect.right);
612 EXPECT_EQ(rect.top, new_rect.top);
613
614 FPDFPage_CloseAnnot(annot);
615 CloseSavedPage(page);
616 CloseSavedDocument();
617 }
618
TEST_F(FPDFAnnotEmbeddertest,ModifyAnnotationFlags)619 TEST_F(FPDFAnnotEmbeddertest, ModifyAnnotationFlags) {
620 // Open a file with an annotation and load its first page.
621 ASSERT_TRUE(OpenDocument("annotation_highlight_rollover_ap.pdf"));
622 FPDF_PAGE page = FPDF_LoadPage(document(), 0);
623 ASSERT_TRUE(page);
624
625 // Check that the page renders correctly.
626 FPDF_BITMAP bitmap = RenderPageWithFlags(page, form_handle_, FPDF_ANNOT);
627 CompareBitmap(bitmap, 612, 792, "dc98f06da047bd8aabfa99562d2cbd1e");
628 FPDFBitmap_Destroy(bitmap);
629
630 // Retrieve the annotation.
631 FPDF_ANNOTATION annot = FPDFPage_GetAnnot(page, 0);
632 ASSERT_TRUE(annot);
633
634 // Check that the original flag values are as expected.
635 int flags = FPDFAnnot_GetFlags(annot);
636 EXPECT_FALSE(flags & FPDF_ANNOT_FLAG_HIDDEN);
637 EXPECT_TRUE(flags & FPDF_ANNOT_FLAG_PRINT);
638
639 // Set the HIDDEN flag.
640 flags |= FPDF_ANNOT_FLAG_HIDDEN;
641 EXPECT_TRUE(FPDFAnnot_SetFlags(annot, flags));
642 flags = FPDFAnnot_GetFlags(annot);
643 EXPECT_TRUE(flags & FPDF_ANNOT_FLAG_HIDDEN);
644 EXPECT_TRUE(flags & FPDF_ANNOT_FLAG_PRINT);
645
646 // Check that the page renders correctly without rendering the annotation.
647 bitmap = RenderPageWithFlags(page, form_handle_, FPDF_ANNOT);
648 CompareBitmap(bitmap, 612, 792, "1940568c9ba33bac5d0b1ee9558c76b3");
649 FPDFBitmap_Destroy(bitmap);
650
651 // Unset the HIDDEN flag.
652 EXPECT_TRUE(FPDFAnnot_SetFlags(annot, FPDF_ANNOT_FLAG_NONE));
653 EXPECT_FALSE(FPDFAnnot_GetFlags(annot));
654 flags &= ~FPDF_ANNOT_FLAG_HIDDEN;
655 EXPECT_TRUE(FPDFAnnot_SetFlags(annot, flags));
656 flags = FPDFAnnot_GetFlags(annot);
657 EXPECT_FALSE(flags & FPDF_ANNOT_FLAG_HIDDEN);
658 EXPECT_TRUE(flags & FPDF_ANNOT_FLAG_PRINT);
659
660 // Check that the page renders correctly as before.
661 bitmap = RenderPageWithFlags(page, form_handle_, FPDF_ANNOT);
662 CompareBitmap(bitmap, 612, 792, "dc98f06da047bd8aabfa99562d2cbd1e");
663 FPDFBitmap_Destroy(bitmap);
664
665 FPDFPage_CloseAnnot(annot);
666 UnloadPage(page);
667 }
668
TEST_F(FPDFAnnotEmbeddertest,AddAndModifyImage)669 TEST_F(FPDFAnnotEmbeddertest, AddAndModifyImage) {
670 #if _FX_PLATFORM_ == _FX_PLATFORM_APPLE_
671 const char md5_original[] = "c35408717759562d1f8bf33d317483d2";
672 const char md5_new_image[] = "ff012f5697436dfcaec25b32d1333596";
673 const char md5_modified_image[] = "86cf8cb2755a7a2046a543e66d9c1e61";
674 #else
675 const char md5_original[] = "964f89bbe8911e540a465cf1a64b7f7e";
676 const char md5_new_image[] = "9ea8732dc9d579f68853f16892856208";
677 const char md5_modified_image[] = "74239d2a8c55c9de1dbb9cd8781895aa";
678 #endif
679
680 // Open a file with two annotations and load its first page.
681 ASSERT_TRUE(OpenDocument("annotation_stamp_with_ap.pdf"));
682 FPDF_PAGE page = FPDF_LoadPage(document(), 0);
683 ASSERT_TRUE(page);
684 EXPECT_EQ(2, FPDFPage_GetAnnotCount(page));
685
686 // Check that the page renders correctly.
687 FPDF_BITMAP bitmap = RenderPageWithFlags(page, form_handle_, FPDF_ANNOT);
688 CompareBitmap(bitmap, 595, 842, md5_original);
689 FPDFBitmap_Destroy(bitmap);
690
691 // Create a stamp annotation and set its annotation rectangle.
692 FPDF_ANNOTATION annot = FPDFPage_CreateAnnot(page, FPDF_ANNOT_STAMP);
693 ASSERT_TRUE(annot);
694 FS_RECTF rect;
695 rect.left = 200.f;
696 rect.bottom = 600.f;
697 rect.right = 400.f;
698 rect.top = 800.f;
699 EXPECT_TRUE(FPDFAnnot_SetRect(annot, &rect));
700
701 // Add a solid-color translucent image object to the new annotation.
702 constexpr int kBitmapSize = 200;
703 FPDF_BITMAP image_bitmap = FPDFBitmap_Create(kBitmapSize, kBitmapSize, 1);
704 FPDFBitmap_FillRect(image_bitmap, 0, 0, kBitmapSize, kBitmapSize, 0xeeeecccc);
705 EXPECT_EQ(kBitmapSize, FPDFBitmap_GetWidth(image_bitmap));
706 EXPECT_EQ(kBitmapSize, FPDFBitmap_GetHeight(image_bitmap));
707 FPDF_PAGEOBJECT image_object = FPDFPageObj_NewImageObj(document());
708 ASSERT_TRUE(FPDFImageObj_SetBitmap(&page, 0, image_object, image_bitmap));
709 ASSERT_TRUE(FPDFImageObj_SetMatrix(image_object, kBitmapSize, 0, 0,
710 kBitmapSize, 0, 0));
711 FPDFPageObj_Transform(image_object, 1, 0, 0, 1, 200, 600);
712 EXPECT_TRUE(FPDFAnnot_AppendObject(annot, image_object));
713 FPDFPage_CloseAnnot(annot);
714
715 // Check that the page renders correctly with the new image object.
716 bitmap = RenderPageWithFlags(page, form_handle_, FPDF_ANNOT);
717 CompareBitmap(bitmap, 595, 842, md5_new_image);
718 FPDFBitmap_Destroy(bitmap);
719
720 // Retrieve the newly added stamp annotation and its image object.
721 annot = FPDFPage_GetAnnot(page, 2);
722 ASSERT_TRUE(annot);
723 EXPECT_EQ(1, FPDFAnnot_GetObjectCount(annot));
724 image_object = FPDFAnnot_GetObject(annot, 0);
725 EXPECT_EQ(FPDF_PAGEOBJ_IMAGE, FPDFPageObj_GetType(image_object));
726
727 // Modify the image in the new annotation.
728 FPDFBitmap_FillRect(image_bitmap, 0, 0, kBitmapSize, kBitmapSize, 0xff000000);
729 ASSERT_TRUE(FPDFImageObj_SetBitmap(&page, 0, image_object, image_bitmap));
730 EXPECT_TRUE(FPDFAnnot_UpdateObject(annot, image_object));
731 FPDFPage_CloseAnnot(annot);
732
733 // Save the document, closing the page and document.
734 EXPECT_TRUE(FPDF_SaveAsCopy(document(), this, 0));
735 FPDF_ClosePage(page);
736 FPDFBitmap_Destroy(image_bitmap);
737
738 // Test that the saved document renders the modified image object correctly.
739 VerifySavedDocument(595, 842, md5_modified_image);
740 }
741
TEST_F(FPDFAnnotEmbeddertest,AddAndModifyText)742 TEST_F(FPDFAnnotEmbeddertest, AddAndModifyText) {
743 #if _FX_PLATFORM_ == _FX_PLATFORM_APPLE_
744 const char md5_original[] = "c35408717759562d1f8bf33d317483d2";
745 const char md5_new_text[] = "e5680ed048c2cfd9a1d27212cdf41286";
746 const char md5_modified_text[] = "79f5cfb0b07caaf936f65f6a7a57ce77";
747 #else
748 const char md5_original[] = "964f89bbe8911e540a465cf1a64b7f7e";
749 const char md5_new_text[] = "00b14fa2dc1c90d1b0d034e1608efef5";
750 const char md5_modified_text[] = "076c8f24a09ddc0e49f7e758edead6f0";
751 #endif
752
753 // Open a file with two annotations and load its first page.
754 ASSERT_TRUE(OpenDocument("annotation_stamp_with_ap.pdf"));
755 FPDF_PAGE page = FPDF_LoadPage(document(), 0);
756 ASSERT_TRUE(page);
757 EXPECT_EQ(2, FPDFPage_GetAnnotCount(page));
758
759 // Check that the page renders correctly.
760 FPDF_BITMAP bitmap = RenderPageWithFlags(page, form_handle_, FPDF_ANNOT);
761 CompareBitmap(bitmap, 595, 842, md5_original);
762 FPDFBitmap_Destroy(bitmap);
763
764 // Create a stamp annotation and set its annotation rectangle.
765 FPDF_ANNOTATION annot = FPDFPage_CreateAnnot(page, FPDF_ANNOT_STAMP);
766 ASSERT_TRUE(annot);
767 FS_RECTF rect;
768 rect.left = 200.f;
769 rect.bottom = 550.f;
770 rect.right = 450.f;
771 rect.top = 650.f;
772 EXPECT_TRUE(FPDFAnnot_SetRect(annot, &rect));
773
774 // Add a translucent text object to the new annotation.
775 FPDF_PAGEOBJECT text_object =
776 FPDFPageObj_NewTextObj(document(), "Arial", 12.0f);
777 EXPECT_TRUE(text_object);
778 std::unique_ptr<unsigned short, pdfium::FreeDeleter> text =
779 GetFPDFWideString(L"I'm a translucent text laying on other text.");
780 EXPECT_TRUE(FPDFText_SetText(text_object, text.get()));
781 EXPECT_TRUE(FPDFText_SetFillColor(text_object, 0, 0, 255, 150));
782 FPDFPageObj_Transform(text_object, 1, 0, 0, 1, 200, 600);
783 EXPECT_TRUE(FPDFAnnot_AppendObject(annot, text_object));
784 FPDFPage_CloseAnnot(annot);
785
786 // Check that the page renders correctly with the new text object.
787 bitmap = RenderPageWithFlags(page, form_handle_, FPDF_ANNOT);
788 CompareBitmap(bitmap, 595, 842, md5_new_text);
789 FPDFBitmap_Destroy(bitmap);
790
791 // Retrieve the newly added stamp annotation and its text object.
792 annot = FPDFPage_GetAnnot(page, 2);
793 ASSERT_TRUE(annot);
794 EXPECT_EQ(1, FPDFAnnot_GetObjectCount(annot));
795 text_object = FPDFAnnot_GetObject(annot, 0);
796 EXPECT_EQ(FPDF_PAGEOBJ_TEXT, FPDFPageObj_GetType(text_object));
797
798 // Modify the text in the new annotation.
799 std::unique_ptr<unsigned short, pdfium::FreeDeleter> new_text =
800 GetFPDFWideString(L"New text!");
801 EXPECT_TRUE(FPDFText_SetText(text_object, new_text.get()));
802 EXPECT_TRUE(FPDFAnnot_UpdateObject(annot, text_object));
803 FPDFPage_CloseAnnot(annot);
804
805 // Check that the page renders correctly with the modified text object.
806 bitmap = RenderPageWithFlags(page, form_handle_, FPDF_ANNOT);
807 CompareBitmap(bitmap, 595, 842, md5_modified_text);
808 FPDFBitmap_Destroy(bitmap);
809
810 // Remove the new annotation, and check that the page renders as before.
811 EXPECT_TRUE(FPDFPage_RemoveAnnot(page, 2));
812 bitmap = RenderPageWithFlags(page, form_handle_, FPDF_ANNOT);
813 CompareBitmap(bitmap, 595, 842, md5_original);
814 FPDFBitmap_Destroy(bitmap);
815
816 UnloadPage(page);
817 }
818
TEST_F(FPDFAnnotEmbeddertest,GetSetStringValue)819 TEST_F(FPDFAnnotEmbeddertest, GetSetStringValue) {
820 // Open a file with four annotations and load its first page.
821 ASSERT_TRUE(OpenDocument("annotation_stamp_with_ap.pdf"));
822 FPDF_PAGE page = FPDF_LoadPage(document(), 0);
823 ASSERT_TRUE(page);
824
825 // Retrieve the first annotation.
826 FPDF_ANNOTATION annot = FPDFPage_GetAnnot(page, 0);
827 ASSERT_TRUE(annot);
828
829 // Check that a non-existent key does not exist.
830 EXPECT_FALSE(FPDFAnnot_HasKey(annot, "none"));
831
832 // Check that the string value of a non-string dictionary entry is empty.
833 static constexpr char kApKey[] = "AP";
834 EXPECT_TRUE(FPDFAnnot_HasKey(annot, kApKey));
835 EXPECT_EQ(FPDF_OBJECT_REFERENCE, FPDFAnnot_GetValueType(annot, kApKey));
836 EXPECT_EQ(2u, FPDFAnnot_GetStringValue(annot, kApKey, nullptr, 0));
837
838 // Check that the string value of the hash is correct.
839 static constexpr char kHashKey[] = "AAPL:Hash";
840 EXPECT_EQ(FPDF_OBJECT_NAME, FPDFAnnot_GetValueType(annot, kHashKey));
841 unsigned long len = FPDFAnnot_GetStringValue(annot, kHashKey, nullptr, 0);
842 std::vector<char> buf(len);
843 EXPECT_EQ(66u, FPDFAnnot_GetStringValue(annot, kHashKey, buf.data(), len));
844 EXPECT_STREQ(L"395fbcb98d558681742f30683a62a2ad",
845 BufferToWString(buf).c_str());
846
847 // Check that the string value of the modified date is correct.
848 static constexpr char kDateKey[] = "M";
849 EXPECT_EQ(FPDF_OBJECT_NAME, FPDFAnnot_GetValueType(annot, kHashKey));
850 len = FPDFAnnot_GetStringValue(annot, kDateKey, nullptr, 0);
851 buf.clear();
852 buf.resize(len);
853 EXPECT_EQ(44u, FPDFAnnot_GetStringValue(annot, kDateKey, buf.data(), len));
854 EXPECT_STREQ(L"D:201706071721Z00'00'", BufferToWString(buf).c_str());
855
856 // Update the date entry for the annotation.
857 const wchar_t new_date[] = L"D:201706282359Z00'00'";
858 std::unique_ptr<unsigned short, pdfium::FreeDeleter> text =
859 GetFPDFWideString(new_date);
860 EXPECT_TRUE(FPDFAnnot_SetStringValue(annot, kDateKey, text.get()));
861
862 // Save the document, closing the page and document.
863 FPDFPage_CloseAnnot(annot);
864 EXPECT_TRUE(FPDF_SaveAsCopy(document(), this, 0));
865 FPDF_ClosePage(page);
866
867 // Open the saved annotation.
868 #if _FX_PLATFORM_ == _FX_PLATFORM_APPLE_
869 const char md5[] = "4d64e61c9c0f8c60ab3cc3234bb73b1c";
870 #else
871 const char md5[] = "c96ee1f316d7f5a1b154de9f9d467f01";
872 #endif
873 OpenSavedDocument();
874 page = LoadSavedPage(0);
875 VerifySavedRendering(page, 595, 842, md5);
876 FPDF_ANNOTATION new_annot = FPDFPage_GetAnnot(page, 0);
877
878 // Check that the string value of the modified date is the newly-set value.
879 EXPECT_EQ(FPDF_OBJECT_STRING, FPDFAnnot_GetValueType(new_annot, kDateKey));
880 len = FPDFAnnot_GetStringValue(new_annot, kDateKey, nullptr, 0);
881 buf.clear();
882 buf.resize(len);
883 EXPECT_EQ(44u,
884 FPDFAnnot_GetStringValue(new_annot, kDateKey, buf.data(), len));
885 EXPECT_STREQ(new_date, BufferToWString(buf).c_str());
886
887 FPDFPage_CloseAnnot(new_annot);
888 CloseSavedPage(page);
889 CloseSavedDocument();
890 }
891
TEST_F(FPDFAnnotEmbeddertest,GetSetAP)892 TEST_F(FPDFAnnotEmbeddertest, GetSetAP) {
893 // Open a file with four annotations and load its first page.
894 ASSERT_TRUE(OpenDocument("annotation_stamp_with_ap.pdf"));
895 FPDF_PAGE page = FPDF_LoadPage(document(), 0);
896 ASSERT_TRUE(page);
897
898 // Retrieve the first annotation.
899 FPDF_ANNOTATION annot = FPDFPage_GetAnnot(page, 0);
900 ASSERT_TRUE(annot);
901
902 // Check that the string value of an AP returns the expected length.
903 unsigned long normal_len =
904 FPDFAnnot_GetAP(annot, FPDF_ANNOT_APPEARANCEMODE_NORMAL, nullptr, 0);
905 EXPECT_EQ(73970u, normal_len);
906
907 // Check that the string value of an AP is not returned if the buffer is too
908 // small. The result buffer should be overwritten with an empty string.
909 std::vector<char> buf(normal_len - 1);
910 // Write L"z" in the buffer to verify it's not overwritten.
911 wcscpy(reinterpret_cast<wchar_t*>(buf.data()), L"z");
912 EXPECT_EQ(73970u, FPDFAnnot_GetAP(annot, FPDF_ANNOT_APPEARANCEMODE_NORMAL,
913 buf.data(), buf.size()));
914 std::string ap = BufferToString(buf);
915 EXPECT_STREQ("z", ap.c_str());
916
917 // Check that the string value of an AP is returned through a buffer that is
918 // the right size.
919 buf.clear();
920 buf.resize(normal_len);
921 EXPECT_EQ(73970u, FPDFAnnot_GetAP(annot, FPDF_ANNOT_APPEARANCEMODE_NORMAL,
922 buf.data(), buf.size()));
923 ap = BufferToString(buf);
924 EXPECT_THAT(ap, testing::StartsWith("q Q q 7.442786 w 2 J"));
925 EXPECT_THAT(ap, testing::EndsWith("c 716.5381 327.7156 l S Q Q"));
926
927 // Check that the string value of an AP is returned through a buffer that is
928 // larger than necessary.
929 buf.clear();
930 buf.resize(normal_len + 1);
931 EXPECT_EQ(73970u, FPDFAnnot_GetAP(annot, FPDF_ANNOT_APPEARANCEMODE_NORMAL,
932 buf.data(), buf.size()));
933 ap = BufferToString(buf);
934 EXPECT_THAT(ap, testing::StartsWith("q Q q 7.442786 w 2 J"));
935 EXPECT_THAT(ap, testing::EndsWith("c 716.5381 327.7156 l S Q Q"));
936
937 // Check that getting an AP for a mode that does not have an AP returns an
938 // empty string.
939 unsigned long rollover_len =
940 FPDFAnnot_GetAP(annot, FPDF_ANNOT_APPEARANCEMODE_ROLLOVER, nullptr, 0);
941 EXPECT_EQ(2u, rollover_len);
942
943 buf.clear();
944 buf.resize(1000);
945 EXPECT_EQ(2u, FPDFAnnot_GetAP(annot, FPDF_ANNOT_APPEARANCEMODE_ROLLOVER,
946 buf.data(), buf.size()));
947 EXPECT_STREQ("", BufferToString(buf).c_str());
948
949 // Check that setting the AP for an invalid appearance mode fails.
950 std::unique_ptr<unsigned short, pdfium::FreeDeleter> apText =
951 GetFPDFWideString(L"new test ap");
952 EXPECT_FALSE(FPDFAnnot_SetAP(annot, -1, apText.get()));
953 EXPECT_FALSE(
954 FPDFAnnot_SetAP(annot, FPDF_ANNOT_APPEARANCEMODE_COUNT, apText.get()));
955 EXPECT_FALSE(FPDFAnnot_SetAP(annot, FPDF_ANNOT_APPEARANCEMODE_COUNT + 1,
956 apText.get()));
957
958 // Set the AP correctly now.
959 EXPECT_TRUE(
960 FPDFAnnot_SetAP(annot, FPDF_ANNOT_APPEARANCEMODE_ROLLOVER, apText.get()));
961
962 // Check that the new annotation value is equal to the value we just set.
963 rollover_len =
964 FPDFAnnot_GetAP(annot, FPDF_ANNOT_APPEARANCEMODE_ROLLOVER, nullptr, 0);
965 EXPECT_EQ(24u, rollover_len);
966 buf.clear();
967 buf.resize(rollover_len);
968 EXPECT_EQ(24u, FPDFAnnot_GetAP(annot, FPDF_ANNOT_APPEARANCEMODE_ROLLOVER,
969 buf.data(), buf.size()));
970 EXPECT_STREQ(L"new test ap", BufferToWString(buf).c_str());
971
972 // Check that the Normal AP was not touched when the Rollover AP was set.
973 buf.clear();
974 buf.resize(normal_len);
975 EXPECT_EQ(73970u, FPDFAnnot_GetAP(annot, FPDF_ANNOT_APPEARANCEMODE_NORMAL,
976 buf.data(), buf.size()));
977 ap = BufferToString(buf);
978 EXPECT_THAT(ap, testing::StartsWith("q Q q 7.442786 w 2 J"));
979 EXPECT_THAT(ap, testing::EndsWith("c 716.5381 327.7156 l S Q Q"));
980
981 // Save the modified document, then reopen it.
982 FPDFPage_CloseAnnot(annot);
983 EXPECT_TRUE(FPDF_SaveAsCopy(document(), this, 0));
984 FPDF_ClosePage(page);
985
986 OpenSavedDocument();
987 page = LoadSavedPage(0);
988 FPDF_ANNOTATION new_annot = FPDFPage_GetAnnot(page, 0);
989
990 // Check that the new annotation value is equal to the value we set before
991 // saving.
992 rollover_len = FPDFAnnot_GetAP(new_annot, FPDF_ANNOT_APPEARANCEMODE_ROLLOVER,
993 nullptr, 0);
994 EXPECT_EQ(24u, rollover_len);
995 buf.clear();
996 buf.resize(rollover_len);
997 EXPECT_EQ(24u, FPDFAnnot_GetAP(new_annot, FPDF_ANNOT_APPEARANCEMODE_ROLLOVER,
998 buf.data(), buf.size()));
999 EXPECT_STREQ(L"new test ap", BufferToWString(buf).c_str());
1000
1001 // Close saved document.
1002 FPDFPage_CloseAnnot(new_annot);
1003 CloseSavedPage(page);
1004 CloseSavedDocument();
1005 }
1006
TEST_F(FPDFAnnotEmbeddertest,RemoveOptionalAP)1007 TEST_F(FPDFAnnotEmbeddertest, RemoveOptionalAP) {
1008 // Open a file with four annotations and load its first page.
1009 ASSERT_TRUE(OpenDocument("annotation_stamp_with_ap.pdf"));
1010 FPDF_PAGE page = FPDF_LoadPage(document(), 0);
1011 ASSERT_TRUE(page);
1012
1013 // Retrieve the first annotation.
1014 FPDF_ANNOTATION annot = FPDFPage_GetAnnot(page, 0);
1015 ASSERT_TRUE(annot);
1016
1017 // Set Down AP. Normal AP is already set.
1018 std::unique_ptr<unsigned short, pdfium::FreeDeleter> apText =
1019 GetFPDFWideString(L"new test ap");
1020 EXPECT_TRUE(
1021 FPDFAnnot_SetAP(annot, FPDF_ANNOT_APPEARANCEMODE_DOWN, apText.get()));
1022 EXPECT_EQ(73970u, FPDFAnnot_GetAP(annot, FPDF_ANNOT_APPEARANCEMODE_NORMAL,
1023 nullptr, 0));
1024 EXPECT_EQ(24u,
1025 FPDFAnnot_GetAP(annot, FPDF_ANNOT_APPEARANCEMODE_DOWN, nullptr, 0));
1026
1027 // Check that setting the Down AP to null removes the Down entry but keeps
1028 // Normal intact.
1029 EXPECT_TRUE(FPDFAnnot_SetAP(annot, FPDF_ANNOT_APPEARANCEMODE_DOWN, nullptr));
1030 EXPECT_EQ(73970u, FPDFAnnot_GetAP(annot, FPDF_ANNOT_APPEARANCEMODE_NORMAL,
1031 nullptr, 0));
1032 EXPECT_EQ(2u,
1033 FPDFAnnot_GetAP(annot, FPDF_ANNOT_APPEARANCEMODE_DOWN, nullptr, 0));
1034
1035 FPDFPage_CloseAnnot(annot);
1036 FPDF_ClosePage(page);
1037 }
1038
TEST_F(FPDFAnnotEmbeddertest,RemoveRequiredAP)1039 TEST_F(FPDFAnnotEmbeddertest, RemoveRequiredAP) {
1040 // Open a file with four annotations and load its first page.
1041 ASSERT_TRUE(OpenDocument("annotation_stamp_with_ap.pdf"));
1042 FPDF_PAGE page = FPDF_LoadPage(document(), 0);
1043 ASSERT_TRUE(page);
1044
1045 // Retrieve the first annotation.
1046 FPDF_ANNOTATION annot = FPDFPage_GetAnnot(page, 0);
1047 ASSERT_TRUE(annot);
1048
1049 // Set Down AP. Normal AP is already set.
1050 std::unique_ptr<unsigned short, pdfium::FreeDeleter> apText =
1051 GetFPDFWideString(L"new test ap");
1052 EXPECT_TRUE(
1053 FPDFAnnot_SetAP(annot, FPDF_ANNOT_APPEARANCEMODE_DOWN, apText.get()));
1054 EXPECT_EQ(73970u, FPDFAnnot_GetAP(annot, FPDF_ANNOT_APPEARANCEMODE_NORMAL,
1055 nullptr, 0));
1056 EXPECT_EQ(24u,
1057 FPDFAnnot_GetAP(annot, FPDF_ANNOT_APPEARANCEMODE_DOWN, nullptr, 0));
1058
1059 // Check that setting the Normal AP to null removes the whole AP dictionary.
1060 EXPECT_TRUE(
1061 FPDFAnnot_SetAP(annot, FPDF_ANNOT_APPEARANCEMODE_NORMAL, nullptr));
1062 EXPECT_EQ(
1063 2u, FPDFAnnot_GetAP(annot, FPDF_ANNOT_APPEARANCEMODE_NORMAL, nullptr, 0));
1064 EXPECT_EQ(2u,
1065 FPDFAnnot_GetAP(annot, FPDF_ANNOT_APPEARANCEMODE_DOWN, nullptr, 0));
1066
1067 FPDFPage_CloseAnnot(annot);
1068 FPDF_ClosePage(page);
1069 }
1070
TEST_F(FPDFAnnotEmbeddertest,ExtractLinkedAnnotations)1071 TEST_F(FPDFAnnotEmbeddertest, ExtractLinkedAnnotations) {
1072 // Open a file with annotations and load its first page.
1073 ASSERT_TRUE(OpenDocument("annotation_highlight_square_with_ap.pdf"));
1074 FPDF_PAGE page = FPDF_LoadPage(document(), 0);
1075 ASSERT_TRUE(page);
1076 EXPECT_EQ(-1, FPDFPage_GetAnnotIndex(page, nullptr));
1077
1078 // Retrieve the highlight annotation which has its popup defined.
1079 FPDF_ANNOTATION annot = FPDFPage_GetAnnot(page, 0);
1080 ASSERT_TRUE(annot);
1081 EXPECT_EQ(FPDF_ANNOT_HIGHLIGHT, FPDFAnnot_GetSubtype(annot));
1082 EXPECT_EQ(0, FPDFPage_GetAnnotIndex(page, annot));
1083 static constexpr char kPopupKey[] = "Popup";
1084 ASSERT_TRUE(FPDFAnnot_HasKey(annot, kPopupKey));
1085 ASSERT_EQ(FPDF_OBJECT_REFERENCE, FPDFAnnot_GetValueType(annot, kPopupKey));
1086
1087 // Retrieve and verify the popup of the highlight annotation.
1088 FPDF_ANNOTATION popup = FPDFAnnot_GetLinkedAnnot(annot, kPopupKey);
1089 ASSERT_TRUE(popup);
1090 EXPECT_EQ(FPDF_ANNOT_POPUP, FPDFAnnot_GetSubtype(popup));
1091 EXPECT_EQ(1, FPDFPage_GetAnnotIndex(page, popup));
1092 FS_RECTF rect;
1093 ASSERT_TRUE(FPDFAnnot_GetRect(popup, &rect));
1094 EXPECT_NEAR(612.0f, rect.left, 0.001f);
1095 EXPECT_NEAR(578.792, rect.bottom, 0.001f);
1096
1097 // Attempting to retrieve |annot|'s "IRT"-linked annotation would fail, since
1098 // "IRT" is not a key in |annot|'s dictionary.
1099 static constexpr char kIRTKey[] = "IRT";
1100 ASSERT_FALSE(FPDFAnnot_HasKey(annot, kIRTKey));
1101 EXPECT_FALSE(FPDFAnnot_GetLinkedAnnot(annot, kIRTKey));
1102
1103 // Attempting to retrieve |annot|'s parent dictionary as an annotation would
1104 // fail, since its parent is not an annotation.
1105 static constexpr char kPKey[] = "P";
1106 ASSERT_TRUE(FPDFAnnot_HasKey(annot, kPKey));
1107 EXPECT_EQ(FPDF_OBJECT_REFERENCE, FPDFAnnot_GetValueType(annot, kPKey));
1108 EXPECT_FALSE(FPDFAnnot_GetLinkedAnnot(annot, kPKey));
1109
1110 FPDFPage_CloseAnnot(popup);
1111 FPDFPage_CloseAnnot(annot);
1112 UnloadPage(page);
1113 }
1114
TEST_F(FPDFAnnotEmbeddertest,GetFormFieldFlagsTextField)1115 TEST_F(FPDFAnnotEmbeddertest, GetFormFieldFlagsTextField) {
1116 // Open file with form text fields.
1117 ASSERT_TRUE(OpenDocument("text_form_multiple.pdf"));
1118 FPDF_PAGE page = FPDF_LoadPage(document(), 0);
1119 ASSERT_TRUE(page);
1120
1121 // Retrieve the first annotation: user-editable text field.
1122 FPDF_ANNOTATION annot = FPDFPage_GetAnnot(page, 0);
1123 ASSERT_TRUE(annot);
1124
1125 // Check that the flag values are as expected.
1126 int flags = FPDFAnnot_GetFormFieldFlags(page, annot);
1127 EXPECT_FALSE(flags & FPDF_FORMFLAG_READONLY);
1128 FPDFPage_CloseAnnot(annot);
1129
1130 // Retrieve the second annotation: read-only text field.
1131 annot = FPDFPage_GetAnnot(page, 1);
1132 ASSERT_TRUE(annot);
1133
1134 // Check that the flag values are as expected.
1135 flags = FPDFAnnot_GetFormFieldFlags(page, annot);
1136 EXPECT_TRUE(flags & FPDF_FORMFLAG_READONLY);
1137 FPDFPage_CloseAnnot(annot);
1138
1139 UnloadPage(page);
1140 }
1141
TEST_F(FPDFAnnotEmbeddertest,GetFormFieldFlagsComboBox)1142 TEST_F(FPDFAnnotEmbeddertest, GetFormFieldFlagsComboBox) {
1143 // Open file with form text fields.
1144 ASSERT_TRUE(OpenDocument("combobox_form.pdf"));
1145 FPDF_PAGE page = FPDF_LoadPage(document(), 0);
1146 ASSERT_TRUE(page);
1147
1148 // Retrieve the first annotation: user-editable combobox.
1149 FPDF_ANNOTATION annot = FPDFPage_GetAnnot(page, 0);
1150 ASSERT_TRUE(annot);
1151
1152 // Check that the flag values are as expected.
1153 int flags = FPDFAnnot_GetFormFieldFlags(page, annot);
1154 EXPECT_FALSE(flags & FPDF_FORMFLAG_READONLY);
1155 EXPECT_TRUE(flags & FPDF_FORMFLAG_CHOICE_COMBO);
1156 EXPECT_TRUE(flags & FPDF_FORMFLAG_CHOICE_EDIT);
1157 FPDFPage_CloseAnnot(annot);
1158
1159 // Retrieve the second annotation: regular combobox.
1160 annot = FPDFPage_GetAnnot(page, 1);
1161 ASSERT_TRUE(annot);
1162
1163 // Check that the flag values are as expected.
1164 flags = FPDFAnnot_GetFormFieldFlags(page, annot);
1165 EXPECT_FALSE(flags & FPDF_FORMFLAG_READONLY);
1166 EXPECT_TRUE(flags & FPDF_FORMFLAG_CHOICE_COMBO);
1167 EXPECT_FALSE(flags & FPDF_FORMFLAG_CHOICE_EDIT);
1168 FPDFPage_CloseAnnot(annot);
1169
1170 // Retrieve the third annotation: read-only combobox.
1171 annot = FPDFPage_GetAnnot(page, 2);
1172 ASSERT_TRUE(annot);
1173
1174 // Check that the flag values are as expected.
1175 flags = FPDFAnnot_GetFormFieldFlags(page, annot);
1176 EXPECT_TRUE(flags & FPDF_FORMFLAG_READONLY);
1177 EXPECT_TRUE(flags & FPDF_FORMFLAG_CHOICE_COMBO);
1178 EXPECT_FALSE(flags & FPDF_FORMFLAG_CHOICE_EDIT);
1179 FPDFPage_CloseAnnot(annot);
1180
1181 UnloadPage(page);
1182 }
1183
TEST_F(FPDFAnnotEmbeddertest,GetFormAnnotNull)1184 TEST_F(FPDFAnnotEmbeddertest, GetFormAnnotNull) {
1185 // Open file with form text fields.
1186 EXPECT_TRUE(OpenDocument("text_form.pdf"));
1187 FPDF_PAGE page = LoadPage(0);
1188 ASSERT_TRUE(page);
1189
1190 // Attempt to get an annotation where no annotation exists on page.
1191 FPDF_ANNOTATION annot =
1192 FPDFAnnot_GetFormFieldAtPoint(form_handle(), page, 0, 0);
1193 EXPECT_FALSE(annot);
1194
1195 UnloadPage(page);
1196 }
1197
TEST_F(FPDFAnnotEmbeddertest,GetFormAnnotAndCheckFlagsTextField)1198 TEST_F(FPDFAnnotEmbeddertest, GetFormAnnotAndCheckFlagsTextField) {
1199 // Open file with form text fields.
1200 EXPECT_TRUE(OpenDocument("text_form_multiple.pdf"));
1201 FPDF_PAGE page = LoadPage(0);
1202 ASSERT_TRUE(page);
1203
1204 // Retrieve user-editable text field annotation.
1205 FPDF_ANNOTATION annot =
1206 FPDFAnnot_GetFormFieldAtPoint(form_handle(), page, 105, 118);
1207 ASSERT_TRUE(annot);
1208
1209 // Check that interactive form annotation flag values are as expected.
1210 int flags = FPDFAnnot_GetFormFieldFlags(page, annot);
1211 EXPECT_FALSE(flags & FPDF_FORMFLAG_READONLY);
1212 FPDFPage_CloseAnnot(annot);
1213
1214 // Retrieve read-only text field annotation.
1215 annot = FPDFAnnot_GetFormFieldAtPoint(form_handle(), page, 105, 202);
1216 ASSERT_TRUE(annot);
1217
1218 // Check that interactive form annotation flag values are as expected.
1219 flags = FPDFAnnot_GetFormFieldFlags(page, annot);
1220 EXPECT_TRUE(flags & FPDF_FORMFLAG_READONLY);
1221 FPDFPage_CloseAnnot(annot);
1222
1223 UnloadPage(page);
1224 }
1225
TEST_F(FPDFAnnotEmbeddertest,GetFormAnnotAndCheckFlagsComboBox)1226 TEST_F(FPDFAnnotEmbeddertest, GetFormAnnotAndCheckFlagsComboBox) {
1227 // Open file with form comboboxes.
1228 EXPECT_TRUE(OpenDocument("combobox_form.pdf"));
1229 FPDF_PAGE page = LoadPage(0);
1230 ASSERT_TRUE(page);
1231
1232 // Retrieve user-editable combobox annotation.
1233 FPDF_ANNOTATION annot =
1234 FPDFAnnot_GetFormFieldAtPoint(form_handle(), page, 102, 63);
1235 ASSERT_TRUE(annot);
1236
1237 // Check that interactive form annotation flag values are as expected.
1238 int flags = FPDFAnnot_GetFormFieldFlags(page, annot);
1239 EXPECT_FALSE(flags & FPDF_FORMFLAG_READONLY);
1240 EXPECT_TRUE(flags & FPDF_FORMFLAG_CHOICE_COMBO);
1241 EXPECT_TRUE(flags & FPDF_FORMFLAG_CHOICE_EDIT);
1242 FPDFPage_CloseAnnot(annot);
1243
1244 // Retrieve regular combobox annotation.
1245 annot = FPDFAnnot_GetFormFieldAtPoint(form_handle(), page, 102, 113);
1246 ASSERT_TRUE(annot);
1247
1248 // Check that interactive form annotation flag values are as expected.
1249 flags = FPDFAnnot_GetFormFieldFlags(page, annot);
1250 EXPECT_FALSE(flags & FPDF_FORMFLAG_READONLY);
1251 EXPECT_TRUE(flags & FPDF_FORMFLAG_CHOICE_COMBO);
1252 EXPECT_FALSE(flags & FPDF_FORMFLAG_CHOICE_EDIT);
1253 FPDFPage_CloseAnnot(annot);
1254
1255 // Retrieve read-only combobox annotation.
1256 annot = FPDFAnnot_GetFormFieldAtPoint(form_handle(), page, 102, 213);
1257 ASSERT_TRUE(annot);
1258
1259 // Check that interactive form annotation flag values are as expected.
1260 flags = FPDFAnnot_GetFormFieldFlags(page, annot);
1261 EXPECT_TRUE(flags & FPDF_FORMFLAG_READONLY);
1262 EXPECT_TRUE(flags & FPDF_FORMFLAG_CHOICE_COMBO);
1263 EXPECT_FALSE(flags & FPDF_FORMFLAG_CHOICE_EDIT);
1264 FPDFPage_CloseAnnot(annot);
1265
1266 UnloadPage(page);
1267 }
1268