blob: 2387d28da61eaa6ac65cfeb64c91d44734049e83 [file] [edit]
// Copyright 2026 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_watermark_overlayer.h"
#include "base/check_op.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/numerics/ranges.h"
#include "pdf/pdfium/pdfium_api_wrappers.h"
#include "pdf/pdfium/pdfium_engine.h"
#include "pdf/pdfium/pdfium_mem_buffer_file_write.h"
#include "pdf/pdfium/pdfium_unsupported_features.h"
#include "third_party/pdfium/public/fpdf_edit.h"
#include "third_party/pdfium/public/fpdf_formfill.h"
#include "third_party/pdfium/public/fpdf_ppo.h"
#include "third_party/pdfium/public/fpdf_save.h"
#include "third_party/pdfium/public/fpdfview.h"
namespace chrome_pdf {
namespace {
// Tolerance in points when comparing page dimensions. Skia's SkPDFDocument
// backend rounds page dimensions to the nearest integer device pixel at 72 DPI
// (introducing up to a 0.5pt difference). Use a 1.0pt tolerance to accommodate
// this rounding while still catching wrong-sized or misoriented pages.
constexpr float kDimensionTolerance = 1.0f;
ScopedUnsupportedFeature CreateScopedUnsupportedFeature() {
// Avoid loading V8 if the PDF contains embedded JavaScript.
return ScopedUnsupportedFeature(ScopedUnsupportedFeature::kNoEngine);
}
} // namespace
// static
std::unique_ptr<PdfiumWatermarkOverlayer> PdfiumWatermarkOverlayer::Create(
base::span<const uint8_t> pdf_buffer) {
auto overlayer = base::WrapUnique(new PdfiumWatermarkOverlayer());
if (!overlayer->Initialize(pdf_buffer)) {
return nullptr;
}
return overlayer;
}
PdfiumWatermarkOverlayer::ScopedSdkInitializer::ScopedSdkInitializer() {
InitializeSDK(/*enable_v8=*/false, /*enable_xfa=*/false, /*use_skia=*/false,
FontMappingMode::kNoMapping);
}
PdfiumWatermarkOverlayer::ScopedSdkInitializer::~ScopedSdkInitializer() {
ShutdownSDK();
}
PdfiumWatermarkOverlayer::PdfiumWatermarkOverlayer() = default;
PdfiumWatermarkOverlayer::~PdfiumWatermarkOverlayer() = default;
bool PdfiumWatermarkOverlayer::Initialize(
base::span<const uint8_t> pdf_buffer) {
ScopedUnsupportedFeature scoped_unsupported_feature =
CreateScopedUnsupportedFeature();
base_doc_ = LoadPdfData(pdf_buffer);
if (!base_doc_) {
return false;
}
CHECK_EQ(FPDF_GetFormType(base_doc_.get()), FORMTYPE_NONE);
page_count_ = FPDF_GetPageCount(base_doc_.get());
return page_count_ > 0;
}
std::vector<gfx::SizeF> PdfiumWatermarkOverlayer::GetPageSizes() const {
ScopedUnsupportedFeature scoped_unsupported_feature =
CreateScopedUnsupportedFeature();
std::vector<gfx::SizeF> page_sizes;
page_sizes.reserve(page_count_);
for (int i = 0; i < page_count_; ++i) {
FS_SIZEF size;
if (!FPDF_GetPageSizeByIndexF(base_doc_.get(), i, &size) ||
size.width <= 0.0f || size.height <= 0.0f) {
LOG(ERROR) << "Failed to get page size for page " << i;
return {};
}
page_sizes.emplace_back(size.width, size.height);
}
return page_sizes;
}
std::vector<uint8_t> PdfiumWatermarkOverlayer::OverlayPages(
base::span<const uint8_t> overlay_pdf_buffer) {
ScopedUnsupportedFeature scoped_unsupported_feature =
CreateScopedUnsupportedFeature();
ScopedFPDFDocument overlay_doc = LoadPdfData(overlay_pdf_buffer);
if (!overlay_doc) {
LOG(ERROR) << "OverlayPages: Failed to load overlay PDF document.";
return {};
}
int overlay_page_count = FPDF_GetPageCount(overlay_doc.get());
if (page_count_ != overlay_page_count) {
LOG(ERROR) << "OverlayPages: Mismatched page counts. Base page count: "
<< page_count_
<< ", Overlay page count: " << overlay_page_count;
return {};
}
for (int i = 0; i < page_count_; ++i) {
FS_SIZEF base_size;
FS_SIZEF overlay_size;
if (!FPDF_GetPageSizeByIndexF(base_doc_.get(), i, &base_size) ||
!FPDF_GetPageSizeByIndexF(overlay_doc.get(), i, &overlay_size) ||
!base::IsApproximatelyEqual(base_size.width, overlay_size.width,
kDimensionTolerance) ||
!base::IsApproximatelyEqual(base_size.height, overlay_size.height,
kDimensionTolerance)) {
LOG(ERROR) << "OverlayPages: Mismatched page dimensions for page " << i;
return {};
}
ScopedFPDFPage base_page(FPDF_LoadPage(base_doc_.get(), i));
if (!base_page) {
LOG(ERROR) << "OverlayPages: Failed to load page " << i
<< " from base PDF.";
return {};
}
FPDF_XOBJECT xobject =
FPDF_NewXObjectFromPage(base_doc_.get(), overlay_doc.get(), i);
if (!xobject) {
LOG(ERROR) << "OverlayPages: Failed to create xobject from overlay page "
<< i;
return {};
}
ScopedFPDFPageObject form_obj(FPDF_NewFormObjectFromXObject(xobject));
FPDF_CloseXObject(xobject);
if (!form_obj) {
LOG(ERROR) << "OverlayPages: Failed to create form object for page " << i;
return {};
}
if (!FPDFPage_InsertObject(base_page.get(), form_obj.release())) {
LOG(ERROR) << "OverlayPages: Failed to insert form object for page " << i;
return {};
}
if (!FPDFPage_GenerateContent(base_page.get())) {
LOG(ERROR) << "OverlayPages: Failed to generate content for page " << i;
return {};
}
}
PDFiumMemBufferFileWrite file_write;
if (!FPDF_SaveAsCopy(base_doc_.get(), &file_write, 0)) {
LOG(ERROR) << "OverlayPages: Failed to serialize modified PDF.";
return {};
}
return file_write.TakeBuffer();
}
} // namespace chrome_pdf