Move DstCopy on gpu into the GrXferProcessor.

include/gpu/GrXferProcessor.h

Index: include/gpu/GrXferProcessor.h
diff --git a/include/gpu/GrXferProcessor.h b/include/gpu/GrXferProcessor.h
index 13e4d2633ff30045b816db20b999744953a20ee7..03d52a93d748f776b6733df8dc1d0a2e2fdb3467 100644
--- a/include/gpu/GrXferProcessor.h
+++ b/include/gpu/GrXferProcessor.h
@@ -10,6 +10,7 @@
 
 #include "GrColor.h"
 #include "GrProcessor.h"
+#include "GrTexture.h"
 #include "GrTypes.h"
 #include "SkXfermode.h"
 
@@ -34,11 +35,10 @@ class GrProcOptInfo;
 class GrXferProcessor : public GrProcessor {
 public:
     /**
-     * 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;
+     * Sets a unique key on the GrProcessorKeyBuilder calls onGetGLProcessorKey(...) to get the
+     * specific subclass's key.
+     */ 
+    void getGLProcessorKey(const GrGLCaps& caps, GrProcessorKeyBuilder* b) const;
 
     /** Returns a new instance of the appropriate *GL* implementation class
         for the given GrXferProcessor; caller is responsible for deleting
@@ -103,9 +103,24 @@ public:
 
     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.
@@ -123,29 +138,43 @@ public:
         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() : fWillReadDstColor(false) {}
+    GrXferProcessor();
+    GrXferProcessor(const GrDeviceCoordTexture* dstCopy, bool willReadDstColor);
 
+private:
     /**
-     * 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.
+     * Sets a unique key on the GrProcessorKeyBuilder that is directly associated with this xfer
+     * processor's GL backend implementation.
      */
-    void setWillReadDstColor() { fWillReadDstColor = true; }
+    virtual void onGetGLProcessorKey(const GrGLCaps& caps,
+                                     GrProcessorKeyBuilder* b) const = 0;
 
-private:
     virtual bool onIsEqual(const GrXferProcessor&) const = 0;
 
-    bool         fWillReadDstColor;
+    bool                    fWillReadDstColor;
+    SkIPoint                fDstCopyTextureOffset;
+    GrTextureAccess         fDstCopy;
 
     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
@@ -159,8 +188,10 @@ GR_MAKE_BITFIELD_OPS(GrXferProcessor::OptFlags);
  */
 class GrXPFactory : public SkRefCnt {
 public:
-    virtual GrXferProcessor* createXferProcessor(const GrProcOptInfo& colorPOI,
-                                                 const GrProcOptInfo& coveragePOI) const = 0;
+    GrXferProcessor* createXferProcessor(const GrProcOptInfo& colorPOI,
+                                         const GrProcOptInfo& coveragePOI,
+                                         const GrDeviceCoordTexture* dstCopy,
+                                         const GrDrawTargetCaps& caps) const;
 
     /**
      * This function returns true if the GrXferProcessor generated from this factory will be able to
@@ -202,10 +233,7 @@ public:
      */
     virtual bool canTweakAlphaForCoverage() const = 0;
 
-    /**
-     *  Returns true if the XP generated by this factory will read dst.
-     */
-    virtual bool willReadDst() const = 0;
+    bool willNeedDstCopy(const GrDrawTargetCaps& caps) const; 
 
     bool isEqual(const GrXPFactory& that) const {
         if (this->classID() != that.classID()) {
@@ -232,6 +260,15 @@ protected:
     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() {