Simplify SkGpuDevice construction

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 116 matching lines @@
 public:
     GrContext* fContext;
     GrTextContext* fTextContext;
     GrFontScaler* fFontScaler;  // cached in the skia glyphcache
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkGpuDevice* SkGpuDevice::Create(GrSurface* surface, unsigned flags) {
     SkASSERT(NULL != surface);
-    if (NULL == surface->asRenderTarget() || NULL == surface->getContext()) {
+    if (NULL == surface->asRenderTarget() || surface->wasDestroyed()) {
         return NULL;
     }
-    if (surface->asTexture()) {
-        return SkNEW_ARGS(SkGpuDevice, (surface->getContext(), surface->asTexture(), flags));
-    } else {
-        return SkNEW_ARGS(SkGpuDevice, (surface->getContext(), surface->asRenderTarget(), flags));
-    }
+    return SkNEW_ARGS(SkGpuDevice, (surface, flags));
 }
 
-SkGpuDevice::SkGpuDevice(GrContext* context, GrTexture* texture, unsigned flags) {
-    this->initFromRenderTarget(context, texture->asRenderTarget(), flags);
-}
+SkGpuDevice::SkGpuDevice(GrSurface* surface, unsigned flags) {
 
-SkGpuDevice::SkGpuDevice(GrContext* context, GrRenderTarget* renderTarget, unsigned flags) {
-    this->initFromRenderTarget(context, renderTarget, flags);
-}
-
-void SkGpuDevice::initFromRenderTarget(GrContext* context,
-                                       GrRenderTarget* renderTarget,
-                                       unsigned flags) {
     fDrawProcs = NULL;
 
-    fContext = context;
-    fContext->ref();
+    fContext = SkRef(surface->getContext());
 
-    fRenderTarget = NULL;
     fNeedClear = flags & kNeedClear_Flag;
 
-    SkASSERT(NULL != renderTarget);
-    fRenderTarget = renderTarget;
-    fRenderTarget->ref();
+    fRenderTarget = SkRef(surface->asRenderTarget());
 
     // Hold onto to the texture in the pixel ref (if there is one) because the texture holds a ref
     // on the RT but not vice-versa.
     // TODO: Remove this trickery once we figure out how to make SkGrPixelRef do this without
     // busting chrome (for a currently unknown reason).
-    GrSurface* surface = fRenderTarget->asTexture();
+    surface = fRenderTarget->asTexture();
     if (NULL == surface) {
         surface = fRenderTarget;
     }
 
     SkPixelRef* pr = SkNEW_ARGS(SkGrPixelRef,
                                 (surface->info(), surface, SkToBool(flags & kCached_Flag)));
     fLegacyBitmap.setInfo(surface->info());
     fLegacyBitmap.setPixelRef(pr)->unref();
 
     bool useDFFonts = !!(flags & kDFFonts_Flag);
@@ skipping 25 matching lines @@
     desc.fWidth = info.width();
     desc.fHeight = info.height();
     desc.fConfig = SkImageInfo2GrPixelConfig(info);
     desc.fSampleCnt = sampleCount;
 
     SkAutoTUnref<GrTexture> texture(context->createUncachedTexture(desc, NULL, 0));
     if (!texture.get()) {
         return NULL;
     }
 
-    return SkNEW_ARGS(SkGpuDevice, (context, texture.get()));
+    return SkNEW_ARGS(SkGpuDevice, (texture.get()));
 }
 
 SkGpuDevice::~SkGpuDevice() {
     if (fDrawProcs) {
         delete fDrawProcs;
     }
 
     delete fMainTextContext;
     delete fFallbackTextContext;
 
     // 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);
     }
 
-    SkSafeUnref(fRenderTarget);
+    fRenderTarget->unref();
     fContext->unref();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-void SkGpuDevice::makeRenderTargetCurrent() {
-    DO_DEFERRED_CLEAR();
-    fContext->setRenderTarget(fRenderTarget);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
 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 1909 matching lines @@
 
     fContext->getLayerCache()->purgeAll();
 #endif
 }
 
 SkImageFilter::Cache* SkGpuDevice::getImageFilterCache() {
     // We always return a transient cache, so it is freed after each
     // filter traversal.
     return SkImageFilter::Cache::Create(kDefaultImageFilterCacheSize);
 }