Implement approx-match support in image filter saveLayer() offscreen.

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 259 matching lines @@
                     SkScalarIsFinite(point.fZ));
     return point;
 };
 
 void writePoint3(const SkPoint3& point, SkWriteBuffer& buffer) {
     buffer.writeScalar(point.fX);
     buffer.writeScalar(point.fY);
     buffer.writeScalar(point.fZ);
 };
 
-class SkDiffuseLightingImageFilter : public SkLightingImageFilter {
+enum BoundaryMode {
+    kTopLeft_BoundaryMode,
+    kTop_BoundaryMode,
+    kTopRight_BoundaryMode,
+    kLeft_BoundaryMode,
+    kInterior_BoundaryMode,
+    kRight_BoundaryMode,
+    kBottomLeft_BoundaryMode,
+    kBottom_BoundaryMode,
+    kBottomRight_BoundaryMode,
+
+    kBoundaryModeCount,
+};
+
+class SkLightingImageFilterInternal : public SkLightingImageFilter {
+protected:
+    SkLightingImageFilterInternal(SkLight* light,
+                                  SkScalar surfaceScale,
+                                  SkImageFilter* input,
+                                  const CropRect* cropRect)
+      : INHERITED(light, surfaceScale, input, cropRect) {}
+
+#if SK_SUPPORT_GPU
+    bool canFilterImageGPU() const override { return true; }
+    bool filterImageGPU(Proxy*, const SkBitmap& src, const Context&,
+                        SkBitmap* result, SkIPoint* offset) const override;
+    virtual GrFragmentProcessor* getFragmentProcessor(GrTexture*,
+                                                      const SkMatrix&,
+                                                      const SkIRect& bounds,
+                                                      BoundaryMode boundaryMode) const = 0;
+#endif
+private:
+#if SK_SUPPORT_GPU
+    void drawRect(GrContext* context,
+                  GrTexture* src,
+                  GrTexture* dst,
+                  const SkMatrix& matrix,
+                  const GrClip& clip,
+                  const SkRect& dstRect,
+                  BoundaryMode boundaryMode,
+                  const SkIRect& bounds) const;
+#endif
+    typedef SkLightingImageFilter INHERITED;
+};
+
+#if SK_SUPPORT_GPU
+void SkLightingImageFilterInternal::drawRect(GrContext* context,
+                                             GrTexture* src,
+                                             GrTexture* dst,
+                                             const SkMatrix& matrix,
+                                             const GrClip& clip,
+                                             const SkRect& dstRect,
+                                             BoundaryMode boundaryMode,
+                                             const SkIRect& bounds) const {
+    SkRect srcRect = dstRect.makeOffset(SkIntToScalar(bounds.x()), SkIntToScalar(bounds.y()));
+    GrFragmentProcessor* fp = this->getFragmentProcessor(src, matrix, bounds, boundaryMode);
+    GrPaint paint;
+    paint.addColorProcessor(fp)->unref();
+    context->drawNonAARectToRect(dst->asRenderTarget(), clip, paint, SkMatrix::I(),
+                                 dstRect, srcRect);
+}
+
+bool SkLightingImageFilterInternal::filterImageGPU(Proxy* proxy,
+                                                   const SkBitmap& src,
+                                                   const Context& ctx,
+                                                   SkBitmap* result,
+                                                   SkIPoint* offset) const {
+    SkBitmap input = src;
+    SkIPoint srcOffset = SkIPoint::Make(0, 0);
+    if (this->getInput(0) &&
+        !this->getInput(0)->getInputResultGPU(proxy, src, ctx, &input, &srcOffset)) {
+        return false;
+    }
+    SkIRect bounds;
+    if (!this->applyCropRect(ctx, proxy, input, &srcOffset, &bounds, &input)) {
+        return false;
+    }
+    SkRect dstRect = SkRect::MakeWH(SkIntToScalar(bounds.width()),
+                                    SkIntToScalar(bounds.height()));
+    GrTexture* srcTexture = input.getTexture();
+    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->refScratchTexture(desc, GrContext::kApprox_ScratchTexMatch));
+    if (!dst) {
+        return false;
+    }
+
+    // setup new clip
+    GrClip clip(dstRect);
+
+    offset->fX = bounds.left();
+    offset->fY = bounds.top();
+    SkMatrix matrix(ctx.ctm());
+    matrix.postTranslate(SkIntToScalar(-bounds.left()), SkIntToScalar(-bounds.top()));
+    bounds.offset(-srcOffset);
+    SkRect topLeft = SkRect::MakeXYWH(0, 0, 1, 1);
+    SkRect top = SkRect::MakeXYWH(1, 0, dstRect.width() - 2, 1);
+    SkRect topRight = SkRect::MakeXYWH(dstRect.width() - 1, 0, 1, 1);
+    SkRect left = SkRect::MakeXYWH(0, 1, 1, dstRect.height() - 2);
+    SkRect interior = dstRect.makeInset(1, 1);
+    SkRect right = SkRect::MakeXYWH(dstRect.width() - 1, 1, 1, dstRect.height() - 2);
+    SkRect bottomLeft = SkRect::MakeXYWH(0, dstRect.height() - 1, 1, 1);
+    SkRect bottom = SkRect::MakeXYWH(1, dstRect.height() - 1, dstRect.width() - 2, 1);
+    SkRect bottomRight = SkRect::MakeXYWH(dstRect.width() - 1, dstRect.height() - 1, 1, 1);
+    this->drawRect(context, srcTexture, dst, matrix, clip, topLeft, kTopLeft_BoundaryMode, bounds);
+    this->drawRect(context, srcTexture, dst, matrix, clip, top, kTop_BoundaryMode, bounds);
+    this->drawRect(context, srcTexture, dst, matrix, clip, topRight, kTopRight_BoundaryMode,
+                   bounds);
+    this->drawRect(context, srcTexture, dst, matrix, clip, left, kLeft_BoundaryMode, bounds);
+    this->drawRect(context, srcTexture, dst, matrix, clip, interior, kInterior_BoundaryMode,
+                   bounds);
+    this->drawRect(context, srcTexture, dst, matrix, clip, right, kRight_BoundaryMode, bounds);
+    this->drawRect(context, srcTexture, dst, matrix, clip, bottomLeft, kBottomLeft_BoundaryMode,
+                   bounds);
+    this->drawRect(context, srcTexture, dst, matrix, clip, bottom, kBottom_BoundaryMode, bounds);
+    this->drawRect(context, srcTexture, dst, matrix, clip, bottomRight, kBottomRight_BoundaryMode,
+                   bounds);
+    WrapTexture(dst, bounds.width(), bounds.height(), result);
+    return true;
+}
+#endif
+
+class SkDiffuseLightingImageFilter : public SkLightingImageFilterInternal {
 public:
     static SkImageFilter* Create(SkLight* light, SkScalar surfaceScale, SkScalar kd, SkImageFilter*,
                                  const CropRect*);
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDiffuseLightingImageFilter)
     SkScalar kd() const { return fKD; }
 
 protected:
     SkDiffuseLightingImageFilter(SkLight* light, SkScalar surfaceScale,
                                  SkScalar kd, SkImageFilter* input, const CropRect* cropRect);
     void flatten(SkWriteBuffer& buffer) const override;
