Reduce usage of 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"
@@ skipping 106 matching lines @@
     }
     unsigned flags;
     if (!CheckAlphaTypeAndGetFlags(nullptr, init, &flags)) {
         return nullptr;
     }
     return sk_sp<SkBaseDevice>(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;
     }
 
-    sk_sp<GrDrawContext> drawContext(CreateDrawContext(context, budgeted, info,
-                                                       sampleCount, props));
+    sk_sp<GrDrawContext> drawContext(MakeDrawContext(context, budgeted, info,
+                                                     sampleCount, origin, props));
     if (!drawContext) {
         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::CreateDrawContext(GrContext* context,
-                                                    SkBudgeted budgeted,
-                                                    const SkImageInfo& origInfo,
-                                                    int sampleCount,
-                                                    const SkSurfaceProps* surfaceProps) {
+sk_sp<GrDrawContext> SkGpuDevice::MakeDrawContext(GrContext* context,
+                                                  SkBudgeted budgeted,
+                                                  const SkImageInfo& origInfo,
+                                                  int sampleCount,
+                                                  GrSurfaceOrigin origin,
+                                                  const SkSurfaceProps* surfaceProps) {
     if (kUnknown_SkColorType == origInfo.colorType() ||
         origInfo.width() < 0 || origInfo.height() < 0) {
         return nullptr;
     }
 
     if (!context) {
         return nullptr;
     }
 
     SkColorType ct = origInfo.colorType();
@@ skipping 10 matching lines @@
     if (!context->caps()->isConfigRenderable(origConfig, sampleCount > 0)) {
         // Fall back from whatever ct was to default of kRGBA or kBGRA which is aliased as kN32
         ct = kN32_SkColorType;
     }
 
     GrPixelConfig config = SkImageInfo2GrPixelConfig(ct, at, cs, *context->caps());
 
     return context->newDrawContext(SkBackingFit::kExact,               // Why exact?
                                    origInfo.width(), origInfo.height(),
                                    config, sk_ref_sp(cs), sampleCount,
-                                   kDefault_GrSurfaceOrigin, surfaceProps, budgeted);
+                                   origin, surfaceProps, budgeted);
 }
 
 sk_sp<SkSpecialImage> SkGpuDevice::filterTexture(const SkDraw& draw,
                                                  SkSpecialImage* srcImg,
                                                  int left, int top,
                                                  SkIPoint* offset,
                                                  const SkImageFilter* filter) {
     SkASSERT(srcImg->isTextureBacked());
     SkASSERT(filter);
 
@@ skipping 67 matching lines @@
     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();
 
-    sk_sp<GrDrawContext> newDC(CreateDrawContext(this->context(), 
-                                                 budgeted,
-                                                 this->imageInfo(),
-                                                 fDrawContext->numColorSamples(),
-                                                 &this->surfaceProps()));
+    sk_sp<GrDrawContext> newDC(MakeDrawContext(this->context(), 
+                                               budgeted,
+                                               this->imageInfo(),
+                                               fDrawContext->numColorSamples(),
+                                               fDrawContext->origin(),
+                                               &this->surfaceProps()));
     if (!newDC) {
         return;
     }
 
     if (shouldRetainContent) {
         if (fRenderTarget->wasDestroyed()) {
             return;
         }
         newDC->copySurface(fDrawContext->asTexture().get(),
                            SkIRect::MakeWH(this->width(), this->height()),
@@ skipping 1468 matching lines @@
     return SkGpuDevice::Make(std::move(dc),
                              cinfo.fInfo.width(), cinfo.fInfo.height(),
                              init).release();
 }
 
 sk_sp<SkSurface> SkGpuDevice::makeSurface(const SkImageInfo& info, const SkSurfaceProps& props) {
     ASSERT_SINGLE_OWNER
     // TODO: Change the signature of newSurface to take a budgeted parameter.
     static const SkBudgeted kBudgeted = SkBudgeted::kNo;
     return SkSurface::MakeRenderTarget(fContext, kBudgeted, info, fDrawContext->desc().fSampleCnt,
-                                       &props);
+                                       fDrawContext->origin(), &props);
 }
 
 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