Stop creating GrODS for stencilPath commands.

src/gpu/GrInOrderDrawBuffer.h

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrInOrderDrawBuffer_DEFINED
 #define GrInOrderDrawBuffer_DEFINED
 
@@ skipping 33 matching lines @@
     // tracking for draws
     DrawToken getCurrentDrawToken() SK_OVERRIDE { return DrawToken(this, fDrawID); }
 
     void clearStencilClip(const SkIRect& rect,
                           bool insideClip,
                           GrRenderTarget* renderTarget) SK_OVERRIDE;
 
     void discard(GrRenderTarget*) SK_OVERRIDE;
 
 private:
-    typedef GrClipMaskManager::ScissorState ScissorState;
     enum {
         kDraw_Cmd           = 1,
         kStencilPath_Cmd    = 2,
         kSetState_Cmd       = 3,
         kClear_Cmd          = 4,
         kCopySurface_Cmd    = 5,
         kDrawPath_Cmd       = 6,
         kDrawPaths_Cmd      = 7,
     };
 
     struct Cmd : ::SkNoncopyable {
         Cmd(uint8_t type) : fType(type) {}
         virtual ~Cmd() {}
 
         virtual void execute(GrInOrderDrawBuffer*, const GrOptDrawState*) = 0;
 
         uint8_t fType;
     };
 
     struct Draw : public Cmd {
         Draw(const DrawInfo& info) : Cmd(kDraw_Cmd), fInfo(info) {}
 
         void execute(GrInOrderDrawBuffer*, const GrOptDrawState*) SK_OVERRIDE;
 
         DrawInfo     fInfo;
     };
 
     struct StencilPath : public Cmd {
-        StencilPath(const GrPath* path) : Cmd(kStencilPath_Cmd), fPath(path) {}
+        StencilPath(const GrPath* path, GrRenderTarget* rt)
+            : Cmd(kStencilPath_Cmd)
+            , fRenderTarget(rt)
+            , fPath(path) {}
 
         const GrPath* path() const { return fPath.get(); }
 
         void execute(GrInOrderDrawBuffer*, const GrOptDrawState*) SK_OVERRIDE;
 
-        GrStencilSettings fStencilSettings;
-
+        SkMatrix                                                fViewMatrix;
+        bool                                                    fUseHWAA;
+        GrStencilSettings                                       fStencil;
+        GrScissorState                                          fScissor;
     private:
-        GrPendingIOResource<const GrPath, kRead_GrIOType>   fPath;
+        GrPendingIOResource<GrRenderTarget, kWrite_GrIOType>    fRenderTarget;
+        GrPendingIOResource<const GrPath, kRead_GrIOType>       fPath;
     };
 
     struct DrawPath : public Cmd {
         DrawPath(const GrPath* path) : Cmd(kDrawPath_Cmd), fPath(path) {}
 
         const GrPath* path() const { return fPath.get(); }
 
         void execute(GrInOrderDrawBuffer*, const GrOptDrawState*) SK_OVERRIDE;
 
         GrStencilSettings       fStencilSettings;
@@ skipping 63 matching lines @@
         SkIRect     fSrcRect;
 
     private:
         GrPendingIOResource<GrSurface, kWrite_GrIOType> fDst;
         GrPendingIOResource<GrSurface, kRead_GrIOType> fSrc;
     };
 
     struct SetState : public Cmd {
         SetState(const GrDrawState& drawState, const GrGeometryProcessor* gp,
                  const GrPathProcessor* pp, const GrDrawTargetCaps& caps,
-                 const ScissorState& scissor, const GrDeviceCoordTexture* dstCopy,
+                 const GrScissorState& scissor, const GrDeviceCoordTexture* dstCopy,
                  GrGpu::DrawType drawType)
         : Cmd(kSetState_Cmd)
         , fState(drawState, gp, pp, caps, scissor, dstCopy, drawType) {}
 
         void execute(GrInOrderDrawBuffer*, const GrOptDrawState*) SK_OVERRIDE;
 
         GrOptDrawState          fState;
     };
 
     typedef void* TCmdAlign; // This wouldn't be enough align if a command used long double.
     typedef GrTRecorder<Cmd, TCmdAlign> CmdBuffer;
 
     void onReset() SK_OVERRIDE;
     void onFlush() SK_OVERRIDE;
 
     // overrides from GrDrawTarget
     void onDraw(const GrDrawState&,
                 const GrGeometryProcessor*,
                 const DrawInfo&,
-                const ScissorState&,
+                const GrScissorState&,
                 const GrDeviceCoordTexture* dstCopy) SK_OVERRIDE;
     void onDrawRect(GrDrawState*,
                     GrColor,
                     const SkRect& rect,
                     const SkRect* localRect,
                     const SkMatrix* localMatrix) SK_OVERRIDE;
 
     void onStencilPath(const GrDrawState&,
                        const GrPathProcessor*,
                        const GrPath*,
-                       const ScissorState&,
+                       const GrScissorState&,
                        const GrStencilSettings&) SK_OVERRIDE;
     void onDrawPath(const GrDrawState&,
                     const GrPathProcessor*,
                     const GrPath*,
-                    const ScissorState&,
+                    const GrScissorState&,
                     const GrStencilSettings&,
                     const GrDeviceCoordTexture* dstCopy) SK_OVERRIDE;
     void onDrawPaths(const GrDrawState&,
                      const GrPathProcessor*,
                      const GrPathRange*,
                      const void* indices,
                      PathIndexType,
                      const float transformValues[],
                      PathTransformType,
                      int count,
-                     const ScissorState&,
+                     const GrScissorState&,
                      const GrStencilSettings&,
                      const GrDeviceCoordTexture*) SK_OVERRIDE;
     void onClear(const SkIRect* rect,
                  GrColor color,
                  bool canIgnoreRect,
                  GrRenderTarget* renderTarget) SK_OVERRIDE;
     bool onCopySurface(GrSurface* dst,
                        GrSurface* src,
                        const SkIRect& srcRect,
                        const SkIPoint& dstPoint) SK_OVERRIDE;
 
     // Attempts to concat instances from info onto the previous draw. info must represent an
     // instanced draw. The caller must have already recorded a new draw state and clip if necessary.
     int concatInstancedDraw(const GrDrawState&, const DrawInfo&);
 
     // Determines whether the current draw operation requires a new GrOptDrawState and if so
     // records it. If the draw can be skipped false is returned and no new GrOptDrawState is
     // recorded.
     bool SK_WARN_UNUSED_RESULT recordStateAndShouldDraw(const GrDrawState&,
                                                         const GrGeometryProcessor*,
                                                         const GrPathProcessor*,
                                                         GrGpu::DrawType,
-                                                        const GrClipMaskManager::ScissorState&,
+                                                        const GrScissorState&,
                                                         const GrDeviceCoordTexture*);
     // We lazily record clip changes in order to skip clips that have no effect.
     void recordClipIfNecessary();
     // Records any trace markers for a command after adding it to the buffer.
     void recordTraceMarkersIfNecessary();
 
     virtual bool isIssued(uint32_t drawID) SK_OVERRIDE { return drawID != fDrawID; }
 
     // TODO: Use a single allocator for commands and records
     enum {
         kCmdBufferInitialSizeInBytes = 8 * 1024,
         kPathIdxBufferMinReserve     = 2 * 64,  // 64 uint16_t's
         kPathXformBufferMinReserve   = 2 * 64,  // 64 two-float transforms
     };
 
     CmdBuffer                           fCmdBuffer;
     GrOptDrawState*                     fPrevState;
     SkTArray<GrTraceMarkerSet, false>   fGpuCmdMarkers;
     SkTDArray<char>                     fPathIndexBuffer;
     SkTDArray<float>                    fPathTransformBuffer;
     uint32_t                            fDrawID;
 
     typedef GrFlushToGpuDrawTarget INHERITED;
 };
 
 #endif