Make all SkSurface_* -related devices all have a device

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 "GrGpuResourcePriv.h"
 #include "SkCanvas.h"
 #include "SkGpuDevice.h"
 #include "SkImage_Base.h"
 #include "SkImagePriv.h"
 #include "SkSurface_Base.h"
 
 #if SK_SUPPORT_GPU
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkSurface_Gpu::SkSurface_Gpu(SkGpuDevice* device)
     : INHERITED(device->width(), device->height(), &device->surfaceProps())
-    , fDevice(SkRef(device)) {
+    , fDevice(SkRef(device))
+    , fOwnsDevice(true) {
+    fDevice->setSurface(this);
+}
+
+
+SkSurface_Gpu::SkSurface_Gpu(SkGpuDevice* device, ReverseOwnershipDeprecated)
+    : INHERITED(device->width(), device->height(), &device->surfaceProps())
+    , fDevice(device)
+    , fOwnsDevice(false) {
+    fDevice->setSurface(this);
 }
 
 SkSurface_Gpu::~SkSurface_Gpu() {
-    fDevice->unref();
+    if (fOwnsDevice) {
+        fDevice->unref();
+    }
 }
 
 SkCanvas* SkSurface_Gpu::onNewCanvas() {
     SkCanvas::InitFlags flags = SkCanvas::kDefault_InitFlags;
     // When we think this works...
 //    flags |= SkCanvas::kConservativeRasterClip_InitFlag;
 
     return SkNEW_ARGS(SkCanvas, (fDevice, &this->props(), flags));
 }
 
@@ skipping 88 matching lines @@
     desc.fConfig = SkImageInfo2GrPixelConfig(newInfo);
     desc.fSampleCnt = sampleCount;
     GrTexture* texture = context->createTexture(desc, SkToBool(budgeted), NULL, 0);
     if (NULL == texture) {
         return NULL;
     }
     SkASSERT(NULL != texture->asRenderTarget());
     return texture->asRenderTarget();
 }
 
+SkGpuDevice* SkSurface_Gpu::createCompatibleDeviceDeprecated(
+    const SkBaseDevice::CreateInfo& cinfo) {
+    GrRenderTarget* rt = fDevice->accessRenderTarget();
+    GrSurfaceDesc desc;
+    desc.fConfig = rt->config();
+    desc.fFlags = kRenderTarget_GrSurfaceFlag;
+    desc.fWidth = cinfo.fInfo.width();
+    desc.fHeight = cinfo.fInfo.height();
+    desc.fSampleCnt = rt->numSamples();
+
+    SkAutoTUnref<GrTexture> texture;
+    // Skia's convention is to only clear a device if it is non-opaque.
+    unsigned flags = cinfo.fInfo.isOpaque() ? 0 : SkGpuDevice::kNeedClear_Flag;
+
+    // layers are never draw in repeat modes, so we can request an approx
+    // match and ignore any padding.
+    const GrContext::ScratchTexMatch match = (SkBaseDevice::kSaveLayer_Usage == cinfo.fUsage) ?
+                                                GrContext::kApprox_ScratchTexMatch :
+                                                GrContext::kExact_ScratchTexMatch;
+    texture.reset(rt->getContext()->refScratchTexture(desc, match));
+
+    if (!texture) {
+        SkDebugf("---- failed to create compatible device texture [%d %d]\n",
+                 cinfo.fInfo.width(), cinfo.fInfo.height());
+        return NULL;
+    }
+
+    // This is a factory function for SkGpuDevice (not SkSurface_Gpu, at the moment).
+    // Caller requested new instance of device, so caller owns the ref.
+    SkGpuDevice* device = SkGpuDevice::CreateWithReverseOwnershipDeprecated(
+        texture->asRenderTarget(), &this->props(), flags);
+    if (NULL == device) {
+        return NULL;
+    }
+
+    SkNEW_ARGS(SkSurface_Gpu, (device, kReverseOwnershipDeprecated));
+
+    // Device owns the surface.
+
+    return device;
+}
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkSurface* SkSurface::NewRenderTargetDirect(GrRenderTarget* target, const SkSurfaceProps* props) {
     SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(target, props));
     if (!device) {
         return NULL;
     }
     return SkNEW_ARGS(SkSurface_Gpu, (device));
 }
 
 SkSurface* SkSurface::NewRenderTarget(GrContext* ctx, Budgeted budgeted, const SkImageInfo& info,
                                       int sampleCount, const SkSurfaceProps* props) {
     SkAutoTUnref<GrRenderTarget> rt(SkSurface_Gpu::CreateRenderTarget(ctx, budgeted, info,
                                                                       sampleCount));
     if (NULL == rt) {
         return NULL;
     }
     SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(rt, props, SkGpuDevice::kNeedClear_Flag));
     if (NULL == device) {
         return NULL;
     }
     return SkNEW_ARGS(SkSurface_Gpu, (device));
 }
 
 #endif