Move clip off of 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 "GrClip.h"
 #include "GrClipMaskManager.h"
 #include "GrContext.h"
 #include "GrPathProcessor.h"
 #include "GrPrimitiveProcessor.h"
 #include "GrIndexBuffer.h"
 #include "GrPathRendering.h"
 #include "GrPipelineBuilder.h"
 #include "GrTraceMarker.h"
 #include "GrVertexBuffer.h"
 
 #include "SkClipStack.h"
 #include "SkMatrix.h"
 #include "SkPath.h"
 #include "SkStrokeRec.h"
 #include "SkTArray.h"
 #include "SkTLazy.h"
 #include "SkTypes.h"
 #include "SkXfermode.h"
 
 class GrBatch;
-class GrClipData;
+class GrClip;
 class GrDrawTargetCaps;
 class GrPath;
 class GrPathRange;
 class GrPipeline;
 
 class GrDrawTarget : public SkRefCnt {
 public:
     SK_DECLARE_INST_COUNT(GrDrawTarget)
 
     typedef GrPathRange::PathIndexType PathIndexType;
     typedef GrPathRendering::PathTransformType PathTransformType;
 
     ///////////////////////////////////////////////////////////////////////////
 
     // The context may not be fully constructed and should not be used during GrDrawTarget
     // construction.
     GrDrawTarget(GrContext* context);
     virtual ~GrDrawTarget();
 
     /**
      * Gets the capabilities of the draw target.
      */
     const GrDrawTargetCaps* caps() const { return fCaps.get(); }
 
     /**
-     * Sets the current clip to the region specified by clip. All draws will be
-     * clipped against this clip if kClip_StateBit is enabled.
-     *
-     * Setting the clip may (or may not) zero out the client's stencil bits.
-     *
-     * @param description of the clipping region
-     */
-    void setClip(const GrClipData* clip);
-
-    /**
-     * Gets the current clip.
-     *
-     * @return the clip.
-     */
-    const GrClipData* getClip() const;
-
-    /**
      * There are two types of "sources" of geometry (vertices and indices) for
      * draw calls made on the target. When performing an indexed draw, the
      * indices and vertices can use different source types. Once a source is
      * specified it can be used for multiple draws. However, the time at which
      * the geometry data is no longer editable depends on the source type.
      *
      * Sometimes it is necessary to perform a draw while upstack code has
      * already specified geometry that it isn't finished with. So there are push
      * and pop methods. This allows the client to push the sources, draw
      * something using alternate sources, and then pop to restore the original
@@ skipping 172 matching lines @@
      *                     not a request for clipping.
      */
     void drawNonIndexed(GrPipelineBuilder*,
                         const GrGeometryProcessor*,
                         GrPrimitiveType type,
                         int startVertex,
                         int vertexCount,
                         const SkRect* devBounds = NULL);
 
     // TODO devbounds should live on the batch
-    void drawBatch(GrPipelineBuilder*,
-                   GrBatch*,
-                   const SkRect* devBounds = NULL);
+    void drawBatch(GrPipelineBuilder*, GrBatch*, const SkRect* devBounds = NULL);
 
     /**
      * Draws path into the stencil buffer. The fill must be either even/odd or
      * winding (not inverse or hairline). It will respect the HW antialias flag
      * on the GrPipelineBuilder (if possible in the 3D API).  Note, we will never have an inverse
      * fill with stencil path
      */
     void stencilPath(GrPipelineBuilder*, const GrPathProcessor*, const GrPath*,
                      GrPathRendering::FillType);
 
@@ skipping 188 matching lines @@
     private:
         void reset();
 
         GrDrawTarget* fTarget;
         void*         fVertices;
         void*         fIndices;
     };
 
     ////////////////////////////////////////////////////////////////////////////
 
-    class AutoClipRestore : public ::SkNoncopyable {
-    public:
-        AutoClipRestore(GrDrawTarget* target) {
-            fTarget = target;
-            fClip = fTarget->getClip();
-        }
-
-        AutoClipRestore(GrDrawTarget* target, const SkIRect& newClip);
-
-        ~AutoClipRestore() {
-            fTarget->setClip(fClip);
-        }
-    private:
-        GrDrawTarget*           fTarget;
-        const GrClipData*       fClip;
-        SkTLazy<SkClipStack>    fStack;
-        GrClipData              fReplacementClip;
-    };
-
-    ////////////////////////////////////////////////////////////////////////////
-
     /**
      * Saves the geometry src state at construction and restores in the destructor. It also saves
      * and then restores the vertex attrib state.
      */
     class AutoGeometryPush : public ::SkNoncopyable {
     public:
         AutoGeometryPush(GrDrawTarget* target) {
             SkASSERT(target);
             fTarget = target;
             target->pushGeometrySource();
@@ skipping 172 matching lines @@
     // but couldn't be made. Otherwise, returns true.  This method needs to be protected because it
     // needs to be accessed by GLPrograms to setup a correct drawstate
     bool setupDstReadIfNecessary(const GrPipelineBuilder&,
                                  const GrProcOptInfo& colorPOI,
                                  const GrProcOptInfo& coveragePOI,
                                  GrDeviceCoordTexture* dstCopy,
                                  const SkRect* drawBounds);
 
     struct PipelineInfo {
         PipelineInfo(GrPipelineBuilder* pipelineBuilder, GrScissorState* scissor,
-                     const GrPrimitiveProcessor* primProc, const SkRect* devBounds,
-                     GrDrawTarget* target);
+                     const GrPrimitiveProcessor* primProc,
+                     const SkRect* devBounds, GrDrawTarget* target);
 
         PipelineInfo(GrPipelineBuilder* pipelineBuilder, GrScissorState* scissor,
-                     const GrBatch* batch, const SkRect* devBounds, GrDrawTarget* target);
+                     const GrBatch* batch, const SkRect* devBounds,
+                     GrDrawTarget* target);
 
         bool willBlendWithDst(const GrPrimitiveProcessor* primProc) const {
             return fPipelineBuilder->willBlendWithDst(primProc);
         }
     private:
         friend class GrDrawTarget;
 
         bool mustSkipDraw() const { return (NULL == fPipelineBuilder); }
 
         GrPipelineBuilder*      fPipelineBuilder;
@@ skipping 125 matching lines @@
     virtual bool setupClip(GrPipelineBuilder*,
                            GrPipelineBuilder::AutoRestoreEffects* are,
                            GrPipelineBuilder::AutoRestoreStencil* ars,
                            GrScissorState* scissorState,
                            const SkRect* devBounds) = 0;
 
     enum {
         kPreallocGeoSrcStateStackCnt = 4,
     };
     SkSTArray<kPreallocGeoSrcStateStackCnt, GeometrySrcState, true> fGeoSrcStateStack;
-    const GrClipData*                                               fClip;
     // The context owns us, not vice-versa, so this ptr is not ref'ed by DrawTarget.
     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;
 };
 
@@ skipping 39 matching lines @@
     virtual bool setupClip(GrPipelineBuilder*,
                            GrPipelineBuilder::AutoRestoreEffects* are,
                            GrPipelineBuilder::AutoRestoreStencil* ars,
                            GrScissorState* scissorState,
                            const SkRect* devBounds) SK_OVERRIDE;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif