Fix for potential typedef issue

src/effects/SkColorFilters.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 "SkBlitRow.h"
 #include "SkColorFilter.h"
 #include "SkColorPriv.h"
 #include "SkFlattenableBuffers.h"
 #include "SkUtils.h"
 #include "SkString.h"
 
 #define ILLEGAL_XFERMODE_MODE   ((SkXfermode::Mode)-1)
 
 // baseclass for filters that store a color and mode
 class SkModeColorFilter : public SkColorFilter {
+    typedef SkColorFilter INHERITED;
+
 public:
     SkModeColorFilter(SkColor color) {
         fColor = color;
         fMode = ILLEGAL_XFERMODE_MODE;
         this->updateCache();
     }
 
     SkModeColorFilter(SkColor color, SkXfermode::Mode mode) {
         fColor = color;
         fMode = mode;
@@ skipping 75 matching lines @@
     // cache
     SkPMColor           fPMColor;
     SkXfermodeProc      fProc;
     SkXfermodeProc16    fProc16;
 
     void updateCache() {
         fPMColor = SkPreMultiplyColor(fColor);
         fProc = SkXfermode::GetProc(fMode);
         fProc16 = SkXfermode::GetProc16(fMode, fColor);
     }
-
-    typedef SkColorFilter INHERITED;
 };
 
 class Src_SkModeColorFilter : public SkModeColorFilter {
+    typedef SkModeColorFilter INHERITED;
+
 public:
     Src_SkModeColorFilter(SkColor color) : INHERITED(color, SkXfermode::kSrc_Mode) {}
 
     virtual uint32_t getFlags() const SK_OVERRIDE {
         if (SkGetPackedA32(this->getPMColor()) == 0xFF) {
             return kAlphaUnchanged_Flag | kHasFilter16_Flag;
         } else {
             return 0;
         }
     }
 
     virtual void filterSpan(const SkPMColor shader[], int count,
                             SkPMColor result[]) const SK_OVERRIDE {
         sk_memset32(result, this->getPMColor(), count);
     }
 
     virtual void filterSpan16(const uint16_t shader[], int count,
                               uint16_t result[]) const SK_OVERRIDE {
         SkASSERT(this->getFlags() & kHasFilter16_Flag);
         sk_memset16(result, SkPixel32ToPixel16(this->getPMColor()), count);
     }
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(Src_SkModeColorFilter)
 
 protected:
     Src_SkModeColorFilter(SkFlattenableReadBuffer& buffer)
         : INHERITED(buffer) {}
-
-private:
-    typedef SkModeColorFilter INHERITED;
 };
 
 class SrcOver_SkModeColorFilter : public SkModeColorFilter {
+    typedef SkModeColorFilter INHERITED;
+
 public:
     SrcOver_SkModeColorFilter(SkColor color)
             : INHERITED(color, SkXfermode::kSrcOver_Mode) {
         fColor32Proc = SkBlitRow::ColorProcFactory();
     }
 
     virtual uint32_t getFlags() const SK_OVERRIDE {
         if (SkGetPackedA32(this->getPMColor()) == 0xFF) {
             return kAlphaUnchanged_Flag | kHasFilter16_Flag;
         } else {
@@ skipping 16 matching lines @@
 
 protected:
     SrcOver_SkModeColorFilter(SkFlattenableReadBuffer& buffer)
         : INHERITED(buffer) {
             fColor32Proc = SkBlitRow::ColorProcFactory();
         }
 
 private:
 
     SkBlitRow::ColorProc fColor32Proc;
-
-    typedef SkModeColorFilter INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 SkColorFilter* SkColorFilter::CreateModeFilter(SkColor color,
                                                SkXfermode::Mode mode) {
     unsigned alpha = SkColorGetA(color);
 
     // first collaps some modes if possible
 
@@ skipping 34 matching lines @@
 ///////////////////////////////////////////////////////////////////////////////
 
 static inline unsigned pin(unsigned value, unsigned max) {
     if (value > max) {
         value = max;
     }
     return value;
 }
 
 class SkLightingColorFilter : public SkColorFilter {
+    typedef SkColorFilter INHERITED;
+
 public:
     SkLightingColorFilter(SkColor mul, SkColor add) : fMul(mul), fAdd(add) {}
 
     virtual void filterSpan(const SkPMColor shader[], int count,
                             SkPMColor result[]) const SK_OVERRIDE {
         unsigned scaleR = SkAlpha255To256(SkColorGetR(fMul));
         unsigned scaleG = SkAlpha255To256(SkColorGetG(fMul));
         unsigned scaleB = SkAlpha255To256(SkColorGetB(fMul));
 
         unsigned addR = SkColorGetR(fAdd);
@@ skipping 31 matching lines @@
         buffer.writeColor(fMul);
         buffer.writeColor(fAdd);
     }
 
     SkLightingColorFilter(SkFlattenableReadBuffer& buffer) {
         fMul = buffer.readColor();
         fAdd = buffer.readColor();
     }
 
     SkColor fMul, fAdd;
-
-private:
-    typedef SkColorFilter INHERITED;
 };
 
 class SkLightingColorFilter_JustAdd : public SkLightingColorFilter {
+    typedef SkLightingColorFilter INHERITED;
+
 public:
     SkLightingColorFilter_JustAdd(SkColor mul, SkColor add)
         : INHERITED(mul, add) {}
 
     virtual void filterSpan(const SkPMColor shader[], int count,
                             SkPMColor result[]) const SK_OVERRIDE {
         unsigned addR = SkColorGetR(fAdd);
         unsigned addG = SkColorGetG(fAdd);
         unsigned addB = SkColorGetB(fAdd);
 
@@ skipping 16 matching lines @@
         str->append("SkLightingColorFilter_JustAdd: add: 0x");
         str->appendHex(fAdd);
     }
 #endif
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLightingColorFilter_JustAdd)
 
 protected:
     SkLightingColorFilter_JustAdd(SkFlattenableReadBuffer& buffer)
         : INHERITED(buffer) {}
-
-private:
-    typedef SkLightingColorFilter INHERITED;
 };
 
 class SkLightingColorFilter_JustMul : public SkLightingColorFilter {
+    typedef SkLightingColorFilter INHERITED;
+
 public:
     SkLightingColorFilter_JustMul(SkColor mul, SkColor add)
         : INHERITED(mul, add) {}
 
     virtual void filterSpan(const SkPMColor shader[], int count,
                             SkPMColor result[]) const SK_OVERRIDE {
         unsigned scaleR = SkAlpha255To256(SkColorGetR(fMul));
         unsigned scaleG = SkAlpha255To256(SkColorGetG(fMul));
         unsigned scaleB = SkAlpha255To256(SkColorGetB(fMul));
 
@@ skipping 15 matching lines @@
         str->append("SkLightingColorFilter_JustMul: mul: 0x");
         str->appendHex(fMul);
     }
 #endif
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLightingColorFilter_JustMul)
 
 protected:
     SkLightingColorFilter_JustMul(SkFlattenableReadBuffer& buffer)
         : INHERITED(buffer) {}
-
-private:
-    typedef SkLightingColorFilter INHERITED;
 };
 
 class SkLightingColorFilter_SingleMul : public SkLightingColorFilter {
+    typedef SkLightingColorFilter INHERITED;
+
 public:
     SkLightingColorFilter_SingleMul(SkColor mul, SkColor add)
             : INHERITED(mul, add) {
         SkASSERT(SkColorGetR(add) == 0);
         SkASSERT(SkColorGetG(add) == 0);
         SkASSERT(SkColorGetB(add) == 0);
         SkASSERT(SkColorGetR(mul) == SkColorGetG(mul));
         SkASSERT(SkColorGetR(mul) == SkColorGetB(mul));
     }
 
@@ skipping 18 matching lines @@
         str->append("SkLightingColorFilter_SingleMul: mul: 0x");
         str->appendHex(fMul);
     }
 #endif
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLightingColorFilter_SingleMul)
 
 protected:
     SkLightingColorFilter_SingleMul(SkFlattenableReadBuffer& buffer)
         : INHERITED(buffer) {}
-
-private:
-    typedef SkLightingColorFilter INHERITED;
 };
 
 class SkLightingColorFilter_NoPin : public SkLightingColorFilter {
+    typedef SkLightingColorFilter INHERITED;
+
 public:
     SkLightingColorFilter_NoPin(SkColor mul, SkColor add)
     : INHERITED(mul, add) {}
 
     virtual void filterSpan(const SkPMColor shader[], int count,
                             SkPMColor result[]) const SK_OVERRIDE {
         unsigned scaleR = SkAlpha255To256(SkColorGetR(fMul));
         unsigned scaleG = SkAlpha255To256(SkColorGetG(fMul));
         unsigned scaleB = SkAlpha255To256(SkColorGetB(fMul));
 
@@ skipping 22 matching lines @@
         str->append(" add: 0x");
         str->appendHex(fAdd);
     }
 #endif
 
     SK_DECLARE_PUBLIC_FLATTENABLE_DESERIALIZATION_PROCS(SkLightingColorFilter_NoPin)
 
 protected:
     SkLightingColorFilter_NoPin(SkFlattenableReadBuffer& buffer)
         : INHERITED(buffer) {}
-
-private:
-    typedef SkLightingColorFilter INHERITED;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
 
 class SkSimpleColorFilter : public SkColorFilter {
 public:
     static SkFlattenable* CreateProc(SkFlattenableReadBuffer& buffer) {
         return SkNEW(SkSimpleColorFilter);
     }
 
@@ skipping 53 matching lines @@
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkModeColorFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(Src_SkModeColorFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SrcOver_SkModeColorFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter_JustAdd)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter_JustMul)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter_SingleMul)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkLightingColorFilter_NoPin)
     SK_DEFINE_FLATTENABLE_REGISTRAR_ENTRY(SkSimpleColorFilter)
 SK_DEFINE_FLATTENABLE_REGISTRAR_GROUP_END