Make GrReducedClip's gen ID only apply to the element list

src/gpu/GrReducedClip.cpp

 /*
  * Copyright 2016 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"
 
 #include "GrClip.h"
@@ skipping 298 matching lines @@
                 if (element->isAA()) {
                     --numAAElements;
                 }
                 result->popHead();
                 element = result->headIter().get();
             }
         }
     }
     *requiresAA = numAAElements > 0;
 
-    if (0 == result->count()) {
-        if (initialState == InitialTriState::kAllIn) {
-            *resultGenID = SkClipStack::kWideOpenGenID;
-        } else {
-            *resultGenID = SkClipStack::kEmptyGenID;
-        }
-    }
-
-    SkASSERT(SkClipStack::kInvalidGenID != *resultGenID);
     SkASSERT(InitialTriState::kUnknown != initialState);
     return static_cast<GrReducedClip::InitialState>(initialState);
 }
 
 /*
 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.
 */
 GrReducedClip::GrReducedClip(const SkClipStack& stack, const SkRect& queryBounds) {
     SkASSERT(!queryBounds.isEmpty());
-
-    // 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.
-    fGenID = stack.getTopmostGenID();
     fHasIBounds = false;
 
     if (stack.isWideOpen()) {
         fInitialState = InitialState::kAllIn;
         return;
     }
 
     SkClipStack::BoundsType stackBoundsType;
     SkRect stackBounds;
     bool iior;
@@ skipping 24 matching lines @@
         }
 
         SkRect tightBounds;
         SkAssertResult(tightBounds.intersect(stackBounds, queryBounds));
         fIBounds = GrClip::GetPixelIBounds(tightBounds);
         SkASSERT(!fIBounds.isEmpty()); // Empty should have been blocked by IsOutsideClip above.
         fHasIBounds = true;
 
         // Implement the clip with an AA rect element.
         fElements.addToHead(stackBounds, SkRegion::kReplace_Op, true/*doAA*/);
+        fElementsGenID = stack.getTopmostGenID();
         fRequiresAA = true;
 
         fInitialState = InitialState::kAllOut;
         return;
     }
 
     SkRect tighterQuery = queryBounds;
     if (SkClipStack::kNormal_BoundsType == stackBoundsType) {
         // Tighten the query by introducing a new clip at the stack's pixel boundaries. (This new
         // clip will be enforced by the scissor through fIBounds.)
         SkAssertResult(tighterQuery.intersect(GrClip::GetPixelBounds(stackBounds)));
     }
 
     fIBounds = GrClip::GetPixelIBounds(tighterQuery);
     SkASSERT(!fIBounds.isEmpty()); // Empty should have been blocked by IsOutsideClip above.
     fHasIBounds = true;
 
     // Now that we have determined the bounds to use and filtered out the trivial cases, call the
     // helper that actually walks the stack.
-    fInitialState = reduced_stack_walker(stack, tighterQuery, fIBounds, &fElements, &fGenID,
+    fInitialState = reduced_stack_walker(stack, tighterQuery, fIBounds, &fElements, &fElementsGenID,
                                          &fRequiresAA);
 }