Make all parameters reqiured to GrReducedClip::ReduceClipStack

tests/ClipStackTest.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "Test.h"
 #if SK_SUPPORT_GPU
     #include "GrReducedClip.h"
@@ skipping 945 matching lines @@
         SkRect inflatedBounds = kBounds;
         inflatedBounds.outset(kBounds.width() / 2, kBounds.height() / 2);
         SkIRect inflatedIBounds;
         inflatedBounds.roundOut(&inflatedIBounds);
 
         typedef GrReducedClip::ElementList ElementList;
         // Get the reduced version of the stack.
         ElementList reducedClips;
         int32_t reducedGenID;
         GrReducedClip::InitialState initial;
-        SkIRect tBounds(inflatedIBounds);
-        SkIRect* tightBounds = r.nextBool() ? &tBounds : nullptr;
+        SkIRect tighterBounds;
+        bool requiresAA;
         GrReducedClip::ReduceClipStack(stack,
                                        inflatedIBounds,
                                        &reducedClips,
                                        &reducedGenID,
                                        &initial,
-                                       tightBounds);
+                                       &tighterBounds,
+                                       &requiresAA);
 
         REPORTER_ASSERT(reporter, SkClipStack::kInvalidGenID != reducedGenID);
 
         // Build a new clip stack based on the reduced clip elements
         SkClipStack reducedStack;
         if (GrReducedClip::kAllOut_InitialState == initial) {
             // whether the result is bounded or not, the whole plane should start outside the clip.
             reducedStack.clipEmpty();
         }
         for (ElementList::Iter iter = reducedClips.headIter(); iter.get(); iter.next()) {
             add_elem_to_stack(*iter.get(), &reducedStack);
         }
 
         // GrReducedClipStack assumes that the final result is clipped to the returned bounds
