Implement approx-match support in image filter saveLayer() offscreen.

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 23 matching lines @@
     enum Flags {
         kNeedClear_Flag = 1 << 0,  //!< Surface requires an initial clear
     };
 
     /**
      * Creates an SkGpuDevice from a GrRenderTarget.
      */
     static SkGpuDevice* Create(GrRenderTarget* target, const SkSurfaceProps*, unsigned flags = 0);
 
     /**
+     * Creates an SkGpuDevice from a GrRenderTarget whose texture width/height is 
+     * different than its actual width/height (e.g., approx-match scratch texture).
+     */
+    static SkGpuDevice* Create(GrRenderTarget* target, int width, int height,
+                               const SkSurfaceProps*, unsigned flags = 0);
+
+    /**
      * 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 NULL.
      */
     static SkGpuDevice* Create(GrContext*, SkSurface::Budgeted, const SkImageInfo&,
                                int sampleCount, const SkSurfaceProps*, unsigned flags = 0);
 
     virtual ~SkGpuDevice();
 
     SkGpuDevice* cloneDevice(const SkSurfaceProps& props) {
         SkBaseDevice* dev = this->onCreateDevice(CreateInfo(this->imageInfo(), kPossible_TileUsage,
                                                             props.pixelGeometry()),
                                                  NULL);
         return static_cast<SkGpuDevice*>(dev);
     }
 
     GrContext* context() const { return fContext; }
 
     // set all pixels to 0
     void clearAll();
 
     void replaceRenderTarget(bool shouldRetainContent);
 
     GrRenderTarget* accessRenderTarget() override;
 
     SkImageInfo imageInfo() const override {
-        return fRenderTarget ? fRenderTarget->surfacePriv().info() : SkImageInfo::MakeUnknown();
+        return fLegacyBitmap.info();
     }
 
     const SkSurfaceProps& surfaceProps() const { return fSurfaceProps; }
 
     void drawPaint(const SkDraw&, const SkPaint& paint) override;
     virtual void drawPoints(const SkDraw&, SkCanvas::PointMode mode, size_t count,
                             const SkPoint[], const SkPaint& paint) override;
     virtual void drawRect(const SkDraw&, const SkRect& r,
                           const SkPaint& paint) override;
     virtual void drawRRect(const SkDraw&, const SkRRect& r,
@@ skipping 33 matching lines @@
     void onAttachToCanvas(SkCanvas* canvas) override;
     void onDetachFromCanvas() override;
 
     const SkBitmap& onAccessBitmap() override;
 
     bool canHandleImageFilter(const SkImageFilter*) override;
     virtual bool filterImage(const SkImageFilter*, const SkBitmap&,
                              const SkImageFilter::Context&,
                              SkBitmap*, SkIPoint*) override;
 
-    bool filterTexture(GrContext*, GrTexture*, const SkImageFilter*,
+    bool filterTexture(GrContext*, GrTexture*, int width, int height, const SkImageFilter*,
                        const SkImageFilter::Context&,
                        SkBitmap* result, SkIPoint* offset);
 
 protected:
     bool onReadPixels(const SkImageInfo&, void*, size_t, int, int) override;
     bool onWritePixels(const SkImageInfo&, const void*, size_t, int, int) override;
     bool onShouldDisableLCD(const SkPaint&) const override;
 
     /**  PRIVATE / EXPERIMENTAL -- do not call */
     virtual bool EXPERIMENTAL_drawPicture(SkCanvas* canvas, const SkPicture* picture,
                                           const SkMatrix*, const SkPaint*) override;
 
 private:
     GrContext*                      fContext;
     GrSkDrawProcs*                  fDrawProcs;
     SkAutoTUnref<const SkClipStack> fClipStack;
     SkIPoint                        fClipOrigin;
     GrClip                          fClip;
     GrTextContext*                  fTextContext;
     SkSurfaceProps                  fSurfaceProps;
     GrRenderTarget*                 fRenderTarget;
     // remove when our clients don't rely on accessBitmap()
     SkBitmap                        fLegacyBitmap;
     bool                            fNeedClear;
 
-    SkGpuDevice(GrRenderTarget*, const SkSurfaceProps*, unsigned flags);
+    SkGpuDevice(GrRenderTarget*, int width, int height, const SkSurfaceProps*, unsigned flags);
 
     SkBaseDevice* onCreateDevice(const CreateInfo&, const SkPaint*) override;
 
     SkSurface* newSurface(const SkImageInfo&, const SkSurfaceProps&) override;
 
     SkImageFilter::Cache* getImageFilterCache() override;
 
     bool forceConservativeRasterClip() const override { return true; }
 
     // sets the render target and clip on context
@@ skipping 49 matching lines @@
     static SkPicture::AccelData::Key ComputeAccelDataKey();
 
     static GrRenderTarget* CreateRenderTarget(GrContext*, SkSurface::Budgeted, const SkImageInfo&,
                                               int sampleCount);
 
     friend class GrTextContext;
     typedef SkBaseDevice INHERITED;
 };
 
 #endif