Move canvas->surface association to the device subclasses

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"
 #include "effects/GrDashingEffect.h"
 #include "effects/GrPorterDuffXferProcessor.h"
 #include "effects/GrTextureDomain.h"
 #include "effects/GrSimpleTextureEffect.h"
 
 #include "GrContext.h"
 #include "GrBitmapTextContext.h"
 #include "GrDistanceFieldTextContext.h"
+#include "GrGpuResourcePriv.h"
 #include "GrLayerHoister.h"
 #include "GrRecordReplaceDraw.h"
 #include "GrStrokeInfo.h"
 #include "GrTracing.h"
 #include "GrGpu.h"
 
 #include "SkGrTexturePixelRef.h"
 
 #include "SkCanvasPriv.h"
 #include "SkDeviceImageFilterProxy.h"
 #include "SkDrawProcs.h"
 #include "SkGlyphCache.h"
 #include "SkImageFilter.h"
 #include "SkLayerInfo.h"
 #include "SkMaskFilter.h"
 #include "SkPathEffect.h"
 #include "SkPicture.h"
 #include "SkPictureData.h"
 #include "SkRecord.h"
 #include "SkRRect.h"
 #include "SkStroke.h"
 #include "SkSurface.h"
 #include "SkSurface_Gpu.h"
 #include "SkTLazy.h"
 #include "SkUtils.h"
 #include "SkVertState.h"
 #include "SkXfermode.h"
 #include "SkErrorInternals.h"
 
+
 #if SK_SUPPORT_GPU
 
 enum { kDefaultImageFilterCacheSize = 32 * 1024 * 1024 };
 
 #if 0
     extern bool (*gShouldDrawProc)();
     #define CHECK_SHOULD_DRAW(draw)                             \
         do {                                                    \
             if (gShouldDrawProc && !gShouldDrawProc()) return;  \
             this->prepareDraw(draw);                            \
@@ skipping 84 matching lines @@
     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)
 {
     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));
@@ skipping 64 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();
     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 38 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();
 }
 
 GrRenderTarget* SkGpuDevice::accessRenderTarget() {
     DO_DEFERRED_CLEAR();
     return fRenderTarget;
 }
 
 void SkGpuDevice::clearAll() {
     GrColor color = 0;
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice::clearAll", fContext);
     SkIRect rect = SkIRect::MakeWH(this->width(), this->height());
     fContext->clear(&rect, color, true, fRenderTarget);
     fNeedClear = false;
 }
 
-void SkGpuDevice::swapRenderTarget(GrRenderTarget* newRenderTarget) {
+void SkGpuDevice::detachBackendRenderTarget(bool retainContent) {
     SkASSERT(!fNeedClear);
     if (fContext->getRenderTarget() == fRenderTarget) {
         fContext->setRenderTarget(NULL);
     }
-    SkRefCnt_SafeAssign(fRenderTarget, newRenderTarget);
-    SkASSERT(newRenderTarget->surfacePriv().info() == fLegacyBitmap.info());
-    SkPixelRef* pr = SkNEW_ARGS(SkGrPixelRef, (newRenderTarget->surfacePriv().info(),
-                                               newRenderTarget));
-    fLegacyBitmap.setPixelRef(pr)->unref();
+
+    GrRenderTarget* oldRT = fRenderTarget;
+    SkSurface::Budgeted budgeted = oldRT->resourcePriv().isBudgeted() ? SkSurface::kYes_Budgeted :
+            SkSurface::kNo_Budgeted;
+
+    GrRenderTarget* newRT = CreateRenderTarget(oldRT->getContext(), budgeted, this->imageInfo(),
+                                               oldRT->numSamples());
+    if (newRT) {
+        if (retainContent && !oldRT->wasDestroyed()) {
+            oldRT->getContext()->copySurface(newRT, oldRT);
+        }
+
+        if (fRenderTarget != newRT) {
+            fRenderTarget->unref();
+            fRenderTarget = newRT;
+        }
+
+        SkASSERT(newRT->surfacePriv().info() == fLegacyBitmap.info());
+        SkPixelRef* pr = SkNEW_ARGS(SkGrPixelRef, (newRT->surfacePriv().info(),
+                                                   newRT));
+        fLegacyBitmap.setPixelRef(pr)->unref();
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SK_COMPILE_ASSERT(SkShader::kNone_BitmapType == 0, shader_type_mismatch);
 SK_COMPILE_ASSERT(SkShader::kDefault_BitmapType == 1, shader_type_mismatch);
 SK_COMPILE_ASSERT(SkShader::kRadial_BitmapType == 2, shader_type_mismatch);
 SK_COMPILE_ASSERT(SkShader::kSweep_BitmapType == 3, shader_type_mismatch);
 SK_COMPILE_ASSERT(SkShader::kTwoPointRadial_BitmapType == 4,
                   shader_type_mismatch);
@@ skipping 1582 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