Drawstate on stack

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
 
@@ skipping 49 matching lines @@
     void setClip(const GrClipData* clip);
 
     /**
      * Gets the current clip.
      *
      * @return the clip.
      */
     const GrClipData* getClip() const;
 
     /**
-     * Sets the draw state object for the draw target. Note that this does not
-     * make a copy. The GrDrawTarget will take a reference to passed object.
-     * Passing NULL will cause the GrDrawTarget to use its own internal draw
-     * state object rather than an externally provided one.
-     */
-    void setDrawState(GrDrawState*  drawState);
-
-    /**
-     * Read-only access to the GrDrawTarget's current draw state.
-     */
-    const GrDrawState& getDrawState() const { return *fDrawState; }
-
-    /**
-     * Read-write access to the GrDrawTarget's current draw state. Note that
-     * this doesn't ref.
-     */
-    GrDrawState* drawState() { return fDrawState; }
-
-    /** When we're using coverage AA but the blend is incompatible (given gpu
-     * limitations) we should disable AA. */
-    bool shouldDisableCoverageAAForBlend() const {
-        // Enable below if we should draw with AA even when it produces
-        // incorrect blending.
-        // return false;
-        return !this->getDrawState().couldApplyCoverage(*this->caps());
-    }
-
-    /**
      * There are three 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 53 matching lines @@
      *
      * @param vertexCount  the number of vertices to reserve space for. Can be
      *                     0. Vertex size is queried from the current GrDrawState.
      * @param indexCount   the number of indices to reserve space for. Can be 0.
      * @param vertices     will point to reserved vertex space if vertexCount is
      *                     non-zero. Illegal to pass NULL if vertexCount > 0.
      * @param indices      will point to reserved index space if indexCount is
      *                     non-zero. Illegal to pass NULL if indexCount > 0.
      */
      bool reserveVertexAndIndexSpace(int vertexCount,
+                                     size_t vertexStride,
                                      int indexCount,
                                      void** vertices,
                                      void** indices);
 
     /**
      * Provides hints to caller about the number of vertices and indices
      * that can be allocated cheaply. This can be useful if caller is reserving
      * space but doesn't know exactly how much geometry is needed.
      *
      * Also may hint whether the draw target should be flushed first. This is
      * useful for deferred targets.
      *
      * @param vertexCount  in: hint about how many vertices the caller would
      *                     like to allocate. Vertex size is queried from the
      *                     current GrDrawState.
      *                     out: a hint about the number of vertices that can be
      *                     allocated cheaply. Negative means no hint.
      *                     Ignored if NULL.
      * @param indexCount   in: hint about how many indices the caller would
      *                     like to allocate.
      *                     out: a hint about the number of indices that can be
      *                     allocated cheaply. Negative means no hint.
      *                     Ignored if NULL.
      *
      * @return  true if target should be flushed based on the input values.
      */
