Reimplement callback.h with C++11
This commit is contained in:
Cheng Zhao
parent
2ff104d012
commit
5c18d89453
1 changed files with 34 additions and 384 deletions
|
|
@ -2,6 +2,8 @@
|
|||
// Use of this source code is governed by the MIT license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
#include <vector>
|
||||
|
||||
#include "base/bind.h"
|
||||
#include "base/callback.h"
|
||||
#include "native_mate/function_template.h"
|
||||
|
|
@ -14,407 +16,55 @@ namespace internal {
|
|||
|
||||
typedef scoped_refptr<RefCountedPersistent<v8::Function> > SafeV8Function;
|
||||
|
||||
// This set of templates invokes a V8::Function by converting the C++ types.
|
||||
template<typename Sig>
|
||||
struct V8FunctionInvoker;
|
||||
template <typename Sig>
|
||||
struct V8FunctionInvoker {};
|
||||
|
||||
template<typename V>
|
||||
struct V8FunctionInvoker<v8::Local<V>()> {
|
||||
static v8::Local<V> Go(v8::Isolate* isolate, SafeV8Function function) {
|
||||
template <typename... ArgTypes>
|
||||
struct V8FunctionInvoker<v8::Local<v8::Value>(ArgTypes...)> {
|
||||
static v8::Local<v8::Value> Go(v8::Isolate* isolate, SafeV8Function function,
|
||||
ArgTypes... raw) {
|
||||
Locker locker(isolate);
|
||||
v8::EscapableHandleScope handle_scope(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> val(holder->Call(holder, 0, NULL));
|
||||
return handle_scope.Escape(val);
|
||||
std::vector<v8::Local<v8::Value>> args = { ConvertToV8(isolate, raw)... };
|
||||
v8::Local<v8::Value> ret(holder->Call(holder, args.size(), &args.front()));
|
||||
return handle_scope.Escape(ret);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename R>
|
||||
struct V8FunctionInvoker<R()> {
|
||||
static R Go(v8::Isolate* isolate, SafeV8Function function) {
|
||||
R ret;
|
||||
template <typename... ArgTypes>
|
||||
struct V8FunctionInvoker<void(ArgTypes...)> {
|
||||
static void Go(v8::Isolate* isolate, SafeV8Function function,
|
||||
ArgTypes... raw) {
|
||||
Locker locker(isolate);
|
||||
MATE_HANDLE_SCOPE(isolate);
|
||||
v8::HandleScope handle_scope(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> val(holder->Call(holder, 0, NULL));
|
||||
Converter<R>::FromV8(isolate, val, &ret);
|
||||
std::vector<v8::Local<v8::Value>> args = { ConvertToV8(isolate, raw)... };
|
||||
holder->Call(holder, args.size(), &args.front());
|
||||
}
|
||||
};
|
||||
|
||||
template <typename ReturnType, typename... ArgTypes>
|
||||
struct V8FunctionInvoker<ReturnType(ArgTypes...)> {
|
||||
static ReturnType Go(v8::Isolate* isolate, SafeV8Function function,
|
||||
ArgTypes... raw) {
|
||||
Locker locker(isolate);
|
||||
v8::HandleScope handle_scope(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
ReturnType ret;
|
||||
std::vector<v8::Local<v8::Value>> args = { ConvertToV8(isolate, raw)... };
|
||||
v8::Local<v8::Value> val(holder->Call(holder, args.size(), &args.front()));
|
||||
Converter<ReturnType>::FromV8(isolate, val, &ret);
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
|
||||
template<>
|
||||
struct V8FunctionInvoker<void()> {
|
||||
static void Go(v8::Isolate* isolate, SafeV8Function function) {
|
||||
Locker locker(isolate);
|
||||
MATE_HANDLE_SCOPE(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
holder->Call(holder, 0, NULL);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename V, typename P1>
|
||||
struct V8FunctionInvoker<v8::Local<V>(P1)> {
|
||||
static v8::Local<V> Go(v8::Isolate* isolate, SafeV8Function function, P1 a1) {
|
||||
Locker locker(isolate);
|
||||
v8::EscapableHandleScope handle_scope(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> args[] = {
|
||||
ConvertToV8(isolate, a1),
|
||||
};
|
||||
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
|
||||
return handle_scope.Escape(val);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename R, typename P1>
|
||||
struct V8FunctionInvoker<R(P1)> {
|
||||
static R Go(v8::Isolate* isolate, SafeV8Function function, P1 a1) {
|
||||
R ret;
|
||||
Locker locker(isolate);
|
||||
MATE_HANDLE_SCOPE(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> args[] = {
|
||||
ConvertToV8(isolate, a1),
|
||||
};
|
||||
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
|
||||
Converter<R>::FromV8(isolate, val, &ret);
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename P1>
|
||||
struct V8FunctionInvoker<void(P1)> {
|
||||
static void Go(v8::Isolate* isolate, SafeV8Function function, P1 a1) {
|
||||
Locker locker(isolate);
|
||||
MATE_HANDLE_SCOPE(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> args[] = {
|
||||
ConvertToV8(isolate, a1),
|
||||
};
|
||||
holder->Call(holder, arraysize(args), args);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename V, typename P1, typename P2>
|
||||
struct V8FunctionInvoker<v8::Local<V>(P1, P2)> {
|
||||
static v8::Local<V> Go(v8::Isolate* isolate, SafeV8Function function, P1 a1,
|
||||
P2 a2) {
|
||||
Locker locker(isolate);
|
||||
v8::EscapableHandleScope handle_scope(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> args[] = {
|
||||
ConvertToV8(isolate, a1),
|
||||
ConvertToV8(isolate, a2),
|
||||
};
|
||||
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
|
||||
return handle_scope.Escape(val);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename R, typename P1, typename P2>
|
||||
struct V8FunctionInvoker<R(P1, P2)> {
|
||||
static R Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2) {
|
||||
R ret;
|
||||
Locker locker(isolate);
|
||||
MATE_HANDLE_SCOPE(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> args[] = {
|
||||
ConvertToV8(isolate, a1),
|
||||
ConvertToV8(isolate, a2),
|
||||
};
|
||||
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
|
||||
Converter<R>::FromV8(isolate, val, &ret);
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename P1, typename P2>
|
||||
struct V8FunctionInvoker<void(P1, P2)> {
|
||||
static void Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2) {
|
||||
Locker locker(isolate);
|
||||
MATE_HANDLE_SCOPE(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> args[] = {
|
||||
ConvertToV8(isolate, a1),
|
||||
ConvertToV8(isolate, a2),
|
||||
};
|
||||
holder->Call(holder, arraysize(args), args);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename V, typename P1, typename P2, typename P3>
|
||||
struct V8FunctionInvoker<v8::Local<V>(P1, P2, P3)> {
|
||||
static v8::Local<V> Go(v8::Isolate* isolate, SafeV8Function function, P1 a1,
|
||||
P2 a2, P3 a3) {
|
||||
Locker locker(isolate);
|
||||
v8::EscapableHandleScope handle_scope(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> args[] = {
|
||||
ConvertToV8(isolate, a1),
|
||||
ConvertToV8(isolate, a2),
|
||||
ConvertToV8(isolate, a3),
|
||||
};
|
||||
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
|
||||
return handle_scope.Escape(val);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename R, typename P1, typename P2, typename P3>
|
||||
struct V8FunctionInvoker<R(P1, P2, P3)> {
|
||||
static R Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2,
|
||||
P3 a3) {
|
||||
R ret;
|
||||
Locker locker(isolate);
|
||||
MATE_HANDLE_SCOPE(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> args[] = {
|
||||
ConvertToV8(isolate, a1),
|
||||
ConvertToV8(isolate, a2),
|
||||
ConvertToV8(isolate, a3),
|
||||
};
|
||||
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
|
||||
Converter<R>::FromV8(isolate, val, &ret);
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename P1, typename P2, typename P3>
|
||||
struct V8FunctionInvoker<void(P1, P2, P3)> {
|
||||
static void Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2,
|
||||
P3 a3) {
|
||||
Locker locker(isolate);
|
||||
MATE_HANDLE_SCOPE(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> args[] = {
|
||||
ConvertToV8(isolate, a1),
|
||||
ConvertToV8(isolate, a2),
|
||||
ConvertToV8(isolate, a3),
|
||||
};
|
||||
holder->Call(holder, arraysize(args), args);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename V, typename P1, typename P2, typename P3, typename P4>
|
||||
struct V8FunctionInvoker<v8::Local<V>(P1, P2, P3, P4)> {
|
||||
static v8::Local<V> Go(v8::Isolate* isolate, SafeV8Function function, P1 a1,
|
||||
P2 a2, P3 a3, P4 a4) {
|
||||
Locker locker(isolate);
|
||||
v8::EscapableHandleScope handle_scope(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> args[] = {
|
||||
ConvertToV8(isolate, a1),
|
||||
ConvertToV8(isolate, a2),
|
||||
ConvertToV8(isolate, a3),
|
||||
ConvertToV8(isolate, a4),
|
||||
};
|
||||
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
|
||||
return handle_scope.Escape(val);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename R, typename P1, typename P2, typename P3, typename P4>
|
||||
struct V8FunctionInvoker<R(P1, P2, P3, P4)> {
|
||||
static R Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2,
|
||||
P3 a3, P4 a4) {
|
||||
R ret;
|
||||
Locker locker(isolate);
|
||||
MATE_HANDLE_SCOPE(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> args[] = {
|
||||
ConvertToV8(isolate, a1),
|
||||
ConvertToV8(isolate, a2),
|
||||
ConvertToV8(isolate, a3),
|
||||
ConvertToV8(isolate, a4),
|
||||
};
|
||||
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
|
||||
Converter<R>::FromV8(isolate, val, &ret);
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename P1, typename P2, typename P3, typename P4>
|
||||
struct V8FunctionInvoker<void(P1, P2, P3, P4)> {
|
||||
static void Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2,
|
||||
P3 a3, P4 a4) {
|
||||
Locker locker(isolate);
|
||||
MATE_HANDLE_SCOPE(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> args[] = {
|
||||
ConvertToV8(isolate, a1),
|
||||
ConvertToV8(isolate, a2),
|
||||
ConvertToV8(isolate, a3),
|
||||
ConvertToV8(isolate, a4),
|
||||
};
|
||||
holder->Call(holder, arraysize(args), args);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename V, typename P1, typename P2, typename P3, typename P4,
|
||||
typename P5>
|
||||
struct V8FunctionInvoker<v8::Local<V>(P1, P2, P3, P4, P5)> {
|
||||
static v8::Local<V> Go(v8::Isolate* isolate, SafeV8Function function, P1 a1,
|
||||
P2 a2, P3 a3, P4 a4, P5 a5) {
|
||||
Locker locker(isolate);
|
||||
v8::EscapableHandleScope handle_scope(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> args[] = {
|
||||
ConvertToV8(isolate, a1),
|
||||
ConvertToV8(isolate, a2),
|
||||
ConvertToV8(isolate, a3),
|
||||
ConvertToV8(isolate, a4),
|
||||
ConvertToV8(isolate, a5),
|
||||
};
|
||||
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
|
||||
return handle_scope.Escape(val);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename R, typename P1, typename P2, typename P3, typename P4,
|
||||
typename P5>
|
||||
struct V8FunctionInvoker<R(P1, P2, P3, P4, P5)> {
|
||||
static R Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2,
|
||||
P3 a3, P4 a4, P5 a5) {
|
||||
R ret;
|
||||
Locker locker(isolate);
|
||||
MATE_HANDLE_SCOPE(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> args[] = {
|
||||
ConvertToV8(isolate, a1),
|
||||
ConvertToV8(isolate, a2),
|
||||
ConvertToV8(isolate, a3),
|
||||
ConvertToV8(isolate, a4),
|
||||
ConvertToV8(isolate, a5),
|
||||
};
|
||||
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
|
||||
Converter<R>::FromV8(isolate, val, &ret);
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename P1, typename P2, typename P3, typename P4, typename P5>
|
||||
struct V8FunctionInvoker<void(P1, P2, P3, P4, P5)> {
|
||||
static void Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2,
|
||||
P3 a3, P4 a4, P5 a5) {
|
||||
Locker locker(isolate);
|
||||
MATE_HANDLE_SCOPE(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> args[] = {
|
||||
ConvertToV8(isolate, a1),
|
||||
ConvertToV8(isolate, a2),
|
||||
ConvertToV8(isolate, a3),
|
||||
ConvertToV8(isolate, a4),
|
||||
ConvertToV8(isolate, a5),
|
||||
};
|
||||
holder->Call(holder, arraysize(args), args);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename V, typename P1, typename P2, typename P3, typename P4,
|
||||
typename P5, typename P6>
|
||||
struct V8FunctionInvoker<v8::Local<V>(P1, P2, P3, P4, P5, P6)> {
|
||||
static v8::Local<V> Go(v8::Isolate* isolate, SafeV8Function function, P1 a1,
|
||||
P2 a2, P3 a3, P4 a4, P5 a5, P6 a6) {
|
||||
Locker locker(isolate);
|
||||
v8::EscapableHandleScope handle_scope(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> args[] = {
|
||||
ConvertToV8(isolate, a1),
|
||||
ConvertToV8(isolate, a2),
|
||||
ConvertToV8(isolate, a3),
|
||||
ConvertToV8(isolate, a4),
|
||||
ConvertToV8(isolate, a5),
|
||||
ConvertToV8(isolate, a6),
|
||||
};
|
||||
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
|
||||
return handle_scope.Escape(val);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename R, typename P1, typename P2, typename P3, typename P4,
|
||||
typename P5, typename P6>
|
||||
struct V8FunctionInvoker<R(P1, P2, P3, P4, P5, P6)> {
|
||||
static R Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2,
|
||||
P3 a3, P4 a4, P5 a5, P6 a6) {
|
||||
R ret;
|
||||
Locker locker(isolate);
|
||||
MATE_HANDLE_SCOPE(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> args[] = {
|
||||
ConvertToV8(isolate, a1),
|
||||
ConvertToV8(isolate, a2),
|
||||
ConvertToV8(isolate, a3),
|
||||
ConvertToV8(isolate, a4),
|
||||
ConvertToV8(isolate, a5),
|
||||
ConvertToV8(isolate, a6),
|
||||
};
|
||||
v8::Local<v8::Value> val(holder->Call(holder, arraysize(args), args));
|
||||
Converter<R>::FromV8(isolate, val, &ret);
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
|
||||
template<typename P1, typename P2, typename P3, typename P4, typename P5,
|
||||
typename P6>
|
||||
struct V8FunctionInvoker<void(P1, P2, P3, P4, P5, P6)> {
|
||||
static void Go(v8::Isolate* isolate, SafeV8Function function, P1 a1, P2 a2,
|
||||
P3 a3, P4 a4, P5 a5, P6 a6) {
|
||||
Locker locker(isolate);
|
||||
MATE_HANDLE_SCOPE(isolate);
|
||||
v8::Local<v8::Function> holder = function->NewHandle();
|
||||
v8::Local<v8::Context> context = holder->CreationContext();
|
||||
v8::Context::Scope context_scope(context);
|
||||
v8::Local<v8::Value> args[] = {
|
||||
ConvertToV8(isolate, a1),
|
||||
ConvertToV8(isolate, a2),
|
||||
ConvertToV8(isolate, a3),
|
||||
ConvertToV8(isolate, a4),
|
||||
ConvertToV8(isolate, a5),
|
||||
ConvertToV8(isolate, a6),
|
||||
};
|
||||
holder->Call(holder, arraysize(args), args);
|
||||
}
|
||||
};
|
||||
|
||||
} // namespace internal
|
||||
|
||||
template<typename Sig>
|
||||
|
|
|
|||
Loading…
Reference in a new issue