[gin] Turn gin into a component

gin/function_template.h.pump

 $$ This is a pump file for generating file templates.  Pump is a python
 $$ script that is part of the Google Test suite of utilities.  Description
 $$ can be found here:
 $$
 $$ http://code.google.com/p/googletest/wiki/PumpManual
 $$
 
 #ifndef GIN_FUNCTION_TEMPLATE_H_
 #define GIN_FUNCTION_TEMPLATE_H_
 
 $var MAX_ARITY = 4
 
 // Copyright 2013 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.
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "gin/arguments.h"
 #include "gin/converter.h"
+#include "gin/gin_export.h"
 #include "gin/handle.h"
 #include "gin/public/gin_embedders.h"
 #include "gin/public/wrapper_info.h"
 #include "gin/wrappable.h"
 
 #include "v8/include/v8.h"
 
 namespace gin {
 
 class PerIsolateData;
@@ skipping 23 matching lines @@
 // 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.
 
 // This simple base class is used so that we can share a single object template
 // among every CallbackHolder instance.
-class CallbackHolderBase : public Wrappable<CallbackHolderBase> {
+class GIN_EXPORT CallbackHolderBase : public Wrappable<CallbackHolderBase> {
  public:
   static WrapperInfo kWrapperInfo;
 
  protected:
   virtual ~CallbackHolderBase() {}
 };
 
 template<typename Sig>
 class CallbackHolder : public CallbackHolderBase {
  public:
@@ skipping 106 matching lines @@
   }
 };
 
 ]]
 
 }  // namespace internal
 
 
 // This should be called once per-isolate to initialize the function template
 // system.
-void InitFunctionTemplates(PerIsolateData* isolate_data);
+GIN_EXPORT void InitFunctionTemplates(PerIsolateData* isolate_data);
 
 
 // CreateFunctionTemplate creates a v8::FunctionTemplate that will create
 // JavaScript functions that execute a provided C++ function or base::Callback.
 // JavaScript arguments are automatically converted via gin::Converter, as is
 // the return value of the C++ function, if any.
 template<typename Sig>
 v8::Local<v8::FunctionTemplate> CreateFunctionTemplate(
     v8::Isolate* isolate, const base::Callback<Sig> callback,
     int callback_flags = 0) {
   typedef internal::CallbackHolder<Sig> HolderT;
   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_