rename GrDrawTargetCaps to GrCaps

src/gpu/effects/GrCustomXfermode.cpp

 /*
  * Copyright 2015 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "effects/GrCustomXfermode.h"
 #include "effects/GrCustomXfermodePriv.h"
 
@@ skipping 477 matching lines @@
     return fMode == s.fMode;
 }
 
 void GrCustomXferFP::onComputeInvariantOutput(GrInvariantOutput* inout) const {
     inout->setToUnknown(GrInvariantOutput::kWill_ReadInput);
 }
 
 GR_DEFINE_FRAGMENT_PROCESSOR_TEST(GrCustomXferFP);
 GrFragmentProcessor* GrCustomXferFP::TestCreate(SkRandom* rand,
                                                 GrContext*,
-                                                const GrDrawTargetCaps&,
+                                                const GrCaps&,
                                                 GrTexture* textures[]) {
     int mode = rand->nextRangeU(SkXfermode::kLastCoeffMode + 1, SkXfermode::kLastSeparableMode);
 
     return SkNEW_ARGS(GrCustomXferFP, (static_cast<SkXfermode::Mode>(mode), textures[0]));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Xfer Processor
 ///////////////////////////////////////////////////////////////////////////////
 
@@ skipping 24 matching lines @@
         return fHWBlendEquation;
     }
 
 private:
     CustomXP(SkXfermode::Mode mode, 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;
 
     bool onWillNeedXferBarrier(const GrRenderTarget* rt,
-                               const GrDrawTargetCaps& caps,
+                               const GrCaps& caps,
                                GrXferBarrierType* outBarrierType) const override;
 
     void onGetBlendInfo(BlendInfo*) const override;
 
     bool onIsEqual(const GrXferProcessor& xpBase) const override;
 
     SkXfermode::Mode fMode;
     GrBlendEquation  fHWBlendEquation;
 
     typedef GrXferProcessor INHERITED;
@@ skipping 86 matching lines @@
 
 bool CustomXP::onIsEqual(const GrXferProcessor& other) const {
     const CustomXP& s = other.cast<CustomXP>();
     return fMode == s.fMode && fHWBlendEquation == s.fHWBlendEquation;
 }
 
 GrXferProcessor::OptFlags CustomXP::onGetOptimizations(const GrProcOptInfo& colorPOI,
                                                        const GrProcOptInfo& coveragePOI,
                                                        bool doesStencilWrite,
                                                        GrColor* overrideColor,
-                                                       const GrDrawTargetCaps& caps) {
+                                                       const GrCaps& caps) {
   /*
     Most the optimizations we do here are based on tweaking alpha for coverage.
 
     The general SVG blend equation is defined in the spec as follows:
 
       Dca' = B(Sc, Dc) * Sa * Da + Y * Sca * (1-Da) + Z * Dca * (1-Sa)
       Da'  = X * Sa * Da + Y * Sa * (1-Da) + Z * Da * (1-Sa)
 
     (Note that Sca, Dca indicate RGB vectors that are premultiplied by alpha,
      and that B(Sc, Dc) is a mode-specific function that accepts non-multiplied
@@ skipping 91 matching lines @@
         flags |= kIgnoreCoverage_OptFlag;
     }
     if (caps.advancedBlendEquationSupport() && !coveragePOI.isFourChannelOutput()) {
         // This blend mode can be implemented in hardware.
         fHWBlendEquation = hw_blend_equation(fMode);
     }
     return flags;
 }
 
 bool CustomXP::onWillNeedXferBarrier(const GrRenderTarget* rt,
-                                     const GrDrawTargetCaps& caps,
+                                     const GrCaps& caps,
                                      GrXferBarrierType* outBarrierType) const {
     if (this->hasHWBlendEquation() && !caps.advancedCoherentBlendEquationSupport()) {
         *outBarrierType = kBlend_GrXferBarrierType;
         return true;
     }
     return false;
 }
 
 void CustomXP::onGetBlendInfo(BlendInfo* blendInfo) const {
     if (this->hasHWBlendEquation()) {
         blendInfo->fEquation = this->hwBlendEquation();
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrCustomXPFactory::GrCustomXPFactory(SkXfermode::Mode mode)
     : fMode(mode) {
     this->initClassID<GrCustomXPFactory>();
 }
 
 GrXferProcessor*
-GrCustomXPFactory::onCreateXferProcessor(const GrDrawTargetCaps& caps,
+GrCustomXPFactory::onCreateXferProcessor(const GrCaps& caps,
                                          const GrProcOptInfo& colorPOI,
                                          const GrProcOptInfo& coveragePOI,
                                          const GrDeviceCoordTexture* dstCopy) const {
     return CustomXP::Create(fMode, dstCopy, this->willReadDstColor(caps, colorPOI, coveragePOI));
 }
 
-bool GrCustomXPFactory::willReadDstColor(const GrDrawTargetCaps& caps,
+bool GrCustomXPFactory::willReadDstColor(const GrCaps& caps,
                                          const GrProcOptInfo& colorPOI,
                                          const GrProcOptInfo& coveragePOI) const {
     if (!caps.advancedBlendEquationSupport()) {
         // No hardware support for advanced blend equations; we will need to do it in the shader.
         return true;
     }
     if (coveragePOI.isFourChannelOutput()) {
         // Advanced blend equations can't tweak alpha for RGB coverage.
         return true;
     }
     return false;
 }
 
 void GrCustomXPFactory::getInvariantOutput(const GrProcOptInfo& colorPOI,
                                                const GrProcOptInfo& coveragePOI,
                                                GrXPFactory::InvariantOutput* output) const {
     output->fWillBlendWithDst = true;
     output->fBlendedColorFlags = 0;
 }
 
 GR_DEFINE_XP_FACTORY_TEST(GrCustomXPFactory);
 GrXPFactory* GrCustomXPFactory::TestCreate(SkRandom* rand,
                                            GrContext*,
-                                           const GrDrawTargetCaps&,
+                                           const GrCaps&,
                                            GrTexture*[]) {
     int mode = rand->nextRangeU(SkXfermode::kLastCoeffMode + 1, SkXfermode::kLastSeparableMode);
 
     return SkNEW_ARGS(GrCustomXPFactory, (static_cast<SkXfermode::Mode>(mode)));
 }