Revert of Move DstCopy on gpu into the GrXferProcessor.

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 "GrColor.h"
 #include "GrProcessor.h"
-#include "GrTexture.h"
 #include "GrTypes.h"
 #include "SkXfermode.h"
 
 class GrDrawTargetCaps;
 class GrGLCaps;
 class GrGLXferProcessor;
 class GrProcOptInfo;
 
 /**
  * GrXferProcessor is responsible for implementing the xfer mode that blends the src color and dst
  * color. It does this by emitting fragment shader code and controlling the fixed-function blend
  * state. The inputs to its shader code are the final computed src color and fractional pixel
  * coverage. The GrXferProcessor's shader code writes the fragment shader output color that goes
  * into the fixed-function blend. When dual-source blending is available, it may also write a
  * seconday fragment shader output color. When allowed by the backend API, the GrXferProcessor may
  * read the destination color. The GrXferProcessor is responsible for setting the blend coefficients
  * and blend constant color.
  *
  * A GrXferProcessor is never installed directly into our draw state, but instead is created from a
  * GrXPFactory once we have finalized the state of our draw.
  */
 class GrXferProcessor : public GrProcessor {
 public:
     /**
-     * Sets a unique key on the GrProcessorKeyBuilder calls onGetGLProcessorKey(...) to get the
-     * specific subclass's key.
-     */ 
-    void getGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const;
+     * Sets a unique key on the GrProcessorKeyBuilder that is directly associated with this xfer
+     * processor's GL backend implementation.
+     */
+    virtual void getGLProcessorKey(const GrGLCaps& caps,
+                                   GrProcessorKeyBuilder* b) const = 0;
 
     /** Returns a new instance of the appropriate *GL* implementation class
         for the given GrXferProcessor; caller is responsible for deleting
         the object. */
     virtual GrGLXferProcessor* createGLInstance() const = 0;
 
     /**
      * Optimizations for blending / coverage that an OptDrawState should apply to itself.
      */
     enum OptFlags {
@@ skipping 44 matching lines @@
         BlendInfo() : fWriteColor(true) {}
 
         GrBlendCoeff fSrcBlend;
         GrBlendCoeff fDstBlend;
         GrColor      fBlendConstant;
         bool         fWriteColor;
     };
 
     virtual void getBlendInfo(BlendInfo* blendInfo) const = 0;
 
+    /** Will this prceossor read the destination pixel value? */
     bool willReadDstColor() const { return fWillReadDstColor; }
 
-    /**
-     * Returns the texture to be used as the destination when reading the dst in the fragment
-     * shader. If the returned texture is NULL then the XP is either not reading the dst or we have
-     * extentions that support framebuffer fetching and thus don't need a copy of the dst texture.
-     */
-    const GrTexture* getDstCopyTexture() const { return fDstCopy.getTexture(); }
-
-    /**
-     * Returns the offset into the DstCopyTexture to use when reading it in the shader. This value
-     * is only valid if getDstCopyTexture() != NULL.
-     */
-    const SkIPoint& dstCopyTextureOffset() const {
-        SkASSERT(this->getDstCopyTexture());
-        return fDstCopyTextureOffset;
-    }
-
     /** 
      * Returns whether or not this xferProcossor will set a secondary output to be used with dual
      * source blending.
      */
     virtual bool hasSecondaryOutput() const { return false; }
 
     /** Returns true if this and other processor conservatively draw identically. It can only return
         true when the two processor are of the same subclass (i.e. they return the same object from
         from getFactory()).
 
         A return value of true from isEqual() should not be used to test whether the processor would
         generate the same shader code. To test for identical code generation use getGLProcessorKey*/
     
     bool isEqual(const GrXferProcessor& that) const {
         if (this->classID() != that.classID()) {
             return false;
         }
-        if (this->fWillReadDstColor != that.fWillReadDstColor) {
-            return false;
-        }
-        if (this->fDstCopy.getTexture() != that.fDstCopy.getTexture()) {
-            return false;
-        }
-        if (this->fDstCopyTextureOffset != that.fDstCopyTextureOffset) {
-            return false;
-        }
         return this->onIsEqual(that);
     }
    
 protected:
-    GrXferProcessor();
-    GrXferProcessor(const GrDeviceCoordTexture* dstCopy, bool willReadDstColor);
+    GrXferProcessor() : fWillReadDstColor(false) {}
+
+    /**
+     * If the prceossor subclass will read the destination pixel value then it must call this
+     * function from its constructor. Otherwise, when its generated backend-specific prceossor class
+     * attempts to generate code that reads the destination pixel it will fail.
+     */
+    void setWillReadDstColor() { fWillReadDstColor = true; }
 
 private:
-    /**
-     * Sets a unique key on the GrProcessorKeyBuilder that is directly associated with this xfer
-     * processor's GL backend implementation.
-     */
-    virtual void onGetGLProcessorKey(const GrGLCaps& caps,
-                                     GrProcessorKeyBuilder* b) const = 0;
-
     virtual bool onIsEqual(const GrXferProcessor&) const = 0;
 
-    bool                    fWillReadDstColor;
-    SkIPoint                fDstCopyTextureOffset;
-    GrTextureAccess         fDstCopy;
+    bool         fWillReadDstColor;
 
     typedef GrFragmentProcessor INHERITED;
 };
 
 GR_MAKE_BITFIELD_OPS(GrXferProcessor::OptFlags);
 
