blob: 8f8eb23e82c7d380a5e4c2805b63c3d6a38f19d7 [file] [edit]
// 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