Use texture barriers to read directly from the RT

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
 
@@ skipping 38 matching lines @@
     public:
         enum CmdType {
             kDraw_CmdType              = 1,
             kStencilPath_CmdType       = 2,
             kSetState_CmdType          = 3,
             kClear_CmdType             = 4,
             kCopySurface_CmdType       = 5,
             kDrawPath_CmdType          = 6,
             kDrawPaths_CmdType         = 7,
             kDrawBatch_CmdType         = 8,
+            kXferBarrier_CmdType       = 9,
         };
 
         Cmd(CmdType type) : fMarkerID(-1), fType(type) {}
         virtual ~Cmd() {}
 
         virtual void execute(GrGpu*, const SetState*) = 0;
 
         CmdType type() const { return fType; }
 
         // trace markers
@@ skipping 75 matching lines @@
     // instanced draw. The caller must have already recorded a new draw state and clip if necessary.
     int concatInstancedDraw(GrInOrderDrawBuffer*, const GrDrawTarget::DrawInfo&);
 
     bool SK_WARN_UNUSED_RESULT setupPipelineAndShouldDraw(GrInOrderDrawBuffer*,
                                                           const GrPrimitiveProcessor*,
                                                           const GrDrawTarget::PipelineInfo&);
     bool SK_WARN_UNUSED_RESULT setupPipelineAndShouldDraw(GrInOrderDrawBuffer*,
                                                           GrBatch*,
                                                           const GrDrawTarget::PipelineInfo&);
 
+    void recordXferBarrierIfNecessary(GrInOrderDrawBuffer*, const GrDrawTarget::PipelineInfo&);
+
     struct Draw : public Cmd {
         Draw(const GrDrawTarget::DrawInfo& info) : Cmd(kDraw_CmdType), fInfo(info) {}
 
         void execute(GrGpu*, const SetState*) override;
 
         GrDrawTarget::DrawInfo     fInfo;
     };
 
     struct StencilPath : public Cmd {
         StencilPath(const GrPath* path, GrRenderTarget* rt)
@@ skipping 105 matching lines @@
 
         ~SetState() { reinterpret_cast<GrPipeline*>(fPipeline.get())->~GrPipeline(); }
 
         // This function is only for getting the location in memory where we will create our
         // pipeline object.
         GrPipeline* pipelineLocation() { return reinterpret_cast<GrPipeline*>(fPipeline.get()); }
 
         const GrPipeline* getPipeline() const {
             return reinterpret_cast<const GrPipeline*>(fPipeline.get());
         }
+        GrRenderTarget* getRenderTarget() const {
+            return this->getPipeline()->getRenderTarget();
+        }
+        const GrXferProcessor* getXferProcessor() const {
+            return this->getPipeline()->getXferProcessor();
+        }
 
         void execute(GrGpu*, const SetState*) override;
 
         typedef GrPendingProgramElement<const GrPrimitiveProcessor> ProgramPrimitiveProcessor;
         ProgramPrimitiveProcessor               fPrimitiveProcessor;
         SkAlignedSStorage<sizeof(GrPipeline)>   fPipeline;
         GrProgramDesc                           fDesc;
         GrBatchTracker                          fBatchTracker;
     };
 
     struct DrawBatch : public Cmd {
         DrawBatch(GrBatch* batch, GrBatchTarget* batchTarget) 
             : Cmd(kDrawBatch_CmdType)
             , fBatch(SkRef(batch))
             , fBatchTarget(batchTarget) {
             SkASSERT(!batch->isUsed());
         }
 
         void execute(GrGpu*, const SetState*) override;
 
         // TODO it wouldn't be too hard to let batches allocate in the cmd buffer
         SkAutoTUnref<GrBatch>  fBatch;
 
     private:
         GrBatchTarget*         fBatchTarget;
     };
 
+    struct XferBarrier : public Cmd {
+        XferBarrier() : Cmd(kXferBarrier_CmdType) {}
+
+        void execute(GrGpu*, const SetState*) 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                           fCmdBuffer;
      SetState*                           fPrevState;
      GrBatchTarget                       fBatchTarget;
      // TODO hack until batch is everywhere
      GrTargetCommands::DrawBatch*        fDrawBatch;
 
      // This will go away when everything uses batch.  However, in the short term anything which
      // might be put into the GrInOrderDrawBuffer needs to make sure it closes the last batch
      void closeBatch();
 };
 
 #endif