mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 1

Simplify Wrappable API.

Browse source
This commit is contained in:
Cheng Zhao 2014-04-16 11:58:17 +08:00
parent ac5be7dad7
commit ace550d6b2
3 changed files with 63 additions and 64 deletions
Download patch file Download diff file Expand all files Collapse all files

45
native_mate/constructor.h
View file

@ -11,23 +11,23 @@
namespace mate { namespace mate {
class WrappableBase; class Wrappable;
namespace internal { namespace internal {
// This set of templates invokes a base::Callback by converting the Arguments // This set of templates invokes a base::Callback by converting the Arguments
// into native types. It relies on the function_template.h to provide helper // into native types. It relies on the function_template.h to provide helper
// templates. // templates.
inline WrappableBase* InvokeFactory( inline Wrappable* InvokeFactory(
Arguments* args, Arguments* args,
const base::Callback<WrappableBase*()>& callback) { const base::Callback<Wrappable*()>& callback) {
return callback.Run(); return callback.Run();
}; };
template<typename P1> template<typename P1>
inline WrappableBase* InvokeFactory( inline Wrappable* InvokeFactory(
Arguments* args, Arguments* args,
const base::Callback<WrappableBase*(P1)>& callback) { const base::Callback<Wrappable*(P1)>& callback) {
typename CallbackParamTraits<P1>::LocalType a1; typename CallbackParamTraits<P1>::LocalType a1;
if (!GetNextArgument(args, 0, false, &a1)) if (!GetNextArgument(args, 0, false, &a1))
return NULL; return NULL;
@ -35,9 +35,9 @@ inline WrappableBase* InvokeFactory(
}; };
template<typename P1, typename P2> template<typename P1, typename P2>
inline WrappableBase* InvokeFactory( inline Wrappable* InvokeFactory(
Arguments* args, Arguments* args,
const base::Callback<WrappableBase*(P1, P2)>& callback) { const base::Callback<Wrappable*(P1, P2)>& callback) {
typename CallbackParamTraits<P1>::LocalType a1; typename CallbackParamTraits<P1>::LocalType a1;
typename CallbackParamTraits<P2>::LocalType a2; typename CallbackParamTraits<P2>::LocalType a2;
if (!GetNextArgument(args, 0, true, &a1) || if (!GetNextArgument(args, 0, true, &a1) ||
@ -47,9 +47,9 @@ inline WrappableBase* InvokeFactory(
}; };
template<typename P1, typename P2, typename P3> template<typename P1, typename P2, typename P3>
inline WrappableBase* InvokeFactory( inline Wrappable* InvokeFactory(
Arguments* args, Arguments* args,
const base::Callback<WrappableBase*(P1, P2, P3)>& callback) { const base::Callback<Wrappable*(P1, P2, P3)>& callback) {
typename CallbackParamTraits<P1>::LocalType a1; typename CallbackParamTraits<P1>::LocalType a1;
typename CallbackParamTraits<P2>::LocalType a2; typename CallbackParamTraits<P2>::LocalType a2;
typename CallbackParamTraits<P3>::LocalType a3; typename CallbackParamTraits<P3>::LocalType a3;
@ -61,9 +61,9 @@ inline WrappableBase* InvokeFactory(
}; };
template<typename P1, typename P2, typename P3, typename P4> template<typename P1, typename P2, typename P3, typename P4>
inline WrappableBase* InvokeFactory( inline Wrappable* InvokeFactory(
Arguments* args, Arguments* args,
const base::Callback<WrappableBase*(P1, P2, P3, P4)>& callback) { const base::Callback<Wrappable*(P1, P2, P3, P4)>& callback) {
typename CallbackParamTraits<P1>::LocalType a1; typename CallbackParamTraits<P1>::LocalType a1;
typename CallbackParamTraits<P2>::LocalType a2; typename CallbackParamTraits<P2>::LocalType a2;
typename CallbackParamTraits<P3>::LocalType a3; typename CallbackParamTraits<P3>::LocalType a3;
@ -77,9 +77,9 @@ inline WrappableBase* InvokeFactory(
}; };
template<typename P1, typename P2, typename P3, typename P4, typename P5> template<typename P1, typename P2, typename P3, typename P4, typename P5>
inline WrappableBase* InvokeFactory( inline Wrappable* InvokeFactory(
Arguments* args, Arguments* args,
const base::Callback<WrappableBase*(P1, P2, P3, P4, P5)>& callback) { const base::Callback<Wrappable*(P1, P2, P3, P4, P5)>& callback) {
typename CallbackParamTraits<P1>::LocalType a1; typename CallbackParamTraits<P1>::LocalType a1;
typename CallbackParamTraits<P2>::LocalType a2; typename CallbackParamTraits<P2>::LocalType a2;
typename CallbackParamTraits<P3>::LocalType a3; typename CallbackParamTraits<P3>::LocalType a3;
@ -96,9 +96,9 @@ inline WrappableBase* InvokeFactory(
template<typename P1, typename P2, typename P3, typename P4, typename P5, template<typename P1, typename P2, typename P3, typename P4, typename P5,
typename P6> typename P6>
inline WrappableBase* InvokeFactory( inline Wrappable* InvokeFactory(
Arguments* args, Arguments* args,
const base::Callback<WrappableBase*(P1, P2, P3, P4, P5, P6)>& callback) { const base::Callback<Wrappable*(P1, P2, P3, P4, P5, P6)>& callback) {
typename CallbackParamTraits<P1>::LocalType a1; typename CallbackParamTraits<P1>::LocalType a1;
typename CallbackParamTraits<P2>::LocalType a2; typename CallbackParamTraits<P2>::LocalType a2;
typename CallbackParamTraits<P3>::LocalType a3; typename CallbackParamTraits<P3>::LocalType a3;
@ -146,7 +146,7 @@ class Constructor {
static void New(const WrappableFactoryFunction& factory, static void New(const WrappableFactoryFunction& factory,
v8::Isolate* isolate, v8::Isolate* isolate,
Arguments* args) { Arguments* args) {
WrappableBase* object = internal::InvokeFactory(args, factory); Wrappable* object = internal::InvokeFactory(args, factory);
if (object) if (object)
object->Wrap(isolate, args->GetThis()); object->Wrap(isolate, args->GetThis());
else else
@ -163,16 +163,19 @@ class Constructor {
template<typename T> template<typename T>
WrappableBase* NewOperatorFactory() { Wrappable* NewOperatorFactory() {
return new T; return new T;
} }
template<typename Sig> template<typename T, typename Sig>
v8::Local<v8::FunctionTemplate> CreateConstructor( v8::Local<v8::Function> CreateConstructor(
v8::Isolate* isolate, v8::Isolate* isolate,
const base::StringPiece& name, const base::StringPiece& name,
const base::Callback<Sig>& constructor) { const base::Callback<Sig>& callback) {
return Constructor<Sig>(name).GetFunctionTemplate(isolate, constructor); v8::Local<v8::FunctionTemplate> constructor =
Constructor<Sig>(name).GetFunctionTemplate(isolate, callback);
T::BuildPrototype(isolate, constructor->PrototypeTemplate());
return constructor->GetFunction();
} }
} // namespace mate } // namespace mate

19
native_mate/wrappable.cc
View file

@ -9,32 +9,37 @@
namespace mate { namespace mate {
WrappableBase::WrappableBase() { Wrappable::Wrappable() {
} }
WrappableBase::~WrappableBase() { Wrappable::~Wrappable() {
MATE_PERSISTENT_RESET(wrapper_); MATE_PERSISTENT_RESET(wrapper_);
} }
void WrappableBase::Wrap(v8::Isolate* isolate, v8::Handle<v8::Object> wrapper) { void Wrappable::Wrap(v8::Isolate* isolate, v8::Handle<v8::Object> wrapper) {
MATE_SET_INTERNAL_FIELD_POINTER(wrapper, 0, this); MATE_SET_INTERNAL_FIELD_POINTER(wrapper, 0, this);
MATE_PERSISTENT_ASSIGN(v8::Object, isolate, wrapper_, wrapper); MATE_PERSISTENT_ASSIGN(v8::Object, isolate, wrapper_, wrapper);
MATE_PERSISTENT_SET_WEAK(wrapper_, this, WeakCallback); MATE_PERSISTENT_SET_WEAK(wrapper_, this, WeakCallback);
} }
ObjectTemplateBuilder WrappableBase::GetObjectTemplateBuilder( // static
void Wrappable::BuildPrototype(v8::Isolate* isolate,
v8::Handle<v8::ObjectTemplate> prototype) {
}
ObjectTemplateBuilder Wrappable::GetObjectTemplateBuilder(
v8::Isolate* isolate) { v8::Isolate* isolate) {
return ObjectTemplateBuilder(isolate); return ObjectTemplateBuilder(isolate);
} }
// static // static
MATE_WEAK_CALLBACK(WrappableBase::WeakCallback, v8::Object, WrappableBase) { MATE_WEAK_CALLBACK(Wrappable::WeakCallback, v8::Object, Wrappable) {
MATE_WEAK_CALLBACK_INIT(WrappableBase); MATE_WEAK_CALLBACK_INIT(Wrappable);
MATE_PERSISTENT_RESET(self->wrapper_); MATE_PERSISTENT_RESET(self->wrapper_);
delete self; delete self;
} }
v8::Handle<v8::Object> WrappableBase::GetWrapperImpl(v8::Isolate* isolate) { v8::Handle<v8::Object> Wrappable::GetWrapper(v8::Isolate* isolate) {
if (!wrapper_.IsEmpty()) { if (!wrapper_.IsEmpty()) {
return MATE_PERSISTENT_TO_LOCAL(v8::Object, isolate, wrapper_); return MATE_PERSISTENT_TO_LOCAL(v8::Object, isolate, wrapper_);
} }

63
native_mate/wrappable.h
View file

@ -18,22 +18,24 @@ void* FromV8Impl(v8::Isolate* isolate, v8::Handle<v8::Value> val);
} // namespace internal } // namespace internal
// WrappableBase is a base class for C++ objects that have corresponding v8 wrapper // Wrappable is a base class for C++ objects that have corresponding v8 wrapper
// objects. To retain a WrappableBase object on the stack, use a mate::Handle. // objects. To retain a Wrappable object on the stack, use a gin::Handle.
// //
// USAGE: // USAGE:
// // my_class.h // // my_class.h
// class MyClass : WrappableBase { // class MyClass : Wrappable<MyClass> {
// public: // public:
// // Optional, only required if non-empty template should be used. // // Optional, only required if non-empty template should be used.
// virtual mate::ObjectTemplateBuilder GetObjectTemplateBuilder( // virtual gin::ObjectTemplateBuilder GetObjectTemplateBuilder(
// v8::Isolate* isolate); // v8::Isolate* isolate);
// ... // ...
// }; // };
// //
// mate::ObjectTemplateBuilder MyClass::GetObjectTemplateBuilder( // // my_class.cc
// gin::ObjectTemplateBuilder MyClass::GetObjectTemplateBuilder(
// v8::Isolate* isolate) { // v8::Isolate* isolate) {
// return WrappableBase::GetObjectTemplateBuilder(isolate).SetValue("foobar", 42); // return Wrappable<MyClass>::GetObjectTemplateBuilder(isolate)
// .SetValue("foobar", 42);
// } // }
// //
// Subclasses should also typically have private constructors and expose a // Subclasses should also typically have private constructors and expose a
@ -42,60 +44,49 @@ void* FromV8Impl(v8::Isolate* isolate, v8::Handle<v8::Value> val);
// wrapper for the object. If clients fail to create a wrapper for a wrappable // wrapper for the object. If clients fail to create a wrapper for a wrappable
// object, the object will leak because we use the weak callback from the // object, the object will leak because we use the weak callback from the
// wrapper as the signal to delete the wrapped object. // wrapper as the signal to delete the wrapped object.
template<typename T>
class Wrappable;
class ObjectTemplateBuilder; class ObjectTemplateBuilder;
// Non-template base class to share code between templates instances. class Wrappable {
class WrappableBase {
public: public:
// Retrieve (or create) the v8 wrapper object cooresponding to this object.
// If the type is created via the Constructor, then the GetWrapper would
// return the constructed object, otherwise it would try to create a new
// object constructed by GetObjectTemplateBuilder.
v8::Handle<v8::Object> GetWrapper(v8::Isolate* isolate);
// Bind the C++ class to the JS wrapper.
void Wrap(v8::Isolate* isolate, v8::Handle<v8::Object> wrapper); void Wrap(v8::Isolate* isolate, v8::Handle<v8::Object> wrapper);
// The user should define T::BuildPrototype if they want to use Constructor
// to build a constructor function for this type.
static void BuildPrototype(v8::Isolate* isolate,
v8::Handle<v8::ObjectTemplate> prototype);
protected: protected:
WrappableBase(); Wrappable();
virtual ~WrappableBase(); virtual ~Wrappable();
virtual ObjectTemplateBuilder GetObjectTemplateBuilder(v8::Isolate* isolate); virtual ObjectTemplateBuilder GetObjectTemplateBuilder(v8::Isolate* isolate);
v8::Handle<v8::Object> GetWrapperImpl(v8::Isolate* isolate);
private: private:
static MATE_WEAK_CALLBACK(WeakCallback, v8::Object, WrappableBase); static MATE_WEAK_CALLBACK(WeakCallback, v8::Object, Wrappable);
v8::Persistent<v8::Object> wrapper_; // Weak v8::Persistent<v8::Object> wrapper_; // Weak
DISALLOW_COPY_AND_ASSIGN(WrappableBase);
};
template<typename T>
class Wrappable : public WrappableBase {
public:
// Retrieve (or create) the v8 wrapper object cooresponding to this object.
v8::Handle<v8::Object> GetWrapper(v8::Isolate* isolate) {
return GetWrapperImpl(isolate);
}
protected:
Wrappable() {}
virtual ~Wrappable() {}
private:
DISALLOW_COPY_AND_ASSIGN(Wrappable); DISALLOW_COPY_AND_ASSIGN(Wrappable);
}; };
// This converter handles any subclass of WrappableBase. // This converter handles any subclass of Wrappable.
template<typename T> template<typename T>
struct Converter<T*, typename enable_if< struct Converter<T*, typename enable_if<
is_convertible<T*, WrappableBase*>::value>::type> { is_convertible<T*, Wrappable*>::value>::type> {
static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate, T* val) { static v8::Handle<v8::Value> ToV8(v8::Isolate* isolate, T* val) {
return val->GetWrapper(isolate); return val->GetWrapper(isolate);
} }
static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val, T** out) { static bool FromV8(v8::Isolate* isolate, v8::Handle<v8::Value> val, T** out) {
*out = static_cast<T*>(static_cast<WrappableBase*>( *out = static_cast<T*>(static_cast<Wrappable*>(
internal::FromV8Impl(isolate, val))); internal::FromV8Impl(isolate, val)));
return *out != NULL; return *out != NULL;
} }