Mojo C++ bindings: support enum validation.

mojo/public/cpp/bindings/lib/template_util.h

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef MOJO_PUBLIC_CPP_BINDINGS_LIB_TEMPLATE_UTIL_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_TEMPLATE_UTIL_H_
 
 namespace mojo {
 namespace internal {
 
@@ skipping 52 matching lines @@
 // This goop is a trick used to implement a template that can be used to
 // determine if a given class is the base class of another given class.
 template <typename, typename>
 struct IsSame {
   static bool const value = false;
 };
 template <typename A>
 struct IsSame<A, A> {
   static bool const value = true;
 };
+
+template <typename T>
+struct EnsureTypeIsComplete {
+  // sizeof() cannot be applied to incomplete types, this line will fail
+  // compilation if T is forward declaration.
+  using CheckSize = char (*)[sizeof(T)];
+};
+
 template <typename Base, typename Derived>
 struct IsBaseOf {
  private:
-  // This class doesn't work correctly with forward declarations.
-  // Because sizeof cannot be applied to incomplete types, this line prevents us
-  // from passing in forward declarations.
-  typedef char (*EnsureTypesAreComplete)[sizeof(Base) + sizeof(Derived)];
-
   static Derived* CreateDerived();
   static char(&Check(Base*))[1];
   static char(&Check(...))[2];
 
+  EnsureTypeIsComplete<Base> check_base_;
+  EnsureTypeIsComplete<Derived> check_derived_;
+
  public:
   static bool const value = sizeof Check(CreateDerived()) == 1 &&
                             !IsSame<Base const, void const>::value;
 };
 
 template <class T>
 struct RemovePointer {
   typedef T type;
 };
 template <class T>
@@ skipping 14 matching lines @@
 
 template <typename T, typename F>
 struct Conditional<false, T, F> {
   typedef F type;
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_TEMPLATE_UTIL_H_