Make all parameters reqiured to GrReducedClip::ReduceClipStack

src/gpu/GrReducedClip.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrReducedClip.h"
 
 typedef SkClipStack::Element Element;
@@ skipping 284 matching lines @@
                 break;
             } else {
                 if (element->isAA()) {
                     --numAAElements;
                 }
                 result->popHead();
                 element = result->headIter().get();
             }
         }
     }
-    if (requiresAA) {
-        *requiresAA = numAAElements > 0;
-    }
+    *requiresAA = numAAElements > 0;
 
     if (0 == result->count()) {
         if (*initialState == GrReducedClip::kAllIn_InitialState) {
             *resultGenID = SkClipStack::kWideOpenGenID;
         } else {
             *resultGenID = SkClipStack::kEmptyGenID;
         }
     }
 }
 
 /*
 There are plenty of optimizations that could be added here. Maybe flips could be folded into
 earlier operations. Or would inserting flips and reversing earlier ops ever be a win? Perhaps
 for the case where the bounds are kInsideOut_BoundsType. We could restrict earlier operations
 based on later intersect operations, and perhaps remove intersect-rects. We could optionally
 take a rect in case the caller knows a bound on what is to be drawn through this clip.
 */
 void GrReducedClip::ReduceClipStack(const SkClipStack& stack,
                                     const SkIRect& queryBounds,
                                     ElementList* result,
                                     int32_t* resultGenID,
                                     InitialState* initialState,
                                     SkIRect* tighterBounds,
                                     bool* requiresAA) {
+    SkASSERT(tighterBounds);
+    SkASSERT(requiresAA);
     result->reset();
 
     // The clip established by the element list might be cached based on the last
     // generation id. When we make early returns, we do not know what was the generation
     // id that lead to the state. Make a conservative guess.
     *resultGenID = stack.getTopmostGenID();
 
     if (stack.isWideOpen()) {
         *initialState = kAllIn_InitialState;
         return;
@@ skipping 10 matching lines @@
 
     const SkIRect* bounds = &queryBounds;
 
     SkRect scalarQueryBounds = SkRect::Make(queryBounds);
 
     if (iior) {
         SkASSERT(SkClipStack::kNormal_BoundsType == stackBoundsType);
         SkRect isectRect;
         if (stackBounds.contains(scalarQueryBounds)) {
             *initialState = GrReducedClip::kAllIn_InitialState;
-            if (tighterBounds) {
-                *tighterBounds = queryBounds;
-            }
-            if (requiresAA) {
-               *requiresAA = false;
-            }
+            *tighterBounds = queryBounds;

[robertphillips, 2016/07/07 20:30:48]

missing ' ' ?

[bsalomon, 2016/07/07 23:53:13]

Done.

+           *requiresAA = false;
         } else if (isectRect.intersect(stackBounds, scalarQueryBounds)) {
             // If the caller asked for tighter integer bounds we may be able to
             // return kAllIn and give the bounds with no elements
-            if (tighterBounds) {
-                isectRect.roundOut(tighterBounds);
-                SkRect scalarTighterBounds = SkRect::Make(*tighterBounds);
-                if (scalarTighterBounds == isectRect) {
-                    // the round-out didn't add any area outside the clip rect.
-                    if (requiresAA) {
-                        *requiresAA = false;
-                    }
-                    *initialState = GrReducedClip::kAllIn_InitialState;
-                    return;
-                }
+            isectRect.roundOut(tighterBounds);
+            SkRect scalarTighterBounds = SkRect::Make(*tighterBounds);
+            if (scalarTighterBounds == isectRect) {
+                // the round-out didn't add any area outside the clip rect.
+                *requiresAA = false;
+                *initialState = GrReducedClip::kAllIn_InitialState;
+                return;
             }
             *initialState = kAllOut_InitialState;
             // iior should only be true if aa/non-aa status matches among all elements.
             SkClipStack::Iter iter(stack, SkClipStack::Iter::kTop_IterStart);
             bool doAA = iter.prev()->isAA();
             result->addToHead(isectRect, SkRegion::kReplace_Op, doAA);
-            if (requiresAA) {
-                *requiresAA = doAA;
-            }
+            *requiresAA = doAA;
         } else {
             *initialState = kAllOut_InitialState;
-             if (requiresAA) {
-                *requiresAA = false;
-             }
+            *requiresAA = false;
         }
         return;
     } else {
         if (SkClipStack::kNormal_BoundsType == stackBoundsType) {
             if (!SkRect::Intersects(stackBounds, scalarQueryBounds)) {
                 *initialState = kAllOut_InitialState;
-                if (requiresAA) {
-                   *requiresAA = false;
-                }
+               *requiresAA = false;
                 return;
             }
-            if (tighterBounds) {
-                SkIRect stackIBounds;
-                stackBounds.roundOut(&stackIBounds);
-                if (!tighterBounds->intersect(queryBounds, stackIBounds)) {
-                    SkASSERT(0);
-                    tighterBounds->setEmpty();
-                }
-                bounds = tighterBounds;
+            SkIRect stackIBounds;
+            stackBounds.roundOut(&stackIBounds);
+            if (!tighterBounds->intersect(queryBounds, stackIBounds)) {
+                SkASSERT(0);
+                tighterBounds->setEmpty();
             }
+            bounds = tighterBounds;
         } else {
             if (stackBounds.contains(scalarQueryBounds)) {
                 *initialState = kAllOut_InitialState;
                 // We know that the bounding box contains all the pixels that are outside the clip,
                 // but we don't know that *all* the pixels in the box are outside the clip. So
                 // proceed to walking the stack.
             }
-            if (tighterBounds) {
-                *tighterBounds = queryBounds;
-            }
+            *tighterBounds = queryBounds;
         }
     }
 
     SkRect scalarBounds = SkRect::Make(*bounds);
 
     // Now that we have determined the bounds to use and filtered out the trivial cases, call the
     // helper that actually walks the stack.
     reduced_stack_walker(stack, scalarBounds, result, resultGenID, initialState, requiresAA);
 
     // The list that was computed in this function may be cached based on the gen id of the last
     // element.
     SkASSERT(SkClipStack::kInvalidGenID != *resultGenID);
 }