(Mostly) Retract GrRenderTarget from SkGpuDevice

src/gpu/SkGpuDevice.h

 /*
  * Copyright 2010 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkGpuDevice_DEFINED
 #define SkGpuDevice_DEFINED
 
@@ skipping 18 matching lines @@
  */
 class SK_API SkGpuDevice : public SkBaseDevice {
 public:
     enum InitContents {
         kClear_InitContents,
         kUninit_InitContents
     };
 
     /**
      * Creates an SkGpuDevice from a GrRenderTarget.
+     * TODO: rm this factory. It is used by SkSurface::MakeRenderTargetDirect,
+     *       MakeFromBackendTexture, MakeFromBackendRenderTarget,
+     *       and MakeFromBackendTextureAsRenderTarget. Only the first is worrisome.
      */
     static sk_sp<SkGpuDevice> Make(sk_sp<GrRenderTarget> target, 
                                    const SkSurfaceProps*,
                                    InitContents);
 
     /**
-     * Creates an SkGpuDevice from a GrRenderTarget whose texture width/height is
+     * Creates an SkGpuDevice from a GrDrawContext whose backing width/height is
      * different than its actual width/height (e.g., approx-match scratch texture).
      */
-    static sk_sp<SkGpuDevice> Make(sk_sp<GrRenderTarget> target, int width, int height,
-                                   const SkSurfaceProps*, InitContents);
+    static sk_sp<SkBaseDevice> Make(sk_sp<GrDrawContext> drawContext,
+                                    int width, int height,
+                                    InitContents);
 
     /**
      * New device that will create an offscreen renderTarget based on the ImageInfo and
      * sampleCount. The Budgeted param controls whether the device's backing store counts against
      * the resource cache budget. On failure, returns nullptr.
      */
     static sk_sp<SkGpuDevice> Make(GrContext*, SkBudgeted, const SkImageInfo&,
                                    int sampleCount, const SkSurfaceProps*, InitContents);
 
     ~SkGpuDevice() override {}
 
     SkGpuDevice* cloneDevice(const SkSurfaceProps& props) {
         SkBaseDevice* dev = this->onCreateDevice(CreateInfo(this->imageInfo(), kPossible_TileUsage,
                                                             props.pixelGeometry()),
                                                  nullptr);
         return static_cast<SkGpuDevice*>(dev);
     }
 
     GrContext* context() const override { return fContext; }
 
     // set all pixels to 0
     void clearAll();
 
-    void replaceRenderTarget(bool shouldRetainContent);
+    void replaceDrawContext(bool shouldRetainContent);
 
     GrRenderTarget* accessRenderTarget() override;
     GrDrawContext* accessDrawContext() override;
 
     SkImageInfo imageInfo() const override {
         return fLegacyBitmap.info();
     }
 
     void drawPaint(const SkDraw&, const SkPaint& paint) override;
     virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count,
@@ skipping 57 matching lines @@
     bool onWritePixels(const SkImageInfo&, const void*, size_t, int, int) override;
     bool onShouldDisableLCD(const SkPaint&) const final;
 
     /**  PRIVATE / EXPERIMENTAL -- do not call */
     virtual bool EXPERIMENTAL_drawPicture(SkCanvas* canvas, const SkPicture* picture,
                                           const SkMatrix*, const SkPaint*) override;
 
 private:
     // We want these unreffed in DrawContext, RenderTarget, GrContext order.
     SkAutoTUnref<GrContext>         fContext;
-    SkAutoTUnref<GrRenderTarget>    fRenderTarget;
+    sk_sp<GrRenderTarget>           fRenderTarget;
     sk_sp<GrDrawContext>            fDrawContext;
 
     SkAutoTUnref<const SkClipStack> fClipStack;
     SkIPoint                        fClipOrigin;
     GrClipStackClip                 fClip;
     // remove when our clients don't rely on accessBitmap()
     SkBitmap                        fLegacyBitmap;
     bool                            fOpaque;
 
     enum Flags {
         kNeedClear_Flag = 1 << 0,  //!< Surface requires an initial clear
         kIsOpaque_Flag  = 1 << 1,  //!< Hint from client that rendering to this device will be
                                    //   opaque even if the config supports alpha.
     };
     static bool CheckAlphaTypeAndGetFlags(const SkImageInfo* info, InitContents init,
                                           unsigned* flags);
 
-    SkGpuDevice(GrRenderTarget*, int width, int height, const SkSurfaceProps*, unsigned flags);
+    SkGpuDevice(sk_sp<GrDrawContext>, int width, int height, unsigned flags);
 
     SkBaseDevice* onCreateDevice(const CreateInfo&, const SkPaint*) override;
 
     sk_sp<SkSurface> makeSurface(const SkImageInfo&, const SkSurfaceProps&) override;
 
     SkImageFilterCache* getImageFilterCache() override;
 
     bool forceConservativeRasterClip() const override { return true; }
 
     // sets the render target and clip on context
@@ skipping 62 matching lines @@
                                  const SkPaint&);
 
     bool drawFilledDRRect(const SkMatrix& viewMatrix, const SkRRect& outer,
                           const SkRRect& inner, const SkPaint& paint);
 
     void drawProducerNine(const SkDraw&, GrTextureProducer*, const SkIRect& center,
                           const SkRect& dst, const SkPaint&);
 
     bool drawDashLine(const SkPoint pts[2], const SkPaint& paint);
 
-    static GrRenderTarget* CreateRenderTarget(GrContext*, SkBudgeted, const SkImageInfo&,
-                                              int sampleCount);
+    static sk_sp<GrDrawContext> CreateDrawContext(GrContext*,
+                                                  SkBudgeted,
+                                                  const SkImageInfo&,
+                                                  int sampleCount,
+                                                  const SkSurfaceProps*);
 
     void drawSpriteWithFilter(const SkDraw&, const SkBitmap&, int x, int y,
                               const SkPaint&) override;
 
     friend class GrAtlasTextContext;
     friend class SkSurface_Gpu;      // for access to surfaceProps
     typedef SkBaseDevice INHERITED;
 };
 
 #endif