src/ppapi/tests/test_paint_aggregator.cc

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ppapi/tests/test_paint_aggregator.h"
   6
   7 #include "ppapi/tests/testing_instance.h"
   8 #include "ppapi/utility/graphics/paint_aggregator.h"
   9
  10 REGISTER_TEST_CASE(PaintAggregator);
  11
  12 bool TestPaintAggregator::Init() {
  13   return true;
  14 }
  15
  16 void TestPaintAggregator::RunTests(const std::string& filter) {
  17   RUN_TEST(InitialState, filter);
  18   RUN_TEST(SingleInvalidation, filter);
  19   RUN_TEST(DoubleDisjointInvalidation, filter);
  20   RUN_TEST(SingleScroll, filter);
  21   RUN_TEST(DoubleOverlappingScroll, filter);
  22   RUN_TEST(NegatingScroll, filter);
  23   RUN_TEST(DiagonalScroll, filter);
  24   RUN_TEST(ContainedPaintAfterScroll, filter);
  25   RUN_TEST(ContainedPaintBeforeScroll, filter);
  26   RUN_TEST(ContainedPaintsBeforeAndAfterScroll, filter);
  27   RUN_TEST(LargeContainedPaintAfterScroll, filter);
  28   RUN_TEST(LargeContainedPaintBeforeScroll, filter);
  29   RUN_TEST(OverlappingPaintBeforeScroll, filter);
  30   RUN_TEST(OverlappingPaintAfterScroll, filter);
  31   RUN_TEST(DisjointPaintBeforeScroll, filter);
  32   RUN_TEST(DisjointPaintAfterScroll, filter);
  33   RUN_TEST(ContainedPaintTrimmedByScroll, filter);
  34   RUN_TEST(ContainedPaintEliminatedByScroll, filter);
  35   RUN_TEST(ContainedPaintAfterScrollTrimmedByScrollDamage, filter);
  36   RUN_TEST(ContainedPaintAfterScrollEliminatedByScrollDamage, filter);
  37 }
  38
  39 std::string TestPaintAggregator::TestInitialState() {
  40   pp::PaintAggregator greg;
  41   if (greg.HasPendingUpdate())
  42     return "Pending update invalid";
  43   PASS();
  44 }
  45
  46 std::string TestPaintAggregator::TestSingleInvalidation() {
  47   pp::PaintAggregator greg;
  48
  49   pp::Rect rect(2, 4, 10, 16);
  50   greg.InvalidateRect(rect);
  51
  52   ASSERT_TRUE(greg.HasPendingUpdate());
  53   ASSERT_TRUE(greg.GetPendingUpdate().scroll_rect.IsEmpty());
  54   ASSERT_TRUE(1U == greg.GetPendingUpdate().paint_rects.size());
  55
  56   ASSERT_TRUE(rect == greg.GetPendingUpdate().paint_rects[0]);
  57
  58   PASS();
  59 }
  60
  61 std::string TestPaintAggregator::TestDoubleDisjointInvalidation() {
  62   pp::PaintAggregator greg;
  63
  64   pp::Rect r1(2, 4, 2, 4);
  65   pp::Rect r2(4, 2, 4, 2);
  66
  67   greg.InvalidateRect(r1);
  68   greg.InvalidateRect(r2);
  69
  70   pp::Rect expected_bounds = r1.Union(r2);
  71
  72   ASSERT_TRUE(greg.HasPendingUpdate());
  73   ASSERT_TRUE(greg.GetPendingUpdate().scroll_rect.IsEmpty());
  74   ASSERT_TRUE(2U == greg.GetPendingUpdate().paint_rects.size());
  75
  76   ASSERT_TRUE(expected_bounds == greg.GetPendingUpdate().paint_bounds);
  77   PASS();
  78 }
  79
  80 std::string TestPaintAggregator::TestSingleScroll() {
  81   pp::PaintAggregator greg;
  82
  83   pp::Rect r1(2, 4, 2, 4);
  84   pp::Rect r2(4, 2, 4, 2);
  85
  86   greg.InvalidateRect(r1);
  87   greg.InvalidateRect(r2);
  88
  89   pp::Rect expected_bounds = r1.Union(r2);
  90
  91   ASSERT_TRUE(greg.HasPendingUpdate());
  92   ASSERT_TRUE(greg.GetPendingUpdate().scroll_rect.IsEmpty());
  93   ASSERT_TRUE(2U == greg.GetPendingUpdate().paint_rects.size());
  94
  95   ASSERT_TRUE(expected_bounds == greg.GetPendingUpdate().paint_bounds);
  96   PASS();
  97 }
  98
  99 std::string TestPaintAggregator::TestDoubleOverlappingScroll() {
 100   pp::PaintAggregator greg;
 101
 102   pp::Rect rect(1, 2, 3, 4);
 103   pp::Point delta1(1, 0);
 104   pp::Point delta2(1, 0);
 105   greg.ScrollRect(rect, delta1);
 106   greg.ScrollRect(rect, delta2);
 107
 108   ASSERT_TRUE(greg.HasPendingUpdate());
 109   ASSERT_TRUE(1U == greg.GetPendingUpdate().paint_rects.size());
 110   ASSERT_FALSE(greg.GetPendingUpdate().scroll_rect.IsEmpty());
 111
 112   ASSERT_TRUE(rect == greg.GetPendingUpdate().scroll_rect);
 113
 114   pp::Point expected_delta(delta1.x() + delta2.x(),
 115                             delta1.y() + delta2.y());
 116   ASSERT_TRUE(expected_delta.x() == greg.GetPendingUpdate().scroll_delta.x());
 117   ASSERT_TRUE(expected_delta.y() == greg.GetPendingUpdate().scroll_delta.y());
 118
 119   pp::Rect resulting_damage = greg.GetPendingUpdate().paint_rects[0];
 120   pp::Rect expected_damage(1, 2, 2, 4);
 121   ASSERT_TRUE(expected_damage == resulting_damage);
 122   PASS();
 123 }
 124
 125 std::string TestPaintAggregator::TestNegatingScroll() {
 126   pp::PaintAggregator greg;
 127
 128   // Scroll twice in opposite directions by equal amounts.  The result
 129   // should be no scrolling.
 130
 131   pp::Rect rect(1, 2, 3, 4);
 132   pp::Point delta1(1, 0);
 133   pp::Point delta2(-1, 0);
 134   greg.ScrollRect(rect, delta1);
 135   greg.ScrollRect(rect, delta2);
 136
 137   ASSERT_FALSE(greg.HasPendingUpdate());
 138   PASS();
 139 }
 140
 141 std::string TestPaintAggregator::TestDiagonalScroll() {
 142   pp::PaintAggregator greg;
 143
 144   // We don't support optimized diagonal scrolling, so this should result in
 145   // repainting.
 146
 147   pp::Rect rect(1, 2, 3, 4);
 148   pp::Point delta(1, 1);
 149   greg.ScrollRect(rect, delta);
 150
 151   ASSERT_TRUE(greg.HasPendingUpdate());
 152   ASSERT_TRUE(greg.GetPendingUpdate().scroll_rect.IsEmpty());
 153   ASSERT_TRUE(1U == greg.GetPendingUpdate().paint_rects.size());
 154
 155   ASSERT_TRUE(rect == greg.GetPendingUpdate().paint_rects[0]);
 156   PASS();
 157 }
 158
 159 std::string TestPaintAggregator::TestContainedPaintAfterScroll() {
 160   pp::PaintAggregator greg;
 161
 162   pp::Rect scroll_rect(0, 0, 10, 10);
 163   greg.ScrollRect(scroll_rect, pp::Point(2, 0));
 164
 165   pp::Rect paint_rect(4, 4, 2, 2);
 166   greg.InvalidateRect(paint_rect);
 167
 168   ASSERT_TRUE(greg.HasPendingUpdate());
 169
 170   // Expecting a paint rect inside the scroll rect. The last paint rect is the
 171   // scroll dirty rect.
 172   ASSERT_FALSE(greg.GetPendingUpdate().scroll_rect.IsEmpty());
 173   ASSERT_TRUE(2U == greg.GetPendingUpdate().paint_rects.size());
 174
 175   ASSERT_TRUE(scroll_rect == greg.GetPendingUpdate().scroll_rect);
 176   ASSERT_TRUE(paint_rect == greg.GetPendingUpdate().paint_rects[0]);
 177   PASS();
 178 }
 179
 180 std::string TestPaintAggregator::TestContainedPaintBeforeScroll() {
 181   pp::PaintAggregator greg;
 182
 183   pp::Rect paint_rect(4, 4, 2, 2);
 184   greg.InvalidateRect(paint_rect);
 185
 186   pp::Rect scroll_rect(0, 0, 10, 10);
 187   greg.ScrollRect(scroll_rect, pp::Point(2, 0));
 188
 189   ASSERT_TRUE(greg.HasPendingUpdate());
 190
 191   // Expecting a paint rect inside the scroll rect. The last paint rect is the
 192   // scroll dirty rect.
 193   ASSERT_FALSE(greg.GetPendingUpdate().scroll_rect.IsEmpty());
 194   ASSERT_TRUE(2U == greg.GetPendingUpdate().paint_rects.size());
 195
 196   paint_rect.Offset(2, 0);
 197
 198   ASSERT_TRUE(scroll_rect == greg.GetPendingUpdate().scroll_rect);
 199   ASSERT_TRUE(paint_rect == greg.GetPendingUpdate().paint_rects[0]);
 200   PASS();
 201 }
 202
 203 std::string TestPaintAggregator::TestContainedPaintsBeforeAndAfterScroll() {
 204   pp::PaintAggregator greg;
 205
 206   pp::Rect paint_rect1(4, 4, 2, 2);
 207   greg.InvalidateRect(paint_rect1);
 208
 209   pp::Rect scroll_rect(0, 0, 10, 10);
 210   greg.ScrollRect(scroll_rect, pp::Point(2, 0));
 211
 212   pp::Rect paint_rect2(6, 4, 2, 2);
 213   greg.InvalidateRect(paint_rect2);
 214
 215   pp::Rect expected_paint_rect = paint_rect2;
 216
 217   ASSERT_TRUE(greg.HasPendingUpdate());
 218
 219   // Expecting a paint rect inside the scroll rect
 220   ASSERT_FALSE(greg.GetPendingUpdate().scroll_rect.IsEmpty());
 221   ASSERT_TRUE(2U == greg.GetPendingUpdate().paint_rects.size());
 222
 223   ASSERT_TRUE(scroll_rect == greg.GetPendingUpdate().scroll_rect);
 224   ASSERT_TRUE(expected_paint_rect == greg.GetPendingUpdate().paint_rects[0]);
 225   PASS();
 226 }
 227
 228 std::string TestPaintAggregator::TestLargeContainedPaintAfterScroll() {
 229   pp::PaintAggregator greg;
 230
 231   pp::Rect scroll_rect(0, 0, 10, 10);
 232   greg.ScrollRect(scroll_rect, pp::Point(0, 1));
 233
 234   pp::Rect paint_rect(0, 0, 10, 9);  // Repaint 90%
 235   greg.InvalidateRect(paint_rect);
 236
 237   ASSERT_TRUE(greg.HasPendingUpdate());
 238
 239   ASSERT_TRUE(greg.GetPendingUpdate().scroll_rect.IsEmpty());
 240   ASSERT_TRUE(1U == greg.GetPendingUpdate().paint_rects.size());
 241
 242   ASSERT_TRUE(scroll_rect == greg.GetPendingUpdate().paint_rects[0]);
 243   PASS();
 244 }
 245
 246 std::string TestPaintAggregator::TestLargeContainedPaintBeforeScroll() {
 247   pp::PaintAggregator greg;
 248
 249   pp::Rect paint_rect(0, 0, 10, 9);  // Repaint 90%
 250   greg.InvalidateRect(paint_rect);
 251
 252   pp::Rect scroll_rect(0, 0, 10, 10);
 253   greg.ScrollRect(scroll_rect, pp::Point(0, 1));
 254
 255   ASSERT_TRUE(greg.HasPendingUpdate());
 256
 257   ASSERT_TRUE(greg.GetPendingUpdate().scroll_rect.IsEmpty());
 258   ASSERT_TRUE(1U == greg.GetPendingUpdate().paint_rects.size());
 259
 260   ASSERT_TRUE(scroll_rect == greg.GetPendingUpdate().paint_rects[0]);
 261   PASS();
 262 }
 263
 264 std::string TestPaintAggregator::TestOverlappingPaintBeforeScroll() {
 265   pp::PaintAggregator greg;
 266
 267   pp::Rect paint_rect(4, 4, 10, 2);
 268   greg.InvalidateRect(paint_rect);
 269
 270   pp::Rect scroll_rect(0, 0, 10, 10);
 271   greg.ScrollRect(scroll_rect, pp::Point(2, 0));
 272
 273   pp::Rect expected_paint_rect = scroll_rect.Union(paint_rect);
 274
 275   ASSERT_TRUE(greg.HasPendingUpdate());
 276
 277   ASSERT_TRUE(greg.GetPendingUpdate().scroll_rect.IsEmpty());
 278   ASSERT_TRUE(1U == greg.GetPendingUpdate().paint_rects.size());
 279
 280   ASSERT_TRUE(expected_paint_rect == greg.GetPendingUpdate().paint_rects[0]);
 281   PASS();
 282 }
 283
 284 std::string TestPaintAggregator::TestOverlappingPaintAfterScroll() {
 285   pp::PaintAggregator greg;
 286
 287   pp::Rect scroll_rect(0, 0, 10, 10);
 288   greg.ScrollRect(scroll_rect, pp::Point(2, 0));
 289
 290   pp::Rect paint_rect(4, 4, 10, 2);
 291   greg.InvalidateRect(paint_rect);
 292
 293   pp::Rect expected_paint_rect = scroll_rect.Union(paint_rect);
 294
 295   ASSERT_TRUE(greg.HasPendingUpdate());
 296
 297   ASSERT_TRUE(greg.GetPendingUpdate().scroll_rect.IsEmpty());
 298   ASSERT_TRUE(1U == greg.GetPendingUpdate().paint_rects.size());
 299
 300   ASSERT_TRUE(expected_paint_rect == greg.GetPendingUpdate().paint_rects[0]);
 301   PASS();
 302 }
 303
 304 std::string TestPaintAggregator::TestDisjointPaintBeforeScroll() {
 305   pp::PaintAggregator greg;
 306
 307   pp::Rect paint_rect(4, 4, 10, 2);
 308   greg.InvalidateRect(paint_rect);
 309
 310   pp::Rect scroll_rect(0, 0, 2, 10);
 311   greg.ScrollRect(scroll_rect, pp::Point(2, 0));
 312
 313   ASSERT_TRUE(greg.HasPendingUpdate());
 314
 315   ASSERT_FALSE(greg.GetPendingUpdate().scroll_rect.IsEmpty());
 316   ASSERT_TRUE(2U == greg.GetPendingUpdate().paint_rects.size());
 317
 318   ASSERT_TRUE(paint_rect == greg.GetPendingUpdate().paint_rects[0]);
 319   ASSERT_TRUE(scroll_rect == greg.GetPendingUpdate().scroll_rect);
 320   PASS();
 321 }
 322
 323 std::string TestPaintAggregator::TestDisjointPaintAfterScroll() {
 324   pp::PaintAggregator greg;
 325
 326   pp::Rect scroll_rect(0, 0, 2, 10);
 327   greg.ScrollRect(scroll_rect, pp::Point(2, 0));
 328
 329   pp::Rect paint_rect(4, 4, 10, 2);
 330   greg.InvalidateRect(paint_rect);
 331
 332   ASSERT_TRUE(greg.HasPendingUpdate());
 333
 334   ASSERT_FALSE(greg.GetPendingUpdate().scroll_rect.IsEmpty());
 335   ASSERT_TRUE(2U == greg.GetPendingUpdate().paint_rects.size());
 336
 337   ASSERT_TRUE(paint_rect == greg.GetPendingUpdate().paint_rects[0]);
 338   ASSERT_TRUE(scroll_rect == greg.GetPendingUpdate().scroll_rect);
 339   PASS();
 340 }
 341
 342 std::string TestPaintAggregator::TestContainedPaintTrimmedByScroll() {
 343   pp::PaintAggregator greg;
 344
 345   pp::Rect paint_rect(4, 4, 6, 6);
 346   greg.InvalidateRect(paint_rect);
 347
 348   pp::Rect scroll_rect(0, 0, 10, 10);
 349   greg.ScrollRect(scroll_rect, pp::Point(2, 0));
 350
 351   // The paint rect should have become narrower.
 352   pp::Rect expected_paint_rect(6, 4, 4, 6);
 353
 354   ASSERT_TRUE(greg.HasPendingUpdate());
 355
 356   ASSERT_FALSE(greg.GetPendingUpdate().scroll_rect.IsEmpty());
 357   ASSERT_TRUE(2U == greg.GetPendingUpdate().paint_rects.size());
 358
 359   ASSERT_TRUE(expected_paint_rect == greg.GetPendingUpdate().paint_rects[0]);
 360   ASSERT_TRUE(scroll_rect == greg.GetPendingUpdate().scroll_rect);
 361   PASS();
 362 }
 363
 364 std::string TestPaintAggregator::TestContainedPaintEliminatedByScroll() {
 365   pp::PaintAggregator greg;
 366
 367   pp::Rect paint_rect(4, 4, 6, 6);
 368   greg.InvalidateRect(paint_rect);
 369
 370   pp::Rect scroll_rect(0, 0, 10, 10);
 371   greg.ScrollRect(scroll_rect, pp::Point(6, 0));
 372
 373   ASSERT_TRUE(greg.HasPendingUpdate());
 374
 375   ASSERT_FALSE(greg.GetPendingUpdate().scroll_rect.IsEmpty());
 376   ASSERT_TRUE(1U == greg.GetPendingUpdate().paint_rects.size());
 377
 378   ASSERT_TRUE(scroll_rect == greg.GetPendingUpdate().scroll_rect);
 379   PASS();
 380 }
 381
 382 std::string
 383 TestPaintAggregator::TestContainedPaintAfterScrollTrimmedByScrollDamage() {
 384   pp::PaintAggregator greg;
 385
 386   pp::Rect scroll_rect(0, 0, 10, 10);
 387   greg.ScrollRect(scroll_rect, pp::Point(4, 0));
 388
 389   pp::Rect paint_rect(2, 0, 4, 10);
 390   greg.InvalidateRect(paint_rect);
 391
 392   pp::Rect expected_scroll_damage(0, 0, 4, 10);
 393   pp::Rect expected_paint_rect(4, 0, 2, 10);
 394
 395   ASSERT_TRUE(greg.HasPendingUpdate());
 396
 397   ASSERT_FALSE(greg.GetPendingUpdate().scroll_rect.IsEmpty());
 398   ASSERT_TRUE(2U == greg.GetPendingUpdate().paint_rects.size());
 399
 400   ASSERT_TRUE(scroll_rect == greg.GetPendingUpdate().scroll_rect);
 401   ASSERT_TRUE(expected_scroll_damage == greg.GetPendingUpdate().paint_rects[1]);
 402   ASSERT_TRUE(expected_paint_rect == greg.GetPendingUpdate().paint_rects[0]);
 403   PASS();
 404 }
 405
 406 std::string
 407 TestPaintAggregator::TestContainedPaintAfterScrollEliminatedByScrollDamage() {
 408   pp::PaintAggregator greg;
 409
 410   pp::Rect scroll_rect(0, 0, 10, 10);
 411   greg.ScrollRect(scroll_rect, pp::Point(4, 0));
 412
 413   pp::Rect paint_rect(2, 0, 2, 10);
 414   greg.InvalidateRect(paint_rect);
 415
 416   pp::Rect expected_scroll_damage(0, 0, 4, 10);
 417
 418   ASSERT_TRUE(greg.HasPendingUpdate());
 419
 420   ASSERT_FALSE(greg.GetPendingUpdate().scroll_rect.IsEmpty());
 421   ASSERT_TRUE(1U == greg.GetPendingUpdate().paint_rects.size());
 422
 423   ASSERT_TRUE(scroll_rect == greg.GetPendingUpdate().scroll_rect);
 424   ASSERT_TRUE(expected_scroll_damage == greg.GetPendingUpdate().paint_rects[0]);
 425   PASS();
 426 }