rename GrDrawTargetCaps to GrCaps

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 149 matching lines @@
      * its state to reflected the given blend optimizations. If the XP needs to see a specific input
      * color to blend correctly, it will set the OverrideColor flag and the output parameter
      * overrideColor will be the required value that should be passed into the XP. 
      * A caller who calls this function on a XP is required to honor the returned OptFlags
      * and color values for its draw.
      */
     OptFlags getOptimizations(const GrProcOptInfo& colorPOI,
                               const GrProcOptInfo& coveragePOI,
                               bool doesStencilWrite,
                               GrColor* overrideColor,
-                              const GrDrawTargetCaps& caps);
+                              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 GrDrawTargetCaps& caps,
+                             const GrCaps& caps,
                              GrXferBarrierType* outBarrierType) const;
 
     struct BlendInfo {
         void reset() {
             fEquation = kAdd_GrBlendEquation;
             fSrcBlend = kOne_GrBlendCoeff;
             fDstBlend = kZero_GrBlendCoeff;
             fBlendConstant = 0;
             fWriteColor = true;
         }
@@ skipping 69 matching lines @@
    
 protected:
     GrXferProcessor();
     GrXferProcessor(const GrDeviceCoordTexture* dstCopy, bool willReadDstColor);
 
 private:
     virtual OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
                                         const GrProcOptInfo& coveragePOI,
                                         bool doesStencilWrite,
                                         GrColor* overrideColor,
-                                        const GrDrawTargetCaps& caps) = 0;
+                                        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.
      */
     virtual bool onWillNeedXferBarrier(const GrRenderTarget*,
-                                       const GrDrawTargetCaps&,
+                                       const GrCaps&,
                                        GrXferBarrierType* outBarrierType SK_UNUSED) const {
         return false;
     }
 
     /**
      * 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 {}
@@ skipping 21 matching lines @@
  *
  * 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;
+                                         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 willNeedDstCopy(const GrDrawTargetCaps& caps, const GrProcOptInfo& colorPOI,
+    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 GrDrawTargetCaps& caps,
+    virtual GrXferProcessor* onCreateXferProcessor(const GrCaps& caps,
                                                    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 GrDrawTargetCaps& caps,
+    virtual bool willReadDstColor(const GrCaps& caps,
                                   const GrProcOptInfo& colorPOI,
                                   const GrProcOptInfo& coveragePOI) 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