Move GrBatchFlushState from GrDrawTarget to GrDrawingManager

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 "GrBatchFlushState.h"
 #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 "GrVertexBuffer.h"
@@ skipping 15 matching lines @@
 
 class GrBatch;
 class GrClip;
 class GrCaps;
 class GrPath;
 class GrDrawPathBatchBase;
 class GrPathRangeDraw;
 
 class GrDrawTarget final : public SkRefCnt {
 public:
-    struct Options {
-        bool fImmediateMode;
-    };
-
     // The context may not be fully constructed and should not be used during GrDrawTarget
     // construction.
-    GrDrawTarget(GrRenderTarget* rt, GrGpu* gpu, GrResourceProvider*, const Options& options);
+    GrDrawTarget(GrRenderTarget* rt, GrGpu* gpu, GrResourceProvider*);
 
     ~GrDrawTarget() override;
 
     void makeClosed() {
         // We only close drawTargets When MDB is enabled. When MDB is disabled there is only
         // ever one drawTarget and all calls will be funnelled into it.
 #ifdef ENABLE_MDB
         this->setFlag(kClosed_Flag);
 #endif
     }
@@ skipping 19 matching lines @@
      * Dump out the drawTarget dependency DAG
      */
     SkDEBUGCODE(void dump() const;)
 
     /**
      * Empties the draw buffer of any queued up draws.
      */
     void reset();
 
     /**
-     * This plays any queued up draws to its GrGpu target. It also resets this object (i.e. flushing
-     * is destructive).
+     * Together these two functions flush all queued up draws to the Gpu.
      */
-    void flush();
+    void prepareBatches(GrBatchFlushState* flushState);
+    void drawBatches(GrBatchFlushState* flushState);
 
     /**
      * Gets the capabilities of the draw target.
      */
     const GrCaps* caps() const { return fGpu->caps(); }
 
     void drawBatch(const GrPipelineBuilder&, GrDrawBatch*);
 
     /**
      * Draws path into the stencil buffer. The fill must be either even/odd or
@@ skipping 96 matching lines @@
      * src bounds then  pixel values in the dst rect corresponding to area clipped
      * by the src rect are not overwritten. This method is not guaranteed to succeed
      * depending on the type of surface, configs, etc, and the backend-specific
      * limitations.
      */
     void copySurface(GrSurface* dst,
                      GrSurface* src,
                      const SkIRect& srcRect,
                      const SkIPoint& dstPoint);
 
-    bool programUnitTest(GrContext* owner, int maxStages);
-
     /** Provides access to internal functions to GrClipMaskManager without friending all of
         GrDrawTarget to CMM. */
     class CMMAccess {
     public:
         CMMAccess(GrDrawTarget* drawTarget) : fDrawTarget(drawTarget) {}
     private:
         void clearStencilClip(const SkIRect& rect, bool insideClip, GrRenderTarget* rt) const {
             fDrawTarget->clearStencilClip(rect, insideClip, rt);
         }
 
@@ skipping 79 matching lines @@
 
     // Used only by CMM.
     void clearStencilClip(const SkIRect&, bool insideClip, GrRenderTarget*);
 
     SkSTArray<256, SkAutoTUnref<GrBatch>, true> fBatches;
     SkAutoTDelete<GrClipMaskManager>            fClipMaskManager;
     // The context is only in service of the clip mask manager, remove once CMM doesn't need this.
     GrContext*                                  fContext;
     GrGpu*                                      fGpu;
     GrResourceProvider*                         fResourceProvider;
-    GrBatchFlushState                           fFlushState;
     bool                                        fFlushing;
 
     SkDEBUGCODE(int                             fDebugID;)
     uint32_t                                    fFlags;
-    Options                                     fOptions;
 
     // 'this' drawTarget relies on the output of the drawTargets in 'fDependencies'
     SkTDArray<GrDrawTarget*>                    fDependencies;
     GrRenderTarget*                             fRenderTarget;
 
     typedef SkRefCnt INHERITED;
 };
 
 #endif