Move canvas->surface association to the device subclasses

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->setSurface(this);
 }
 
 SkSurface_Gpu::~SkSurface_Gpu() {
+    // In case the device outlives this instance, make sure device does not try to access this.
+    fDevice->setSurface(NULL);
     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 25 matching lines @@
 // Create a new render target and, if necessary, copy the contents of the old
 // render target into it. Note that this flushes the SkGpuDevice but
 // doesn't force an OpenGL flush.
 void SkSurface_Gpu::onCopyOnWrite(ContentChangeMode mode) {
     GrRenderTarget* rt = fDevice->accessRenderTarget();
     // are we sharing our render target with the image? Note this call should never create a new
     // image because onCopyOnWrite is only called when there is a cached image.
     SkImage* image = this->getCachedImage(kNo_Budgeted);
     SkASSERT(image);
     if (rt->asTexture() == SkTextureImageGetTexture(image)) {
-        GrRenderTarget* oldRT = this->fDevice->accessRenderTarget();
-        SkSurface::Budgeted budgeted = oldRT->resourcePriv().isBudgeted() ? kYes_Budgeted :
-                kNo_Budgeted;
-        SkAutoTUnref<GrRenderTarget> newRT(
-            SkGpuDevice::CreateRenderTarget(oldRT->getContext(), budgeted, fDevice->imageInfo(),
-                                            oldRT->numSamples()));
-
-        if (kRetain_ContentChangeMode == mode && !oldRT->wasDestroyed() && newRT) {
-            oldRT->getContext()->copySurface(newRT, oldRT);
-        }
-
-        SkASSERT(this->getCachedCanvas());
-        SkASSERT(this->getCachedCanvas()->getDevice() == fDevice);
-
-        this->fDevice->swapRenderTarget(newRT);
-
+        fDevice->detachBackendRenderTarget(kRetain_ContentChangeMode == mode);
         SkTextureImageApplyBudgetedDecision(image);
     } else if (kDiscard_ContentChangeMode == mode) {
         this->SkSurface_Gpu::onDiscard();
     }
 }
 
 void SkSurface_Gpu::onDiscard() {
     fDevice->accessRenderTarget()->discard();
 }
 
@@ skipping 16 matching lines @@
         return NULL;
     }
     SkAutoTUnref<SkGpuDevice> device(SkGpuDevice::Create(rt, props, SkGpuDevice::kNeedClear_Flag));
     if (NULL == device) {
         return NULL;
     }
     return SkNEW_ARGS(SkSurface_Gpu, (device));
 }
 
 #endif