Pass in ProcOptInfos into willNeedDstCopy on XPs

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 13 matching lines @@
 #include "SkTArray.h"
 #include "SkTLazy.h"
 #include "SkTypes.h"
 #include "SkXfermode.h"
 
 class GrBatch;
 class GrClipData;
 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;
 
     ///////////////////////////////////////////////////////////////////////////
 
@@ skipping 627 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(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);
+
+        PipelineInfo(GrPipelineBuilder* pipelineBuilder, GrScissorState* scissor,
+                     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;
+        GrScissorState*         fScissor;
+        GrProcOptInfo           fColorPOI; 
+        GrProcOptInfo           fCoveragePOI; 
+        GrDeviceCoordTexture    fDstCopy;
+    };
+
+    void setupPipeline(const PipelineInfo& pipelineInfo, GrPipeline* pipeline);
+
 private:
     /**
      * This will be called before allocating a texture as a dst for copySurface. This function
      * populates the dstDesc's config, flags, and origin so as to maximize efficiency and guarantee
      * success of the copySurface call.
      */
     void initCopySurfaceDstDesc(const GrSurface* src, GrSurfaceDesc* dstDesc) {
         if (!this->onInitCopySurfaceDstDesc(src, dstDesc)) {
             dstDesc->fOrigin = kDefault_GrSurfaceOrigin;
             dstDesc->fFlags = kRenderTarget_GrSurfaceFlag | kNoStencil_GrSurfaceFlag;
@@ skipping 16 matching lines @@
     // 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 GrPipelineBuilder&,
-                        const GrGeometryProcessor*,
-                        const DrawInfo&,
-                        const GrScissorState&) = 0;
-    virtual void onDrawBatch(GrBatch*,
-                             const GrPipelineBuilder&,
-                             const GrScissorState&,
-                             const SkRect* devBounds) = 0;
+    virtual void onDraw(const GrGeometryProcessor*, const DrawInfo&, const PipelineInfo&) = 0;
+    virtual void onDrawBatch(GrBatch*, const PipelineInfo&) = 0;
     // TODO copy in order drawbuffer onDrawRect to here
     virtual void onDrawRect(GrPipelineBuilder*,
                             GrColor color,
                             const SkMatrix& viewMatrix,
                             const SkRect& rect,
                             const SkRect* localRect,
                             const SkMatrix* localMatrix) = 0;
 
     virtual void onStencilPath(const GrPipelineBuilder&,
                                const GrPathProcessor*,
                                const GrPath*,
                                const GrScissorState&,
                                const GrStencilSettings&) = 0;
-    virtual void onDrawPath(const GrPipelineBuilder&,
-                            const GrPathProcessor*,
+    virtual void onDrawPath(const GrPathProcessor*,
                             const GrPath*,
-                            const GrScissorState&,
                             const GrStencilSettings&,
-                            const SkRect* devBounds) = 0;
-    virtual void onDrawPaths(const GrPipelineBuilder&,
-                             const GrPathProcessor*,
+                            const PipelineInfo&) = 0;
+    virtual void onDrawPaths(const GrPathProcessor*,
                              const GrPathRange*,
                              const void* indices,
                              PathIndexType,
                              const float transformValues[],
                              PathTransformType,
                              int count,
-                             const GrScissorState&,
                              const GrStencilSettings&,
-                             const SkRect* devBounds) = 0;
+                             const PipelineInfo&) = 0;
 
     virtual void onClear(const SkIRect* rect, GrColor color, bool canIgnoreRect,
                          GrRenderTarget* renderTarget) = 0;
 
     /** The subclass will get a chance to copy the surface for falling back to the default
         implementation, which simply draws a rectangle (and fails if dst isn't a render target). It
         should assume that any clipping has already been performed on the rect and point. It won't
         be called if the copy can be skipped. */
     virtual bool onCopySurface(GrSurface* dst,
                                GrSurface* src,
@@ skipping 103 matching lines @@
     virtual bool setupClip(GrPipelineBuilder*,
                            GrPipelineBuilder::AutoRestoreEffects* are,
                            GrPipelineBuilder::AutoRestoreStencil* ars,
                            GrScissorState* scissorState,
                            const SkRect* devBounds) SK_OVERRIDE;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif