Initial error handling code

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 231 matching lines @@
         surfaceToLight = l->surfaceToLight(x, y, m[4], surfaceScale);
         *dptr++ = lightingType.light(bottomRightNormal(m, surfaceScale), surfaceToLight, l->lightColor(surfaceToLight));
     }
 }
 
 SkPoint3 readPoint3(SkFlattenableReadBuffer& buffer) {
     SkPoint3 point;
     point.fX = buffer.readScalar();
     point.fY = buffer.readScalar();
     point.fZ = buffer.readScalar();
+    buffer.validate(SkScalarIsFinite(point.fX) &&
+                    SkScalarIsFinite(point.fY) &&
+                    SkScalarIsFinite(point.fZ));
     return point;
 };
 
 void writePoint3(const SkPoint3& point, SkFlattenableWriteBuffer& buffer) {
     buffer.writeScalar(point.fX);
     buffer.writeScalar(point.fY);
     buffer.writeScalar(point.fZ);
 };
 
 class SkDiffuseLightingImageFilter : public SkLightingImageFilter {
+    typedef SkLightingImageFilter INHERITED;
+
 public:
     SkDiffuseLightingImageFilter(SkLight* light, SkScalar surfaceScale,
                                  SkScalar kd, SkImageFilter* input, const SkIRect* cropRect);
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkDiffuseLightingImageFilter)
 
 #if SK_SUPPORT_GPU
     virtual bool asNewEffect(GrEffectRef** effect, GrTexture*, const SkMatrix& matrix) 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 {
+    typedef SkLightingImageFilter INHERITED;
+
 public:
     SkSpecularLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar ks, SkScalar shininess, SkImageFilter* input, const SkIRect* cropRect);
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkSpecularLightingImageFilter)
 
 #if SK_SUPPORT_GPU
     virtual bool asNewEffect(GrEffectRef** effect, GrTexture*, const SkMatrix& matrix) 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:
