Convert the rest of the functions in core.cc to use CreateFunctionTemplate.

gin/converter.cc

Index: gin/converter.cc
diff --git a/gin/converter.cc b/gin/converter.cc
index 614e5155a2bdfd0e6fc302463852d9d962ff92bd..04fe7eaf9e93dc2fa31a4e3c598530a8752e3de3 100644
--- a/gin/converter.cc
+++ b/gin/converter.cc
@@ -24,7 +24,7 @@ Handle<Value> Converter<bool>::ToV8(Isolate* isolate, bool val) {
   return Boolean::New(val).As<Value>();
 }
 
-bool Converter<bool>::FromV8(Handle<Value> val, bool* out) {
+bool Converter<bool>::FromV8(Isolate* isolate, Handle<Value> val, bool* out) {
   *out = val->BooleanValue();
   return true;
 }
@@ -33,7 +33,8 @@ Handle<Value> Converter<int32_t>::ToV8(Isolate* isolate, int32_t val) {
   return Integer::New(val, isolate).As<Value>();
 }
 
-bool Converter<int32_t>::FromV8(Handle<Value> val, int32_t* out) {
+bool Converter<int32_t>::FromV8(Isolate* isolate, Handle<Value> val,
+                                int32_t* out) {
   if (!val->IsInt32())
     return false;
   *out = val->Int32Value();
@@ -44,7 +45,8 @@ Handle<Value> Converter<uint32_t>::ToV8(Isolate* isolate, uint32_t val) {
   return Integer::NewFromUnsigned(val, isolate).As<Value>();
 }
 
-bool Converter<uint32_t>::FromV8(Handle<Value> val, uint32_t* out) {
+bool Converter<uint32_t>::FromV8(Isolate* isolate, Handle<Value> val,
+                                 uint32_t* out) {
   if (!val->IsUint32())
     return false;
   *out = val->Uint32Value();
@@ -55,7 +57,8 @@ Handle<Value> Converter<int64_t>::ToV8(Isolate* isolate, int64_t val) {
   return Number::New(isolate, static_cast<double>(val)).As<Value>();
 }
 
-bool Converter<int64_t>::FromV8(Handle<Value> val, int64_t* out) {
+bool Converter<int64_t>::FromV8(Isolate* isolate, Handle<Value> val,
+                                int64_t* out) {
   if (!val->IsNumber())
     return false;
   // Even though IntegerValue returns int64_t, JavaScript cannot represent
@@ -68,7 +71,8 @@ Handle<Value> Converter<uint64_t>::ToV8(Isolate* isolate, uint64_t val) {
   return Number::New(isolate, static_cast<double>(val)).As<Value>();
 }
 
-bool Converter<uint64_t>::FromV8(Handle<Value> val, uint64_t* out) {
+bool Converter<uint64_t>::FromV8(Isolate* isolate, Handle<Value> val,
+                                 uint64_t* out) {
   if (!val->IsNumber())
     return false;
   *out = static_cast<uint64_t>(val->IntegerValue());
@@ -79,7 +83,8 @@ Handle<Value> Converter<double>::ToV8(Isolate* isolate, double val) {
   return Number::New(isolate, val).As<Value>();
 }
 
-bool Converter<double>::FromV8(Handle<Value> val, double* out) {
+bool Converter<double>::FromV8(Isolate* isolate, Handle<Value> val,
+                               double* out) {
   if (!val->IsNumber())
     return false;
   *out = val->NumberValue();
@@ -94,7 +99,7 @@ Handle<Value> Converter<std::string>::ToV8(Isolate* isolate,
                              static_cast<uint32_t>(val.length()));
 }
 
-bool Converter<std::string>::FromV8(Handle<Value> val,
+bool Converter<std::string>::FromV8(Isolate* isolate, Handle<Value> val,
                                     std::string* out) {
   if (!val->IsString())
     return false;
@@ -105,7 +110,7 @@ bool Converter<std::string>::FromV8(Handle<Value> val,
   return true;
 }
 
-bool Converter<Handle<Function> >::FromV8(Handle<Value> val,
+bool Converter<Handle<Function> >::FromV8(Isolate* isolate, Handle<Value> val,
                                           Handle<Function>* out) {
   if (!val->IsFunction())
     return false;
@@ -113,12 +118,12 @@ bool Converter<Handle<Function> >::FromV8(Handle<Value> val,
   return true;
 }
 
-Handle<Value> Converter<Handle<Object> >::ToV8(v8::Isolate* isolate,
+Handle<Value> Converter<Handle<Object> >::ToV8(Isolate* isolate,
                                                Handle<Object> val) {
   return val.As<Value>();
 }
 
-bool Converter<Handle<Object> >::FromV8(Handle<Value> val,
+bool Converter<Handle<Object> >::FromV8(Isolate* isolate, Handle<Value> val,
                                         Handle<Object>* out) {
   if (!val->IsObject())
     return false;
@@ -126,12 +131,13 @@ bool Converter<Handle<Object> >::FromV8(Handle<Value> val,
   return true;
 }
 
-Handle<Value> Converter<Handle<ArrayBuffer> >::ToV8(v8::Isolate* isolate,
+Handle<Value> Converter<Handle<ArrayBuffer> >::ToV8(Isolate* isolate,
                                                     Handle<ArrayBuffer> val) {
   return val.As<Value>();
 }
 
-bool Converter<Handle<ArrayBuffer> >::FromV8(Handle<Value> val,
+bool Converter<Handle<ArrayBuffer> >::FromV8(Isolate* isolate,
+                                             Handle<Value> val,
                                              Handle<ArrayBuffer>* out) {
   if (!val->IsArrayBuffer())
     return false;
@@ -139,12 +145,13 @@ bool Converter<Handle<ArrayBuffer> >::FromV8(Handle<Value> val,
   return true;
 }
 
-Handle<Value> Converter<Handle<External> >::ToV8(v8::Isolate* isolate,
+Handle<Value> Converter<Handle<External> >::ToV8(Isolate* isolate,
                                                  Handle<External> val) {
   return val.As<Value>();
 }
 
-bool Converter<Handle<External> >::FromV8(Handle<Value> val,
+bool Converter<Handle<External> >::FromV8(Isolate* isolate,
+                                          v8::Handle<Value> val,
                                           Handle<External>* out) {
   if (!val->IsExternal())
     return false;
@@ -152,12 +159,12 @@ bool Converter<Handle<External> >::FromV8(Handle<Value> val,
   return true;
 }
 
-Handle<Value> Converter<Handle<Value> >::ToV8(v8::Isolate* isolate,
+Handle<Value> Converter<Handle<Value> >::ToV8(Isolate* isolate,
                                               Handle<Value> val) {
   return val;
 }
 
-bool Converter<Handle<Value> >::FromV8(Handle<Value> val,
+bool Converter<Handle<Value> >::FromV8(Isolate* isolate, Handle<Value> val,
                                        Handle<Value>* out) {
   *out = val;
   return true;
@@ -175,7 +182,7 @@ std::string V8ToString(v8::Handle<v8::Value> value) {
   if (value.IsEmpty())
     return std::string();
   std::string result;
-  if (!ConvertFromV8(value, &result))
+  if (!ConvertFromV8(NULL, value, &result))
     return std::string();
   return result;
 }