blob: bb2c7e63c632033e816aab68727a954b74ff54c6 [file] [log] [blame]
// Copyright 2019 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_page.h"
#include <utility>
#include <vector>
#include <optional>
#include "base/check.h"
#include "base/files/file_path.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/test_discardable_memory_allocator.h"
#include "build/build_config.h"
#include "pdf/accessibility_structs.h"
#include "pdf/pdfium/pdfium_engine.h"
#include "pdf/pdfium/pdfium_test_base.h"
#include "pdf/test/test_client.h"
#include "pdf/test/test_helpers.h"
#include "pdf/ui/thumbnail.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "third_party/pdfium/public/fpdf_formfill.h"
#include "third_party/skia/include/core/SkImage.h"
#include "third_party/skia/include/core/SkImageInfo.h"
#include "third_party/skia/include/core/SkPixmap.h"
#include "third_party/skia/include/core/SkRefCnt.h"
#include "ui/accessibility/accessibility_features.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/rect_f.h"
#include "ui/gfx/geometry/size_f.h"
#include "ui/gfx/geometry/skia_conversions.h"
#include "ui/gfx/geometry/test/geometry_util.h"
#include "ui/gfx/range/range.h"
namespace chrome_pdf {
namespace {
TEST(PDFiumPageHelperTest, ToPDFiumRotation) {
EXPECT_EQ(ToPDFiumRotation(PageOrientation::kOriginal), 0);
EXPECT_EQ(ToPDFiumRotation(PageOrientation::kClockwise90), 1);
EXPECT_EQ(ToPDFiumRotation(PageOrientation::kClockwise180), 2);
EXPECT_EQ(ToPDFiumRotation(PageOrientation::kClockwise270), 3);
}
TEST(PDFiumPageHelperTest, ScopedUnloadPreventer) {
// Should not DCHECK in its dtor due to ScopedUnloadPreventer usage.
PDFiumPage page1(/*engine=*/nullptr, 1);
PDFiumPage page2(/*engine=*/nullptr, 2);
PDFiumPage::ScopedUnloadPreventer prevent_unload1(&page1);
PDFiumPage::ScopedUnloadPreventer prevent_unload2(&page2);
PDFiumPage::ScopedUnloadPreventer prevent_unload3(prevent_unload2);
PDFiumPage::ScopedUnloadPreventer prevent_unload4(&page2);
prevent_unload2 = prevent_unload1;
prevent_unload1 = prevent_unload2;
prevent_unload1 = prevent_unload4;
prevent_unload4 = prevent_unload1;
prevent_unload3 = prevent_unload4;
}
void CompareTextRuns(const AccessibilityTextRunInfo& expected_text_run,
const AccessibilityTextRunInfo& actual_text_run) {
EXPECT_EQ(expected_text_run.len, actual_text_run.len);
EXPECT_RECTF_EQ(expected_text_run.bounds, actual_text_run.bounds);
EXPECT_EQ(expected_text_run.direction, actual_text_run.direction);
const AccessibilityTextStyleInfo& expected_style = expected_text_run.style;
const AccessibilityTextStyleInfo& actual_style = actual_text_run.style;
EXPECT_EQ(expected_style.font_name, actual_style.font_name);
EXPECT_EQ(expected_style.font_weight, actual_style.font_weight);
EXPECT_EQ(expected_style.render_mode, actual_style.render_mode);
EXPECT_FLOAT_EQ(expected_style.font_size, actual_style.font_size);
EXPECT_EQ(expected_style.fill_color, actual_style.fill_color);
EXPECT_EQ(expected_style.stroke_color, actual_style.stroke_color);
EXPECT_EQ(expected_style.is_italic, actual_style.is_italic);
EXPECT_EQ(expected_style.is_bold, actual_style.is_bold);
}
template <typename T>
void PopulateTextObjects(const std::vector<gfx::Range>& ranges,
std::vector<T>* text_objects) {
text_objects->resize(ranges.size());
for (size_t i = 0; i < ranges.size(); ++i) {
(*text_objects)[i].start_char_index = ranges[i].start();
(*text_objects)[i].char_count = ranges[i].end() - ranges[i].start();
}
}
// Returns the page size for a `PDFiumPage`. The caller must make sure that
// `pdfium_page` is available.
gfx::SizeF GetPageSizeHelper(PDFiumPage& pdfium_page) {
FPDF_PAGE page = pdfium_page.GetPage();
return gfx::SizeF(FPDF_GetPageWidthF(page), FPDF_GetPageHeightF(page));
}
base::FilePath GetThumbnailTestData(const std::string& expectation_file_prefix,
size_t page_index,
float device_pixel_ratio,
bool use_skia) {
std::string file_dir = base::StringPrintf("%.1fx", device_pixel_ratio);
std::string file_name = base::StringPrintf(
"%s_expected%s.pdf.%zu.png", expectation_file_prefix.c_str(),
use_skia ? "_skia" : "", page_index);
return base::FilePath(FILE_PATH_LITERAL("thumbnail"))
.AppendASCII(file_dir)
.AppendASCII(file_name);
}
} // namespace
using PDFiumPageTest = PDFiumTestBase;
TEST_P(PDFiumPageTest, Constructor) {
PDFiumPage page(/*engine=*/nullptr, 2);
EXPECT_EQ(page.index(), 2);
EXPECT_TRUE(page.rect().IsEmpty());
EXPECT_FALSE(page.available());
}
TEST_P(PDFiumPageTest, IsCharInPageBounds) {
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("hello_world_cropped.pdf"));
ASSERT_TRUE(engine);
PDFiumPage page(engine.get(), 0);
EXPECT_FALSE(page.available());
EXPECT_EQ(page.GetCharCount(), 0);
page.MarkAvailable();
EXPECT_TRUE(page.available());
EXPECT_EQ(page.GetCharCount(), 30);
const gfx::RectF page_bounds = page.GetCroppedRect();
EXPECT_EQ(page_bounds, gfx::RectF(193.33333f, 129.33333f));
EXPECT_EQ(page.GetCharAtIndex(0), 'H');
EXPECT_FALSE(page.IsCharInPageBounds(0, page_bounds));
EXPECT_EQ(page.GetCharAtIndex(12), '!');
EXPECT_TRUE(page.IsCharInPageBounds(12, page_bounds));
EXPECT_EQ(page.GetCharAtIndex(13), '\r');
EXPECT_TRUE(page.IsCharInPageBounds(13, page_bounds));
EXPECT_EQ(page.GetCharAtIndex(14), '\n');
EXPECT_TRUE(page.IsCharInPageBounds(14, page_bounds));
EXPECT_EQ(page.GetCharAtIndex(15), 'G');
EXPECT_FALSE(page.IsCharInPageBounds(15, page_bounds));
EXPECT_EQ(page.GetCharAtIndex(29), '!');
EXPECT_FALSE(page.IsCharInPageBounds(29, page_bounds));
}
TEST_P(PDFiumPageTest, GetBoundingBoxRotatedMultipage) {
// Check getting bounding box for multiple rotated pages.
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("rotated_multi_page.pdf"));
ASSERT_TRUE(engine);
ASSERT_EQ(4, engine->GetNumberOfPages());
// Rotation 0 degrees clockwise.
{
PDFiumPage& page = GetPDFiumPageForTest(*engine, 0);
const gfx::RectF bounding_box = page.GetBoundingBox();
EXPECT_FLOAT_EQ(0.0f, bounding_box.x());
EXPECT_FLOAT_EQ(266.66669f, bounding_box.y());
EXPECT_FLOAT_EQ(133.33334f, bounding_box.width());
EXPECT_FLOAT_EQ(400.0f, bounding_box.height());
}
// Rotation 90 degrees clockwise.
{
PDFiumPage& page = GetPDFiumPageForTest(*engine, 1);
const gfx::RectF bounding_box = page.GetBoundingBox();
EXPECT_FLOAT_EQ(266.66669f, bounding_box.x());
EXPECT_FLOAT_EQ(666.66669f, bounding_box.y());
EXPECT_FLOAT_EQ(400.0f, bounding_box.width());
EXPECT_FLOAT_EQ(133.33334f, bounding_box.height());
}
// Rotation 180 degrees clockwise.
{
PDFiumPage& page = GetPDFiumPageForTest(*engine, 2);
const gfx::RectF bounding_box = page.GetBoundingBox();
EXPECT_FLOAT_EQ(666.66669f, bounding_box.x());
EXPECT_FLOAT_EQ(933.33337f, bounding_box.y());
EXPECT_FLOAT_EQ(133.33334f, bounding_box.width());
EXPECT_FLOAT_EQ(400.0f, bounding_box.height());
}
// Rotation 270 degrees clockwise.
{
PDFiumPage& page = GetPDFiumPageForTest(*engine, 3);
const gfx::RectF bounding_box = page.GetBoundingBox();
EXPECT_FLOAT_EQ(933.33337f, bounding_box.x());
EXPECT_FLOAT_EQ(0.0f, bounding_box.y());
EXPECT_FLOAT_EQ(400.0f, bounding_box.width());
EXPECT_FLOAT_EQ(133.33334f, bounding_box.height());
}
}
TEST_P(PDFiumPageTest, GetBoundingBoxAnnotations) {
// Check getting the bounding box for annotations.
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("annots.pdf"));
ASSERT_TRUE(engine);
ASSERT_EQ(1, engine->GetNumberOfPages());
PDFiumPage& page = GetPDFiumPageForTest(*engine, 0);
const gfx::RectF bounding_box = page.GetBoundingBox();
EXPECT_FLOAT_EQ(92.0f, bounding_box.x());
EXPECT_FLOAT_EQ(450.66669, bounding_box.y());
EXPECT_FLOAT_EQ(201.33334f, bounding_box.width());
EXPECT_FLOAT_EQ(469.33334f, bounding_box.height());
}
TEST_P(PDFiumPageTest, GetBoundingBoxBlankPage) {
// Check getting the bounding box for a blank page. The bounding box should be
// the crop box scaled to page pixels.
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("blank.pdf"));
ASSERT_TRUE(engine);
ASSERT_EQ(1, engine->GetNumberOfPages());
// The crop box is 200x200 in points.
PDFiumPage& page = GetPDFiumPageForTest(*engine, 0);
const gfx::RectF bounding_box = page.GetBoundingBox();
EXPECT_FLOAT_EQ(0.0f, bounding_box.x());
EXPECT_FLOAT_EQ(0.0f, bounding_box.y());
EXPECT_FLOAT_EQ(266.66669f, bounding_box.width());
EXPECT_FLOAT_EQ(266.66669f, bounding_box.height());
}
TEST_P(PDFiumPageTest, GetBoundingBoxCropped) {
// Check getting the bounding box for a page with a crop box different than
// the media box.
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("landscape_rectangles.pdf"));
ASSERT_TRUE(engine);
ASSERT_EQ(1, engine->GetNumberOfPages());
PDFiumPage& page = GetPDFiumPageForTest(*engine, 0);
const gfx::RectF bounding_box = page.GetBoundingBox();
EXPECT_FLOAT_EQ(0.0f, bounding_box.x());
EXPECT_FLOAT_EQ(0.0f, bounding_box.y());
EXPECT_FLOAT_EQ(800.0f, bounding_box.width());
EXPECT_FLOAT_EQ(533.33337f, bounding_box.height());
}
TEST_P(PDFiumPageTest, GetBoundingBoxRotatedMultipageCropped) {
// Check getting the bounding box for a multiple rotated pages with a crop
// box.
TestClient client;
std::unique_ptr<PDFiumEngine> engine = InitializeEngine(
&client, FILE_PATH_LITERAL("rotated_multi_page_cropped.pdf"));
ASSERT_TRUE(engine);
ASSERT_EQ(4, engine->GetNumberOfPages());
// Rotation 0 degrees clockwise.
{
PDFiumPage& page = GetPDFiumPageForTest(*engine, 0);
const gfx::RectF bounding_box = page.GetBoundingBox();
EXPECT_FLOAT_EQ(0.0f, bounding_box.x());
EXPECT_FLOAT_EQ(133.33334f, bounding_box.y());
EXPECT_FLOAT_EQ(66.666672f, bounding_box.width());
EXPECT_FLOAT_EQ(400.0f, bounding_box.height());
}
// Rotation 90 degrees clockwise.
{
PDFiumPage& page = GetPDFiumPageForTest(*engine, 1);
const gfx::RectF bounding_box = page.GetBoundingBox();
EXPECT_FLOAT_EQ(133.33334f, bounding_box.x());
EXPECT_FLOAT_EQ(400.0f, bounding_box.y());
EXPECT_FLOAT_EQ(400.0f, bounding_box.width());
EXPECT_FLOAT_EQ(66.666672f, bounding_box.height());
}
// Rotation 180 degrees clockwise.
{
PDFiumPage& page = GetPDFiumPageForTest(*engine, 2);
const gfx::RectF bounding_box = page.GetBoundingBox();
EXPECT_FLOAT_EQ(400.0f, bounding_box.x());
EXPECT_FLOAT_EQ(133.33334f, bounding_box.y());
EXPECT_FLOAT_EQ(66.666672f, bounding_box.width());
EXPECT_FLOAT_EQ(400.0f, bounding_box.height());
}
// Rotation 270 degrees clockwise.
{
PDFiumPage& page = GetPDFiumPageForTest(*engine, 3);
const gfx::RectF bounding_box = page.GetBoundingBox();
EXPECT_FLOAT_EQ(133.33334f, bounding_box.x());
EXPECT_FLOAT_EQ(0.0f, bounding_box.y());
EXPECT_FLOAT_EQ(400.0f, bounding_box.width());
EXPECT_FLOAT_EQ(66.666672f, bounding_box.height());
}
}
INSTANTIATE_TEST_SUITE_P(All, PDFiumPageTest, testing::Bool());
class PDFiumPageLinkTest : public PDFiumTestBase {
public:
PDFiumPageLinkTest() = default;
PDFiumPageLinkTest(const PDFiumPageLinkTest&) = delete;
PDFiumPageLinkTest& operator=(const PDFiumPageLinkTest&) = delete;
~PDFiumPageLinkTest() override = default;
const std::vector<PDFiumPage::Link>& GetLinks(PDFiumEngine& engine,
int page_index) {
PDFiumPage& page = GetPDFiumPageForTest(engine, page_index);
page.CalculateLinks();
return page.links_;
}
};
TEST_P(PDFiumPageLinkTest, LinkGeneration) {
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("weblinks.pdf"));
ASSERT_TRUE(engine);
ASSERT_EQ(1, engine->GetNumberOfPages());
bool using_test_fonts = UsingTestFonts();
const std::vector<PDFiumPage::Link>& links = GetLinks(*engine, 0);
ASSERT_EQ(3u, links.size());
const PDFiumPage::Link& link = links[0];
EXPECT_EQ("http://yahoo.com", link.target.url);
EXPECT_EQ(7, link.start_char_index);
EXPECT_EQ(16, link.char_count);
ASSERT_EQ(1u, link.bounding_rects.size());
if (using_test_fonts) {
EXPECT_EQ(gfx::Rect(75, 192, 110, 15), link.bounding_rects[0]);
} else {
EXPECT_EQ(gfx::Rect(75, 191, 110, 16), link.bounding_rects[0]);
}
const PDFiumPage::Link& second_link = links[1];
EXPECT_EQ("http://bing.com", second_link.target.url);
EXPECT_EQ(52, second_link.start_char_index);
EXPECT_EQ(15, second_link.char_count);
ASSERT_EQ(1u, second_link.bounding_rects.size());
if (using_test_fonts) {
EXPECT_EQ(gfx::Rect(131, 120, 138, 22), second_link.bounding_rects[0]);
} else {
EXPECT_EQ(gfx::Rect(131, 121, 138, 20), second_link.bounding_rects[0]);
}
const PDFiumPage::Link& third_link = links[2];
EXPECT_EQ("http://google.com", third_link.target.url);
EXPECT_EQ(92, third_link.start_char_index);
EXPECT_EQ(17, third_link.char_count);
ASSERT_EQ(1u, third_link.bounding_rects.size());
EXPECT_EQ(gfx::Rect(82, 67, 161, 21), third_link.bounding_rects[0]);
}
TEST_P(PDFiumPageLinkTest, AnnotLinkGeneration) {
struct ExpectedLink {
int32_t start_char_index;
int32_t char_count;
std::vector<gfx::Rect> bounding_rects;
std::string url;
int page;
float y_in_pixels;
};
static ExpectedLink expected_links[] = {
{144, 38, {{99, 436, 236, 13}}, "https://pdfium.googlesource.com/pdfium"},
{27, 38, {{112, 215, 617, 28}}, "", 1, 89.333336},
{65, 27, {{93, 334, 174, 21}}, "https://www.adobe.com"},
{253,
18,
{{242, 455, 1, 18}, {242, 472, 1, 15}},
"https://cs.chromium.org"},
{-1, 0, {{58, 926, 28, 27}}, "https://www.google.com"}};
if (UsingTestFonts()) {
expected_links[0].bounding_rects[0] = {99, 436, 236, 14};
}
static constexpr size_t kExpectedLinkCount = std::size(expected_links);
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("link_annots.pdf"));
ASSERT_TRUE(engine);
ASSERT_EQ(2, engine->GetNumberOfPages());
const std::vector<PDFiumPage::Link>& links = GetLinks(*engine, 0);
ASSERT_EQ(kExpectedLinkCount, links.size());
for (size_t i = 0; i < kExpectedLinkCount; ++i) {
const PDFiumPage::Link& actual_current_link = links[i];
const ExpectedLink& expected_current_link = expected_links[i];
EXPECT_EQ(expected_current_link.start_char_index,
actual_current_link.start_char_index);
EXPECT_EQ(expected_current_link.char_count, actual_current_link.char_count);
size_t bounds_size = actual_current_link.bounding_rects.size();
ASSERT_EQ(expected_current_link.bounding_rects.size(), bounds_size);
for (size_t bounds_index = 0; bounds_index < bounds_size; ++bounds_index) {
EXPECT_EQ(expected_current_link.bounding_rects[bounds_index],
actual_current_link.bounding_rects[bounds_index]);
}
EXPECT_EQ(expected_current_link.url, actual_current_link.target.url);
if (actual_current_link.target.url.empty()) {
EXPECT_EQ(expected_current_link.page, actual_current_link.target.page);
ASSERT_TRUE(actual_current_link.target.y_in_pixels.has_value());
EXPECT_FLOAT_EQ(expected_current_link.y_in_pixels,
actual_current_link.target.y_in_pixels.value());
}
}
}
TEST_P(PDFiumPageLinkTest, GetLinkTarget) {
TestClient client;
std::unique_ptr<PDFiumEngine> engine = InitializeEngine(
&client, FILE_PATH_LITERAL("in_doc_link_with_various_page_sizes.pdf"));
ASSERT_EQ(3, engine->GetNumberOfPages());
const std::vector<PDFiumPage::Link>& links = GetLinks(*engine, 0);
ASSERT_EQ(1u, links.size());
// Get the destination link that exists in the first page.
PDFiumPage& first_page = GetPDFiumPageForTest(*engine, 0);
FPDF_LINK link = FPDFLink_GetLinkAtPoint(first_page.GetPage(), 70, 740);
ASSERT_TRUE(link);
FPDF_DEST dest_link = FPDFLink_GetDest(engine->doc(), link);
ASSERT_TRUE(dest_link);
PDFiumPage::LinkTarget target;
PDFiumPage::Area area = first_page.GetLinkTarget(link, &target);
EXPECT_EQ(PDFiumPage::Area::DOCLINK_AREA, area);
EXPECT_TRUE(target.url.empty());
ASSERT_EQ(1, target.page);
// Make sure the target page's size is different from the first page's. This
// guarantees that the in-screen coordinates are calculated based on the
// target page's dimension.
PDFiumPage& target_page = GetPDFiumPageForTest(*engine, target.page);
ASSERT_TRUE(target_page.available());
ASSERT_TRUE(first_page.available());
EXPECT_NE(GetPageSizeHelper(first_page), GetPageSizeHelper(target_page));
ASSERT_TRUE(target.x_in_pixels.has_value());
ASSERT_TRUE(target.y_in_pixels.has_value());
EXPECT_FLOAT_EQ(74.666664f, target.x_in_pixels.value());
EXPECT_FLOAT_EQ(120.f, target.y_in_pixels.value());
EXPECT_FALSE(target.zoom.has_value());
}
// Regression test for crbug.com/1396248
TEST_P(PDFiumPageLinkTest, GetUTF8LinkTarget) {
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("uri_action_utf8.pdf"));
ASSERT_EQ(1, engine->GetNumberOfPages());
const std::vector<PDFiumPage::Link>& links = GetLinks(*engine, 0);
ASSERT_EQ(1u, links.size());
// Get the only link in the document.
PDFiumPage& first_page = GetPDFiumPageForTest(*engine, 0);
FPDF_LINK link = FPDFLink_GetLinkAtPoint(first_page.GetPage(), 100, 100);
ASSERT_TRUE(link);
FPDF_DEST dest_link = FPDFLink_GetDest(engine->doc(), link);
EXPECT_FALSE(dest_link);
PDFiumPage::LinkTarget target;
PDFiumPage::Area area = first_page.GetLinkTarget(link, &target);
EXPECT_EQ(PDFiumPage::Area::WEBLINK_AREA, area);
EXPECT_EQ("https://site.test/hello_你好.html", target.url);
EXPECT_EQ(-1, target.page);
EXPECT_FALSE(target.x_in_pixels.has_value());
EXPECT_FALSE(target.y_in_pixels.has_value());
EXPECT_FALSE(target.zoom.has_value());
}
INSTANTIATE_TEST_SUITE_P(All, PDFiumPageLinkTest, testing::Bool());
using PDFiumPageImageTest = PDFiumTestBase;
TEST_P(PDFiumPageImageTest, CalculateImages) {
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("image_alt_text.pdf"));
ASSERT_TRUE(engine);
ASSERT_EQ(1, engine->GetNumberOfPages());
PDFiumPage& page = GetPDFiumPageForTest(*engine, 0);
page.CalculateImages();
ASSERT_EQ(3u, page.images_.size());
EXPECT_EQ(gfx::Rect(380, 78, 67, 68), page.images_[0].bounding_rect);
EXPECT_EQ("Image 1", page.images_[0].alt_text);
EXPECT_EQ(gfx::Rect(380, 385, 27, 28), page.images_[1].bounding_rect);
EXPECT_EQ("Image 2", page.images_[1].alt_text);
EXPECT_EQ(gfx::Rect(380, 678, 1, 1), page.images_[2].bounding_rect);
EXPECT_EQ("Image 3", page.images_[2].alt_text);
}
TEST_P(PDFiumPageImageTest, ImageAltText) {
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("text_with_image.pdf"));
ASSERT_TRUE(engine);
ASSERT_EQ(1, engine->GetNumberOfPages());
PDFiumPage& page = GetPDFiumPageForTest(*engine, 0);
page.CalculateImages();
ASSERT_EQ(3u, page.images_.size());
EXPECT_EQ(gfx::Rect(380, 78, 67, 68), page.images_[0].bounding_rect);
EXPECT_EQ("Image 1", page.images_[0].alt_text);
EXPECT_EQ(gfx::Rect(380, 385, 27, 28), page.images_[1].bounding_rect);
EXPECT_EQ("", page.images_[1].alt_text);
EXPECT_EQ(gfx::Rect(380, 678, 1, 1), page.images_[2].bounding_rect);
EXPECT_EQ("", page.images_[2].alt_text);
}
INSTANTIATE_TEST_SUITE_P(All, PDFiumPageImageTest, testing::Bool());
class PDFiumPageImageDataTest : public PDFiumPageImageTest {
public:
PDFiumPageImageDataTest() : enable_pdf_ocr_({features::kPdfOcr}) {}
PDFiumPageImageDataTest(const PDFiumPageImageDataTest&) = delete;
PDFiumPageImageDataTest& operator=(const PDFiumPageImageDataTest&) = delete;
~PDFiumPageImageDataTest() override = default;
void SetUp() override {
PDFiumPageImageTest::SetUp();
base::DiscardableMemoryAllocator::SetInstance(
&discardable_memory_allocator_);
}
void TearDown() override {
base::DiscardableMemoryAllocator::SetInstance(nullptr);
PDFiumPageImageTest::TearDown();
}
private:
base::test::ScopedFeatureList enable_pdf_ocr_;
base::TestDiscardableMemoryAllocator discardable_memory_allocator_;
};
TEST_P(PDFiumPageImageDataTest, ImageData) {
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("text_with_image.pdf"));
ASSERT_TRUE(engine);
ASSERT_EQ(1, engine->GetNumberOfPages());
PDFiumPage& page = GetPDFiumPageForTest(*engine, 0);
page.CalculateImages();
ASSERT_EQ(3u, page.images_.size());
ASSERT_FALSE(page.images_[0].alt_text.empty());
SkBitmap image_bitmap = engine->GetImageForOcr(
/*page_index=*/0, page.images_[0].page_object_index);
EXPECT_FALSE(image_bitmap.drawsNothing());
EXPECT_EQ(image_bitmap.width(), 50);
EXPECT_EQ(image_bitmap.height(), 50);
ASSERT_TRUE(page.images_[1].alt_text.empty());
image_bitmap = engine->GetImageForOcr(/*page_index=*/0,
page.images_[1].page_object_index);
EXPECT_FALSE(image_bitmap.drawsNothing());
// While the scaled image size is 20x20, `image_data` has the same size as
// the image in the PDF file, which is 50x50, and is not scaled.
EXPECT_EQ(image_bitmap.width(), 50);
EXPECT_EQ(image_bitmap.height(), 50);
}
TEST_P(PDFiumPageImageDataTest, RotatedPageImageData) {
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("rotated_page.pdf"));
ASSERT_TRUE(engine);
ASSERT_EQ(1, engine->GetNumberOfPages());
PDFiumPage& page = GetPDFiumPageForTest(*engine, 0);
page.CalculateImages();
ASSERT_EQ(1u, page.images_.size());
// This page is rotated, therefore the extracted image size is 25x100 while
// the stored image is 100x25.
SkBitmap image_bitmap = engine->GetImageForOcr(
/*page_index=*/0, page.images_[0].page_object_index);
EXPECT_EQ(image_bitmap.width(), 25);
EXPECT_EQ(image_bitmap.height(), 100);
}
TEST_P(PDFiumPageImageDataTest, ImageDataForNonImage) {
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("text_with_image.pdf"));
ASSERT_TRUE(engine);
ASSERT_EQ(1, engine->GetNumberOfPages());
PDFiumPage& page = GetPDFiumPageForTest(*engine, 0);
page.CalculateImages();
ASSERT_EQ(3u, page.images_.size());
ASSERT_EQ(1, page.images_[0].page_object_index);
// Existing non-image object.
SkBitmap image_bitmap = engine->GetImageForOcr(
/*page_index=*/0, /*image_index=*/0);
EXPECT_TRUE(image_bitmap.drawsNothing());
EXPECT_EQ(image_bitmap.width(), 0);
EXPECT_EQ(image_bitmap.height(), 0);
// Out of range.
image_bitmap = engine->GetImageForOcr(
/*page_index=*/0, /*image_index=*/1000);
EXPECT_TRUE(image_bitmap.drawsNothing());
EXPECT_EQ(image_bitmap.width(), 0);
EXPECT_EQ(image_bitmap.height(), 0);
}
INSTANTIATE_TEST_SUITE_P(All, PDFiumPageImageDataTest, testing::Bool());
using PDFiumPageTextTest = PDFiumTestBase;
TEST_P(PDFiumPageTextTest, TextRunBounds) {
TestClient client;
std::unique_ptr<PDFiumEngine> engine = InitializeEngine(
&client, FILE_PATH_LITERAL("leading_trailing_spaces_per_text_run.pdf"));
ASSERT_TRUE(engine);
constexpr int kFirstRunStartIndex = 0;
constexpr int kFirstRunEndIndex = 20;
constexpr int kPageIndex = 0;
std::optional<AccessibilityTextRunInfo> text_run_info_1 =
engine->GetTextRunInfo(kPageIndex, kFirstRunStartIndex);
ASSERT_TRUE(text_run_info_1.has_value());
const auto& actual_text_run_1 = text_run_info_1.value();
EXPECT_EQ(21u, actual_text_run_1.len);
EXPECT_TRUE(base::IsUnicodeWhitespace(
engine->GetCharUnicode(kPageIndex, kFirstRunStartIndex)));
gfx::RectF text_run_bounds = actual_text_run_1.bounds;
EXPECT_TRUE(text_run_bounds.Contains(
engine->GetCharBounds(kPageIndex, kFirstRunStartIndex)));
// Last non-space character should fall in the bounding box of the text run.
// Text run looks like this:
// " Hello, world! \r\n "<17 characters><first Tj>
// " \r\n "<4 characters><second Tj>
// " "<1 character><third Tj starting spaces>
// Finally generated text run: " Hello, world! \r\n \r\n "
constexpr int kFirstRunLastNonSpaceCharIndex = 13;
EXPECT_FALSE(base::IsUnicodeWhitespace(
engine->GetCharUnicode(kPageIndex, kFirstRunLastNonSpaceCharIndex)));
EXPECT_TRUE(text_run_bounds.Contains(
engine->GetCharBounds(kPageIndex, kFirstRunLastNonSpaceCharIndex)));
EXPECT_TRUE(base::IsUnicodeWhitespace(
engine->GetCharUnicode(kPageIndex, kFirstRunEndIndex)));
gfx::RectF end_char_rect =
engine->GetCharBounds(kPageIndex, kFirstRunEndIndex);
EXPECT_FALSE(text_run_bounds.Contains(end_char_rect));
// Equals to the length of the previous text run.
constexpr int kSecondRunStartIndex = 21;
constexpr int kSecondRunEndIndex = 36;
// Test the properties of second text run.
// Note: The leading spaces in second text run are accounted for in the end
// of first text run. Hence we won't see a space leading the second text run.
std::optional<AccessibilityTextRunInfo> text_run_info_2 =
engine->GetTextRunInfo(kPageIndex, kSecondRunStartIndex);
ASSERT_TRUE(text_run_info_2.has_value());
const auto& actual_text_run_2 = text_run_info_2.value();
EXPECT_EQ(16u, actual_text_run_2.len);
EXPECT_FALSE(base::IsUnicodeWhitespace(
engine->GetCharUnicode(kPageIndex, kSecondRunStartIndex)));
text_run_bounds = actual_text_run_2.bounds;
EXPECT_TRUE(text_run_bounds.Contains(
engine->GetCharBounds(kPageIndex, kSecondRunStartIndex)));
// Last non-space character should fall in the bounding box of the text run.
// Text run looks like this:
// "Goodbye, world! "<19 characters><first Tj>
// Finally generated text run: "Goodbye, world! "
constexpr int kSecondRunLastNonSpaceCharIndex = 35;
EXPECT_FALSE(base::IsUnicodeWhitespace(
engine->GetCharUnicode(kPageIndex, kSecondRunLastNonSpaceCharIndex)));
EXPECT_TRUE(text_run_bounds.Contains(
engine->GetCharBounds(kPageIndex, kSecondRunLastNonSpaceCharIndex)));
EXPECT_TRUE(base::IsUnicodeWhitespace(
engine->GetCharUnicode(kPageIndex, kSecondRunEndIndex)));
EXPECT_FALSE(text_run_bounds.Contains(
engine->GetCharBounds(kPageIndex, kSecondRunEndIndex)));
}
TEST_P(PDFiumPageTextTest, GetTextRunInfo) {
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("weblinks.pdf"));
ASSERT_TRUE(engine);
int current_char_index = 0;
AccessibilityTextStyleInfo expected_style_1 = {
"Times-Roman",
0,
AccessibilityTextRenderMode::kFill,
12,
0xff000000,
0xff000000,
false,
false};
AccessibilityTextStyleInfo expected_style_2 = {
"Helvetica", 0, AccessibilityTextRenderMode::kFill,
16, 0xff000000, 0xff000000,
false, false};
// The links span from [7, 22], [52, 66] and [92, 108] with 16, 15 and 17
// text run lengths respectively. There are text runs preceding and
// succeeding them.
AccessibilityTextRunInfo expected_text_runs[] = {
{7, gfx::RectF(26.666666f, 189.333333f, 38.666672f, 13.333344f),
AccessibilityTextDirection::kLeftToRight, expected_style_1},
{16, gfx::RectF(70.666664f, 189.333333f, 108.0f, 14.666672f),
AccessibilityTextDirection::kLeftToRight, expected_style_1},
{20, gfx::RectF(181.333333f, 189.333333f, 117.333333f, 14.666672f),
AccessibilityTextDirection::kLeftToRight, expected_style_1},
{9, gfx::RectF(28.0f, 117.33334f, 89.333328f, 20.0f),
AccessibilityTextDirection::kLeftToRight, expected_style_2},
{15, gfx::RectF(126.66666f, 117.33334f, 137.33334f, 20.0f),
AccessibilityTextDirection::kLeftToRight, expected_style_2},
{20, gfx::RectF(266.66666f, 118.66666f, 169.33334f, 18.666664f),
AccessibilityTextDirection::kLeftToRight, expected_style_2},
{5, gfx::RectF(28.0f, 65.333336f, 40.0f, 18.666664f),
AccessibilityTextDirection::kLeftToRight, expected_style_2},
{17, gfx::RectF(77.333336f, 64.0f, 160.0f, 20.0f),
AccessibilityTextDirection::kLeftToRight, expected_style_2}};
if (UsingTestFonts()) {
expected_text_runs[4].bounds =
gfx::RectF(126.66666f, 117.33334f, 137.33334f, 21.33334f);
expected_text_runs[5].bounds =
gfx::RectF(266.66666f, 118.66666f, 170.66666f, 20.0f);
expected_text_runs[7].bounds =
gfx::RectF(77.333336f, 64.0f, 160.0f, 21.33333f);
}
// Test negative char index returns nullopt
std::optional<AccessibilityTextRunInfo> text_run_info_result =
engine->GetTextRunInfo(0, -1);
ASSERT_FALSE(text_run_info_result.has_value());
// Test valid char index returns expected text run info and expected text
// style info
for (const auto& expected_text_run : expected_text_runs) {
text_run_info_result = engine->GetTextRunInfo(0, current_char_index);
ASSERT_TRUE(text_run_info_result.has_value());
const auto& actual_text_run = text_run_info_result.value();
CompareTextRuns(expected_text_run, actual_text_run);
current_char_index += actual_text_run.len;
}
// Test char index outside char range returns nullopt
PDFiumPage& page = GetPDFiumPageForTest(*engine, 0);
EXPECT_EQ(page.GetCharCount(), current_char_index);
text_run_info_result = engine->GetTextRunInfo(0, current_char_index);
ASSERT_FALSE(text_run_info_result.has_value());
}
TEST_P(PDFiumPageTextTest, HighlightTextRunInfo) {
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("highlights.pdf"));
ASSERT_TRUE(engine);
ASSERT_EQ(1, engine->GetNumberOfPages());
// Highlights span across text run indices 0, 2 and 3.
static const AccessibilityTextStyleInfo kExpectedStyle = {
"Helvetica", 0, AccessibilityTextRenderMode::kFill,
16, 0xff000000, 0xff000000,
false, false};
AccessibilityTextRunInfo expected_text_runs[] = {
{5, gfx::RectF(1.3333334f, 198.66667f, 46.666668f, 14.666672f),
AccessibilityTextDirection::kLeftToRight, kExpectedStyle},
{7, gfx::RectF(50.666668f, 198.66667f, 47.999996f, 17.333328f),
AccessibilityTextDirection::kLeftToRight, kExpectedStyle},
{7, gfx::RectF(106.66666f, 198.66667f, 73.333336f, 18.666672f),
AccessibilityTextDirection::kLeftToRight, kExpectedStyle},
{2, gfx::RectF(181.33333f, 202.66667f, 16.0f, 14.66667f),
AccessibilityTextDirection::kNone, kExpectedStyle},
{2, gfx::RectF(198.66667f, 202.66667f, 21.333328f, 10.666672f),
AccessibilityTextDirection::kLeftToRight, kExpectedStyle}};
if (UsingTestFonts()) {
expected_text_runs[2].bounds =
gfx::RectF(106.66666f, 198.66667f, 73.333336f, 19.999985f);
expected_text_runs[4].bounds =
gfx::RectF(198.66667f, 201.33333f, 21.333328f, 12.000015f);
}
int current_char_index = 0;
for (const auto& expected_text_run : expected_text_runs) {
std::optional<AccessibilityTextRunInfo> text_run_info_result =
engine->GetTextRunInfo(0, current_char_index);
ASSERT_TRUE(text_run_info_result.has_value());
const auto& actual_text_run = text_run_info_result.value();
CompareTextRuns(expected_text_run, actual_text_run);
current_char_index += actual_text_run.len;
}
}
INSTANTIATE_TEST_SUITE_P(All, PDFiumPageTextTest, testing::Bool());
using PDFiumPageHighlightTest = PDFiumTestBase;
TEST_P(PDFiumPageHighlightTest, PopulateHighlights) {
struct ExpectedHighlight {
int32_t start_char_index;
int32_t char_count;
gfx::Rect bounding_rect;
uint32_t color;
};
constexpr uint32_t kHighlightDefaultColor = MakeARGB(255, 255, 255, 0);
constexpr uint32_t kHighlightRedColor = MakeARGB(102, 230, 0, 0);
constexpr uint32_t kHighlightNoColor = MakeARGB(0, 0, 0, 0);
static const ExpectedHighlight kExpectedHighlights[] = {
{0, 5, {5, 196, 49, 26}, kHighlightDefaultColor},
{12, 7, {110, 196, 77, 26}, kHighlightRedColor},
{20, 1, {192, 196, 13, 26}, kHighlightNoColor}};
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("highlights.pdf"));
ASSERT_TRUE(engine);
ASSERT_EQ(1, engine->GetNumberOfPages());
PDFiumPage& page = GetPDFiumPageForTest(*engine, 0);
page.PopulateAnnotations();
ASSERT_EQ(std::size(kExpectedHighlights), page.highlights_.size());
for (size_t i = 0; i < page.highlights_.size(); ++i) {
ASSERT_EQ(kExpectedHighlights[i].start_char_index,
page.highlights_[i].start_char_index);
ASSERT_EQ(kExpectedHighlights[i].char_count,
page.highlights_[i].char_count);
EXPECT_EQ(kExpectedHighlights[i].bounding_rect,
page.highlights_[i].bounding_rect);
ASSERT_EQ(kExpectedHighlights[i].color, page.highlights_[i].color);
}
}
INSTANTIATE_TEST_SUITE_P(All, PDFiumPageHighlightTest, testing::Bool());
using PDFiumPageTextFieldTest = PDFiumTestBase;
TEST_P(PDFiumPageTextFieldTest, PopulateTextFields) {
struct ExpectedTextField {
const char* name;
const char* value;
gfx::Rect bounding_rect;
int flags;
};
static const ExpectedTextField kExpectedTextFields[] = {
{"Text Box", "Text", {138, 230, 135, 41}, 0},
{"ReadOnly", "Elephant", {138, 163, 135, 41}, 1},
{"Required", "Required Field", {138, 303, 135, 34}, 2},
{"Password", "", {138, 356, 135, 35}, 8192}};
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("form_text_fields.pdf"));
ASSERT_TRUE(engine);
ASSERT_EQ(1, engine->GetNumberOfPages());
PDFiumPage& page = GetPDFiumPageForTest(*engine, 0);
page.PopulateAnnotations();
size_t text_fields_count = page.text_fields_.size();
ASSERT_EQ(std::size(kExpectedTextFields), text_fields_count);
for (size_t i = 0; i < text_fields_count; ++i) {
EXPECT_EQ(kExpectedTextFields[i].name, page.text_fields_[i].name);
EXPECT_EQ(kExpectedTextFields[i].value, page.text_fields_[i].value);
EXPECT_EQ(kExpectedTextFields[i].bounding_rect,
page.text_fields_[i].bounding_rect);
EXPECT_EQ(kExpectedTextFields[i].flags, page.text_fields_[i].flags);
}
}
INSTANTIATE_TEST_SUITE_P(All, PDFiumPageTextFieldTest, testing::Bool());
using PDFiumPageChoiceFieldTest = PDFiumTestBase;
TEST_P(PDFiumPageChoiceFieldTest, PopulateChoiceFields) {
struct ExpectedChoiceFieldOption {
const char* name;
bool is_selected;
};
struct ExpectedChoiceField {
const char* name;
std::vector<struct ExpectedChoiceFieldOption> options;
gfx::Rect bounding_rect;
int flags;
};
static const ExpectedChoiceField kExpectedChoiceFields[] = {
{"Listbox_SingleSelect",
{{"Foo", false}, {"Bar", false}, {"Qux", false}},
{138, 296, 135, 41},
0},
{"Combo1",
{{"Apple", false}, {"Banana", true}, {"Cherry", false}},
{138, 230, 135, 41},
131072},
{"Listbox_ReadOnly",
{{"Dog", false}, {"Elephant", false}, {"Frog", false}},
{138, 96, 135, 41},
1},
{"Listbox_MultiSelectMultipleIndices",
{
{"Albania", false},
{"Belgium", true},
{"Croatia", false},
{"Denmark", true},
{"Estonia", false},
},
{138, 430, 135, 41},
2097152},
{"Listbox_MultiSelectMultipleValues",
{
{"Alpha", false},
{"Beta", false},
{"Gamma", true},
{"Delta", false},
{"Epsilon", true},
},
{138, 496, 135, 41},
2097152},
{"Listbox_MultiSelectMultipleMismatch",
{
{"Alligator", true},
{"Bear", false},
{"Cougar", true},
{"Deer", false},
{"Echidna", false},
},
{138, 563, 135, 41},
2097152}};
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("form_choice_fields.pdf"));
ASSERT_TRUE(engine);
ASSERT_EQ(1, engine->GetNumberOfPages());
PDFiumPage& page = GetPDFiumPageForTest(*engine, 0);
page.PopulateAnnotations();
size_t choice_fields_count = page.choice_fields_.size();
ASSERT_EQ(std::size(kExpectedChoiceFields), choice_fields_count);
for (size_t i = 0; i < choice_fields_count; ++i) {
EXPECT_EQ(kExpectedChoiceFields[i].name, page.choice_fields_[i].name);
size_t choice_field_options_count = page.choice_fields_[i].options.size();
ASSERT_EQ(std::size(kExpectedChoiceFields[i].options),
choice_field_options_count);
for (size_t j = 0; j < choice_field_options_count; ++j) {
EXPECT_EQ(kExpectedChoiceFields[i].options[j].name,
page.choice_fields_[i].options[j].name);
EXPECT_EQ(kExpectedChoiceFields[i].options[j].is_selected,
page.choice_fields_[i].options[j].is_selected);
}
EXPECT_EQ(kExpectedChoiceFields[i].bounding_rect,
page.choice_fields_[i].bounding_rect);
EXPECT_EQ(kExpectedChoiceFields[i].flags, page.choice_fields_[i].flags);
}
}
INSTANTIATE_TEST_SUITE_P(All, PDFiumPageChoiceFieldTest, testing::Bool());
using PDFiumPageButtonTest = PDFiumTestBase;
TEST_P(PDFiumPageButtonTest, PopulateButtons) {
struct ExpectedButton {
const char* name;
const char* value;
int type;
int flags;
bool is_checked;
uint32_t control_count;
int control_index;
gfx::Rect bounding_rect;
};
static const ExpectedButton kExpectedButtons[] = {{"readOnlyCheckbox",
"Yes",
FPDF_FORMFIELD_CHECKBOX,
1,
true,
1,
0,
{185, 43, 28, 28}},
{"checkbox",
"Yes",
FPDF_FORMFIELD_CHECKBOX,
2,
false,
1,
0,
{185, 96, 28, 28}},
{"RadioButton",
"value1",
FPDF_FORMFIELD_RADIOBUTTON,
49154,
false,
2,
0,
{185, 243, 28, 28}},
{"RadioButton",
"value2",
FPDF_FORMFIELD_RADIOBUTTON,
49154,
true,
2,
1,
{252, 243, 27, 28}},
{"PushButton",
"",
FPDF_FORMFIELD_PUSHBUTTON,
65536,
false,
0,
-1,
{118, 270, 55, 67}}};
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("form_buttons.pdf"));
ASSERT_TRUE(engine);
ASSERT_EQ(1, engine->GetNumberOfPages());
PDFiumPage& page = GetPDFiumPageForTest(*engine, 0);
page.PopulateAnnotations();
size_t buttons_count = page.buttons_.size();
ASSERT_EQ(std::size(kExpectedButtons), buttons_count);
for (size_t i = 0; i < buttons_count; ++i) {
EXPECT_EQ(kExpectedButtons[i].name, page.buttons_[i].name);
EXPECT_EQ(kExpectedButtons[i].value, page.buttons_[i].value);
EXPECT_EQ(kExpectedButtons[i].type, page.buttons_[i].type);
EXPECT_EQ(kExpectedButtons[i].flags, page.buttons_[i].flags);
EXPECT_EQ(kExpectedButtons[i].is_checked, page.buttons_[i].is_checked);
EXPECT_EQ(kExpectedButtons[i].control_count,
page.buttons_[i].control_count);
EXPECT_EQ(kExpectedButtons[i].control_index,
page.buttons_[i].control_index);
EXPECT_EQ(kExpectedButtons[i].bounding_rect,
page.buttons_[i].bounding_rect);
}
}
INSTANTIATE_TEST_SUITE_P(All, PDFiumPageButtonTest, testing::Bool());
class PDFiumPageThumbnailTest : public PDFiumTestBase {
public:
PDFiumPageThumbnailTest() = default;
PDFiumPageThumbnailTest(const PDFiumPageThumbnailTest&) = delete;
PDFiumPageThumbnailTest& operator=(const PDFiumPageThumbnailTest&) = delete;
~PDFiumPageThumbnailTest() override = default;
void TestGenerateThumbnail(PDFiumEngine& engine,
size_t page_index,
float device_pixel_ratio,
const gfx::Size& expected_thumbnail_size,
const std::string& expectation_file_prefix) {
PDFiumPage& page = GetPDFiumPageForTest(engine, page_index);
Thumbnail thumbnail = page.GenerateThumbnail(device_pixel_ratio);
EXPECT_EQ(expected_thumbnail_size, thumbnail.image_size());
EXPECT_EQ(device_pixel_ratio, thumbnail.device_pixel_ratio());
auto image_info =
SkImageInfo::Make(gfx::SizeToSkISize(thumbnail.image_size()),
kRGBA_8888_SkColorType, kPremul_SkAlphaType);
int stride = thumbnail.stride();
ASSERT_GT(stride, 0);
ASSERT_EQ(image_info.minRowBytes(), static_cast<size_t>(stride));
std::vector<uint8_t> data = thumbnail.TakeData();
sk_sp<SkImage> image = SkImages::RasterFromPixmapCopy(
SkPixmap(image_info, data.data(), image_info.minRowBytes()));
ASSERT_TRUE(image);
base::FilePath expectation_png_file_path =
GetThumbnailTestData(expectation_file_prefix, page_index,
device_pixel_ratio, /*use_skia=*/GetParam());
EXPECT_TRUE(MatchesPngFile(image.get(), expectation_png_file_path));
}
};
TEST_P(PDFiumPageThumbnailTest, GenerateThumbnail) {
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("variable_page_sizes.pdf"));
ASSERT_EQ(7, engine->GetNumberOfPages());
static constexpr struct {
size_t page_index;
float device_pixel_ratio;
gfx::Size expected_thumbnail_size;
} kGenerateThumbnailTestParams[] = {
{0, 1, {108, 140}}, // ANSI Letter
{1, 1, {108, 152}}, // ISO 216 A4
{2, 1, {140, 140}}, // Square
{3, 1, {540, 108}}, // Wide
{4, 1, {108, 540}}, // Tall
{5, 1, {1399, 46}}, // Super wide
{6, 1, {46, 1399}}, // Super tall
{0, 2, {216, 280}}, // ANSI Letter
{1, 2, {214, 303}}, // ISO 216 A4
{2, 2, {255, 255}}, // Square
{3, 2, {571, 114}}, // Wide
{4, 2, {114, 571}}, // Tall
{5, 2, {1399, 46}}, // Super wide
{6, 2, {46, 1399}}, // Super tall
};
#if defined(ARCH_CPU_ARM64)
std::string file_name =
GetParam() ? "variable_page_sizes_arm64" : "variable_page_sizes";
#else
std::string file_name = "variable_page_sizes";
#endif
for (const auto& params : kGenerateThumbnailTestParams) {
TestGenerateThumbnail(*engine, params.page_index, params.device_pixel_ratio,
params.expected_thumbnail_size, file_name);
}
}
// For crbug.com/1248455
TEST_P(PDFiumPageThumbnailTest, GenerateThumbnailForAnnotation) {
TestClient client;
std::unique_ptr<PDFiumEngine> engine =
InitializeEngine(&client, FILE_PATH_LITERAL("signature_widget.pdf"));
TestGenerateThumbnail(*engine, /*page_index=*/0, /*device_pixel_ratio=*/1,
/*expected_thumbnail_size=*/{140, 140},
"signature_widget");
TestGenerateThumbnail(*engine, /*page_index=*/0, /*device_pixel_ratio=*/2,
/*expected_thumbnail_size=*/{255, 255},
"signature_widget");
}
INSTANTIATE_TEST_SUITE_P(All, PDFiumPageThumbnailTest, testing::Bool());
} // namespace chrome_pdf