Check for xfer barriers in GrBatch, auto-issue barriers in GrGpu

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 "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"
 
 #include "batches/GrBatch.h"
 
 class GrBufferedDrawTarget;
 
-// TODO: Convert all commands into GrBatch and remove this class. Xferbarrier will just become a
-// batch blocker (when there is overlap) and the xp is responsible for issuing any barrier calls
-// on the backend.
+// TODO: Convert all commands into GrBatch and remove this class.
 class GrTargetCommands : ::SkNoncopyable {
 public:
     GrTargetCommands(GrGpu* gpu)
         : fCmdBuffer(kCmdBufferInitialSizeInBytes)
         , fBatchTarget(gpu) {
     }
 
     class Cmd : ::SkNoncopyable {
     public:
         enum CmdType {
             kStencilPath_CmdType       = 1,
             kClear_CmdType             = 2,
             kClearStencil_CmdType      = 3,
             kCopySurface_CmdType       = 4,
             kDrawPath_CmdType          = 5,
             kDrawPaths_CmdType         = 6,
             kDrawBatch_CmdType         = 7,
-            kXferBarrier_CmdType       = 8,
         };
 
         Cmd(CmdType type)
             : fType(type)
 #if GR_BATCH_SPEW
             , fUniqueID(GenID(&gUniqueID))
 #endif
         {}
         virtual ~Cmd() {}
 
@@ skipping 20 matching lines @@
     void reset();
     void flush(GrBufferedDrawTarget*);
 
 private:
     friend class GrCommandBuilder;
     friend class GrBufferedDrawTarget; // This goes away when State becomes just a pipeline
     friend class GrReorderCommandBuilder;
 
     typedef GrGpu::DrawArgs DrawArgs;
 
-    void recordXferBarrierIfNecessary(const GrPipeline&, GrBufferedDrawTarget*);
-
     // TODO: This can be just a pipeline once paths are in batch, and it should live elsewhere
     struct StateForPathDraw : public SkNVRefCnt<StateForPathDraw> {
         // TODO get rid of the prim proc parameter when we use batch everywhere
         StateForPathDraw(const GrPrimitiveProcessor* primProc = NULL)
             : fPrimitiveProcessor(primProc)
             , fCompiled(false) {}
 
         ~StateForPathDraw() { reinterpret_cast<GrPipeline*>(fPipeline.get())->~GrPipeline(); }
 
         // This function is only for getting the location in memory where we will create our
@@ skipping 146 matching lines @@
             SkASSERT(!batch->isUsed());
         }
 
         GrBatch* batch() { return fBatch; }
         void execute(GrGpu*) override;
     private:
         SkAutoTUnref<GrBatch>  fBatch;
         GrBatchTarget*         fBatchTarget;
     };
 
-    struct XferBarrier : public Cmd {
-        XferBarrier(GrRenderTarget* rt)
-            : Cmd(kXferBarrier_CmdType)
-            , fRenderTarget(rt) {
-        }
-
-        void execute(GrGpu*) override;
-
-        GrXferBarrierType   fBarrierType;
-
-    private:
-        GrPendingIOResource<GrRenderTarget, kWrite_GrIOType> fRenderTarget;
-    };
-
     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