Add desired width & height to drawContext (as opposed to using the width & height of the RT)

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 109 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, const SkSurfaceProps* props,
+sk_sp<SkGpuDevice> SkGpuDevice::Make(int width, int height,
+                                     sk_sp<GrRenderTarget> rt, 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->drawContext(std::move(rt), props));
-    return sk_sp<SkGpuDevice>(new SkGpuDevice(std::move(drawContext), width, height, flags));
+    sk_sp<GrDrawContext> drawContext(context->drawContext(width, height, std::move(rt), props));
+    return sk_sp<SkGpuDevice>(new SkGpuDevice(std::move(drawContext), flags));
 }
 
 sk_sp<SkBaseDevice> 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<SkBaseDevice>(new SkGpuDevice(std::move(drawContext), flags));
 }
 
 sk_sp<SkGpuDevice> SkGpuDevice::Make(GrContext* context, SkBudgeted budgeted,
                                      const SkImageInfo& info, int sampleCount,
                                      const SkSurfaceProps* props, InitContents init) {
     unsigned flags;
     if (!CheckAlphaTypeAndGetFlags(&info, init, &flags)) {
         return nullptr;
     }
 
     sk_sp<GrDrawContext> drawContext(CreateDrawContext(context, budgeted, info,
                                                        sampleCount, props));
     if (!drawContext) {
         return nullptr;
     }
 
-    return sk_sp<SkGpuDevice>(new SkGpuDevice(std::move(drawContext),
-                                              info.width(), info.height(), flags));
+    return sk_sp<SkGpuDevice>(new SkGpuDevice(std::move(drawContext), flags));
 }
 
-SkGpuDevice::SkGpuDevice(sk_sp<GrDrawContext> drawContext, int width, int height, unsigned flags) 
+SkGpuDevice::SkGpuDevice(sk_sp<GrDrawContext> drawContext, unsigned flags) 
     : INHERITED(drawContext->surfaceProps())
     , fContext(SkRef(drawContext->accessRenderTarget()->getContext()))
     , fRenderTarget(drawContext->renderTarget())
     , fDrawContext(std::move(drawContext)) {
     fOpaque = SkToBool(flags & kIsOpaque_Flag);
 
     SkAlphaType at = fOpaque ? kOpaque_SkAlphaType : kPremul_SkAlphaType;
-    SkImageInfo info = fRenderTarget->surfacePriv().info(at).makeWH(width, height);
+    SkImageInfo info = fRenderTarget->surfacePriv().info(at).makeWH(fDrawContext->width(),
+                                                                    fDrawContext->height());
     SkPixelRef* pr = new SkGrPixelRef(info, fRenderTarget.get());
     fLegacyBitmap.setInfo(info);
     fLegacyBitmap.setPixelRef(pr)->unref();
-
+  
     if (flags & kNeedClear_Flag) {
         this->clearAll();
     }
 }
 
 sk_sp<GrDrawContext> SkGpuDevice::CreateDrawContext(GrContext* context,
                                                     SkBudgeted budgeted,
                                                     const SkImageInfo& origInfo,
                                                     int sampleCount,
                                                     const SkSurfaceProps* surfaceProps) {
@@ skipping 1676 matching lines @@
     if (!dc) {
         SkErrorInternals::SetError( kInternalError_SkError,
                                     "---- failed to create gpu device texture [%d %d]\n",
                                     cinfo.fInfo.width(), cinfo.fInfo.height());
         return nullptr;    
     }
 
     // Skia's convention is to only clear a device if it is non-opaque.
     InitContents init = cinfo.fInfo.isOpaque() ? kUninit_InitContents : kClear_InitContents;
 
-    return SkGpuDevice::Make(std::move(dc),
-                             cinfo.fInfo.width(), cinfo.fInfo.height(),
-                             init).release();
+    return SkGpuDevice::Make(std::move(dc), 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);
 }
 
 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