Migrate PrivateAccessibilityTextRunInfo to PDF specific struct
Add AccessibilityTextRunInfo in pdf/ to replace usage of PrivateAccessibilityTextRunInfo. PrivateAccessibilityTextRunInfo is a Pepper struct. The new struct ensures that PrivateAccessibilityTextRunInfo is scoped to parts specific to Pepper implementation. Bug: 1144444 Change-Id: Id3efb8ba95a25b3955213f9ddf2ed0f5d5d55232 Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2560092 Auto-Submit: Ankit Kumar 🌪️ <ankk@microsoft.com> Commit-Queue: Sadrul Chowdhury <sadrul@chromium.org> Reviewed-by: Sadrul Chowdhury <sadrul@chromium.org> Reviewed-by: K. Moon <kmoon@chromium.org> Cr-Commit-Position: refs/heads/master@{#833319}
This commit is contained in:
Ankit Kumar 🌪️
committed by
Chromium LUCI CQ
Chromium LUCI CQ
parent
43a95a9a5d
commit
c3421524b4
@ -177,6 +177,7 @@ if (enable_pdf) {
|
||||
configs += [ ":pdf_common_config" ]
|
||||
|
||||
deps = [
|
||||
":accessibility_structs",
|
||||
":internal",
|
||||
":pdf",
|
||||
":ppapi_migration",
|
||||
@ -189,7 +190,10 @@ if (enable_pdf) {
|
||||
source_set("accessibility_structs") {
|
||||
visibility = [ ":*" ]
|
||||
|
||||
sources = [ "accessibility_structs.h" ]
|
||||
sources = [
|
||||
"accessibility_structs.cc",
|
||||
"accessibility_structs.h",
|
||||
]
|
||||
|
||||
configs += [ ":pdf_common_config" ]
|
||||
|
||||
|
||||
1
pdf/DEPS
1
pdf/DEPS
@ -10,5 +10,6 @@ include_rules = [
|
||||
"+ui/events/keycodes/keyboard_codes.h",
|
||||
"+ui/gfx/geometry",
|
||||
"+ui/gfx/range/range.h",
|
||||
"+ui/gfx/test/gfx_util.h",
|
||||
"+v8/include/v8.h"
|
||||
]
|
||||
|
||||
@ -18,16 +18,15 @@ namespace chrome_pdf {
|
||||
|
||||
namespace {
|
||||
|
||||
bool IsCharWithinTextRun(
|
||||
const pp::PDF::PrivateAccessibilityTextRunInfo& text_run,
|
||||
uint32_t text_run_start_char_index,
|
||||
uint32_t char_index) {
|
||||
bool IsCharWithinTextRun(const AccessibilityTextRunInfo& text_run,
|
||||
uint32_t text_run_start_char_index,
|
||||
uint32_t char_index) {
|
||||
return char_index >= text_run_start_char_index &&
|
||||
char_index - text_run_start_char_index < text_run.len;
|
||||
}
|
||||
|
||||
bool GetEnclosingTextRunRangeForCharRange(
|
||||
const std::vector<pp::PDF::PrivateAccessibilityTextRunInfo>& text_runs,
|
||||
const std::vector<AccessibilityTextRunInfo>& text_runs,
|
||||
int start_char_index,
|
||||
int char_count,
|
||||
uint32_t* start_text_run_index,
|
||||
@ -68,7 +67,7 @@ bool CompareTextRuns(const T& a, const T& b) {
|
||||
void GetAccessibilityLinkInfo(
|
||||
PDFEngine* engine,
|
||||
int32_t page_index,
|
||||
const std::vector<pp::PDF::PrivateAccessibilityTextRunInfo>& text_runs,
|
||||
const std::vector<AccessibilityTextRunInfo>& text_runs,
|
||||
std::vector<pp::PDF::PrivateAccessibilityLinkInfo>* links) {
|
||||
std::vector<PDFEngine::AccessibilityLinkInfo> engine_link_info =
|
||||
engine->GetLinkInfo(page_index);
|
||||
@ -117,7 +116,7 @@ void GetAccessibilityImageInfo(
|
||||
void GetAccessibilityHighlightInfo(
|
||||
PDFEngine* engine,
|
||||
int32_t page_index,
|
||||
const std::vector<pp::PDF::PrivateAccessibilityTextRunInfo>& text_runs,
|
||||
const std::vector<AccessibilityTextRunInfo>& text_runs,
|
||||
std::vector<pp::PDF::PrivateAccessibilityHighlightInfo>* highlights) {
|
||||
std::vector<PDFEngine::AccessibilityHighlightInfo> engine_highlight_info =
|
||||
engine->GetHighlightInfo(page_index);
|
||||
@ -185,7 +184,7 @@ bool GetAccessibilityInfo(
|
||||
PDFEngine* engine,
|
||||
int32_t page_index,
|
||||
AccessibilityPageInfo& page_info,
|
||||
std::vector<pp::PDF::PrivateAccessibilityTextRunInfo>* text_runs,
|
||||
std::vector<AccessibilityTextRunInfo>& text_runs,
|
||||
std::vector<AccessibilityCharInfo>& chars,
|
||||
pp::PDF::PrivateAccessibilityPageObjects* page_objects) {
|
||||
int page_count = engine->GetNumberOfPages();
|
||||
@ -210,13 +209,13 @@ bool GetAccessibilityInfo(
|
||||
|
||||
int char_index = 0;
|
||||
while (char_index < char_count) {
|
||||
base::Optional<pp::PDF::PrivateAccessibilityTextRunInfo>
|
||||
text_run_info_result = engine->GetTextRunInfo(page_index, char_index);
|
||||
base::Optional<AccessibilityTextRunInfo> text_run_info_result =
|
||||
engine->GetTextRunInfo(page_index, char_index);
|
||||
DCHECK(text_run_info_result.has_value());
|
||||
const auto& text_run_info = text_run_info_result.value();
|
||||
uint32_t text_run_end = char_index + text_run_info.len;
|
||||
DCHECK_LE(text_run_end, static_cast<uint32_t>(char_count));
|
||||
text_runs->push_back(text_run_info);
|
||||
text_runs.push_back(text_run_info);
|
||||
|
||||
// We need to provide enough information to draw a bounding box
|
||||
// around any arbitrary text range, but the bounding boxes of characters
|
||||
@ -233,25 +232,25 @@ bool GetAccessibilityInfo(
|
||||
gfx::RectF next_char_bounds = engine->GetCharBounds(page_index, i + 1);
|
||||
double& char_width = chars[i].char_width;
|
||||
switch (text_run_info.direction) {
|
||||
case PP_PRIVATEDIRECTION_NONE:
|
||||
case PP_PRIVATEDIRECTION_LTR:
|
||||
case AccessibilityTextDirection::kNone:
|
||||
case AccessibilityTextDirection::kLeftToRight:
|
||||
char_width = next_char_bounds.x() - char_bounds.x();
|
||||
break;
|
||||
case PP_PRIVATEDIRECTION_TTB:
|
||||
case AccessibilityTextDirection::kTopToBottom:
|
||||
char_width = next_char_bounds.y() - char_bounds.y();
|
||||
break;
|
||||
case PP_PRIVATEDIRECTION_RTL:
|
||||
case AccessibilityTextDirection::kRightToLeft:
|
||||
char_width = char_bounds.right() - next_char_bounds.right();
|
||||
break;
|
||||
case PP_PRIVATEDIRECTION_BTT:
|
||||
case AccessibilityTextDirection::kBottomToTop:
|
||||
char_width = char_bounds.bottom() - next_char_bounds.bottom();
|
||||
break;
|
||||
}
|
||||
char_bounds = next_char_bounds;
|
||||
}
|
||||
double& char_width = chars[text_run_end - 1].char_width;
|
||||
if (text_run_info.direction == PP_PRIVATEDIRECTION_BTT ||
|
||||
text_run_info.direction == PP_PRIVATEDIRECTION_TTB) {
|
||||
if (text_run_info.direction == AccessibilityTextDirection::kBottomToTop ||
|
||||
text_run_info.direction == AccessibilityTextDirection::kTopToBottom) {
|
||||
char_width = char_bounds.height();
|
||||
} else {
|
||||
char_width = char_bounds.width();
|
||||
@ -260,12 +259,11 @@ bool GetAccessibilityInfo(
|
||||
char_index += text_run_info.len;
|
||||
}
|
||||
|
||||
page_info.text_run_count = text_runs->size();
|
||||
GetAccessibilityLinkInfo(engine, page_index, *text_runs,
|
||||
&page_objects->links);
|
||||
page_info.text_run_count = text_runs.size();
|
||||
GetAccessibilityLinkInfo(engine, page_index, text_runs, &page_objects->links);
|
||||
GetAccessibilityImageInfo(engine, page_index, page_info.text_run_count,
|
||||
&page_objects->images);
|
||||
GetAccessibilityHighlightInfo(engine, page_index, *text_runs,
|
||||
GetAccessibilityHighlightInfo(engine, page_index, text_runs,
|
||||
&page_objects->highlights);
|
||||
GetAccessibilityFormFieldInfo(engine, page_index, page_info.text_run_count,
|
||||
&page_objects->form_fields);
|
||||
|
||||
@ -13,9 +13,10 @@
|
||||
|
||||
namespace chrome_pdf {
|
||||
|
||||
class PDFEngine;
|
||||
struct AccessibilityCharInfo;
|
||||
struct AccessibilityPageInfo;
|
||||
class PDFEngine;
|
||||
struct AccessibilityTextRunInfo;
|
||||
|
||||
// Retrieve |page_info|, |text_runs|, |chars|, and |page_objects| from
|
||||
// |engine| for the page at 0-indexed |page_index|. Returns true on success with
|
||||
@ -25,7 +26,7 @@ bool GetAccessibilityInfo(
|
||||
PDFEngine* engine,
|
||||
int32_t page_index,
|
||||
AccessibilityPageInfo& page_info,
|
||||
std::vector<pp::PDF::PrivateAccessibilityTextRunInfo>* text_runs,
|
||||
std::vector<AccessibilityTextRunInfo>& text_runs,
|
||||
std::vector<AccessibilityCharInfo>& chars,
|
||||
pp::PDF::PrivateAccessibilityPageObjects* page_objects);
|
||||
|
||||
|
||||
48
pdf/accessibility_structs.cc
Normal file
48
pdf/accessibility_structs.cc
Normal file
@ -0,0 +1,48 @@
|
||||
// Copyright 2020 The Chromium Authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#include "pdf/accessibility_structs.h"
|
||||
|
||||
namespace chrome_pdf {
|
||||
|
||||
AccessibilityTextStyleInfo::AccessibilityTextStyleInfo() = default;
|
||||
|
||||
AccessibilityTextStyleInfo::AccessibilityTextStyleInfo(
|
||||
const std::string& font_name,
|
||||
int font_weight,
|
||||
AccessibilityTextRenderMode render_mode,
|
||||
float font_size,
|
||||
uint32_t fill_color,
|
||||
uint32_t stroke_color,
|
||||
bool is_italic,
|
||||
bool is_bold)
|
||||
: font_name(font_name),
|
||||
font_weight(font_weight),
|
||||
render_mode(render_mode),
|
||||
font_size(font_size),
|
||||
fill_color(fill_color),
|
||||
stroke_color(stroke_color),
|
||||
is_italic(is_italic),
|
||||
is_bold(is_bold) {}
|
||||
|
||||
AccessibilityTextStyleInfo::AccessibilityTextStyleInfo(
|
||||
const AccessibilityTextStyleInfo& other) = default;
|
||||
|
||||
AccessibilityTextStyleInfo::~AccessibilityTextStyleInfo() = default;
|
||||
|
||||
AccessibilityTextRunInfo::AccessibilityTextRunInfo() = default;
|
||||
|
||||
AccessibilityTextRunInfo::AccessibilityTextRunInfo(
|
||||
uint32_t len,
|
||||
const gfx::RectF& bounds,
|
||||
AccessibilityTextDirection direction,
|
||||
const AccessibilityTextStyleInfo& style)
|
||||
: len(len), bounds(bounds), direction(direction), style(style) {}
|
||||
|
||||
AccessibilityTextRunInfo::AccessibilityTextRunInfo(
|
||||
const AccessibilityTextRunInfo& other) = default;
|
||||
|
||||
AccessibilityTextRunInfo::~AccessibilityTextRunInfo() = default;
|
||||
|
||||
} // namespace chrome_pdf
|
||||
@ -7,7 +7,10 @@
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#include <string>
|
||||
|
||||
#include "ui/gfx/geometry/rect.h"
|
||||
#include "ui/gfx/geometry/rect_f.h"
|
||||
|
||||
namespace chrome_pdf {
|
||||
|
||||
@ -18,6 +21,75 @@ struct AccessibilityPageInfo {
|
||||
uint32_t char_count = 0;
|
||||
};
|
||||
|
||||
// TODO(crbug.com/1144444): Remove next line comment after PDF migrates away
|
||||
// from Pepper.
|
||||
// Explicitly set all enum values to match enum values in PP_TextRenderingMode.
|
||||
// See PDF Reference 1.7, page 402, table 5.3.
|
||||
enum class AccessibilityTextRenderMode {
|
||||
kUnknown = -1,
|
||||
kFill = 0,
|
||||
kStroke = 1,
|
||||
kFillStroke = 2,
|
||||
kInvisible = 3,
|
||||
kFillClip = 4,
|
||||
kStrokeClip = 5,
|
||||
kFillStrokeClip = 6,
|
||||
kClip = 7,
|
||||
kMaxValue = kClip,
|
||||
};
|
||||
|
||||
struct AccessibilityTextStyleInfo {
|
||||
AccessibilityTextStyleInfo();
|
||||
AccessibilityTextStyleInfo(const std::string& font_name,
|
||||
int font_weight,
|
||||
AccessibilityTextRenderMode render_mode,
|
||||
float font_size,
|
||||
uint32_t fill_color,
|
||||
uint32_t stroke_color,
|
||||
bool is_italic,
|
||||
bool is_bold);
|
||||
AccessibilityTextStyleInfo(const AccessibilityTextStyleInfo& other);
|
||||
~AccessibilityTextStyleInfo();
|
||||
|
||||
std::string font_name;
|
||||
int font_weight = 0;
|
||||
AccessibilityTextRenderMode render_mode =
|
||||
AccessibilityTextRenderMode::kUnknown;
|
||||
float font_size = 0.0f;
|
||||
// Colors are ARGB.
|
||||
uint32_t fill_color = 0;
|
||||
uint32_t stroke_color = 0;
|
||||
bool is_italic = false;
|
||||
bool is_bold = false;
|
||||
};
|
||||
|
||||
// TODO(crbug.com/1144444): Remove next line comment after PDF migrates away
|
||||
// from Pepper.
|
||||
// Explicitly set all enum values to match enum values in PP_PrivateDirection.
|
||||
enum class AccessibilityTextDirection {
|
||||
kNone = 0,
|
||||
kLeftToRight = 1,
|
||||
kRightToLeft = 2,
|
||||
kTopToBottom = 3,
|
||||
kBottomToTop = 4,
|
||||
kMaxValue = kBottomToTop,
|
||||
};
|
||||
|
||||
struct AccessibilityTextRunInfo {
|
||||
AccessibilityTextRunInfo();
|
||||
AccessibilityTextRunInfo(uint32_t len,
|
||||
const gfx::RectF& bounds,
|
||||
AccessibilityTextDirection direction,
|
||||
const AccessibilityTextStyleInfo& style);
|
||||
AccessibilityTextRunInfo(const AccessibilityTextRunInfo& other);
|
||||
~AccessibilityTextRunInfo();
|
||||
|
||||
uint32_t len = 0;
|
||||
gfx::RectF bounds;
|
||||
AccessibilityTextDirection direction = AccessibilityTextDirection::kNone;
|
||||
struct AccessibilityTextStyleInfo style;
|
||||
};
|
||||
|
||||
struct AccessibilityCharInfo {
|
||||
uint32_t unicode_character = 0;
|
||||
double char_width = 0.0;
|
||||
@ -25,4 +97,4 @@ struct AccessibilityCharInfo {
|
||||
|
||||
} // namespace chrome_pdf
|
||||
|
||||
#endif // PDF_ACCESSIBILITY_STRUCTS_H_
|
||||
#endif // PDF_ACCESSIBILITY_STRUCTS_H_
|
||||
|
||||
@ -498,6 +498,37 @@ PrivateAccessibilityCharInfoFromAccessibilityCharInfo(
|
||||
return pp_chars;
|
||||
}
|
||||
|
||||
pp::PDF::PrivateAccessibilityTextStyleInfo
|
||||
PrivateAccessibilityTextStyleInfoFromAccessibilityTextStyleInfo(
|
||||
const AccessibilityTextStyleInfo& style) {
|
||||
pp::PDF::PrivateAccessibilityTextStyleInfo pp_style;
|
||||
pp_style.font_name = style.font_name;
|
||||
pp_style.font_weight = style.font_weight;
|
||||
pp_style.render_mode = static_cast<PP_TextRenderingMode>(style.render_mode);
|
||||
pp_style.font_size = style.font_size;
|
||||
pp_style.fill_color = style.fill_color;
|
||||
pp_style.stroke_color = style.stroke_color;
|
||||
pp_style.is_italic = style.is_italic;
|
||||
pp_style.is_bold = style.is_bold;
|
||||
return pp_style;
|
||||
}
|
||||
|
||||
std::vector<pp::PDF::PrivateAccessibilityTextRunInfo>
|
||||
PrivateAccessibilityCharInfoFromAccessibilityTextRunInfo(
|
||||
const std::vector<AccessibilityTextRunInfo>& text_runs) {
|
||||
std::vector<pp::PDF::PrivateAccessibilityTextRunInfo> pp_text_runs;
|
||||
pp_text_runs.reserve(text_runs.size());
|
||||
for (const auto& text_run : text_runs) {
|
||||
pp::PDF::PrivateAccessibilityTextRunInfo pp_text_run = {
|
||||
text_run.len, PPFloatRectFromRectF(text_run.bounds),
|
||||
static_cast<PP_PrivateDirection>(text_run.direction),
|
||||
PrivateAccessibilityTextStyleInfoFromAccessibilityTextStyleInfo(
|
||||
text_run.style)};
|
||||
pp_text_runs.push_back(std::move(pp_text_run));
|
||||
}
|
||||
return pp_text_runs;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
OutOfProcessInstance::OutOfProcessInstance(PP_Instance instance)
|
||||
@ -846,11 +877,11 @@ void OutOfProcessInstance::SendNextAccessibilityPage(int32_t page_index) {
|
||||
++next_accessibility_page_index_;
|
||||
|
||||
AccessibilityPageInfo page_info;
|
||||
std::vector<pp::PDF::PrivateAccessibilityTextRunInfo> text_runs;
|
||||
std::vector<AccessibilityTextRunInfo> text_runs;
|
||||
std::vector<AccessibilityCharInfo> chars;
|
||||
pp::PDF::PrivateAccessibilityPageObjects page_objects;
|
||||
|
||||
if (!GetAccessibilityInfo(engine(), page_index, page_info, &text_runs, chars,
|
||||
if (!GetAccessibilityInfo(engine(), page_index, page_info, text_runs, chars,
|
||||
&page_objects)) {
|
||||
return;
|
||||
}
|
||||
@ -859,8 +890,10 @@ void OutOfProcessInstance::SendNextAccessibilityPage(int32_t page_index) {
|
||||
PrivateAccessibilityPageInfoFromAccessibilityPageInfo(page_info);
|
||||
std::vector<PP_PrivateAccessibilityCharInfo> pp_chars =
|
||||
PrivateAccessibilityCharInfoFromAccessibilityCharInfo(chars);
|
||||
std::vector<pp::PDF::PrivateAccessibilityTextRunInfo> pp_text_runs =
|
||||
PrivateAccessibilityCharInfoFromAccessibilityTextRunInfo(text_runs);
|
||||
pp::PDF::SetAccessibilityPageInfo(GetPluginInstance(), &pp_page_info,
|
||||
text_runs, pp_chars, page_objects);
|
||||
pp_text_runs, pp_chars, page_objects);
|
||||
|
||||
// Schedule loading the next page.
|
||||
pp::Module::Get()->core()->CallOnMainThread(
|
||||
|
||||
@ -57,6 +57,7 @@ namespace chrome_pdf {
|
||||
class InputEvent;
|
||||
class Thumbnail;
|
||||
class UrlLoader;
|
||||
struct AccessibilityTextRunInfo;
|
||||
struct DocumentAttachmentInfo;
|
||||
struct DocumentMetadata;
|
||||
|
||||
@ -436,10 +437,11 @@ class PDFEngine {
|
||||
virtual uint32_t GetCharUnicode(int page_index, int char_index) = 0;
|
||||
// Given a start char index, find the longest continuous run of text that's
|
||||
// in a single direction and with the same text style. Return a filled out
|
||||
// pp::PDF::PrivateAccessibilityTextRunInfo on success or base::nullopt on
|
||||
// failure. e.g. When |start_char_index| is out of bounds.
|
||||
virtual base::Optional<pp::PDF::PrivateAccessibilityTextRunInfo>
|
||||
GetTextRunInfo(int page_index, int start_char_index) = 0;
|
||||
// AccessibilityTextRunInfo on success or base::nullopt on failure. e.g. When
|
||||
// |start_char_index| is out of bounds.
|
||||
virtual base::Optional<AccessibilityTextRunInfo> GetTextRunInfo(
|
||||
int page_index,
|
||||
int start_char_index) = 0;
|
||||
// For all the links on page |page_index|, get their urls, underlying text
|
||||
// ranges and bounding boxes.
|
||||
virtual std::vector<AccessibilityLinkInfo> GetLinkInfo(int page_index) = 0;
|
||||
|
||||
@ -75,11 +75,11 @@ TEST_F(AccessibilityTest, GetAccessibilityPage) {
|
||||
|
||||
ASSERT_EQ(2, engine->GetNumberOfPages());
|
||||
AccessibilityPageInfo page_info;
|
||||
std::vector<pp::PDF::PrivateAccessibilityTextRunInfo> text_runs;
|
||||
std::vector<AccessibilityTextRunInfo> text_runs;
|
||||
std::vector<AccessibilityCharInfo> chars;
|
||||
pp::PDF::PrivateAccessibilityPageObjects page_objects;
|
||||
ASSERT_TRUE(GetAccessibilityInfo(engine.get(), 0, page_info, &text_runs,
|
||||
chars, &page_objects));
|
||||
ASSERT_TRUE(GetAccessibilityInfo(engine.get(), 0, page_info, text_runs, chars,
|
||||
&page_objects));
|
||||
EXPECT_EQ(0u, page_info.page_index);
|
||||
EXPECT_EQ(gfx::Rect(5, 3, 266, 266), page_info.bounds);
|
||||
EXPECT_EQ(text_runs.size(), page_info.text_run_count);
|
||||
@ -92,13 +92,13 @@ TEST_F(AccessibilityTest, GetAccessibilityPage) {
|
||||
const auto& expected = kExpectedTextRuns[i];
|
||||
EXPECT_EQ(expected.len, text_runs[i].len) << i;
|
||||
EXPECT_FLOAT_EQ(expected.font_size, text_runs[i].style.font_size) << i;
|
||||
EXPECT_FLOAT_EQ(expected.bounds_x, text_runs[i].bounds.point.x) << i;
|
||||
EXPECT_FLOAT_EQ(expected.bounds_y, text_runs[i].bounds.point.y) << i;
|
||||
EXPECT_FLOAT_EQ(expected.bounds_x, text_runs[i].bounds.x()) << i;
|
||||
EXPECT_FLOAT_EQ(expected.bounds_y, text_runs[i].bounds.y()) << i;
|
||||
float expected_bounds_w =
|
||||
GetExpectedBoundsWidth(using_test_fonts, i, expected.bounds_w);
|
||||
EXPECT_FLOAT_EQ(expected_bounds_w, text_runs[i].bounds.size.width) << i;
|
||||
EXPECT_FLOAT_EQ(expected.bounds_h, text_runs[i].bounds.size.height) << i;
|
||||
EXPECT_EQ(PP_PRIVATEDIRECTION_LTR, text_runs[i].direction);
|
||||
EXPECT_FLOAT_EQ(expected_bounds_w, text_runs[i].bounds.width()) << i;
|
||||
EXPECT_FLOAT_EQ(expected.bounds_h, text_runs[i].bounds.height()) << i;
|
||||
EXPECT_EQ(AccessibilityTextDirection::kLeftToRight, text_runs[i].direction);
|
||||
}
|
||||
|
||||
ASSERT_EQ(kExpectedCharCount, chars.size());
|
||||
@ -128,11 +128,11 @@ TEST_F(AccessibilityTest, GetAccessibilityImageInfo) {
|
||||
ASSERT_EQ(1, engine->GetNumberOfPages());
|
||||
|
||||
AccessibilityPageInfo page_info;
|
||||
std::vector<pp::PDF::PrivateAccessibilityTextRunInfo> text_runs;
|
||||
std::vector<AccessibilityTextRunInfo> text_runs;
|
||||
std::vector<AccessibilityCharInfo> chars;
|
||||
pp::PDF::PrivateAccessibilityPageObjects page_objects;
|
||||
ASSERT_TRUE(GetAccessibilityInfo(engine.get(), 0, page_info, &text_runs,
|
||||
chars, &page_objects));
|
||||
ASSERT_TRUE(GetAccessibilityInfo(engine.get(), 0, page_info, text_runs, chars,
|
||||
&page_objects));
|
||||
EXPECT_EQ(0u, page_info.page_index);
|
||||
EXPECT_EQ(gfx::Rect(5, 3, 816, 1056), page_info.bounds);
|
||||
EXPECT_EQ(text_runs.size(), page_info.text_run_count);
|
||||
@ -471,11 +471,11 @@ TEST_F(AccessibilityTest, GetAccessibilityLinkInfo) {
|
||||
ASSERT_EQ(1, engine->GetNumberOfPages());
|
||||
|
||||
AccessibilityPageInfo page_info;
|
||||
std::vector<pp::PDF::PrivateAccessibilityTextRunInfo> text_runs;
|
||||
std::vector<AccessibilityTextRunInfo> text_runs;
|
||||
std::vector<AccessibilityCharInfo> chars;
|
||||
pp::PDF::PrivateAccessibilityPageObjects page_objects;
|
||||
ASSERT_TRUE(GetAccessibilityInfo(engine.get(), 0, page_info, &text_runs,
|
||||
chars, &page_objects));
|
||||
ASSERT_TRUE(GetAccessibilityInfo(engine.get(), 0, page_info, text_runs, chars,
|
||||
&page_objects));
|
||||
EXPECT_EQ(0u, page_info.page_index);
|
||||
EXPECT_EQ(gfx::Rect(5, 3, 533, 266), page_info.bounds);
|
||||
EXPECT_EQ(text_runs.size(), page_info.text_run_count);
|
||||
@ -518,11 +518,11 @@ TEST_F(AccessibilityTest, GetAccessibilityHighlightInfo) {
|
||||
ASSERT_EQ(1, engine->GetNumberOfPages());
|
||||
|
||||
AccessibilityPageInfo page_info;
|
||||
std::vector<pp::PDF::PrivateAccessibilityTextRunInfo> text_runs;
|
||||
std::vector<AccessibilityTextRunInfo> text_runs;
|
||||
std::vector<AccessibilityCharInfo> chars;
|
||||
pp::PDF::PrivateAccessibilityPageObjects page_objects;
|
||||
ASSERT_TRUE(GetAccessibilityInfo(engine.get(), 0, page_info, &text_runs,
|
||||
chars, &page_objects));
|
||||
ASSERT_TRUE(GetAccessibilityInfo(engine.get(), 0, page_info, text_runs, chars,
|
||||
&page_objects));
|
||||
EXPECT_EQ(0u, page_info.page_index);
|
||||
EXPECT_EQ(gfx::Rect(5, 3, 533, 266), page_info.bounds);
|
||||
EXPECT_EQ(text_runs.size(), page_info.text_run_count);
|
||||
@ -576,11 +576,11 @@ TEST_F(AccessibilityTest, GetAccessibilityTextFieldInfo) {
|
||||
ASSERT_EQ(1, engine->GetNumberOfPages());
|
||||
|
||||
AccessibilityPageInfo page_info;
|
||||
std::vector<pp::PDF::PrivateAccessibilityTextRunInfo> text_runs;
|
||||
std::vector<AccessibilityTextRunInfo> text_runs;
|
||||
std::vector<AccessibilityCharInfo> chars;
|
||||
pp::PDF::PrivateAccessibilityPageObjects page_objects;
|
||||
ASSERT_TRUE(GetAccessibilityInfo(engine.get(), 0, page_info, &text_runs,
|
||||
chars, &page_objects));
|
||||
ASSERT_TRUE(GetAccessibilityInfo(engine.get(), 0, page_info, text_runs, chars,
|
||||
&page_objects));
|
||||
EXPECT_EQ(0u, page_info.page_index);
|
||||
EXPECT_EQ(gfx::Rect(5, 3, 400, 400), page_info.bounds);
|
||||
EXPECT_EQ(text_runs.size(), page_info.text_run_count);
|
||||
|
||||
@ -3,6 +3,7 @@
|
||||
// found in the LICENSE file.
|
||||
|
||||
#include "build/build_config.h"
|
||||
#include "pdf/accessibility_structs.h"
|
||||
#include "pdf/pdf_engine.h"
|
||||
#include "pdf/ppapi_migration/input_event_conversions.h"
|
||||
#include "ppapi/c/pp_input_event.h"
|
||||
@ -276,6 +277,27 @@ STATIC_ASSERT_ENUM(PP_TEXTRENDERINGMODE_FILLSTROKECLIP,
|
||||
STATIC_ASSERT_ENUM(PP_TEXTRENDERINGMODE_CLIP, FPDF_TEXTRENDERMODE_CLIP);
|
||||
STATIC_ASSERT_ENUM(PP_TEXTRENDERINGMODE_LAST, FPDF_TEXTRENDERMODE_LAST);
|
||||
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::AccessibilityTextRenderMode::kUnknown,
|
||||
PP_TEXTRENDERINGMODE_UNKNOWN);
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::AccessibilityTextRenderMode::kFill,
|
||||
PP_TEXTRENDERINGMODE_FILL);
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::AccessibilityTextRenderMode::kStroke,
|
||||
PP_TEXTRENDERINGMODE_STROKE);
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::AccessibilityTextRenderMode::kFillStroke,
|
||||
PP_TEXTRENDERINGMODE_FILLSTROKE);
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::AccessibilityTextRenderMode::kInvisible,
|
||||
PP_TEXTRENDERINGMODE_INVISIBLE);
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::AccessibilityTextRenderMode::kFillClip,
|
||||
PP_TEXTRENDERINGMODE_FILLCLIP);
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::AccessibilityTextRenderMode::kStrokeClip,
|
||||
PP_TEXTRENDERINGMODE_STROKECLIP);
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::AccessibilityTextRenderMode::kFillStrokeClip,
|
||||
PP_TEXTRENDERINGMODE_FILLSTROKECLIP);
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::AccessibilityTextRenderMode::kClip,
|
||||
PP_TEXTRENDERINGMODE_CLIP);
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::AccessibilityTextRenderMode::kMaxValue,
|
||||
PP_TEXTRENDERINGMODE_LAST);
|
||||
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::PDFEngine::FormType::kNone, FORMTYPE_NONE);
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::PDFEngine::FormType::kAcroForm,
|
||||
FORMTYPE_ACRO_FORM);
|
||||
@ -296,4 +318,17 @@ STATIC_ASSERT_ENUM(chrome_pdf::kPostScript2, FPDF_PRINTMODE_POSTSCRIPT2);
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::kPostScript3, FPDF_PRINTMODE_POSTSCRIPT3);
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::kEmfWithReducedRasterization,
|
||||
FPDF_PRINTMODE_EMF_IMAGE_MASKS);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::AccessibilityTextDirection::kNone,
|
||||
PP_PRIVATEDIRECTION_NONE);
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::AccessibilityTextDirection::kLeftToRight,
|
||||
PP_PRIVATEDIRECTION_LTR);
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::AccessibilityTextDirection::kRightToLeft,
|
||||
PP_PRIVATEDIRECTION_RTL);
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::AccessibilityTextDirection::kTopToBottom,
|
||||
PP_PRIVATEDIRECTION_TTB);
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::AccessibilityTextDirection::kBottomToTop,
|
||||
PP_PRIVATEDIRECTION_BTT);
|
||||
STATIC_ASSERT_ENUM(chrome_pdf::AccessibilityTextDirection::kMaxValue,
|
||||
PP_PRIVATEDIRECTION_LAST);
|
||||
|
||||
@ -31,6 +31,7 @@
|
||||
#include "gin/public/gin_embedders.h"
|
||||
#include "gin/public/isolate_holder.h"
|
||||
#include "gin/public/v8_platform.h"
|
||||
#include "pdf/accessibility_structs.h"
|
||||
#include "pdf/document_loader_impl.h"
|
||||
#include "pdf/draw_utils/coordinates.h"
|
||||
#include "pdf/draw_utils/shadow.h"
|
||||
@ -2468,8 +2469,9 @@ uint32_t PDFiumEngine::GetCharUnicode(int page_index, int char_index) {
|
||||
return pages_[page_index]->GetCharUnicode(char_index);
|
||||
}
|
||||
|
||||
base::Optional<pp::PDF::PrivateAccessibilityTextRunInfo>
|
||||
PDFiumEngine::GetTextRunInfo(int page_index, int start_char_index) {
|
||||
base::Optional<AccessibilityTextRunInfo> PDFiumEngine::GetTextRunInfo(
|
||||
int page_index,
|
||||
int start_char_index) {
|
||||
DCHECK(PageIndexInBounds(page_index));
|
||||
auto info = pages_[page_index]->GetTextRunInfo(start_char_index);
|
||||
if (!client_->IsPrintPreview() && start_char_index >= 0)
|
||||
|
||||
@ -46,6 +46,7 @@ class MouseInputEvent;
|
||||
class PDFiumDocument;
|
||||
class PDFiumPermissions;
|
||||
class TouchInputEvent;
|
||||
struct AccessibilityTextRunInfo;
|
||||
|
||||
namespace draw_utils {
|
||||
class ShadowMatrix;
|
||||
@ -135,7 +136,7 @@ class PDFiumEngine : public PDFEngine,
|
||||
int GetCharCount(int page_index) override;
|
||||
gfx::RectF GetCharBounds(int page_index, int char_index) override;
|
||||
uint32_t GetCharUnicode(int page_index, int char_index) override;
|
||||
base::Optional<pp::PDF::PrivateAccessibilityTextRunInfo> GetTextRunInfo(
|
||||
base::Optional<AccessibilityTextRunInfo> GetTextRunInfo(
|
||||
int page_index,
|
||||
int start_char_index) override;
|
||||
std::vector<AccessibilityLinkInfo> GetLinkInfo(int page_index) override;
|
||||
|
||||
@ -21,6 +21,7 @@
|
||||
#include "base/strings/string_number_conversions.h"
|
||||
#include "base/strings/string_util.h"
|
||||
#include "base/strings/utf_string_conversions.h"
|
||||
#include "pdf/accessibility_structs.h"
|
||||
#include "pdf/pdfium/pdfium_api_string_buffer_adapter.h"
|
||||
#include "pdf/pdfium/pdfium_engine.h"
|
||||
#include "pdf/pdfium/pdfium_unsupported_features.h"
|
||||
@ -122,7 +123,7 @@ int GetFirstNonUnicodeWhiteSpaceCharIndex(FPDF_TEXTPAGE text_page,
|
||||
return i;
|
||||
}
|
||||
|
||||
PP_PrivateDirection GetDirectionFromAngle(float angle) {
|
||||
AccessibilityTextDirection GetDirectionFromAngle(float angle) {
|
||||
// Rotating the angle by 45 degrees to simplify the conditions statements.
|
||||
// It's like if we rotated the whole cartesian coordinate system like below.
|
||||
// X X
|
||||
@ -140,15 +141,15 @@ PP_PrivateDirection GetDirectionFromAngle(float angle) {
|
||||
angle = fmodf(angle + k45DegreesInRadians, k360DegreesInRadians);
|
||||
// Quadrant I.
|
||||
if (angle >= 0 && angle <= k90DegreesInRadians)
|
||||
return PP_PRIVATEDIRECTION_LTR;
|
||||
return AccessibilityTextDirection::kLeftToRight;
|
||||
// Quadrant II.
|
||||
if (angle > k90DegreesInRadians && angle <= k180DegreesInRadians)
|
||||
return PP_PRIVATEDIRECTION_TTB;
|
||||
return AccessibilityTextDirection::kTopToBottom;
|
||||
// Quadrant III.
|
||||
if (angle > k180DegreesInRadians && angle <= k270DegreesInRadians)
|
||||
return PP_PRIVATEDIRECTION_RTL;
|
||||
return AccessibilityTextDirection::kRightToLeft;
|
||||
// Quadrant IV.
|
||||
return PP_PRIVATEDIRECTION_BTT;
|
||||
return AccessibilityTextDirection::kBottomToTop;
|
||||
}
|
||||
|
||||
void AddCharSizeToAverageCharSize(gfx::SizeF new_size,
|
||||
@ -349,16 +350,16 @@ void PDFiumPage::CalculatePageObjectTextRunBreaks() {
|
||||
|
||||
void PDFiumPage::CalculateTextRunStyleInfo(
|
||||
int char_index,
|
||||
pp::PDF::PrivateAccessibilityTextStyleInfo* style_info) {
|
||||
AccessibilityTextStyleInfo& style_info) {
|
||||
FPDF_TEXTPAGE text_page = GetTextPage();
|
||||
style_info->font_size = FPDFText_GetFontSize(text_page, char_index);
|
||||
style_info.font_size = FPDFText_GetFontSize(text_page, char_index);
|
||||
|
||||
int flags = 0;
|
||||
size_t buffer_size =
|
||||
FPDFText_GetFontInfo(text_page, char_index, nullptr, 0, &flags);
|
||||
if (buffer_size > 0) {
|
||||
PDFiumAPIStringBufferAdapter<std::string> api_string_adapter(
|
||||
&style_info->font_name, buffer_size, true);
|
||||
&style_info.font_name, buffer_size, true);
|
||||
void* data = api_string_adapter.GetData();
|
||||
size_t bytes_written =
|
||||
FPDFText_GetFontInfo(text_page, char_index, data, buffer_size, nullptr);
|
||||
@ -366,22 +367,22 @@ void PDFiumPage::CalculateTextRunStyleInfo(
|
||||
api_string_adapter.Close(bytes_written);
|
||||
}
|
||||
|
||||
style_info->font_weight = FPDFText_GetFontWeight(text_page, char_index);
|
||||
style_info.font_weight = FPDFText_GetFontWeight(text_page, char_index);
|
||||
// As defined in PDF 1.7 table 5.20.
|
||||
constexpr int kFlagItalic = (1 << 6);
|
||||
// Bold text is considered bold when greater than or equal to 700.
|
||||
constexpr int kStandardBoldValue = 700;
|
||||
style_info->is_italic = (flags & kFlagItalic);
|
||||
style_info->is_bold = style_info->font_weight >= kStandardBoldValue;
|
||||
style_info.is_italic = (flags & kFlagItalic);
|
||||
style_info.is_bold = style_info.font_weight >= kStandardBoldValue;
|
||||
unsigned int fill_r;
|
||||
unsigned int fill_g;
|
||||
unsigned int fill_b;
|
||||
unsigned int fill_a;
|
||||
if (FPDFText_GetFillColor(text_page, char_index, &fill_r, &fill_g, &fill_b,
|
||||
&fill_a)) {
|
||||
style_info->fill_color = MakeARGB(fill_a, fill_r, fill_g, fill_b);
|
||||
style_info.fill_color = MakeARGB(fill_a, fill_r, fill_g, fill_b);
|
||||
} else {
|
||||
style_info->fill_color = MakeARGB(0xff, 0, 0, 0);
|
||||
style_info.fill_color = MakeARGB(0xff, 0, 0, 0);
|
||||
}
|
||||
|
||||
unsigned int stroke_r;
|
||||
@ -390,22 +391,24 @@ void PDFiumPage::CalculateTextRunStyleInfo(
|
||||
unsigned int stroke_a;
|
||||
if (FPDFText_GetStrokeColor(text_page, char_index, &stroke_r, &stroke_g,
|
||||
&stroke_b, &stroke_a)) {
|
||||
style_info->stroke_color = MakeARGB(stroke_a, stroke_r, stroke_g, stroke_b);
|
||||
style_info.stroke_color = MakeARGB(stroke_a, stroke_r, stroke_g, stroke_b);
|
||||
} else {
|
||||
style_info->stroke_color = MakeARGB(0xff, 0, 0, 0);
|
||||
style_info.stroke_color = MakeARGB(0xff, 0, 0, 0);
|
||||
}
|
||||
|
||||
int render_mode = FPDFText_GetTextRenderMode(text_page, char_index);
|
||||
DCHECK_GE(render_mode, PP_TEXTRENDERINGMODE_FIRST);
|
||||
DCHECK_LE(render_mode, PP_TEXTRENDERINGMODE_LAST);
|
||||
style_info->render_mode = static_cast<PP_TextRenderingMode>(render_mode);
|
||||
DCHECK_GE(render_mode,
|
||||
static_cast<int>(AccessibilityTextRenderMode::kUnknown));
|
||||
DCHECK_LE(render_mode,
|
||||
static_cast<int>(AccessibilityTextRenderMode::kMaxValue));
|
||||
style_info.render_mode =
|
||||
static_cast<AccessibilityTextRenderMode>(render_mode);
|
||||
}
|
||||
|
||||
bool PDFiumPage::AreTextStyleEqual(
|
||||
int char_index,
|
||||
const pp::PDF::PrivateAccessibilityTextStyleInfo& style) {
|
||||
pp::PDF::PrivateAccessibilityTextStyleInfo char_style;
|
||||
CalculateTextRunStyleInfo(char_index, &char_style);
|
||||
bool PDFiumPage::AreTextStyleEqual(int char_index,
|
||||
const AccessibilityTextStyleInfo& style) {
|
||||
AccessibilityTextStyleInfo char_style;
|
||||
CalculateTextRunStyleInfo(char_index, char_style);
|
||||
return char_style.font_name == style.font_name &&
|
||||
char_style.font_weight == style.font_weight &&
|
||||
char_style.render_mode == style.render_mode &&
|
||||
@ -434,8 +437,8 @@ void PDFiumPage::LogOverlappingAnnotations() {
|
||||
overlap_count, 1, 100, 50);
|
||||
}
|
||||
|
||||
base::Optional<pp::PDF::PrivateAccessibilityTextRunInfo>
|
||||
PDFiumPage::GetTextRunInfo(int start_char_index) {
|
||||
base::Optional<AccessibilityTextRunInfo> PDFiumPage::GetTextRunInfo(
|
||||
int start_char_index) {
|
||||
FPDF_PAGE page = GetPage();
|
||||
FPDF_TEXTPAGE text_page = GetTextPage();
|
||||
int chars_count = FPDFText_CountChars(text_page);
|
||||
@ -451,11 +454,8 @@ PDFiumPage::GetTextRunInfo(int start_char_index) {
|
||||
// If so, |info.len| needs to take the number of characters
|
||||
// iterated into account.
|
||||
DCHECK_GT(actual_start_char_index, start_char_index);
|
||||
pp::PDF::PrivateAccessibilityTextRunInfo info;
|
||||
AccessibilityTextRunInfo info;
|
||||
info.len = chars_count - start_char_index;
|
||||
info.bounds = pp::FloatRect();
|
||||
info.direction = PP_PRIVATEDIRECTION_NONE;
|
||||
info.style.render_mode = PP_TEXTRENDERINGMODE_UNKNOWN;
|
||||
return info;
|
||||
}
|
||||
|
||||
@ -473,8 +473,8 @@ PDFiumPage::GetTextRunInfo(int start_char_index) {
|
||||
int char_index = actual_start_char_index;
|
||||
|
||||
// Set text run's style info from the first character of the text run.
|
||||
pp::PDF::PrivateAccessibilityTextRunInfo info;
|
||||
CalculateTextRunStyleInfo(char_index, &info.style);
|
||||
AccessibilityTextRunInfo info;
|
||||
CalculateTextRunStyleInfo(char_index, info.style);
|
||||
|
||||
gfx::RectF start_char_rect =
|
||||
GetFloatCharRectInPixels(page, text_page, char_index);
|
||||
@ -493,7 +493,7 @@ PDFiumPage::GetTextRunInfo(int start_char_index) {
|
||||
|
||||
// Add first non-space char to text run.
|
||||
text_run_bounds.Union(start_char_rect);
|
||||
PP_PrivateDirection char_direction =
|
||||
AccessibilityTextDirection char_direction =
|
||||
GetDirectionFromAngle(FPDFText_GetCharAngle(text_page, char_index));
|
||||
if (char_index < chars_count)
|
||||
char_index++;
|
||||
@ -589,14 +589,14 @@ PDFiumPage::GetTextRunInfo(int start_char_index) {
|
||||
|
||||
info.len = char_index - start_char_index;
|
||||
info.style.font_size = text_run_font_size;
|
||||
info.bounds = PPFloatRectFromRectF(text_run_bounds);
|
||||
info.bounds = text_run_bounds;
|
||||
// Infer text direction from first and last character of the text run. We
|
||||
// can't base our decision on the character direction, since a character of a
|
||||
// RTL language will have an angle of 0 when not rotated, just like a
|
||||
// character in a LTR language.
|
||||
info.direction = char_index - actual_start_char_index > 1
|
||||
? GetDirectionFromAngle(text_run_angle)
|
||||
: PP_PRIVATEDIRECTION_NONE;
|
||||
: AccessibilityTextDirection::kNone;
|
||||
return info;
|
||||
}
|
||||
|
||||
|
||||
@ -34,6 +34,8 @@ namespace chrome_pdf {
|
||||
|
||||
class PDFiumEngine;
|
||||
class Thumbnail;
|
||||
struct AccessibilityTextRunInfo;
|
||||
struct AccessibilityTextStyleInfo;
|
||||
|
||||
// Wrapper around a page from the document.
|
||||
class PDFiumPage {
|
||||
@ -55,8 +57,7 @@ class PDFiumPage {
|
||||
// Log overlaps between annotations in the page.
|
||||
void LogOverlappingAnnotations();
|
||||
// See definition of PDFEngine::GetTextRunInfo().
|
||||
base::Optional<pp::PDF::PrivateAccessibilityTextRunInfo> GetTextRunInfo(
|
||||
int start_char_index);
|
||||
base::Optional<AccessibilityTextRunInfo> GetTextRunInfo(int start_char_index);
|
||||
// Get a unicode character from the page.
|
||||
uint32_t GetCharUnicode(int char_index);
|
||||
// Get the bounds of a character in page pixels.
|
||||
@ -348,14 +349,12 @@ class PDFiumPage {
|
||||
// broken for page objects such as links and images.
|
||||
void CalculatePageObjectTextRunBreaks();
|
||||
// Set text run style information based on a character of the text run.
|
||||
void CalculateTextRunStyleInfo(
|
||||
int char_index,
|
||||
pp::PDF::PrivateAccessibilityTextStyleInfo* style_info);
|
||||
void CalculateTextRunStyleInfo(int char_index,
|
||||
AccessibilityTextStyleInfo& style_info);
|
||||
// Returns a boolean indicating if the character at index |char_index| has the
|
||||
// same text style as the text run.
|
||||
bool AreTextStyleEqual(
|
||||
int char_index,
|
||||
const pp::PDF::PrivateAccessibilityTextStyleInfo& style);
|
||||
bool AreTextStyleEqual(int char_index,
|
||||
const AccessibilityTextStyleInfo& style);
|
||||
|
||||
// Key : Marked content id for the image element as specified in the
|
||||
// struct tree.
|
||||
|
||||
@ -16,6 +16,7 @@
|
||||
#include "base/test/gtest_util.h"
|
||||
#include "cc/test/pixel_comparator.h"
|
||||
#include "cc/test/pixel_test_utils.h"
|
||||
#include "pdf/accessibility_structs.h"
|
||||
#include "pdf/pdfium/pdfium_engine.h"
|
||||
#include "pdf/pdfium/pdfium_test_base.h"
|
||||
#include "pdf/ppapi_migration/geometry_conversions.h"
|
||||
@ -28,6 +29,7 @@
|
||||
#include "ui/gfx/geometry/rect.h"
|
||||
#include "ui/gfx/geometry/rect_f.h"
|
||||
#include "ui/gfx/range/range.h"
|
||||
#include "ui/gfx/test/gfx_util.h"
|
||||
|
||||
namespace chrome_pdf {
|
||||
|
||||
@ -49,33 +51,14 @@ TEST(PDFiumPageHelperDeathTest, ToPDFiumRotation) {
|
||||
#endif
|
||||
}
|
||||
|
||||
// Clone of pp::PDF::PrivateAccessibilityTextRunInfo.
|
||||
struct ExpectedAccessibilityTextRunInfo {
|
||||
uint32_t len;
|
||||
gfx::RectF bounds;
|
||||
PP_PrivateDirection direction;
|
||||
pp::PDF::PrivateAccessibilityTextStyleInfo style;
|
||||
};
|
||||
|
||||
void CompareTextRuns(
|
||||
const ExpectedAccessibilityTextRunInfo& expected_text_run,
|
||||
const pp::PDF::PrivateAccessibilityTextRunInfo& actual_text_run) {
|
||||
void CompareTextRuns(const AccessibilityTextRunInfo& expected_text_run,
|
||||
const AccessibilityTextRunInfo& actual_text_run) {
|
||||
EXPECT_EQ(expected_text_run.len, actual_text_run.len);
|
||||
|
||||
// Use EXPECT_FLOAT_EQ() here instead of direct gfx::RectF comparisons to
|
||||
// avoid having to deal with float rounding errors.
|
||||
gfx::RectF actual_bounds = RectFFromPPFloatRect(actual_text_run.bounds);
|
||||
EXPECT_FLOAT_EQ(expected_text_run.bounds.x(), actual_bounds.x());
|
||||
EXPECT_FLOAT_EQ(expected_text_run.bounds.y(), actual_bounds.y());
|
||||
EXPECT_FLOAT_EQ(expected_text_run.bounds.width(), actual_bounds.width());
|
||||
EXPECT_FLOAT_EQ(expected_text_run.bounds.height(), actual_bounds.height());
|
||||
|
||||
EXPECT_RECTF_EQ(expected_text_run.bounds, actual_text_run.bounds);
|
||||
EXPECT_EQ(expected_text_run.direction, actual_text_run.direction);
|
||||
|
||||
const pp::PDF::PrivateAccessibilityTextStyleInfo& expected_style =
|
||||
expected_text_run.style;
|
||||
const pp::PDF::PrivateAccessibilityTextStyleInfo& actual_style =
|
||||
actual_text_run.style;
|
||||
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);
|
||||
@ -285,7 +268,7 @@ TEST_F(PDFiumPageTextTest, TestTextRunBounds) {
|
||||
constexpr int kFirstRunStartIndex = 0;
|
||||
constexpr int kFirstRunEndIndex = 20;
|
||||
constexpr int kPageIndex = 0;
|
||||
base::Optional<pp::PDF::PrivateAccessibilityTextRunInfo> text_run_info_1 =
|
||||
base::Optional<AccessibilityTextRunInfo> text_run_info_1 =
|
||||
engine->GetTextRunInfo(kPageIndex, kFirstRunStartIndex);
|
||||
ASSERT_TRUE(text_run_info_1.has_value());
|
||||
|
||||
@ -294,7 +277,7 @@ TEST_F(PDFiumPageTextTest, TestTextRunBounds) {
|
||||
|
||||
EXPECT_TRUE(base::IsUnicodeWhitespace(
|
||||
engine->GetCharUnicode(kPageIndex, kFirstRunStartIndex)));
|
||||
gfx::RectF text_run_bounds = RectFFromPPFloatRect(actual_text_run_1.bounds);
|
||||
gfx::RectF text_run_bounds = actual_text_run_1.bounds;
|
||||
EXPECT_TRUE(text_run_bounds.Contains(
|
||||
engine->GetCharBounds(kPageIndex, kFirstRunStartIndex)));
|
||||
|
||||
@ -321,7 +304,7 @@ TEST_F(PDFiumPageTextTest, TestTextRunBounds) {
|
||||
// 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.
|
||||
base::Optional<pp::PDF::PrivateAccessibilityTextRunInfo> text_run_info_2 =
|
||||
base::Optional<AccessibilityTextRunInfo> text_run_info_2 =
|
||||
engine->GetTextRunInfo(kPageIndex, kSecondRunStartIndex);
|
||||
ASSERT_TRUE(text_run_info_2.has_value());
|
||||
|
||||
@ -330,7 +313,7 @@ TEST_F(PDFiumPageTextTest, TestTextRunBounds) {
|
||||
|
||||
EXPECT_FALSE(base::IsUnicodeWhitespace(
|
||||
engine->GetCharUnicode(kPageIndex, kSecondRunStartIndex)));
|
||||
text_run_bounds = RectFFromPPFloatRect(actual_text_run_2.bounds);
|
||||
text_run_bounds = actual_text_run_2.bounds;
|
||||
EXPECT_TRUE(text_run_bounds.Contains(
|
||||
engine->GetCharBounds(kPageIndex, kSecondRunStartIndex)));
|
||||
|
||||
@ -358,38 +341,39 @@ TEST_F(PDFiumPageTextTest, GetTextRunInfo) {
|
||||
|
||||
int current_char_index = 0;
|
||||
|
||||
pp::PDF::PrivateAccessibilityTextStyleInfo expected_style_1 = {
|
||||
AccessibilityTextStyleInfo expected_style_1 = {
|
||||
"Times-Roman",
|
||||
0,
|
||||
PP_TEXTRENDERINGMODE_FILL,
|
||||
AccessibilityTextRenderMode::kFill,
|
||||
12,
|
||||
0xff000000,
|
||||
0xff000000,
|
||||
false,
|
||||
false};
|
||||
pp::PDF::PrivateAccessibilityTextStyleInfo expected_style_2 = {
|
||||
"Helvetica", 0, PP_TEXTRENDERINGMODE_FILL, 16, 0xff000000, 0xff000000,
|
||||
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.
|
||||
ExpectedAccessibilityTextRunInfo expected_text_runs[] = {
|
||||
AccessibilityTextRunInfo expected_text_runs[] = {
|
||||
{7, gfx::RectF(26.666666f, 189.333333f, 38.666672f, 13.333344f),
|
||||
PP_PrivateDirection::PP_PRIVATEDIRECTION_LTR, expected_style_1},
|
||||
AccessibilityTextDirection::kLeftToRight, expected_style_1},
|
||||
{16, gfx::RectF(70.666664f, 189.333333f, 108.0f, 14.666672f),
|
||||
PP_PrivateDirection::PP_PRIVATEDIRECTION_LTR, expected_style_1},
|
||||
AccessibilityTextDirection::kLeftToRight, expected_style_1},
|
||||
{20, gfx::RectF(181.333333f, 189.333333f, 117.333333f, 14.666672f),
|
||||
PP_PrivateDirection::PP_PRIVATEDIRECTION_LTR, expected_style_1},
|
||||
AccessibilityTextDirection::kLeftToRight, expected_style_1},
|
||||
{9, gfx::RectF(28.0f, 117.33334f, 89.333328f, 20.0f),
|
||||
PP_PrivateDirection::PP_PRIVATEDIRECTION_LTR, expected_style_2},
|
||||
AccessibilityTextDirection::kLeftToRight, expected_style_2},
|
||||
{15, gfx::RectF(126.66666f, 117.33334f, 137.33334f, 20.0f),
|
||||
PP_PrivateDirection::PP_PRIVATEDIRECTION_LTR, expected_style_2},
|
||||
AccessibilityTextDirection::kLeftToRight, expected_style_2},
|
||||
{20, gfx::RectF(266.66666f, 118.66666f, 169.33334f, 18.666664f),
|
||||
PP_PrivateDirection::PP_PRIVATEDIRECTION_LTR, expected_style_2},
|
||||
AccessibilityTextDirection::kLeftToRight, expected_style_2},
|
||||
{5, gfx::RectF(28.0f, 65.333336f, 40.0f, 18.666664f),
|
||||
PP_PrivateDirection::PP_PRIVATEDIRECTION_LTR, expected_style_2},
|
||||
AccessibilityTextDirection::kLeftToRight, expected_style_2},
|
||||
{17, gfx::RectF(77.333336f, 64.0f, 160.0f, 20.0f),
|
||||
PP_PrivateDirection::PP_PRIVATEDIRECTION_LTR, expected_style_2}};
|
||||
AccessibilityTextDirection::kLeftToRight, expected_style_2}};
|
||||
|
||||
if (UsingTestFonts()) {
|
||||
expected_text_runs[4].bounds =
|
||||
@ -401,8 +385,8 @@ TEST_F(PDFiumPageTextTest, GetTextRunInfo) {
|
||||
}
|
||||
|
||||
// Test negative char index returns nullopt
|
||||
base::Optional<pp::PDF::PrivateAccessibilityTextRunInfo>
|
||||
text_run_info_result = engine->GetTextRunInfo(0, -1);
|
||||
base::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
|
||||
@ -430,20 +414,21 @@ TEST_F(PDFiumPageTextTest, TestHighlightTextRunInfo) {
|
||||
ASSERT_EQ(1, engine->GetNumberOfPages());
|
||||
|
||||
// Highlights span across text run indices 0, 2 and 3.
|
||||
static const pp::PDF::PrivateAccessibilityTextStyleInfo kExpectedStyle = {
|
||||
"Helvetica", 0, PP_TEXTRENDERINGMODE_FILL, 16, 0xff000000, 0xff000000,
|
||||
static const AccessibilityTextStyleInfo kExpectedStyle = {
|
||||
"Helvetica", 0, AccessibilityTextRenderMode::kFill,
|
||||
16, 0xff000000, 0xff000000,
|
||||
false, false};
|
||||
ExpectedAccessibilityTextRunInfo expected_text_runs[] = {
|
||||
AccessibilityTextRunInfo expected_text_runs[] = {
|
||||
{5, gfx::RectF(1.3333334f, 198.66667f, 46.666668f, 14.666672f),
|
||||
PP_PrivateDirection::PP_PRIVATEDIRECTION_LTR, kExpectedStyle},
|
||||
AccessibilityTextDirection::kLeftToRight, kExpectedStyle},
|
||||
{7, gfx::RectF(50.666668f, 198.66667f, 47.999996f, 17.333328f),
|
||||
PP_PrivateDirection::PP_PRIVATEDIRECTION_LTR, kExpectedStyle},
|
||||
AccessibilityTextDirection::kLeftToRight, kExpectedStyle},
|
||||
{7, gfx::RectF(106.66666f, 198.66667f, 73.333336f, 18.666672f),
|
||||
PP_PrivateDirection::PP_PRIVATEDIRECTION_LTR, kExpectedStyle},
|
||||
AccessibilityTextDirection::kLeftToRight, kExpectedStyle},
|
||||
{2, gfx::RectF(181.33333f, 202.66667f, 16.0f, 14.66667f),
|
||||
PP_PrivateDirection::PP_PRIVATEDIRECTION_NONE, kExpectedStyle},
|
||||
AccessibilityTextDirection::kNone, kExpectedStyle},
|
||||
{2, gfx::RectF(198.66667f, 202.66667f, 21.333328f, 10.666672f),
|
||||
PP_PrivateDirection::PP_PRIVATEDIRECTION_LTR, kExpectedStyle}};
|
||||
AccessibilityTextDirection::kLeftToRight, kExpectedStyle}};
|
||||
|
||||
if (UsingTestFonts()) {
|
||||
expected_text_runs[2].bounds =
|
||||
@ -454,8 +439,8 @@ TEST_F(PDFiumPageTextTest, TestHighlightTextRunInfo) {
|
||||
|
||||
int current_char_index = 0;
|
||||
for (const auto& expected_text_run : expected_text_runs) {
|
||||
base::Optional<pp::PDF::PrivateAccessibilityTextRunInfo>
|
||||
text_run_info_result = engine->GetTextRunInfo(0, current_char_index);
|
||||
base::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);
|
||||
|
||||
Reference in New Issue
Block a user