Create GrCommandBuilder

src/gpu/GrTargetCommands.h

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrTargetCommands_DEFINED
 #define GrTargetCommands_DEFINED
 
 #include "GrBatch.h"
 #include "GrBatchTarget.h"
 #include "GrDrawTarget.h"
 #include "GrGpu.h"
 #include "GrPath.h"
 #include "GrPendingProgramElement.h"
 #include "GrRenderTarget.h"
 #include "GrTRecorder.h"
 #include "SkRect.h"
 #include "SkTypes.h"
 
 class GrInOrderDrawBuffer;
 class GrVertexBufferAllocPool;
 class GrIndexBufferAllocPool;
 
 class GrTargetCommands : ::SkNoncopyable {
-    struct State;
-    struct SetState;
-
 public:
     GrTargetCommands(GrGpu* gpu,
                      GrVertexBufferAllocPool* vertexPool,
                      GrIndexBufferAllocPool* indexPool)
         : fCmdBuffer(kCmdBufferInitialSizeInBytes)
         , fBatchTarget(gpu, vertexPool, indexPool) {
     }
 
     class Cmd : ::SkNoncopyable {
     public:
@@ skipping 21 matching lines @@
         int markerID() const { return fMarkerID; }
 
     private:
         int              fMarkerID;
         CmdType          fType;
     };
 
     void reset();
     void flush(GrInOrderDrawBuffer*);
 
-    Cmd* recordClearStencilClip(const SkIRect& rect,
-                                bool insideClip,
-                                GrRenderTarget* renderTarget);
-
-    Cmd* recordDiscard(GrRenderTarget*);
-    Cmd* recordDrawBatch(State*, GrBatch*);
-    Cmd* recordStencilPath(const GrPipelineBuilder&,
-                           const GrPathProcessor*,
-                           const GrPath*,
-                           const GrScissorState&,
-                           const GrStencilSettings&);
-    Cmd* recordDrawPath(State*,
-                        const GrPathProcessor*,
-                        const GrPath*,
-                        const GrStencilSettings&);
-    Cmd* recordDrawPaths(State*,
-                         GrInOrderDrawBuffer*,
-                         const GrPathProcessor*,
-                         const GrPathRange*,
-                         const void*,
-                         GrDrawTarget::PathIndexType,
-                         const float transformValues[],
-                         GrDrawTarget::PathTransformType ,
-                         int,
-                         const GrStencilSettings&,
-                         const GrDrawTarget::PipelineInfo&);
-    Cmd* recordClear(const SkIRect* rect,
-                     GrColor,
-                     bool canIgnoreRect,
-                     GrRenderTarget*);
-    Cmd* recordCopySurface(GrSurface* dst,
-                           GrSurface* src,
-                           const SkIRect& srcRect,
-                           const SkIPoint& dstPoint);
-
 private:
-    friend class GrInOrderDrawBuffer;
+    friend class GrCommandBuilder;
+    friend class GrInOrderDrawBuffer; // This goes away when State becomes just a pipeline
 
     typedef GrGpu::DrawArgs DrawArgs;
 
     void recordXferBarrierIfNecessary(const GrPipeline&, GrInOrderDrawBuffer*);
 
     // TODO: This can be just a pipeline once paths are in batch, and it should live elsewhere
     struct State : public SkNVRefCnt<State> {
         // TODO get rid of the prim proc parameter when we use batch everywhere
         State(const GrPrimitiveProcessor* primProc = NULL)
             : fPrimitiveProcessor(primProc)
@@ skipping 168 matching lines @@
         void execute(GrGpu*) override;
 
         GrXferBarrierType   fBarrierType;
     };
 
     static const int kCmdBufferInitialSizeInBytes = 8 * 1024;
 
     typedef void* TCmdAlign; // This wouldn't be enough align if a command used long double.
     typedef GrTRecorder<Cmd, TCmdAlign> CmdBuffer;
 
+    CmdBuffer* cmdBuffer() { return &fCmdBuffer; }
+    GrBatchTarget* batchTarget() { return &fBatchTarget; }
+
     CmdBuffer                           fCmdBuffer;
     GrBatchTarget                       fBatchTarget;
 };
 
 #endif