tunnel down texture-size-constraint to imagefilters

src/core/SkImageFilter.cpp

 /*
  * Copyright 2012 The Android Open Source Project
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include "SkImageFilter.h"
 
 #include "SkBitmap.h"
@@ skipping 245 matching lines @@
         this->onFilterImage(proxy, src, context, result, offset)) {
         if (context.cache()) {
             context.cache()->set(key, *result, *offset);
         }
         return true;
     }
     return false;
 }
 
 bool SkImageFilter::filterInput(int index, Proxy* proxy, const SkBitmap& src,
-                                const Context& context,
-                                SkBitmap* result, SkIPoint* offset) const {
+                                const Context& origCtx,
+                                SkBitmap* result, SkIPoint* offset,
+                                bool relaxSizeConstraint) const {
     SkImageFilter* input = this->getInput(index);
-    return !input || input->filterImage(proxy, src, context, result, offset);
+    if (!input) {
+        return true;
+    }
+
+    SizeConstraint constraint = origCtx.sizeConstraint();
+    if (relaxSizeConstraint && (kExact_SizeConstraint == constraint)) {
+        constraint = kApprox_SizeConstraint;
+    }
+    Context ctx(origCtx.ctm(), origCtx.clipBounds(), origCtx.cache(), constraint);
+
+    return input->filterImage(proxy, src, ctx, result, offset);
 }
 
 bool SkImageFilter::filterBounds(const SkIRect& src, const SkMatrix& ctm,
                                  SkIRect* dst) const {
     SkASSERT(dst);
     return this->onFilterBounds(src, ctm, dst);
 }
 
 void SkImageFilter::computeFastBounds(const SkRect& src, SkRect* dst) const {
     if (0 == fInputCount) {
@@ skipping 60 matching lines @@
     SkRect srcRect = SkRect::Make(bounds);
     SkRect dstRect = SkRect::MakeWH(srcRect.width(), srcRect.height());
     GrContext* context = srcTexture->getContext();
 
     GrSurfaceDesc desc;
     desc.fFlags = kRenderTarget_GrSurfaceFlag,
     desc.fWidth = bounds.width();
     desc.fHeight = bounds.height();
     desc.fConfig = kRGBA_8888_GrPixelConfig;
 
-    SkAutoTUnref<GrTexture> dst(context->textureProvider()->createApproxTexture(desc));
+    SkAutoTUnref<GrTexture> dst(context->textureProvider()->createTexture(desc,
+                                      GrTextureProvider::FromImageFilter(ctx.sizeConstraint())));
     if (!dst) {
         return false;
     }
 
     // setup new clip
     GrClip clip(dstRect);
 
     GrFragmentProcessor* fp;
     offset->fX = bounds.left();
     offset->fY = bounds.top();
@@ skipping 98 matching lines @@
 
 #if SK_SUPPORT_GPU
 
 void SkImageFilter::WrapTexture(GrTexture* texture, int width, int height, SkBitmap* result) {
     SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
     result->setInfo(info);
     result->setPixelRef(new SkGrPixelRef(info, texture))->unref();
 }
 
 bool SkImageFilter::filterInputGPU(int index, SkImageFilter::Proxy* proxy,
-                                   const SkBitmap& src, const Context& ctx,
-                                   SkBitmap* result, SkIPoint* offset) const {
+                                   const SkBitmap& src, const Context& origCtx,
+                                   SkBitmap* result, SkIPoint* offset,
+                                   bool relaxSizeConstraint) const {
     SkImageFilter* input = this->getInput(index);
     if (!input) {
         return true;
     }
     // Ensure that GrContext calls under filterImage and filterImageGPU below will see an identity
     // matrix with no clip and that the matrix, clip, and render target set before this function was
     // called are restored before we return to the caller.
     GrContext* context = src.getTexture()->getContext();
 
+    SizeConstraint constraint = origCtx.sizeConstraint();
+    if (relaxSizeConstraint && (kExact_SizeConstraint == constraint)) {
+        constraint = kApprox_SizeConstraint;
+    }
+    Context ctx(origCtx.ctm(), origCtx.clipBounds(), origCtx.cache(), constraint);
+
     if (input->canFilterImageGPU()) {
         return input->filterImageGPU(proxy, src, ctx, result, offset);
     } else {
         if (input->filterImage(proxy, src, ctx, result, offset)) {
             if (!result->getTexture()) {
                 const SkImageInfo info = result->info();
                 if (kUnknown_SkColorType == info.colorType()) {
                     return false;
                 }
                 SkAutoTUnref<GrTexture> resultTex(
@@ skipping 123 matching lines @@
     }
     return dev;
 }
 
 bool SkImageFilter::DeviceProxy::filterImage(const SkImageFilter* filter, const SkBitmap& src,
                                        const SkImageFilter::Context& ctx,
                                        SkBitmap* result, SkIPoint* offset) {
     return fDevice->filterImage(filter, src, ctx, result, offset);
 }