Begin weaning GrClipMaskManager off of GrDrawTarget (take 2)

include/gpu/GrDrawContext.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrDrawContext_DEFINED
 #define GrDrawContext_DEFINED
 
 #include "GrColor.h"
 #include "GrRenderTarget.h"
 #include "SkRefCnt.h"
+#include "SkRegion.h"
 #include "SkSurfaceProps.h"
 #include "../private/GrSingleOwner.h"
 
 class GrAtlasTextContext;
 class GrAuditTrail;
 class GrClip;
 class GrContext;
 class GrDrawBatch;
 class GrDrawPathBatchBase;
 class GrDrawingManager;
 class GrDrawTarget;
 class GrPaint;
 class GrPathProcessor;
 class GrPipelineBuilder;
 class GrRenderTarget;
+class GrStencilSettings;
 class GrStrokeInfo;
 class GrSurface;
 class SkDrawFilter;
 struct SkIPoint;
 struct SkIRect;
 class SkMatrix;
 class SkPaint;
 class SkPath;
 struct SkPoint;
 struct SkRect;
@@ skipping 56 matching lines @@
      *                      is always a single pixel thick, else the rect is
      *                      mitered/beveled stroked based on stroke width.
      *  The rects coords are used to access the paint (through texture matrix)
      */
     void drawRect(const GrClip&,
                   const GrPaint& paint,
                   const SkMatrix& viewMatrix,
                   const SkRect&,
                   const GrStrokeInfo* strokeInfo = NULL);
 
+    bool stencilRect(const SkIRect* scissorRect,

[joshualitt, 2016/03/01 17:34:50]

I really like the direction this CL is going, but do we want this to be on a
subclass of the DC?

to play devil's advocate to myself, what about DefaultPathRenderer? Doesn't he
need to use the stencil?  In any case do we want to limit this usage to internal
constructs?

[bsalomon, 2016/03/01 17:38:55]

I think the name here isn't quite right... it isn't just stenciling.
drawAndStencilClipRect? perfomClipRectCoverageAndStencil()?
addRectToCoverageClipMask?

[bsalomon, 2016/03/01 17:40:06]

I think some way of hiding this is in order (priv class, subclass, ...). Don't
want someone to call this from say an image filter impl. I think this is a
pretty fragile signature that should only exist for the ccm.

[robertphillips, 2016/03/01 20:11:57]

Done - for now. I was hoping to fold the stencil-only path into this call too
but we can re-rename it if that succeeds.

[robertphillips, 2016/03/01 20:11:57]

Done. I have added GrDrawContextPriv.

+                     const GrStencilSettings&,
+                     SkRegion::Op op,
+                     bool invert,
+                     bool doAA,
+                     const SkMatrix& viewMatrix,
+                     const SkRect&);
+
     /**
      * Maps a rectangle of shader coordinates to a rectangle and fills that rectangle.
      *
      * @param paint         describes how to color pixels.
      * @param viewMatrix    transformation matrix which applies to rectToDraw
      * @param rectToDraw    the rectangle to draw
      * @param localRect     the rectangle of shader coordinates applied to rectToDraw
      */
     void fillRectToRect(const GrClip&,
                         const GrPaint& paint,
@@ skipping 33 matching lines @@
      * @param path          the path to draw
      * @param strokeInfo    the stroke information (width, join, cap) and
      *                      the dash information (intervals, count, phase).
      */
     void drawPath(const GrClip&,
                   const GrPaint&,
                   const SkMatrix& viewMatrix,
                   const SkPath&,
                   const GrStrokeInfo&);
 
+    bool stencilPath(const SkIRect* scissorRect,
+                     const GrStencilSettings&,
+                     SkRegion::Op op,
+                     bool invert,
+                     bool doAA,
+                     const SkMatrix& viewMatrix,
+                     const SkPath&);
+
     /**
      * Draws vertices with a paint.
      *
      * @param   paint           describes how to color pixels.
      * @param   viewMatrix      transformation matrix
      * @param   primitiveType   primitives type to draw.
      * @param   vertexCount     number of vertices.
      * @param   positions       array of vertex positions, required.
      * @param   texCoords       optional array of texture coordinates used
      *                          to access the paint.
@@ skipping 105 matching lines @@
     GrAuditTrail* auditTrail() { return fAuditTrail; }
     const SkSurfaceProps& surfaceProps() const { return fSurfaceProps; }
     
     SkDEBUGCODE(GrSingleOwner* singleOwner() { return fSingleOwner; })
     SkDEBUGCODE(void validate() const;)
 
 private:
     friend class GrAtlasTextBlob; // for access to drawBatch
     friend class GrDrawingManager; // for ctor
 
+    GrDrawBatch* getFillRectBatch(const GrPaint& paint,
+                                  const SkMatrix& viewMatrix,
+                                  const SkRect& rect);
+
     void internalDrawPath(GrPipelineBuilder*,
                           const SkMatrix& viewMatrix,
                           GrColor,
                           bool useAA,
                           const SkPath&,
                           const GrStrokeInfo&);
 
     // This entry point allows the GrTextContext-derived classes to add their batches to
     // the drawTarget.
     void drawBatch(GrPipelineBuilder* pipelineBuilder, GrDrawBatch* batch);
@@ skipping 10 matching lines @@
     GrContext*                        fContext;
 
     SkSurfaceProps                    fSurfaceProps;
     GrAuditTrail*                     fAuditTrail;
 
     // In debug builds we guard against improper thread handling
     SkDEBUGCODE(mutable GrSingleOwner* fSingleOwner;)
 };
 
 #endif