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

include/gpu/GrXferProcessor.h

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrXferProcessor_DEFINED
 #define GrXferProcessor_DEFINED
 
 #include "GrBlend.h"
 #include "GrColor.h"
 #include "GrProcessor.h"
 #include "GrTexture.h"
 #include "GrTypes.h"
 #include "SkXfermode.h"
 
 class GrShaderCaps;
 class GrGLSLCaps;
 class GrGLXferProcessor;
 class GrProcOptInfo;
 
 /**
  * Barriers for blending. When a shader reads the dst directly, an Xfer barrier is sometimes
  * required after a pixel has been written, before it can be safely read again.
  */
 enum GrXferBarrierType {
-    kTexture_GrXferBarrierType, //<! Required when a shader reads and renders to the same texture.
-    kBlend_GrXferBarrierType,   //<! Required by certain blend extensions.
+    kNone_GrXferBarrierType = 0, //<! No barrier is required
+    kTexture_GrXferBarrierType,  //<! Required when a shader reads and renders to the same texture.
+    kBlend_GrXferBarrierType,    //<! Required by certain blend extensions.
 };
+/** Should be able to treat kNone as false in boolean expressions */
+GR_STATIC_ASSERT(SkToBool(kNone_GrXferBarrierType) == false);
 
 /**
  * GrXferProcessor is responsible for implementing the xfer mode that blends the src color and dst
  * color, and for applying any coverage. It does this by emitting fragment shader code and
  * controlling the fixed-function blend state. When dual-source blending is available, it may also
  * write a seconday fragment shader output color. GrXferProcessor has two modes of operation:
  *
  * Dst read: When allowed by the backend API, or when supplied a texture of the destination, the
  * GrXferProcessor may read the destination color. While operating in this mode, the subclass only
  * provides shader code that blends the src and dst colors, and the base class applies coverage.
@@ skipping 100 matching lines @@
     OptFlags getOptimizations(const GrProcOptInfo& colorPOI,
                               const GrProcOptInfo& coveragePOI,
                               bool doesStencilWrite,
                               GrColor* overrideColor,
                               const GrCaps& caps);
 
     /**
      * Returns whether this XP will require an Xfer barrier on the given rt. If true, outBarrierType
      * is updated to contain the type of barrier needed.
      */
-    bool willNeedXferBarrier(const GrRenderTarget* rt,
-                             const GrCaps& caps,
-                             GrXferBarrierType* outBarrierType) const;
+    GrXferBarrierType xferBarrierType(const GrRenderTarget* rt, const GrCaps& caps) const;
 
     struct BlendInfo {
         void reset() {
             fEquation = kAdd_GrBlendEquation;
             fSrcBlend = kOne_GrBlendCoeff;
             fDstBlend = kZero_GrBlendCoeff;
             fBlendConstant = 0;
             fWriteColor = true;
         }
 
@@ skipping 85 matching lines @@
                                         const GrCaps& caps) = 0;
 
     /**
      * Sets a unique key on the GrProcessorKeyBuilder that is directly associated with this xfer
      * processor's GL backend implementation.
      */
     virtual void onGetGLProcessorKey(const GrGLSLCaps& caps,
                                      GrProcessorKeyBuilder* b) const = 0;
 
     /**
-     * If not using a texture barrier, retrieves whether the subclass will require a different type
-     * of barrier.
+     * Determines the type of barrier (if any) required by the subclass. Note that the possibility
+     * that a kTexture type barrier is required is handled by the base class and need not be
+     * considered by subclass overrides of this function.
      */
-    virtual bool onWillNeedXferBarrier(const GrRenderTarget*,
-                                       const GrCaps&,
-                                       GrXferBarrierType* outBarrierType SK_UNUSED) const {
-        return false;
+    virtual GrXferBarrierType onXferBarrier(const GrRenderTarget*, const GrCaps&) const {
+        return kNone_GrXferBarrierType;
     }
 
     /**
      * If we are not performing a dst read, returns whether the subclass will set a secondary
      * output. When using dst reads, the base class controls the secondary output and this method
      * will not be called.
      */
     virtual bool onHasSecondaryOutput() const { return false; }
 
     /**
@@ skipping 122 matching lines @@
     enum {
         kIllegalXPFClassID = 0,
     };
     static int32_t gCurrXPFClassID;
 
     typedef GrProgramElement INHERITED;
 };
 
 #endif