-    virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
-                               SkBitmap* result, SkIPoint* offset) const override;
+    bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
+                       SkBitmap* result, SkIPoint* offset) const override;
 #if SK_SUPPORT_GPU
-    virtual bool asFragmentProcessor(GrFragmentProcessor**, GrTexture*, const SkMatrix&,
-                                     const SkIRect& bounds) const override;
+    GrFragmentProcessor* getFragmentProcessor(GrTexture*, const SkMatrix&,
+                                              const SkIRect& bounds, BoundaryMode) const override;
 #endif
 
 private:
     friend class SkLightingImageFilter;
-    typedef SkLightingImageFilter INHERITED;
+    typedef SkLightingImageFilterInternal INHERITED;
     SkScalar fKD;
 };
 
-class SkSpecularLightingImageFilter : public SkLightingImageFilter {
+class SkSpecularLightingImageFilter : public SkLightingImageFilterInternal {
 public:
     static SkImageFilter* Create(SkLight* light, SkScalar surfaceScale,
                                  SkScalar ks, SkScalar shininess, SkImageFilter*, const CropRect*);
 
     SK_TO_STRING_OVERRIDE()
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSpecularLightingImageFilter)
 
     SkScalar ks() const { return fKS; }
     SkScalar shininess() const { return fShininess; }
 
 protected:
     SkSpecularLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar ks,
                                   SkScalar shininess, SkImageFilter* input, const CropRect*);
     void flatten(SkWriteBuffer& buffer) const override;
-    virtual bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
-                               SkBitmap* result, SkIPoint* offset) const override;
+    bool onFilterImage(Proxy*, const SkBitmap& src, const Context&,
+                       SkBitmap* result, SkIPoint* offset) const override;
 #if SK_SUPPORT_GPU
-    virtual bool asFragmentProcessor(GrFragmentProcessor**, GrTexture*, const SkMatrix&,
-                                     const SkIRect& bounds) const override;
+    GrFragmentProcessor* getFragmentProcessor(GrTexture*, const SkMatrix&,
+                                              const SkIRect& bounds, BoundaryMode) const override;
 #endif
 
 private:
     SkScalar fKS;
     SkScalar fShininess;
     friend class SkLightingImageFilter;
