Revert of Move DstCoordTexture to GrXP, rename and remove the word "copy" from dstcopytexture names.

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
 
@@ skipping 86 matching lines @@
  * 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:
     /**
-     * A texture that contains the dst pixel values and an integer coord offset from device space
-     * to the space of the texture. Depending on GPU capabilities a DstTexture may be used by a
-     * GrXferProcessor for blending in the fragment shader.
-     */
-    class DstTexture {
-    public:
-        DstTexture() { fOffset.set(0, 0); }
-
-        DstTexture(const DstTexture& other) {
-            *this = other;
-        }
-
-        DstTexture(GrTexture* texture, const SkIPoint& offset)
-            : fTexture(SkSafeRef(texture))
-            , fOffset(offset) {
-        }
-
-        DstTexture& operator=(const DstTexture& other) {
-            fTexture.reset(SkSafeRef(other.fTexture.get()));
-            fOffset = other.fOffset;
-            return *this;
-        }
-
-        const SkIPoint& offset() const { return fOffset; }
-
-        void setOffset(const SkIPoint& offset) { fOffset = offset; }
-        void setOffset(int ox, int oy) { fOffset.set(ox, oy); }
-
-        GrTexture* texture() const { return fTexture.get(); }
-
-        GrTexture* setTexture(GrTexture* texture) {
-            fTexture.reset(SkSafeRef(texture));
-            return texture;
-        }
-
-    private:
-        SkAutoTUnref<GrTexture> fTexture;
-        SkIPoint                fOffset;
-    };
-
-    /**
      * Sets a unique key on the GrProcessorKeyBuilder calls onGetGLProcessorKey(...) to get the
      * specific subclass's key.
      */ 
     void getGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const;
 
     /** 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;
 
@@ skipping 75 matching lines @@
         this->onGetBlendInfo(blendInfo);
     }
 
     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* getDstTexture() const { return fDstTexture.getTexture(); }
+    const GrTexture* getDstCopyTexture() const { return fDstCopy.getTexture(); }
 
     /**
-     * Returns the offset in device coords to use when accessing the dst texture to get the dst
-     * pixel color in the shader. This value is only valid if getDstTexture() != NULL.
+     * Returns the offset into the DstCopyTexture to use when reading it in the shader. This value
+     * is only valid if getDstCopyTexture() != NULL.
      */
-    const SkIPoint& dstTextureOffset() const {
-        SkASSERT(this->getDstTexture());
-        return fDstTextureOffset;
+    const SkIPoint& dstCopyTextureOffset() const {
+        SkASSERT(this->getDstCopyTexture());
+        return fDstCopyTextureOffset;
     }
 
     /**
      * Returns whether or not the XP will look at coverage when doing its blending.
      */
     bool readsCoverage() const { return fReadsCoverage; }
 
     /** 
      * Returns whether or not this xferProcossor will set a secondary output to be used with dual
      * source blending.
@@ skipping 10 matching lines @@
     bool isEqual(const GrXferProcessor& that) const {
         if (this->classID() != that.classID()) {
             return false;
         }
         if (this->fWillReadDstColor != that.fWillReadDstColor) {
             return false;
         }
         if (this->fReadsCoverage != that.fReadsCoverage) {
             return false;
         }
-        if (this->fDstTexture.getTexture() != that.fDstTexture.getTexture()) {
+        if (this->fDstCopy.getTexture() != that.fDstCopy.getTexture()) {
             return false;
         }
-        if (this->fDstTextureOffset != that.fDstTextureOffset) {
+        if (this->fDstCopyTextureOffset != that.fDstCopyTextureOffset) {
             return false;
         }
         return this->onIsEqual(that);
     }
    
 protected:
     GrXferProcessor();
-    GrXferProcessor(const DstTexture*, bool willReadDstColor);
+    GrXferProcessor(const GrDeviceCoordTexture* dstCopy, bool willReadDstColor);
 
 private:
     virtual OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
                                         const GrProcOptInfo& coveragePOI,
                                         bool doesStencilWrite,
                                         GrColor* overrideColor,
                                         const GrCaps& caps) = 0;
 
     /**
      * Sets a unique key on the GrProcessorKeyBuilder that is directly associated with this xfer
@@ skipping 16 matching lines @@
      * Retrieves the hardware blend state required by this Xfer processor. The BlendInfo struct
      * comes initialized to default values, so the Xfer processor only needs to set the state it
      * needs. It may not even need to override this method at all.
      */
     virtual void onGetBlendInfo(BlendInfo*) const {}
 
     virtual bool onIsEqual(const GrXferProcessor&) const = 0;
 
     bool                    fWillReadDstColor;
     bool                    fReadsCoverage;
-    SkIPoint                fDstTextureOffset;
-    GrTextureAccess         fDstTexture;
+    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
  * 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:
-    typedef GrXferProcessor::DstTexture DstTexture;
     GrXferProcessor* createXferProcessor(const GrProcOptInfo& colorPOI,
                                          const GrProcOptInfo& coveragePOI,
-                                         const DstTexture*,
+                                         const GrDeviceCoordTexture* dstCopy,
                                          const GrCaps& caps) const;
 
     /**
      * 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;
 
     struct InvariantOutput {
         bool        fWillBlendWithDst;
         GrColor     fBlendedColor;
         uint32_t    fBlendedColorFlags;
     };
 
     /** 
      * This function returns known information about the output of the xfer processor produced by
      * this xp factory. The invariant color information returned by this function refers to the
      * final color produced after all blending.
      */
     virtual void getInvariantOutput(const GrProcOptInfo& colorPOI, const GrProcOptInfo& coveragePOI,
                                     InvariantOutput*) const = 0;
 
-    bool willNeedDstTexture(const GrCaps& caps, const GrProcOptInfo& colorPOI,
-                            const GrProcOptInfo& coveragePOI) const;
+    bool willNeedDstCopy(const GrCaps& caps, const GrProcOptInfo& colorPOI,
+                         const GrProcOptInfo& coveragePOI) const;
 
     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 GrCaps& caps,
                                                    const GrProcOptInfo& colorPOI,
                                                    const GrProcOptInfo& coveragePOI,
-                                                   const DstTexture*) const = 0;
+                                                   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 GrCaps& caps,
                                   const GrProcOptInfo& colorPOI,
                                   const GrProcOptInfo& coveragePOI) const = 0;
 
     virtual bool onIsEqual(const GrXPFactory&) const = 0;
 
@@ skipping 12 matching lines @@
     enum {
         kIllegalXPFClassID = 0,
     };
     static int32_t gCurrXPFClassID;
 
     typedef GrProgramElement INHERITED;
 };
 
 #endif