Make GrBatch carry its own GrPipeline

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 "GrClip.h"
 #include "GrClipMaskManager.h"
 #include "GrContext.h"
 #include "GrPathProcessor.h"
 #include "GrPrimitiveProcessor.h"
 #include "GrIndexBuffer.h"
 #include "GrPathRendering.h"
 #include "GrPipelineBuilder.h"
+#include "GrPipeline.h"
 #include "GrTraceMarker.h"
 #include "GrVertexBuffer.h"
 #include "GrXferProcessor.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 GrClip;
 class GrCaps;
 class GrPath;
 class GrPathRange;
-class GrPipeline;
 
 class GrDrawTarget : public SkRefCnt {
 public:
     
 
     typedef GrPathRange::PathIndexType PathIndexType;
     typedef GrPathRendering::PathTransformType PathTransformType;
 
     ///////////////////////////////////////////////////////////////////////////
 
@@ skipping 146 matching lines @@
                      const SkIRect& srcRect,
                      const SkIPoint& dstPoint);
     /**
      * 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() {};
 
     bool programUnitTest(GrContext* owner, int maxStages);
 
+    struct PipelineInfo {
+        PipelineInfo(const GrPipelineBuilder* pipelineBuilder, const GrScissorState* scissor,
+                     const GrPrimitiveProcessor* primProc,
+                     const SkRect* devBounds, GrDrawTarget* target);
+
+        PipelineInfo(const GrPipelineBuilder* pipelineBuilder, const GrScissorState* scissor,
+                     const GrBatch* batch, const SkRect* devBounds,
+                     GrDrawTarget* target);
+
+        bool valid() const { return SkToBool(fArgs.fPipelineBuilder); }
+
+        const GrPipeline::CreateArgs& pipelineCreateArgs() const {
+            SkASSERT(this->valid());
+            return fArgs;
+        }
+
+        bool willColorBlendWithDst(const GrPrimitiveProcessor* primProc) const {
+            SkASSERT(this->valid());
+            return fArgs.fPipelineBuilder->willColorBlendWithDst(primProc);
+        }
+    private:
+        GrPipeline::CreateArgs      fArgs;
+    };
+
 protected:
-    friend class GrCommandBuilder; // for PipelineInfo
-    friend class GrInOrderCommandBuilder; // for PipelineInfo
-    friend class GrReorderCommandBuilder; // for PipelineInfo
-    friend class GrTargetCommands; // for PipelineInfo
 
     GrGpu* getGpu() { return fGpu; }
     const GrGpu* getGpu() const { return fGpu; }
 
     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,
                                  GrXferProcessor::DstTexture*,
                                  const SkRect* drawBounds);
 
-    struct PipelineInfo {
-        PipelineInfo(const GrPipelineBuilder& pipelineBuilder, GrScissorState* scissor,
-                     const GrPrimitiveProcessor* primProc,
-                     const SkRect* devBounds, GrDrawTarget* target);
-
-        PipelineInfo(const GrPipelineBuilder& pipelineBuilder, GrScissorState* scissor,
-                     const GrBatch* batch, const SkRect* devBounds,
-                     GrDrawTarget* target);
-
-        bool willColorBlendWithDst(const GrPrimitiveProcessor* primProc) const {
-            return fPipelineBuilder->willColorBlendWithDst(primProc);
-        }
-    private:
-        friend class GrDrawTarget;
-
-        bool mustSkipDraw() const { return (NULL == fPipelineBuilder); }
-
-        const GrPipelineBuilder*    fPipelineBuilder;
-        GrScissorState*             fScissor;
-        GrProcOptInfo               fColorPOI;
-        GrProcOptInfo               fCoveragePOI;
-        GrXferProcessor::DstTexture fDstTexture;
-    };
-
-    const GrPipeline* setupPipeline(const PipelineInfo&, void* pipelineAddr,
-                                    GrPipelineOptimizations*);
-
 private:
     virtual void onReset() = 0;
 
     virtual void onFlush() = 0;
 
-    virtual void onDrawBatch(GrBatch*, const PipelineInfo&) = 0;
+    virtual void onDrawBatch(GrBatch*) = 0;
     virtual void onStencilPath(const GrPipelineBuilder&,
                                const GrPathProcessor*,
                                const GrPath*,
                                const GrScissorState&,
                                const GrStencilSettings&) = 0;
     virtual void onDrawPath(const GrPathProcessor*,
                             const GrPath*,
                             const GrStencilSettings&,
                             const PipelineInfo&) = 0;
     virtual void onDrawPaths(const GrPathProcessor*,
@@ skipping 76 matching lines @@
     bool setupClip(const GrPipelineBuilder&,
                    GrPipelineBuilder::AutoRestoreFragmentProcessorState*,
                    GrPipelineBuilder::AutoRestoreStencil*,
                    GrScissorState* scissorState,
                    const SkRect* devBounds) override;
 
     typedef GrDrawTarget INHERITED;
 };
 
 #endif