Initial error handling code

include/core/SkAnnotation.h

Index: include/core/SkAnnotation.h
diff --git a/include/core/SkAnnotation.h b/include/core/SkAnnotation.h
index 18ee1cd1a65993eaf2cdf5f203bfd7fe455b7a6b..d699ea156a3b67486381b7fc105703e05a739211 100644
--- a/include/core/SkAnnotation.h
+++ b/include/core/SkAnnotation.h
@@ -21,6 +21,8 @@ struct SkPoint;
  *  Use helper functions at the bottom of this file for now.
  */
 class SkAnnotation : public SkFlattenable {
+    typedef SkFlattenable INHERITED;

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

Can you come up with a small test case that shows this matters?  I'm just very
curious.  It seems like it shouldn't.

I tried this code and was unable to reproduce what you're seeing.  It didn't
matter where I put the typedefs, I always get A, B, B.

#include <stdio.h>

struct A {
    virtual void print() { printf("A\n"); }
};  

struct B : public A {
    typedef A INHERITED;
    virtual void print() { printf("B\n"); }
};  

struct C : public B {
    virtual void print() { this->INHERITED::print(); }
    typedef B INHERITED;
};

int main(int, char**) {
    A* a;

    a = new A;
    a->print();
    a = new B;
    a->print();
    a = new C;
    a->print();

    return 0;
}

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

I got this error while writing some code last week, and I found it to be pretty
bad. Essentially, it works for calling virtual functions, but it doesn't work
for function parameters. For example, If I'd write this :

struct A {
    enum Type { k0, k1, k2 };
};

struct B : public A {
    enum Type { kA, kB, kC };
    typedef A INHERITED;
};  

struct C : public B {
    void doSomething(INHERITED::Type type = INHERITED::kA) {} // Error here
    typedef B INHERITED;
};

I'd get an error :

error: default argument for parameter of type ‘A::Type’ has type ‘B::Type’

which is fairly easy to miss, since, looking at the code, we'd think both the
parameter type and the default argument are of the same type.

If I change the struct C to :

struct C : public B {
    typedef B INHERITED;
    void doSomething(INHERITED::Type type = INHERITED::kA) {}
};

then everything works fine. I didn't want to have issues or limitations because
of this and I didn't want others to get puzzled by errors like these, so I
decided to preemptively fix this kind of thing right away.

+
 public:
     enum Flags {
         // If set, the associated drawing primitive should not be drawn
@@ -52,8 +54,6 @@ private:
 
     void writeToStream(SkWStream*) const;
     void readFromStream(SkStream*);
-
-    typedef SkFlattenable INHERITED;
 };
 
 /**