-    typedef SkLightingImageFilter INHERITED;
     SkScalar fKS;
     SkScalar fShininess;
 };
 
 #if SK_SUPPORT_GPU
 
 class GrLightingEffect : public GrSingleTextureEffect {
 public:
     GrLightingEffect(GrTexture* texture, const SkLight* light, SkScalar surfaceScale, const SkMatrix& matrix);
     virtual ~GrLightingEffect();
@@ skipping 188 matching lines @@
 
 class GrGLLight;
 
 #endif
 
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class SkLight : public SkFlattenable {
+    typedef SkFlattenable INHERITED;
+
 public:
     SK_DECLARE_INST_COUNT(SkLight)
 
     enum LightType {
         kDistant_LightType,
         kPoint_LightType,
         kSpot_LightType,
     };
     virtual LightType type() const = 0;
     const SkPoint3& color() const { return fColor; }
     virtual GrGLLight* createGLLight() const = 0;
     virtual bool isEqual(const SkLight& other) const {
         return fColor == other.fColor;
     }
     // Called to know whether the generated GrGLLight will require access to the fragment position.
     virtual bool requiresFragmentPosition() const = 0;
     virtual SkLight* transform(const SkMatrix& matrix) const = 0;
 
+    SK_DEFINE_FLATTENABLE_TYPE(SkLight)
+
 protected:
     SkLight(SkColor color)
       : fColor(SkIntToScalar(SkColorGetR(color)),
                SkIntToScalar(SkColorGetG(color)),
                SkIntToScalar(SkColorGetB(color))) {}
     SkLight(const SkPoint3& color)
       : fColor(color) {}
     SkLight(SkFlattenableReadBuffer& buffer)
       : INHERITED(buffer) {
         fColor = readPoint3(buffer);
     }
     virtual void flatten(SkFlattenableWriteBuffer& buffer) const SK_OVERRIDE {
         INHERITED::flatten(buffer);
         writePoint3(fColor, buffer);
     }
 
 private:
-    typedef SkFlattenable INHERITED;
     SkPoint3 fColor;
 };
 
 SK_DEFINE_INST_COUNT(SkLight)
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class SkDistantLight : public SkLight {
+    typedef SkLight INHERITED;
+
 public:
     SkDistantLight(const SkPoint3& direction, SkColor color)
       : INHERITED(color), fDirection(direction) {
     }
 
     SkPoint3 surfaceToLight(int x, int y, int z, SkScalar surfaceScale) const {
         return fDirection;
     };
     SkPoint3 lightColor(const SkPoint3&) const { return color(); }
     virtual LightType type() const { return kDistant_LightType; }
@@ skipping 29 matching lines @@
     }
     virtual SkLight* transform(const SkMatrix& matrix) const {
         return new SkDistantLight(direction(), color());
     }
     virtual void flatten(SkFlattenableWriteBuffer& buffer) const {
         INHERITED::flatten(buffer);
         writePoint3(fDirection, buffer);
     }
 
 private:
-    typedef SkLight INHERITED;
     SkPoint3 fDirection;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class SkPointLight : public SkLight {
+    typedef SkLight INHERITED;
+
 public:
     SkPointLight(const SkPoint3& location, SkColor color)
      : INHERITED(color), fLocation(location) {}
 
     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;
@@ skipping 32 matching lines @@
         fLocation = readPoint3(buffer);
     }
     SkPointLight(const SkPoint3& location, const SkPoint3& color)
      : INHERITED(color), fLocation(location) {}
     virtual void flatten(SkFlattenableWriteBuffer& buffer) const {
         INHERITED::flatten(buffer);
         writePoint3(fLocation, buffer);
     }
 
 private:
-    typedef SkLight INHERITED;
     SkPoint3 fLocation;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class SkSpotLight : public SkLight {
+    typedef SkLight INHERITED;
+
 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))
     {
        fS = target - location;
        fS.normalize();
        fCosOuterConeAngle = SkScalarCos(SkDegreesToRadians(cutoffAngle));
@@ skipping 53 matching lines @@
 
 protected:
     SkSpotLight(SkFlattenableReadBuffer& buffer) : INHERITED(buffer) {
         fLocation = readPoint3(buffer);
         fTarget = readPoint3(buffer);
         fSpecularExponent = buffer.readScalar();
         fCosOuterConeAngle = buffer.readScalar();
         fCosInnerConeAngle = buffer.readScalar();
         fConeScale = buffer.readScalar();
         fS = readPoint3(buffer);
+        buffer.validate(SkScalarIsFinite(fSpecularExponent) &&
+                        SkScalarIsFinite(fCosOuterConeAngle) &&
+                        SkScalarIsFinite(fCosInnerConeAngle) &&
+                        SkScalarIsFinite(fConeScale));
     }
     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 20 matching lines @@
                fLocation == o.fLocation &&
                fTarget == o.fTarget &&
                fSpecularExponent == o.fSpecularExponent &&
                fCosOuterConeAngle == o.fCosOuterConeAngle;
     }
 
 private:
     static const SkScalar kSpecularExponentMin;
     static const SkScalar kSpecularExponentMax;
 
-    typedef SkLight INHERITED;
     SkPoint3 fLocation;
     SkPoint3 fTarget;
     SkScalar fSpecularExponent;
     SkScalar fCosOuterConeAngle;
     SkScalar fCosInnerConeAngle;
     SkScalar fConeScale;
     SkPoint3 fS;
 };
 
 // According to the spec, the specular term should be in the range [1, 128] :
@@ skipping 59 matching lines @@
 SkImageFilter* SkLightingImageFilter::CreateSpotLitSpecular(
     const SkPoint3& location, const SkPoint3& target,
     SkScalar specularExponent, SkScalar cutoffAngle,
     SkColor lightColor, SkScalar surfaceScale,
     SkScalar ks, SkScalar shininess, SkImageFilter* input, const SkIRect* cropRect) {
     return SkNEW_ARGS(SkSpecularLightingImageFilter,
         (SkNEW_ARGS(SkSpotLight, (location, target, specularExponent, cutoffAngle, lightColor)),
         surfaceScale, ks, shininess, input, cropRect));
 }
 