-    typedef SkLightingImageFilter INHERITED;
+    typedef SkLightingImageFilterInternal INHERITED;
 };
 
 #if SK_SUPPORT_GPU
 
 class GrLightingEffect : public GrSingleTextureEffect {
 public:
-    GrLightingEffect(GrTexture* texture, const SkLight* light, SkScalar surfaceScale, const SkMatrix& matrix);
+    GrLightingEffect(GrTexture* texture, const SkLight* light, SkScalar surfaceScale,
+                     const SkMatrix& matrix, BoundaryMode boundaryMode);
     virtual ~GrLightingEffect();
 
     const SkLight* light() const { return fLight; }
     SkScalar surfaceScale() const { return fSurfaceScale; }
     const SkMatrix& filterMatrix() const { return fFilterMatrix; }
+    BoundaryMode boundaryMode() const { return fBoundaryMode; }
 
 protected:
     bool onIsEqual(const GrFragmentProcessor&) const override;
 
     void onComputeInvariantOutput(GrInvariantOutput* inout) const override {
         // lighting shaders are complicated. We just throw up our hands.
         inout->mulByUnknownFourComponents();
     }
 
 private:
     typedef GrSingleTextureEffect INHERITED;
     const SkLight* fLight;
     SkScalar fSurfaceScale;
     SkMatrix fFilterMatrix;
+    BoundaryMode fBoundaryMode;
 };
 
 class GrDiffuseLightingEffect : public GrLightingEffect {
 public:
     static GrFragmentProcessor* Create(GrTexture* texture,
                                        const SkLight* light,
                                        SkScalar surfaceScale,
                                        const SkMatrix& matrix,
-                                       SkScalar kd) {
+                                       SkScalar kd,
+                                       BoundaryMode boundaryMode) {
         return SkNEW_ARGS(GrDiffuseLightingEffect, (texture,
                                                     light,
                                                     surfaceScale,
                                                     matrix,
-                                                    kd));
+                                                    kd,
+                                                    boundaryMode));
     }
 
     const char* name() const override { return "DiffuseLighting"; }
 
     void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
 
     GrGLFragmentProcessor* createGLInstance() const override;
 
     SkScalar kd() const { return fKD; }
 
 private:
     bool onIsEqual(const GrFragmentProcessor&) const override;
 
     GrDiffuseLightingEffect(GrTexture* texture,
                             const SkLight* light,
                             SkScalar surfaceScale,
                             const SkMatrix& matrix,
-                            SkScalar kd);
+                            SkScalar kd,
+                            BoundaryMode boundaryMode);
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
     typedef GrLightingEffect INHERITED;
     SkScalar fKD;
 };
 
 class GrSpecularLightingEffect : public GrLightingEffect {
 public:
     static GrFragmentProcessor* Create(GrTexture* texture,
                                        const SkLight* light,
                                        SkScalar surfaceScale,
                                        const SkMatrix& matrix,
                                        SkScalar ks,
-                                       SkScalar shininess) {
+                                       SkScalar shininess,
+                                       BoundaryMode boundaryMode) {
         return SkNEW_ARGS(GrSpecularLightingEffect, (texture,
                                                      light,
                                                      surfaceScale,
                                                      matrix,
                                                      ks,
-                                                     shininess));
+                                                     shininess,
+                                                     boundaryMode));
     }
 
     const char* name() const override { return "SpecularLighting"; }
 
     void getGLProcessorKey(const GrGLCaps&, GrProcessorKeyBuilder*) const override;
 
     GrGLFragmentProcessor* createGLInstance() const override;
 
     SkScalar ks() const { return fKS; }
     SkScalar shininess() const { return fShininess; }
 
 private:
     bool onIsEqual(const GrFragmentProcessor&) const override;
 
     GrSpecularLightingEffect(GrTexture* texture,
                              const SkLight* light,
                              SkScalar surfaceScale,
                              const SkMatrix& matrix,
                              SkScalar ks,
-                             SkScalar shininess);
+                             SkScalar shininess,
+                             BoundaryMode boundaryMode);
 
     GR_DECLARE_FRAGMENT_PROCESSOR_TEST;
     typedef GrLightingEffect INHERITED;
     SkScalar fKS;
     SkScalar fShininess;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLLight {
@@ skipping 33 matching lines @@
     UniformHandle fColorUni;
 
     typedef SkRefCnt INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLDistantLight : public GrGLLight {
 public:
     virtual ~GrGLDistantLight() {}
-    virtual void setData(const GrGLProgramDataManager&,
-                         const SkLight* light) const override;
+    void setData(const GrGLProgramDataManager&, const SkLight* light) const override;
     void emitSurfaceToLight(GrGLFPBuilder*, const char* z) override;
 
 private:
     typedef GrGLLight INHERITED;
     UniformHandle fDirectionUni;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLPointLight : public GrGLLight {
 public:
     virtual ~GrGLPointLight() {}
-    virtual void setData(const GrGLProgramDataManager&,
-                         const SkLight* light) const override;
+    void setData(const GrGLProgramDataManager&, const SkLight* light) const override;
     void emitSurfaceToLight(GrGLFPBuilder*, const char* z) override;
 
 private:
     typedef GrGLLight INHERITED;
     UniformHandle fLocationUni;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLSpotLight : public GrGLLight {
 public:
     virtual ~GrGLSpotLight() {}
-    virtual void setData(const GrGLProgramDataManager&,
-                         const SkLight* light) const override;
+    void setData(const GrGLProgramDataManager&, const SkLight* light) const override;
     void emitSurfaceToLight(GrGLFPBuilder*, const char* z) override;
     void emitLightColor(GrGLFPBuilder*, const char *surfaceToLight) override;
 
 private:
     typedef GrGLLight INHERITED;
 
     SkString        fLightColorFunc;
     UniformHandle   fLocationUni;
     UniformHandle   fExponentUni;
     UniformHandle   fCosOuterConeAngleUni;
@@ skipping 164 matching lines @@
 
 private:
     typedef SkLight INHERITED;
     SkPoint3 fLocation;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class SkSpotLight : public SkLight {
 public:
-    SkSpotLight(const SkPoint3& location, const SkPoint3& target, SkScalar specularExponent, SkScalar cutoffAngle, SkColor color)
+    SkSpotLight(const SkPoint3& location,
+                const SkPoint3& target,
+                SkScalar specularExponent,
+                SkScalar cutoffAngle,
+                SkColor color)
      : INHERITED(color),
        fLocation(location),
        fTarget(target),
        fSpecularExponent(SkScalarPin(specularExponent, kSpecularExponentMin, kSpecularExponentMax))
     {
        fS = target - location;
        fS.normalize();
        fCosOuterConeAngle = SkScalarCos(SkDegreesToRadians(cutoffAngle));
        const SkScalar antiAliasThreshold = 0.016f;
        fCosInnerConeAngle = fCosOuterConeAngle + antiAliasThreshold;
        fConeScale = SkScalarInvert(antiAliasThreshold);
     }
 
     SkLight* transform(const SkMatrix& matrix) const override {
         SkPoint location2 = SkPoint::Make(fLocation.fX, fLocation.fY);
         matrix.mapPoints(&location2, 1);
         // Use X scale and Y scale on Z and average the result
         SkPoint locationZ = SkPoint::Make(fLocation.fZ, fLocation.fZ);
         matrix.mapVectors(&locationZ, 1);
         SkPoint3 location(location2.fX, location2.fY, SkScalarAve(locationZ.fX, locationZ.fY));
         SkPoint target2 = SkPoint::Make(fTarget.fX, fTarget.fY);
         matrix.mapPoints(&target2, 1);
         SkPoint targetZ = SkPoint::Make(fTarget.fZ, fTarget.fZ);
         matrix.mapVectors(&targetZ, 1);
         SkPoint3 target(target2.fX, target2.fY, SkScalarAve(targetZ.fX, targetZ.fY));
         SkPoint3 s = target - location;
         s.normalize();
-        return new SkSpotLight(location, target, fSpecularExponent, fCosOuterConeAngle, fCosInnerConeAngle, fConeScale, s, color());
+        return new SkSpotLight(location,
+                               target,
+                               fSpecularExponent,
+                               fCosOuterConeAngle,
+                               fCosInnerConeAngle,
+                               fConeScale,
+                               s,
+                               color());
     }
 
     SkPoint3 surfaceToLight(int x, int y, int z, SkScalar surfaceScale) const {
         SkPoint3 direction(fLocation.fX - SkIntToScalar(x),
                            fLocation.fY - SkIntToScalar(y),
                            fLocation.fZ - SkScalarMul(SkIntToScalar(z), surfaceScale));
         direction.normalize();
         return direction;
     };
     SkPoint3 lightColor(const SkPoint3& surfaceToLight) const {
@@ skipping 33 matching lines @@
         fCosOuterConeAngle = buffer.readScalar();
         fCosInnerConeAngle = buffer.readScalar();
         fConeScale = buffer.readScalar();
         fS = readPoint3(buffer);
         buffer.validate(SkScalarIsFinite(fSpecularExponent) &&
                         SkScalarIsFinite(fCosOuterConeAngle) &&
                         SkScalarIsFinite(fCosInnerConeAngle) &&
                         SkScalarIsFinite(fConeScale));
     }
 protected:
-    SkSpotLight(const SkPoint3& location, const SkPoint3& target, SkScalar specularExponent, SkScalar cosOuterConeAngle, SkScalar cosInnerConeAngle, SkScalar coneScale, const SkPoint3& s, const SkPoint3& color)
+    SkSpotLight(const SkPoint3& location,
+                const SkPoint3& target,
+                SkScalar specularExponent,
+                SkScalar cosOuterConeAngle,
+                SkScalar cosInnerConeAngle,
+                SkScalar coneScale,
+                const SkPoint3& s,
+                const SkPoint3& color)
      : INHERITED(color),
        fLocation(location),
        fTarget(target),
        fSpecularExponent(specularExponent),
        fCosOuterConeAngle(cosOuterConeAngle),
        fCosInnerConeAngle(cosInnerConeAngle),
        fConeScale(coneScale),
        fS(s)
     {
     }
@@ skipping 162 matching lines @@
         return NULL;
     }
     // According to the spec, kd can be any non-negative number :
     // http://www.w3.org/TR/SVG/filters.html#feDiffuseLightingElement
     if (kd < 0) {
         return NULL;
     }
     return SkNEW_ARGS(SkDiffuseLightingImageFilter, (light, surfaceScale, kd, input, cropRect));
 }
 
-SkDiffuseLightingImageFilter::SkDiffuseLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar kd, SkImageFilter* input, const CropRect* cropRect)
-  : SkLightingImageFilter(light, surfaceScale, input, cropRect),
+SkDiffuseLightingImageFilter::SkDiffuseLightingImageFilter(SkLight* light,
+                                                           SkScalar surfaceScale,
+                                                           SkScalar kd,
+                                                           SkImageFilter* input,
+                                                           const CropRect* cropRect)
+  : INHERITED(light, surfaceScale, input, cropRect),
     fKD(kd)
 {
 }
 
 SkFlattenable* SkDiffuseLightingImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkAutoTUnref<SkLight> light(SkLight::UnflattenLight(buffer));
     SkScalar surfaceScale = buffer.readScalar();
     SkScalar kd = buffer.readScalar();
     return Create(light, surfaceScale, kd, common.getInput(0), &common.cropRect());
@@ skipping 38 matching lines @@
     }
 
     SkAutoTUnref<SkLight> transformedLight(light()->transform(ctx.ctm()));
 
     DiffuseLightingType lightingType(fKD);
     offset->fX = bounds.left();
     offset->fY = bounds.top();
     bounds.offset(-srcOffset);
     switch (transformedLight->type()) {
         case SkLight::kDistant_LightType:
-            lightBitmap<DiffuseLightingType, SkDistantLight>(lightingType, transformedLight, src, dst, surfaceScale(), bounds);
+            lightBitmap<DiffuseLightingType, SkDistantLight>(lightingType,
+                                                             transformedLight,
+                                                             src,
+                                                             dst,
+                                                             surfaceScale(),
+                                                             bounds);
             break;
         case SkLight::kPoint_LightType:
-            lightBitmap<DiffuseLightingType, SkPointLight>(lightingType, transformedLight, src, dst, surfaceScale(), bounds);
+            lightBitmap<DiffuseLightingType, SkPointLight>(lightingType,
+                                                           transformedLight,
+                                                           src,
+                                                           dst,
+                                                           surfaceScale(),
+                                                           bounds);
             break;
         case SkLight::kSpot_LightType:
-            lightBitmap<DiffuseLightingType, SkSpotLight>(lightingType, transformedLight, src, dst, surfaceScale(), bounds);
+            lightBitmap<DiffuseLightingType, SkSpotLight>(lightingType,
+                                                          transformedLight,
+                                                          src,
+                                                          dst,
+                                                          surfaceScale(),
+                                                          bounds);
             break;
     }
 
     return true;
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void SkDiffuseLightingImageFilter::toString(SkString* str) const {
     str->appendf("SkDiffuseLightingImageFilter: (");
     str->appendf("kD: %f\n", fKD);
     str->append(")");
 }
 #endif
 
 #if SK_SUPPORT_GPU
-bool SkDiffuseLightingImageFilter::asFragmentProcessor(GrFragmentProcessor** fp,
+GrFragmentProcessor* SkDiffuseLightingImageFilter::getFragmentProcessor(
                                                        GrTexture* texture,
                                                        const SkMatrix& matrix,
-                                                       const SkIRect&) const {
-    if (fp) {
-        SkScalar scale = SkScalarMul(surfaceScale(), SkIntToScalar(255));
-        *fp = GrDiffuseLightingEffect::Create(texture, light(), scale, matrix, kd());
-    }
-    return true;
+                                                       const SkIRect&,
+                                                       BoundaryMode boundaryMode
+) const {
+    SkScalar scale = SkScalarMul(surfaceScale(), SkIntToScalar(255));
+    return GrDiffuseLightingEffect::Create(texture, light(), scale, matrix, kd(), boundaryMode);
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkImageFilter* SkSpecularLightingImageFilter::Create(SkLight* light, SkScalar surfaceScale,
                 SkScalar ks, SkScalar shininess, SkImageFilter* input, const CropRect* cropRect) {
     if (NULL == light) {
         return NULL;
     }
     if (!SkScalarIsFinite(surfaceScale) || !SkScalarIsFinite(ks) || !SkScalarIsFinite(shininess)) {
         return NULL;
     }
     // According to the spec, ks can be any non-negative number :
     // http://www.w3.org/TR/SVG/filters.html#feSpecularLightingElement
     if (ks < 0) {
         return NULL;
     }
     return SkNEW_ARGS(SkSpecularLightingImageFilter,
                       (light, surfaceScale, ks, shininess, input, cropRect));
 }
 
-SkSpecularLightingImageFilter::SkSpecularLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar ks, SkScalar shininess, SkImageFilter* input, const CropRect* cropRect)
-  : SkLightingImageFilter(light, surfaceScale, input, cropRect),
+SkSpecularLightingImageFilter::SkSpecularLightingImageFilter(SkLight* light,
+                                                             SkScalar surfaceScale,
+                                                             SkScalar ks,
+                                                             SkScalar shininess,
+                                                             SkImageFilter* input,
+                                                             const CropRect* cropRect)
+  : INHERITED(light, surfaceScale, input, cropRect),
     fKS(ks),
     fShininess(shininess)
 {
 }
 
 SkFlattenable* SkSpecularLightingImageFilter::CreateProc(SkReadBuffer& buffer) {
     SK_IMAGEFILTER_UNFLATTEN_COMMON(common, 1);
     SkAutoTUnref<SkLight> light(SkLight::UnflattenLight(buffer));
     SkScalar surfaceScale = buffer.readScalar();
     SkScalar ks = buffer.readScalar();
@@ skipping 41 matching lines @@
         return false;
     }
 
     SpecularLightingType lightingType(fKS, fShininess);
     offset->fX = bounds.left();
     offset->fY = bounds.top();
     bounds.offset(-srcOffset);
     SkAutoTUnref<SkLight> transformedLight(light()->transform(ctx.ctm()));
     switch (transformedLight->type()) {
         case SkLight::kDistant_LightType:
-            lightBitmap<SpecularLightingType, SkDistantLight>(lightingType, transformedLight, src, dst, surfaceScale(), bounds);
+            lightBitmap<SpecularLightingType, SkDistantLight>(lightingType,
+                                                              transformedLight,
+                                                              src,
+                                                              dst,
+                                                              surfaceScale(),
+                                                              bounds);
             break;
         case SkLight::kPoint_LightType:
-            lightBitmap<SpecularLightingType, SkPointLight>(lightingType, transformedLight, src, dst, surfaceScale(), bounds);
+            lightBitmap<SpecularLightingType, SkPointLight>(lightingType,
+                                                            transformedLight,
+                                                            src,
+                                                            dst,
+                                                            surfaceScale(),
+                                                            bounds);
             break;
         case SkLight::kSpot_LightType:
-            lightBitmap<SpecularLightingType, SkSpotLight>(lightingType, transformedLight, src, dst, surfaceScale(), bounds);
+            lightBitmap<SpecularLightingType, SkSpotLight>(lightingType,
+                                                           transformedLight,
+                                                           src,
+                                                           dst,
+                                                           surfaceScale(),
+                                                           bounds);
             break;
     }
     return true;
 }
 
 #ifndef SK_IGNORE_TO_STRING
 void SkSpecularLightingImageFilter::toString(SkString* str) const {
     str->appendf("SkSpecularLightingImageFilter: (");
     str->appendf("kS: %f shininess: %f", fKS, fShininess);
     str->append(")");
 }
 #endif
 
 #if SK_SUPPORT_GPU
-bool SkSpecularLightingImageFilter::asFragmentProcessor(GrFragmentProcessor** fp,
-                                                        GrTexture* texture,
-                                                        const SkMatrix& matrix,
-                                                        const SkIRect&) const {
-    if (fp) {
-        SkScalar scale = SkScalarMul(surfaceScale(), SkIntToScalar(255));
-        *fp = GrSpecularLightingEffect::Create(texture, light(), scale, matrix, ks(), shininess());
-    }
-    return true;
+GrFragmentProcessor* SkSpecularLightingImageFilter::getFragmentProcessor(
+                                                         GrTexture* texture,
+                                                         const SkMatrix& matrix,
+                                                         const SkIRect&,
+                                                         BoundaryMode boundaryMode) const {
+    SkScalar scale = SkScalarMul(surfaceScale(), SkIntToScalar(255));
+    return GrSpecularLightingEffect::Create(texture, light(), scale, matrix, ks(), shininess(),
+                                            boundaryMode);
 }
 #endif
 
 ///////////////////////////////////////////////////////////////////////////////
 
 #if SK_SUPPORT_GPU
 
 namespace {
 SkPoint3 random_point3(SkRandom* random) {
     return SkPoint3(SkScalarToFloat(random->nextSScalar1()),
@@ skipping 16 matching lines @@
                                             random->nextUScalar1(),
                                             random->nextUScalar1(),
                                             random->nextU()));
         }
         default:
             SkFAIL("Unexpected value.");
             return NULL;
     }
 }
 
