Skip to content

Commit d120d92

Browse files
trevnorristrevnorris
committed
base-object: add BaseObject
BaseObject is a class that just handles the Persistent handle attached to the class instance. This also removed WeakObject. Reordering the inheritance chain helps prevent unneeded calls on instances that don't call MakeCallback.
1 parent 6cea16f commit d120d92

12 files changed

+188
-160
lines changed

‎node.gyp

+2-2
Original file line numberDiff line numberDiff line change
@@ -117,6 +117,8 @@
117117
# headers to make for a more pleasant IDE experience
118118
'src/async-wrap.h',
119119
'src/async-wrap-inl.h',
120+
'src/base-object.h',
121+
'src/base-object-inl.h',
120122
'src/env.h',
121123
'src/env-inl.h',
122124
'src/handle_wrap.h',
@@ -145,8 +147,6 @@
145147
'src/tree.h',
146148
'src/util.h',
147149
'src/util-inl.h',
148-
'src/weak-object.h',
149-
'src/weak-object-inl.h',
150150
'deps/http_parser/http_parser.h',
151151
'<(SHARED_INTERMEDIATE_DIR)/node_natives.h',
152152
# javascript files to make for an even more pleasant IDE experience

‎src/async-wrap-inl.h

+4-20
Original file line numberDiff line numberDiff line change
@@ -23,21 +23,21 @@
2323
#define SRC_ASYNC_WRAP_INL_H_
2424

2525
#include "async-wrap.h"
26+
#include "base-object.h"
27+
#include "base-object-inl.h"
2628
#include "env.h"
2729
#include "env-inl.h"
2830
#include "util.h"
2931
#include "util-inl.h"
32+
3033
#include "v8.h"
3134
#include <assert.h>
3235