-        if (tightBounds) {
-            reducedStack.clipDevRect(*tightBounds, SkRegion::kIntersect_Op);
-        }
+        reducedStack.clipDevRect(tighterBounds, SkRegion::kIntersect_Op);
+        stack.clipDevRect(tighterBounds, SkRegion::kIntersect_Op);
 
         // convert both the original stack and reduced stack to SkRegions and see if they're equal
         SkRegion region;
         SkRegion reducedRegion;
 
         region.setRect(inflatedIBounds);
         const SkClipStack::Element* element;
         SkClipStack::Iter iter(stack, SkClipStack::Iter::kBottom_IterStart);
         while ((element = iter.next())) {
             add_elem_to_region(*element, inflatedIBounds, &region);
@@ skipping 20 matching lines @@
     {
         SkClipStack stack;
         stack.clipDevRect(SkRect::MakeXYWH(0, 0, 100, 100), SkRegion::kReplace_Op, true);
         stack.clipDevRect(SkRect::MakeXYWH(0, 0, SkScalar(50.3), SkScalar(50.3)), SkRegion::kReplace_Op, true);
         SkIRect inflatedIBounds = SkIRect::MakeXYWH(0, 0, 100, 100);
 
         GrReducedClip::ElementList reducedClips;
         int32_t reducedGenID;
         GrReducedClip::InitialState initial;
         SkIRect tightBounds;
+        bool requiresAA;
 
         GrReducedClip::ReduceClipStack(stack,
                                        inflatedIBounds,
                                        &reducedClips,
                                        &reducedGenID,
                                        &initial,
-                                       &tightBounds);
+                                       &tightBounds,
+                                       &requiresAA);
 
         REPORTER_ASSERT(reporter, reducedClips.count() == 1);
         // Clips will be cached based on the generation id. Make sure the gen id is valid.
         REPORTER_ASSERT(reporter, SkClipStack::kInvalidGenID != reducedGenID);
     }
     {
         SkClipStack stack;
 
         // Create a clip with following 25.3, 25.3 boxes which are 25 apart:
         //  A  B
         //  C  D
 
         stack.clipDevRect(SkRect::MakeXYWH(0, 0, SkScalar(25.3), SkScalar(25.3)), SkRegion::kReplace_Op, true);
         int32_t genIDA = stack.getTopmostGenID();
         stack.clipDevRect(SkRect::MakeXYWH(50, 0, SkScalar(25.3), SkScalar(25.3)), SkRegion::kUnion_Op, true);
         int32_t genIDB = stack.getTopmostGenID();
         stack.clipDevRect(SkRect::MakeXYWH(0, 50, SkScalar(25.3), SkScalar(25.3)), SkRegion::kUnion_Op, true);
         int32_t genIDC = stack.getTopmostGenID();
         stack.clipDevRect(SkRect::MakeXYWH(50, 50, SkScalar(25.3), SkScalar(25.3)), SkRegion::kUnion_Op, true);
         int32_t genIDD = stack.getTopmostGenID();
 
 
 #define XYWH SkIRect::MakeXYWH
 
-        SkIRect unused;
-        unused.setEmpty();
         SkIRect stackBounds = XYWH(0, 0, 76, 76);
 
         // The base test is to test each rect in two ways:
         // 1) The box dimensions. (Should reduce to "all in", no elements).
         // 2) A bit over the box dimensions.
         // In the case 2, test that the generation id is what is expected.
         // The rects are of fractional size so that case 2 never gets optimized to an empty element
         // list.
 
         // Not passing in tighter bounds is tested for consistency.
         static const struct SUPPRESS_VISIBILITY_WARNING {
             SkIRect testBounds;
             int reducedClipCount;
             int32_t reducedGenID;
             GrReducedClip::InitialState initialState;
             SkIRect tighterBounds; // If this is empty, the query will not pass tighter bounds
             // parameter.
         } testCases[] = {
             // Rect A.
             { XYWH(0, 0, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, XYWH(0, 0, 25, 25) },
-            { XYWH(0, 0, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, unused },
             { XYWH(0, 0, 27, 27), 1, genIDA, GrReducedClip::kAllOut_InitialState, XYWH(0, 0, 27, 27)},
-            { XYWH(0, 0, 27, 27), 1, genIDA, GrReducedClip::kAllOut_InitialState, unused },
 
             // Rect B.
             { XYWH(50, 0, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, XYWH(50, 0, 25, 25) },
-            { XYWH(50, 0, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, unused },
             { XYWH(50, 0, 27, 27), 1, genIDB, GrReducedClip::kAllOut_InitialState, XYWH(50, 0, 26, 27) },
-            { XYWH(50, 0, 27, 27), 1, genIDB, GrReducedClip::kAllOut_InitialState, unused },
 
             // Rect C.
             { XYWH(0, 50, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, XYWH(0, 50, 25, 25) },
-            { XYWH(0, 50, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, unused },
             { XYWH(0, 50, 27, 27), 1, genIDC, GrReducedClip::kAllOut_InitialState, XYWH(0, 50, 27, 26) },
-            { XYWH(0, 50, 27, 27), 1, genIDC, GrReducedClip::kAllOut_InitialState, unused },
 
             // Rect D.
-            { XYWH(50, 50, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, unused },
             { XYWH(50, 50, 25, 25), 0, SkClipStack::kWideOpenGenID, GrReducedClip::kAllIn_InitialState, XYWH(50, 50, 25, 25)},
-            { XYWH(50, 50, 27, 27), 1, genIDD, GrReducedClip::kAllOut_InitialState, unused },
             { XYWH(50, 50, 27, 27), 1, genIDD, GrReducedClip::kAllOut_InitialState,  XYWH(50, 50, 26, 26)},
 
             // Other tests:
-            { XYWH(0, 0, 100, 100), 4, genIDD, GrReducedClip::kAllOut_InitialState, unused },
             { XYWH(0, 0, 100, 100), 4, genIDD, GrReducedClip::kAllOut_InitialState, stackBounds },
 
             // Rect in the middle, touches none.
-            { XYWH(26, 26, 24, 24), 0, SkClipStack::kEmptyGenID, GrReducedClip::kAllOut_InitialState, unused },
             { XYWH(26, 26, 24, 24), 0, SkClipStack::kEmptyGenID, GrReducedClip::kAllOut_InitialState, XYWH(26, 26, 24, 24) },
 
             // Rect in the middle, touches all the rects. GenID is the last rect.
-            { XYWH(24, 24, 27, 27), 4, genIDD, GrReducedClip::kAllOut_InitialState, unused },
             { XYWH(24, 24, 27, 27), 4, genIDD, GrReducedClip::kAllOut_InitialState, XYWH(24, 24, 27, 27) },
         };
 
 #undef XYWH
 
         for (size_t i = 0; i < SK_ARRAY_COUNT(testCases); ++i) {
             GrReducedClip::ElementList reducedClips;
             int32_t reducedGenID;
             GrReducedClip::InitialState initial;
             SkIRect tightBounds;
+            bool requiresAA;
 
             GrReducedClip::ReduceClipStack(stack,
                                            testCases[i].testBounds,
                                            &reducedClips,
                                            &reducedGenID,
                                            &initial,
-                                           testCases[i].tighterBounds.isEmpty() ? nullptr : &tightBounds);
+                                           &tightBounds,
+                                           &requiresAA);
 
             REPORTER_ASSERT(reporter, reducedClips.count() == testCases[i].reducedClipCount);
             SkASSERT(reducedClips.count() == testCases[i].reducedClipCount);
             REPORTER_ASSERT(reporter, reducedGenID == testCases[i].reducedGenID);
             SkASSERT(reducedGenID == testCases[i].reducedGenID);
             REPORTER_ASSERT(reporter, initial == testCases[i].initialState);
             SkASSERT(initial == testCases[i].initialState);
-            if (!testCases[i].tighterBounds.isEmpty()) {
-                REPORTER_ASSERT(reporter, tightBounds == testCases[i].tighterBounds);
-                SkASSERT(tightBounds == testCases[i].tighterBounds);
-            }
+            REPORTER_ASSERT(reporter, tightBounds == testCases[i].tighterBounds);
+            SkASSERT(tightBounds == testCases[i].tighterBounds);
         }
     }
 }
 
 static void test_reduced_clip_stack_no_aa_crash(skiatest::Reporter* reporter) {
     SkClipStack stack;
     stack.clipDevRect(SkIRect::MakeXYWH(0, 0, 100, 100), SkRegion::kReplace_Op);
     stack.clipDevRect(SkIRect::MakeXYWH(0, 0, 50, 50), SkRegion::kReplace_Op);
     SkIRect inflatedIBounds = SkIRect::MakeXYWH(0, 0, 100, 100);
 
     GrReducedClip::ElementList reducedClips;
     int32_t reducedGenID;
     GrReducedClip::InitialState initial;
     SkIRect tightBounds;
+    bool requiresAA;
 
     // At the time, this would crash.
     GrReducedClip::ReduceClipStack(stack,
                                    inflatedIBounds,
                                    &reducedClips,
                                    &reducedGenID,
                                    &initial,
-                                   &tightBounds);
+                                   &tightBounds,
+                                   &requiresAA);
 
     REPORTER_ASSERT(reporter, 0 == reducedClips.count());
 }
 
 #endif
 
 DEF_TEST(ClipStack, reporter) {
     SkClipStack stack;
 
     REPORTER_ASSERT(reporter, 0 == stack.getSaveCount());
@@ skipping 36 matching lines @@
     test_rect_replace(reporter);
     test_rect_inverse_fill(reporter);
     test_path_replace(reporter);
     test_quickContains(reporter);
 #if SK_SUPPORT_GPU
     test_reduced_clip_stack(reporter);
     test_reduced_clip_stack_genid(reporter);
     test_reduced_clip_stack_no_aa_crash(reporter);
 #endif
 }