Start using RenderTargetProxy (omnibus)

src/effects/SkXfermodeImageFilter.cpp

 /*
  * Copyright 2013 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkXfermodeImageFilter.h"
 #include "SkArithmeticModePriv.h"
 
 #include "SkCanvas.h"
 #include "SkColorPriv.h"
 #include "SkReadBuffer.h"
 #include "SkSpecialImage.h"
 #include "SkSpecialSurface.h"
 #include "SkWriteBuffer.h"
 #include "SkXfermode.h"
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrRenderTargetContext.h"
+#include "GrTextureProxy.h"
 #include "effects/GrConstColorProcessor.h"
 #include "effects/GrTextureDomain.h"
 #include "effects/GrSimpleTextureEffect.h"
 #include "SkArithmeticMode_gpu.h"
 #include "SkGr.h"
 #include "SkGrPriv.h"
 #endif
 
 class SkXfermodeImageFilter_Base : public SkImageFilter {
 public:
@@ skipping 215 matching lines @@
     GrPaint paint;
     sk_sp<GrFragmentProcessor> bgFP;
 
     if (backgroundTex) {
         SkMatrix backgroundMatrix;
         backgroundMatrix.setIDiv(backgroundTex->width(), backgroundTex->height());
         backgroundMatrix.preTranslate(-SkIntToScalar(backgroundOffset.fX),
                                       -SkIntToScalar(backgroundOffset.fY));
         bgFP = GrTextureDomainEffect::Make(
                             backgroundTex.get(), nullptr, backgroundMatrix,
-                            GrTextureDomain::MakeTexelDomain(backgroundTex.get(),
+                            GrTextureDomain::MakeTexelDomain(backgroundTex->width(),
+                                                             backgroundTex->height(),
                                                              background->subset()),
                             GrTextureDomain::kDecal_Mode,
                             GrTextureParams::kNone_FilterMode);
     } else {
         bgFP = GrConstColorProcessor::Make(GrColor4f::TransparentBlack(),
                                            GrConstColorProcessor::kIgnore_InputMode);
     }
 
     if (foregroundTex) {
         SkMatrix foregroundMatrix;
         foregroundMatrix.setIDiv(foregroundTex->width(), foregroundTex->height());
         foregroundMatrix.preTranslate(-SkIntToScalar(foregroundOffset.fX),
                                       -SkIntToScalar(foregroundOffset.fY));
 
         sk_sp<GrFragmentProcessor> foregroundFP;
 
         foregroundFP = GrTextureDomainEffect::Make(
                             foregroundTex.get(), nullptr, foregroundMatrix,
-                            GrTextureDomain::MakeTexelDomain(foregroundTex.get(), 
+                            GrTextureDomain::MakeTexelDomain(foregroundTex->width(),
+                                                             foregroundTex->height(),
                                                              foreground->subset()),
                             GrTextureDomain::kDecal_Mode,
                             GrTextureParams::kNone_FilterMode);
 
         paint.addColorFragmentProcessor(std::move(foregroundFP));
 
         sk_sp<GrFragmentProcessor> xferFP = this->makeFGFrag(bgFP);
 
         // A null 'xferFP' here means kSrc_Mode was used in which case we can just proceed
         if (xferFP) {
             paint.addColorFragmentProcessor(std::move(xferFP));
         }
     } else {
         paint.addColorFragmentProcessor(std::move(bgFP));
     }
 
     paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
 
-    sk_sp<GrRenderTargetContext> renderTargetContext(context->makeRenderTargetContext(
+    sk_sp<GrRenderTargetContext> renderTargetContext(context->makeDeferredRenderTargetContext(
         SkBackingFit::kApprox, bounds.width(), bounds.height(),
         GrRenderableConfigForColorSpace(outputProperties.colorSpace()),
         sk_ref_sp(outputProperties.colorSpace())));
     if (!renderTargetContext) {
         return nullptr;
     }
     paint.setGammaCorrect(renderTargetContext->isGammaCorrect());
 
     SkMatrix matrix;
     matrix.setTranslate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
     renderTargetContext->drawRect(GrNoClip(), paint, matrix, SkRect::Make(bounds));
 
-    return SkSpecialImage::MakeFromGpu(SkIRect::MakeWH(bounds.width(), bounds.height()),
-                                       kNeedNewImageUniqueID_SpecialImage,
-                                       renderTargetContext->asTexture(),
-                                       sk_ref_sp(renderTargetContext->getColorSpace()));
+    return SkSpecialImage::MakeDeferredFromGpu(SkIRect::MakeWH(bounds.width(), bounds.height()),
+                                               kNeedNewImageUniqueID_SpecialImage,
+                                               renderTargetContext->asDeferredTexture(),
+                                               sk_ref_sp(renderTargetContext->getColorSpace()));
 }
 
 sk_sp<GrFragmentProcessor>
 SkXfermodeImageFilter_Base::makeFGFrag(sk_sp<GrFragmentProcessor> bgFP) const {
     // A null fMode is interpreted to mean kSrcOver_Mode (to match raster).
     SkXfermode* xfer = SkXfermode::Peek(fMode);
     sk_sp<SkXfermode> srcover;
     if (!xfer) {
         // It would be awesome to use SkXfermode::Create here but it knows better
         // than us and won't return a kSrcOver_Mode SkXfermode. That means we
@@ skipping 204 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkXfermodeImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkXfermodeImageFilter_Base)
     // manually register the legacy serialized name "SkXfermodeImageFilter"
     SkFlattenable::Register("SkXfermodeImageFilter", SkXfermodeImageFilter_Base::CreateProc,
                             SkFlattenable::kSkImageFilter_Type);
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkArithmeticImageFilter)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END