clear stencil clip on draw target

src/gpu/GrDrawTarget.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawTarget_DEFINED
 #define GrDrawTarget_DEFINED
 
 #include "GrClipData.h"
+#include "GrClipMaskManager.h"
 #include "GrContext.h"
 #include "GrDrawState.h"
 #include "GrIndexBuffer.h"
 #include "GrPathRendering.h"
 #include "GrTraceMarker.h"
 
 #include "SkClipStack.h"
 #include "SkMatrix.h"
 #include "SkPath.h"
 #include "SkStrokeRec.h"
@@ skipping 390 matching lines @@
      * clip and all other draw state (blend mode, stages, etc). Clears the
      * whole thing if rect is NULL, otherwise just the rect. If canIgnoreRect
      * is set then the entire render target can be optionally cleared.
      */
     virtual void clear(const SkIRect* rect,
                        GrColor color,
                        bool canIgnoreRect,
                        GrRenderTarget* renderTarget = NULL) = 0;
 
     /**
+     * Similar to the above.  DrawTarget subclass sets clip bit in the stencil buffer. The subclass
+     * is free to clear the remaining bits to zero if masked clears are more
+     * expensive than clearing all bits.
+     */
+
+    virtual void clearStencilClip(const SkIRect& rect, bool insideClip, GrRenderTarget* = NULL) = 0;

[bsalomon, 2014/10/28 15:08:01]

Does this need to be on GrDT or can it just be on GrGpu? I don't think this
should be exposed to any code that has a GrDT but should be called on GrGpu by
GrDT on behalf of GrCMM 

+
+    /**
      * Discards the contents render target. NULL indicates that the current render target should
      * be discarded.
      **/
     virtual void discard(GrRenderTarget* = NULL) = 0;
 
     /**
      * Called at start and end of gpu trace marking
      * GR_CREATE_GPU_TRACE_MARKER(marker_str, target) will automatically call these at the start
      * and end of a code block respectively
      */
@@ skipping 253 matching lines @@
         bool isIssued() { return fDrawTarget && fDrawTarget->isIssued(fDrawID); }
 
     private:
         GrDrawTarget*  fDrawTarget;
         uint32_t       fDrawID;   // this may wrap, but we're doing direct comparison
                                   // so that should be okay
     };
 
     virtual DrawToken getCurrentDrawToken() { return DrawToken(this, 0); }
 
-    // The state of the scissor is controlled by the clip manager, no one else should set
-    // Scissor state
-    struct ScissorState {
-        ScissorState() : fEnabled(false) {}
-        void set(const SkIRect& rect) { fRect = rect; fEnabled = true; }
-        bool    fEnabled;
-        SkIRect fRect;
-    };
-
 protected:
     // Extend access to GrDrawState::convertToPEndeingExec to subclasses.
     void convertDrawStateToPendingExec(GrDrawState* ds) {
         ds->convertToPendingExec();
     }
 
     enum GeometrySrcType {
         kNone_GeometrySrcType,     //<! src has not been specified
         kReserved_GeometrySrcType, //<! src was set using reserve*Space
         kArray_GeometrySrcType,    //<! src was set using set*SourceToArray
@@ skipping 229 matching lines @@
     GrContext*                                                      fContext;
     // To keep track that we always have at least as many debug marker adds as removes
     int                                                             fGpuTraceMarkerCount;
     GrTraceMarkerSet                                                fActiveTraceMarkers;
     GrTraceMarkerSet                                                fStoredTraceMarkers;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif