Initial error handling code

include/core/SkAnnotation.h

 /*
  * Copyright 2012 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #ifndef SkAnnotation_DEFINED
 #define SkAnnotation_DEFINED
 
 #include "SkFlattenable.h"
 
 class SkData;
 class SkDataSet;
 class SkStream;
 class SkWStream;
 struct SkPoint;
 
 /**
  *  Experimental class for annotating draws. Do not use directly yet.
  *  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
         kNoDraw_Flag  = 1 << 0,
     };
 
     SkAnnotation(SkDataSet*, uint32_t flags);
     virtual ~SkAnnotation();
 
     uint32_t getFlags() const { return fFlags; }
@@ skipping 11 matching lines @@
 protected:
     SkAnnotation(SkFlattenableReadBuffer&);
     virtual void flatten(SkFlattenableWriteBuffer&) const SK_OVERRIDE;
 
 private:
     SkDataSet*  fDataSet;
     uint32_t    fFlags;
 
     void writeToStream(SkWStream*) const;
     void readFromStream(SkStream*);
-
-    typedef SkFlattenable INHERITED;
 };
 
 /**
  *  Experimental collection of predefined Keys into the Annotation dictionary
  */
 class SkAnnotationKeys {
 public:
     /**
      *  Returns the canonical key whose payload is a URL
      */
@@ skipping 52 matching lines @@
  *
  *  If the backend of this canvas does not support annotations, this call is
  *  safely ignored.
  *
  *  The caller is responsible for managing its ownership of the SkData.
  */
 SK_API void SkAnnotateLinkToDestination(SkCanvas*, const SkRect&, SkData*);
 
 
 #endif