Add support for reading the dst pixel value in an effect. Use in a new effect for the kDarken xfer …

include/gpu/GrEffect.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef GrEffect_DEFINED
 #define GrEffect_DEFINED
 
@@ skipping 120 matching lines @@
 
     int numTextures() const { return fTextureAccesses.count(); }
 
     /** Returns the access pattern for the texture at index. index must be valid according to
         numTextures(). */
     const GrTextureAccess& textureAccess(int index) const { return *fTextureAccesses[index]; }
 
     /** Shortcut for textureAccess(index).texture(); */
     GrTexture* texture(int index) const { return this->textureAccess(index).getTexture(); }
 
+    /** Will this effect read the destination pixel value? */
+    bool willReadDst() const { return fWillReadDst; }
 
     int numVertexAttribs() const { return fVertexAttribTypes.count(); }
 
     GrSLType vertexAttribType(int index) const { return fVertexAttribTypes[index]; }
 
     static const int kMaxVertexAttribs = 2;
 
-
     /** Useful for effects that want to insert a texture matrix that is implied by the texture
         dimensions */
     static inline SkMatrix MakeDivByTextureWHMatrix(const GrTexture* texture) {
         GrAssert(NULL != texture);
         SkMatrix mat;
         mat.setIDiv(texture->width(), texture->height());
         return mat;
     }
 
     void* operator new(size_t size);
@@ skipping 25 matching lines @@
      */
     void addTextureAccess(const GrTextureAccess* textureAccess);
 
     /**
      * Subclasses call this from their constructor to register vertex attributes (at most
      * kMaxVertexAttribs). This must only be called from the constructor because GrEffects are
      * immutable.
      */
     void addVertexAttrib(GrSLType type);
 
-    GrEffect() : fEffectRef(NULL) {};
+    GrEffect() : fWillReadDst(false), fEffectRef(NULL) {}
 
     /** This should be called by GrEffect subclass factories. See the comment on AutoEffectUnref for
         an example factory function. */
     static GrEffectRef* CreateEffectRef(GrEffect* effect) {
         if (NULL == effect->fEffectRef) {
             effect->fEffectRef = SkNEW_ARGS(GrEffectRef, (effect));
         } else {
             effect->fEffectRef->ref();
         }
         return effect->fEffectRef;
@@ skipping 22 matching lines @@
         GrEffect* fEffect;
     };
 
     /** Helper for getting the GrEffect out of a GrEffectRef and down-casting to a GrEffect subclass
       */
     template <typename T>
     static const T& CastEffect(const GrEffect& effectRef) {
         return *static_cast<const T*>(&effectRef);
     }
 
+    /**
+     * If the effect subclass will read the destination pixel value then it must call this function
+     * from its constructor. Otherwise, when its generated backend-specific effect class attempts
+     * to generate code that reads the destination pixel it will fail.
+     */
+    void setWillReadDst() { fWillReadDst = true; }
+
 private:
     bool isEqual(const GrEffect& other) const {
         if (&this->getFactory() != &other.getFactory()) {
             return false;
         }
         bool result = this->onIsEqual(other);
 #if GR_DEBUG
         if (result) {
             GrAssert(this->numTextures() == other.numTextures());
             for (int i = 0; i < this->numTextures(); ++i) {
@@ skipping 11 matching lines @@
 
     void EffectRefDestroyed() { fEffectRef = NULL; }
 
     friend class GrEffectRef;   // to call EffectRefDestroyed()
     friend class GrEffectStage; // to rewrap GrEffect in GrEffectRef when restoring an effect-stage
                                 // from deferred state, to call isEqual on naked GrEffects, and
                                 // to inc/dec deferred ref counts.
 
     SkSTArray<4, const GrTextureAccess*, true>   fTextureAccesses;
     SkSTArray<kMaxVertexAttribs, GrSLType, true> fVertexAttribTypes;
+    bool                                         fWillReadDst;
     GrEffectRef*                                 fEffectRef;
 
     typedef GrRefCnt INHERITED;
 };
 
 inline GrEffectRef::GrEffectRef(GrEffect* effect) {
     GrAssert(NULL != effect);
     effect->ref();
     fEffect = effect;
 }
 
 #endif