+SkString emitNormalFunc(BoundaryMode mode,
+                        const char* pointToNormalName,
+                        const char* sobelFuncName) {
+    SkString result;
+    switch (mode) {
+    case kTopLeft_BoundaryMode:
+        result.printf("\treturn %s(%s(0.0, 0.0, m[4], m[5], m[7], m[8], %g),\n"
+                      "\t          %s(0.0, 0.0, m[4], m[7], m[5], m[8], %g),\n"
+                      "\t          surfaceScale);\n",
+                      pointToNormalName, sobelFuncName, gTwoThirds,
+                                         sobelFuncName, gTwoThirds);
+        break;
+    case kTop_BoundaryMode:
+        result.printf("\treturn %s(%s(0.0, 0.0, m[3], m[5], m[6], m[8], %g),\n"
+                      "\t          %s(0.0, 0.0, m[4], m[7], m[5], m[8], %g),\n"
+                      "\t          surfaceScale);\n",
+                      pointToNormalName, sobelFuncName, gOneThird,
+                                         sobelFuncName, gOneHalf);
+        break;
+    case kTopRight_BoundaryMode:
+        result.printf("\treturn %s(%s( 0.0,  0.0, m[3], m[4], m[6], m[7], %g),\n"
+                      "\t          %s(m[3], m[6], m[4], m[7],  0.0,  0.0, %g),\n"
+                      "\t          surfaceScale);\n",
+                      pointToNormalName, sobelFuncName, gTwoThirds,
+                                         sobelFuncName, gTwoThirds);
+        break;
+    case kLeft_BoundaryMode:
+        result.printf("\treturn %s(%s(m[1], m[2], m[4], m[5], m[7], m[8], %g),\n"
+                      "\t          %s( 0.0,  0.0, m[1], m[7], m[2], m[8], %g),\n"
+                      "\t          surfaceScale);\n",
+                      pointToNormalName, sobelFuncName, gOneHalf,
+                                         sobelFuncName, gOneThird);
+        break;
+    case kInterior_BoundaryMode:
+        result.printf("\treturn %s(%s(m[0], m[2], m[3], m[5], m[6], m[8], %g),\n"
+                      "\t          %s(m[0], m[6], m[1], m[7], m[2], m[8], %g),\n"
+                      "\t          surfaceScale);\n",
+                      pointToNormalName, sobelFuncName, gOneQuarter,
+                                         sobelFuncName, gOneQuarter);
+        break;
+    case kRight_BoundaryMode:
+        result.printf("\treturn %s(%s(m[0], m[1], m[3], m[4], m[6], m[7], %g),\n"
+                      "\t          %s(m[0], m[6], m[1], m[7],  0.0,  0.0, %g),\n"
+                      "\t          surfaceScale);\n",
+                      pointToNormalName, sobelFuncName, gOneHalf,
+                                         sobelFuncName, gOneThird);
+        break;
+    case kBottomLeft_BoundaryMode:
+        result.printf("\treturn %s(%s(m[1], m[2], m[4], m[5],  0.0,  0.0, %g),\n"
+                      "\t          %s( 0.0,  0.0, m[1], m[4], m[2], m[5], %g),\n"
+                      "\t          surfaceScale);\n",
+                      pointToNormalName, sobelFuncName, gTwoThirds,
+                                         sobelFuncName, gTwoThirds);
+        break;
+    case kBottom_BoundaryMode:
+        result.printf("\treturn %s(%s(m[0], m[2], m[3], m[5],  0.0,  0.0, %g),\n"
+                      "\t          %s(m[0], m[3], m[1], m[4], m[2], m[5], %g),\n"
+                      "\t          surfaceScale);\n",
+                      pointToNormalName, sobelFuncName, gOneThird,
+                                         sobelFuncName, gOneHalf);
+        break;
+    case kBottomRight_BoundaryMode:
+        result.printf("\treturn %s(%s(m[0], m[1], m[3], m[4],  0.0,  0.0, %g),\n"
+                      "\t          %s(m[0], m[3], m[1], m[4],  0.0,  0.0, %g),\n"
+                      "\t          surfaceScale);\n",
+                      pointToNormalName, sobelFuncName, gTwoThirds,
+                                         sobelFuncName, gTwoThirds);
+        break;
+    default:
+        SkASSERT(false);
+        break;
+    }
+    return result;
+}
+
 }
 
 class GrGLLightingEffect  : public GrGLFragmentProcessor {
 public:
     GrGLLightingEffect(const GrProcessor&);
     virtual ~GrGLLightingEffect();
 
-    virtual void emitCode(GrGLFPBuilder*,
-                          const GrFragmentProcessor&,
-                          const char* outputColor,
-                          const char* inputColor,
-                          const TransformedCoordsArray&,
-                          const TextureSamplerArray&) override;
+    void emitCode(GrGLFPBuilder*,
+                  const GrFragmentProcessor&,
+                  const char* outputColor,
+                  const char* inputColor,
+                  const TransformedCoordsArray&,
+                  const TextureSamplerArray&) override;
 
     static inline void GenKey(const GrProcessor&, const GrGLCaps&, GrProcessorKeyBuilder* b);
 
     /**
      * Subclasses of GrGLLightingEffect must call INHERITED::setData();
      */
     void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
 protected:
     virtual void emitLightFunc(GrGLFPBuilder*, SkString* funcName) = 0;
 
 private:
     typedef GrGLFragmentProcessor INHERITED;
 
     UniformHandle       fImageIncrementUni;
     UniformHandle       fSurfaceScaleUni;
     GrGLLight*          fLight;
+    BoundaryMode        fBoundaryMode;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class GrGLDiffuseLightingEffect  : public GrGLLightingEffect {
 public:
     GrGLDiffuseLightingEffect(const GrProcessor&);
     void emitLightFunc(GrGLFPBuilder*, SkString* funcName) override;
     void setData(const GrGLProgramDataManager&, const GrProcessor&) override;
 
@@ skipping 16 matching lines @@
 
     UniformHandle   fKSUni;
     UniformHandle   fShininessUni;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrLightingEffect::GrLightingEffect(GrTexture* texture,
                                    const SkLight* light,
                                    SkScalar surfaceScale,
-                                   const SkMatrix& matrix)
+                                   const SkMatrix& matrix,
+                                   BoundaryMode boundaryMode)
     : INHERITED(texture, GrCoordTransform::MakeDivByTextureWHMatrix(texture))
     , fLight(light)
     , fSurfaceScale(surfaceScale)
-    , fFilterMatrix(matrix) {
+    , fFilterMatrix(matrix)
+    , fBoundaryMode(boundaryMode) {
     fLight->ref();
     if (light->requiresFragmentPosition()) {
         this->setWillReadFragmentPosition();
     }
 }
 
 GrLightingEffect::~GrLightingEffect() {
     fLight->unref();
 }
 
 bool GrLightingEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
     const GrLightingEffect& s = sBase.cast<GrLightingEffect>();
     return fLight->isEqual(*s.fLight) &&
-           fSurfaceScale == s.fSurfaceScale;
+           fSurfaceScale == s.fSurfaceScale &&
+           fBoundaryMode == s.fBoundaryMode;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrDiffuseLightingEffect::GrDiffuseLightingEffect(GrTexture* texture,
                                                  const SkLight* light,
                                                  SkScalar surfaceScale,
                                                  const SkMatrix& matrix,
-                                                 SkScalar kd)
-    : INHERITED(texture, light, surfaceScale, matrix), fKD(kd) {
+                                                 SkScalar kd,
+                                                 BoundaryMode boundaryMode)
+    : INHERITED(texture, light, surfaceScale, matrix, boundaryMode), fKD(kd) {
     this->initClassID<GrDiffuseLightingEffect>();
 }
 
 bool GrDiffuseLightingEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
     const GrDiffuseLightingEffect& s = sBase.cast<GrDiffuseLightingEffect>();
     return INHERITED::onIsEqual(sBase) &&
             this->kd() == s.kd();
 }
 
 void GrDiffuseLightingEffect::getGLProcessorKey(const GrGLCaps& caps,
@@ skipping 11 matching lines @@
                                               GrContext* context,
                                               const GrDrawTargetCaps&,
                                               GrTexture* textures[]) {
     SkScalar surfaceScale = random->nextSScalar1();
     SkScalar kd = random->nextUScalar1();
     SkAutoTUnref<SkLight> light(create_random_light(random));
     SkMatrix matrix;
     for (int i = 0; i < 9; i++) {
         matrix[i] = random->nextUScalar1();
     }
+    BoundaryMode mode = static_cast<BoundaryMode>(random->nextU() % kBoundaryModeCount);
     return GrDiffuseLightingEffect::Create(textures[GrProcessorUnitTest::kAlphaTextureIdx],
-                                           light, surfaceScale, matrix, kd);
+                                           light, surfaceScale, matrix, kd, mode);
 }
 
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrGLLightingEffect::GrGLLightingEffect(const GrProcessor& fp) {
     const GrLightingEffect& m = fp.cast<GrLightingEffect>();
     fLight = m.light()->createGLLight();
+    fBoundaryMode = m.boundaryMode();
 }
 
 GrGLLightingEffect::~GrGLLightingEffect() {
     delete fLight;
 }
 
 void GrGLLightingEffect::emitCode(GrGLFPBuilder* builder,
                                   const GrFragmentProcessor&,
                                   const char* outputColor,
                                   const char* inputColor,
@@ skipping 30 matching lines @@
     static const GrGLShaderVar gPointToNormalArgs[] =  {
         GrGLShaderVar("x", kFloat_GrSLType),
         GrGLShaderVar("y", kFloat_GrSLType),
         GrGLShaderVar("scale", kFloat_GrSLType),
     };
     SkString pointToNormalName;
     fsBuilder->emitFunction(kVec3f_GrSLType,
                             "pointToNormal",
                             SK_ARRAY_COUNT(gPointToNormalArgs),
                             gPointToNormalArgs,
-                            "\treturn normalize(vec3(-x * scale, y * scale, 1));\n",
+                            "\treturn normalize(vec3(-x * scale, -y * scale, 1));\n",
                             &pointToNormalName);
 
     static const GrGLShaderVar gInteriorNormalArgs[] =  {
         GrGLShaderVar("m", kFloat_GrSLType, 9),
         GrGLShaderVar("surfaceScale", kFloat_GrSLType),
     };
-    SkString interiorNormalBody;
-    interiorNormalBody.appendf("\treturn %s(%s(m[0], m[2], m[3], m[5], m[6], m[8], 0.25),\n"
-                               "\t       %s(m[0], m[6], m[1], m[7], m[2], m[8], 0.25),\n"
-                               "\t       surfaceScale);\n",
-                                pointToNormalName.c_str(),
-                                sobelFuncName.c_str(),
-                                sobelFuncName.c_str());
-    SkString interiorNormalName;
+    SkString normalBody = emitNormalFunc(fBoundaryMode,
+                                         pointToNormalName.c_str(),
+                                         sobelFuncName.c_str());
+    SkString normalName;
     fsBuilder->emitFunction(kVec3f_GrSLType,
-                            "interiorNormal",
+                            "normal",
                             SK_ARRAY_COUNT(gInteriorNormalArgs),
                             gInteriorNormalArgs,
-                            interiorNormalBody.c_str(),
-                            &interiorNormalName);
+                            normalBody.c_str(),
+                            &normalName);
 
     fsBuilder->codeAppendf("\t\tvec2 coord = %s;\n", coords2D.c_str());
     fsBuilder->codeAppend("\t\tfloat m[9];\n");
 
     const char* imgInc = builder->getUniformCStr(fImageIncrementUni);
     const char* surfScale = builder->getUniformCStr(fSurfaceScaleUni);
 
     int index = 0;
