1e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata// Copyright (c) 2010 The Chromium Authors. All rights reserved. 2e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata// Use of this source code is governed by a BSD-style license that can be 3e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata// found in the LICENSE file. 4e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata 5e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata#include "pdf/paint_aggregator.h" 6e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata 7e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata#include <algorithm> 8e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata 9e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata#include "base/logging.h" 10e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata 11e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata// ---------------------------------------------------------------------------- 12e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata// ALGORITHM NOTES 13e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata// 14e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata// We attempt to maintain a scroll rect in the presence of invalidations that 15e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata// are contained within the scroll rect. If an invalidation crosses a scroll 16e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata// rect, then we just treat the scroll rect as an invalidation rect. 17e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata// 18e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata// For invalidations performed prior to scrolling and contained within the 19e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata// scroll rect, we offset the invalidation rects to account for the fact that 20e99af270a60891e68d465c4cd97dbe29cd1a05e4Petr Machata// the consumer will perform scrolling before painting. 21b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias// 22b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias// We only support scrolling along one axis at a time. A diagonal scroll will 23b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias// therefore be treated as an invalidation. 24b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias// ---------------------------------------------------------------------------- 25b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias 26b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. IglesiasPaintAggregator::PaintUpdate::PaintUpdate() { 27b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias} 28b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias 29366c2f46d844f040458df9b7e35fc3b8527ed2d3Petr MachataPaintAggregator::PaintUpdate::~PaintUpdate() { 30b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias} 31b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias 32b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. IglesiasPaintAggregator::InternalPaintUpdate::InternalPaintUpdate() : 33b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias synthesized_scroll_damage_rect_(false) { 34b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias} 35b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias 36b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. IglesiasPaintAggregator::InternalPaintUpdate::~InternalPaintUpdate() { 37b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias} 38b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias 39b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesiaspp::Rect PaintAggregator::InternalPaintUpdate::GetScrollDamage() const { 40929bd57ca202fd2f2e8485ebf65d683e664f67b5Petr Machata // Should only be scrolling in one direction at a time. 41b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias DCHECK(!(scroll_delta.x() && scroll_delta.y())); 42b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias 43b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias pp::Rect damaged_rect; 44b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias 45929bd57ca202fd2f2e8485ebf65d683e664f67b5Petr Machata // Compute the region we will expose by scrolling, and paint that into a 46b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias // shared memory section. 47b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias if (scroll_delta.x()) { 48b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias int32_t dx = scroll_delta.x(); 49b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias damaged_rect.set_y(scroll_rect.y()); 50929bd57ca202fd2f2e8485ebf65d683e664f67b5Petr Machata damaged_rect.set_height(scroll_rect.height()); 51b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias if (dx > 0) { 52b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias damaged_rect.set_x(scroll_rect.x()); 53b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias damaged_rect.set_width(dx); 54b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias } else { 55929bd57ca202fd2f2e8485ebf65d683e664f67b5Petr Machata damaged_rect.set_x(scroll_rect.right() + dx); 56b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias damaged_rect.set_width(-dx); 57b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias } 58b1dda4bc2c78429823a5ca7699f3207a7aea2371Edgar E. Iglesias } else { 59 int32_t dy = scroll_delta.y(); 60 damaged_rect.set_x(scroll_rect.x()); 61 damaged_rect.set_width(scroll_rect.width()); 62 if (dy > 0) { 63 damaged_rect.set_y(scroll_rect.y()); 64 damaged_rect.set_height(dy); 65 } else { 66 damaged_rect.set_y(scroll_rect.bottom() + dy); 67 damaged_rect.set_height(-dy); 68 } 69 } 70 71 // In case the scroll offset exceeds the width/height of the scroll rect 72 return scroll_rect.Intersect(damaged_rect); 73} 74 75PaintAggregator::PaintAggregator() { 76} 77 78bool PaintAggregator::HasPendingUpdate() const { 79 return !update_.scroll_rect.IsEmpty() || !update_.paint_rects.empty(); 80} 81 82void PaintAggregator::ClearPendingUpdate() { 83 update_ = InternalPaintUpdate(); 84} 85 86PaintAggregator::PaintUpdate PaintAggregator::GetPendingUpdate() { 87 // Convert the internal paint update to the external one, which includes a 88 // bit more precomputed info for the caller. 89 PaintUpdate ret; 90 ret.scroll_delta = update_.scroll_delta; 91 ret.scroll_rect = update_.scroll_rect; 92 ret.has_scroll = ret.scroll_delta.x() != 0 || ret.scroll_delta.y() != 0; 93 94 // Include the scroll damage (if any) in the paint rects. 95 // Code invalidates damaged rect here, it pick it up from the list of paint 96 // rects in the next block. 97 if (ret.has_scroll && !update_.synthesized_scroll_damage_rect_) { 98 update_.synthesized_scroll_damage_rect_ = true; 99 pp::Rect scroll_damage = update_.GetScrollDamage(); 100 InvalidateRectInternal(scroll_damage, false); 101 } 102 103 ret.paint_rects.reserve(update_.paint_rects.size() + 1); 104 for (size_t i = 0; i < update_.paint_rects.size(); i++) 105 ret.paint_rects.push_back(update_.paint_rects[i]); 106 107 return ret; 108} 109 110void PaintAggregator::SetIntermediateResults( 111 const std::vector<ReadyRect>& ready, 112 const std::vector<pp::Rect>& pending) { 113 update_.ready_rects.insert( 114 update_.ready_rects.end(), ready.begin(), ready.end()); 115 update_.paint_rects = pending; 116} 117 118std::vector<PaintAggregator::ReadyRect> PaintAggregator::GetReadyRects() const { 119 return update_.ready_rects; 120} 121 122void PaintAggregator::InvalidateRect(const pp::Rect& rect) { 123 InvalidateRectInternal(rect, true); 124} 125 126void PaintAggregator::ScrollRect(const pp::Rect& clip_rect, 127 const pp::Point& amount) { 128 // We only support scrolling along one axis at a time. 129 if (amount.x() != 0 && amount.y() != 0) { 130 InvalidateRect(clip_rect); 131 return; 132 } 133 134 // We can only scroll one rect at a time. 135 if (!update_.scroll_rect.IsEmpty() && update_.scroll_rect != clip_rect) { 136 InvalidateRect(clip_rect); 137 return; 138 } 139 140 // Again, we only support scrolling along one axis at a time. Make sure this 141 // update doesn't scroll on a different axis than any existing one. 142 if ((amount.x() && update_.scroll_delta.y()) || 143 (amount.y() && update_.scroll_delta.x())) { 144 InvalidateRect(clip_rect); 145 return; 146 } 147 148 // The scroll rect is new or isn't changing (though the scroll amount may 149 // be changing). 150 update_.scroll_rect = clip_rect; 151 update_.scroll_delta += amount; 152 153 // We might have just wiped out a pre-existing scroll. 154 if (update_.scroll_delta == pp::Point()) { 155 update_.scroll_rect = pp::Rect(); 156 return; 157 } 158 159 // Adjust any paint rects that intersect the scroll. For the portion of the 160 // paint that is inside the scroll area, move it by the scroll amount and 161 // replace the existing paint with it. For the portion (if any) that is 162 // outside the scroll, just invalidate it. 163 std::vector<pp::Rect> leftover_rects; 164 for (size_t i = 0; i < update_.paint_rects.size(); ++i) { 165 if (!update_.scroll_rect.Intersects(update_.paint_rects[i])) 166 continue; 167 168 pp::Rect intersection = 169 update_.paint_rects[i].Intersect(update_.scroll_rect); 170 pp::Rect rect = update_.paint_rects[i]; 171 while (!rect.IsEmpty()) { 172 pp::Rect leftover = rect.Subtract(intersection); 173 if (leftover.IsEmpty()) 174 break; 175 // Don't want to call InvalidateRectInternal now since it'll modify 176 // update_.paint_rects, so keep track of this and do it below. 177 leftover_rects.push_back(leftover); 178 rect = rect.Subtract(leftover); 179 } 180 181 update_.paint_rects[i] = ScrollPaintRect(intersection, amount); 182 183 // The rect may have been scrolled out of view. 184 if (update_.paint_rects[i].IsEmpty()) { 185 update_.paint_rects.erase(update_.paint_rects.begin() + i); 186 i--; 187 } 188 } 189 190 for (size_t i = 0; i < leftover_rects.size(); ++i) 191 InvalidateRectInternal(leftover_rects[i], false); 192 193 for (size_t i = 0; i < update_.ready_rects.size(); ++i) { 194 if (update_.scroll_rect.Contains(update_.ready_rects[i].rect)) { 195 update_.ready_rects[i].rect = 196 ScrollPaintRect(update_.ready_rects[i].rect, amount); 197 } 198 } 199 200 if (update_.synthesized_scroll_damage_rect_) { 201 pp::Rect damage = update_.GetScrollDamage(); 202 InvalidateRect(damage); 203 } 204} 205 206pp::Rect PaintAggregator::ScrollPaintRect(const pp::Rect& paint_rect, 207 const pp::Point& amount) const { 208 pp::Rect result = paint_rect; 209 result.Offset(amount); 210 result = update_.scroll_rect.Intersect(result); 211 return result; 212} 213 214void PaintAggregator::InvalidateScrollRect() { 215 pp::Rect scroll_rect = update_.scroll_rect; 216 update_.scroll_rect = pp::Rect(); 217 update_.scroll_delta = pp::Point(); 218 InvalidateRect(scroll_rect); 219} 220 221void PaintAggregator::InvalidateRectInternal(const pp::Rect& rect_old, 222 bool check_scroll) { 223 pp::Rect rect = rect_old; 224 // Check if any rects that are ready to be painted overlap. 225 for (size_t i = 0; i < update_.ready_rects.size(); ++i) { 226 const pp::Rect& existing_rect = update_.ready_rects[i].rect; 227 if (rect.Intersects(existing_rect)) { 228 // Re-invalidate in case the union intersects other paint rects. 229 rect = existing_rect.Union(rect); 230 update_.ready_rects.erase(update_.ready_rects.begin() + i); 231 break; 232 } 233 } 234 235 bool add_paint = true; 236 237 // Combine overlapping paints using smallest bounding box. 238 for (size_t i = 0; i < update_.paint_rects.size(); ++i) { 239 const pp::Rect& existing_rect = update_.paint_rects[i]; 240 if (existing_rect.Contains(rect)) // Optimize out redundancy. 241 add_paint = false; 242 if (rect.Intersects(existing_rect) || rect.SharesEdgeWith(existing_rect)) { 243 // Re-invalidate in case the union intersects other paint rects. 244 pp::Rect combined_rect = existing_rect.Union(rect); 245 update_.paint_rects.erase(update_.paint_rects.begin() + i); 246 InvalidateRectInternal(combined_rect, check_scroll); 247 add_paint = false; 248 } 249 } 250 251 if (add_paint) { 252 // Add a non-overlapping paint. 253 update_.paint_rects.push_back(rect); 254 } 255 256 // If the new paint overlaps with a scroll, then also invalidate the rect in 257 // its new position. 258 if (check_scroll && 259 !update_.scroll_rect.IsEmpty() && 260 update_.scroll_rect.Intersects(rect)) { 261 InvalidateRectInternal(ScrollPaintRect(rect, update_.scroll_delta), false); 262 } 263} 264