-    virtual bool geometryHints(int* vertexCount,
+    virtual bool geometryHints(size_t vertexStride,

[bsalomon, 2014/11/14 21:51:02]

one line?

+                               int* vertexCount,
                                int* indexCount) const;
 
     /**
      * Sets source of vertex data for the next draw. Data does not have to be
      * in the buffer until drawIndexed, drawNonIndexed, or drawIndexedInstances.
      *
      * @param buffer        vertex buffer containing vertex data. Must be
      *                      unlocked before draw call. Vertex size is queried
      *                      from current GrDrawState.
      */
-    void setVertexSourceToBuffer(const GrVertexBuffer* buffer);
+    void setVertexSourceToBuffer(const GrVertexBuffer* buffer, size_t vertexStride);
 
     /**
      * Sets source of index data for the next indexed draw. Data does not have
      * to be in the buffer until drawIndexed.
      *
      * @param buffer index buffer containing indices. Must be unlocked
      *               before indexed draw call.
      */
     void setIndexSourceToBuffer(const GrIndexBuffer* buffer);
 
@@ skipping 41 matching lines @@
      * @param startVertex  the vertex in the vertex array/buffer corresponding
      *                     to index 0
      * @param startIndex   first index to read from index src.
      * @param vertexCount  one greater than the max index.
      * @param indexCount   the number of index elements to read. The index count
      *                     is effectively trimmed to the last completely
      *                     specified primitive.
      * @param devBounds    optional bounds hint. This is a promise from the caller,
      *                     not a request for clipping.
      */
-    void drawIndexed(GrPrimitiveType type,
+    void drawIndexed(GrDrawState*,
+                     GrPrimitiveType type,
                      int startVertex,
                      int startIndex,
                      int vertexCount,
                      int indexCount,
                      const SkRect* devBounds = NULL);
 
     /**
      * Draws non-indexed geometry using the current state and current vertex
      * sources.
      *
      * @param type         The type of primitives to draw.
      * @param startVertex  the vertex in the vertex array/buffer corresponding
      *                     to index 0
      * @param vertexCount  one greater than the max index.
      * @param devBounds    optional bounds hint. This is a promise from the caller,
      *                     not a request for clipping.
      */
-    void drawNonIndexed(GrPrimitiveType type,
+    void drawNonIndexed(GrDrawState*,
+                        GrPrimitiveType type,
                         int startVertex,
                         int vertexCount,
                         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 draw state (if possible in the 3D API).  Note, we will never have an inverse fill
      * with stencil path
      */
-    void stencilPath(const GrPath*, GrPathRendering::FillType fill);
+    void stencilPath(GrDrawState*, const GrPath*, GrPathRendering::FillType fill);
 
     /**
      * Draws a path. Fill must not be a hairline. It will respect the HW
      * antialias flag on the draw state (if possible in the 3D API).
      */
-    void drawPath(const GrPath*, GrPathRendering::FillType fill);
+    void drawPath(GrDrawState*, const GrPath*, GrPathRendering::FillType fill);
 
     /**
      * Draws many paths. It will respect the HW
      * antialias flag on the draw state (if possible in the 3D API).
      *
      * @param pathRange       Source of paths to draw from
      * @param indices         Array of indices into the the pathRange
      * @param count           Number of paths to draw (length of indices array)
      * @param transforms      Array of individual transforms, one for each path
      * @param transformsType  Type of transformations in the array. Array contains
                               PathTransformSize(transformsType) * count elements
      * @param fill            Fill type for drawing all the paths
      */
-    void drawPaths(const GrPathRange* pathRange,
-                   const uint32_t indices[], int count,
-                   const float transforms[], PathTransformType transformsType,
+    void drawPaths(GrDrawState*, const GrPathRange* pathRange,
+                   const uint32_t indices[],
+                   int count,
+                   const float transforms[],
+                   PathTransformType transformsType,
                    GrPathRendering::FillType fill);
 
     /**
      * Helper function for drawing rects. It performs a geometry src push and pop
      * and thus will finalize any reserved geometry.
      *
      * @param rect        the rect to draw
      * @param localRect   optional rect that specifies local coords to map onto
      *                    rect. If NULL then rect serves as the local coords.
      * @param localMatrix optional matrix applied to localRect. If
      *                    srcRect is non-NULL and srcMatrix is non-NULL
      *                    then srcRect will be transformed by srcMatrix.
      *                    srcMatrix can be NULL when no srcMatrix is desired.
      */
-    void drawRect(const SkRect& rect,
+    void drawRect(GrDrawState* ds,
+                  const SkRect& rect,
                   const SkRect* localRect,
                   const SkMatrix* localMatrix) {
         AutoGeometryPush agp(this);
-        this->onDrawRect(rect, localRect, localMatrix);
+        this->onDrawRect(ds, rect, localRect, localMatrix);
     }
 
     /**
      * Helper for drawRect when the caller doesn't need separate local rects or matrices.
      */
-    void drawSimpleRect(const SkRect& rect) {
-        this->drawRect(rect, NULL, NULL);
+    void drawSimpleRect(GrDrawState* ds, const SkRect& rect) {
+        this->drawRect(ds, rect, NULL, NULL);
     }
-    void drawSimpleRect(const SkIRect& irect) {
+    void drawSimpleRect(GrDrawState* ds, const SkIRect& irect) {
         SkRect rect = SkRect::Make(irect);
-        this->drawRect(rect, NULL, NULL);
+        this->drawRect(ds, rect, NULL, NULL);
     }
 
     /**
      * This call is used to draw multiple instances of some geometry with a
      * given number of vertices (V) and indices (I) per-instance. The indices in
      * the index source must have the form i[k+I] == i[k] + V. Also, all indices
      * i[kI] ... i[(k+1)I-1] must be elements of the range kV ... (k+1)V-1. As a
      * concrete example, the following index buffer for drawing a series of
      * quads each as two triangles each satisfies these conditions with V=4 and
      * I=6:
@@ skipping 12 matching lines @@
      *                      consists of verticesPerInstance vertices indexed by
      *                      indicesPerInstance indices drawn as the primitive
      *                      type specified by type.
      * @param verticesPerInstance   The number of vertices in each instance (V
      *                              in the above description).
      * @param indicesPerInstance    The number of indices in each instance (I
      *                              in the above description).
      * @param devBounds    optional bounds hint. This is a promise from the caller,
      *                     not a request for clipping.
      */
-    void drawIndexedInstances(GrPrimitiveType type,
+    void drawIndexedInstances(GrDrawState*,
+                              GrPrimitiveType type,
                               int instanceCount,
                               int verticesPerInstance,
                               int indicesPerInstance,
                               const SkRect* devBounds = NULL);
 
     /**
      * Clear the passed in render target. Ignores the draw state and clip. 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.
      */
-    void clear(const SkIRect* rect, GrColor color, bool canIgnoreRect,
+    void clear(const SkIRect* rect,
+               GrColor color,
+               bool canIgnoreRect,
                GrRenderTarget* renderTarget);
 
     /**
      * Discards the contents render target.
      **/
     virtual void discard(GrRenderTarget*) = 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
@@ skipping 25 matching lines @@
      * true is returned since there is no actual copy necessary to succeed.
      */
     virtual bool copySurface(GrSurface* dst,
                              GrSurface* src,
                              const SkIRect& srcRect,
                              const SkIPoint& dstPoint);
     /**
      * Function that determines whether a copySurface call would succeed without
      * performing the copy.
      */
-    virtual bool canCopySurface(GrSurface* dst,
-                                GrSurface* src,
+    virtual bool canCopySurface(const GrSurface* dst,
+                                const GrSurface* src,
                                 const SkIRect& srcRect,
                                 const SkIPoint& dstPoint);
 
     /**
      * This is can be called before allocating a texture to be a dst for copySurface. It will
      * populate the origin, config, and flags fields of the desc such that copySurface is more
      * likely to succeed and be efficient.
      */
     virtual void initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* desc);
 
 
     /**
      * Release any resources that are cached but not currently in use. This
      * is intended to give an application some recourse when resources are low.
      */
     virtual void purgeResources() {};
 
-    class DrawInfo;
-    /**
-     * For subclass internal use to invoke a call to onDraw(). See DrawInfo below.
-     */
-    void executeDraw(const DrawInfo& info,
-                     const GrClipMaskManager::ScissorState& scissorState) {
-        this->onDraw(info, scissorState);
-    }
-
-    /**
-     * For subclass internal use to invoke a call to onStencilPath().
-     */
-    void executeStencilPath(const GrPath* path,
-                            const GrClipMaskManager::ScissorState& scissorState,
-                            const GrStencilSettings& stencilSettings) {
-        this->onStencilPath(path, scissorState, stencilSettings);
-    }
-
-    /**
-     * For subclass internal use to invoke a call to onDrawPath().
-     */
-    void executeDrawPath(const GrPath* path,
-                         const GrClipMaskManager::ScissorState& scissorState,
-                         const GrStencilSettings& stencilSettings,
-                         const GrDeviceCoordTexture* dstCopy) {
-        this->onDrawPath(path, scissorState, stencilSettings, dstCopy);
-    }
-
-    /**
-     * For subclass internal use to invoke a call to onDrawPaths().
-     */
-    void executeDrawPaths(const GrPathRange* pathRange,
-                          const uint32_t indices[],
-                          int count,
-                          const float transforms[],
-                          PathTransformType transformsType,
-                          const GrClipMaskManager::ScissorState& scissorState,
-                          const GrStencilSettings& stencilSettings,
-                          const GrDeviceCoordTexture* dstCopy) {
-        this->onDrawPaths(pathRange, indices, count, transforms, transformsType,
-                          scissorState, stencilSettings, dstCopy);
-    }
-
-    ////////////////////////////////////////////////////////////////////////////
-
-    /**
-     * See AutoStateRestore below.
-     */
-    enum ASRInit {
-        kPreserve_ASRInit,
-        kReset_ASRInit
-    };
-
-    /**
-     * Saves off the current state and restores it in the destructor. It will
-     * install a new GrDrawState object on the target (setDrawState) and restore
-     * the previous one in the destructor. The caller should call drawState() to
-     * get the new draw state after the ASR is installed.
-     *
-     * GrDrawState* state = target->drawState();
-     * AutoStateRestore asr(target, GrDrawTarget::kReset_ASRInit).
-     * state->setRenderTarget(rt); // state refers to the GrDrawState set on
-     *                             // target before asr was initialized.
-     *                             // Therefore, rt is set on the GrDrawState
-     *                             // that will be restored after asr's
-     *                             // destructor rather than target's current
-     *                             // GrDrawState.
-     */
-    class AutoStateRestore : public ::SkNoncopyable {
-    public:
-        /**
-         * Default ASR will have no effect unless set() is subsequently called.
-         */
-        AutoStateRestore();
-
-        /**
-         * Saves the state on target. The state will be restored when the ASR
-         * is destroyed. If this constructor is used do not call set().
-         *
-         * @param init  Should the newly installed GrDrawState be a copy of the
-         *              previous state or a default-initialized GrDrawState.
-         * @param viewMatrix Optional view matrix. If init = kPreserve then the draw state's
-         *                   matrix will be preconcat'ed with the param. All stages will be
-                             updated to compensate for the matrix change. If init == kReset
-                             then the draw state's matrix will be this matrix.
-         */
-        AutoStateRestore(GrDrawTarget* target, ASRInit init, const SkMatrix* viewMatrix = NULL);
-
-        ~AutoStateRestore();
-
-        /**
-         * Saves the state on target. The state will be restored when the ASR
-         * is destroyed. This should only be called once per ASR object and only
-         * when the default constructor was used. For nested saves use multiple
-         * ASR objects.
-         *
-         * @param init  Should the newly installed GrDrawState be a copy of the
-         *              previous state or a default-initialized GrDrawState.
-         * @param viewMatrix Optional view matrix. If init = kPreserve then the draw state's
-         *                   matrix will be preconcat'ed with the param. All stages will be
-                             updated to compensate for the matrix change. If init == kReset
-                             then the draw state's matrix will be this matrix.
-         */
-        void set(GrDrawTarget* target, ASRInit init, const SkMatrix* viewMatrix = NULL);
-
-        /**
-         * Like set() but makes the view matrix identity. When init is kReset it is as though
-         * NULL was passed to set's viewMatrix param. When init is kPreserve it is as though
-         * the inverse view matrix was passed. If kPreserve is passed and the draw state's matrix
-         * is not invertible then this may fail.
-         */
-        bool setIdentity(GrDrawTarget* target, ASRInit init);
-
-    private:
-        GrDrawTarget*                       fDrawTarget;
-        SkTLazy<GrDrawState>                fTempState;
-        GrDrawState*                        fSavedState;
-    };
-
     ////////////////////////////////////////////////////////////////////////////
 
     class AutoReleaseGeometry : public ::SkNoncopyable {
     public:
         AutoReleaseGeometry(GrDrawTarget*  target,
                             int            vertexCount,
+                            size_t         vertexStride,
                             int            indexCount);
         AutoReleaseGeometry();
         ~AutoReleaseGeometry();
         bool set(GrDrawTarget*  target,
                  int            vertexCount,
+                 size_t         vertexStride,
                  int            indexCount);
         bool succeeded() const { return SkToBool(fTarget); }
         void* vertices() const { SkASSERT(this->succeeded()); return fVertices; }
         void* indices() const { SkASSERT(this->succeeded()); return fIndices; }
         SkPoint* positions() const {
             return static_cast<SkPoint*>(this->vertices());
         }
 
     private:
         void reset();
@@ skipping 25 matching lines @@
     };
 
     ////////////////////////////////////////////////////////////////////////////
 
     /**
      * 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)
-            : fAttribRestore(target->drawState()) {
+        AutoGeometryPush(GrDrawTarget* target) {
             SkASSERT(target);
             fTarget = target;
             target->pushGeometrySource();
         }
 
         ~AutoGeometryPush() { fTarget->popGeometrySource(); }
 
     private:
         GrDrawTarget*                           fTarget;
-        GrDrawState::AutoVertexAttribRestore    fAttribRestore;
-    };
-
-    /**
-     * Combination of AutoGeometryPush and AutoStateRestore. The vertex attribs will be in default
-     * state regardless of ASRInit value.
-     */
-    class AutoGeometryAndStatePush : public ::SkNoncopyable {
-    public:
-        AutoGeometryAndStatePush(GrDrawTarget* target,
-                                 ASRInit init,
-                                 const SkMatrix* viewMatrix = NULL)
-            : fState(target, init, viewMatrix) {
-            SkASSERT(target);
-            fTarget = target;
-            target->pushGeometrySource();
-            if (kPreserve_ASRInit == init) {
-                target->drawState()->setDefaultVertexAttribs();
-            }
-        }
-
-        ~AutoGeometryAndStatePush() { fTarget->popGeometrySource(); }
-
-    private:
-        AutoStateRestore fState;
-        GrDrawTarget*    fTarget;
     };
 
     ///////////////////////////////////////////////////////////////////////////
     // Draw execution tracking (for font atlases and other resources)
     class DrawToken {
     public:
         DrawToken(GrDrawTarget* drawTarget, uint32_t drawID) :
                   fDrawTarget(drawTarget), fDrawID(drawID) {}
 
         bool isIssued() { return fDrawTarget && fDrawTarget->isIssued(fDrawID); }
@@ skipping 141 matching lines @@
     }
 
     // Subclass must initialize this in its constructor.
     SkAutoTUnref<const GrDrawTargetCaps> fCaps;
 
     const GrTraceMarkerSet& getActiveTraceMarkers() { return fActiveTraceMarkers; }
 
     // Makes a copy of the dst if it is necessary for the draw. Returns false if a copy is required
     // 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(DrawInfo* info) {
-        return this->setupDstReadIfNecessary(&info->fDstCopy, info->getDevBounds());
+    bool setupDstReadIfNecessary(GrDrawState* ds, DrawInfo* info) {
+        return this->setupDstReadIfNecessary(ds, &info->fDstCopy, info->getDevBounds());
     }
-    bool setupDstReadIfNecessary(GrDeviceCoordTexture* dstCopy, const SkRect* drawBounds);
+    bool setupDstReadIfNecessary(GrDrawState*,
+                                 GrDeviceCoordTexture* dstCopy,
+                                 const SkRect* drawBounds);
 
 private:
     // A subclass can optionally overload this function to be notified before
     // vertex and index space is reserved.
-    virtual void willReserveVertexAndIndexSpace(int vertexCount, int indexCount) {}
+    virtual void willReserveVertexAndIndexSpace(int vertexCount,
+                                                size_t vertexStride,
+                                                int indexCount) {}
 
     // implemented by subclass to allocate space for reserved geom
     virtual bool onReserveVertexSpace(size_t vertexSize, int vertexCount, void** vertices) = 0;
     virtual bool onReserveIndexSpace(int indexCount, void** indices) = 0;
     // implemented by subclass to handle release of reserved geom space
     virtual void releaseReservedVertexSpace() = 0;
     virtual void releaseReservedIndexSpace() = 0;
     // subclass overrides to be notified just before geo src state is pushed/popped.
     virtual void geometrySourceWillPush() = 0;
     virtual void geometrySourceWillPop(const GeometrySrcState& restoredState) = 0;
     // subclass called to perform drawing
-    virtual void onDraw(const DrawInfo&, const GrClipMaskManager::ScissorState&) = 0;
+    virtual void onDraw(const GrDrawState&,
+                        const DrawInfo&,
+                        const GrClipMaskManager::ScissorState&) = 0;
     // TODO copy in order drawbuffer onDrawRect to here
-    virtual void onDrawRect(const SkRect& rect,
+    virtual void onDrawRect(GrDrawState*,
+                            const SkRect& rect,
                             const SkRect* localRect,
                             const SkMatrix* localMatrix) = 0;
 
-    virtual void onStencilPath(const GrPath*,
+    virtual void onStencilPath(const GrDrawState&,
+                               const GrPath*,
                                const GrClipMaskManager::ScissorState&,
                                const GrStencilSettings&) = 0;
-    virtual void onDrawPath(const GrPath*,
+    virtual void onDrawPath(const GrDrawState&,
+                            const GrPath*,
                             const GrClipMaskManager::ScissorState&,
                             const GrStencilSettings&,
                             const GrDeviceCoordTexture* dstCopy) = 0;
-    virtual void onDrawPaths(const GrPathRange*,
+    virtual void onDrawPaths(const GrDrawState&,
+                             const GrPathRange*,
                              const uint32_t indices[],
                              int count,
                              const float transforms[],
                              PathTransformType,
                              const GrClipMaskManager::ScissorState&,
                              const GrStencilSettings&,
                              const GrDeviceCoordTexture*) = 0;
 
     virtual void onClear(const SkIRect* rect, GrColor color, bool canIgnoreRect,
                          GrRenderTarget* renderTarget) = 0;
 
 
     // helpers for reserving vertex and index space.
     bool reserveVertexSpace(size_t vertexSize,
                             int vertexCount,
                             void** vertices);
     bool reserveIndexSpace(int indexCount, void** indices);
 
     // called by drawIndexed and drawNonIndexed. Use a negative indexCount to
     // indicate non-indexed drawing.
-    bool checkDraw(GrPrimitiveType type, int startVertex,
-                   int startIndex, int vertexCount,
+    bool checkDraw(const GrDrawState&,
+                   GrPrimitiveType type,
+                   int startVertex,
+                   int startIndex,
+                   int vertexCount,
                    int indexCount) const;
     // called when setting a new vert/idx source to unref prev vb/ib
     void releasePreviousVertexSource();
     void releasePreviousIndexSource();
 
     // Check to see if this set of draw commands has been sent out
     virtual bool       isIssued(uint32_t drawID) { return true; }
-    void getPathStencilSettingsForFilltype(GrPathRendering::FillType, GrStencilSettings*);
+    void getPathStencilSettingsForFilltype(GrPathRendering::FillType,
+                                           const GrStencilBuffer*,
+                                           GrStencilSettings*);
     virtual GrClipMaskManager* clipMaskManager() = 0;
     virtual bool setupClip(const SkRect* devBounds,
                            GrDrawState::AutoRestoreEffects* are,
                            GrDrawState::AutoRestoreStencil* ars,
+                           GrDrawState*,
                            GrClipMaskManager::ScissorState* scissorState) = 0;
 
     enum {
         kPreallocGeoSrcStateStackCnt = 4,
     };
     SkSTArray<kPreallocGeoSrcStateStackCnt, GeometrySrcState, true> fGeoSrcStateStack;
     const GrClipData*                                               fClip;
-    GrDrawState*                                                    fDrawState;
-    GrDrawState                                                     fDefaultDrawState;
     // 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 32 matching lines @@
 
 protected:
     GrClipMaskManager           fClipMaskManager;
 
 private:
     GrClipMaskManager* clipMaskManager() { return &fClipMaskManager; }
 
     virtual bool setupClip(const SkRect* devBounds,
                            GrDrawState::AutoRestoreEffects* are,
                            GrDrawState::AutoRestoreStencil* ars,
+                           GrDrawState*,
                            GrClipMaskManager::ScissorState* scissorState) SK_OVERRIDE;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif