(Mostly) Retract GrRenderTarget from SkGpuDevice

src/gpu/SkGpuDevice.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 "SkGpuDevice.h"
 
 #include "GrBlurUtils.h"
@@ skipping 111 matching lines @@
         }
     }
     if (kClear_InitContents == init) {
         *flags |= kNeedClear_Flag;
     }
     return true;
 }
 
 sk_sp<SkGpuDevice> SkGpuDevice::Make(sk_sp<GrRenderTarget> rt, const SkSurfaceProps* props,
                                      InitContents init) {
-    const int width = rt->width();
-    const int height = rt->height();
-    return SkGpuDevice::Make(std::move(rt), width, height, props, init);
-}
-
-sk_sp<SkGpuDevice> SkGpuDevice::Make(sk_sp<GrRenderTarget> rt, int width, int height,
-                                     const SkSurfaceProps* props, InitContents init) {
-    if (!rt || rt->wasDestroyed()) {
+    if (!rt || rt->wasDestroyed() || !rt->getContext()) {
         return nullptr;
     }
     unsigned flags;
     if (!CheckAlphaTypeAndGetFlags(nullptr, init, &flags)) {
         return nullptr;
     }
-    return sk_sp<SkGpuDevice>(new SkGpuDevice(rt.get(), width, height, props, flags));
+
+    const int width = rt->width();
+    const int height = rt->height();
+
+    GrContext* context = rt->getContext();
+
+    sk_sp<GrDrawContext> drawContext(context->drawContext(std::move(rt), props));
+    return sk_sp<SkGpuDevice>(new SkGpuDevice(std::move(drawContext), width, height, flags));
+}
+
+sk_sp<SkBaseDevice> SkGpuDevice::Make(sk_sp<GrDrawContext> drawContext,
+                                      int width, int height,
+                                      InitContents init) {
+    if (!drawContext || drawContext->wasAbandoned()) {
+        return nullptr;
+    }
+    unsigned flags;
+    if (!CheckAlphaTypeAndGetFlags(nullptr, init, &flags)) {
+        return nullptr;
+    }
+    return sk_sp<SkBaseDevice>(new SkGpuDevice(std::move(drawContext), width, height, flags));
 }
 
 sk_sp<SkGpuDevice> SkGpuDevice::Make(GrContext* context, SkBudgeted budgeted,
                                      const SkImageInfo& info, int sampleCount,
                                      const SkSurfaceProps* props, InitContents init) {
     unsigned flags;
     if (!CheckAlphaTypeAndGetFlags(&info, init, &flags)) {
         return nullptr;
     }
 
-    SkAutoTUnref<GrRenderTarget> rt(CreateRenderTarget(context, budgeted, info, sampleCount));
-    if (!rt) {
+    sk_sp<GrDrawContext> drawContext(CreateDrawContext(context, budgeted, info,
+                                                       sampleCount, props));
+    if (!drawContext) {
         return nullptr;
     }
 
-    return sk_sp<SkGpuDevice>(new SkGpuDevice(rt, info.width(), info.height(), props, flags));
+    return sk_sp<SkGpuDevice>(new SkGpuDevice(std::move(drawContext),
+                                              info.width(), info.height(), flags));
 }
 
-SkGpuDevice::SkGpuDevice(GrRenderTarget* rt, int width, int height,
-                         const SkSurfaceProps* props, unsigned flags)
-    : INHERITED(SkSurfacePropsCopyOrDefault(props))
-    , fContext(SkRef(rt->getContext()))
-    , fRenderTarget(SkRef(rt)) {
+SkGpuDevice::SkGpuDevice(sk_sp<GrDrawContext> drawContext, int width, int height, unsigned flags) 
+    : INHERITED(drawContext->surfaceProps())
+    , fContext(SkRef(drawContext->accessRenderTarget()->getContext()))
+    , fRenderTarget(drawContext->renderTarget())
+    , fDrawContext(std::move(drawContext)) {
     fOpaque = SkToBool(flags & kIsOpaque_Flag);
 
     SkAlphaType at = fOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
-    SkImageInfo info = rt->surfacePriv().info(at).makeWH(width, height);
-    SkPixelRef* pr = new SkGrPixelRef(info, rt);
+    SkImageInfo info = fRenderTarget->surfacePriv().info(at).makeWH(width, height);
+    SkPixelRef* pr = new SkGrPixelRef(info, fRenderTarget.get());
     fLegacyBitmap.setInfo(info);
     fLegacyBitmap.setPixelRef(pr)->unref();
 
-    fDrawContext = this->context()->drawContext(sk_ref_sp(rt), &this->surfaceProps());
     if (flags & kNeedClear_Flag) {
         this->clearAll();
     }
 }
 
-GrRenderTarget* SkGpuDevice::CreateRenderTarget(GrContext* context, SkBudgeted budgeted,
-                                                const SkImageInfo& origInfo, int sampleCount) {
+sk_sp<GrDrawContext> SkGpuDevice::CreateDrawContext(GrContext* context,
+                                                    SkBudgeted budgeted,
+                                                    const SkImageInfo& origInfo,
+                                                    int sampleCount,
+                                                    const SkSurfaceProps* surfaceProps) {
     if (kUnknown_SkColorType == origInfo.colorType() ||
         origInfo.width() < 0 || origInfo.height() < 0) {
         return nullptr;
     }
 
     if (!context) {
         return nullptr;
     }
 
     SkColorType ct = origInfo.colorType();
     SkAlphaType at = origInfo.alphaType();
     SkColorProfileType pt = origInfo.profileType();
     if (kRGB_565_SkColorType == ct || kGray_8_SkColorType == ct) {
         at = kOpaque_SkAlphaType;  // force this setting
     }
     if (kOpaque_SkAlphaType != at) {
         at = kPremul_SkAlphaType;  // force this setting
     }
 
     GrPixelConfig origConfig = SkImageInfo2GrPixelConfig(ct, at, pt, *context->caps());
     if (!context->caps()->isConfigRenderable(origConfig, sampleCount > 0)) {
         // Fall back from whatever ct was to default of kRGBA or kBGRA which is aliased as kN32
         ct = kN32_SkColorType;
     }
 
-    const SkImageInfo info = SkImageInfo::Make(origInfo.width(), origInfo.height(), ct, at, pt);
+    GrPixelConfig config = SkImageInfo2GrPixelConfig(ct, at, pt, *context->caps());
 
-    GrSurfaceDesc desc;
-    desc.fFlags = kRenderTarget_GrSurfaceFlag;
-    desc.fWidth = info.width();
-    desc.fHeight = info.height();
-    desc.fConfig = SkImageInfo2GrPixelConfig(info, *context->caps());
-    desc.fSampleCnt = sampleCount;
-    desc.fIsMipMapped = false;
-    GrTexture* texture = context->textureProvider()->createTexture(desc, budgeted, nullptr, 0);
-    if (nullptr == texture) {
-        return nullptr;
-    }
-    SkASSERT(nullptr != texture->asRenderTarget());
-    return texture->asRenderTarget();
+    return context->newDrawContext(SkBackingFit::kExact,               // Why exact?
+                                   origInfo.width(), origInfo.height(),
+                                   config, sampleCount,
+                                   kDefault_GrSurfaceOrigin, surfaceProps, budgeted);
+
 }
 
 // This method ensures that we always have a texture-backed "bitmap" when we finally
 // call through to the base impl so that the image filtering code will take the
 // gpu-specific paths. This mirrors SkCanvas::internalDrawDevice (the other
 // use of SkImageFilter::filterImage) in that the source and dest will have
 // homogenous backing (e.g., raster or gpu).
 void SkGpuDevice::drawSpriteWithFilter(const SkDraw& draw, const SkBitmap& bitmap,
                                        int x, int y, const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
@@ skipping 103 matching lines @@
     ASSERT_SINGLE_OWNER
     SkASSERT(fClipStack.get());
 
     SkASSERT(draw.fClipStack && draw.fClipStack == fClipStack);
 
     fClip.reset(fClipStack, &this->getOrigin());
 }
 
 GrRenderTarget* SkGpuDevice::accessRenderTarget() {
     ASSERT_SINGLE_OWNER
-    return fRenderTarget;
+    return fRenderTarget.get();
 }
 
 GrDrawContext* SkGpuDevice::accessDrawContext() {
     ASSERT_SINGLE_OWNER
     return fDrawContext.get();
 }
 
 void SkGpuDevice::clearAll() {
     ASSERT_SINGLE_OWNER
     GrColor color = 0;
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "clearAll", fContext);
     SkIRect rect = SkIRect::MakeWH(this->width(), this->height());
     fDrawContext->clear(&rect, color, true);
 }
 
-void SkGpuDevice::replaceRenderTarget(bool shouldRetainContent) {
+void SkGpuDevice::replaceDrawContext(bool shouldRetainContent) {
     ASSERT_SINGLE_OWNER
 
     SkBudgeted budgeted = fRenderTarget->resourcePriv().isBudgeted();
 
-    SkAutoTUnref<GrRenderTarget> newRT(CreateRenderTarget(
-        this->context(), budgeted, this->imageInfo(), fRenderTarget->desc().fSampleCnt));
-
-    if (nullptr == newRT) {
+    sk_sp<GrDrawContext> newDC(CreateDrawContext(this->context(), 
+                                                 budgeted,
+                                                 this->imageInfo(),
+                                                 fDrawContext->numColorSamples(),
+                                                 &this->surfaceProps()));
+    if (!newDC) {
         return;
     }
 
     if (shouldRetainContent) {
         if (fRenderTarget->wasDestroyed()) {
             return;
         }
-        this->context()->copySurface(newRT, fRenderTarget);
+        newDC->copySurface(fDrawContext->asTexture().get(),
+                           SkIRect::MakeWH(this->width(), this->height()),
+                           SkIPoint::Make(0, 0));
     }
 
-    SkASSERT(fRenderTarget != newRT);
+    SkASSERT(fDrawContext->accessRenderTarget() != newDC->accessRenderTarget());
 
-    fRenderTarget.reset(newRT.release());
+    fRenderTarget = newDC->renderTarget();
 
 #ifdef SK_DEBUG
     SkImageInfo info = fRenderTarget->surfacePriv().info(fOpaque ? kOpaque_SkAlphaType :
                                                                    kPremul_SkAlphaType);
     SkASSERT(info == fLegacyBitmap.info());
 #endif
-    SkPixelRef* pr = new SkGrPixelRef(fLegacyBitmap.info(), fRenderTarget);
+    SkPixelRef* pr = new SkGrPixelRef(fLegacyBitmap.info(), fRenderTarget.get());
     fLegacyBitmap.setPixelRef(pr)->unref();
 
-    fDrawContext = this->context()->drawContext(sk_ref_sp(fRenderTarget.get()),
-                                                &this->surfaceProps());
+    fDrawContext = newDC;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawPaint", fContext);
 
     GrPaint grPaint;
@@ skipping 904 matching lines @@
 void SkGpuDevice::drawDevice(const SkDraw& draw, SkBaseDevice* device,
                              int x, int y, const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
     // clear of the source device must occur before CHECK_SHOULD_DRAW
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawDevice", fContext);
     SkGpuDevice* dev = static_cast<SkGpuDevice*>(device);
 
     // drawDevice is defined to be in device coords.
     CHECK_SHOULD_DRAW(draw);
 
-    GrRenderTarget* devRT = dev->accessRenderTarget();
-    GrTexture* devTex;
-    if (nullptr == (devTex = devRT->asTexture())) {
+    sk_sp<GrTexture> devTex(dev->accessDrawContext()->asTexture());
+    if (!devTex) {
         return;
     }
 
     const SkImageInfo ii = dev->imageInfo();
     int w = ii.width();
     int h = ii.height();
 
     SkASSERT(!paint.getImageFilter());
 
     GrPaint grPaint;
     SkAutoTUnref<const GrFragmentProcessor> fp(
-        GrSimpleTextureEffect::Create(devTex, SkMatrix::I()));
+        GrSimpleTextureEffect::Create(devTex.get(), SkMatrix::I()));
     if (GrPixelConfigIsAlphaOnly(devTex->config())) {
         // Can this happen?
         fp.reset(GrFragmentProcessor::MulOutputByInputUnpremulColor(fp));
    } else {
         fp.reset(GrFragmentProcessor::MulOutputByInputAlpha(fp));
     }
 
     if (!SkPaintToGrPaintReplaceShader(this->context(), paint, fp,
                                        this->surfaceProps().isGammaCorrect(), &grPaint)) {
         return;
@@ skipping 381 matching lines @@
 void SkGpuDevice::flush() {
     ASSERT_SINGLE_OWNER
 
     fRenderTarget->prepareForExternalIO();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkBaseDevice* SkGpuDevice::onCreateDevice(const CreateInfo& cinfo, const SkPaint*) {
     ASSERT_SINGLE_OWNER
-    GrSurfaceDesc desc;
-    desc.fConfig = fRenderTarget->config();
-    desc.fFlags = kRenderTarget_GrSurfaceFlag;
-    desc.fWidth = cinfo.fInfo.width();
-    desc.fHeight = cinfo.fInfo.height();
-    desc.fSampleCnt = fRenderTarget->desc().fSampleCnt;
 
-    SkAutoTUnref<GrTexture> texture;
+    SkSurfaceProps props(this->surfaceProps().flags(), cinfo.fPixelGeometry);
+
+    // layers are never drawn in repeat modes, so we can request an approx
+    // match and ignore any padding.
+    SkBackingFit fit = kNever_TileUsage == cinfo.fTileUsage ? SkBackingFit::kApprox
+                                                            : SkBackingFit::kExact;
+
+    sk_sp<GrDrawContext> dc(fContext->newDrawContext(fit,
+                                                     cinfo.fInfo.width(), cinfo.fInfo.height(),
+                                                     fDrawContext->config(),
+                                                     fDrawContext->desc().fSampleCnt,
+                                                     kDefault_GrSurfaceOrigin,
+                                                     &props));
+    if (!dc) {
+        SkErrorInternals::SetError( kInternalError_SkError,
+                                    "---- failed to create gpu device texture [%d %d]\n",
+                                    cinfo.fInfo.width(), cinfo.fInfo.height());
+        return nullptr;    
+    }
+
     // Skia's convention is to only clear a device if it is non-opaque.
     InitContents init = cinfo.fInfo.isOpaque() ? kUninit_InitContents : kClear_InitContents;
 
-    // layers are never draw in repeat modes, so we can request an approx
-    // match and ignore any padding.
-    if (kNever_TileUsage == cinfo.fTileUsage) {
-        texture.reset(fContext->textureProvider()->createApproxTexture(desc));
-    } else {
-        texture.reset(fContext->textureProvider()->createTexture(desc, SkBudgeted::kYes));
-    }
-
-    if (texture) {
-        SkSurfaceProps props(this->surfaceProps().flags(), cinfo.fPixelGeometry);
-        return SkGpuDevice::Make(sk_ref_sp(texture->asRenderTarget()),
-                                 cinfo.fInfo.width(), cinfo.fInfo.height(),
-                                 &props, init).release();
-    } else {
-        SkErrorInternals::SetError( kInternalError_SkError,
-                                    "---- failed to create gpu device texture [%d %d]\n",
-                                    cinfo.fInfo.width(), cinfo.fInfo.height());
-        return nullptr;
-    }
+    return SkGpuDevice::Make(std::move(dc),
+                             cinfo.fInfo.width(), cinfo.fInfo.height(),
+                             init).release();
 }
 
 sk_sp<SkSurface> SkGpuDevice::makeSurface(const SkImageInfo& info, const SkSurfaceProps& props) {
     ASSERT_SINGLE_OWNER
     // TODO: Change the signature of newSurface to take a budgeted parameter.
     static const SkBudgeted kBudgeted = SkBudgeted::kNo;
     return SkSurface::MakeRenderTarget(fContext, kBudgeted, info, fDrawContext->desc().fSampleCnt,
                                        &props);
 }
 
@@ skipping 71 matching lines @@
 }
 
 SkImageFilterCache* SkGpuDevice::getImageFilterCache() {
     ASSERT_SINGLE_OWNER
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilterCache::Create(kDefaultImageFilterCacheSize);
 }
 
 #endif