Thread GrShaderDataManager through Image filters

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 214 matching lines @@
         }
     }
 }
 
 bool SkImageFilter::onFilterImage(Proxy*, const SkBitmap&, const Context&,
                                   SkBitmap*, SkIPoint*) const {
     return false;
 }
 
 bool SkImageFilter::canFilterImageGPU() const {
-    return this->asFragmentProcessor(NULL, NULL, SkMatrix::I(), SkIRect());
+    return this->asFragmentProcessor(NULL, NULL, NULL, SkMatrix::I(), SkIRect());
 }
 
 bool SkImageFilter::filterImageGPU(Proxy* proxy, const SkBitmap& src, const Context& ctx,
                                    SkBitmap* result, SkIPoint* offset) const {
 #if SK_SUPPORT_GPU
     SkBitmap input = src;
     SkASSERT(fInputCount == 1);
     SkIPoint srcOffset = SkIPoint::Make(0, 0);
     if (this->getInput(0) &&
         !this->getInput(0)->getInputResultGPU(proxy, src, ctx, &input, &srcOffset)) {
@@ skipping 22 matching lines @@
 
     // setup new clip
     GrClip clip(dstRect);
 
     GrFragmentProcessor* fp;
     offset->fX = bounds.left();
     offset->fY = bounds.top();
     bounds.offset(-srcOffset);
     SkMatrix matrix(ctx.ctm());
     matrix.postTranslate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
-    if (this->asFragmentProcessor(&fp, srcTexture, matrix, bounds)) {
+    GrPaint paint;
+    if (this->asFragmentProcessor(&fp, paint.getShaderDataManager(), srcTexture, matrix, bounds)) {
         SkASSERT(fp);
-        GrPaint paint;
         paint.addColorProcessor(fp)->unref();
 
         GrDrawContext* drawContext = context->drawContext();
         if (drawContext) {
             drawContext->drawNonAARectToRect(dst->asRenderTarget(), clip, paint, SkMatrix::I(),
                                              dstRect, srcRect);
 
             WrapTexture(dst, bounds.width(), bounds.height(), result);
             return true;
         }
@@ skipping 76 matching lines @@
             bounds.join(rect);
         }
     }
 
     // don't modify dst until now, so we don't accidentally change it in the
     // loop, but then return false on the next filter.
     *dst = bounds;
     return true;
 }
 
-bool SkImageFilter::asFragmentProcessor(GrFragmentProcessor**, GrTexture*, const SkMatrix&,
-                                        const SkIRect&) const {
+bool SkImageFilter::asFragmentProcessor(GrFragmentProcessor**, GrShaderDataManager*, GrTexture*,
+                                        const SkMatrix&, const SkIRect&) const {
     return false;
 }
 
 SkImageFilter* SkImageFilter::CreateMatrixFilter(const SkMatrix& matrix,
                                                  SkFilterQuality filterQuality,
                                                  SkImageFilter* input) {
     return SkMatrixImageFilter::Create(matrix, filterQuality, input);
 }
 
 #if SK_SUPPORT_GPU
@@ skipping 152 matching lines @@
     }
     return dev;
 }
 
 bool SkImageFilter::Proxy::filterImage(const SkImageFilter* filter, const SkBitmap& src,
                                        const SkImageFilter::Context& ctx,
                                        SkBitmap* result, SkIPoint* offset) {
     return fDevice->filterImage(filter, src, ctx, result, offset);
 }