tunnel down texture-size-constraint to imagefilters

src/image/SkImage_Gpu.cpp

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkBitmapCache.h"
 #include "SkImage_Gpu.h"
 #include "GrCaps.h"
 #include "GrContext.h"
 #include "GrDrawContext.h"
 #include "GrTextureParamsAdjuster.h"
 #include "effects/GrYUVtoRGBEffect.h"
 #include "SkCanvas.h"
 #include "SkGpuDevice.h"
 #include "SkGr.h"
 #include "SkPixelRef.h"
 
 SkImage_Gpu::SkImage_Gpu(int w, int h, uint32_t uniqueID, SkAlphaType at, GrTexture* tex,
                          SkSurface::Budgeted budgeted)
     : INHERITED(w, h, uniqueID)
     , fTexture(SkRef(tex))
     , fAlphaType(at)
     , fBudgeted(budgeted)
     , fAddedRasterVersionToCache(false)
-    {}
+{
+    // At the moment, we can't handle general transformations on textures (e.g. tiling,
+    // mip/filtering) unless they are exactly sized to match the "logical" size (image size).
+    // Hence these asserts.
+    SkASSERT(tex->width() == w);
+    SkASSERT(tex->height() == h);
+}
 
 SkImage_Gpu::~SkImage_Gpu() {
     if (fAddedRasterVersionToCache.load()) {
         SkNotifyBitmapGenIDIsStale(this->uniqueID());
     }
 }
 
 extern void SkTextureImageApplyBudgetedDecision(SkImage* image) {
     if (as_IB(image)->getTexture()) {
         ((SkImage_Gpu*)image)->applyBudgetDecision();
@@ skipping 142 matching lines @@
     return new SkImage_Gpu(desc.fWidth, desc.fHeight, kNeedNewImageUniqueID, fAlphaType, subTx,
                            fBudgeted);
 }
 
 ///////////////////////////////////////////////////////////////////////////////////////////////////
 
 #include "SkGrPixelRef.h"
 #include "SkImageFilter.h"
 
 class SkGpuImageFilterProxy : public SkImageFilter::Proxy {
-    GrContext* fCtx;
-
 public:
-    SkGpuImageFilterProxy(GrContext* ctx) : fCtx(ctx) {}
+    SkGpuImageFilterProxy(GrContext* ctx, bool requireExactTexSize)
+        : INHERITED(requireExactTexSize), fCtx(ctx)
+    {}
 
     SkBaseDevice* createDevice(int width, int height) override {
         GrSurfaceDesc desc;
         desc.fConfig = kSkia8888_GrPixelConfig;
         desc.fFlags = kRenderTarget_GrSurfaceFlag;
         desc.fWidth = width;
         desc.fHeight = height;
         desc.fSampleCnt = 0;
 
         SkAutoTUnref<GrTexture> texture(fCtx->textureProvider()->createTexture(desc, true));
 
         if (texture) {
             SkSurfaceProps props(0, kUnknown_SkPixelGeometry);
             return SkGpuDevice::Create(texture->asRenderTarget(), width, height, &props,
                                        SkGpuDevice::kClear_InitContents);
         } else {
             return nullptr;
         }
     }
 
     bool filterImage(const SkImageFilter* filter, const SkBitmap& src,
                      const SkImageFilter::Context& ctx, SkBitmap* dst, SkIPoint* offset) override {
         return filter->canFilterImageGPU() &&
                filter->filterImageGPU(this, src, ctx, dst, offset);
     }
+
+private:
+    GrContext* fCtx;
+
+    typedef Proxy INHERITED;
 };
 
 static SkIRect compute_fast_ibounds(SkImageFilter* filter, const SkIRect& srcBounds) {
     SkRect fastBounds;
     fastBounds.set(srcBounds);
     filter->computeFastBounds(fastBounds, &fastBounds);
     return fastBounds.roundOut();
 }
 
 SkImage* SkImage_Gpu::onApplyFilter(SkImageFilter* filter, SkIPoint* offsetResult,
                                     bool forceResultToOriginalSize) const {
     const SkIRect srcBounds = SkIRect::MakeWH(this->width(), this->height());
 
     if (forceResultToOriginalSize) {
         SkBitmap src;
         GrWrapTextureInBitmap(fTexture, this->width(), this->height(), this->isOpaque(), &src);
 
-        const SkIRect clipBounds = srcBounds;
-        SkGpuImageFilterProxy proxy(fTexture->getContext());
+        // Since we want to return an image that wraps the filter's texture, and our clients
+        // assume (at the moment) that the image can be scaled/tiled etc., we must have an exact
+        // sized texture (matching the image's logical size). Hence we pass true to the Proxy's
+        // constructor.
+        const bool kRequireExactTexSize = true;
+        SkGpuImageFilterProxy proxy(fTexture->getContext(), kRequireExactTexSize);
         SkAutoTUnref<SkImageFilter::Cache> cache(SkGpuDevice::NewImageFilterCache());
-        SkImageFilter::Context ctx(SkMatrix::I(), clipBounds, cache);
+        SkImageFilter::Context ctx(SkMatrix::I(), srcBounds, cache);
 
         SkBitmap dst;
         if (!filter->filterImage(&proxy, src, ctx, &dst, offsetResult)) {
             return nullptr;
         }
         return new SkImage_Gpu(dst.width(), dst.height(), kNeedNewImageUniqueID, dst.alphaType(),
                                dst.getTexture(), SkSurface::kNo_Budgeted);
     }
 
     const SkIRect dstR = compute_fast_ibounds(filter, srcBounds);
@@ skipping 152 matching lines @@
     if (!dst) {
         return nullptr;
     }
     
     const SkIRect srcR = SkIRect::MakeWH(desc.fWidth, desc.fHeight);
     const SkIPoint dstP = SkIPoint::Make(0, 0);
     ctx->copySurface(dst, src, srcR, dstP, GrContext::kFlushWrites_PixelOp);
     return dst;
 }