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..8d1641f88ae51dbf7210edda1ecef2d6ae795dc7
--- /dev/null
+++ b/src/effects/SkFlattenableUtils.cpp
@@ -0,0 +1,288 @@
+/*
+ * 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 "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 {
+
+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) {

[mtklein, 2013/09/24 22:52:18]

We're going to have to come up with some way to manage the complexity here. 
This is sort of, unmaintainable.

Is there any way we can make this part of the registration?  If not, this may be
the place to use a judicious macro or two.

[sugoi1, 2013/09/25 21:15:27]

Agreed. I'll try to think of a way to make the code clearer here. It shouldn't
be too hard :)

+    static TypeFunctions typeFunctions[SkFlattenable::kTypeCount];
+    static bool init = false;
+    if (!init) {
+        // SkFlattenable::kNone : nothing to do
+        // SkFlattenable::kSkFlattenable : nothing to do
+        // SkFlattenable::kBATShader : not implemented - TODO
+        typeFunctions[SkFlattenable::kSk2DPathEffect] =
+            TypeFunctions(Sk2DPathEffect::CreateProc, Sk2DPathEffect::IsA);
+        // SkFlattenable::kSk3DShader : local to SkBlitter.cpp - TODO
+        typeFunctions[SkFlattenable::kSkAnnotation] =
+            TypeFunctions(SkAnnotation::CreateProc, SkAnnotation::IsA);
+        typeFunctions[SkFlattenable::kSkArithmeticMode_scalar] = TypeFunctions(
+            SkArithmeticMode::GetFactory(SkFlattenable::kSkArithmeticMode_scalar),
+            SkArithmeticMode::GetTypeCheck(SkFlattenable::kSkArithmeticMode_scalar));
+        typeFunctions[SkFlattenable::kSkAvoidXfermode] =
+            TypeFunctions(SkAvoidXfermode::CreateProc, SkAvoidXfermode::IsA);
+        typeFunctions[SkFlattenable::kSkBicubicImageFilter] =
+            TypeFunctions(SkBicubicImageFilter::CreateProc, SkBicubicImageFilter::IsA);
+        typeFunctions[SkFlattenable::kSkBitmapProcShader] =
+            TypeFunctions(SkBitmapProcShader::CreateProc, SkBitmapProcShader::IsA);
+        typeFunctions[SkFlattenable::kSkBitmapSource] =
+            TypeFunctions(SkBitmapSource::CreateProc, SkBitmapSource::IsA);
+        typeFunctions[SkFlattenable::kSkBlurDrawLooper] =
+            TypeFunctions(SkBlurDrawLooper::CreateProc, SkBlurDrawLooper::IsA);
+        typeFunctions[SkFlattenable::kSkBlurImageFilter] =
+            TypeFunctions(SkBlurImageFilter::CreateProc, SkBlurImageFilter::IsA);
+        typeFunctions[SkFlattenable::kSkBlurMaskFilterImpl] = TypeFunctions(
+            SkBlurMaskFilter::GetFactory(SkFlattenable::kSkBlurMaskFilterImpl),
+            SkBlurMaskFilter::GetTypeCheck(SkFlattenable::kSkBlurMaskFilterImpl));
+        typeFunctions[SkFlattenable::kSkClearXfermode] = TypeFunctions(
+            SkProcXfermode::GetFactory(SkFlattenable::kSkClearXfermode),
+            SkProcXfermode::GetTypeCheck(SkFlattenable::kSkClearXfermode));
+        typeFunctions[SkFlattenable::kSkColorFilterImageFilter] =
+            TypeFunctions(SkColorFilterImageFilter::CreateProc, SkColorFilterImageFilter::IsA);
+        typeFunctions[SkFlattenable::kSkColorMatrixFilter] =
+            TypeFunctions(SkColorMatrixFilter::CreateProc, SkColorMatrixFilter::IsA);
+        typeFunctions[SkFlattenable::kSkColorShader] =
+            TypeFunctions(SkColorShader::CreateProc, SkColorShader::IsA);
+        typeFunctions[SkFlattenable::kSkColorTable] =
+            TypeFunctions(SkColorTable::CreateProc, SkColorTable::IsA);
+        typeFunctions[SkFlattenable::kSkComposeImageFilter] =
+            TypeFunctions(SkComposeImageFilter::CreateProc, SkComposeImageFilter::IsA);
+        typeFunctions[SkFlattenable::kSkComposePathEffect] =
+            TypeFunctions(SkComposePathEffect::CreateProc, SkComposePathEffect::IsA);
+        typeFunctions[SkFlattenable::kSkComposeShader] =
+            TypeFunctions(SkComposeShader::CreateProc, SkComposeShader::IsA);
+        typeFunctions[SkFlattenable::kSkCornerPathEffect] =
+            TypeFunctions(SkCornerPathEffect::CreateProc, SkCornerPathEffect::IsA);
+        typeFunctions[SkFlattenable::kSkCosineMapper] =
+            TypeFunctions(SkCosineMapper::CreateProc, SkCosineMapper::IsA);
+        typeFunctions[SkFlattenable::kSkData] =
+            TypeFunctions(SkData::CreateProc, SkData::IsA);
+        // SkFlattenable::kSkDataPixelRef : in image library - skip
+        typeFunctions[SkFlattenable::kSkDataSet] =
+            TypeFunctions(SkDataSet::CreateProc, SkDataSet::IsA);
+        typeFunctions[SkFlattenable::kSkDataTable] =
+            TypeFunctions(SkDataTable::CreateProc, SkDataTable::IsA);
+        typeFunctions[SkFlattenable::kSkDiffuseLightingImageFilter] = TypeFunctions(
+            SkLightingImageFilter::GetFactory(SkFlattenable::kSkDiffuseLightingImageFilter),
+            SkLightingImageFilter::GetTypeCheck(SkFlattenable::kSkDiffuseLightingImageFilter));
+        typeFunctions[SkFlattenable::kSkDilateImageFilter] =
+            TypeFunctions(SkDilateImageFilter::CreateProc, SkDilateImageFilter::IsA);
+        typeFunctions[SkFlattenable::kSkDiscreteMapper] =
+            TypeFunctions(SkDiscreteMapper::CreateProc, SkDiscreteMapper::IsA);
+        typeFunctions[SkFlattenable::kSkDiscretePathEffect] =
+            TypeFunctions(SkDiscretePathEffect::CreateProc, SkDiscretePathEffect::IsA);
+        typeFunctions[SkFlattenable::kSkDisplacementMapEffect] =
+            TypeFunctions(SkDisplacementMapEffect::CreateProc, SkDisplacementMapEffect::IsA);
+        typeFunctions[SkFlattenable::kSkDistantLight] = TypeFunctions(
+            SkLightingImageFilter::GetFactory(SkFlattenable::kSkDistantLight),
+            SkLightingImageFilter::GetTypeCheck(SkFlattenable::kSkDistantLight));
+        typeFunctions[SkFlattenable::kSkDownSampleImageFilter] =
+            TypeFunctions(SkDownSampleImageFilter::CreateProc, SkDownSampleImageFilter::IsA);
+        typeFunctions[SkFlattenable::kSkDropShadowImageFilter] =
+            TypeFunctions(SkDropShadowImageFilter::CreateProc, SkDropShadowImageFilter::IsA);
+        typeFunctions[SkFlattenable::kSkDstInXfermode] = TypeFunctions(
+            SkProcXfermode::GetFactory(SkFlattenable::kSkDstInXfermode),
+            SkProcXfermode::GetTypeCheck(SkFlattenable::kSkDstInXfermode));
+        typeFunctions[SkFlattenable::kSkDstOutXfermode] = TypeFunctions(
+            SkProcXfermode::GetFactory(SkFlattenable::kSkDstOutXfermode),
+            SkProcXfermode::GetTypeCheck(SkFlattenable::kSkDstOutXfermode));
+        typeFunctions[SkFlattenable::kSkEmbossMaskFilter] =
+            TypeFunctions(SkEmbossMaskFilter::CreateProc, SkEmbossMaskFilter::IsA);
+        typeFunctions[SkFlattenable::kSkEmptyShader] =
+            TypeFunctions(SkEmptyShader::CreateProc, SkEmptyShader::IsA);
+        typeFunctions[SkFlattenable::kSkErodeImageFilter] =
+            TypeFunctions(SkErodeImageFilter::CreateProc, SkErodeImageFilter::IsA);
+        typeFunctions[SkFlattenable::kSkFilterShader] =
+            TypeFunctions(SkFilterShader::CreateProc, SkFilterShader::IsA);
+        typeFunctions[SkFlattenable::kSkImageRef_GlobalPool] =
+            TypeFunctions(SkImageRef_GlobalPool::CreateProc, SkImageRef_GlobalPool::IsA);
+        typeFunctions[SkFlattenable::kSkKernel33MaskFilter] =
+            TypeFunctions(SkKernel33MaskFilter::CreateProc, SkKernel33MaskFilter::IsA);
+        typeFunctions[SkFlattenable::kSkLayerDrawLooper] =
+            TypeFunctions(SkLayerDrawLooper::CreateProc, SkLayerDrawLooper::IsA);
+        typeFunctions[SkFlattenable::kSkLayerRasterizer] =
+            TypeFunctions(SkLayerRasterizer::CreateProc, SkLayerRasterizer::IsA);
+        typeFunctions[SkFlattenable::kSkLerpXfermode] =
+            TypeFunctions(SkLerpXfermode::CreateProc, SkLerpXfermode::IsA);
+        typeFunctions[SkFlattenable::kSkLightingColorFilter] = TypeFunctions(
+            SkColorFilter::GetFactory(SkFlattenable::kSkLightingColorFilter),
+            SkColorFilter::GetTypeCheck(SkFlattenable::kSkLightingColorFilter));
+        typeFunctions[SkFlattenable::kSkLightingColorFilter_JustAdd] = TypeFunctions(
+            SkColorFilter::GetFactory(SkFlattenable::kSkLightingColorFilter_JustAdd),
+            SkColorFilter::GetTypeCheck(SkFlattenable::kSkLightingColorFilter_JustAdd));
+        typeFunctions[SkFlattenable::kSkLightingColorFilter_JustMul] = TypeFunctions(
+            SkColorFilter::GetFactory(SkFlattenable::kSkLightingColorFilter_JustMul),
+            SkColorFilter::GetTypeCheck(SkFlattenable::kSkLightingColorFilter_JustMul));
+        typeFunctions[SkFlattenable::kSkLightingColorFilter_NoPin] = TypeFunctions(
+            SkColorFilter::GetFactory(SkFlattenable::kSkLightingColorFilter_NoPin),
+            SkColorFilter::GetTypeCheck(SkFlattenable::kSkLightingColorFilter_NoPin));
+        typeFunctions[SkFlattenable::kSkLightingColorFilter_SingleMul] = TypeFunctions(
+            SkColorFilter::GetFactory(SkFlattenable::kSkLightingColorFilter_SingleMul),
+            SkColorFilter::GetTypeCheck(SkFlattenable::kSkLightingColorFilter_SingleMul));
+        typeFunctions[SkFlattenable::kSkLinearGradient] =
+            TypeFunctions(SkLinearGradient::CreateProc, SkLinearGradient::IsA);
+        typeFunctions[SkFlattenable::kSkLine2DPathEffect] =
+            TypeFunctions(SkLine2DPathEffect::CreateProc, SkLine2DPathEffect::IsA);
+        typeFunctions[SkFlattenable::kSkLumaMaskXfermode] =
+            TypeFunctions(SkLumaMaskXfermode::CreateProc, SkLumaMaskXfermode::IsA);
+        // SkFlattenable::kSkLumaMaskXfermodeSrcOver : local to SkLumaXfermode.cpp - TODO
+        typeFunctions[SkFlattenable::kSkMagnifierImageFilter] =
+            TypeFunctions(SkMagnifierImageFilter::CreateProc, SkMagnifierImageFilter::IsA);
+        typeFunctions[SkFlattenable::kSkMallocPixelRef] =
+            TypeFunctions(SkMallocPixelRef::CreateProc, SkMallocPixelRef::IsA);
+        typeFunctions[SkFlattenable::kSkMatrixConvolutionImageFilter] =
+            TypeFunctions(SkMatrixConvolutionImageFilter::CreateProc, SkMatrixConvolutionImageFilter::IsA);
+        typeFunctions[SkFlattenable::kSkMergeImageFilter] =
+            TypeFunctions(SkMergeImageFilter::CreateProc, SkMergeImageFilter::IsA);
+        typeFunctions[SkFlattenable::kSkModeColorFilter] = TypeFunctions(
+            SkColorFilter::GetFactory(SkFlattenable::kSkModeColorFilter),
+            SkColorFilter::GetTypeCheck(SkFlattenable::kSkModeColorFilter));
+        typeFunctions[SkFlattenable::kSkOffsetImageFilter] =
+            TypeFunctions(SkOffsetImageFilter::CreateProc, SkOffsetImageFilter::IsA);
+        typeFunctions[SkFlattenable::kSkPath1DPathEffect] =
+            TypeFunctions(SkPath1DPathEffect::CreateProc, SkPath1DPathEffect::IsA);
+        typeFunctions[SkFlattenable::kSkPath2DPathEffect] =
+            TypeFunctions(SkPath2DPathEffect::CreateProc, SkPath2DPathEffect::IsA);
+        typeFunctions[SkFlattenable::kSkPerlinNoiseShader] =
+            TypeFunctions(SkPerlinNoiseShader::CreateProc, SkPerlinNoiseShader::IsA);
+        typeFunctions[SkFlattenable::kSkPixelXorXfermode] =
+            TypeFunctions(SkPixelXorXfermode::CreateProc, SkPixelXorXfermode::IsA);
+        typeFunctions[SkFlattenable::kSkPointLight] = TypeFunctions(
+            SkLightingImageFilter::GetFactory(SkFlattenable::kSkPointLight),
+            SkLightingImageFilter::GetTypeCheck(SkFlattenable::kSkPointLight));
+        typeFunctions[SkFlattenable::kSkProcCoeffXfermode] = TypeFunctions(
+            SkProcXfermode::GetFactory(SkFlattenable::kSkProcCoeffXfermode),
+            SkProcXfermode::GetTypeCheck(SkFlattenable::kSkProcCoeffXfermode));
+        typeFunctions[SkFlattenable::kSkProcXfermode] =
+            TypeFunctions(SkProcXfermode::CreateProc, SkProcXfermode::IsA);
+        typeFunctions[SkFlattenable::kSkRadialGradient] =
+            TypeFunctions(SkRadialGradient::CreateProc, SkRadialGradient::IsA);
+        typeFunctions[SkFlattenable::kSkRectShaderImageFilter] =
+            TypeFunctions(SkRectShaderImageFilter::CreateProc, SkRectShaderImageFilter::IsA);
+        typeFunctions[SkFlattenable::kSkSpecularLightingImageFilter] = TypeFunctions(
+            SkLightingImageFilter::GetFactory(SkFlattenable::kSkSpecularLightingImageFilter),
+            SkLightingImageFilter::GetTypeCheck(SkFlattenable::kSkSpecularLightingImageFilter));
+        typeFunctions[SkFlattenable::kSkSpotLight] = TypeFunctions(
+            SkLightingImageFilter::GetFactory(SkFlattenable::kSkSpotLight),
+            SkLightingImageFilter::GetTypeCheck(SkFlattenable::kSkSpotLight));
+        typeFunctions[SkFlattenable::kSkSrcXfermode] = TypeFunctions(
+            SkProcXfermode::GetFactory(SkFlattenable::kSkSrcXfermode),
+            SkProcXfermode::GetTypeCheck(SkFlattenable::kSkSrcXfermode));
+        typeFunctions[SkFlattenable::kSkStippleMaskFilter] =
+            TypeFunctions(SkStippleMaskFilter::CreateProc, SkStippleMaskFilter::IsA);
+        typeFunctions[SkFlattenable::kSkSumPathEffect] =
+            TypeFunctions(SkSumPathEffect::CreateProc, SkSumPathEffect::IsA);
+        typeFunctions[SkFlattenable::kSkSweepGradient] =
+            TypeFunctions(SkSweepGradient::CreateProc, SkSweepGradient::IsA);
+        typeFunctions[SkFlattenable::kSkTable_ColorFilter] = TypeFunctions(
+            SkTableColorFilter::GetFactory(SkFlattenable::kSkTable_ColorFilter),
+            SkTableColorFilter::GetTypeCheck(SkFlattenable::kSkTable_ColorFilter));
+        typeFunctions[SkFlattenable::kSkTableMaskFilter] =
+            TypeFunctions(SkTableMaskFilter::CreateProc, SkTableMaskFilter::IsA);
+        typeFunctions[SkFlattenable::kSkTransparentShader] =
+            TypeFunctions(SkTransparentShader::CreateProc, SkTransparentShader::IsA);
+        // SkFlattenable::kSkTriColorShader : not implemented - TODO
+        typeFunctions[SkFlattenable::kSkTwoPointConicalGradient] =
+            TypeFunctions(SkTwoPointConicalGradient::CreateProc, SkTwoPointConicalGradient::IsA);
+        typeFunctions[SkFlattenable::kSkTwoPointRadialGradient] =
+            TypeFunctions(SkTwoPointRadialGradient::CreateProc, SkTwoPointRadialGradient::IsA);
+        typeFunctions[SkFlattenable::kSkXfermodeImageFilter] =
+            TypeFunctions(SkXfermodeImageFilter::CreateProc, SkXfermodeImageFilter::IsA);
+        typeFunctions[SkFlattenable::kSrc_SkModeColorFilter] = TypeFunctions(
+            SkColorFilter::GetFactory(SkFlattenable::kSrc_SkModeColorFilter),
+            SkColorFilter::GetTypeCheck(SkFlattenable::kSrc_SkModeColorFilter));
+        typeFunctions[SkFlattenable::kSrcOver_SkModeColorFilter] = TypeFunctions(
+            SkColorFilter::GetFactory(SkFlattenable::kSrcOver_SkModeColorFilter),
+            SkColorFilter::GetTypeCheck(SkFlattenable::kSrcOver_SkModeColorFilter));
+
+        init = true;
+    }
+    return typeFunctions[(type < SkFlattenable::kTypeCount) ? type : SkFlattenable::kNone];
+}
+
+} // 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