Remove GrRenderTarget member variable from SkGpuDevice

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 "GrBlurUtils.h"
 #include "GrContext.h"
-#include "SkDraw.h"
+#include "GrDrawContextPriv.h"
 #include "GrGpu.h"
 #include "GrGpuResourcePriv.h"
 #include "GrImageIDTextureAdjuster.h"
 #include "GrStyle.h"
 #include "GrTracing.h"
+
 #include "SkCanvasPriv.h"
+#include "SkDraw.h"
 #include "SkErrorInternals.h"
 #include "SkGlyphCache.h"
 #include "SkGr.h"
 #include "SkGrPriv.h"
 #include "SkImage_Base.h"
 #include "SkImageCacherator.h"
 #include "SkImageFilter.h"
 #include "SkImageFilterCache.h"
 #include "SkLatticeIter.h"
 #include "SkMaskFilter.h"
@@ skipping 108 matching lines @@
         return nullptr;
     }
 
     return sk_sp<SkGpuDevice>(new SkGpuDevice(std::move(drawContext),
                                               info.width(), info.height(), flags));
 }
 
 SkGpuDevice::SkGpuDevice(sk_sp<GrDrawContext> drawContext, int width, int height, unsigned flags) 
     : INHERITED(drawContext->surfaceProps())
     , fContext(SkRef(drawContext->accessRenderTarget()->getContext()))
-    , fRenderTarget(drawContext->renderTarget())
     , fDrawContext(std::move(drawContext)) {
     fSize.set(width, height);
     fOpaque = SkToBool(flags & kIsOpaque_Flag);
 
     if (flags & kNeedClear_Flag) {
         this->clearAll();
     }
 }
 
 sk_sp<GrDrawContext> SkGpuDevice::MakeDrawContext(GrContext* context,
@@ skipping 61 matching lines @@
     // TODO: teach fRenderTarget to take ImageInfo directly to specify the src pixels
     GrPixelConfig config = SkImageInfo2GrPixelConfig(dstInfo, *fContext->caps());
     if (kUnknown_GrPixelConfig == config) {
         return false;
     }
 
     uint32_t flags = 0;
     if (kUnpremul_SkAlphaType == dstInfo.alphaType()) {
         flags = GrContext::kUnpremul_PixelOpsFlag;
     }
-    return fRenderTarget->readPixels(x, y, dstInfo.width(), dstInfo.height(), config, dstPixels,
-                                     dstRowBytes, flags);
+    return fDrawContext->accessRenderTarget()->readPixels(x, y,
+                                                          dstInfo.width(), dstInfo.height(),
+                                                          config, dstPixels,
+                                                          dstRowBytes, flags);
 }
 
 bool SkGpuDevice::onWritePixels(const SkImageInfo& info, const void* pixels, size_t rowBytes,
                                 int x, int y) {
     ASSERT_SINGLE_OWNER
     // TODO: teach fRenderTarget to take ImageInfo directly to specify the src pixels
     GrPixelConfig config = SkImageInfo2GrPixelConfig(info, *fContext->caps());
     if (kUnknown_GrPixelConfig == config) {
         return false;
     }
     uint32_t flags = 0;
     if (kUnpremul_SkAlphaType == info.alphaType()) {
         flags = GrContext::kUnpremul_PixelOpsFlag;
     }
-    fRenderTarget->writePixels(x, y, info.width(), info.height(), config, pixels, rowBytes, flags);
-
+    fDrawContext->accessRenderTarget()->writePixels(x, y, info.width(), info.height(),
+                                                    config, pixels, rowBytes, flags);
     return true;
 }
 
 bool SkGpuDevice::onAccessPixels(SkPixmap* pmap) {
     ASSERT_SINGLE_OWNER
     return false;
 }
 
 // call this every draw call, to ensure that the context reflects our state,
 // and not the state from some other canvas/device
@@ skipping 12 matching lines @@
     ASSERT_SINGLE_OWNER
     GrColor color = 0;
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "clearAll", fContext);
     SkIRect rect = SkIRect::MakeWH(this->width(), this->height());
     fDrawContext->clear(&rect, color, true);
 }
 
 void SkGpuDevice::replaceDrawContext(bool shouldRetainContent) {
     ASSERT_SINGLE_OWNER
 
-    SkBudgeted budgeted = fRenderTarget->resourcePriv().isBudgeted();
+    SkBudgeted budgeted = fDrawContext->drawContextPriv().isBudgeted();
 
     sk_sp<GrDrawContext> newDC(MakeDrawContext(this->context(), 
                                                budgeted,
                                                this->imageInfo(),
                                                fDrawContext->numColorSamples(),
                                                fDrawContext->origin(),
                                                &this->surfaceProps()));
     if (!newDC) {
         return;
     }
 
     if (shouldRetainContent) {
-        if (fRenderTarget->wasDestroyed()) {
+        if (fDrawContext->wasAbandoned()) {

[egdaniel, 2016/08/03 19:55:06]

is there an actual difference in what abandoned vs destroyed means here?

[robertphillips, 2016/08/03 20:36:10]

The two (public) ways to get into the GrGpuResource-destroyed state are:
GrContext::abandonContext and GrContext::releaseResourcesAndAbandonContext. In
both cases the drawingMgr is abandoned first.

             return;
         }
         newDC->copySurface(fDrawContext->asTexture().get(),
                            SkIRect::MakeWH(this->width(), this->height()),
                            SkIPoint::Make(0, 0));
     }
 
-    SkASSERT(fDrawContext->accessRenderTarget() != newDC->accessRenderTarget());
-
-    fRenderTarget = newDC->renderTarget();
-
     fDrawContext = newDC;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 void SkGpuDevice::drawPaint(const SkDraw& draw, const SkPaint& paint) {
     ASSERT_SINGLE_OWNER
     CHECK_SHOULD_DRAW(draw);
     GR_CREATE_TRACE_MARKER_CONTEXT("SkGpuDevice", "drawPaint", fContext);
 
@@ skipping 1462 matching lines @@
 }
 
 SkImageFilterCache* SkGpuDevice::getImageFilterCache() {
     ASSERT_SINGLE_OWNER
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilterCache::Create(kDefaultImageFilterCacheSize);
 }
 
 #endif