Add sk_sp to SkSurface_Gpu and SkGpuDevice

src/image/SkSurface_Gpu.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkSurface_Gpu.h"
 
 #include "GrResourceProvider.h"
 #include "SkCanvas.h"
 #include "SkGpuDevice.h"
 #include "SkImage_Base.h"
 #include "SkImage_Gpu.h"
 #include "SkImagePriv.h"
 #include "SkSurface_Base.h"
 
 #if SK_SUPPORT_GPU
 
-SkSurface_Gpu::SkSurface_Gpu(SkGpuDevice* device)
+SkSurface_Gpu::SkSurface_Gpu(sk_sp<SkGpuDevice> device)
     : INHERITED(device->width(), device->height(), &device->surfaceProps())
-    , fDevice(SkRef(device)) {
+    , fDevice(std::move(device)) {
 }
 
 SkSurface_Gpu::~SkSurface_Gpu() {
-    fDevice->unref();
 }
 
 static GrRenderTarget* prepare_rt_for_external_access(SkSurface_Gpu* surface,
                                                       SkSurface::BackendHandleAccess access) {
     switch (access) {
         case SkSurface::kFlushRead_BackendHandleAccess:
             break;
         case SkSurface::kFlushWrite_BackendHandleAccess:
         case SkSurface::kDiscardWrite_BackendHandleAccess:
             // for now we don't special-case on Discard, but we may in the future.
@@ skipping 21 matching lines @@
 bool SkSurface_Gpu::onGetRenderTargetHandle(GrBackendObject* obj, BackendHandleAccess access) {
     GrRenderTarget* rt = prepare_rt_for_external_access(this, access);
     *obj = rt->getRenderTargetHandle();
     return true;
 }
 
 SkCanvas* SkSurface_Gpu::onNewCanvas() {
     SkCanvas::InitFlags flags = SkCanvas::kDefault_InitFlags;
     flags = static_cast<SkCanvas::InitFlags>(flags | SkCanvas::kConservativeRasterClip_InitFlag);
 
-    return new SkCanvas(fDevice, flags);
+    return new SkCanvas(fDevice.get(), flags);
 }
 
 sk_sp<SkSurface> SkSurface_Gpu::onNewSurface(const SkImageInfo& info) {
     GrRenderTarget* rt = fDevice->accessRenderTarget();
     int sampleCount = rt->numColorSamples();
     // TODO: Make caller specify this (change virtual signature of onNewSurface).
     static const SkBudgeted kBudgeted = SkBudgeted::kNo;
     return SkSurface::MakeRenderTarget(fDevice->context(), kBudgeted, info, sampleCount,
                                        &this->props());
 }
@@ skipping 50 matching lines @@
 }
 
 void SkSurface_Gpu::onPrepareForExternalIO() {
     fDevice->accessRenderTarget()->prepareForExternalIO();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 sk_sp<SkSurface> SkSurface::MakeRenderTargetDirect(GrRenderTarget* target,
                                                    const SkSurfaceProps* props) {
-    SkAutoTUnref<SkGpuDevice> device(
-        SkGpuDevice::Create(target, props, SkGpuDevice::kUninit_InitContents));
+    sk_sp<SkGpuDevice> device(
+        SkGpuDevice::Make(sk_ref_sp(target), props, SkGpuDevice::kUninit_InitContents));
     if (!device) {
         return nullptr;
     }
-    return sk_make_sp<SkSurface_Gpu>(device);
+    return sk_make_sp<SkSurface_Gpu>(std::move(device));
 }
 
 sk_sp<SkSurface> SkSurface::MakeRenderTarget(GrContext* ctx, SkBudgeted budgeted,
                                              const SkImageInfo& info, int sampleCount,
                                              const SkSurfaceProps* props) {
-    SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(
+    sk_sp<SkGpuDevice> device(SkGpuDevice::Make(
             ctx, budgeted, info, sampleCount, props, SkGpuDevice::kClear_InitContents));
     if (!device) {
         return nullptr;
     }
-    return sk_make_sp<SkSurface_Gpu>(device);
+    return sk_make_sp<SkSurface_Gpu>(std::move(device));
 }
 
 sk_sp<SkSurface> SkSurface::MakeFromBackendTexture(GrContext* context,
                                                    const GrBackendTextureDesc& desc,
                                                    const SkSurfaceProps* props) {
     if (nullptr == context) {
         return nullptr;
     }
     if (!SkToBool(desc.fFlags & kRenderTarget_GrBackendTextureFlag)) {
         return nullptr;
     }
     SkAutoTUnref<GrSurface> surface(context->textureProvider()->wrapBackendTexture(desc,
                                     kBorrow_GrWrapOwnership));
     if (!surface) {
         return nullptr;
     }
-    SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(surface->asRenderTarget(), props,
-                                                         SkGpuDevice::kUninit_InitContents));
+    sk_sp<SkGpuDevice> device(SkGpuDevice::Make(sk_ref_sp(surface->asRenderTarget()), props,
+                                                SkGpuDevice::kUninit_InitContents));
     if (!device) {
         return nullptr;
     }
-    return sk_make_sp<SkSurface_Gpu>(device);
+    return sk_make_sp<SkSurface_Gpu>(std::move(device));
 }
 
 sk_sp<SkSurface> SkSurface::MakeFromBackendRenderTarget(GrContext* context,
                                                         const GrBackendRenderTargetDesc& desc,
                                                         const SkSurfaceProps* props) {
-    if (nullptr == context) {
+    if (!context) {
         return nullptr;
     }
-    SkAutoTUnref<GrRenderTarget> rt(context->textureProvider()->wrapBackendRenderTarget(desc));
+    sk_sp<GrRenderTarget> rt(context->textureProvider()->wrapBackendRenderTarget(desc));
     if (!rt) {
         return nullptr;
     }
-    SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(rt, props,
-                                                         SkGpuDevice::kUninit_InitContents));
+    sk_sp<SkGpuDevice> device(SkGpuDevice::Make(std::move(rt), props,
+                                                SkGpuDevice::kUninit_InitContents));
     if (!device) {
         return nullptr;
     }
-    return sk_make_sp<SkSurface_Gpu>(device);
+    return sk_make_sp<SkSurface_Gpu>(std::move(device));
 }
 
 sk_sp<SkSurface> SkSurface::MakeFromBackendTextureAsRenderTarget(GrContext* context,
                                                                  const GrBackendTextureDesc& desc,
                                                                  const SkSurfaceProps* props) {
-    if (nullptr == context) {
+    if (!context) {
         return nullptr;
     }
-    SkAutoTUnref<GrRenderTarget> rt(
-            context->resourceProvider()->wrapBackendTextureAsRenderTarget(desc));
+    sk_sp<GrRenderTarget> rt(context->resourceProvider()->wrapBackendTextureAsRenderTarget(desc));
     if (!rt) {
         return nullptr;
     }
-    SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(rt, props,
-                                                         SkGpuDevice::kUninit_InitContents));
+    sk_sp<SkGpuDevice> device(SkGpuDevice::Make(std::move(rt), props,
+                                                SkGpuDevice::kUninit_InitContents));
     if (!device) {
         return nullptr;
     }
-    return sk_make_sp<SkSurface_Gpu>(device);
+    return sk_make_sp<SkSurface_Gpu>(std::move(device));
 }
 
 #endif