Allow single-pass filters (which use asNewEffect()) to participate in the image filter DAG. This w…

src/effects/SkLightingImageFilter.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 "SkLightingImageFilter.h"
 #include "SkBitmap.h"
 #include "SkColorPriv.h"
@@ skipping 246 matching lines @@
     buffer.writeScalar(point.fY);
     buffer.writeScalar(point.fZ);
 };
 
 class SkDiffuseLightingImageFilter : public SkLightingImageFilter {
 public:
     SkDiffuseLightingImageFilter(SkLight* light, SkScalar surfaceScale,
                                  SkScalar kd, SkImageFilter* input);
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDiffuseLightingImageFilter)
 
-    virtual bool asNewEffect(GrEffectRef** effect, GrTexture*) const SK_OVERRIDE;
+#if SK_SUPPORT_GPU
+    virtual bool canFilterImageGPU() const { return true; }
+    virtual GrEffectRef* asNewEffect(GrTexture*) const SK_OVERRIDE;
+#endif
     SkScalar kd() const { return fKD; }
 
 protected:
     explicit SkDiffuseLightingImageFilter(SkFlattenableReadBuffer& buffer);
     virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE;
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
                                SkBitmap* result, SkIPoint* offset) SK_OVERRIDE;
 
 
 private:
     typedef SkLightingImageFilter INHERITED;
     SkScalar fKD;
 };
 
 class SkSpecularLightingImageFilter : public SkLightingImageFilter {
 public:
     SkSpecularLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar ks, SkScalar shininess, SkImageFilter* input);
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSpecularLightingImageFilter)
 
-    virtual bool asNewEffect(GrEffectRef** effect, GrTexture*) const SK_OVERRIDE;
+#if SK_SUPPORT_GPU
+    virtual bool canFilterImageGPU() const { return true; }
+    virtual GrEffectRef* asNewEffect(GrTexture*) const SK_OVERRIDE;
+#endif
+
     SkScalar ks() const { return fKS; }
     SkScalar shininess() const { return fShininess; }
 
 protected:
     explicit SkSpecularLightingImageFilter(SkFlattenableReadBuffer& buffer);
     virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE;
     virtual bool onFilterImage(Proxy*, const SkBitmap& src, const SkMatrix&,
                                SkBitmap* result, SkIPoint* offset) SK_OVERRIDE;
 
 private:
@@ skipping 554 matching lines @@
         case SkLight::kPoint_LightType:
             lightBitmap<DiffuseLightingType, SkPointLight>(lightingType, light(), src, dst, surfaceScale());
             break;
         case SkLight::kSpot_LightType:
             lightBitmap<DiffuseLightingType, SkSpotLight>(lightingType, light(), src, dst, surfaceScale());
             break;
     }
     return true;
 }
 
-bool SkDiffuseLightingImageFilter::asNewEffect(GrEffectRef** effect,
-                                               GrTexture* texture) const {
 #if SK_SUPPORT_GPU
-    if (effect) {
-        SkScalar scale = SkScalarMul(surfaceScale(), SkIntToScalar(255));
-        *effect = GrDiffuseLightingEffect::Create(texture, light(), scale, kd());
-    }
-    return true;
-#else
-    SkDEBUGFAIL("Should not call in GPU-less build");
-    return false;
+GrEffectRef* SkDiffuseLightingImageFilter::asNewEffect(GrTexture* texture) const {
+    SkScalar scale = SkScalarMul(surfaceScale(), SkIntToScalar(255));
+    return GrDiffuseLightingEffect::Create(texture, light(), scale, kd());
+}
 #endif
-}
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkSpecularLightingImageFilter::SkSpecularLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar ks, SkScalar shininess, SkImageFilter* input)
   : SkLightingImageFilter(light, surfaceScale, input),
     fKS(ks),
     fShininess(shininess)
 {
 }
 
@@ skipping 36 matching lines @@
         case SkLight::kPoint_LightType:
             lightBitmap<SpecularLightingType, SkPointLight>(lightingType, light(), src, dst, surfaceScale());
             break;
         case SkLight::kSpot_LightType:
             lightBitmap<SpecularLightingType, SkSpotLight>(lightingType, light(), src, dst, surfaceScale());
             break;
     }
     return true;
 }
 
-bool SkSpecularLightingImageFilter::asNewEffect(GrEffectRef** effect,
-                                                GrTexture* texture) const {
 #if SK_SUPPORT_GPU
-    if (effect) {
-        SkScalar scale = SkScalarMul(surfaceScale(), SkIntToScalar(255));
-        *effect = GrSpecularLightingEffect::Create(texture, light(), scale, ks(), shininess());
-    }
-    return true;
-#else
-    SkDEBUGFAIL("Should not call in GPU-less build");
-    return false;
+GrEffectRef* SkSpecularLightingImageFilter::asNewEffect(GrTexture* texture) const {
+    SkScalar scale = SkScalarMul(surfaceScale(), SkIntToScalar(255));
+    return GrSpecularLightingEffect::Create(texture, light(), scale, ks(), shininess());
+}
 #endif
-}
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 namespace {
 SkPoint3 random_point3(SkMWCRandom* random) {
     return SkPoint3(SkScalarToFloat(random->nextSScalar1()),
                     SkScalarToFloat(random->nextSScalar1()),
                     SkScalarToFloat(random->nextSScalar1()));
@@ skipping 515 matching lines @@
 
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDiffuseLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSpecularLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDistantLight)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkPointLight)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSpotLight)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END