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 29 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,
+            kBlendBarrier_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 54 matching lines @@
     Cmd* recordClear(GrInOrderDrawBuffer*,
                      const SkIRect* rect,
                      GrColor,
                      bool canIgnoreRect,
                      GrRenderTarget*);
     Cmd* recordCopySurface(GrInOrderDrawBuffer*,
                            GrSurface* dst,
                            GrSurface* src,
                            const SkIRect& srcRect,
                            const SkIPoint& dstPoint);
+    Cmd* recordBlendBarrier(GrInOrderDrawBuffer*);
 
 protected:
     void willReserveVertexAndIndexSpace(int vertexCount,
                                         size_t vertexStride,
                                         int indexCount);
 
 private:
     friend class GrInOrderDrawBuffer;
 
     typedef GrGpu::DrawArgs DrawArgs;
@@ skipping 154 matching lines @@
 
         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 BlendBarrier : public Cmd {
+        BlendBarrier() : Cmd(kBlendBarrier_CmdType) {}
+        void execute(GrGpu*, const SetState*) override;
+    };
+
      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