Make all SkSurface_* -related devices all have a device

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 "effects/GrBicubicEffect.h"
@@ skipping 112 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkGpuDevice* SkGpuDevice::Create(GrRenderTarget* rt, const SkSurfaceProps* props, unsigned flags) {
     if (!rt || rt->wasDestroyed()) {
         return NULL;
     }
     return SkNEW_ARGS(SkGpuDevice, (rt, props, flags));
 }
 
+SkGpuDevice* SkGpuDevice::CreateWithReverseOwnershipDeprecated(GrRenderTarget* rt,
+                                                               const SkSurfaceProps* props,
+                                                               unsigned flags) {
+    SkGpuDevice* device = SkGpuDevice::Create(rt, props, flags);
+    if (NULL == device) {
+        return device;
+    }
+    device->fDeviceOwnsSurface = true;
+    return device;
+}
+
 static SkDeviceProperties surfaceprops_to_deviceprops(const SkSurfaceProps* props) {
     if (props) {
         return SkDeviceProperties(props->pixelGeometry());
     } else {
         return SkDeviceProperties(SkDeviceProperties::kLegacyLCD_InitType);
     }
 }
 
 static SkSurfaceProps copy_or_default_props(const SkSurfaceProps* props) {
     if (props) {
         return SkSurfaceProps(*props);
     } else {
         return SkSurfaceProps(SkSurfaceProps::kLegacyFontHost_InitType);
     }
 }
 
 SkGpuDevice::SkGpuDevice(GrRenderTarget* rt, const SkSurfaceProps* props, unsigned flags)
     : INHERITED(surfaceprops_to_deviceprops(props))
     , fSurfaceProps(copy_or_default_props(props))
+    , fSurface(NULL)
+    , fDeviceOwnsSurface(false)
 {
     fDrawProcs = NULL;
 
     fContext = SkRef(rt->getContext());
     fNeedClear = flags & kNeedClear_Flag;
 
     fRenderTarget = SkRef(rt);
 
     SkImageInfo info = rt->surfacePriv().info();
     SkPixelRef* pr = SkNEW_ARGS(SkGrPixelRef, (info, rt));
     fLegacyBitmap.setInfo(info);
     fLegacyBitmap.setPixelRef(pr)->unref();
 
     bool useDFT = fSurfaceProps.isUseDistanceFieldFonts();
     fTextContext = fContext->createTextContext(fRenderTarget, this->getLeakyProperties(), useDFT);
 }
 
+void SkGpuDevice::setSurface(SkSurface_Gpu* surface) {
+    if (fDeviceOwnsSurface) {
+        SkRefCnt_SafeAssign(fSurface, surface);
+    } else {
+        fSurface = surface;
+    }
+}
+
 SkGpuDevice* SkGpuDevice::Create(GrContext* context, SkSurface::Budgeted budgeted,
                                  const SkImageInfo& info, int sampleCount,
                                  const SkSurfaceProps* props, unsigned flags) {
 
     SkAutoTUnref<GrRenderTarget> rt(SkSurface_Gpu::CreateRenderTarget(context, budgeted, info,
                                                                       sampleCount));
     if (!rt) {
         return NULL;
     }
 
@@ skipping 10 matching lines @@
     // The GrContext takes a ref on the target. We don't want to cause the render
     // target to be unnecessarily kept alive.
     if (fContext->getRenderTarget() == fRenderTarget) {
         fContext->setRenderTarget(NULL);
     }
 
     if (fContext->getClip() == &fClipData) {
         fContext->setClip(NULL);
     }
 
-    fRenderTarget->unref();
+    this->setSurface(NULL);
     fContext->unref();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
+void SkGpuDevice::discard() {
+    if (fSurface) {
+        fSurface->aboutToDraw(SkSurface::kDiscard_ContentChangeMode);
+    }
+}
+
 bool SkGpuDevice::onReadPixels(const SkImageInfo& dstInfo, void* dstPixels, size_t dstRowBytes,
                                int x, int y) {
     DO_DEFERRED_CLEAR();
 
     // TODO: teach fRenderTarget to take ImageInfo directly to specify the src pixels
     GrPixelConfig config = SkImageInfo2GrPixelConfig(dstInfo);
     if (kUnknown_GrPixelConfig == config) {
         return false;
     }
 
@@ skipping 39 matching lines @@
 void SkGpuDevice::onDetachFromCanvas() {
     INHERITED::onDetachFromCanvas();
     fClipData.fClipStack.reset(NULL);
 }
 
 // call this every draw call, to ensure that the context reflects our state,
 // and not the state from some other canvas/device
 void SkGpuDevice::prepareDraw(const SkDraw& draw) {
     SkASSERT(fClipData.fClipStack);
 
+    if (fSurface) {
+        fSurface->aboutToDraw(SkSurface::kRetain_ContentChangeMode);
+    }
+
     fContext->setRenderTarget(fRenderTarget);
 
     SkASSERT(draw.fClipStack && draw.fClipStack == fClipData.fClipStack);
 
     fClipData.fOrigin = this->getOrigin();
 
     fContext->setClip(&fClipData);
 
     DO_DEFERRED_CLEAR();
 }
@@ skipping 1515 matching lines @@
 }
 
 void SkGpuDevice::flush() {
     DO_DEFERRED_CLEAR();
     fRenderTarget->prepareForExternalRead();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkBaseDevice* SkGpuDevice::onCreateCompatibleDevice(const CreateInfo& cinfo) {
-    GrSurfaceDesc desc;
-    desc.fConfig = fRenderTarget->config();
-    desc.fFlags = kRenderTarget_GrSurfaceFlag;
-    desc.fWidth = cinfo.fInfo.width();
-    desc.fHeight = cinfo.fInfo.height();
-    desc.fSampleCnt = fRenderTarget->numSamples();
-
-    SkAutoTUnref<GrTexture> texture;
-    // Skia's convention is to only clear a device if it is non-opaque.
-    unsigned flags = cinfo.fInfo.isOpaque() ? 0 : kNeedClear_Flag;
-
-    // layers are never draw in repeat modes, so we can request an approx
-    // match and ignore any padding.
-    const GrContext::ScratchTexMatch match = (kSaveLayer_Usage == cinfo.fUsage) ?
-                                                GrContext::kApprox_ScratchTexMatch :
-                                                GrContext::kExact_ScratchTexMatch;
-    texture.reset(fContext->refScratchTexture(desc, match));
-
-    if (texture) {
-        SkSurfaceProps props(fSurfaceProps.flags(), cinfo.fPixelGeometry);
-        return SkGpuDevice::Create(texture->asRenderTarget(), &props, flags);
-    } else {
-        SkDebugf("---- failed to create compatible device texture [%d %d]\n",
-                 cinfo.fInfo.width(), cinfo.fInfo.height());
-        return NULL;
-    }
+    return fSurface->createCompatibleDeviceDeprecated(cinfo);
 }
 
 SkSurface* SkGpuDevice::newSurface(const SkImageInfo& info, const SkSurfaceProps& props) {
     // TODO: Change the signature of newSurface to take a budgeted parameter.
     static const SkSurface::Budgeted kBudgeted = SkSurface::kNo_Budgeted;
     return SkSurface::NewRenderTarget(fContext, kBudgeted, info, fRenderTarget->numSamples(),
                                       &props);
 }
 
 bool SkGpuDevice::EXPERIMENTAL_drawPicture(SkCanvas* mainCanvas, const SkPicture* mainPicture,
@@ skipping 55 matching lines @@
 #endif
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }
 
 #endif