Start using RenderTargetProxy (omnibus)

src/gpu/GrContext.cpp

 /*
  * Copyright 2011 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "GrContext.h"
 #include "GrContextPriv.h"
 #include "GrContextOptions.h"
 #include "GrDrawingManager.h"
 #include "GrRenderTargetContext.h"
 #include "GrResourceCache.h"
 #include "GrResourceProvider.h"
+#include "GrRenderTarget.h"
 #include "GrRenderTargetProxy.h"
 #include "GrSoftwarePathRenderer.h"
 #include "GrSurfacePriv.h"
 
 #include "SkConfig8888.h"
 #include "SkGrPriv.h"
 
 #include "batches/GrCopySurfaceBatch.h"
 #include "effects/GrConfigConversionEffect.h"
 #include "effects/GrGammaEffect.h"
@@ skipping 446 matching lines @@
                                                     GrConfigConversionEffect::kNone_PMConversion,
                                                     textureMatrix);
             }
             if (fp) {
                 GrPaint paint;
                 paint.addColorFragmentProcessor(std::move(fp));
                 paint.setPorterDuffXPFactory(SkBlendMode::kSrc);
                 paint.setAllowSRGBInputs(true);
                 SkRect rect = SkRect::MakeWH(SkIntToScalar(width), SkIntToScalar(height));
                 tempRTC->drawRect(GrNoClip(), paint, SkMatrix::I(), rect, nullptr);
-                surfaceToRead.reset(tempRTC->asTexture().release());
+                GrRenderTarget* tempRT = tempRTC->instantiate();
+                surfaceToRead.reset(tempRT->asTexture()); // .release());
                 left = 0;
                 top = 0;
                 didTempDraw = true;
             }
         }
     }
 
     if (GrGpu::kRequireDraw_DrawPreference == drawPreference && !didTempDraw) {
         return false;
     }
@@ skipping 250 matching lines @@
         return nullptr;
     }
 
     GrSurfaceDesc desc;
     desc.fFlags = kRenderTarget_GrSurfaceFlag;
     desc.fOrigin = origin;
     desc.fWidth = width;
     desc.fHeight = height;
     desc.fConfig = config;
     desc.fSampleCnt = sampleCnt;
-
+ 
     sk_sp<GrTexture> tex;
     if (SkBackingFit::kExact == fit) {
         tex.reset(this->textureProvider()->createTexture(desc, budgeted));
     } else {
         tex.reset(this->textureProvider()->createApproxTexture(desc));
     }
     if (!tex) {
         return nullptr;
     }
 
-    sk_sp<GrRenderTargetContext> renderTargetContext(
-        this->contextPriv().makeWrappedRenderTargetContext(sk_ref_sp(tex->asRenderTarget()),
-                                                           std::move(colorSpace), surfaceProps));
-    if (!renderTargetContext) {
-        return nullptr;
-    }
+    sk_sp<GrRenderTargetProxy> rtp(GrRenderTargetProxy::Make(sk_ref_sp(tex->asRenderTarget())));
 
-    return renderTargetContext;
+    return fDrawingManager->makeRenderTargetContext(std::move(rtp),
+                                                    std::move(colorSpace), surfaceProps);
 }
 
 sk_sp<GrRenderTargetContext> GrContext::makeDeferredRenderTargetContext(
                                                         SkBackingFit fit,
                                                         int width, int height,
                                                         GrPixelConfig config,
                                                         sk_sp<SkColorSpace> colorSpace,
                                                         int sampleCnt,
                                                         GrSurfaceOrigin origin,
                                                         const SkSurfaceProps* surfaceProps,
@@ skipping 93 matching lines @@
     ASSERT_SINGLE_OWNER
     fResourceCache->setLimits(maxTextures, maxTextureBytes);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 
 void GrContext::dumpMemoryStatistics(SkTraceMemoryDump* traceMemoryDump) const {
     ASSERT_SINGLE_OWNER
     fResourceCache->dumpMemoryStatistics(traceMemoryDump);
 }