| // Copyright 2024 The Chromium Authors | |
| // Use of this source code is governed by a BSD-style license that can be | |
| // found in the LICENSE file. | |
| #include "pdf/pdfium/pdfium_ink_writer.h" | |
| #include <array> | |
| #include <memory> | |
| #include <optional> | |
| #include <string_view> | |
| #include <utility> | |
| #include <vector> | |
| #include "base/files/file_path.h" | |
| #include "base/time/time.h" | |
| #include "pdf/pdf_ink_brush.h" | |
| #include "pdf/pdfium/pdfium_api_wrappers.h" | |
| #include "pdf/pdfium/pdfium_engine.h" | |
| #include "pdf/pdfium/pdfium_ink_reader.h" | |
| #include "pdf/pdfium/pdfium_page.h" | |
| #include "pdf/pdfium/pdfium_test_base.h" | |
| #include "pdf/test/pdf_ink_test_helpers.h" | |
| #include "pdf/test/test_client.h" | |
| #include "pdf/test/test_helpers.h" | |
| #include "third_party/ink/src/ink/geometry/affine_transform.h" | |
| #include "third_party/ink/src/ink/geometry/intersects.h" | |
| #include "third_party/ink/src/ink/geometry/partitioned_mesh.h" | |
| #include "third_party/ink/src/ink/geometry/point.h" | |
| #include "third_party/ink/src/ink/strokes/input/stroke_input.h" | |
| #include "third_party/ink/src/ink/strokes/input/stroke_input_batch.h" | |
| #include "third_party/ink/src/ink/strokes/stroke.h" | |
| #include "third_party/pdfium/public/fpdf_edit.h" | |
| #include "third_party/pdfium/public/fpdfview.h" | |
| #include "ui/gfx/geometry/point_f.h" | |
| #include "ui/gfx/geometry/size.h" | |
| namespace chrome_pdf { | |
| namespace { | |
| constexpr auto kBasicInputs = std::to_array<PdfInkInputData>({ | |
| {{126.122f, 52.852f}, base::Seconds(0.0f)}, | |
| {{127.102f, 52.2398f}, base::Seconds(0.031467f)}, | |
| {{130.041f, 50.7704f}, base::Seconds(0.07934f)}, | |
| {{132.49f, 50.2806f}, base::Seconds(0.11225f)}, | |
| {{133.714f, 49.7908f}, base::Seconds(0.143326f)}, | |
| {{134.204f, 49.7908f}, base::Seconds(0.187606f)}, | |
| {{135.184f, 49.7908f}, base::Seconds(0.20368f)}, | |
| {{136.408f, 50.5255f}, base::Seconds(0.232364f)}, | |
| {{137.143f, 52.2398f}, base::Seconds(0.261512f)}, | |
| {{137.878f, 54.4439f}, base::Seconds(0.290249f)}, | |
| {{137.878f, 55.9133f}, base::Seconds(0.316557f)}, | |
| {{137.878f, 57.3827f}, base::Seconds(0.341756f)}, | |
| {{137.143f, 58.852f}, base::Seconds(0.37093f)}, | |
| {{136.408f, 59.8316f}, base::Seconds(0.39636f)}, | |
| {{135.184f, 60.3214f}, base::Seconds(0.421022f)}, | |
| {{134.694f, 60.3214f}, base::Seconds(0.450936f)}, | |
| {{133.714f, 60.8112f}, base::Seconds(0.475798f)}, | |
| {{132.245f, 60.8112f}, base::Seconds(0.501089f)}, | |
| {{130.531f, 61.0561f}, base::Seconds(0.525835f)}, | |
| {{130.041f, 61.301f}, base::Seconds(0.551003f)}, | |
| {{129.306f, 61.301f}, base::Seconds(0.575968f)}, | |
| {{128.816f, 61.301f}, base::Seconds(0.618475f)}, | |
| {{128.327f, 61.0561f}, base::Seconds(0.634891f)}, | |
| {{127.347f, 60.0765f}, base::Seconds(0.668079f)}, | |
| {{126.612f, 59.0969f}, base::Seconds(0.692914f)}, | |
| {{126.122f, 58.3622f}, base::Seconds(0.718358f)}, | |
| {{125.878f, 57.1378f}, base::Seconds(0.743602f)}, | |
| {{125.388f, 55.9133f}, base::Seconds(0.768555f)}, | |
| {{125.143f, 54.6888f}, base::Seconds(0.794048f)}, | |
| {{125.143f, 54.199f}, base::Seconds(0.819457f)}, | |
| {{125.143f, 53.7092f}, base::Seconds(0.851297f)}, | |
| {{125.388f, 53.4643f}, base::Seconds(0.901739f)}, | |
| {{125.633f, 53.2194f}, base::Seconds(0.951174f)}, | |
| {{125.878f, 53.2194f}, base::Seconds(0.985401f)}, | |
| }); | |
| std::unique_ptr<PdfInkBrush> CreateTestBrush() { | |
| return std::make_unique<PdfInkBrush>(PdfInkBrush::Type::kPen, SK_ColorRED, | |
| /*size=*/4.0f); | |
| } | |
| } // namespace | |
| using PDFiumInkWriterTest = PDFiumTestBase; | |
| TEST_P(PDFiumInkWriterTest, BasicWriteAndRead) { | |
| TestClient client(/*use_skia_renderer=*/GetParam()); | |
| std::unique_ptr<PDFiumEngine> engine = | |
| InitializeEngine(&client, FILE_PATH_LITERAL("blank.pdf")); | |
| ASSERT_TRUE(engine); | |
| PDFiumPage& pdfium_page = GetPDFiumPage(*engine, 0); | |
| FPDF_PAGE page = pdfium_page.GetPage(); | |
| ASSERT_TRUE(page); | |
| auto brush = CreateTestBrush(); | |
| std::optional<ink::StrokeInputBatch> inputs = | |
| CreateInkInputBatch(kBasicInputs); | |
| ASSERT_TRUE(inputs.has_value()); | |
| ink::Stroke stroke(brush->ink_brush(), inputs.value()); | |
| auto results = WriteStrokeToPage(page, stroke); | |
| EXPECT_EQ(1u, results.size()); | |
| ASSERT_TRUE(FPDFPage_GenerateContent(page)); | |
| std::vector<uint8_t> saved_pdf_data = engine->GetSaveData(); | |
| ASSERT_TRUE(!saved_pdf_data.empty()); | |
| CheckPdfRendering( | |
| saved_pdf_data, | |
| /*page_index=*/0, gfx::Size(200, 200), | |
| GetInkTestDataFilePath(FILE_PATH_LITERAL("ink_writer_basic.png"))); | |
| // Load `saved_pdf_data` into `saved_engine` and get a handle to the one and | |
| // only page. | |
| TestClient saved_client(/*use_skia_renderer=*/GetParam()); | |
| std::unique_ptr<PDFiumEngine> saved_engine = | |
| InitializeEngineFromData(&saved_client, std::move(saved_pdf_data)); | |
| ASSERT_TRUE(saved_engine); | |
| ASSERT_EQ(saved_engine->GetNumberOfPages(), 1); | |
| PDFiumPage& saved_pdfium_page = GetPDFiumPage(*saved_engine, 0); | |
| FPDF_PAGE saved_page = saved_pdfium_page.GetPage(); | |
| ASSERT_TRUE(saved_page); | |
| // Complete the round trip and read the written PDF data back into memory as | |
| // an ink::PartitionedMesh. ReadV2InkPathsFromPageAsModeledShapes() is known | |
| // to be good because its unit tests reads from a real, known to be good Ink | |
| // PDF. | |
| std::vector<ReadV2InkPathResult> saved_results = | |
| ReadV2InkPathsFromPageAsModeledShapes(saved_page); | |
| ASSERT_EQ(saved_results.size(), 1u); | |
| // Take the original and saved shapes and compare them. Note that | |
| // `saved_shape` does not have an outline, so just check they behave the same | |
| // way with ink::Intersects(). | |
| const auto& shape = stroke.GetShape(); | |
| const auto& saved_shape = saved_results[0].shape; | |
| // All point values below are in canonical coordinates, so no transform is | |
| // necessary. | |
| const auto no_transform = ink::AffineTransform::Identity(); | |
| // Points at the corners do not intersect. | |
| EXPECT_FALSE(ink::Intersects(ink::Point{0, 0}, shape, no_transform)); | |
| EXPECT_FALSE(ink::Intersects(ink::Point{0, 0}, saved_shape, no_transform)); | |
| EXPECT_FALSE(ink::Intersects(ink::Point{266, 266}, shape, no_transform)); | |
| EXPECT_FALSE( | |
| ink::Intersects(ink::Point{266, 266}, saved_shape, no_transform)); | |
| // Points close to `shape`, that still do not intersect. | |
| EXPECT_FALSE(ink::Intersects(ink::Point{139, 51}, shape, no_transform)); | |
| EXPECT_FALSE(ink::Intersects(ink::Point{139, 51}, saved_shape, no_transform)); | |
| EXPECT_FALSE(ink::Intersects(ink::Point{127, 63}, shape, no_transform)); | |
| EXPECT_FALSE(ink::Intersects(ink::Point{127, 63}, saved_shape, no_transform)); | |
| // Points that do intersect. | |
| EXPECT_TRUE(ink::Intersects(ink::Point{139, 53}, shape, no_transform)); | |
| EXPECT_TRUE(ink::Intersects(ink::Point{139, 53}, saved_shape, no_transform)); | |
| EXPECT_TRUE(ink::Intersects(ink::Point{128, 63}, shape, no_transform)); | |
| EXPECT_TRUE(ink::Intersects(ink::Point{128, 63}, saved_shape, no_transform)); | |
| } | |
| TEST_P(PDFiumInkWriterTest, WriteToCroppedPage) { | |
| TestClient client(/*use_skia_renderer=*/GetParam()); | |
| std::unique_ptr<PDFiumEngine> engine = | |
| InitializeEngine(&client, FILE_PATH_LITERAL("hello_world_cropped.pdf")); | |
| ASSERT_TRUE(engine); | |
| PDFiumPage& pdfium_page = GetPDFiumPage(*engine, 0); | |
| FPDF_PAGE page = pdfium_page.GetPage(); | |
| ASSERT_TRUE(page); | |
| auto brush = CreateTestBrush(); | |
| // `kBasicInputs` values range from (125.143, 49.7908) to (137.878, 61.301) | |
| // in screen coordinates. Converted to points, (125.143, 49.7908) becomes | |
| // (93.75, 37). So the upper-left corner of the captured stroke should be | |
| // roughly starting at that location, minus a little bit for implementation | |
| // details of how Ink draws strokes. | |
| std::optional<ink::StrokeInputBatch> inputs = | |
| CreateInkInputBatch(kBasicInputs); | |
| ASSERT_TRUE(inputs.has_value()); | |
| ink::Stroke stroke(brush->ink_brush(), inputs.value()); | |
| auto results = WriteStrokeToPage(page, stroke); | |
| EXPECT_EQ(results.size(), 1u); | |
| ASSERT_TRUE(FPDFPage_GenerateContent(page)); | |
| std::vector<uint8_t> saved_pdf_data = engine->GetSaveData(); | |
| ASSERT_TRUE(!saved_pdf_data.empty()); | |
| base::FilePath expectation_path = GetInkTestDataFilePath( | |
| GetTestDataPathWithPlatformSuffix("ink_writer_cropped.png")); | |
| CheckFuzzyPdfRendering(saved_pdf_data, /*page_index=*/0, gfx::Size(135, 90), | |
| expectation_path); | |
| // Load `saved_pdf_data` into `saved_engine` and get a handle to the one and | |
| // only page. | |
| TestClient saved_client(/*use_skia_renderer=*/GetParam()); | |
| std::unique_ptr<PDFiumEngine> saved_engine = | |
| InitializeEngineFromData(&saved_client, std::move(saved_pdf_data)); | |
| ASSERT_TRUE(saved_engine); | |
| ASSERT_EQ(saved_engine->GetNumberOfPages(), 1); | |
| PDFiumPage& saved_pdfium_page = GetPDFiumPage(*saved_engine, 0); | |
| FPDF_PAGE saved_page = saved_pdfium_page.GetPage(); | |
| ASSERT_TRUE(saved_page); | |
| // Complete the round trip and read the written PDF data back into memory as | |
| // an ink::PartitionedMesh. ReadV2InkPathsFromPageAsModeledShapes() is known | |
| // to be good because its unit tests reads from a real, known to be good Ink | |
| // PDF. | |
| std::vector<ReadV2InkPathResult> saved_results = | |
| ReadV2InkPathsFromPageAsModeledShapes(saved_page); | |
| ASSERT_EQ(saved_results.size(), 1u); | |
| const std::optional<PdfRect> maybe_bounds = | |
| GetPageObjectBounds(saved_results[0].page_object); | |
| ASSERT_TRUE(maybe_bounds.has_value()); | |
| const auto& bounds = maybe_bounds.value(); | |
| // While the cropped image shows the stroke on the visible page at an X coord | |
| // of 92, that object's position in the PDF page is relative to the MediaBox, | |
| // not the CropBox. So its bounding box should be 55 points to the right of | |
| // that. | |
| EXPECT_NEAR(147.39908f, bounds.left(), 0.001f); | |
| EXPECT_NEAR(49.52425f, bounds.bottom(), 0.001f); | |
| EXPECT_NEAR(159.8443f, bounds.right(), 0.001f); | |
| EXPECT_NEAR(61.155205f, bounds.top(), 0.001f); | |
| } | |
| TEST_P(PDFiumInkWriterTest, EmptyStroke) { | |
| TestClient client(/*use_skia_renderer=*/GetParam()); | |
| std::unique_ptr<PDFiumEngine> engine = | |
| InitializeEngine(&client, FILE_PATH_LITERAL("blank.pdf")); | |
| ASSERT_TRUE(engine); | |
| PDFiumPage& pdfium_page = GetPDFiumPage(*engine, 0); | |
| FPDF_PAGE page = pdfium_page.GetPage(); | |
| ASSERT_TRUE(page); | |
| auto brush = CreateTestBrush(); | |
| ink::Stroke unused_stroke(brush->ink_brush()); | |
| auto results = WriteStrokeToPage(page, unused_stroke); | |
| EXPECT_TRUE(results.empty()); | |
| } | |
| TEST_P(PDFiumInkWriterTest, NoPage) { | |
| TestClient client(/*use_skia_renderer=*/GetParam()); | |
| std::unique_ptr<PDFiumEngine> engine = | |
| InitializeEngine(&client, FILE_PATH_LITERAL("blank.pdf")); | |
| ASSERT_TRUE(engine); | |
| PDFiumPage& pdfium_page = GetPDFiumPage(*engine, 0); | |
| FPDF_PAGE page = pdfium_page.GetPage(); | |
| ASSERT_TRUE(page); | |
| auto brush = CreateTestBrush(); | |
| ink::Stroke unused_stroke(brush->ink_brush()); | |
| auto results = WriteStrokeToPage(/*page=*/nullptr, unused_stroke); | |
| EXPECT_TRUE(results.empty()); | |
| } | |
| // Don't be concerned about any slight rendering differences in AGG vs. Skia, | |
| // covering one of these is sufficient for checking how data is written out. | |
| INSTANTIATE_TEST_SUITE_P(All, PDFiumInkWriterTest, testing::Values(false)); | |
| } // namespace chrome_pdf |