blob: 3ad114c1a08f00c3f3753751936e89e769ad21b6 [file] [log] [blame]
// Copyright (c) 2010 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/paint_aggregator.h"
#include <stddef.h>
#include <stdint.h>
#include <algorithm>
#include "base/logging.h"
namespace {
bool IsNegative(int32_t num) {
return num < 0;
}
} // namespace
// ----------------------------------------------------------------------------
// ALGORITHM NOTES
//
// We attempt to maintain a scroll rect in the presence of invalidations that
// are contained within the scroll rect. If an invalidation crosses a scroll
// rect, then we just treat the scroll rect as an invalidation rect.
//
// For invalidations performed prior to scrolling and contained within the
// scroll rect, we offset the invalidation rects to account for the fact that
// the consumer will perform scrolling before painting.
//
// We only support scrolling along one axis at a time. A diagonal scroll will
// therefore be treated as an invalidation.
// ----------------------------------------------------------------------------
PaintAggregator::PaintUpdate::PaintUpdate() = default;
PaintAggregator::PaintUpdate::PaintUpdate(const PaintUpdate& that) = default;
PaintAggregator::PaintUpdate::~PaintUpdate() = default;
PaintAggregator::InternalPaintUpdate::InternalPaintUpdate()
: synthesized_scroll_damage_rect_(false) {}
PaintAggregator::InternalPaintUpdate::~InternalPaintUpdate() {}
pp::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;
// Compute the region we will expose by scrolling, and paint that into a
// shared memory section.
if (scroll_delta.x()) {
int32_t dx = scroll_delta.x();
damaged_rect.set_y(scroll_rect.y());
damaged_rect.set_height(scroll_rect.height());
if (dx > 0) {
damaged_rect.set_x(scroll_rect.x());
damaged_rect.set_width(dx);
} else {
damaged_rect.set_x(scroll_rect.right() + dx);
damaged_rect.set_width(-dx);
}
} else {
int32_t dy = scroll_delta.y();
damaged_rect.set_x(scroll_rect.x());
damaged_rect.set_width(scroll_rect.width());
if (dy > 0) {
damaged_rect.set_y(scroll_rect.y());
damaged_rect.set_height(dy);
} else {
damaged_rect.set_y(scroll_rect.bottom() + dy);
damaged_rect.set_height(-dy);
}
}
// In case the scroll offset exceeds the width/height of the scroll rect
return scroll_rect.Intersect(damaged_rect);
}
PaintAggregator::PaintAggregator() {}
bool PaintAggregator::HasPendingUpdate() const {
return !update_.scroll_rect.IsEmpty() || !update_.paint_rects.empty();
}
void PaintAggregator::ClearPendingUpdate() {
update_ = InternalPaintUpdate();
}
PaintAggregator::PaintUpdate PaintAggregator::GetPendingUpdate() {
// Convert the internal paint update to the external one, which includes a
// bit more precomputed info for the caller.
PaintUpdate ret;
ret.scroll_delta = update_.scroll_delta;
ret.scroll_rect = update_.scroll_rect;
ret.has_scroll = ret.scroll_delta.x() != 0 || ret.scroll_delta.y() != 0;
// Include the scroll damage (if any) in the paint rects.
// Code invalidates damaged rect here, it pick it up from the list of paint
// 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();
InvalidateRectInternal(scroll_damage, false);
}
ret.paint_rects.reserve(update_.paint_rects.size() + 1);
ret.paint_rects.insert(ret.paint_rects.end(), update_.paint_rects.begin(),
update_.paint_rects.end());
return ret;
}
void PaintAggregator::SetIntermediateResults(
const std::vector<ReadyRect>& ready,
const std::vector<pp::Rect>& pending) {
update_.ready_rects.insert(update_.ready_rects.end(), ready.begin(),
ready.end());
update_.paint_rects = pending;
}
std::vector<PaintAggregator::ReadyRect> PaintAggregator::GetReadyRects() const {
return update_.ready_rects;
}
void PaintAggregator::InvalidateRect(const pp::Rect& rect) {
InvalidateRectInternal(rect, true);
}
void PaintAggregator::ScrollRect(const pp::Rect& clip_rect,
const pp::Point& amount) {
// We only support scrolling along one axis at a time.
if (amount.x() != 0 && amount.y() != 0) {
InvalidateRect(clip_rect);
return;
}
// We can only scroll one rect at a time.
if (!update_.scroll_rect.IsEmpty() && update_.scroll_rect != clip_rect) {
InvalidateRect(clip_rect);
return;
}
// Again, we only support scrolling along one axis at a time. Make sure this
// update doesn't scroll on a different axis than any existing one.
if ((amount.x() && update_.scroll_delta.y()) ||
(amount.y() && update_.scroll_delta.x())) {
InvalidateRect(clip_rect);
return;
}
// If we scroll in a reverse direction to the direction we originally scrolled
// and there were invalidations that happened in-between we may end up
// incorrectly clipping the invalidated rects (see crbug.com/488390). This bug
// doesn't exist in the original implementation
// (ppapi/utility/graphics/paint_aggregator.cc) which uses a different method
// of handling invalidations that occur after a scroll. The problem is that
// when we scroll the invalidated region, we clip it to the scroll rect. This
// can cause us to lose information about what the invalidated region was if
// it gets scrolled back into view. We either need to not do this clipping or
// disallow combining scrolls that occur in different directions with
// invalidations that happen in-between. This code really needs some tests...
if (!update_.paint_rects.empty()) {
if (IsNegative(amount.x()) != IsNegative(update_.scroll_delta.x()) ||
IsNegative(amount.y()) != IsNegative(update_.scroll_delta.y())) {
InvalidateRect(clip_rect);
return;
}
}
// The scroll rect is new or isn't changing (though the scroll amount may
// be changing).
update_.scroll_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();
return;
}
// Adjust any paint rects that intersect the scroll. For the portion of the
// 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;
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];
while (!rect.IsEmpty()) {
pp::Rect leftover = rect.Subtract(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);
}
update_.paint_rects[i] = ScrollPaintRect(intersection, amount);
// The rect may have been scrolled out of view.
if (update_.paint_rects[i].IsEmpty()) {
update_.paint_rects.erase(update_.paint_rects.begin() + i);
i--;
}
}
for (const auto& leftover_rect : leftover_rects)
InvalidateRectInternal(leftover_rect, false);
for (auto& update_rect : update_.ready_rects) {
if (update_.scroll_rect.Contains(update_rect.rect))
update_rect.rect = ScrollPaintRect(update_rect.rect, amount);
}
if (update_.synthesized_scroll_damage_rect_) {
pp::Rect damage = update_.GetScrollDamage();
InvalidateRect(damage);
}
}
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);
return result;
}
void PaintAggregator::InvalidateScrollRect() {
pp::Rect scroll_rect = update_.scroll_rect;
update_.scroll_rect = pp::Rect();
update_.scroll_delta = pp::Point();
InvalidateRect(scroll_rect);
}
void PaintAggregator::InvalidateRectInternal(const pp::Rect& rect_old,
bool check_scroll) {
pp::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;
if (rect.Intersects(existing_rect)) {
// Re-invalidate in case the union intersects other paint rects.
rect = existing_rect.Union(rect);
update_.ready_rects.erase(update_.ready_rects.begin() + i);
break;
}
}
bool add_paint = true;
// 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];
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);
update_.paint_rects.erase(update_.paint_rects.begin() + i);
InvalidateRectInternal(combined_rect, check_scroll);
add_paint = false;
}
}
if (add_paint) {
// Add a non-overlapping paint.
update_.paint_rects.push_back(rect);
}
// If the new paint overlaps with a scroll, then also invalidate the rect in
// its new position.
if (check_scroll && !update_.scroll_rect.IsEmpty() &&
update_.scroll_rect.Intersects(rect)) {
InvalidateRectInternal(ScrollPaintRect(rect, update_.scroll_delta), false);
}
}