-    for (int dy = -1; dy <= 1; dy++) {
+    for (int dy = 1; dy >= -1; dy--) {
         for (int dx = -1; dx <= 1; dx++) {
             SkString texCoords;
             texCoords.appendf("coord + vec2(%d, %d) * %s", dx, dy, imgInc);
             fsBuilder->codeAppendf("\t\tm[%d] = ", index++);
             fsBuilder->appendTextureLookup(samplers[0], texCoords.c_str());
             fsBuilder->codeAppend(".a;\n");
         }
     }
     fsBuilder->codeAppend("\t\tvec3 surfaceToLight = ");
     SkString arg;
     arg.appendf("%s * m[4]", surfScale);
     fLight->emitSurfaceToLight(builder, arg.c_str());
     fsBuilder->codeAppend(";\n");
     fsBuilder->codeAppendf("\t\t%s = %s(%s(m, %s), surfaceToLight, ",
-                           outputColor, lightFunc.c_str(), interiorNormalName.c_str(), surfScale);
+                           outputColor, lightFunc.c_str(), normalName.c_str(), surfScale);
     fLight->emitLightColor(builder, "surfaceToLight");
     fsBuilder->codeAppend(");\n");
     SkString modulate;
     GrGLSLMulVarBy4f(&modulate, outputColor, inputColor);
     fsBuilder->codeAppend(modulate.c_str());
 }
 
 void GrGLLightingEffect::GenKey(const GrProcessor& proc,
                                 const GrGLCaps& caps, GrProcessorKeyBuilder* b) {
-    b->add32(proc.cast<GrLightingEffect>().light()->type());
+    const GrLightingEffect& lighting = proc.cast<GrLightingEffect>();
+    b->add32(lighting.boundaryMode() << 2 | lighting.light()->type());
 }
 
 void GrGLLightingEffect::setData(const GrGLProgramDataManager& pdman,
                                  const GrProcessor& proc) {
     const GrLightingEffect& lighting = proc.cast<GrLightingEffect>();
     GrTexture* texture = lighting.texture(0);
     float ySign = texture->origin() == kTopLeft_GrSurfaceOrigin ? -1.0f : 1.0f;
     pdman.set2f(fImageIncrementUni, 1.0f / texture->width(), ySign / texture->height());
     pdman.set1f(fSurfaceScaleUni, lighting.surfaceScale());
     SkAutoTUnref<SkLight> transformedLight(lighting.light()->transform(lighting.filterMatrix()));
@@ skipping 37 matching lines @@
     pdman.set1f(fKDUni, diffuse.kd());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrSpecularLightingEffect::GrSpecularLightingEffect(GrTexture* texture,
                                                    const SkLight* light,
                                                    SkScalar surfaceScale,
                                                    const SkMatrix& matrix,
                                                    SkScalar ks,
-                                                   SkScalar shininess)
-    : INHERITED(texture, light, surfaceScale, matrix),
+                                                   SkScalar shininess,
+                                                   BoundaryMode boundaryMode)
+    : INHERITED(texture, light, surfaceScale, matrix, boundaryMode),
       fKS(ks),
       fShininess(shininess) {
     this->initClassID<GrSpecularLightingEffect>();
 }
 
 bool GrSpecularLightingEffect::onIsEqual(const GrFragmentProcessor& sBase) const {
     const GrSpecularLightingEffect& s = sBase.cast<GrSpecularLightingEffect>();
     return INHERITED::onIsEqual(sBase) &&
            this->ks() == s.ks() &&
            this->shininess() == s.shininess();
@@ skipping 15 matching lines @@
                                                           const GrDrawTargetCaps&,
                                                           GrTexture* textures[]) {
     SkScalar surfaceScale = random->nextSScalar1();
     SkScalar ks = random->nextUScalar1();
     SkScalar shininess = random->nextUScalar1();
     SkAutoTUnref<SkLight> light(create_random_light(random));
     SkMatrix matrix;
     for (int i = 0; i < 9; i++) {
         matrix[i] = random->nextUScalar1();
     }
+    BoundaryMode mode = static_cast<BoundaryMode>(random->nextU() % kBoundaryModeCount);
     return GrSpecularLightingEffect::Create(textures[GrProcessorUnitTest::kAlphaTextureIdx],
-                                            light, surfaceScale, matrix, ks, shininess);
+                                            light, surfaceScale, matrix, ks, shininess, mode);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 GrGLSpecularLightingEffect::GrGLSpecularLightingEffect(const GrProcessor& proc)
     : INHERITED(proc) {
 }
 
 void GrGLSpecularLightingEffect::emitLightFunc(GrGLFPBuilder* builder, SkString* funcName) {
     const char* ks;
     const char* shininess;
 
     fKSUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
                                  kFloat_GrSLType, kDefault_GrSLPrecision, "KS", &ks);
     fShininessUni = builder->addUniform(GrGLProgramBuilder::kFragment_Visibility,
-                                        kFloat_GrSLType, kDefault_GrSLPrecision, "Shininess", &shininess);
+                                        kFloat_GrSLType,
+                                        kDefault_GrSLPrecision,
+                                        "Shininess",
+                                        &shininess);
 
     static const GrGLShaderVar gLightArgs[] = {
         GrGLShaderVar("normal", kVec3f_GrSLType),
         GrGLShaderVar("surfaceToLight", kVec3f_GrSLType),
         GrGLShaderVar("lightColor", kVec3f_GrSLType)
     };
     SkString lightBody;
     lightBody.appendf("\tvec3 halfDir = vec3(normalize(surfaceToLight + vec3(0, 0, 1)));\n");
     lightBody.appendf("\tfloat colorScale = %s * pow(dot(normal, halfDir), %s);\n", ks, shininess);
     lightBody.appendf("\tvec3 color = lightColor * clamp(colorScale, 0.0, 1.0);\n");
@@ skipping 144 matching lines @@
 
     fsBuilder->codeAppendf("%s(%s)", fLightColorFunc.c_str(), surfaceToLight);
 }
 
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkDiffuseLightingImageFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSpecularLightingImageFilter)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END