Update feSpotLight to match spec

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 837 matching lines @@
 class SkSpotLight : public SkImageFilterLight {
 public:
     SkSpotLight(const SkPoint3& location,
                 const SkPoint3& target,
                 SkScalar specularExponent,
                 SkScalar cutoffAngle,
                 SkColor color)
      : INHERITED(color),
        fLocation(location),
        fTarget(target),
-       fSpecularExponent(SkScalarPin(specularExponent, kSpecularExponentMin, kSpecularExponentMax))

[Stephen White, 2015/10/16 15:03:10]

Although it may not be spec-correct, this was added by sugoi@ back in
https://chromiumcodereview.appspot.com/23533042/ in order to fix a fuzzer issue.
According to that change, large negative values were a problem, presumably
generating near-zero scale when passed to pow(). That said, I tried the unit
test in debug with your change, and it didn't assert, so maybe we're ok.

(By way of explanation, the fuzzer is there to test Skia when run cross-process,
which we do for accelerated filters. Even if Blink applies the correct limits,
we need to protect Skia against a compromised renderer process giving arbitrary
values.)

Also, this seems to be the last use of these min/max constants. We should either
apply them to "shininess" as the spec suggests, or remove them.

[ericrk, 2015/10/16 18:36:23]

Per offline discussion - going to remove and see if fuzz gets mad - will add a
less restrictive limit back if it does. removing constant for now.

+       fSpecularExponent(specularExponent)
     {
        fS = target - location;
        fast_normalize(&fS);
        fCosOuterConeAngle = SkScalarCos(SkDegreesToRadians(cutoffAngle));
        const SkScalar antiAliasThreshold = 0.016f;
        fCosInnerConeAngle = fCosOuterConeAngle + antiAliasThreshold;
        fConeScale = SkScalarInvert(antiAliasThreshold);
     }
 
     SkImageFilterLight* transform(const SkMatrix& matrix) const override {
@@ skipping 1120 matching lines @@
     SkString lightColorBody;
     lightColorBody.appendf("\tfloat cosAngle = -dot(surfaceToLight, %s);\n", s);
     lightColorBody.appendf("\tif (cosAngle < %s) {\n", cosOuter);
     lightColorBody.appendf("\t\treturn vec3(0);\n");
     lightColorBody.appendf("\t}\n");
     lightColorBody.appendf("\tfloat scale = pow(cosAngle, %s);\n", exponent);
     lightColorBody.appendf("\tif (cosAngle < %s) {\n", cosInner);
     lightColorBody.appendf("\t\treturn %s * scale * (cosAngle - %s) * %s;\n",
                            color, cosOuter, coneScale);
     lightColorBody.appendf("\t}\n");
-    lightColorBody.appendf("\treturn %s;\n", color);
+    lightColorBody.appendf("\treturn %s * scale;\n", color);
     GrGLFragmentBuilder* fsBuilder = builder->getFragmentShaderBuilder();
     fsBuilder->emitFunction(kVec3f_GrSLType,
                             "lightColor",
                             SK_ARRAY_COUNT(gLightColorArgs),
                             gLightColorArgs,
                             lightColorBody.c_str(),
                             &fLightColorFunc);
 
     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