-///////////////////////////////////////////////////////////////////////////////
-
 /**
  * We install a GrXPFactory (XPF) early on in the pipeline before all the final draw information is
  * known (e.g. whether there is fractional pixel coverage, will coverage be 1 or 4 channel, is the
  * draw opaque, etc.). Once the state of the draw is finalized, we use the XPF along with all the
  * draw information to create a GrXferProcessor (XP) which can implement the desired blending for
  * the draw.
  *
  * Before the XP is created, the XPF is able to answer queries about what functionality the XPs it
  * creates will have. For example, can it create an XP that supports RGB coverage or will the XP
  * blend with the destination color.
  */
 class GrXPFactory : public SkRefCnt {
 public:
-    GrXferProcessor* createXferProcessor(const GrProcOptInfo& colorPOI,
-                                         const GrProcOptInfo& coveragePOI,
-                                         const GrDeviceCoordTexture* dstCopy,
-                                         const GrDrawTargetCaps& caps) const;
+    virtual GrXferProcessor* createXferProcessor(const GrProcOptInfo& colorPOI,
+                                                 const GrProcOptInfo& coveragePOI) const = 0;
 
     /**
      * This function returns true if the GrXferProcessor generated from this factory will be able to
      * correctly blend when using RGB coverage. The knownColor and knownColorFlags represent the
      * final computed color from the color stages.
      */
     virtual bool supportsRGBCoverage(GrColor knownColor, uint32_t knownColorFlags) const = 0;
 
     /**
      * Depending on color blend mode requested it may or may not be possible to correctly blend with
@@ skipping 21 matching lines @@
     virtual void getInvariantOutput(const GrProcOptInfo& colorPOI, const GrProcOptInfo& coveragePOI,
                                     InvariantOutput*) const = 0;
 
     /**
      * Determines whether multiplying the computed per-pixel color by the pixel's fractional
      * coverage before the blend will give the correct final destination color. In general it
      * will not as coverage is applied after blending.
      */
     virtual bool canTweakAlphaForCoverage() const = 0;
 
-    bool willNeedDstCopy(const GrDrawTargetCaps& caps) const; 
+    /**
+     *  Returns true if the XP generated by this factory will read dst.
+     */
+    virtual bool willReadDst() const = 0;
 
     bool isEqual(const GrXPFactory& that) const {
         if (this->classID() != that.classID()) {
             return false;
         }
         return this->onIsEqual(that);
     }
 
     /**
       * Helper for down-casting to a GrXPFactory subclass
       */
     template <typename T> const T& cast() const { return *static_cast<const T*>(this); }
 
     uint32_t classID() const { SkASSERT(kIllegalXPFClassID != fClassID); return fClassID; }
 
 protected:
     GrXPFactory() : fClassID(kIllegalXPFClassID) {}
 
     template <typename XPF_SUBCLASS> void initClassID() {
          static uint32_t kClassID = GenClassID();
          fClassID = kClassID;
     }
 
     uint32_t fClassID;
 
 private:
-    virtual GrXferProcessor* onCreateXferProcessor(const GrProcOptInfo& colorPOI,
-                                                   const GrProcOptInfo& coveragePOI,
-                                                   const GrDeviceCoordTexture* dstCopy) const = 0;
-    /**
-     *  Returns true if the XP generated by this factory will explicitly read dst in the fragment
-     *  shader.
-     */
-    virtual bool willReadDstColor() const = 0;
-
     virtual bool onIsEqual(const GrXPFactory&) const = 0;
 
     static uint32_t GenClassID() {
         // fCurrXPFactoryID has been initialized to kIllegalXPFactoryID. The
         // atomic inc returns the old value not the incremented value. So we add
         // 1 to the returned value.
         uint32_t id = static_cast<uint32_t>(sk_atomic_inc(&gCurrXPFClassID)) + 1;
         if (!id) {
             SkFAIL("This should never wrap as it should only be called once for each GrXPFactory "
                    "subclass.");
         }
         return id;
     }
 
     enum {
         kIllegalXPFClassID = 0,
     };
     static int32_t gCurrXPFClassID;
 
     typedef GrProgramElement INHERITED;
 };
 
 #endif