3336
namespace node {
3437

3538
inline AsyncWrap::AsyncWrap(Environment* env, v8::Handle<v8::Object> object)
36-
: object_(env->isolate(), object),
37-
env_(env),
39+
: BaseObject(env, object),
3840
async_flags_(NO_OPTIONS) {
39-
assert(!object.IsEmpty());
40-
4141
if (!env->has_async_listeners())
4242
return;
4343

@@ -54,7 +54,6 @@ inline AsyncWrap::AsyncWrap(Environment* env, v8::Handle<v8::Object> object)
5454

5555

5656
inline AsyncWrap::~AsyncWrap() {
57-
assert(persistent().IsEmpty());
5857
}
5958

6059

@@ -89,21 +88,6 @@ inline bool AsyncWrap::has_async_queue() {
8988
}
9089

9190

92-
inline Environment* AsyncWrap::env() const {
93-
return env_;
94-
}
95-
96-
97-
inline v8::Local<v8::Object> AsyncWrap::object() {
98-
return PersistentToLocal(env()->isolate(), persistent());
99-
}
100-
101-
102-
inline v8::Persistent<v8::Object>& AsyncWrap::persistent() {
103-
return object_;
104-
}
105-
106-
10791
inline v8::Handle<v8::Value> AsyncWrap::MakeCallback(
10892
const v8::Handle<v8::Function> cb,
10993
int argc,

‎src/async-wrap.h

+2-11
Original file line numberDiff line numberDiff line change
@@ -22,12 +22,13 @@
2222
#ifndef SRC_ASYNC_WRAP_H_
2323
#define SRC_ASYNC_WRAP_H_
2424

25+
#include "base-object.h"
2526
#include "env.h"
2627
#include "v8.h"
2728

2829
namespace node {
2930

30-
class AsyncWrap {
31+
class AsyncWrap : public BaseObject {
3132
public:
3233
enum AsyncFlags {
3334
NO_OPTIONS = 0,
@@ -49,14 +50,6 @@ class AsyncWrap {
4950

5051
inline bool has_async_queue();
5152

52-
inline Environment* env() const;
53-
54-
// Returns the wrapped object. Illegal to call in your destructor.
55-
inline v8::Local<v8::Object> object();
56-
57-
// Parent class is responsible to Dispose.
58-
inline v8::Persistent<v8::Object>& persistent();
59-
6053
// Only call these within a valid HandleScope.
6154
inline v8::Handle<v8::Value> MakeCallback(const v8::Handle<v8::Function> cb,
6255
int argc,
@@ -79,8 +72,6 @@ class AsyncWrap {
7972
static inline void RemoveAsyncListener(
8073
const v8::FunctionCallbackInfo<v8::Value>& args);
8174

82-
v8::Persistent<v8::Object> object_;
83-
Environment* const env_;
8475
uint32_t async_flags_;
8576
};
8677

‎src/weak-object-inl.h ‎src/base-object-inl.h

+46-25
Original file line numberDiff line numberDiff line change
@@ -19,48 +19,69 @@
1919
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
2020
// USE OR OTHER DEALINGS IN THE SOFTWARE.
2121

22-
#ifndef SRC_WEAK_OBJECT_INL_H_
23-
#define SRC_WEAK_OBJECT_INL_H_
22+
#ifndef SRC_BASE_OBJECT_INL_H_
23+
#define SRC_BASE_OBJECT_INL_H_
2424

25-
#include "weak-object.h"
26-
#include "async-wrap.h"
27-
#include "async-wrap-inl.h"
25+
#include "base-object.h"
2826
#include "util.h"
2927
#include "util-inl.h"
28+
#include "v8.h"
29+
30+
#include <assert.h>
3031

3132
namespace node {
3233

33-
WeakObject::WeakObject(Environment* env, v8::Local<v8::Object> object)
34-
: AsyncWrap(env, object) {
35-
persistent().MarkIndependent();
34+
inline BaseObject::BaseObject(Environment* env, v8::Local<v8::Object> handle)
35+
: handle_(env->isolate(), handle),
36+
env_(env) {
37+
assert(!handle.IsEmpty());
38+
}
39+
3640

37-
// The pointer is resolved as void*.
38-
Wrap<WeakObject>(object, this);
39-
MakeWeak();
41+
inline BaseObject::~BaseObject() {
42+
assert(handle_.IsEmpty());
4043
}
4144

42-
WeakObject::~WeakObject() {
45+
46+
inline v8::Persistent<v8::Object>& BaseObject::persistent() {
47+
return handle_;
4348
}
4449

45-
void WeakObject::MakeWeak() {
46-
persistent().MakeWeak(this, WeakCallback);
50+
51+
inline v8::Local<v8::Object> BaseObject::object() {
52+
return PersistentToLocal(env_->isolate(), handle_);
4753
}
4854

49-
void WeakObject::ClearWeak() {
50-
persistent().ClearWeak();
55+
56+
inline Environment* BaseObject::env() const {
57+
return env_;
5158
}
5259

53-
void WeakObject::WeakCallback(v8::Isolate* isolate,
54-
v8::Persistent<v8::Object>* persistent,
55-
WeakObject* self) {
56-
// Dispose now instead of in the destructor to avoid child classes that call
57-
// `delete this` in their destructor from blowing up.
58-
// Dispose the class member instead of the argument or else the IsEmpty()
59-
// check in ~AsyncWrap will fail.
60-
self->persistent().Dispose();
60+
61+
template <typename Type>
62+
inline void BaseObject::WeakCallback(
63+
const v8::WeakCallbackData<v8::Object, Type>& data) {
64+
Type* self = data.GetParameter();
65+
self->persistent().Reset();
6166
delete self;
6267
}
6368

69+
70+
template <typename Type>
71+
inline void BaseObject::MakeWeak(Type* ptr) {
72+
v8::HandleScope scope(env_->isolate());
73+
v8::Local<v8::Object> handle = object();
74+
assert(handle->InternalFieldCount() > 0);
75+
Wrap<Type>(handle, ptr);
76+
handle_.MarkIndependent();
77+
handle_.SetWeak<Type>(ptr, WeakCallback<Type>);
78+
}
79+
80+
81+
inline void BaseObject::ClearWeak() {
82+
handle_.ClearWeak();
83+
}
84+
6485
} // namespace node
6586

66-
#endif // SRC_WEAK_OBJECT_INL_H_
87+
#endif // SRC_BASE_OBJECT_INL_H_

‎src/weak-object.h ‎src/base-object.h

+28-14
Original file line numberDiff line numberDiff line change
@@ -19,29 +19,43 @@
1919
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
2020
// USE OR OTHER DEALINGS IN THE SOFTWARE.
2121

22-
#ifndef SRC_WEAK_OBJECT_H_
23-
#define SRC_WEAK_OBJECT_H_
22+
#ifndef SRC_BASE_OBJECT_H_
23+
#define SRC_BASE_OBJECT_H_
2424

25-
#include "async-wrap.h"
2625
#include "env.h"
2726
#include "v8.h"
2827

2928
namespace node {
3029

31-
class WeakObject : public AsyncWrap {
32-
protected:
33-
// |object| should be an instance of a v8::ObjectTemplate that has at least
34-
// one internal field reserved with v8::ObjectTemplate::SetInternalFieldCount.
35-
inline WeakObject(Environment* env, v8::Local<v8::Object> object);
36-
virtual inline ~WeakObject();
37-
inline void MakeWeak();
30+
class BaseObject {
31+
public:
32+
BaseObject(Environment* env, v8::Local<v8::Object> handle);
33+
~BaseObject();
34+
35+
// Returns the wrapped object. Illegal to call in your destructor.
36+
inline v8::Local<v8::Object> object();
37+
38+
// Parent class is responsible to Dispose.
39+
inline v8::Persistent<v8::Object>& persistent();
40+
41+
inline Environment* env() const;
42+
43+
template <typename Type>
44+
inline void MakeWeak(Type* ptr);
45+
3846
inline void ClearWeak();
47+
3948
private:
40-
inline static void WeakCallback(v8::Isolate* isolate,
41-
v8::Persistent<v8::Object>* persistent,
42-
WeakObject* self);
49+
BaseObject();
50+
51+
template <typename Type>
52+
static inline void WeakCallback(
53+
const v8::WeakCallbackData<v8::Object, Type>& data);
54+
55+
v8::Persistent<v8::Object> handle_;
56+
Environment* env_;
4357
};
4458

4559
} // namespace node
4660

47-
#endif // SRC_WEAK_OBJECT_H_
61+
#endif // SRC_BASE_OBJECT_H_

‎src/node_contextify.cc

+5-4
Original file line numberDiff line numberDiff line change
@@ -22,12 +22,12 @@
2222
#include "node.h"
2323
#include "node_internals.h"
2424
#include "node_watchdog.h"
25+
#include "base-object.h"
26+
#include "base-object-inl.h"
2527
#include "env.h"
2628
#include "env-inl.h"
2729
#include "util.h"
2830
#include "util-inl.h"
29-
#include "weak-object.h"
30-
#include "weak-object-inl.h"
3131

3232
namespace node {
3333

@@ -381,7 +381,7 @@ class ContextifyContext {
381381
}
382382
};
383383

384-
class ContextifyScript : public WeakObject {
384+
class ContextifyScript : public BaseObject {
385385
private:
386386
Persistent<Script> script_;
387387

@@ -607,7 +607,8 @@ class ContextifyScript : public WeakObject {
607607

608608

609609
ContextifyScript(Environment* env, Local<Object> object)
610-
: WeakObject(env, object) {
610+
: BaseObject(env, object) {
611+
MakeWeak<ContextifyScript>(this);
611612
}
612613

613614

‎src/node_crypto.cc

+2
Original file line numberDiff line numberDiff line change
@@ -26,6 +26,8 @@
2626
#include "node_crypto_groups.h"
2727
#include "tls_wrap.h" // TLSCallbacks
2828

29+
#include "async-wrap.h"
30+
#include "async-wrap-inl.h"
2931
#include "env.h"
3032
#include "env-inl.h"
3133
#include "string_bytes.h"

0 commit comments

Comments
 (0)