Initial error handling code

src/effects/SkBlurMaskFilter.cpp

 
 /*
  * Copyright 2006 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 "SkBlurMaskFilter.h"
 #include "SkBlurMask.h"
 #include "SkGpuBlurUtils.h"
 #include "SkFlattenableBuffers.h"
 #include "SkMaskFilter.h"
 #include "SkRTConf.h"
 #include "SkStringUtils.h"
 #include "SkStrokeRec.h"
 
 #if SK_SUPPORT_GPU
 #include "GrContext.h"
 #include "GrTexture.h"
 #include "effects/GrSimpleTextureEffect.h"
 #include "SkGrPixelRef.h"
 #endif
 
 class SkBlurMaskFilterImpl : public SkMaskFilter {
+    typedef SkMaskFilter INHERITED;
+
 public:
     SkBlurMaskFilterImpl(SkScalar sigma, SkBlurMaskFilter::BlurStyle, uint32_t flags);
 
     // overrides from SkMaskFilter
     virtual SkMask::Format getFormat() const SK_OVERRIDE;
     virtual bool filterMask(SkMask* dst, const SkMask& src, const SkMatrix&,
                             SkIPoint* margin) const SK_OVERRIDE;
 
 #if SK_SUPPORT_GPU
     virtual bool canFilterMaskGPU(const SkRect& devBounds,
@@ skipping 31 matching lines @@
 
     SkBlurMaskFilterImpl(SkFlattenableReadBuffer&);
     virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
 
     SkScalar computeXformedSigma(const SkMatrix& ctm) const {
         bool ignoreTransform = SkToBool(fBlurFlags & SkBlurMaskFilter::kIgnoreTransform_BlurFlag);
 
         SkScalar xformedSigma = ignoreTransform ? fSigma : ctm.mapRadius(fSigma);
         return SkMinScalar(xformedSigma, kMAX_BLUR_SIGMA);
     }
-
-    typedef SkMaskFilter INHERITED;
 };
 
 const SkScalar SkBlurMaskFilterImpl::kMAX_BLUR_SIGMA = SkIntToScalar(128);
 
 SkMaskFilter* SkBlurMaskFilter::Create(SkScalar radius,
                                        SkBlurMaskFilter::BlurStyle style,
                                        uint32_t flags) {
     // use !(radius > 0) instead of radius <= 0 to reject NaN values
     if (!(radius > 0) || (unsigned)style >= SkBlurMaskFilter::kBlurStyleCount
         || flags > SkBlurMaskFilter::kAll_BlurFlag) {
@@ skipping 10 matching lines @@
                                        uint32_t flags) {
     // use !(sigma > 0) instead of sigma <= 0 to reject NaN values
     if (!(sigma > 0) || (unsigned)style >= SkBlurMaskFilter::kBlurStyleCount
         || flags > SkBlurMaskFilter::kAll_BlurFlag) {
         return NULL;
     }
 
     return SkNEW_ARGS(SkBlurMaskFilterImpl, (sigma, style, flags));
 }
 
+SkFlattenable::Factory SkBlurMaskFilter::GetFactory(SkFlattenable::Type type) {
+    switch(type) {
+    case SkFlattenable::kSkBlurMaskFilterImpl:
+        return SkBlurMaskFilterImpl::CreateProc;
+    default:
+        break;
+    }
+    return NULL;
+}
+
+SkFlattenable::TypeCheck SkBlurMaskFilter::GetTypeCheck(SkFlattenable::Type type) {
+    switch(type) {
+    case SkFlattenable::kSkBlurMaskFilterImpl:
+        return SkBlurMaskFilterImpl::IsA;
+    default:
+        break;
+    }
+    return NULL;
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 SkBlurMaskFilterImpl::SkBlurMaskFilterImpl(SkScalar sigma,
                                            SkBlurMaskFilter::BlurStyle style,
                                            uint32_t flags)
     : fSigma(sigma), fBlurStyle(style), fBlurFlags(flags) {
 #if 0
     fGamma = NULL;
     if (gammaScale) {
         fGamma = new U8[256];
@@ skipping 354 matching lines @@
     } else {
         str->append("None");
     }
     str->append("))");
 }
 #endif
 
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_START(SkBlurMaskFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkBlurMaskFilterImpl)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END