Initial error handling code

src/effects/SkFlattenableUtils.cpp

Index: src/effects/SkFlattenableUtils.cpp
diff --git a/src/effects/SkFlattenableUtils.cpp b/src/effects/SkFlattenableUtils.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..ad644c02bf2f7fac4b3481986a0350d0ab8b7737
--- /dev/null
+++ b/src/effects/SkFlattenableUtils.cpp
@@ -0,0 +1,203 @@
+/*
+ * Copyright 2013 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "SkFlattenableUtils.h"
+#include "Sk1DPathEffect.h"
+#include "Sk2DPathEffect.h"
+#include "SkAnnotation.h"
+#include "SkArithmeticMode.h"
+#include "SkAvoidXfermode.h"
+#include "SkBicubicImageFilter.h"
+#include "SkBitmapProcShader.h"
+#include "SkBitmapSource.h"
+#include "SkBlurDrawLooper.h"
+#include "SkBlurImageFilter.h"
+#include "SkBlurMaskFilter.h"
+#include "SkColorFilterImageFilter.h"
+#include "SkColorMatrixFilter.h"
+#include "SkColorShader.h"
+#include "SkColorTable.h"
+#include "SkComposeImageFilter.h"
+#include "SkComposeShader.h"
+#include "SkCornerPathEffect.h"
+#include "SkData.h"
+#include "SkDataSet.h"
+#include "SkDataTable.h"
+#include "SkDiscretePathEffect.h"
+#include "SkDisplacementMapEffect.h"
+#include "SkDropShadowImageFilter.h"
+#include "SkEmbossMaskFilter.h"
+#include "SkEmptyShader.h"
+#include "SkFilterShader.h"
+#include "SkImageRef_GlobalPool.h"
+#include "SkKernel33MaskFilter.h"
+#include "SkLayerDrawLooper.h"
+#include "SkLayerRasterizer.h"
+#include "SkLerpXfermode.h"
+#include "SkLightingImageFilter.h"
+#include "SkLumaXfermode.h"
+#include "SkMagnifierImageFilter.h"
+#include "SkMallocPixelRef.h"
+#include "SkMatrixConvolutionImageFilter.h"
+#include "SkMergeImageFilter.h"
+#include "SkMorphologyImageFilter.h"
+#include "SkOffsetImageFilter.h"
+#include "SkPathEffect.h"
+#include "SkPerlinNoiseShader.h"
+#include "SkPixelXorXfermode.h"
+#include "SkRectShaderImageFilter.h"
+#include "SkStippleMaskFilter.h"
+#include "SkTableColorFilter.h"
+#include "SkTableMaskFilter.h"
+#include "SkTestImageFilters.h"
+#include "SkTileImageFilter.h"
+#include "SkTransparentShader.h"
+#include "SkUnitMappers.h"
+#include "SkXfermode.h"
+#include "SkXfermodeImageFilter.h"
+#include "gradients/SkLinearGradient.h"
+#include "gradients/SkRadialGradient.h"
+#include "gradients/SkSweepGradient.h"
+#include "gradients/SkTwoPointConicalGradient.h"
+#include "gradients/SkTwoPointRadialGradient.h"
+
+namespace {
+
+#define REGISTER_TYPE(type) \
+    typeFunctions[SkFlattenable::k##type##_Type] = \
+        TypeFunctions(type::CreateProc, type::IsA);
+#define REGISTER_TYPE_BASE(type, base) \
+    typeFunctions[SkFlattenable::k##type##_Type] = TypeFunctions( \
+        base::GetFactory(SkFlattenable::k##type##_Type), \
+        base::GetTypeCheck(SkFlattenable::k##type##_Type));
+
+struct TypeFunctions {
+    TypeFunctions() : fFactory(0), fTypeCheck(0) {}
+    TypeFunctions(SkFlattenable::Factory factory, SkFlattenable::TypeCheck typeCheck) :
+        fFactory(factory), fTypeCheck(typeCheck) {}
+    SkFlattenable::Factory fFactory;
+    SkFlattenable::TypeCheck fTypeCheck;
+};
+
+const TypeFunctions& GetFunctions(SkFlattenable::Type type) {
+    static TypeFunctions typeFunctions[SkFlattenable::kTypeCount];
+    static bool init = false;
+    if (!init) {
+        // None : nothing to do
+        // SkFlattenable : nothing to do
+        // SkLightingImageFilter : uninstantiatable - nothing to do
+        // BATShader : not implemented - TODO
+        // Sk3DShader : local to SkBlitter.cpp - TODO
+        // SkLumaMaskXfermodeSrcOver : local to SkLumaXfermode.cpp - TODO
+        // SkDataPixelRef : in image library - skip
+        // SkTriColorShader : not implemented - TODO
+
+        REGISTER_TYPE(Sk2DPathEffect);
+        REGISTER_TYPE(SkAnnotation);
+        REGISTER_TYPE(SkAvoidXfermode);
+        REGISTER_TYPE(SkBicubicImageFilter);
+        REGISTER_TYPE(SkBitmapProcShader);
+        REGISTER_TYPE(SkBitmapSource);
+        REGISTER_TYPE(SkBlurDrawLooper);
+        REGISTER_TYPE(SkBlurImageFilter);
+        REGISTER_TYPE(SkColorFilterImageFilter);
+        REGISTER_TYPE(SkColorMatrixFilter);
+        REGISTER_TYPE(SkColorShader);
+        REGISTER_TYPE(SkColorTable);
+        REGISTER_TYPE(SkComposeImageFilter);
+        REGISTER_TYPE(SkComposePathEffect);
+        REGISTER_TYPE(SkComposeShader);
+        REGISTER_TYPE(SkCornerPathEffect);
+        REGISTER_TYPE(SkCosineMapper);
+        REGISTER_TYPE(SkData);
+        REGISTER_TYPE(SkDataSet);
+        REGISTER_TYPE(SkDataTable);
+        REGISTER_TYPE(SkDilateImageFilter);
+        REGISTER_TYPE(SkDiscreteMapper);
+        REGISTER_TYPE(SkDiscretePathEffect);
+        REGISTER_TYPE(SkDisplacementMapEffect);
+        REGISTER_TYPE(SkDownSampleImageFilter);
+        REGISTER_TYPE(SkDropShadowImageFilter);
+        REGISTER_TYPE(SkEmbossMaskFilter);
+        REGISTER_TYPE(SkEmptyShader);
+        REGISTER_TYPE(SkErodeImageFilter);
+        REGISTER_TYPE(SkFilterShader);
+        REGISTER_TYPE(SkImageRef_GlobalPool);
+        REGISTER_TYPE(SkKernel33MaskFilter);
+        REGISTER_TYPE(SkLayerDrawLooper);
+        REGISTER_TYPE(SkLayerRasterizer);
+        REGISTER_TYPE(SkLerpXfermode);
+        REGISTER_TYPE(SkLinearGradient);
+        REGISTER_TYPE(SkLine2DPathEffect);
+        REGISTER_TYPE(SkLumaMaskXfermode);
+        REGISTER_TYPE(SkMagnifierImageFilter);
+        REGISTER_TYPE(SkMallocPixelRef);
+        REGISTER_TYPE(SkMatrixConvolutionImageFilter);
+        REGISTER_TYPE(SkMergeImageFilter);
+        REGISTER_TYPE(SkOffsetImageFilter);
+        REGISTER_TYPE(SkPath1DPathEffect);
+        REGISTER_TYPE(SkPath2DPathEffect);
+        REGISTER_TYPE(SkPerlinNoiseShader);
+        REGISTER_TYPE(SkPixelXorXfermode);
+        REGISTER_TYPE(SkProcXfermode);
+        REGISTER_TYPE(SkRadialGradient);
+        REGISTER_TYPE(SkRectShaderImageFilter);
+        REGISTER_TYPE(SkStippleMaskFilter);
+        REGISTER_TYPE(SkSumPathEffect);
+        REGISTER_TYPE(SkSweepGradient);
+        REGISTER_TYPE(SkTableMaskFilter);
+        REGISTER_TYPE(SkTileImageFilter);
+        REGISTER_TYPE(SkTransparentShader);
+        REGISTER_TYPE(SkTwoPointConicalGradient);
+        REGISTER_TYPE(SkTwoPointRadialGradient);
+        REGISTER_TYPE(SkXfermodeImageFilter);
+
+        REGISTER_TYPE_BASE(SkArithmeticMode_scalar,         SkArithmeticMode);
+        REGISTER_TYPE_BASE(SkBlurMaskFilterImpl,            SkBlurMaskFilter);
+        REGISTER_TYPE_BASE(SkLightingColorFilter,           SkColorFilter);
+        REGISTER_TYPE_BASE(SkLightingColorFilter_JustAdd,   SkColorFilter);
+        REGISTER_TYPE_BASE(SkLightingColorFilter_JustMul,   SkColorFilter);
+        REGISTER_TYPE_BASE(SkLightingColorFilter_NoPin,     SkColorFilter);
+        REGISTER_TYPE_BASE(SkLightingColorFilter_SingleMul, SkColorFilter);
+        REGISTER_TYPE_BASE(SkLightingColorFilter_JustAdd,   SkColorFilter);
+        REGISTER_TYPE_BASE(SkModeColorFilter,               SkColorFilter);
+        REGISTER_TYPE_BASE(Src_SkModeColorFilter,           SkColorFilter);
+        REGISTER_TYPE_BASE(SrcOver_SkModeColorFilter,       SkColorFilter);
+        REGISTER_TYPE_BASE(SkDiffuseLightingImageFilter,    SkLightingImageFilter);
+        REGISTER_TYPE_BASE(SkDistantLight,                  SkLightingImageFilter);
+        REGISTER_TYPE_BASE(SkPointLight,                    SkLightingImageFilter);
+        REGISTER_TYPE_BASE(SkSpecularLightingImageFilter,   SkLightingImageFilter);
+        REGISTER_TYPE_BASE(SkSpotLight,                     SkLightingImageFilter);
+        REGISTER_TYPE_BASE(SkClearXfermode,                 SkProcXfermode);
+        REGISTER_TYPE_BASE(SkDstInXfermode,                 SkProcXfermode);
+        REGISTER_TYPE_BASE(SkDstOutXfermode,                SkProcXfermode);
+        REGISTER_TYPE_BASE(SkProcCoeffXfermode,             SkProcXfermode);
+        REGISTER_TYPE_BASE(SkSrcXfermode,                   SkProcXfermode);
+        REGISTER_TYPE_BASE(SkTable_ColorFilter,             SkTableColorFilter);
+
+        init = true;
+    }
+    return typeFunctions[(type >= 0) && (type < SkFlattenable::kTypeCount) ?
+                         type : SkFlattenable::kNone_Type];
+}
+
+} // end namespace
+
+namespace SkFlattenableUtils {
+
+// Returns the factory function required to create the given type
+SkFlattenable::Factory TypeToFactory(SkFlattenable::Type type) {
+    return GetFunctions(type).fFactory;
+}
+
+// Checks if typeA is a typeB
+bool TypeIsA(SkFlattenable::Type typeA, SkFlattenable::Type typeB) {
+    SkFlattenable::TypeCheck typeCheck = GetFunctions(typeA).fTypeCheck;
+    return typeCheck ? (*typeCheck)(typeB) : false;
+}
+
+} // end SkFlattenableUtils namespace