Cleanup patch to move all of SkImageFilterUtils into SkImageFilter.

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"
 #include "SkReadBuffer.h"
 #include "SkWriteBuffer.h"
 #include "SkRect.h"
 #include "SkValidationUtils.h"
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
-#include "GrTexture.h"
-#include "SkImageFilterUtils.h"
+#include "SkGrPixelRef.h"
+#include "SkGr.h"
 #endif
 
 SkImageFilter::SkImageFilter(int inputCount, SkImageFilter** inputs, const CropRect* cropRect)
   : fInputCount(inputCount),
     fInputs(new SkImageFilter*[inputCount]),
     fCropRect(cropRect ? *cropRect : CropRect(SkRect(), 0x0)) {
     for (int i = 0; i < inputCount; ++i) {
         fInputs[i] = inputs[i];
         SkSafeRef(fInputs[i]);
     }
@@ skipping 110 matching lines @@
     return false;
 }
 
 bool SkImageFilter::canFilterImageGPU() const {
     return this->asNewEffect(NULL, NULL, SkMatrix::I(), SkIRect());
 }
 
 bool SkImageFilter::filterImageGPU(Proxy* proxy, const SkBitmap& src, const SkMatrix& ctm,
                                    SkBitmap* result, SkIPoint* offset) const {
 #if SK_SUPPORT_GPU
-    SkBitmap input;
+    SkBitmap input = src;
     SkASSERT(fInputCount == 1);
     SkIPoint srcOffset = SkIPoint::Make(0, 0);
-    if (!SkImageFilterUtils::GetInputResultGPU(this->getInput(0), proxy, src, ctm, &input, &srcOffset)) {
+    if (this->getInput(0) &&
+        !this->getInput(0)->getInputResultGPU(proxy, src, ctm, &input, &srcOffset)) {
         return false;
     }
     GrTexture* srcTexture = input.getTexture();
     SkIRect bounds;
     src.getBounds(&bounds);
     bounds.offset(srcOffset);
     if (!this->applyCropRect(&bounds, ctm)) {
         return false;
     }
     SkRect srcRect = SkRect::Make(bounds);
@@ skipping 18 matching lines @@
     SkMatrix matrix(ctm);
     matrix.postTranslate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
     this->asNewEffect(&effect, srcTexture, matrix, bounds);
     SkASSERT(effect);
     SkAutoUnref effectRef(effect);
     GrPaint paint;
     paint.addColorEffect(effect);
     context->drawRectToRect(paint, dstRect, srcRect);
 
     SkAutoTUnref<GrTexture> resultTex(dst.detach());
-    SkImageFilterUtils::WrapTexture(resultTex, bounds.width(), bounds.height(), result);
+    WrapTexture(resultTex, bounds.width(), bounds.height(), result);
     return true;
 #else
     return false;
 #endif
 }
 
 bool SkImageFilter::applyCropRect(SkIRect* rect, const SkMatrix& matrix) const {
     SkRect cropRect;
     matrix.mapRect(&cropRect, fCropRect.rect());
     SkIRect cropRectI;
@@ skipping 33 matching lines @@
     return true;
 }
 
 bool SkImageFilter::asNewEffect(GrEffectRef**, GrTexture*, const SkMatrix&, const SkIRect&) const {
     return false;
 }
 
 bool SkImageFilter::asColorFilter(SkColorFilter**) const {
     return false;
 }
+
+#if SK_SUPPORT_GPU
+
+void SkImageFilter::WrapTexture(GrTexture* texture, int width, int height, SkBitmap* result) {
+    SkImageInfo info = SkImageInfo::MakeN32Premul(width, height);
+    result->setConfig(info);
+    result->setPixelRef(SkNEW_ARGS(SkGrPixelRef, (info, texture)))->unref();
+}
+
+bool SkImageFilter::getInputResultGPU(SkImageFilter::Proxy* proxy,
+                                      const SkBitmap& src, const SkMatrix& ctm,
+                                      SkBitmap* result, SkIPoint* offset) const {
+    // 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();
+    GrContext::AutoWideOpenIdentityDraw awoid(context, NULL);
+    if (this->canFilterImageGPU()) {
+        return this->filterImageGPU(proxy, src, ctm, result, offset);
+    } else {
+        if (this->filterImage(proxy, src, ctm, result, offset)) {
+            if (!result->getTexture()) {
+                SkImageInfo info;
+                if (!result->asImageInfo(&info)) {
+                    return false;
+                }
+                GrTexture* resultTex = GrLockAndRefCachedBitmapTexture(context, *result, NULL);
+                result->setPixelRef(new SkGrPixelRef(info, resultTex))->unref();
+                GrUnlockAndUnrefCachedBitmapTexture(resultTex);
+            }
+            return true;
+        } else {
+            return false;
+        }
+    }
+}
+#endif