Migrate painting code in pdf/ to gfx:: types
Updates painting classes (PaintAggregator, PaintManager, PaintReadyRect) to use gfx:: geometry types, instead of pp:: geometry types. Also updated OutOfProcessInstance and related code that uses the painting classes. Beyond renaming from the pp:: to the equivalent gfx:: types, some special cases needed to be handled: 1. In some cases, a member function of a pp:: or gfx:: type mutated in place, while the corresponding member function did not. These cases required extra care to find an equivalent replacement. 2. pp::Point was replaced with gfx::Point or gfx::Vector2d, depending on usage. pp::Point does not distinguish between these two cases. In all the remaining cases, the pp:: and gfx:: types behave the same. Bug: 1099020, 1101101 Change-Id: Ia899e57a728b6a517d7739f10f59825ffe75dfdd Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2305594 Commit-Queue: K. Moon <kmoon@chromium.org> Reviewed-by: Lei Zhang <thestig@chromium.org> Reviewed-by: Daniel Hosseinian <dhoss@chromium.org> Cr-Commit-Position: refs/heads/master@{#790570}
This commit is contained in:
@ -32,6 +32,7 @@
|
||||
#include "pdf/document_metadata.h"
|
||||
#include "pdf/pdf_features.h"
|
||||
#include "pdf/ppapi_migration/bitmap.h"
|
||||
#include "pdf/ppapi_migration/geometry_conversions.h"
|
||||
#include "ppapi/c/dev/ppb_cursor_control_dev.h"
|
||||
#include "ppapi/c/pp_errors.h"
|
||||
#include "ppapi/c/private/ppb_pdf.h"
|
||||
@ -55,6 +56,9 @@
|
||||
#include "ppapi/cpp/var_dictionary.h"
|
||||
#include "ui/events/keycodes/keyboard_codes.h"
|
||||
#include "ui/gfx/geometry/point_f.h"
|
||||
#include "ui/gfx/geometry/rect.h"
|
||||
#include "ui/gfx/geometry/size.h"
|
||||
#include "ui/gfx/geometry/vector2d.h"
|
||||
#include "url/gurl.h"
|
||||
|
||||
namespace chrome_pdf {
|
||||
@ -667,13 +671,14 @@ void OutOfProcessInstance::DidChangeView(const pp::View& view) {
|
||||
plugin_dip_size_ = view_rect.size();
|
||||
plugin_size_ = view_device_size;
|
||||
|
||||
paint_manager_.SetSize(view_device_size, device_scale_);
|
||||
paint_manager_.SetSize(SizeFromPPSize(view_device_size), device_scale_);
|
||||
|
||||
pp::Size new_image_data_size =
|
||||
PaintManager::GetNewContextSize(image_data_.size(), plugin_size_);
|
||||
if (new_image_data_size != image_data_.size()) {
|
||||
const gfx::Size old_image_data_size = SizeFromPPSize(image_data_.size());
|
||||
gfx::Size new_image_data_size = PaintManager::GetNewContextSize(
|
||||
old_image_data_size, SizeFromPPSize(plugin_size_));
|
||||
if (new_image_data_size != old_image_data_size) {
|
||||
image_data_ = pp::ImageData(this, PP_IMAGEDATAFORMAT_BGRA_PREMUL,
|
||||
new_image_data_size, false);
|
||||
PPSizeFromSize(new_image_data_size), false);
|
||||
skia_image_data_ =
|
||||
SkBitmapFromPPImageData(std::make_unique<pp::ImageData>(image_data_));
|
||||
first_paint_ = true;
|
||||
@ -950,17 +955,18 @@ void OutOfProcessInstance::StopFind() {
|
||||
SetTickmarks(tickmarks_);
|
||||
}
|
||||
|
||||
pp::Graphics2D OutOfProcessInstance::CreatePaintGraphics(const pp::Size& size) {
|
||||
return pp::Graphics2D(this, size, /*is_always_opaque=*/true);
|
||||
pp::Graphics2D OutOfProcessInstance::CreatePaintGraphics(
|
||||
const gfx::Size& size) {
|
||||
return pp::Graphics2D(this, PPSizeFromSize(size), /*is_always_opaque=*/true);
|
||||
}
|
||||
|
||||
bool OutOfProcessInstance::BindPaintGraphics(pp::Graphics2D& graphics) {
|
||||
return BindGraphics(graphics);
|
||||
}
|
||||
|
||||
void OutOfProcessInstance::OnPaint(const std::vector<pp::Rect>& paint_rects,
|
||||
void OutOfProcessInstance::OnPaint(const std::vector<gfx::Rect>& paint_rects,
|
||||
std::vector<PaintReadyRect>* ready,
|
||||
std::vector<pp::Rect>* pending) {
|
||||
std::vector<gfx::Rect>* pending) {
|
||||
base::AutoReset<bool> auto_reset_in_paint(&in_paint_, true);
|
||||
if (image_data_.is_null()) {
|
||||
DCHECK(plugin_size_.IsEmpty());
|
||||
@ -981,7 +987,8 @@ void OutOfProcessInstance::OnPaint(const std::vector<pp::Rect>& paint_rects,
|
||||
for (const auto& paint_rect : paint_rects) {
|
||||
// Intersect with plugin area since there could be pending invalidates from
|
||||
// when the plugin area was larger.
|
||||
pp::Rect rect = paint_rect.Intersect(pp::Rect(pp::Point(), plugin_size_));
|
||||
pp::Rect rect = PPRectFromRect(paint_rect);
|
||||
rect = rect.Intersect(pp::Rect(pp::Point(), plugin_size_));
|
||||
if (rect.IsEmpty())
|
||||
continue;
|
||||
|
||||
@ -998,7 +1005,7 @@ void OutOfProcessInstance::OnPaint(const std::vector<pp::Rect>& paint_rects,
|
||||
}
|
||||
for (auto& pending_rect : pdf_pending) {
|
||||
pending_rect.Offset(available_area_.point());
|
||||
pending->push_back(pending_rect);
|
||||
pending->push_back(RectFromPPRect(pending_rect));
|
||||
}
|
||||
}
|
||||
|
||||
@ -1124,12 +1131,12 @@ void OutOfProcessInstance::Invalidate(const pp::Rect& rect) {
|
||||
|
||||
pp::Rect offset_rect(rect);
|
||||
offset_rect.Offset(available_area_.point());
|
||||
paint_manager_.InvalidateRect(offset_rect);
|
||||
paint_manager_.InvalidateRect(RectFromPPRect(offset_rect));
|
||||
}
|
||||
|
||||
void OutOfProcessInstance::DidScroll(const pp::Point& point) {
|
||||
void OutOfProcessInstance::DidScroll(const gfx::Vector2d& offset) {
|
||||
if (!image_data_.is_null())
|
||||
paint_manager_.ScrollRect(available_area_, point);
|
||||
paint_manager_.ScrollRect(RectFromPPRect(available_area_), offset);
|
||||
}
|
||||
|
||||
void OutOfProcessInstance::ScrollToX(int x_in_screen_coords) {
|
||||
@ -1652,7 +1659,7 @@ void OutOfProcessInstance::HandleResetPrintPreviewModeMessage(
|
||||
engine_->SetGrayscale(dict.Get(pp::Var(kJSPrintPreviewGrayscale)).AsBool());
|
||||
engine_->New(url_.c_str(), /*headers=*/nullptr);
|
||||
|
||||
paint_manager_.InvalidateRect(pp::Rect(pp::Point(), plugin_size_));
|
||||
paint_manager_.InvalidateRect(gfx::Rect(SizeFromPPSize(plugin_size_)));
|
||||
}
|
||||
|
||||
void OutOfProcessInstance::HandleSaveMessage(const pp::VarDictionary& dict) {
|
||||
@ -1746,41 +1753,41 @@ void OutOfProcessInstance::HandleViewportMessage(
|
||||
dict.Get(pp::Var(kJSPinchY)).AsDouble());
|
||||
// Pinch vector is the panning caused due to change in pinch
|
||||
// center between start and end of the gesture.
|
||||
pp::Point pinch_vector =
|
||||
pp::Point(dict.Get(kJSPinchVectorX).AsDouble() * zoom_ratio,
|
||||
dict.Get(kJSPinchVectorY).AsDouble() * zoom_ratio);
|
||||
pp::Point scroll_delta;
|
||||
gfx::Vector2d pinch_vector =
|
||||
gfx::Vector2d(dict.Get(kJSPinchVectorX).AsDouble() * zoom_ratio,
|
||||
dict.Get(kJSPinchVectorY).AsDouble() * zoom_ratio);
|
||||
gfx::Vector2d scroll_delta;
|
||||
// If the rendered document doesn't fill the display area we will
|
||||
// use |paint_offset| to anchor the paint vertically into the same place.
|
||||
// We use the scroll bars instead of the pinch vector to get the actual
|
||||
// position on screen of the paint.
|
||||
pp::Point paint_offset;
|
||||
gfx::Vector2d paint_offset;
|
||||
|
||||
if (plugin_size_.width() > GetDocumentPixelWidth() * zoom_ratio) {
|
||||
// We want to keep the paint in the middle but it must stay in the same
|
||||
// position relative to the scroll bars.
|
||||
paint_offset = pp::Point(0, (1 - zoom_ratio) * pinch_center.y());
|
||||
scroll_delta = pp::Point(
|
||||
paint_offset = gfx::Vector2d(0, (1 - zoom_ratio) * pinch_center.y());
|
||||
scroll_delta = gfx::Vector2d(
|
||||
0,
|
||||
(scroll_offset.y() - scroll_offset_at_last_raster_.y() * zoom_ratio));
|
||||
|
||||
pinch_vector = pp::Point();
|
||||
pinch_vector = gfx::Vector2d();
|
||||
last_bitmap_smaller_ = true;
|
||||
} else if (last_bitmap_smaller_) {
|
||||
pinch_center = pp::Point((plugin_size_.width() / device_scale_) / 2,
|
||||
(plugin_size_.height() / device_scale_) / 2);
|
||||
const double zoom_when_doc_covers_plugin_width =
|
||||
zoom_ * plugin_size_.width() / GetDocumentPixelWidth();
|
||||
paint_offset = pp::Point(
|
||||
paint_offset = gfx::Vector2d(
|
||||
(1 - zoom / zoom_when_doc_covers_plugin_width) * pinch_center.x(),
|
||||
(1 - zoom_ratio) * pinch_center.y());
|
||||
pinch_vector = pp::Point();
|
||||
scroll_delta = pp::Point(
|
||||
pinch_vector = gfx::Vector2d();
|
||||
scroll_delta = gfx::Vector2d(
|
||||
(scroll_offset.x() - scroll_offset_at_last_raster_.x() * zoom_ratio),
|
||||
(scroll_offset.y() - scroll_offset_at_last_raster_.y() * zoom_ratio));
|
||||
}
|
||||
|
||||
paint_manager_.SetTransform(zoom_ratio, pinch_center,
|
||||
paint_manager_.SetTransform(zoom_ratio, PointFromPPPoint(pinch_center),
|
||||
pinch_vector + paint_offset + scroll_delta,
|
||||
true);
|
||||
needs_reraster_ = false;
|
||||
@ -1840,7 +1847,7 @@ void OutOfProcessInstance::DocumentLoadFailed() {
|
||||
}
|
||||
|
||||
document_load_state_ = LOAD_STATE_FAILED;
|
||||
paint_manager_.InvalidateRect(pp::Rect(pp::Point(), plugin_size_));
|
||||
paint_manager_.InvalidateRect(gfx::Rect(SizeFromPPSize(plugin_size_)));
|
||||
|
||||
// Send a progress value of -1 to indicate a failure.
|
||||
SendLoadingProgress(-1);
|
||||
@ -1949,7 +1956,7 @@ void OutOfProcessInstance::OnGeometryChanged(double old_zoom,
|
||||
|
||||
if (document_size_.IsEmpty())
|
||||
return;
|
||||
paint_manager_.InvalidateRect(pp::Rect(pp::Point(), plugin_size_));
|
||||
paint_manager_.InvalidateRect(gfx::Rect(SizeFromPPSize(plugin_size_)));
|
||||
|
||||
if (accessibility_state_ == ACCESSIBILITY_STATE_LOADED)
|
||||
SendAccessibilityViewportInfo();
|
||||
|
@ -29,11 +29,17 @@
|
||||
#include "ppapi/utility/completion_callback_factory.h"
|
||||
#include "third_party/skia/include/core/SkBitmap.h"
|
||||
|
||||
namespace gfx {
|
||||
class Rect;
|
||||
class Size;
|
||||
class Vector2d;
|
||||
} // namespace gfx
|
||||
|
||||
namespace pp {
|
||||
class Graphics2D;
|
||||
class Size;
|
||||
class TextInput_Dev;
|
||||
}
|
||||
} // namespace pp
|
||||
|
||||
namespace chrome_pdf {
|
||||
|
||||
@ -62,11 +68,11 @@ class OutOfProcessInstance : public pp::Instance,
|
||||
void StopFind() override;
|
||||
|
||||
// pp::PaintManager::Client implementation.
|
||||
pp::Graphics2D CreatePaintGraphics(const pp::Size& size) override;
|
||||
pp::Graphics2D CreatePaintGraphics(const gfx::Size& size) override;
|
||||
bool BindPaintGraphics(pp::Graphics2D& graphics) override;
|
||||
void OnPaint(const std::vector<pp::Rect>& paint_rects,
|
||||
void OnPaint(const std::vector<gfx::Rect>& paint_rects,
|
||||
std::vector<PaintReadyRect>* ready,
|
||||
std::vector<pp::Rect>* pending) override;
|
||||
std::vector<gfx::Rect>* pending) override;
|
||||
|
||||
// pp::Printing_Dev implementation.
|
||||
uint32_t QuerySupportedPrintOutputFormats() override;
|
||||
@ -103,7 +109,7 @@ class OutOfProcessInstance : public pp::Instance,
|
||||
// PDFEngine::Client implementation.
|
||||
void ProposeDocumentLayout(const DocumentLayout& layout) override;
|
||||
void Invalidate(const pp::Rect& rect) override;
|
||||
void DidScroll(const pp::Point& point) override;
|
||||
void DidScroll(const gfx::Vector2d& offset) override;
|
||||
void ScrollToX(int x_in_screen_coords) override;
|
||||
void ScrollToY(int y_in_screen_coords, bool compensate_for_toolbar) override;
|
||||
void ScrollBy(const pp::Point& point) override;
|
||||
|
@ -7,9 +7,10 @@
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include <algorithm>
|
||||
|
||||
#include "base/check.h"
|
||||
#include "ui/gfx/geometry/point.h"
|
||||
#include "ui/gfx/geometry/rect.h"
|
||||
#include "ui/gfx/geometry/vector2d.h"
|
||||
|
||||
namespace chrome_pdf {
|
||||
|
||||
@ -47,11 +48,11 @@ PaintAggregator::InternalPaintUpdate::InternalPaintUpdate()
|
||||
|
||||
PaintAggregator::InternalPaintUpdate::~InternalPaintUpdate() = default;
|
||||
|
||||
pp::Rect PaintAggregator::InternalPaintUpdate::GetScrollDamage() const {
|
||||
gfx::Rect PaintAggregator::InternalPaintUpdate::GetScrollDamage() const {
|
||||
// Should only be scrolling in one direction at a time.
|
||||
DCHECK(!(scroll_delta.x() && scroll_delta.y()));
|
||||
|
||||
pp::Rect damaged_rect;
|
||||
gfx::Rect damaged_rect;
|
||||
|
||||
// Compute the region we will expose by scrolling, and paint that into a
|
||||
// shared memory section.
|
||||
@ -80,7 +81,7 @@ pp::Rect PaintAggregator::InternalPaintUpdate::GetScrollDamage() const {
|
||||
}
|
||||
|
||||
// In case the scroll offset exceeds the width/height of the scroll rect
|
||||
return scroll_rect.Intersect(damaged_rect);
|
||||
return gfx::IntersectRects(scroll_rect, damaged_rect);
|
||||
}
|
||||
|
||||
PaintAggregator::PaintAggregator() = default;
|
||||
@ -106,7 +107,7 @@ PaintAggregator::PaintUpdate PaintAggregator::GetPendingUpdate() {
|
||||
// rects in the next block.
|
||||
if (ret.has_scroll && !update_.synthesized_scroll_damage_rect_) {
|
||||
update_.synthesized_scroll_damage_rect_ = true;
|
||||
pp::Rect scroll_damage = update_.GetScrollDamage();
|
||||
gfx::Rect scroll_damage = update_.GetScrollDamage();
|
||||
InvalidateRectInternal(scroll_damage, false);
|
||||
}
|
||||
|
||||
@ -119,7 +120,7 @@ PaintAggregator::PaintUpdate PaintAggregator::GetPendingUpdate() {
|
||||
|
||||
void PaintAggregator::SetIntermediateResults(
|
||||
const std::vector<PaintReadyRect>& ready,
|
||||
const std::vector<pp::Rect>& pending) {
|
||||
const std::vector<gfx::Rect>& pending) {
|
||||
update_.ready_rects.insert(update_.ready_rects.end(), ready.begin(),
|
||||
ready.end());
|
||||
update_.paint_rects = pending;
|
||||
@ -129,12 +130,12 @@ std::vector<PaintReadyRect> PaintAggregator::GetReadyRects() const {
|
||||
return update_.ready_rects;
|
||||
}
|
||||
|
||||
void PaintAggregator::InvalidateRect(const pp::Rect& rect) {
|
||||
void PaintAggregator::InvalidateRect(const gfx::Rect& rect) {
|
||||
InvalidateRectInternal(rect, true);
|
||||
}
|
||||
|
||||
void PaintAggregator::ScrollRect(const pp::Rect& clip_rect,
|
||||
const pp::Point& amount) {
|
||||
void PaintAggregator::ScrollRect(const gfx::Rect& clip_rect,
|
||||
const gfx::Vector2d& amount) {
|
||||
// We only support scrolling along one axis at a time.
|
||||
if (amount.x() != 0 && amount.y() != 0) {
|
||||
InvalidateRect(clip_rect);
|
||||
@ -180,8 +181,8 @@ void PaintAggregator::ScrollRect(const pp::Rect& clip_rect,
|
||||
update_.scroll_delta += amount;
|
||||
|
||||
// We might have just wiped out a pre-existing scroll.
|
||||
if (update_.scroll_delta == pp::Point()) {
|
||||
update_.scroll_rect = pp::Rect();
|
||||
if (update_.scroll_delta == gfx::Vector2d()) {
|
||||
update_.scroll_rect = gfx::Rect();
|
||||
return;
|
||||
}
|
||||
|
||||
@ -189,22 +190,22 @@ void PaintAggregator::ScrollRect(const pp::Rect& clip_rect,
|
||||
// paint that is inside the scroll area, move it by the scroll amount and
|
||||
// replace the existing paint with it. For the portion (if any) that is
|
||||
// outside the scroll, just invalidate it.
|
||||
std::vector<pp::Rect> leftover_rects;
|
||||
std::vector<gfx::Rect> leftover_rects;
|
||||
for (size_t i = 0; i < update_.paint_rects.size(); ++i) {
|
||||
if (!update_.scroll_rect.Intersects(update_.paint_rects[i]))
|
||||
continue;
|
||||
|
||||
pp::Rect intersection =
|
||||
update_.paint_rects[i].Intersect(update_.scroll_rect);
|
||||
pp::Rect rect = update_.paint_rects[i];
|
||||
gfx::Rect intersection =
|
||||
gfx::IntersectRects(update_.paint_rects[i], update_.scroll_rect);
|
||||
gfx::Rect rect = update_.paint_rects[i];
|
||||
while (!rect.IsEmpty()) {
|
||||
pp::Rect leftover = rect.Subtract(intersection);
|
||||
gfx::Rect leftover = gfx::SubtractRects(rect, intersection);
|
||||
if (leftover.IsEmpty())
|
||||
break;
|
||||
// Don't want to call InvalidateRectInternal now since it'll modify
|
||||
// update_.paint_rects, so keep track of this and do it below.
|
||||
leftover_rects.push_back(leftover);
|
||||
rect = rect.Subtract(leftover);
|
||||
rect.Subtract(leftover);
|
||||
}
|
||||
|
||||
update_.paint_rects[i] = ScrollPaintRect(intersection, amount);
|
||||
@ -225,35 +226,33 @@ void PaintAggregator::ScrollRect(const pp::Rect& clip_rect,
|
||||
}
|
||||
|
||||
if (update_.synthesized_scroll_damage_rect_) {
|
||||
pp::Rect damage = update_.GetScrollDamage();
|
||||
InvalidateRect(damage);
|
||||
InvalidateRect(update_.GetScrollDamage());
|
||||
}
|
||||
}
|
||||
|
||||
pp::Rect PaintAggregator::ScrollPaintRect(const pp::Rect& paint_rect,
|
||||
const pp::Point& amount) const {
|
||||
pp::Rect result = paint_rect;
|
||||
result.Offset(amount);
|
||||
result = update_.scroll_rect.Intersect(result);
|
||||
gfx::Rect PaintAggregator::ScrollPaintRect(const gfx::Rect& paint_rect,
|
||||
const gfx::Vector2d& amount) const {
|
||||
gfx::Rect result = paint_rect + amount;
|
||||
result.Intersect(update_.scroll_rect);
|
||||
return result;
|
||||
}
|
||||
|
||||
void PaintAggregator::InvalidateScrollRect() {
|
||||
pp::Rect scroll_rect = update_.scroll_rect;
|
||||
update_.scroll_rect = pp::Rect();
|
||||
update_.scroll_delta = pp::Point();
|
||||
gfx::Rect scroll_rect = update_.scroll_rect;
|
||||
update_.scroll_rect = gfx::Rect();
|
||||
update_.scroll_delta = gfx::Vector2d();
|
||||
InvalidateRect(scroll_rect);
|
||||
}
|
||||
|
||||
void PaintAggregator::InvalidateRectInternal(const pp::Rect& rect_old,
|
||||
void PaintAggregator::InvalidateRectInternal(const gfx::Rect& rect_old,
|
||||
bool check_scroll) {
|
||||
pp::Rect rect = rect_old;
|
||||
gfx::Rect rect = rect_old;
|
||||
// Check if any rects that are ready to be painted overlap.
|
||||
for (size_t i = 0; i < update_.ready_rects.size(); ++i) {
|
||||
const pp::Rect& existing_rect = update_.ready_rects[i].rect;
|
||||
const gfx::Rect& existing_rect = update_.ready_rects[i].rect;
|
||||
if (rect.Intersects(existing_rect)) {
|
||||
// Re-invalidate in case the union intersects other paint rects.
|
||||
rect = existing_rect.Union(rect);
|
||||
rect.Union(existing_rect);
|
||||
update_.ready_rects.erase(update_.ready_rects.begin() + i);
|
||||
break;
|
||||
}
|
||||
@ -263,12 +262,12 @@ void PaintAggregator::InvalidateRectInternal(const pp::Rect& rect_old,
|
||||
|
||||
// Combine overlapping paints using smallest bounding box.
|
||||
for (size_t i = 0; i < update_.paint_rects.size(); ++i) {
|
||||
const pp::Rect& existing_rect = update_.paint_rects[i];
|
||||
const gfx::Rect& existing_rect = update_.paint_rects[i];
|
||||
if (existing_rect.Contains(rect)) // Optimize out redundancy.
|
||||
add_paint = false;
|
||||
if (rect.Intersects(existing_rect) || rect.SharesEdgeWith(existing_rect)) {
|
||||
// Re-invalidate in case the union intersects other paint rects.
|
||||
pp::Rect combined_rect = existing_rect.Union(rect);
|
||||
gfx::Rect combined_rect = gfx::UnionRects(rect, existing_rect);
|
||||
update_.paint_rects.erase(update_.paint_rects.begin() + i);
|
||||
InvalidateRectInternal(combined_rect, check_scroll);
|
||||
add_paint = false;
|
||||
|
@ -8,7 +8,8 @@
|
||||
#include <vector>
|
||||
|
||||
#include "pdf/paint_ready_rect.h"
|
||||
#include "ppapi/cpp/rect.h"
|
||||
#include "ui/gfx/geometry/rect.h"
|
||||
#include "ui/gfx/geometry/vector2d.h"
|
||||
|
||||
namespace chrome_pdf {
|
||||
|
||||
@ -36,18 +37,18 @@ class PaintAggregator {
|
||||
// region instead).
|
||||
//
|
||||
// If there is no scroll, this will be (0, 0).
|
||||
pp::Point scroll_delta;
|
||||
gfx::Vector2d scroll_delta;
|
||||
|
||||
// The rectangle that should be scrolled by the scroll_delta. If there is no
|
||||
// scroll, this will be (0, 0, 0, 0). We only track one scroll command at
|
||||
// once. If there are multiple ones, they will be converted to invalidates.
|
||||
pp::Rect scroll_rect;
|
||||
gfx::Rect scroll_rect;
|
||||
|
||||
// A list of all the individual dirty rectangles. This is an aggregated list
|
||||
// of all invalidate calls. Different rectangles may be unified to produce a
|
||||
// minimal list with no overlap that is more efficient to paint. This list
|
||||
// also contains the region exposed by any scroll command.
|
||||
std::vector<pp::Rect> paint_rects;
|
||||
std::vector<gfx::Rect> paint_rects;
|
||||
};
|
||||
|
||||
PaintAggregator();
|
||||
@ -63,16 +64,16 @@ class PaintAggregator {
|
||||
// are finished painting (ready), and ones that are still in-progress
|
||||
// (pending).
|
||||
void SetIntermediateResults(const std::vector<PaintReadyRect>& ready,
|
||||
const std::vector<pp::Rect>& pending);
|
||||
const std::vector<gfx::Rect>& pending);
|
||||
|
||||
// Returns the rectangles that are ready to be painted.
|
||||
std::vector<PaintReadyRect> GetReadyRects() const;
|
||||
|
||||
// The given rect should be repainted.
|
||||
void InvalidateRect(const pp::Rect& rect);
|
||||
void InvalidateRect(const gfx::Rect& rect);
|
||||
|
||||
// The given rect should be scrolled by the given amounts.
|
||||
void ScrollRect(const pp::Rect& clip_rect, const pp::Point& amount);
|
||||
void ScrollRect(const gfx::Rect& clip_rect, const gfx::Vector2d& amount);
|
||||
|
||||
private:
|
||||
// This structure is an internal version of PaintUpdate. It's different in
|
||||
@ -92,14 +93,14 @@ class PaintAggregator {
|
||||
// Computes the rect damaged by scrolling within |scroll_rect| by
|
||||
// |scroll_delta|. This rect must be repainted. It is not included in
|
||||
// paint_rects.
|
||||
pp::Rect GetScrollDamage() const;
|
||||
gfx::Rect GetScrollDamage() const;
|
||||
|
||||
pp::Point scroll_delta;
|
||||
pp::Rect scroll_rect;
|
||||
gfx::Vector2d scroll_delta;
|
||||
gfx::Rect scroll_rect;
|
||||
|
||||
// Does not include the scroll damage rect unless
|
||||
// synthesized_scroll_damage_rect_ is set.
|
||||
std::vector<pp::Rect> paint_rects;
|
||||
std::vector<gfx::Rect> paint_rects;
|
||||
|
||||
// Rectangles that are finished painting.
|
||||
std::vector<PaintReadyRect> ready_rects;
|
||||
@ -108,14 +109,14 @@ class PaintAggregator {
|
||||
bool synthesized_scroll_damage_rect_;
|
||||
};
|
||||
|
||||
pp::Rect ScrollPaintRect(const pp::Rect& paint_rect,
|
||||
const pp::Point& amount) const;
|
||||
gfx::Rect ScrollPaintRect(const gfx::Rect& paint_rect,
|
||||
const gfx::Vector2d& amount) const;
|
||||
void InvalidateScrollRect();
|
||||
|
||||
// Internal method used by InvalidateRect. If |check_scroll| is true, then the
|
||||
// method checks if there's a pending scroll and if so also invalidates |rect|
|
||||
// in the new scroll position.
|
||||
void InvalidateRectInternal(const pp::Rect& rect, bool check_scroll);
|
||||
void InvalidateRectInternal(const gfx::Rect& rect, bool check_scroll);
|
||||
|
||||
InternalPaintUpdate update_;
|
||||
};
|
||||
|
@ -12,11 +12,28 @@
|
||||
#include "base/auto_reset.h"
|
||||
#include "base/check_op.h"
|
||||
#include "pdf/paint_ready_rect.h"
|
||||
#include "pdf/ppapi_migration/geometry_conversions.h"
|
||||
#include "ppapi/c/pp_errors.h"
|
||||
#include "ppapi/cpp/module.h"
|
||||
#include "ppapi/cpp/point.h"
|
||||
#include "ppapi/cpp/rect.h"
|
||||
#include "ui/gfx/geometry/point.h"
|
||||
#include "ui/gfx/geometry/rect.h"
|
||||
#include "ui/gfx/geometry/size.h"
|
||||
#include "ui/gfx/geometry/vector2d.h"
|
||||
|
||||
namespace chrome_pdf {
|
||||
|
||||
namespace {
|
||||
|
||||
// Not part of ppapi_migration because `gfx::Vector2d` only needs to be
|
||||
// converted to `pp::Point` at the boundary with `pp::Graphics2D`.
|
||||
pp::Point ToPepperPoint(const gfx::Vector2d& vector) {
|
||||
return pp::Point(vector.x(), vector.y());
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
PaintManager::PaintManager(Client* client) : client_(client) {
|
||||
DCHECK(client_);
|
||||
|
||||
@ -28,20 +45,20 @@ PaintManager::PaintManager(Client* client) : client_(client) {
|
||||
PaintManager::~PaintManager() = default;
|
||||
|
||||
// static
|
||||
pp::Size PaintManager::GetNewContextSize(const pp::Size& current_context_size,
|
||||
const pp::Size& plugin_size) {
|
||||
gfx::Size PaintManager::GetNewContextSize(const gfx::Size& current_context_size,
|
||||
const gfx::Size& plugin_size) {
|
||||
// The amount of additional space in pixels to allocate to the right/bottom of
|
||||
// the context.
|
||||
constexpr int kBufferSize = 50;
|
||||
|
||||
// Default to returning the same size.
|
||||
pp::Size result = current_context_size;
|
||||
gfx::Size result = current_context_size;
|
||||
|
||||
// The minimum size of the plugin before resizing the context to ensure we
|
||||
// aren't wasting too much memory. We deduct twice the kBufferSize from the
|
||||
// current context size which gives a threshhold that is kBufferSize below
|
||||
// the plugin size when the context size was last computed.
|
||||
pp::Size min_size(
|
||||
gfx::Size min_size(
|
||||
std::max(current_context_size.width() - 2 * kBufferSize, 0),
|
||||
std::max(current_context_size.height() - 2 * kBufferSize, 0));
|
||||
|
||||
@ -55,14 +72,14 @@ pp::Size PaintManager::GetNewContextSize(const pp::Size& current_context_size,
|
||||
plugin_size.height() < min_size.height()) {
|
||||
// Create a larger context than needed so that if we only resize by a
|
||||
// small margin, we don't need a new context.
|
||||
result = pp::Size(plugin_size.width() + kBufferSize,
|
||||
plugin_size.height() + kBufferSize);
|
||||
result = gfx::Size(plugin_size.width() + kBufferSize,
|
||||
plugin_size.height() + kBufferSize);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void PaintManager::SetSize(const pp::Size& new_size, float device_scale) {
|
||||
void PaintManager::SetSize(const gfx::Size& new_size, float device_scale) {
|
||||
if (GetEffectiveSize() == new_size &&
|
||||
GetEffectiveDeviceScale() == device_scale) {
|
||||
return;
|
||||
@ -78,13 +95,14 @@ void PaintManager::SetSize(const pp::Size& new_size, float device_scale) {
|
||||
}
|
||||
|
||||
void PaintManager::SetTransform(float scale,
|
||||
const pp::Point& origin,
|
||||
const pp::Point& translate,
|
||||
const gfx::Point& origin,
|
||||
const gfx::Vector2d& translate,
|
||||
bool schedule_flush) {
|
||||
if (graphics_.is_null())
|
||||
return;
|
||||
|
||||
graphics_.SetLayerTransform(scale, origin, translate);
|
||||
graphics_.SetLayerTransform(scale, PPPointFromPoint(origin),
|
||||
ToPepperPoint(translate));
|
||||
|
||||
if (!schedule_flush)
|
||||
return;
|
||||
@ -97,7 +115,7 @@ void PaintManager::SetTransform(float scale,
|
||||
}
|
||||
|
||||
void PaintManager::ClearTransform() {
|
||||
SetTransform(1.f, pp::Point(), pp::Point(), false);
|
||||
SetTransform(1.f, gfx::Point(), gfx::Vector2d(), false);
|
||||
}
|
||||
|
||||
void PaintManager::Invalidate() {
|
||||
@ -105,17 +123,18 @@ void PaintManager::Invalidate() {
|
||||
return;
|
||||
|
||||
EnsureCallbackPending();
|
||||
aggregator_.InvalidateRect(pp::Rect(GetEffectiveSize()));
|
||||
aggregator_.InvalidateRect(gfx::Rect(GetEffectiveSize()));
|
||||
}
|
||||
|
||||
void PaintManager::InvalidateRect(const pp::Rect& rect) {
|
||||
void PaintManager::InvalidateRect(const gfx::Rect& rect) {
|
||||
DCHECK(!in_paint_);
|
||||
|
||||
if (graphics_.is_null() && !has_pending_resize_)
|
||||
return;
|
||||
|
||||
// Clip the rect to the device area.
|
||||
pp::Rect clipped_rect = rect.Intersect(pp::Rect(GetEffectiveSize()));
|
||||
gfx::Rect clipped_rect =
|
||||
gfx::IntersectRects(rect, gfx::Rect(GetEffectiveSize()));
|
||||
if (clipped_rect.IsEmpty())
|
||||
return; // Nothing to do.
|
||||
|
||||
@ -123,8 +142,8 @@ void PaintManager::InvalidateRect(const pp::Rect& rect) {
|
||||
aggregator_.InvalidateRect(clipped_rect);
|
||||
}
|
||||
|
||||
void PaintManager::ScrollRect(const pp::Rect& clip_rect,
|
||||
const pp::Point& amount) {
|
||||
void PaintManager::ScrollRect(const gfx::Rect& clip_rect,
|
||||
const gfx::Vector2d& amount) {
|
||||
DCHECK(!in_paint_);
|
||||
|
||||
if (graphics_.is_null() && !has_pending_resize_)
|
||||
@ -135,7 +154,7 @@ void PaintManager::ScrollRect(const pp::Rect& clip_rect,
|
||||
aggregator_.ScrollRect(clip_rect, amount);
|
||||
}
|
||||
|
||||
pp::Size PaintManager::GetEffectiveSize() const {
|
||||
gfx::Size PaintManager::GetEffectiveSize() const {
|
||||
return has_pending_resize_ ? pending_size_ : plugin_size_;
|
||||
}
|
||||
|
||||
@ -165,7 +184,7 @@ void PaintManager::DoPaint() {
|
||||
base::AutoReset<bool> auto_reset_in_paint(&in_paint_, true);
|
||||
|
||||
std::vector<PaintReadyRect> ready_rects;
|
||||
std::vector<pp::Rect> pending_rects;
|
||||
std::vector<gfx::Rect> pending_rects;
|
||||
|
||||
DCHECK(aggregator_.HasPendingUpdate());
|
||||
|
||||
@ -176,11 +195,14 @@ void PaintManager::DoPaint() {
|
||||
// do this later.
|
||||
if (has_pending_resize_) {
|
||||
plugin_size_ = pending_size_;
|
||||
// Extra call to pp_size() required here because the operator for converting
|
||||
// to PP_Size is non-const.
|
||||
const gfx::Size old_size = SizeFromPPSize(graphics_.size().pp_size());
|
||||
// Only create a new graphics context if the current context isn't big
|
||||
// enough or if it is far too big. This avoids creating a new context if
|
||||
// we only resize by a small amount.
|
||||
pp::Size new_size = GetNewContextSize(graphics_.size(), pending_size_);
|
||||
if (graphics_.size() != new_size) {
|
||||
gfx::Size new_size = GetNewContextSize(old_size, pending_size_);
|
||||
if (old_size != new_size) {
|
||||
graphics_ = client_->CreatePaintGraphics(new_size);
|
||||
graphics_need_to_be_bound_ = true;
|
||||
|
||||
@ -197,7 +219,7 @@ void PaintManager::DoPaint() {
|
||||
// This must be cleared before calling into the plugin since it may do
|
||||
// additional invalidation or sizing operations.
|
||||
has_pending_resize_ = false;
|
||||
pending_size_ = pp::Size();
|
||||
pending_size_ = gfx::Size();
|
||||
}
|
||||
|
||||
PaintAggregator::PaintUpdate update = aggregator_.GetPendingUpdate();
|
||||
@ -208,15 +230,15 @@ void PaintManager::DoPaint() {
|
||||
|
||||
std::vector<PaintReadyRect> ready_now;
|
||||
if (pending_rects.empty()) {
|
||||
std::vector<PaintReadyRect> temp_ready;
|
||||
temp_ready.insert(temp_ready.end(), ready_rects.begin(), ready_rects.end());
|
||||
aggregator_.SetIntermediateResults(temp_ready, pending_rects);
|
||||
aggregator_.SetIntermediateResults(ready_rects, pending_rects);
|
||||
ready_now = aggregator_.GetReadyRects();
|
||||
aggregator_.ClearPendingUpdate();
|
||||
|
||||
// Apply any scroll first.
|
||||
if (update.has_scroll)
|
||||
graphics_.Scroll(update.scroll_rect, update.scroll_delta);
|
||||
if (update.has_scroll) {
|
||||
graphics_.Scroll(PPRectFromRect(update.scroll_rect),
|
||||
ToPepperPoint(update.scroll_delta));
|
||||
}
|
||||
|
||||
view_size_changed_waiting_for_paint_ = false;
|
||||
} else {
|
||||
@ -246,7 +268,7 @@ void PaintManager::DoPaint() {
|
||||
|
||||
for (const auto& ready_rect : ready_now) {
|
||||
graphics_.PaintImageData(ready_rect.image_data, pp::Point(),
|
||||
ready_rect.rect);
|
||||
PPRectFromRect(ready_rect.rect));
|
||||
}
|
||||
|
||||
Flush();
|
||||
|
@ -12,12 +12,13 @@
|
||||
#include "pdf/paint_aggregator.h"
|
||||
#include "ppapi/cpp/graphics_2d.h"
|
||||
#include "ppapi/utility/completion_callback_factory.h"
|
||||
#include "ui/gfx/geometry/size.h"
|
||||
|
||||
namespace pp {
|
||||
namespace gfx {
|
||||
class Point;
|
||||
class Rect;
|
||||
class Size;
|
||||
} // namespace pp
|
||||
class Vector2d;
|
||||
} // namespace gfx
|
||||
|
||||
namespace chrome_pdf {
|
||||
|
||||
@ -34,7 +35,7 @@ class PaintManager {
|
||||
public:
|
||||
// Creates a new, unbound `pp::Graphics2D` for the paint manager, with the
|
||||
// given |size| and always-opaque rendering.
|
||||
virtual pp::Graphics2D CreatePaintGraphics(const pp::Size& size) = 0;
|
||||
virtual pp::Graphics2D CreatePaintGraphics(const gfx::Size& size) = 0;
|
||||
|
||||
// Binds a `pp::Graphics2D` created by `CreatePaintGraphics()`, returning
|
||||
// `true` if binding was successful.
|
||||
@ -58,9 +59,9 @@ class PaintManager {
|
||||
// PaintManager needs to handle the callback.
|
||||
//
|
||||
// Calling Invalidate/Scroll is not allowed while inside an OnPaint
|
||||
virtual void OnPaint(const std::vector<pp::Rect>& paint_rects,
|
||||
virtual void OnPaint(const std::vector<gfx::Rect>& paint_rects,
|
||||
std::vector<PaintReadyRect>* ready,
|
||||
std::vector<pp::Rect>* pending) = 0;
|
||||
std::vector<gfx::Rect>* pending) = 0;
|
||||
|
||||
protected:
|
||||
// You shouldn't be doing deleting through this interface.
|
||||
@ -81,8 +82,8 @@ class PaintManager {
|
||||
// size. We may allocated a slightly larger buffer than required so that we
|
||||
// don't have to resize the context when scrollbars appear/dissapear due to
|
||||
// zooming (which can result in flickering).
|
||||
static pp::Size GetNewContextSize(const pp::Size& current_context_size,
|
||||
const pp::Size& plugin_size);
|
||||
static gfx::Size GetNewContextSize(const gfx::Size& current_context_size,
|
||||
const gfx::Size& plugin_size);
|
||||
|
||||
// Sets the size of the plugin. If the size is the same as the previous call,
|
||||
// this will be a NOP. If the size has changed, a new device will be
|
||||
@ -93,22 +94,22 @@ class PaintManager {
|
||||
// changes, you can always call this function without worrying about whether
|
||||
// the size changed or ViewChanged is called for another reason (like the
|
||||
// position changed).
|
||||
void SetSize(const pp::Size& new_size, float new_device_scale);
|
||||
void SetSize(const gfx::Size& new_size, float new_device_scale);
|
||||
|
||||
// Invalidate the entire plugin.
|
||||
void Invalidate();
|
||||
|
||||
// Invalidate the given rect.
|
||||
void InvalidateRect(const pp::Rect& rect);
|
||||
void InvalidateRect(const gfx::Rect& rect);
|
||||
|
||||
// The given rect should be scrolled by the given amounts.
|
||||
void ScrollRect(const pp::Rect& clip_rect, const pp::Point& amount);
|
||||
void ScrollRect(const gfx::Rect& clip_rect, const gfx::Vector2d& amount);
|
||||
|
||||
// Returns the size of the graphics context for the next paint operation.
|
||||
// This is the pending size if a resize is pending (the plugin has called
|
||||
// SetSize but we haven't actually painted it yet), or the current size of
|
||||
// no resize is pending.
|
||||
pp::Size GetEffectiveSize() const;
|
||||
gfx::Size GetEffectiveSize() const;
|
||||
float GetEffectiveDeviceScale() const;
|
||||
|
||||
// Set the transform for the graphics layer.
|
||||
@ -116,8 +117,8 @@ class PaintManager {
|
||||
// this change. If |schedule_flush| is false, then the change will not take
|
||||
// effect until another change causes a flush.
|
||||
void SetTransform(float scale,
|
||||
const pp::Point& origin,
|
||||
const pp::Point& translate,
|
||||
const gfx::Point& origin,
|
||||
const gfx::Vector2d& translate,
|
||||
bool schedule_flush);
|
||||
// Resets any transform for the graphics layer.
|
||||
// This does not schedule a flush.
|
||||
@ -164,8 +165,8 @@ class PaintManager {
|
||||
// paint operation. When true, the new size is in pending_size_.
|
||||
bool has_pending_resize_ = false;
|
||||
bool graphics_need_to_be_bound_ = false;
|
||||
pp::Size pending_size_;
|
||||
pp::Size plugin_size_;
|
||||
gfx::Size pending_size_;
|
||||
gfx::Size plugin_size_;
|
||||
float pending_device_scale_ = 1.0f;
|
||||
float device_scale_ = 1.0f;
|
||||
|
||||
|
@ -4,6 +4,7 @@
|
||||
|
||||
#include "pdf/paint_ready_rect.h"
|
||||
|
||||
#include "pdf/ppapi_migration/geometry_conversions.h"
|
||||
#include "ppapi/cpp/image_data.h"
|
||||
#include "ppapi/cpp/rect.h"
|
||||
|
||||
@ -12,7 +13,9 @@ namespace chrome_pdf {
|
||||
PaintReadyRect::PaintReadyRect(const pp::Rect& rect,
|
||||
const pp::ImageData& image_data,
|
||||
bool flush_now)
|
||||
: rect(rect), image_data(image_data), flush_now(flush_now) {}
|
||||
: rect(RectFromPPRect(rect)),
|
||||
image_data(image_data),
|
||||
flush_now(flush_now) {}
|
||||
|
||||
PaintReadyRect::PaintReadyRect(const PaintReadyRect& other) = default;
|
||||
|
||||
|
@ -6,7 +6,11 @@
|
||||
#define PDF_PAINT_READY_RECT_H_
|
||||
|
||||
#include "ppapi/cpp/image_data.h"
|
||||
#include "ppapi/cpp/rect.h"
|
||||
#include "ui/gfx/geometry/rect.h"
|
||||
|
||||
namespace pp {
|
||||
class Rect;
|
||||
} // namespace pp
|
||||
|
||||
namespace chrome_pdf {
|
||||
|
||||
@ -20,7 +24,7 @@ struct PaintReadyRect {
|
||||
PaintReadyRect(const PaintReadyRect& other);
|
||||
PaintReadyRect& operator=(const PaintReadyRect& other);
|
||||
|
||||
pp::Rect rect;
|
||||
gfx::Rect rect;
|
||||
pp::ImageData image_data;
|
||||
|
||||
// Whether to flush to screen immediately; otherwise, when the rest of the
|
||||
|
@ -48,6 +48,7 @@ class SkBitmap;
|
||||
namespace gfx {
|
||||
class Rect;
|
||||
class Size;
|
||||
class Vector2d;
|
||||
} // namespace gfx
|
||||
|
||||
namespace pp {
|
||||
@ -134,7 +135,7 @@ class PDFEngine {
|
||||
virtual void Invalidate(const pp::Rect& rect) {}
|
||||
|
||||
// Informs the client to scroll the plugin area by the given offset.
|
||||
virtual void DidScroll(const pp::Point& point) {}
|
||||
virtual void DidScroll(const gfx::Vector2d& offset) {}
|
||||
|
||||
// Scroll the horizontal/vertical scrollbars to a given position.
|
||||
// Values are in screen coordinates, where 0 is the top/left of the document
|
||||
|
@ -61,6 +61,7 @@
|
||||
#include "third_party/skia/include/core/SkBitmap.h"
|
||||
#include "ui/events/keycodes/keyboard_codes.h"
|
||||
#include "ui/gfx/geometry/rect.h"
|
||||
#include "ui/gfx/geometry/vector2d.h"
|
||||
#include "v8/include/v8.h"
|
||||
|
||||
#if defined(OS_LINUX)
|
||||
@ -513,7 +514,7 @@ void PDFiumEngine::ScrolledToXPosition(int position) {
|
||||
int old_x = position_.x();
|
||||
position_.set_x(position);
|
||||
CalculateVisiblePages();
|
||||
client_->DidScroll(pp::Point(old_x - position, 0));
|
||||
client_->DidScroll(gfx::Vector2d(old_x - position, 0));
|
||||
OnSelectionPositionChanged();
|
||||
}
|
||||
|
||||
@ -523,7 +524,7 @@ void PDFiumEngine::ScrolledToYPosition(int position) {
|
||||
int old_y = position_.y();
|
||||
position_.set_y(position);
|
||||
CalculateVisiblePages();
|
||||
client_->DidScroll(pp::Point(0, old_y - position));
|
||||
client_->DidScroll(gfx::Vector2d(0, old_y - position));
|
||||
OnSelectionPositionChanged();
|
||||
}
|
||||
|
||||
|
@ -26,7 +26,7 @@ void PreviewModeClient::Invalidate(const pp::Rect& rect) {
|
||||
NOTREACHED();
|
||||
}
|
||||
|
||||
void PreviewModeClient::DidScroll(const pp::Point& point) {
|
||||
void PreviewModeClient::DidScroll(const gfx::Vector2d& point) {
|
||||
NOTREACHED();
|
||||
}
|
||||
|
||||
|
@ -13,6 +13,10 @@
|
||||
#include "base/callback_forward.h"
|
||||
#include "pdf/pdf_engine.h"
|
||||
|
||||
namespace gfx {
|
||||
class Vector2d;
|
||||
} // namespace gfx
|
||||
|
||||
namespace chrome_pdf {
|
||||
|
||||
// The interface that's provided to the print preview rendering engine.
|
||||
@ -30,7 +34,7 @@ class PreviewModeClient : public PDFEngine::Client {
|
||||
// PDFEngine::Client implementation.
|
||||
void ProposeDocumentLayout(const DocumentLayout& layout) override;
|
||||
void Invalidate(const pp::Rect& rect) override;
|
||||
void DidScroll(const pp::Point& point) override;
|
||||
void DidScroll(const gfx::Vector2d& offset) override;
|
||||
void ScrollToX(int x_in_screen_coords) override;
|
||||
void ScrollToY(int y_in_screen_coords, bool compensate_for_toolbar) override;
|
||||
void ScrollBy(const pp::Point& point) override;
|
||||
|
Reference in New Issue
Block a user