+SkFlattenable::Factory SkLightingImageFilter::GetFactory(SkFlattenable::Type type) {
+    switch(type) {
+    case SkFlattenable::kSkDiffuseLightingImageFilter:
+        return SkDiffuseLightingImageFilter::CreateProc;
+    case SkFlattenable::kSkDistantLight:
+        return SkDistantLight::CreateProc;
+    case SkFlattenable::kSkPointLight:
+        return SkPointLight::CreateProc;
+    case SkFlattenable::kSkSpecularLightingImageFilter:
+        return SkSpecularLightingImageFilter::CreateProc;
+    case SkFlattenable::kSkSpotLight:
+        return SkSpotLight::CreateProc;
+    default:
+        break;
+    }
+    return NULL;
+}
+
+SkFlattenable::TypeCheck SkLightingImageFilter::GetTypeCheck(SkFlattenable::Type type) {
+    switch(type) {
+    case SkFlattenable::kSkDiffuseLightingImageFilter:
+        return SkDiffuseLightingImageFilter::IsA;
+    case SkFlattenable::kSkDistantLight:
+        return SkDistantLight::IsA;
+    case SkFlattenable::kSkPointLight:
+        return SkPointLight::IsA;
+    case SkFlattenable::kSkSpecularLightingImageFilter:
+        return SkSpecularLightingImageFilter::IsA;
+    case SkFlattenable::kSkSpotLight:
+        return SkSpotLight::IsA;
+    default:
+        break;
+    }
+    return NULL;
+}
+
 SkLightingImageFilter::~SkLightingImageFilter() {
     fLight->unref();
 }
 
 SkLightingImageFilter::SkLightingImageFilter(SkFlattenableReadBuffer& buffer)
   : INHERITED(buffer)
 {
     fLight = buffer.readFlattenableT<SkLight>();
     fSurfaceScale = buffer.readScalar();
+    buffer.validate(SkScalarIsFinite(fSurfaceScale));
 }
 
 void SkLightingImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeFlattenable(fLight);
     buffer.writeScalar(fSurfaceScale);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkDiffuseLightingImageFilter::SkDiffuseLightingImageFilter(SkLight* light, SkScalar surfaceScale, SkScalar kd, SkImageFilter* input, const SkIRect* cropRect = NULL)
   : SkLightingImageFilter(light, surfaceScale, input, cropRect),
     fKD(kd)
 {
 }
 
 SkDiffuseLightingImageFilter::SkDiffuseLightingImageFilter(SkFlattenableReadBuffer& buffer)
   : INHERITED(buffer)
 {
     fKD = buffer.readScalar();
+    buffer.validate(SkScalarIsFinite(fKD));
 }
 
 void SkDiffuseLightingImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeScalar(fKD);
 }
 
 bool SkDiffuseLightingImageFilter::onFilterImage(Proxy*,
                                                  const SkBitmap& src,
                                                  const SkMatrix& ctm,
@@ skipping 57 matching lines @@
     fKS(ks),
     fShininess(shininess)
 {
 }
 
 SkSpecularLightingImageFilter::SkSpecularLightingImageFilter(SkFlattenableReadBuffer& buffer)
   : INHERITED(buffer)
 {
     fKS = buffer.readScalar();
     fShininess = buffer.readScalar();
+    buffer.validate(SkScalarIsFinite(fKS) &&
+                    SkScalarIsFinite(fShininess));
 }
 
 void SkSpecularLightingImageFilter::flatten(SkFlattenableWriteBuffer& buffer) const {
     this->INHERITED::flatten(buffer);
     buffer.writeScalar(fKS);
     buffer.writeScalar(fShininess);
 }
 
 bool SkSpecularLightingImageFilter::onFilterImage(Proxy*,
                                                   const SkBitmap& src,
@@ skipping 592 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