Remove SkSurface::MakeRenderTargetDirect

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 "GrContextPriv.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"
@@ skipping 59 matching lines @@
             default: // If it is unpremul or unknown don't try to render
                 return false;
         }
     }
     if (kClear_InitContents == init) {
         *flags |= kNeedClear_Flag;
     }
     return true;
 }
 
-sk_sp<SkGpuDevice> SkGpuDevice::Make(sk_sp<GrRenderTarget> rt, sk_sp<SkColorSpace> colorSpace,
-                                     const SkSurfaceProps* props, InitContents init) {
-    if (!rt || rt->wasDestroyed() || !rt->getContext()) {
-        return nullptr;
-    }
-    unsigned flags;
-    if (!CheckAlphaTypeAndGetFlags(nullptr, init, &flags)) {
-        return nullptr;
-    }
-
-    const int width = rt->width();
-    const int height = rt->height();
-
-    GrContext* context = rt->getContext();
-
-    sk_sp<GrDrawContext> drawContext(context->contextPriv().makeWrappedDrawContext(
-                                                                            std::move(rt),
-                                                                            std::move(colorSpace),
-                                                                            props));
-    return sk_sp<SkGpuDevice>(new SkGpuDevice(std::move(drawContext), width, height, flags));
-}
-
-sk_sp<SkBaseDevice> SkGpuDevice::Make(sk_sp<GrDrawContext> drawContext,
-                                      int width, int height,
-                                      InitContents init) {
+sk_sp<SkGpuDevice> SkGpuDevice::Make(sk_sp<GrDrawContext> drawContext,
+                                     int width, int height,
+                                     InitContents init) {
     if (!drawContext || drawContext->wasAbandoned()) {
         return nullptr;
     }
     unsigned flags;
     if (!CheckAlphaTypeAndGetFlags(nullptr, init, &flags)) {
         return nullptr;
     }
-    return sk_sp<SkBaseDevice>(new SkGpuDevice(std::move(drawContext), width, height, flags));
+    return sk_sp<SkGpuDevice>(new SkGpuDevice(std::move(drawContext), width, height, flags));
 }
 
 sk_sp<SkGpuDevice> SkGpuDevice::Make(GrContext* context, SkBudgeted budgeted,
                                      const SkImageInfo& info, int sampleCount,
                                      GrSurfaceOrigin origin,
                                      const SkSurfaceProps* props, InitContents init) {
     unsigned flags;
     if (!CheckAlphaTypeAndGetFlags(&info, init, &flags)) {
         return nullptr;
     }
@@ skipping 103 matching lines @@
     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;
     }
-    fDrawContext->accessRenderTarget()->writePixels(x, y, info.width(), info.height(),
-                                                    config, pixels, rowBytes, flags);
-    return true;
+    return fDrawContext->accessRenderTarget()->writePixels(x, y, info.width(), info.height(),
+                                                           config, pixels, rowBytes, flags);
 }
 
 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
 void SkGpuDevice::prepareDraw(const SkDraw& draw) {
@@ skipping 1514 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