blob: b69180a0ce0b1db6cd4ffba31540d10ec5c8f90e [file] [log] [blame]
// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "pdf/pdf_ink_module.h"
#include <stddef.h>
#include <algorithm>
#include <limits>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
#include "base/check.h"
#include "base/containers/fixed_flat_map.h"
#include "base/feature_list.h"
#include "base/ranges/algorithm.h"
#include "base/time/time.h"
#include "base/values.h"
#include "pdf/draw_utils/page_boundary_intersect.h"
#include "pdf/ink/ink_affine_transform.h"
#include "pdf/ink/ink_brush.h"
#include "pdf/ink/ink_in_progress_stroke.h"
#include "pdf/ink/ink_intersects.h"
#include "pdf/ink/ink_modeled_shape_view.h"
#include "pdf/ink/ink_rect.h"
#include "pdf/ink/ink_skia_renderer.h"
#include "pdf/ink/ink_stroke.h"
#include "pdf/ink/ink_stroke_input_batch.h"
#include "pdf/ink/ink_stroke_input_batch_view.h"
#include "pdf/input_utils.h"
#include "pdf/pdf_features.h"
#include "pdf/pdf_ink_brush.h"
#include "pdf/pdf_ink_cursor.h"
#include "pdf/pdf_ink_transform.h"
#include "third_party/blink/public/common/input/web_input_event.h"
#include "third_party/blink/public/common/input/web_mouse_event.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "third_party/skia/include/core/SkCanvas.h"
#include "third_party/skia/include/core/SkColor.h"
#include "ui/gfx/geometry/point_f.h"
#include "ui/gfx/geometry/rect.h"
#include "ui/gfx/geometry/rect_conversions.h"
#include "ui/gfx/geometry/rect_f.h"
#include "ui/gfx/geometry/skia_conversions.h"
namespace chrome_pdf {
namespace {
PdfInkModule::StrokeInputPoints GetStrokePointsForTesting( // IN-TEST
const InkStrokeInputBatchView& input_batch) {
PdfInkModule::StrokeInputPoints stroke_points;
stroke_points.reserve(input_batch.Size());
for (size_t i = 0; i < input_batch.Size(); ++i) {
InkStrokeInput stroke_input = input_batch.Get(i);
stroke_points.emplace_back(stroke_input.position.x,
stroke_input.position.y);
}
return stroke_points;
}
// Default to a black pen brush.
std::unique_ptr<PdfInkBrush> CreateDefaultBrush() {
const PdfInkBrush::Params kDefaultBrushParams = {SK_ColorBLACK, 1.0f};
return std::make_unique<PdfInkBrush>(PdfInkBrush::Type::kPen,
kDefaultBrushParams);
}
// Check if `color` is a valid color value within range.
void CheckColorIsWithinRange(int color) {
CHECK_GE(color, 0);
CHECK_LE(color, 255);
}
InkRect GetEraserRect(const gfx::PointF& center, int distance_to_center) {
return {
center.x() - distance_to_center,
center.y() - distance_to_center,
center.x() + distance_to_center,
center.y() + distance_to_center,
};
}
void UnionInkRects(std::optional<InkRect>& result_rect,
const InkRect& new_rect) {
if (result_rect.has_value()) {
auto& value = result_rect.value();
value.x_min = std::min(value.x_min, new_rect.x_min);
value.y_min = std::min(value.y_min, new_rect.y_min);
value.x_max = std::max(value.x_max, new_rect.x_max);
value.y_max = std::max(value.y_max, new_rect.y_max);
} else {
result_rect = new_rect;
}
}
gfx::Rect InkRectToEnclosingGfxRect(const InkRect& rect) {
const float x = rect.x_min;
const float y = rect.y_min;
const float width = rect.x_max - x;
const float height = rect.y_max - y;
return gfx::ToEnclosingRect(gfx::RectF(x, y, width, height));
}
SkRect GetDrawPageClipRect(const gfx::Rect& content_rect,
const gfx::Vector2dF& origin_offset) {
gfx::RectF clip_rect(content_rect);
clip_rect.Offset(origin_offset);
return gfx::RectFToSkRect(clip_rect);
}
} // namespace
PdfInkModule::PdfInkModule(Client& client) : client_(client) {
CHECK(base::FeatureList::IsEnabled(features::kPdfInk2));
CHECK(is_drawing_stroke());
drawing_stroke_state().brush = CreateDefaultBrush();
}
PdfInkModule::~PdfInkModule() = default;
void PdfInkModule::Draw(SkCanvas& canvas) {
auto skia_renderer = InkSkiaRenderer::Create();
const gfx::Vector2dF origin_offset = client_->GetViewportOriginOffset();
const PageOrientation rotation = client_->GetOrientation();
const float zoom = client_->GetZoom();
for (const auto& [page_index, page_strokes] : strokes_) {
if (!client_->IsPageVisible(page_index)) {
continue;
}
// Use an updated transform based on the page and its position in the
// viewport.
const gfx::Rect content_rect = client_->GetPageContentsRect(page_index);
const InkAffineTransform transform =
GetInkRenderTransform(origin_offset, rotation, content_rect, zoom);
if (draw_render_transform_callback_for_testing_) {
draw_render_transform_callback_for_testing_.Run(transform);
}
SkAutoCanvasRestore save_restore(&canvas, /*doSave=*/true);
canvas.clipRect(GetDrawPageClipRect(content_rect, origin_offset));
for (const auto& finished_stroke : page_strokes) {
if (!finished_stroke.should_draw) {
continue;
}
bool success =
skia_renderer->Draw(*finished_stroke.stroke, transform, canvas);
CHECK(success);
}
}
auto in_progress_stroke = CreateInProgressStrokeSegmentsFromInputs();
if (!in_progress_stroke.empty()) {
DrawingStrokeState& state = drawing_stroke_state();
const gfx::Rect content_rect =
client_->GetPageContentsRect(state.page_index);
const InkAffineTransform transform =
GetInkRenderTransform(origin_offset, rotation, content_rect, zoom);
if (draw_render_transform_callback_for_testing_) {
draw_render_transform_callback_for_testing_.Run(transform);
}
SkAutoCanvasRestore save_restore(&canvas, /*doSave=*/true);
canvas.clipRect(GetDrawPageClipRect(content_rect, origin_offset));
for (const auto& segment : in_progress_stroke) {
bool success = skia_renderer->Draw(*segment, transform, canvas);
CHECK(success);
}
}
}
bool PdfInkModule::HandleInputEvent(const blink::WebInputEvent& event) {
if (!enabled()) {
return false;
}
switch (event.GetType()) {
case blink::WebInputEvent::Type::kMouseDown:
return OnMouseDown(static_cast<const blink::WebMouseEvent&>(event));
case blink::WebInputEvent::Type::kMouseUp:
return OnMouseUp(static_cast<const blink::WebMouseEvent&>(event));
case blink::WebInputEvent::Type::kMouseMove:
return OnMouseMove(static_cast<const blink::WebMouseEvent&>(event));
default:
return false;
}
}
bool PdfInkModule::OnMessage(const base::Value::Dict& message) {
using MessageHandler = void (PdfInkModule::*)(const base::Value::Dict&);
static constexpr auto kMessageHandlers =
base::MakeFixedFlatMap<std::string_view, MessageHandler>({
{"annotationRedo", &PdfInkModule::HandleAnnotationRedoMessage},
{"annotationUndo", &PdfInkModule::HandleAnnotationUndoMessage},
{"setAnnotationBrush",
&PdfInkModule::HandleSetAnnotationBrushMessage},
{"setAnnotationMode", &PdfInkModule::HandleSetAnnotationModeMessage},
});
auto it = kMessageHandlers.find(*message.FindString("type"));
if (it == kMessageHandlers.end()) {
return false;
}
MessageHandler handler = it->second;
(this->*handler)(message);
return true;
}
void PdfInkModule::OnGeometryChanged() {
MaybeSetCursor();
}
const PdfInkBrush* PdfInkModule::GetPdfInkBrushForTesting() const {
return is_drawing_stroke() ? drawing_stroke_state().brush.get() : nullptr;
}
std::optional<float> PdfInkModule::GetEraserSizeForTesting() const {
if (is_erasing_stroke()) {
return erasing_stroke_state().eraser_size;
}
return std::nullopt;
}
PdfInkModule::DocumentStrokeInputPointsMap
PdfInkModule::GetStrokesInputPositionsForTesting() const {
DocumentStrokeInputPointsMap all_strokes_points;
for (const auto& [page_index, strokes] : strokes_) {
for (const auto& stroke : strokes) {
all_strokes_points[page_index].push_back(
GetStrokePointsForTesting(stroke.stroke->GetInputs())); // IN-TEST
}
}
return all_strokes_points;
}
PdfInkModule::DocumentStrokeInputPointsMap
PdfInkModule::GetVisibleStrokesInputPositionsForTesting() const {
DocumentStrokeInputPointsMap all_strokes_points;
for (const auto& [page_index, strokes] : strokes_) {
for (const auto& stroke : strokes) {
if (!stroke.should_draw) {
continue;
}
all_strokes_points[page_index].push_back(
GetStrokePointsForTesting(stroke.stroke->GetInputs())); // IN-TEST
}
}
return all_strokes_points;
}
void PdfInkModule::SetDrawRenderTransformCallbackForTesting(
RenderTransformCallback callback) {
draw_render_transform_callback_for_testing_ = std::move(callback);
}
bool PdfInkModule::OnMouseDown(const blink::WebMouseEvent& event) {
CHECK(enabled());
blink::WebMouseEvent normalized_event = NormalizeMouseEvent(event);
if (normalized_event.button != blink::WebPointerProperties::Button::kLeft) {
return false;
}
gfx::PointF position = normalized_event.PositionInWidget();
return is_drawing_stroke() ? StartStroke(position)
: StartEraseStroke(position);
}
bool PdfInkModule::OnMouseUp(const blink::WebMouseEvent& event) {
CHECK(enabled());
if (event.button != blink::WebPointerProperties::Button::kLeft) {
return false;
}
gfx::PointF position = event.PositionInWidget();
return is_drawing_stroke() ? FinishStroke(position)
: FinishEraseStroke(position);
}
bool PdfInkModule::OnMouseMove(const blink::WebMouseEvent& event) {
CHECK(enabled());
gfx::PointF position = event.PositionInWidget();
return is_drawing_stroke() ? ContinueStroke(position)
: ContinueEraseStroke(position);
}
bool PdfInkModule::StartStroke(const gfx::PointF& position) {
int page_index = client_->VisiblePageIndexFromPoint(position);
if (page_index < 0) {
// Do not draw when not on a page.
return false;
}
CHECK(is_drawing_stroke());
DrawingStrokeState& state = drawing_stroke_state();
gfx::PointF page_position =
ConvertEventPositionToCanonicalPosition(position, page_index);
CHECK(!state.start_time.has_value());
state.start_time = base::Time::Now();
state.page_index = page_index;
// Start of the first segment of a stroke.
StrokeInputSegment segment;
segment.push_back({
.position = InkPoint{page_position.x(), page_position.y()},
.elapsed_time_seconds = 0,
});
state.inputs.push_back(std::move(segment));
// Invalidate area around this one point.
client_->Invalidate(state.brush->GetInvalidateArea(position, position));
std::optional<PdfInkUndoRedoModel::DiscardedDrawCommands> discards =
undo_redo_model_.StartDraw();
CHECK(discards.has_value());
ApplyUndoRedoDiscards(discards.value());
// Remember this location to support invalidating all of the area between
// this location and the next position.
CHECK(!state.input_last_event_position.has_value());
state.input_last_event_position = position;
return true;
}
bool PdfInkModule::ContinueStroke(const gfx::PointF& position) {
CHECK(is_drawing_stroke());
DrawingStrokeState& state = drawing_stroke_state();
if (!state.start_time.has_value()) {
// Ignore when not drawing.
return false;
}
CHECK(state.input_last_event_position.has_value());
const gfx::PointF last_position = state.input_last_event_position.value();
if (position == last_position) {
// Since the position did not change, do nothing.
return true;
}
const int page_index = client_->VisiblePageIndexFromPoint(position);
const int last_page_index = client_->VisiblePageIndexFromPoint(last_position);
if (page_index != state.page_index && last_page_index != state.page_index) {
// If `position` is outside the page, and so was `last_position`, then just
// update `last_position` and treat the event as handled.
state.input_last_event_position = position;
return true;
}
CHECK_GE(state.page_index, 0);
if (page_index != state.page_index) {
// `position` is outside the page, and `last_position` is inside the page.
CHECK_EQ(last_page_index, state.page_index);
const gfx::PointF boundary_position = CalculatePageBoundaryIntersectPoint(
client_->GetPageContentsRect(state.page_index), last_position,
position);
if (boundary_position != last_position) {
// Record the last point before leaving the page, if `last_position` was
// not already on the page boundary.
RecordStrokePosition(boundary_position);
client_->Invalidate(
state.brush->GetInvalidateArea(last_position, boundary_position));
}
// Remember `position` for use in the next event and treat event as handled.
state.input_last_event_position = position;
return true;
}
gfx::PointF invalidation_position = last_position;
if (last_page_index != state.page_index) {
// If the stroke left the page and is now re-entering, then start a new
// segment.
CHECK(!state.inputs.back().empty());
state.inputs.push_back(StrokeInputSegment());
const gfx::PointF boundary_position = CalculatePageBoundaryIntersectPoint(
client_->GetPageContentsRect(state.page_index), position,
last_position);
if (boundary_position != position) {
// Record the first point after entering the page.
RecordStrokePosition(boundary_position);
invalidation_position = boundary_position;
}
}
RecordStrokePosition(position);
// Invalidate area covering a straight line between this position and the
// previous one.
client_->Invalidate(
state.brush->GetInvalidateArea(position, invalidation_position));
// Remember `position` for use in the next event.
state.input_last_event_position = position;
return true;
}
bool PdfInkModule::FinishStroke(const gfx::PointF& position) {
// Process `position` as though it was the last point of movement first,
// before moving on to various bookkeeping tasks.
if (!ContinueStroke(position)) {
return false;
}
CHECK(is_drawing_stroke());
DrawingStrokeState& state = drawing_stroke_state();
auto in_progress_stroke_segments = CreateInProgressStrokeSegmentsFromInputs();
if (!in_progress_stroke_segments.empty()) {
CHECK_GE(state.page_index, 0);
for (const auto& segment : in_progress_stroke_segments) {
size_t id = stroke_id_generator_.GetIdAndAdvance();
strokes_[state.page_index].push_back(
FinishedStrokeState(segment->CopyToStroke(), id));
bool undo_redo_success = undo_redo_model_.Draw(id);
CHECK(undo_redo_success);
}
}
client_->StrokeFinished();
bool undo_redo_success = undo_redo_model_.FinishDraw();
CHECK(undo_redo_success);
// Reset `state` now that the stroke operation is done.
state.inputs.clear();
state.start_time = std::nullopt;
state.page_index = -1;
state.input_last_event_position.reset();
return true;
}
bool PdfInkModule::StartEraseStroke(const gfx::PointF& position) {
int page_index = client_->VisiblePageIndexFromPoint(position);
if (page_index < 0) {
// Do not erase when not on a page.
return false;
}
CHECK(is_erasing_stroke());
EraserState& state = erasing_stroke_state();
CHECK(!state.erasing);
state.erasing = true;
std::optional<PdfInkUndoRedoModel::DiscardedDrawCommands> discards =
undo_redo_model_.StartErase();
CHECK(discards.has_value());
ApplyUndoRedoDiscards(discards.value());
state.did_erase_strokes = EraseHelper(position, page_index);
return true;
}
bool PdfInkModule::ContinueEraseStroke(const gfx::PointF& position) {
CHECK(is_erasing_stroke());
EraserState& state = erasing_stroke_state();
if (!state.erasing) {
return false;
}
int page_index = client_->VisiblePageIndexFromPoint(position);
if (page_index < 0) {
// Do nothing when the eraser tool is in use, but the event position is
// off-page. Treat the event as handled to be consistent with
// ContinueStroke(), and so that nothing else attempts to handle this event.
return true;
}
state.did_erase_strokes |= EraseHelper(position, page_index);
return true;
}
bool PdfInkModule::FinishEraseStroke(const gfx::PointF& position) {
// Process `position` as though it was the last point of movement first,
// before moving on to various bookkeeping tasks.
if (!ContinueEraseStroke(position)) {
return false;
}
bool undo_redo_success = undo_redo_model_.FinishErase();
CHECK(undo_redo_success);
CHECK(is_erasing_stroke());
EraserState& state = erasing_stroke_state();
if (state.did_erase_strokes) {
client_->StrokeFinished();
}
// Reset `state` now that the erase operation is done.
state.erasing = false;
state.did_erase_strokes = false;
return true;
}
bool PdfInkModule::EraseHelper(const gfx::PointF& position, int page_index) {
CHECK_GE(page_index, 0);
auto it = strokes_.find(page_index);
if (it == strokes_.end()) {
// Nothing to erase on the page.
return false;
}
gfx::PointF canonical_position =
ConvertEventPositionToCanonicalPosition(position, page_index);
const InkRect eraser_rect =
GetEraserRect(canonical_position, erasing_stroke_state().eraser_size);
std::optional<InkRect> invalidate_rect;
for (auto& stroke : it->second) {
if (!stroke.should_draw) {
// Already erased.
continue;
}
// No transform needed, as `eraser_rect` is already using transformed
// coordinates from `canonical_position`.
static constexpr InkAffineTransform kIdentityTransform = {1, 0, 0, 0, 1, 0};
const InkModeledShapeView& shape = stroke.stroke->GetShape();
if (!InkIntersectsRectWithShape(eraser_rect, shape, kIdentityTransform)) {
continue;
}
stroke.should_draw = false;
UnionInkRects(invalidate_rect, shape.Bounds());
bool undo_redo_success = undo_redo_model_.Erase(stroke.id);
CHECK(undo_redo_success);
}
if (!invalidate_rect.has_value()) {
return false;
}
// If `invalidate_rect` has a value, then something got erased.
client_->Invalidate(InkRectToEnclosingGfxRect(invalidate_rect.value()));
return true;
}
void PdfInkModule::HandleAnnotationRedoMessage(
const base::Value::Dict& message) {
ApplyUndoRedoCommands(undo_redo_model_.Redo());
}
void PdfInkModule::HandleAnnotationUndoMessage(
const base::Value::Dict& message) {
ApplyUndoRedoCommands(undo_redo_model_.Undo());
}
void PdfInkModule::HandleSetAnnotationBrushMessage(
const base::Value::Dict& message) {
CHECK(enabled_);
const base::Value::Dict* data = message.FindDict("data");
CHECK(data);
float size = base::checked_cast<float>(data->FindDouble("size").value());
PdfInkBrush::CheckToolSizeIsInRange(size);
const std::string& brush_type_string = *data->FindString("type");
if (brush_type_string == "eraser") {
auto& eraser_state = current_tool_state_.emplace<EraserState>();
eraser_state.eraser_size = size;
MaybeSetCursor();
return;
}
// All brush types except the eraser should have a color and size.
const base::Value::Dict* color = data->FindDict("color");
CHECK(color);
int color_r = color->FindInt("r").value();
int color_g = color->FindInt("g").value();
int color_b = color->FindInt("b").value();
CheckColorIsWithinRange(color_r);
CheckColorIsWithinRange(color_g);
CheckColorIsWithinRange(color_b);
PdfInkBrush::Params params = {
.color = SkColorSetRGB(color_r, color_g, color_b),
.size = size,
};
std::optional<PdfInkBrush::Type> brush_type =
PdfInkBrush::StringToType(brush_type_string);
CHECK(brush_type.has_value());
current_tool_state_.emplace<DrawingStrokeState>();
drawing_stroke_state().brush =
std::make_unique<PdfInkBrush>(brush_type.value(), params);
MaybeSetCursor();
}
void PdfInkModule::HandleSetAnnotationModeMessage(
const base::Value::Dict& message) {
enabled_ = message.FindBool("enable").value();
MaybeSetCursor();
}
std::vector<std::unique_ptr<InkInProgressStroke>>
PdfInkModule::CreateInProgressStrokeSegmentsFromInputs() const {
if (!is_drawing_stroke()) {
return {};
}
const DrawingStrokeState& state = drawing_stroke_state();
std::vector<std::unique_ptr<InkInProgressStroke>> stroke_segments;
stroke_segments.reserve(state.inputs.size());
for (size_t segment_number = 0; const auto& segment : state.inputs) {
++segment_number;
if (segment.empty()) {
// Only the last segment can possibly be empty, if the stroke left the
// page but never returned back in.
CHECK_EQ(segment_number, state.inputs.size());
break;
}
auto stroke = InkInProgressStroke::Create();
// TODO(crbug.com/339682315): This should not fail with the wrapper.
if (!stroke) {
return {};
}
auto input_batch = InkStrokeInputBatch::Create(segment);
CHECK(input_batch);
stroke->Start(state.brush->GetInkBrush());
bool enqueue_results = stroke->EnqueueInputs(input_batch.get(), nullptr);
CHECK(enqueue_results);
stroke->FinishInputs();
bool update_results = stroke->UpdateShape(0);
CHECK(update_results);
stroke_segments.push_back(std::move(stroke));
}
return stroke_segments;
}
gfx::PointF PdfInkModule::ConvertEventPositionToCanonicalPosition(
const gfx::PointF& position,
int page_index) {
// If the page is visible at `position`, then its rect must not be empty.
auto page_contents_rect = client_->GetPageContentsRect(page_index);
CHECK(!page_contents_rect.IsEmpty());
return EventPositionToCanonicalPosition(position, client_->GetOrientation(),
page_contents_rect,
client_->GetZoom());
}
void PdfInkModule::RecordStrokePosition(const gfx::PointF& position) {
CHECK(is_drawing_stroke());
DrawingStrokeState& state = drawing_stroke_state();
gfx::PointF canonical_position =
ConvertEventPositionToCanonicalPosition(position, state.page_index);
base::TimeDelta time_diff = base::Time::Now() - state.start_time.value();
state.inputs.back().push_back({
.position = InkPoint{canonical_position.x(), canonical_position.y()},
.elapsed_time_seconds = static_cast<float>(time_diff.InSecondsF()),
});
}
void PdfInkModule::ApplyUndoRedoCommands(
const PdfInkUndoRedoModel::Commands& commands) {
switch (PdfInkUndoRedoModel::GetCommandsType(commands)) {
case PdfInkUndoRedoModel::CommandsType::kNone: {
return;
}
case PdfInkUndoRedoModel::CommandsType::kDraw: {
ApplyUndoRedoCommandsHelper(
PdfInkUndoRedoModel::GetDrawCommands(commands).value(),
/*should_draw=*/true);
return;
}
case PdfInkUndoRedoModel::CommandsType::kErase: {
ApplyUndoRedoCommandsHelper(
PdfInkUndoRedoModel::GetEraseCommands(commands).value(),
/*should_draw=*/false);
return;
}
}
}
void PdfInkModule::ApplyUndoRedoCommandsHelper(std::set<size_t> ids,
bool should_draw) {
CHECK(!strokes_.empty());
CHECK(!ids.empty());
for (auto& [page_index, page_ink_strokes] : strokes_) {
std::vector<size_t> page_ids;
page_ids.reserve(page_ink_strokes.size());
for (const auto& stroke : page_ink_strokes) {
page_ids.push_back(stroke.id);
}
std::vector<size_t> ids_to_apply_command;
base::ranges::set_intersection(ids, page_ids,
std::back_inserter(ids_to_apply_command));
if (ids_to_apply_command.empty()) {
continue;
}
// `it` is always valid, because all the IDs in `ids_to_apply_command` are
// in `page_ink_strokes`.
auto it = page_ink_strokes.begin();
std::optional<InkRect> invalidate_rect;
for (size_t id : ids_to_apply_command) {
it = base::ranges::lower_bound(
it, page_ink_strokes.end(), id, {},
[](const FinishedStrokeState& state) { return state.id; });
auto& stroke = *it;
CHECK_NE(stroke.should_draw, should_draw);
stroke.should_draw = should_draw;
UnionInkRects(invalidate_rect, stroke.stroke->GetShape().Bounds());
ids.erase(id);
}
CHECK(invalidate_rect.has_value());
client_->Invalidate(InkRectToEnclosingGfxRect(invalidate_rect.value()));
if (ids.empty()) {
return; // Return early if there is nothing left to apply.
}
}
}
void PdfInkModule::ApplyUndoRedoDiscards(
const PdfInkUndoRedoModel::DiscardedDrawCommands& discards) {
if (discards.empty()) {
return;
}
// Although `discards` contain the full set of IDs to discard, only the first
// ID is needed here. This is because the `page_ink_strokes` values in
// `strokes_` are in sorted order. All elements in `page_ink_strokes` with the
// first ID or larger IDs can be discarded.
const size_t start_id = *discards.begin();
for (auto& [page_index, page_ink_strokes] : strokes_) {
// Find the first element in `page_ink_strokes` whose ID >= `start_id`.
auto it = base::ranges::lower_bound(
page_ink_strokes, start_id, {},
[](const FinishedStrokeState& state) { return state.id; });
page_ink_strokes.erase(it, page_ink_strokes.end());
}
// Check the pages with strokes and remove the ones that are now empty.
// Also find the maximum stroke ID that is in use.
std::optional<size_t> max_stroke_id;
for (auto it = strokes_.begin(); it != strokes_.end();) {
const auto& page_ink_strokes = it->second;
if (page_ink_strokes.empty()) {
it = strokes_.erase(it);
} else {
max_stroke_id =
std::max(max_stroke_id.value_or(0), page_ink_strokes.back().id);
++it;
}
}
// Now that some strokes have been discarded, Let the StrokeIdGenerator know
// there are IDs available for reuse.
if (max_stroke_id.has_value()) {
// Since some stroke(s) got discarded, the maximum stroke ID value cannot be
// the max integer value. Thus adding 1 will not overflow.
CHECK_NE(max_stroke_id.value(), std::numeric_limits<size_t>::max());
stroke_id_generator_.ResetIdTo(max_stroke_id.value() + 1);
} else {
stroke_id_generator_.ResetIdTo(0);
}
}
void PdfInkModule::MaybeSetCursor() {
if (!enabled()) {
// Do nothing when disabled. The code outside of PdfInkModule will select a
// normal mouse cursor and switch to that.
return;
}
SkColor color;
float brush_size;
if (is_drawing_stroke()) {
const auto& ink_brush = drawing_stroke_state().brush->GetInkBrush();
color = ink_brush.GetColor();
brush_size = ink_brush.GetSize();
} else {
CHECK(is_erasing_stroke());
constexpr SkColor kEraserColor = SK_ColorWHITE;
color = kEraserColor;
brush_size = erasing_stroke_state().eraser_size;
}
client_->UpdateInkCursorImage(GenerateToolCursor(
color,
CursorDiameterFromBrushSizeAndZoom(brush_size, client_->GetZoom())));
}
PdfInkModule::DrawingStrokeState::DrawingStrokeState() = default;
PdfInkModule::DrawingStrokeState::~DrawingStrokeState() = default;
PdfInkModule::FinishedStrokeState::FinishedStrokeState(
std::unique_ptr<InkStroke> stroke,
size_t id)
: stroke(std::move(stroke)), id(id) {}
PdfInkModule::FinishedStrokeState::FinishedStrokeState(
PdfInkModule::FinishedStrokeState&&) noexcept = default;
PdfInkModule::FinishedStrokeState& PdfInkModule::FinishedStrokeState::operator=(
PdfInkModule::FinishedStrokeState&&) noexcept = default;
PdfInkModule::FinishedStrokeState::~FinishedStrokeState() = default;
PdfInkModule::StrokeIdGenerator::StrokeIdGenerator() = default;
PdfInkModule::StrokeIdGenerator::~StrokeIdGenerator() = default;
size_t PdfInkModule::StrokeIdGenerator::GetIdAndAdvance() {
// Die intentionally if `next_stroke_id_` is about to overflow.
CHECK_NE(next_stroke_id_, std::numeric_limits<size_t>::max());
return next_stroke_id_++;
}
void PdfInkModule::StrokeIdGenerator::ResetIdTo(size_t id) {
next_stroke_id_ = id;
}
} // namespace chrome_pdf