rename GrDrawTargetCaps to GrCaps

src/gpu/effects/GrPorterDuffXferProcessor.cpp

 /*
  * Copyright 2014 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "effects/GrPorterDuffXferProcessor.h"
 
 #include "GrBlend.h"
@@ skipping 77 matching lines @@
     GrBlendCoeff getDstBlend() const { return fDstBlend; }
 
 private:
     PorterDuffXferProcessor(GrBlendCoeff srcBlend, GrBlendCoeff dstBlend, GrColor constant,
                             const GrDeviceCoordTexture* dstCopy, bool willReadDstColor);
 
     GrXferProcessor::OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
                                                  const GrProcOptInfo& coveragePOI,
                                                  bool doesStencilWrite,
                                                  GrColor* overrideColor,
-                                                 const GrDrawTargetCaps& caps) override;
+                                                 const GrCaps& caps) override;
 
     void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
 
     void onGetBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const override {
         if (!this->willReadDstColor()) {
             blendInfo->fSrcBlend = fSrcBlend;
             blendInfo->fDstBlend = fDstBlend;
         } else {
             blendInfo->fSrcBlend = kOne_GrBlendCoeff;
             blendInfo->fDstBlend = kZero_GrBlendCoeff;
@@ skipping 10 matching lines @@
             fSecondaryOutputType != xp.fSecondaryOutputType) {
             return false;
         }
         return true;
     }
 
     GrXferProcessor::OptFlags internalGetOptimizations(const GrProcOptInfo& colorPOI,
                                                        const GrProcOptInfo& coveragePOI,
                                                        bool doesStencilWrite);
 
-    void calcOutputTypes(GrXferProcessor::OptFlags blendOpts, const GrDrawTargetCaps& caps,
+    void calcOutputTypes(GrXferProcessor::OptFlags blendOpts, const GrCaps& caps,
                          bool hasSolidCoverage);
 
     GrBlendCoeff fSrcBlend;
     GrBlendCoeff fDstBlend;
     GrColor      fBlendConstant;
     PrimaryOutputType fPrimaryOutputType;
     SecondaryOutputType fSecondaryOutputType;
 
     typedef GrXferProcessor INHERITED;
 };
@@ skipping 158 matching lines @@
 
 GrGLXferProcessor* PorterDuffXferProcessor::createGLInstance() const {
     return SkNEW_ARGS(GLPorterDuffXferProcessor, (*this));
 }
 
 GrXferProcessor::OptFlags
 PorterDuffXferProcessor::onGetOptimizations(const GrProcOptInfo& colorPOI,
                                             const GrProcOptInfo& coveragePOI,
                                             bool doesStencilWrite,
                                             GrColor* overrideColor,
-                                            const GrDrawTargetCaps& caps) {
+                                            const GrCaps& caps) {
     GrXferProcessor::OptFlags optFlags = this->internalGetOptimizations(colorPOI,
                                                                         coveragePOI,
                                                                         doesStencilWrite);
     this->calcOutputTypes(optFlags, caps, coveragePOI.isSolidWhite());
     return optFlags;
 }
 
 void PorterDuffXferProcessor::calcOutputTypes(GrXferProcessor::OptFlags optFlags,
-                                              const GrDrawTargetCaps& caps,
+                                              const GrCaps& caps,
                                               bool hasSolidCoverage) {
     if (this->willReadDstColor()) {
         fPrimaryOutputType = kCustom_PrimaryOutputType;
         return;
     }
 
     if (optFlags & kIgnoreColor_OptFlag) {
         if (optFlags & kIgnoreCoverage_OptFlag) {
             fPrimaryOutputType = kNone_PrimaryOutputType;
             return;
@@ skipping 149 matching lines @@
 
     bool hasSecondaryOutput() const override { return false; }
 
 private:
     PDLCDXferProcessor(GrColor blendConstant, uint8_t alpha);
 
     GrXferProcessor::OptFlags onGetOptimizations(const GrProcOptInfo& colorPOI,
                                                  const GrProcOptInfo& coveragePOI,
                                                  bool doesStencilWrite,
                                                  GrColor* overrideColor,
-                                                 const GrDrawTargetCaps& caps) override;
+                                                 const GrCaps& caps) override;
 
     void onGetGLProcessorKey(const GrGLSLCaps& caps, GrProcessorKeyBuilder* b) const override;
 
     void onGetBlendInfo(GrXferProcessor::BlendInfo* blendInfo) const override {
         blendInfo->fSrcBlend = kConstC_GrBlendCoeff;
         blendInfo->fDstBlend = kISC_GrBlendCoeff;
         blendInfo->fBlendConstant = fBlendConstant;
     }
 
     bool onIsEqual(const GrXferProcessor& xpBase) const override {
@@ skipping 70 matching lines @@
 
 GrGLXferProcessor* PDLCDXferProcessor::createGLInstance() const {
     return SkNEW_ARGS(GLPDLCDXferProcessor, (*this));
 }
 
 GrXferProcessor::OptFlags
 PDLCDXferProcessor::onGetOptimizations(const GrProcOptInfo& colorPOI,
                                        const GrProcOptInfo& coveragePOI,
                                        bool doesStencilWrite,
                                        GrColor* overrideColor,
-                                       const GrDrawTargetCaps& caps) {
+                                       const GrCaps& caps) {
         // We want to force our primary output to be alpha * Coverage, where alpha is the alpha
         // value of the blend the constant. We should already have valid blend coeff's if we are at
         // a point where we have RGB coverage. We don't need any color stages since the known color
         // output is already baked into the blendConstant.
         *overrideColor = GrColorPackRGBA(fAlpha, fAlpha, fAlpha, fAlpha);
         return GrXferProcessor::kOverrideColor_OptFlag;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 GrPorterDuffXPFactory::GrPorterDuffXPFactory(GrBlendCoeff src, GrBlendCoeff dst)
@@ skipping 77 matching lines @@
             static GrPorterDuffXPFactory gScreenPDXPF(kOne_GrBlendCoeff, kISC_GrBlendCoeff);
             return SkRef(&gScreenPDXPF);
             break;
         }
         default:
             return NULL;
     }
 }
 
 GrXferProcessor*
-GrPorterDuffXPFactory::onCreateXferProcessor(const GrDrawTargetCaps& caps,
+GrPorterDuffXPFactory::onCreateXferProcessor(const GrCaps& caps,
                                              const GrProcOptInfo& colorPOI,
                                              const GrProcOptInfo& covPOI,
                                              const GrDeviceCoordTexture* dstCopy) const {
     if (covPOI.isFourChannelOutput()) {
         return PDLCDXferProcessor::Create(fSrcCoeff, fDstCoeff, colorPOI);
     } else {
         return PorterDuffXferProcessor::Create(fSrcCoeff, fDstCoeff, 0, dstCopy,
                                                this->willReadDstColor(caps, colorPOI, covPOI));
     }
 }
@@ skipping 69 matching lines @@
         case kIConstC_GrBlendCoeff:
         case kConstA_GrBlendCoeff:
         case kIConstA_GrBlendCoeff:
             output->fBlendedColorFlags = 0;
             break;
     }
 
     output->fWillBlendWithDst = false;
 }
 
-bool GrPorterDuffXPFactory::willReadDstColor(const GrDrawTargetCaps& caps,
+bool GrPorterDuffXPFactory::willReadDstColor(const GrCaps& caps,
                                              const GrProcOptInfo& colorPOI,
                                              const GrProcOptInfo& coveragePOI) const {
     // We can always blend correctly if we have dual source blending.
     if (caps.shaderCaps()->dualSourceBlendingSupport()) {
         return false;
     }
 
     if (can_tweak_alpha_for_coverage(fDstCoeff)) {
         return false;
     }
@@ skipping 16 matching lines @@
         return false;
     }
 
     return true;
 }
 
 GR_DEFINE_XP_FACTORY_TEST(GrPorterDuffXPFactory);
 
 GrXPFactory* GrPorterDuffXPFactory::TestCreate(SkRandom* random,
                                                GrContext*,
-                                               const GrDrawTargetCaps&,
+                                               const GrCaps&,
                                                GrTexture*[]) {
     SkXfermode::Mode mode = SkXfermode::Mode(random->nextULessThan(SkXfermode::kLastCoeffMode));
     return GrPorterDuffXPFactory::Create(mode);
 }