src/third_party/skia/tests/ClipStackTest.cpp

   1 /*
   2  * Copyright 2011 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "Test.h"
   9 #if SK_SUPPORT_GPU
  10     #include "GrReducedClip.h"
  11 #endif
  12 #include "SkClipStack.h"
  13 #include "SkPath.h"
  14 #include "SkRandom.h"
  15 #include "SkRect.h"
  16 #include "SkRegion.h"
  17
  18 static void test_assign_and_comparison(skiatest::Reporter* reporter) {
  19     SkClipStack s;
  20     bool doAA = false;
  21
  22     REPORTER_ASSERT(reporter, 0 == s.getSaveCount());
  23
  24     // Build up a clip stack with a path, an empty clip, and a rect.
  25     s.save();
  26     REPORTER_ASSERT(reporter, 1 == s.getSaveCount());
  27
  28     SkPath p;
  29     p.moveTo(5, 6);
  30     p.lineTo(7, 8);
  31     p.lineTo(5, 9);
  32     p.close();
  33     s.clipDevPath(p, SkRegion::kIntersect_Op, doAA);
  34
  35     s.save();
  36     REPORTER_ASSERT(reporter, 2 == s.getSaveCount());
  37
  38     SkRect r = SkRect::MakeLTRB(1, 2, 3, 4);
  39     s.clipDevRect(r, SkRegion::kIntersect_Op, doAA);
  40     r = SkRect::MakeLTRB(10, 11, 12, 13);
  41     s.clipDevRect(r, SkRegion::kIntersect_Op, doAA);
  42
  43     s.save();
  44     REPORTER_ASSERT(reporter, 3 == s.getSaveCount());
  45
  46     r = SkRect::MakeLTRB(14, 15, 16, 17);
  47     s.clipDevRect(r, SkRegion::kUnion_Op, doAA);
  48
  49     // Test that assignment works.
  50     SkClipStack copy = s;
  51     REPORTER_ASSERT(reporter, s == copy);
  52
  53     // Test that different save levels triggers not equal.
  54     s.restore();
  55     REPORTER_ASSERT(reporter, 2 == s.getSaveCount());
  56     REPORTER_ASSERT(reporter, s != copy);
  57
  58     // Test that an equal, but not copied version is equal.
  59     s.save();
  60     REPORTER_ASSERT(reporter, 3 == s.getSaveCount());
  61     r = SkRect::MakeLTRB(14, 15, 16, 17);
  62     s.clipDevRect(r, SkRegion::kUnion_Op, doAA);
  63     REPORTER_ASSERT(reporter, s == copy);
  64
  65     // Test that a different op on one level triggers not equal.
  66     s.restore();
  67     REPORTER_ASSERT(reporter, 2 == s.getSaveCount());
  68     s.save();
  69     REPORTER_ASSERT(reporter, 3 == s.getSaveCount());
  70     r = SkRect::MakeLTRB(14, 15, 16, 17);
  71     s.clipDevRect(r, SkRegion::kIntersect_Op, doAA);
  72     REPORTER_ASSERT(reporter, s != copy);
  73
  74     // Test that version constructed with rect-path rather than a rect is still considered equal.
  75     s.restore();
  76     s.save();
  77     SkPath rp;
  78     rp.addRect(r);
  79     s.clipDevPath(rp, SkRegion::kUnion_Op, doAA);
  80     REPORTER_ASSERT(reporter, s == copy);
  81
  82     // Test that different rects triggers not equal.
  83     s.restore();
  84     REPORTER_ASSERT(reporter, 2 == s.getSaveCount());
  85     s.save();
  86     REPORTER_ASSERT(reporter, 3 == s.getSaveCount());
  87
  88     r = SkRect::MakeLTRB(24, 25, 26, 27);
  89     s.clipDevRect(r, SkRegion::kUnion_Op, doAA);
  90     REPORTER_ASSERT(reporter, s != copy);
  91
  92     // Sanity check
  93     s.restore();
  94     REPORTER_ASSERT(reporter, 2 == s.getSaveCount());
  95
  96     copy.restore();
  97     REPORTER_ASSERT(reporter, 2 == copy.getSaveCount());
  98     REPORTER_ASSERT(reporter, s == copy);
  99     s.restore();
 100     REPORTER_ASSERT(reporter, 1 == s.getSaveCount());
 101     copy.restore();
 102     REPORTER_ASSERT(reporter, 1 == copy.getSaveCount());
 103     REPORTER_ASSERT(reporter, s == copy);
 104
 105     // Test that different paths triggers not equal.
 106     s.restore();
 107     REPORTER_ASSERT(reporter, 0 == s.getSaveCount());
 108     s.save();
 109     REPORTER_ASSERT(reporter, 1 == s.getSaveCount());
 110
 111     p.addRect(r);
 112     s.clipDevPath(p, SkRegion::kIntersect_Op, doAA);
 113     REPORTER_ASSERT(reporter, s != copy);
 114 }
 115
 116 static void assert_count(skiatest::Reporter* reporter, const SkClipStack& stack,
 117                          int count) {
 118     SkClipStack::B2TIter iter(stack);
 119     int counter = 0;
 120     while (iter.next()) {
 121         counter += 1;
 122     }
 123     REPORTER_ASSERT(reporter, count == counter);
 124 }
 125
 126 // Exercise the SkClipStack's bottom to top and bidirectional iterators
 127 // (including the skipToTopmost functionality)
 128 static void test_iterators(skiatest::Reporter* reporter) {
 129     SkClipStack stack;
 130
 131     static const SkRect gRects[] = {
 132         { 0,   0,  40,  40 },
 133         { 60,  0, 100,  40 },
 134         { 0,  60,  40, 100 },
 135         { 60, 60, 100, 100 }
 136     };
 137
 138     for (size_t i = 0; i < SK_ARRAY_COUNT(gRects); i++) {
 139         // the union op will prevent these from being fused together
 140         stack.clipDevRect(gRects[i], SkRegion::kUnion_Op, false);
 141     }
 142
 143     assert_count(reporter, stack, 4);
 144
 145     // bottom to top iteration
 146     {
 147         const SkClipStack::Element* element = NULL;
 148
 149         SkClipStack::B2TIter iter(stack);
 150         int i;
 151
 152         for (i = 0, element = iter.next(); element; ++i, element = iter.next()) {
 153             REPORTER_ASSERT(reporter, SkClipStack::Element::kRect_Type == element->getType());
 154             REPORTER_ASSERT(reporter, element->getRect() == gRects[i]);
 155         }
 156
 157         SkASSERT(i == 4);
 158     }
 159
 160     // top to bottom iteration
 161     {
 162         const SkClipStack::Element* element = NULL;
 163
 164         SkClipStack::Iter iter(stack, SkClipStack::Iter::kTop_IterStart);
 165         int i;
 166
 167         for (i = 3, element = iter.prev(); element; --i, element = iter.prev()) {
 168             REPORTER_ASSERT(reporter, SkClipStack::Element::kRect_Type == element->getType());
 169             REPORTER_ASSERT(reporter, element->getRect() == gRects[i]);
 170         }
 171
 172         SkASSERT(i == -1);
 173     }
 174
 175     // skipToTopmost
 176     {
 177         const SkClipStack::Element* element = NULL;
 178
 179         SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
 180
 181         element = iter.skipToTopmost(SkRegion::kUnion_Op);
 182         REPORTER_ASSERT(reporter, SkClipStack::Element::kRect_Type == element->getType());
 183         REPORTER_ASSERT(reporter, element->getRect() == gRects[3]);
 184     }
 185 }
 186
 187 // Exercise the SkClipStack's getConservativeBounds computation
 188 static void test_bounds(skiatest::Reporter* reporter, SkClipStack::Element::Type primType) {
 189     static const int gNumCases = 20;
 190     static const SkRect gAnswerRectsBW[gNumCases] = {
 191         // A op B
 192         { 40, 40, 50, 50 },
 193         { 10, 10, 50, 50 },
 194         { 10, 10, 80, 80 },
 195         { 10, 10, 80, 80 },
 196         { 40, 40, 80, 80 },
 197
 198         // invA op B
 199         { 40, 40, 80, 80 },
 200         { 0, 0, 100, 100 },
 201         { 0, 0, 100, 100 },
 202         { 0, 0, 100, 100 },
 203         { 40, 40, 50, 50 },
 204
 205         // A op invB
 206         { 10, 10, 50, 50 },
 207         { 40, 40, 50, 50 },
 208         { 0, 0, 100, 100 },
 209         { 0, 0, 100, 100 },
 210         { 0, 0, 100, 100 },
 211
 212         // invA op invB
 213         { 0, 0, 100, 100 },
 214         { 40, 40, 80, 80 },
 215         { 0, 0, 100, 100 },
 216         { 10, 10, 80, 80 },
 217         { 10, 10, 50, 50 },
 218     };
 219
 220     static const SkRegion::Op gOps[] = {
 221         SkRegion::kIntersect_Op,
 222         SkRegion::kDifference_Op,
 223         SkRegion::kUnion_Op,
 224         SkRegion::kXOR_Op,
 225         SkRegion::kReverseDifference_Op
 226     };
 227
 228     SkRect rectA, rectB;
 229
 230     rectA.iset(10, 10, 50, 50);
 231     rectB.iset(40, 40, 80, 80);
 232
 233     SkRRect rrectA, rrectB;
 234     rrectA.setOval(rectA);
 235     rrectB.setRectXY(rectB, SkIntToScalar(1), SkIntToScalar(2));
 236
 237     SkPath pathA, pathB;
 238
 239     pathA.addRoundRect(rectA, SkIntToScalar(5), SkIntToScalar(5));
 240     pathB.addRoundRect(rectB, SkIntToScalar(5), SkIntToScalar(5));
 241
 242     SkClipStack stack;
 243     SkRect devClipBound;
 244     bool isIntersectionOfRects = false;
 245
 246     int testCase = 0;
 247     int numBitTests = SkClipStack::Element::kPath_Type == primType ? 4 : 1;
 248     for (int invBits = 0; invBits < numBitTests; ++invBits) {
 249         for (size_t op = 0; op < SK_ARRAY_COUNT(gOps); ++op) {
 250
 251             stack.save();
 252             bool doInvA = SkToBool(invBits & 1);
 253             bool doInvB = SkToBool(invBits & 2);
 254
 255             pathA.setFillType(doInvA ? SkPath::kInverseEvenOdd_FillType :
 256                                        SkPath::kEvenOdd_FillType);
 257             pathB.setFillType(doInvB ? SkPath::kInverseEvenOdd_FillType :
 258                                        SkPath::kEvenOdd_FillType);
 259
 260             switch (primType) {
 261                 case SkClipStack::Element::kEmpty_Type:
 262                     SkDEBUGFAIL("Don't call this with kEmpty.");
 263                     break;
 264                 case SkClipStack::Element::kRect_Type:
 265                     stack.clipDevRect(rectA, SkRegion::kIntersect_Op, false);
 266                     stack.clipDevRect(rectB, gOps[op], false);
 267                     break;
 268                 case SkClipStack::Element::kRRect_Type:
 269                     stack.clipDevRRect(rrectA, SkRegion::kIntersect_Op, false);
 270                     stack.clipDevRRect(rrectB, gOps[op], false);
 271                     break;
 272                 case SkClipStack::Element::kPath_Type:
 273                     stack.clipDevPath(pathA, SkRegion::kIntersect_Op, false);
 274                     stack.clipDevPath(pathB, gOps[op], false);
 275                     break;
 276             }
 277
 278             REPORTER_ASSERT(reporter, !stack.isWideOpen());
 279             REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID != stack.getTopmostGenID());
 280
 281             stack.getConservativeBounds(0, 0, 100, 100, &devClipBound,
 282                                         &isIntersectionOfRects);
 283
 284             if (SkClipStack::Element::kRect_Type == primType) {
 285                 REPORTER_ASSERT(reporter, isIntersectionOfRects ==
 286                         (gOps[op] == SkRegion::kIntersect_Op));
 287             } else {
 288                 REPORTER_ASSERT(reporter, !isIntersectionOfRects);
 289             }
 290
 291             SkASSERT(testCase < gNumCases);
 292             REPORTER_ASSERT(reporter, devClipBound == gAnswerRectsBW[testCase]);
 293             ++testCase;
 294
 295             stack.restore();
 296         }
 297     }
 298 }
 299
 300 // Test out 'isWideOpen' entry point
 301 static void test_isWideOpen(skiatest::Reporter* reporter) {
 302     {
 303         // Empty stack is wide open. Wide open stack means that gen id is wide open.
 304         SkClipStack stack;
 305         REPORTER_ASSERT(reporter, stack.isWideOpen());
 306         REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
 307     }
 308
 309     SkRect rectA, rectB;
 310
 311     rectA.iset(10, 10, 40, 40);
 312     rectB.iset(50, 50, 80, 80);
 313
 314     // Stack should initially be wide open
 315     {
 316         SkClipStack stack;
 317
 318         REPORTER_ASSERT(reporter, stack.isWideOpen());
 319         REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
 320     }
 321
 322     // Test out case where the user specifies a union that includes everything
 323     {
 324         SkClipStack stack;
 325
 326         SkPath clipA, clipB;
 327
 328         clipA.addRoundRect(rectA, SkIntToScalar(5), SkIntToScalar(5));
 329         clipA.setFillType(SkPath::kInverseEvenOdd_FillType);
 330
 331         clipB.addRoundRect(rectB, SkIntToScalar(5), SkIntToScalar(5));
 332         clipB.setFillType(SkPath::kInverseEvenOdd_FillType);
 333
 334         stack.clipDevPath(clipA, SkRegion::kReplace_Op, false);
 335         stack.clipDevPath(clipB, SkRegion::kUnion_Op, false);
 336
 337         REPORTER_ASSERT(reporter, stack.isWideOpen());
 338         REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
 339     }
 340
 341     // Test out union w/ a wide open clip
 342     {
 343         SkClipStack stack;
 344
 345         stack.clipDevRect(rectA, SkRegion::kUnion_Op, false);
 346
 347         REPORTER_ASSERT(reporter, stack.isWideOpen());
 348         REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
 349     }
 350
 351     // Test out empty difference from a wide open clip
 352     {
 353         SkClipStack stack;
 354
 355         SkRect emptyRect;
 356         emptyRect.setEmpty();
 357
 358         stack.clipDevRect(emptyRect, SkRegion::kDifference_Op, false);
 359
 360         REPORTER_ASSERT(reporter, stack.isWideOpen());
 361         REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
 362     }
 363
 364     // Test out return to wide open
 365     {
 366         SkClipStack stack;
 367
 368         stack.save();
 369
 370         stack.clipDevRect(rectA, SkRegion::kReplace_Op, false);
 371
 372         REPORTER_ASSERT(reporter, !stack.isWideOpen());
 373         REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID != stack.getTopmostGenID());
 374
 375         stack.restore();
 376
 377         REPORTER_ASSERT(reporter, stack.isWideOpen());
 378         REPORTER_ASSERT(reporter, SkClipStack::kWideOpenGenID == stack.getTopmostGenID());
 379     }
 380 }
 381
 382 static int count(const SkClipStack& stack) {
 383
 384     SkClipStack::Iter iter(stack, SkClipStack::Iter::kTop_IterStart);
 385
 386     const SkClipStack::Element* element = NULL;
 387     int count = 0;
 388
 389     for (element = iter.prev(); element; element = iter.prev(), ++count) {
 390         ;
 391     }
 392
 393     return count;
 394 }
 395
 396 static void test_rect_inverse_fill(skiatest::Reporter* reporter) {
 397     // non-intersecting rectangles
 398     SkRect rect  = SkRect::MakeLTRB(0, 0, 10, 10);
 399
 400     SkPath path;
 401     path.addRect(rect);
 402     path.toggleInverseFillType();
 403     SkClipStack stack;
 404     stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
 405
 406     SkRect bounds;
 407     SkClipStack::BoundsType boundsType;
 408     stack.getBounds(&bounds, &boundsType);
 409     REPORTER_ASSERT(reporter, SkClipStack::kInsideOut_BoundsType == boundsType);
 410     REPORTER_ASSERT(reporter, bounds == rect);
 411 }
 412
 413 static void test_rect_replace(skiatest::Reporter* reporter) {
 414     SkRect rect = SkRect::MakeWH(100, 100);
 415     SkRect rect2 = SkRect::MakeXYWH(50, 50, 100, 100);
 416
 417     SkRect bound;
 418     SkClipStack::BoundsType type;
 419     bool isIntersectionOfRects;
 420
 421     // Adding a new rect with the replace operator should not increase
 422     // the stack depth. BW replacing BW.
 423     {
 424         SkClipStack stack;
 425         REPORTER_ASSERT(reporter, 0 == count(stack));
 426         stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
 427         REPORTER_ASSERT(reporter, 1 == count(stack));
 428         stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
 429         REPORTER_ASSERT(reporter, 1 == count(stack));
 430     }
 431
 432     // Adding a new rect with the replace operator should not increase
 433     // the stack depth. AA replacing AA.
 434     {
 435         SkClipStack stack;
 436         REPORTER_ASSERT(reporter, 0 == count(stack));
 437         stack.clipDevRect(rect, SkRegion::kReplace_Op, true);
 438         REPORTER_ASSERT(reporter, 1 == count(stack));
 439         stack.clipDevRect(rect, SkRegion::kReplace_Op, true);
 440         REPORTER_ASSERT(reporter, 1 == count(stack));
 441     }
 442
 443     // Adding a new rect with the replace operator should not increase
 444     // the stack depth. BW replacing AA replacing BW.
 445     {
 446         SkClipStack stack;
 447         REPORTER_ASSERT(reporter, 0 == count(stack));
 448         stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
 449         REPORTER_ASSERT(reporter, 1 == count(stack));
 450         stack.clipDevRect(rect, SkRegion::kReplace_Op, true);
 451         REPORTER_ASSERT(reporter, 1 == count(stack));
 452         stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
 453         REPORTER_ASSERT(reporter, 1 == count(stack));
 454     }
 455
 456     // Make sure replace clip rects don't collapse too much.
 457     {
 458         SkClipStack stack;
 459         stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
 460         stack.clipDevRect(rect2, SkRegion::kIntersect_Op, false);
 461         REPORTER_ASSERT(reporter, 1 == count(stack));
 462
 463         stack.save();
 464         stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
 465         REPORTER_ASSERT(reporter, 2 == count(stack));
 466         stack.getBounds(&bound, &type, &isIntersectionOfRects);
 467         REPORTER_ASSERT(reporter, bound == rect);
 468         stack.restore();
 469         REPORTER_ASSERT(reporter, 1 == count(stack));
 470
 471         stack.save();
 472         stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
 473         stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
 474         REPORTER_ASSERT(reporter, 2 == count(stack));
 475         stack.restore();
 476         REPORTER_ASSERT(reporter, 1 == count(stack));
 477
 478         stack.save();
 479         stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
 480         stack.clipDevRect(rect2, SkRegion::kIntersect_Op, false);
 481         stack.clipDevRect(rect, SkRegion::kReplace_Op, false);
 482         REPORTER_ASSERT(reporter, 2 == count(stack));
 483         stack.restore();
 484         REPORTER_ASSERT(reporter, 1 == count(stack));
 485     }
 486 }
 487
 488 // Simplified path-based version of test_rect_replace.
 489 static void test_path_replace(skiatest::Reporter* reporter) {
 490     SkRect rect = SkRect::MakeWH(100, 100);
 491     SkPath path;
 492     path.addCircle(50, 50, 50);
 493
 494     // Replace operation doesn't grow the stack.
 495     {
 496         SkClipStack stack;
 497         REPORTER_ASSERT(reporter, 0 == count(stack));
 498         stack.clipDevPath(path, SkRegion::kReplace_Op, false);
 499         REPORTER_ASSERT(reporter, 1 == count(stack));
 500         stack.clipDevPath(path, SkRegion::kReplace_Op, false);
 501         REPORTER_ASSERT(reporter, 1 == count(stack));
 502     }
 503
 504     // Replacing rect with path.
 505     {
 506         SkClipStack stack;
 507         stack.clipDevRect(rect, SkRegion::kReplace_Op, true);
 508         REPORTER_ASSERT(reporter, 1 == count(stack));
 509         stack.clipDevPath(path, SkRegion::kReplace_Op, true);
 510         REPORTER_ASSERT(reporter, 1 == count(stack));
 511     }
 512 }
 513
 514 // Test out SkClipStack's merging of rect clips. In particular exercise
 515 // merging of aa vs. bw rects.
 516 static void test_rect_merging(skiatest::Reporter* reporter) {
 517
 518     SkRect overlapLeft  = SkRect::MakeLTRB(10, 10, 50, 50);
 519     SkRect overlapRight = SkRect::MakeLTRB(40, 40, 80, 80);
 520
 521     SkRect nestedParent = SkRect::MakeLTRB(10, 10, 90, 90);
 522     SkRect nestedChild  = SkRect::MakeLTRB(40, 40, 60, 60);
 523
 524     SkRect bound;
 525     SkClipStack::BoundsType type;
 526     bool isIntersectionOfRects;
 527
 528     // all bw overlapping - should merge
 529     {
 530         SkClipStack stack;
 531
 532         stack.clipDevRect(overlapLeft, SkRegion::kReplace_Op, false);
 533
 534         stack.clipDevRect(overlapRight, SkRegion::kIntersect_Op, false);
 535
 536         REPORTER_ASSERT(reporter, 1 == count(stack));
 537
 538         stack.getBounds(&bound, &type, &isIntersectionOfRects);
 539
 540         REPORTER_ASSERT(reporter, isIntersectionOfRects);
 541     }
 542
 543     // all aa overlapping - should merge
 544     {
 545         SkClipStack stack;
 546
 547         stack.clipDevRect(overlapLeft, SkRegion::kReplace_Op, true);
 548
 549         stack.clipDevRect(overlapRight, SkRegion::kIntersect_Op, true);
 550
 551         REPORTER_ASSERT(reporter, 1 == count(stack));
 552
 553         stack.getBounds(&bound, &type, &isIntersectionOfRects);
 554
 555         REPORTER_ASSERT(reporter, isIntersectionOfRects);
 556     }
 557
 558     // mixed overlapping - should _not_ merge
 559     {
 560         SkClipStack stack;
 561
 562         stack.clipDevRect(overlapLeft, SkRegion::kReplace_Op, true);
 563
 564         stack.clipDevRect(overlapRight, SkRegion::kIntersect_Op, false);
 565
 566         REPORTER_ASSERT(reporter, 2 == count(stack));
 567
 568         stack.getBounds(&bound, &type, &isIntersectionOfRects);
 569
 570         REPORTER_ASSERT(reporter, !isIntersectionOfRects);
 571     }
 572
 573     // mixed nested (bw inside aa) - should merge
 574     {
 575         SkClipStack stack;
 576
 577         stack.clipDevRect(nestedParent, SkRegion::kReplace_Op, true);
 578
 579         stack.clipDevRect(nestedChild, SkRegion::kIntersect_Op, false);
 580
 581         REPORTER_ASSERT(reporter, 1 == count(stack));
 582
 583         stack.getBounds(&bound, &type, &isIntersectionOfRects);
 584
 585         REPORTER_ASSERT(reporter, isIntersectionOfRects);
 586     }
 587
 588     // mixed nested (aa inside bw) - should merge
 589     {
 590         SkClipStack stack;
 591
 592         stack.clipDevRect(nestedParent, SkRegion::kReplace_Op, false);
 593
 594         stack.clipDevRect(nestedChild, SkRegion::kIntersect_Op, true);
 595
 596         REPORTER_ASSERT(reporter, 1 == count(stack));
 597
 598         stack.getBounds(&bound, &type, &isIntersectionOfRects);
 599
 600         REPORTER_ASSERT(reporter, isIntersectionOfRects);
 601     }
 602
 603     // reverse nested (aa inside bw) - should _not_ merge
 604     {
 605         SkClipStack stack;
 606
 607         stack.clipDevRect(nestedChild, SkRegion::kReplace_Op, false);
 608
 609         stack.clipDevRect(nestedParent, SkRegion::kIntersect_Op, true);
 610
 611         REPORTER_ASSERT(reporter, 2 == count(stack));
 612
 613         stack.getBounds(&bound, &type, &isIntersectionOfRects);
 614
 615         REPORTER_ASSERT(reporter, !isIntersectionOfRects);
 616     }
 617 }
 618
 619 static void test_quickContains(skiatest::Reporter* reporter) {
 620     SkRect testRect = SkRect::MakeLTRB(10, 10, 40, 40);
 621     SkRect insideRect = SkRect::MakeLTRB(20, 20, 30, 30);
 622     SkRect intersectingRect = SkRect::MakeLTRB(25, 25, 50, 50);
 623     SkRect outsideRect = SkRect::MakeLTRB(0, 0, 50, 50);
 624     SkRect nonIntersectingRect = SkRect::MakeLTRB(100, 100, 110, 110);
 625
 626     SkPath insideCircle;
 627     insideCircle.addCircle(25, 25, 5);
 628     SkPath intersectingCircle;
 629     intersectingCircle.addCircle(25, 40, 10);
 630     SkPath outsideCircle;
 631     outsideCircle.addCircle(25, 25, 50);
 632     SkPath nonIntersectingCircle;
 633     nonIntersectingCircle.addCircle(100, 100, 5);
 634
 635     {
 636         SkClipStack stack;
 637         stack.clipDevRect(outsideRect, SkRegion::kDifference_Op, false);
 638         // return false because quickContains currently does not care for kDifference_Op
 639         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
 640     }
 641
 642     // Replace Op tests
 643     {
 644         SkClipStack stack;
 645         stack.clipDevRect(outsideRect, SkRegion::kReplace_Op, false);
 646         REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
 647     }
 648
 649     {
 650         SkClipStack stack;
 651         stack.clipDevRect(insideRect, SkRegion::kIntersect_Op, false);
 652         stack.save(); // To prevent in-place substitution by replace OP
 653         stack.clipDevRect(outsideRect, SkRegion::kReplace_Op, false);
 654         REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
 655         stack.restore();
 656     }
 657
 658     {
 659         SkClipStack stack;
 660         stack.clipDevRect(outsideRect, SkRegion::kIntersect_Op, false);
 661         stack.save(); // To prevent in-place substitution by replace OP
 662         stack.clipDevRect(insideRect, SkRegion::kReplace_Op, false);
 663         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
 664         stack.restore();
 665     }
 666
 667     // Verify proper traversal of multi-element clip
 668     {
 669         SkClipStack stack;
 670         stack.clipDevRect(insideRect, SkRegion::kIntersect_Op, false);
 671         // Use a path for second clip to prevent in-place intersection
 672         stack.clipDevPath(outsideCircle, SkRegion::kIntersect_Op, false);
 673         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
 674     }
 675
 676     // Intersect Op tests with rectangles
 677     {
 678         SkClipStack stack;
 679         stack.clipDevRect(outsideRect, SkRegion::kIntersect_Op, false);
 680         REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
 681     }
 682
 683     {
 684         SkClipStack stack;
 685         stack.clipDevRect(insideRect, SkRegion::kIntersect_Op, false);
 686         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
 687     }
 688
 689     {
 690         SkClipStack stack;
 691         stack.clipDevRect(intersectingRect, SkRegion::kIntersect_Op, false);
 692         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
 693     }
 694
 695     {
 696         SkClipStack stack;
 697         stack.clipDevRect(nonIntersectingRect, SkRegion::kIntersect_Op, false);
 698         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
 699     }
 700
 701     // Intersect Op tests with circle paths
 702     {
 703         SkClipStack stack;
 704         stack.clipDevPath(outsideCircle, SkRegion::kIntersect_Op, false);
 705         REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
 706     }
 707
 708     {
 709         SkClipStack stack;
 710         stack.clipDevPath(insideCircle, SkRegion::kIntersect_Op, false);
 711         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
 712     }
 713
 714     {
 715         SkClipStack stack;
 716         stack.clipDevPath(intersectingCircle, SkRegion::kIntersect_Op, false);
 717         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
 718     }
 719
 720     {
 721         SkClipStack stack;
 722         stack.clipDevPath(nonIntersectingCircle, SkRegion::kIntersect_Op, false);
 723         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
 724     }
 725
 726     // Intersect Op tests with inverse filled rectangles
 727     {
 728         SkClipStack stack;
 729         SkPath path;
 730         path.addRect(outsideRect);
 731         path.toggleInverseFillType();
 732         stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
 733         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
 734     }
 735
 736     {
 737         SkClipStack stack;
 738         SkPath path;
 739         path.addRect(insideRect);
 740         path.toggleInverseFillType();
 741         stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
 742         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
 743     }
 744
 745     {
 746         SkClipStack stack;
 747         SkPath path;
 748         path.addRect(intersectingRect);
 749         path.toggleInverseFillType();
 750         stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
 751         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
 752     }
 753
 754     {
 755         SkClipStack stack;
 756         SkPath path;
 757         path.addRect(nonIntersectingRect);
 758         path.toggleInverseFillType();
 759         stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
 760         REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
 761     }
 762
 763     // Intersect Op tests with inverse filled circles
 764     {
 765         SkClipStack stack;
 766         SkPath path = outsideCircle;
 767         path.toggleInverseFillType();
 768         stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
 769         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
 770     }
 771
 772     {
 773         SkClipStack stack;
 774         SkPath path = insideCircle;
 775         path.toggleInverseFillType();
 776         stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
 777         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
 778     }
 779
 780     {
 781         SkClipStack stack;
 782         SkPath path = intersectingCircle;
 783         path.toggleInverseFillType();
 784         stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
 785         REPORTER_ASSERT(reporter, false == stack.quickContains(testRect));
 786     }
 787
 788     {
 789         SkClipStack stack;
 790         SkPath path = nonIntersectingCircle;
 791         path.toggleInverseFillType();
 792         stack.clipDevPath(path, SkRegion::kIntersect_Op, false);
 793         REPORTER_ASSERT(reporter, true == stack.quickContains(testRect));
 794     }
 795 }
 796
 797 ///////////////////////////////////////////////////////////////////////////////////////////////////
 798
 799 #if SK_SUPPORT_GPU
 800 // Functions that add a shape to the clip stack. The shape is computed from a rectangle.
 801 // AA is always disabled since the clip stack reducer can cause changes in aa rasterization of the
 802 // stack. A fractional edge repeated in different elements may be rasterized fewer times using the
 803 // reduced stack.
 804 typedef void (*AddElementFunc) (const SkRect& rect,
 805                                 bool invert,
 806                                 SkRegion::Op op,
 807                                 SkClipStack* stack);
 808
 809 static void add_round_rect(const SkRect& rect, bool invert, SkRegion::Op op, SkClipStack* stack) {
 810     SkScalar rx = rect.width() / 10;
 811     SkScalar ry = rect.height() / 20;
 812     if (invert) {
 813         SkPath path;
 814         path.addRoundRect(rect, rx, ry);
 815         path.setFillType(SkPath::kInverseWinding_FillType);
 816         stack->clipDevPath(path, op, false);
 817     } else {
 818         SkRRect rrect;
 819         rrect.setRectXY(rect, rx, ry);
 820         stack->clipDevRRect(rrect, op, false);
 821     }
 822 };
 823
 824 static void add_rect(const SkRect& rect, bool invert, SkRegion::Op op, SkClipStack* stack) {
 825     if (invert) {
 826         SkPath path;
 827         path.addRect(rect);
 828         path.setFillType(SkPath::kInverseWinding_FillType);
 829         stack->clipDevPath(path, op, false);
 830     } else {
 831         stack->clipDevRect(rect, op, false);
 832     }
 833 };
 834
 835 static void add_oval(const SkRect& rect, bool invert, SkRegion::Op op, SkClipStack* stack) {
 836     SkPath path;
 837     path.addOval(rect);
 838     if (invert) {
 839         path.setFillType(SkPath::kInverseWinding_FillType);
 840     }
 841     stack->clipDevPath(path, op, false);
 842 };
 843
 844 static void add_elem_to_stack(const SkClipStack::Element& element, SkClipStack* stack) {
 845     switch (element.getType()) {
 846         case SkClipStack::Element::kRect_Type:
 847             stack->clipDevRect(element.getRect(), element.getOp(), element.isAA());
 848             break;
 849         case SkClipStack::Element::kRRect_Type:
 850             stack->clipDevRRect(element.getRRect(), element.getOp(), element.isAA());
 851             break;
 852         case SkClipStack::Element::kPath_Type:
 853             stack->clipDevPath(element.getPath(), element.getOp(), element.isAA());
 854             break;
 855         case SkClipStack::Element::kEmpty_Type:
 856             SkDEBUGFAIL("Why did the reducer produce an explicit empty.");
 857             stack->clipEmpty();
 858             break;
 859     }
 860 }
 861
 862 static void add_elem_to_region(const SkClipStack::Element& element,
 863                                const SkIRect& bounds,
 864                                SkRegion* region) {
 865     SkRegion elemRegion;
 866     SkRegion boundsRgn(bounds);
 867     SkPath path;
 868
 869     switch (element.getType()) {
 870         case SkClipStack::Element::kEmpty_Type:
 871             elemRegion.setEmpty();
 872             break;
 873         default:
 874             element.asPath(&path);
 875             elemRegion.setPath(path, boundsRgn);
 876             break;
 877     }
 878     region->op(elemRegion, element.getOp());
 879 }
 880
 881 static void test_reduced_clip_stack(skiatest::Reporter* reporter) {
 882     // We construct random clip stacks, reduce them, and then rasterize both versions to verify that
 883     // they are equal.
 884
 885     // All the clip elements will be contained within these bounds.
 886     static const SkRect kBounds = SkRect::MakeWH(100, 100);
 887
 888     enum {
 889         kNumTests = 200,
 890         kMinElemsPerTest = 1,
 891         kMaxElemsPerTest = 50,
 892     };
 893
 894     // min/max size of a clip element as a fraction of kBounds.
 895     static const SkScalar kMinElemSizeFrac = SK_Scalar1 / 5;
 896     static const SkScalar kMaxElemSizeFrac = SK_Scalar1;
 897
 898     static const SkRegion::Op kOps[] = {
 899         SkRegion::kDifference_Op,
 900         SkRegion::kIntersect_Op,
 901         SkRegion::kUnion_Op,
 902         SkRegion::kXOR_Op,
 903         SkRegion::kReverseDifference_Op,
 904         SkRegion::kReplace_Op,
 905     };
 906
 907     // Replace operations short-circuit the optimizer. We want to make sure that we test this code
 908     // path a little bit but we don't want it to prevent us from testing many longer traversals in
 909     // the optimizer.
 910     static const int kReplaceDiv = 4 * kMaxElemsPerTest;
 911
 912     // We want to test inverse fills. However, they are quite rare in practice so don't over do it.
 913     static const SkScalar kFractionInverted = SK_Scalar1 / kMaxElemsPerTest;
 914
 915     static const AddElementFunc kElementFuncs[] = {
 916         add_rect,
 917         add_round_rect,
 918         add_oval,
 919     };
 920
 921     SkRandom r;
 922
 923     for (int i = 0; i < kNumTests; ++i) {
 924         // Randomly generate a clip stack.
 925         SkClipStack stack;
 926         int numElems = r.nextRangeU(kMinElemsPerTest, kMaxElemsPerTest);
 927         for (int e = 0; e < numElems; ++e) {
 928             SkRegion::Op op = kOps[r.nextULessThan(SK_ARRAY_COUNT(kOps))];
 929             if (op == SkRegion::kReplace_Op) {
 930                 if (r.nextU() % kReplaceDiv) {
 931                     --e;
 932                     continue;
 933                 }
 934             }
 935
 936             // saves can change the clip stack behavior when an element is added.
 937             bool doSave = r.nextBool();
 938
 939             SkSize size = SkSize::Make(
 940                 SkScalarFloorToScalar(SkScalarMul(kBounds.width(), r.nextRangeScalar(kMinElemSizeFrac, kMaxElemSizeFrac))),
 941                 SkScalarFloorToScalar(SkScalarMul(kBounds.height(), r.nextRangeScalar(kMinElemSizeFrac, kMaxElemSizeFrac))));
 942
 943             SkPoint xy = {SkScalarFloorToScalar(r.nextRangeScalar(kBounds.fLeft, kBounds.fRight - size.fWidth)),
 944                           SkScalarFloorToScalar(r.nextRangeScalar(kBounds.fTop, kBounds.fBottom - size.fHeight))};
 945
 946             SkRect rect = SkRect::MakeXYWH(xy.fX, xy.fY, size.fWidth, size.fHeight);
 947
 948             bool invert = r.nextBiasedBool(kFractionInverted);
 949
 950             kElementFuncs[r.nextULessThan(SK_ARRAY_COUNT(kElementFuncs))](rect, invert, op, &stack);
 951             if (doSave) {
 952                 stack.save();
 953             }
 954         }
 955
 956         SkRect inflatedBounds = kBounds;
 957         inflatedBounds.outset(kBounds.width() / 2, kBounds.height() / 2);
 958         SkIRect inflatedIBounds;
 959         inflatedBounds.roundOut(&inflatedIBounds);
 960
 961         typedef GrReducedClip::ElementList ElementList;
 962         // Get the reduced version of the stack.
 963         ElementList reducedClips;
 964         int32_t reducedGenID;
 965         GrReducedClip::InitialState initial;
 966         SkIRect tBounds(inflatedIBounds);
 967         SkIRect* tightBounds = r.nextBool() ? &tBounds : NULL;
 968         GrReducedClip::ReduceClipStack(stack,
 969                                        inflatedIBounds,
 970                                        &reducedClips,
 971                                        &reducedGenID,
 972                                        &initial,
 973                                        tightBounds);
 974
 975         REPORTER_ASSERT(reporter, SkClipStack::kInvalidGenID != reducedGenID);
 976
 977         // Build a new clip stack based on the reduced clip elements
 978         SkClipStack reducedStack;
 979         if (GrReducedClip::kAllOut_InitialState == initial) {
 980             // whether the result is bounded or not, the whole plane should start outside the clip.
 981             reducedStack.clipEmpty();
 982         }
 983         for (ElementList::Iter iter = reducedClips.headIter(); iter.get(); iter.next()) {
 984             add_elem_to_stack(*iter.get(), &reducedStack);
 985         }
 986
 987         // GrReducedClipStack assumes that the final result is clipped to the returned bounds
 988         if (tightBounds) {
 989             reducedStack.clipDevRect(*tightBounds, SkRegion::kIntersect_Op);
 990         }
 991
 992         // convert both the original stack and reduced stack to SkRegions and see if they're equal
 993         SkRegion region;
 994         SkRegion reducedRegion;
 995
 996         region.setRect(inflatedIBounds);
 997         const SkClipStack::Element* element;
 998         SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
 999         while ((element = iter.next())) {
1000             add_elem_to_region(*element, inflatedIBounds, &region);
1001         }
1002
1003         reducedRegion.setRect(inflatedIBounds);
1004         iter.reset(reducedStack, SkClipStack::Iter::kBottom_IterStart);
1005         while ((element = iter.next())) {
1006             add_elem_to_region(*element, inflatedIBounds, &reducedRegion);
1007         }
1008         SkString testCase;
1009         testCase.printf("Iteration %d", i);
1010         REPORTER_ASSERT_MESSAGE(reporter, region == reducedRegion, testCase.c_str());
1011     }
1012 }
1013
1014 #if defined(WIN32)
1015     #define SUPPRESS_VISIBILITY_WARNING
1016 #else
1017     #define SUPPRESS_VISIBILITY_WARNING __attribute__((visibility("hidden")))
1018 #endif
1019
1020 static void test_reduced_clip_stack_genid(skiatest::Reporter* reporter) {
1021     {
1022         SkClipStack stack;
1023         stack.clipDevRect(SkRect::MakeXYWH(0, 0, 100, 100), SkRegion::kReplace_Op, true);
1024         stack.clipDevRect(SkRect::MakeXYWH(0, 0, SkScalar(50.3), SkScalar(50.3)), SkRegion::kReplace_Op, true);
1025         SkIRect inflatedIBounds = SkIRect::MakeXYWH(0, 0, 100, 100);
1026
1027         GrReducedClip::ElementList reducedClips;
1028         int32_t reducedGenID;
1029         GrReducedClip::InitialState initial;
1030         SkIRect tightBounds;
1031
1032         GrReducedClip::ReduceClipStack(stack,
1033                                        inflatedIBounds,
1034                                        &reducedClips,
1035                                        &reducedGenID,
1036                                        &initial,
1037                                        &tightBounds);
1038
1039         REPORTER_ASSERT(reporter, reducedClips.count() == 1);
1040         // Clips will be cached based on the generation id. Make sure the gen id is valid.
1041         REPORTER_ASSERT(reporter, SkClipStack::kInvalidGenID != reducedGenID);
1042     }
1043     {
1044         SkClipStack stack;
1045
1046         // Create a clip with following 25.3, 25.3 boxes which are 25 apart:
1047         //  A  B
1048         //  C  D
1049
1050         stack.clipDevRect(SkRect::MakeXYWH(0, 0, SkScalar(25.3), SkScalar(25.3)), SkRegion::kReplace_Op, true);
1051         int32_t genIDA = stack.getTopmostGenID();
1052         stack.clipDevRect(SkRect::MakeXYWH(50, 0, SkScalar(25.3), SkScalar(25.3)), SkRegion::kUnion_Op, true);
1053         int32_t genIDB = stack.getTopmostGenID();
1054         stack.clipDevRect(SkRect::MakeXYWH(0, 50, SkScalar(25.3), SkScalar(25.3)), SkRegion::kUnion_Op, true);
1055         int32_t genIDC = stack.getTopmostGenID();
1056         stack.clipDevRect(SkRect::MakeXYWH(50, 50, SkScalar(25.3), SkScalar(25.3)), SkRegion::kUnion_Op, true);
1057         int32_t genIDD = stack.getTopmostGenID();
1058
1059
1060 #define XYWH SkIRect::MakeXYWH
1061
1062         SkIRect unused;
1063         unused.setEmpty();
1064         SkIRect stackBounds = XYWH(0, 0, 76, 76);
1065
1066         // The base test is to test each rect in two ways:
1067         // 1) The box dimensions. (Should reduce to "all in", no elements).
1068         // 2) A bit over the box dimensions.
1069         // In the case 2, test that the generation id is what is expected.
1070         // The rects are of fractional size so that case 2 never gets optimized to an empty element
1071         // list.
1072
1073         // Not passing in tighter bounds is tested for consistency.
1074         static const struct SUPPRESS_VISIBILITY_WARNING {
1075             SkIRect testBounds;
1076             int reducedClipCount;
1077             int32_t reducedGenID;
1078             GrReducedClip::InitialState initialState;
1079             SkIRect tighterBounds; // If this is empty, the query will not pass tighter bounds
1080             // parameter.
1081         } testCases[] = {
1082             // Rect A.
1083             { XYWH(0, 0, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, XYWH(0, 0, 25, 25) },
1084             { XYWH(0, 0, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, unused },
1085             { XYWH(0, 0, 27, 27), 1, genIDA, GrReducedClip::kAllOut_InitialState, XYWH(0, 0, 27, 27)},
1086             { XYWH(0, 0, 27, 27), 1, genIDA, GrReducedClip::kAllOut_InitialState, unused },
1087
1088             // Rect B.
1089             { XYWH(50, 0, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, XYWH(50, 0, 25, 25) },
1090             { XYWH(50, 0, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, unused },
1091             { XYWH(50, 0, 27, 27), 1, genIDB, GrReducedClip::kAllOut_InitialState, XYWH(50, 0, 26, 27) },
1092             { XYWH(50, 0, 27, 27), 1, genIDB, GrReducedClip::kAllOut_InitialState, unused },
1093
1094             // Rect C.
1095             { XYWH(0, 50, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, XYWH(0, 50, 25, 25) },
1096             { XYWH(0, 50, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, unused },
1097             { XYWH(0, 50, 27, 27), 1, genIDC, GrReducedClip::kAllOut_InitialState, XYWH(0, 50, 27, 26) },
1098             { XYWH(0, 50, 27, 27), 1, genIDC, GrReducedClip::kAllOut_InitialState, unused },
1099
1100             // Rect D.
1101             { XYWH(50, 50, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, unused },
1102             { XYWH(50, 50, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, XYWH(50, 50, 25, 25)},
1103             { XYWH(50, 50, 27, 27), 1, genIDD, GrReducedClip::kAllOut_InitialState, unused },
1104             { XYWH(50, 50, 27, 27), 1, genIDD, GrReducedClip::kAllOut_InitialState,  XYWH(50, 50, 26, 26)},
1105
1106             // Other tests:
1107             { XYWH(0, 0, 100, 100), 4, genIDD, GrReducedClip::kAllOut_InitialState, unused },
1108             { XYWH(0, 0, 100, 100), 4, genIDD, GrReducedClip::kAllOut_InitialState, stackBounds },
1109
1110             // Rect in the middle, touches none.
1111             { XYWH(26, 26, 24, 24), 0, SkClipStack::kEmptyGenID, GrReducedClip::kAllOut_InitialState, unused },
1112             { XYWH(26, 26, 24, 24), 0, SkClipStack::kEmptyGenID, GrReducedClip::kAllOut_InitialState, XYWH(26, 26, 24, 24) },
1113
1114             // Rect in the middle, touches all the rects. GenID is the last rect.
1115             { XYWH(24, 24, 27, 27), 4, genIDD, GrReducedClip::kAllOut_InitialState, unused },
1116             { XYWH(24, 24, 27, 27), 4, genIDD, GrReducedClip::kAllOut_InitialState, XYWH(24, 24, 27, 27) },
1117         };
1118
1119 #undef XYWH
1120
1121         for (size_t i = 0; i < SK_ARRAY_COUNT(testCases); ++i) {
1122             GrReducedClip::ElementList reducedClips;
1123             int32_t reducedGenID;
1124             GrReducedClip::InitialState initial;
1125             SkIRect tightBounds;
1126
1127             GrReducedClip::ReduceClipStack(stack,
1128                                            testCases[i].testBounds,
1129                                            &reducedClips,
1130                                            &reducedGenID,
1131                                            &initial,
1132                                            testCases[i].tighterBounds.isEmpty() ? NULL : &tightBounds);
1133
1134             REPORTER_ASSERT(reporter, reducedClips.count() == testCases[i].reducedClipCount);
1135             SkASSERT(reducedClips.count() == testCases[i].reducedClipCount);
1136             REPORTER_ASSERT(reporter, reducedGenID == testCases[i].reducedGenID);
1137             SkASSERT(reducedGenID == testCases[i].reducedGenID);
1138             REPORTER_ASSERT(reporter, initial == testCases[i].initialState);
1139             SkASSERT(initial == testCases[i].initialState);
1140             if (!testCases[i].tighterBounds.isEmpty()) {
1141                 REPORTER_ASSERT(reporter, tightBounds == testCases[i].tighterBounds);
1142                 SkASSERT(tightBounds == testCases[i].tighterBounds);
1143             }
1144         }
1145     }
1146 }
1147
1148 static void test_reduced_clip_stack_no_aa_crash(skiatest::Reporter* reporter) {
1149     SkClipStack stack;
1150     stack.clipDevRect(SkIRect::MakeXYWH(0, 0, 100, 100), SkRegion::kReplace_Op);
1151     stack.clipDevRect(SkIRect::MakeXYWH(0, 0, 50, 50), SkRegion::kReplace_Op);
1152     SkIRect inflatedIBounds = SkIRect::MakeXYWH(0, 0, 100, 100);
1153
1154     GrReducedClip::ElementList reducedClips;
1155     int32_t reducedGenID;
1156     GrReducedClip::InitialState initial;
1157     SkIRect tightBounds;
1158
1159     // At the time, this would crash.
1160     GrReducedClip::ReduceClipStack(stack,
1161                                    inflatedIBounds,
1162                                    &reducedClips,
1163                                    &reducedGenID,
1164                                    &initial,
1165                                    &tightBounds);
1166
1167     REPORTER_ASSERT(reporter, 0 == reducedClips.count());
1168 }
1169
1170 #endif
1171
1172 DEF_TEST(ClipStack, reporter) {
1173     SkClipStack stack;
1174
1175     REPORTER_ASSERT(reporter, 0 == stack.getSaveCount());
1176     assert_count(reporter, stack, 0);
1177
1178     static const SkIRect gRects[] = {
1179         { 0, 0, 100, 100 },
1180         { 25, 25, 125, 125 },
1181         { 0, 0, 1000, 1000 },
1182         { 0, 0, 75, 75 }
1183     };
1184     for (size_t i = 0; i < SK_ARRAY_COUNT(gRects); i++) {
1185         stack.clipDevRect(gRects[i], SkRegion::kIntersect_Op);
1186     }
1187
1188     // all of the above rects should have been intersected, leaving only 1 rect
1189     SkClipStack::B2TIter iter(stack);
1190     const SkClipStack::Element* element = iter.next();
1191     SkRect answer;
1192     answer.iset(25, 25, 75, 75);
1193
1194     REPORTER_ASSERT(reporter, element);
1195     REPORTER_ASSERT(reporter, SkClipStack::Element::kRect_Type == element->getType());
1196     REPORTER_ASSERT(reporter, SkRegion::kIntersect_Op == element->getOp());
1197     REPORTER_ASSERT(reporter, element->getRect() == answer);
1198     // now check that we only had one in our iterator
1199     REPORTER_ASSERT(reporter, !iter.next());
1200
1201     stack.reset();
1202     REPORTER_ASSERT(reporter, 0 == stack.getSaveCount());
1203     assert_count(reporter, stack, 0);
1204
1205     test_assign_and_comparison(reporter);
1206     test_iterators(reporter);
1207     test_bounds(reporter, SkClipStack::Element::kRect_Type);
1208     test_bounds(reporter, SkClipStack::Element::kRRect_Type);
1209     test_bounds(reporter, SkClipStack::Element::kPath_Type);
1210     test_isWideOpen(reporter);
1211     test_rect_merging(reporter);
1212     test_rect_replace(reporter);
1213     test_rect_inverse_fill(reporter);
1214     test_path_replace(reporter);
1215     test_quickContains(reporter);
1216 #if SK_SUPPORT_GPU
1217     test_reduced_clip_stack(reporter);
1218     test_reduced_clip_stack_genid(reporter);
1219     test_reduced_clip_stack_no_aa_crash(reporter);
1220 #endif
1221 }