Gin: Make it easier to implement Wrappable

gin/function_template.h

 // This file was GENERATED by command:
 //     pump.py function_template.h.pump
 // DO NOT EDIT BY HAND!!!
 
 
 
 #ifndef GIN_FUNCTION_TEMPLATE_H_
 #define GIN_FUNCTION_TEMPLATE_H_
 
 // Copyright 2013 The Chromium Authors. All rights reserved.
@@ skipping 14 matching lines @@
 namespace gin {
 
 class PerIsolateData;
 
 enum CreateFunctionTemplateFlags {
   HolderIsFirstArgument = 1 << 0,
 };
 
 namespace internal {
 
-// TODO(aa): Move this to base/template_util.h as remove_const.
 template<typename T>
 struct CallbackParamTraits {
   typedef T LocalType;
 };
 template<typename T>
 struct CallbackParamTraits<const T&> {
   typedef T LocalType;
 };
 template<typename T>
 struct CallbackParamTraits<const T*> {
   typedef T* LocalType;
 };
 
 
 // CallbackHolder and CallbackHolderBase are used to pass a base::Callback from
 // CreateFunctionTemplate through v8 (via v8::FunctionTemplate) to
 // DispatchToCallback, where it is invoked.
 //
 // v8::FunctionTemplate only supports passing void* as data so how do we know
 // when to delete the base::Callback? That's where CallbackHolderBase comes in.
 // It inherits from Wrappable, which delete itself when both (a) the refcount
 // via base::RefCounted has dropped to zero, and (b) there are no more
 // JavaScript references in V8.
-class CallbackHolderBase : public Wrappable {
- public:
-  virtual WrapperInfo* GetWrapperInfo() OVERRIDE;
-  static WrapperInfo kWrapperInfo;
+
+// This simple base class is used so that we can share a single object template
+// among every CallbackHolder instance.
+class CallbackHolderBase : public Wrappable<CallbackHolderBase> {
  protected:
-  virtual ~CallbackHolderBase() {}
+  ~CallbackHolderBase() {}
 };
 
 template<typename Sig>
 class CallbackHolder : public CallbackHolderBase {
  public:
   CallbackHolder(const base::Callback<Sig>& callback, int flags)
       : callback(callback), flags(flags) {}
   base::Callback<Sig> callback;
   int flags;
  private:
-  virtual ~CallbackHolder() {}
+  ~CallbackHolder() {}
 };
 
 
 // This set of templates invokes a base::Callback, converts the return type to a
 // JavaScript value, and returns that value to script via the provided
 // gin::Arguments object.
 //
 // In C++, you can declare the function foo(void), but you can't pass a void
 // expression to foo. As a result, we must specialize the case of Callbacks that
 // have the void return type.
@@ skipping 260 matching lines @@
   gin::Handle<HolderT> holder = CreateHandle(
       isolate, new HolderT(callback, callback_flags));
   return v8::FunctionTemplate::New(
       &internal::Dispatcher<Sig>::DispatchToCallback,
       ConvertToV8<internal::CallbackHolderBase*>(isolate, holder.get()));
 }
 
 }  // namespace gin
 
 #endif  // GIN_FUNCTION_TEMPLATE_H_