Move scissor state to GrAppliedClip

src/gpu/GrClipMaskManager.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 "GrClipMaskManager.h"
 #include "GrCaps.h"
 #include "GrDrawContext.h"
@@ skipping 191 matching lines @@
         fps[i]->unref();
     }
     return !failed;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // sort out what kind of clip mask needs to be created: alpha, stencil,
 // scissor, or entirely software
 bool GrClipMaskManager::setupClipping(const GrPipelineBuilder& pipelineBuilder,
                                       GrPipelineBuilder::AutoRestoreStencil* ars,
-                                      GrScissorState* scissorState,
                                       const SkRect* devBounds,
                                       GrAppliedClip* out) {
     if (kRespectClip_StencilClipMode == fClipMode) {
         fClipMode = kIgnoreClip_StencilClipMode;
     }
 
     GrReducedClip::ElementList elements(16);
     int32_t genID = 0;
     GrReducedClip::InitialState initialState = GrReducedClip::kAllIn_InitialState;
     SkIRect clipSpaceIBounds;
@@ skipping 12 matching lines @@
 
     // The clip mask manager always draws with a single IRect so we special case that logic here
     // Image filters just use a rect, so we also special case that logic
     switch (clip.clipType()) {
         case GrClip::kWideOpen_ClipType:
             SkFAIL("Should have caught this with clip.isWideOpen()");
             return true;
         case GrClip::kIRect_ClipType: {
             SkIRect scissor = clip.irect();
             if (scissor.intersect(clipSpaceRTIBounds)) {
-                scissorState->set(scissor);
+                out->fScissorState.set(scissor);
                 this->setPipelineBuilderStencil(pipelineBuilder, ars);
                 return true;
             }
             return false;
         }
         case GrClip::kClipStack_ClipType: {
             clipSpaceRTIBounds.offset(clip.origin());
             GrReducedClip::ReduceClipStack(*clip.clipStack(),
                                             clipSpaceRTIBounds,
                                             &elements,
@@ skipping 30 matching lines @@
         bool disallowAnalyticAA = pipelineBuilder.getRenderTarget()->isUnifiedMultisampled();
         const GrFragmentProcessor* clipFP = nullptr;
         if (elements.isEmpty() ||
             (requiresAA &&
              this->getAnalyticClipProcessor(elements, disallowAnalyticAA, clipToRTOffset, devBounds,
                                             &clipFP))) {
             SkIRect scissorSpaceIBounds(clipSpaceIBounds);
             scissorSpaceIBounds.offset(-clip.origin());
             if (nullptr == devBounds ||
                 !SkRect::Make(scissorSpaceIBounds).contains(*devBounds)) {
-                scissorState->set(scissorSpaceIBounds);
+                out->fScissorState.set(scissorSpaceIBounds);
             }
             this->setPipelineBuilderStencil(pipelineBuilder, ars);
             out->fClipCoverageFP.reset(clipFP);
             return true;
         }
     }
 
     // If MSAA is enabled we can do everything in the stencil buffer.
     if (0 == rt->numStencilSamples() && requiresAA) {
         SkAutoTUnref<GrTexture> result;
@@ skipping 39 matching lines @@
                                 initialState,
                                 elements,
                                 clipSpaceIBounds,
                                 clipSpaceToStencilSpaceOffset);
 
     // This must occur after createStencilClipMask. That function may change the scissor. Also, it
     // only guarantees that the stencil mask is correct within the bounds it was passed, so we must
     // use both stencil and scissor test to the bounds for the final draw.
     SkIRect scissorSpaceIBounds(clipSpaceIBounds);
     scissorSpaceIBounds.offset(clipSpaceToStencilSpaceOffset);
-    scissorState->set(scissorSpaceIBounds);
+    out->fScissorState.set(scissorSpaceIBounds);
     this->setPipelineBuilderStencil(pipelineBuilder, ars);
     return true;
 }
 
 namespace {
 ////////////////////////////////////////////////////////////////////////////////
 // Set a coverage drawing XPF on the pipelineBuilder for the given op and invertCoverage mode
 void set_coverage_drawing_xpf(SkRegion::Op op, bool invertCoverage,
                               GrPipelineBuilder* pipelineBuilder) {
     SkASSERT(op <= SkRegion::kLastOp);
@@ skipping 747 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 
 void GrClipMaskManager::adjustPathStencilParams(const GrStencilAttachment* stencilAttachment,
                                                 GrStencilSettings* settings) {
     if (stencilAttachment) {
         int stencilBits = stencilAttachment->bits();
         this->adjustStencilParams(settings, fClipMode, stencilBits);
     }
 }