Skip to content

V
V8
Commit 8565d3e9 authored by jochen@chromium.org's avatar jochen@chromium.org
Browse files
Options

Remove deprecated Persistent::MakeWeak usage from V8 

BUG=none
LOG=n
R=dcarney@chromium.org, ulan@chromium.org

Review URL: https://codereview.chromium.org/101523002

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@18227 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
parent ee5726cd
Hide whitespace changes
Inline Side-by-side
Showing with 349 additions and 322 deletions
src/d8.cc
View file @ 8565d3e9
...@@ -1097,16 +1097,22 @@ static char* ReadChars(Isolate* isolate, const char* name, int* size_out) { ...@@ -1097,16 +1097,22 @@ static char* ReadChars(Isolate* isolate, const char* name, int* size_out) {
return chars; return chars;
} }
static void ReadBufferWeakCallback(v8::Isolate* isolate,
Persistent<ArrayBuffer>* array_buffer, struct DataAndPersistent {
uint8_t* data) { uint8_t* data;
size_t byte_length = Persistent<ArrayBuffer> handle;
Local<ArrayBuffer>::New(isolate, *array_buffer)->ByteLength(); };
isolate->AdjustAmountOfExternalAllocatedMemory(
static void ReadBufferWeakCallback(
const v8::WeakCallbackData<ArrayBuffer, DataAndPersistent>& data) {
size_t byte_length = data.GetValue()->ByteLength();
data.GetIsolate()->AdjustAmountOfExternalAllocatedMemory(
-static_cast<intptr_t>(byte_length)); -static_cast<intptr_t>(byte_length));
delete[] data; delete[] data.GetParameter()->data;
array_buffer->Reset(); data.GetParameter()->handle.Reset();
delete data.GetParameter();
} }
...@@ -1120,16 +1126,18 @@ void Shell::ReadBuffer(const v8::FunctionCallbackInfo<v8::Value>& args) { ...@@ -1120,16 +1126,18 @@ void Shell::ReadBuffer(const v8::FunctionCallbackInfo<v8::Value>& args) {
} }
Isolate* isolate = args.GetIsolate(); Isolate* isolate = args.GetIsolate();
uint8_t* data = reinterpret_cast<uint8_t*>( DataAndPersistent* data = new DataAndPersistent;
data->data = reinterpret_cast<uint8_t*>(
ReadChars(args.GetIsolate(), *filename, &length)); ReadChars(args.GetIsolate(), *filename, &length));
if (data == NULL) { if (data->data == NULL) {
delete data;
Throw(args.GetIsolate(), "Error reading file"); Throw(args.GetIsolate(), "Error reading file");
return; return;
} }
Handle<v8::ArrayBuffer> buffer = ArrayBuffer::New(isolate, data, length); Handle<v8::ArrayBuffer> buffer = ArrayBuffer::New(isolate, data, length);
v8::Persistent<v8::ArrayBuffer> weak_handle(isolate, buffer); data->handle.Reset(isolate, buffer);
weak_handle.MakeWeak(data, ReadBufferWeakCallback); data->handle.SetWeak(data, ReadBufferWeakCallback);
weak_handle.MarkIndependent(); data->handle.MarkIndependent();
isolate->AdjustAmountOfExternalAllocatedMemory(length); isolate->AdjustAmountOfExternalAllocatedMemory(length);
args.GetReturnValue().Set(buffer); args.GetReturnValue().Set(buffer);
......
test/cctest/test-api.cc
View file @ 8565d3e9
...@@ -3445,12 +3445,20 @@ class WeakCallCounter { ...@@ -3445,12 +3445,20 @@ class WeakCallCounter {
template<typename T> template<typename T>
static void WeakPointerCallback(v8::Isolate* isolate, struct WeakCallCounterAndPersistent {
Persistent<T>* handle, explicit WeakCallCounterAndPersistent(WeakCallCounter* counter)
WeakCallCounter* counter) { : counter(counter) {}
CHECK_EQ(1234, counter->id()); WeakCallCounter* counter;
counter->increment(); v8::Persistent<T> handle;
handle->Reset(); };
template <typename T>
static void WeakPointerCallback(
const v8::WeakCallbackData<T, WeakCallCounterAndPersistent<T> >& data) {
CHECK_EQ(1234, data.GetParameter()->counter->id());
data.GetParameter()->counter->increment();
data.GetParameter()->handle.Reset();
} }
...@@ -3465,52 +3473,53 @@ THREADED_TEST(ApiObjectGroups) { ...@@ -3465,52 +3473,53 @@ THREADED_TEST(ApiObjectGroups) {
v8::Isolate* iso = env->GetIsolate(); v8::Isolate* iso = env->GetIsolate();
HandleScope scope(iso); HandleScope scope(iso);
Persistent<Value> g1s1;
Persistent<Value> g1s2;
Persistent<Value> g1c1;
Persistent<Value> g2s1;
Persistent<Value> g2s2;
Persistent<Value> g2c1;
WeakCallCounter counter(1234); WeakCallCounter counter(1234);
WeakCallCounterAndPersistent<Value> g1s1(&counter);
WeakCallCounterAndPersistent<Value> g1s2(&counter);
WeakCallCounterAndPersistent<Value> g1c1(&counter);
WeakCallCounterAndPersistent<Value> g2s1(&counter);
WeakCallCounterAndPersistent<Value> g2s2(&counter);
WeakCallCounterAndPersistent<Value> g2c1(&counter);
{ {
HandleScope scope(iso); HandleScope scope(iso);
g1s1.Reset(iso, Object::New()); g1s1.handle.Reset(iso, Object::New());
g1s2.Reset(iso, Object::New()); g1s2.handle.Reset(iso, Object::New());
g1c1.Reset(iso, Object::New()); g1c1.handle.Reset(iso, Object::New());
g1s1.MakeWeak(&counter, &WeakPointerCallback); g1s1.handle.SetWeak(&g1s1, &WeakPointerCallback);
g1s2.MakeWeak(&counter, &WeakPointerCallback); g1s2.handle.SetWeak(&g1s2, &WeakPointerCallback);
g1c1.MakeWeak(&counter, &WeakPointerCallback); g1c1.handle.SetWeak(&g1c1, &WeakPointerCallback);
g2s1.Reset(iso, Object::New()); g2s1.handle.Reset(iso, Object::New());
g2s2.Reset(iso, Object::New()); g2s2.handle.Reset(iso, Object::New());
g2c1.Reset(iso, Object::New()); g2c1.handle.Reset(iso, Object::New());
g2s1.MakeWeak(&counter, &WeakPointerCallback); g2s1.handle.SetWeak(&g2s1, &WeakPointerCallback);
g2s2.MakeWeak(&counter, &WeakPointerCallback); g2s2.handle.SetWeak(&g2s2, &WeakPointerCallback);
g2c1.MakeWeak(&counter, &WeakPointerCallback); g2c1.handle.SetWeak(&g2c1, &WeakPointerCallback);
} }
Persistent<Value> root(iso, g1s1); // make a root. WeakCallCounterAndPersistent<Value> root(&counter);
root.handle.Reset(iso, g1s1.handle); // make a root.
// Connect group 1 and 2, make a cycle. // Connect group 1 and 2, make a cycle.
{ {
HandleScope scope(iso); HandleScope scope(iso);
CHECK(Local<Object>::New(iso, g1s2.As<Object>())-> CHECK(Local<Object>::New(iso, g1s2.handle.As<Object>())->
Set(0, Local<Value>::New(iso, g2s2))); Set(0, Local<Value>::New(iso, g2s2.handle)));
CHECK(Local<Object>::New(iso, g2s1.As<Object>())-> CHECK(Local<Object>::New(iso, g2s1.handle.As<Object>())->
Set(0, Local<Value>::New(iso, g1s1))); Set(0, Local<Value>::New(iso, g1s1.handle)));
} }
{ {
UniqueId id1 = MakeUniqueId(g1s1); UniqueId id1 = MakeUniqueId(g1s1.handle);
UniqueId id2 = MakeUniqueId(g2s2); UniqueId id2 = MakeUniqueId(g2s2.handle);
iso->SetObjectGroupId(g1s1, id1); iso->SetObjectGroupId(g1s1.handle, id1);
iso->SetObjectGroupId(g1s2, id1); iso->SetObjectGroupId(g1s2.handle, id1);
iso->SetReferenceFromGroup(id1, g1c1); iso->SetReferenceFromGroup(id1, g1c1.handle);
iso->SetObjectGroupId(g2s1, id2); iso->SetObjectGroupId(g2s1.handle, id2);
iso->SetObjectGroupId(g2s2, id2); iso->SetObjectGroupId(g2s2.handle, id2);
iso->SetReferenceFromGroup(id2, g2c1); iso->SetReferenceFromGroup(id2, g2c1.handle);
} }
// Do a single full GC, ensure incremental marking is stopped. // Do a single full GC, ensure incremental marking is stopped.
v8::internal::Heap* heap = reinterpret_cast<v8::internal::Isolate*>( v8::internal::Heap* heap = reinterpret_cast<v8::internal::Isolate*>(
...@@ -3521,22 +3530,22 @@ THREADED_TEST(ApiObjectGroups) { ...@@ -3521,22 +3530,22 @@ THREADED_TEST(ApiObjectGroups) {
CHECK_EQ(0, counter.NumberOfWeakCalls()); CHECK_EQ(0, counter.NumberOfWeakCalls());
// Weaken the root. // Weaken the root.
root.MakeWeak(&counter, &WeakPointerCallback); root.handle.SetWeak(&root, &WeakPointerCallback);
// But make children strong roots---all the objects (except for children) // But make children strong roots---all the objects (except for children)
// should be collectable now. // should be collectable now.
g1c1.ClearWeak(); g1c1.handle.ClearWeak();
g2c1.ClearWeak(); g2c1.handle.ClearWeak();
// Groups are deleted, rebuild groups. // Groups are deleted, rebuild groups.
{ {
UniqueId id1 = MakeUniqueId(g1s1); UniqueId id1 = MakeUniqueId(g1s1.handle);
UniqueId id2 = MakeUniqueId(g2s2); UniqueId id2 = MakeUniqueId(g2s2.handle);
iso->SetObjectGroupId(g1s1, id1); iso->SetObjectGroupId(g1s1.handle, id1);
iso->SetObjectGroupId(g1s2, id1); iso->SetObjectGroupId(g1s2.handle, id1);
iso->SetReferenceFromGroup(id1, g1c1); iso->SetReferenceFromGroup(id1, g1c1.handle);
iso->SetObjectGroupId(g2s1, id2); iso->SetObjectGroupId(g2s1.handle, id2);
iso->SetObjectGroupId(g2s2, id2); iso->SetObjectGroupId(g2s2.handle, id2);
iso->SetReferenceFromGroup(id2, g2c1); iso->SetReferenceFromGroup(id2, g2c1.handle);
} }
heap->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask); heap->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
...@@ -3545,8 +3554,8 @@ THREADED_TEST(ApiObjectGroups) { ...@@ -3545,8 +3554,8 @@ THREADED_TEST(ApiObjectGroups) {
CHECK_EQ(5, counter.NumberOfWeakCalls()); CHECK_EQ(5, counter.NumberOfWeakCalls());
// And now make children weak again and collect them. // And now make children weak again and collect them.
g1c1.MakeWeak(&counter, &WeakPointerCallback); g1c1.handle.SetWeak(&g1c1, &WeakPointerCallback);
g2c1.MakeWeak(&counter, &WeakPointerCallback); g2c1.handle.SetWeak(&g2c1, &WeakPointerCallback);
heap->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask); heap->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
CHECK_EQ(7, counter.NumberOfWeakCalls()); CHECK_EQ(7, counter.NumberOfWeakCalls());
...@@ -3558,50 +3567,53 @@ THREADED_TEST(ApiObjectGroupsForSubtypes) { ...@@ -3558,50 +3567,53 @@ THREADED_TEST(ApiObjectGroupsForSubtypes) {
v8::Isolate* iso = env->GetIsolate(); v8::Isolate* iso = env->GetIsolate();
HandleScope scope(iso); HandleScope scope(iso);
Persistent<Object> g1s1;
Persistent<String> g1s2;
Persistent<String> g1c1;
Persistent<Object> g2s1;
Persistent<String> g2s2;
Persistent<String> g2c1;
WeakCallCounter counter(1234); WeakCallCounter counter(1234);
WeakCallCounterAndPersistent<Object> g1s1(&counter);
WeakCallCounterAndPersistent<String> g1s2(&counter);
WeakCallCounterAndPersistent<String> g1c1(&counter);
WeakCallCounterAndPersistent<Object> g2s1(&counter);
WeakCallCounterAndPersistent<String> g2s2(&counter);
WeakCallCounterAndPersistent<String> g2c1(&counter);
{ {
HandleScope scope(iso); HandleScope scope(iso);
g1s1.Reset(iso, Object::New()); g1s1.handle.Reset(iso, Object::New());
g1s2.Reset(iso, String::NewFromUtf8(iso, "foo1")); g1s2.handle.Reset(iso, String::NewFromUtf8(iso, "foo1"));
g1c1.Reset(iso, String::NewFromUtf8(iso, "foo2")); g1c1.handle.Reset(iso, String::NewFromUtf8(iso, "foo2"));
g1s1.MakeWeak(&counter, &WeakPointerCallback); g1s1.handle.SetWeak(&g1s1, &WeakPointerCallback);
g1s2.MakeWeak(&counter, &WeakPointerCallback); g1s2.handle.SetWeak(&g1s2, &WeakPointerCallback);
g1c1.MakeWeak(&counter, &WeakPointerCallback); g1c1.handle.SetWeak(&g1c1, &WeakPointerCallback);
g2s1.Reset(iso, Object::New()); g2s1.handle.Reset(iso, Object::New());
g2s2.Reset(iso, String::NewFromUtf8(iso, "foo3")); g2s2.handle.Reset(iso, String::NewFromUtf8(iso, "foo3"));
g2c1.Reset(iso, String::NewFromUtf8(iso, "foo4")); g2c1.handle.Reset(iso, String::NewFromUtf8(iso, "foo4"));
g2s1.MakeWeak(&counter, &WeakPointerCallback); g2s1.handle.SetWeak(&g2s1, &WeakPointerCallback);
g2s2.MakeWeak(&counter, &WeakPointerCallback); g2s2.handle.SetWeak(&g2s2, &WeakPointerCallback);
g2c1.MakeWeak(&counter, &WeakPointerCallback); g2c1.handle.SetWeak(&g2c1, &WeakPointerCallback);
} }
Persistent<Value> root(iso, g1s1); // make a root. WeakCallCounterAndPersistent<Value> root(&counter);
root.handle.Reset(iso, g1s1.handle); // make a root.
// Connect group 1 and 2, make a cycle. // Connect group 1 and 2, make a cycle.
{ {
HandleScope scope(iso); HandleScope scope(iso);
CHECK(Local<Object>::New(iso, g1s1)->Set(0, Local<Object>::New(iso, g2s1))); CHECK(Local<Object>::New(iso, g1s1.handle)
CHECK(Local<Object>::New(iso, g2s1)->Set(0, Local<Object>::New(iso, g1s1))); ->Set(0, Local<Object>::New(iso, g2s1.handle)));
CHECK(Local<Object>::New(iso, g2s1.handle)
->Set(0, Local<Object>::New(iso, g1s1.handle)));
} }
{ {
UniqueId id1 = MakeUniqueId(g1s1); UniqueId id1 = MakeUniqueId(g1s1.handle);
UniqueId id2 = MakeUniqueId(g2s2); UniqueId id2 = MakeUniqueId(g2s2.handle);
iso->SetObjectGroupId(g1s1, id1); iso->SetObjectGroupId(g1s1.handle, id1);
iso->SetObjectGroupId(g1s2, id1); iso->SetObjectGroupId(g1s2.handle, id1);
iso->SetReference(g1s1, g1c1); iso->SetReference(g1s1.handle, g1c1.handle);
iso->SetObjectGroupId(g2s1, id2); iso->SetObjectGroupId(g2s1.handle, id2);
iso->SetObjectGroupId(g2s2, id2); iso->SetObjectGroupId(g2s2.handle, id2);
iso->SetReferenceFromGroup(id2, g2c1); iso->SetReferenceFromGroup(id2, g2c1.handle);
} }
// Do a single full GC, ensure incremental marking is stopped. // Do a single full GC, ensure incremental marking is stopped.
v8::internal::Heap* heap = reinterpret_cast<v8::internal::Isolate*>( v8::internal::Heap* heap = reinterpret_cast<v8::internal::Isolate*>(
...@@ -3612,22 +3624,22 @@ THREADED_TEST(ApiObjectGroupsForSubtypes) { ...@@ -3612,22 +3624,22 @@ THREADED_TEST(ApiObjectGroupsForSubtypes) {
CHECK_EQ(0, counter.NumberOfWeakCalls()); CHECK_EQ(0, counter.NumberOfWeakCalls());
// Weaken the root. // Weaken the root.
root.MakeWeak(&counter, &WeakPointerCallback); root.handle.SetWeak(&root, &WeakPointerCallback);
// But make children strong roots---all the objects (except for children) // But make children strong roots---all the objects (except for children)
// should be collectable now. // should be collectable now.
g1c1.ClearWeak(); g1c1.handle.ClearWeak();
g2c1.ClearWeak(); g2c1.handle.ClearWeak();
// Groups are deleted, rebuild groups. // Groups are deleted, rebuild groups.
{ {
UniqueId id1 = MakeUniqueId(g1s1); UniqueId id1 = MakeUniqueId(g1s1.handle);
UniqueId id2 = MakeUniqueId(g2s2); UniqueId id2 = MakeUniqueId(g2s2.handle);
iso->SetObjectGroupId(g1s1, id1); iso->SetObjectGroupId(g1s1.handle, id1);
iso->SetObjectGroupId(g1s2, id1); iso->SetObjectGroupId(g1s2.handle, id1);
iso->SetReference(g1s1, g1c1); iso->SetReference(g1s1.handle, g1c1.handle);
iso->SetObjectGroupId(g2s1, id2); iso->SetObjectGroupId(g2s1.handle, id2);
iso->SetObjectGroupId(g2s2, id2); iso->SetObjectGroupId(g2s2.handle, id2);
iso->SetReferenceFromGroup(id2, g2c1); iso->SetReferenceFromGroup(id2, g2c1.handle);
} }
heap->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask); heap->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
...@@ -3636,8 +3648,8 @@ THREADED_TEST(ApiObjectGroupsForSubtypes) { ...@@ -3636,8 +3648,8 @@ THREADED_TEST(ApiObjectGroupsForSubtypes) {
CHECK_EQ(5, counter.NumberOfWeakCalls()); CHECK_EQ(5, counter.NumberOfWeakCalls());
// And now make children weak again and collect them. // And now make children weak again and collect them.
g1c1.MakeWeak(&counter, &WeakPointerCallback); g1c1.handle.SetWeak(&g1c1, &WeakPointerCallback);
g2c1.MakeWeak(&counter, &WeakPointerCallback); g2c1.handle.SetWeak(&g2c1, &WeakPointerCallback);
heap->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask); heap->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
CHECK_EQ(7, counter.NumberOfWeakCalls()); CHECK_EQ(7, counter.NumberOfWeakCalls());
...@@ -3651,68 +3663,69 @@ THREADED_TEST(ApiObjectGroupsCycle) { ...@@ -3651,68 +3663,69 @@ THREADED_TEST(ApiObjectGroupsCycle) {
WeakCallCounter counter(1234); WeakCallCounter counter(1234);
Persistent<Value> g1s1; WeakCallCounterAndPersistent<Value> g1s1(&counter);
Persistent<Value> g1s2; WeakCallCounterAndPersistent<Value> g1s2(&counter);
Persistent<Value> g2s1; WeakCallCounterAndPersistent<Value> g2s1(&counter);
Persistent<Value> g2s2; WeakCallCounterAndPersistent<Value> g2s2(&counter);
Persistent<Value> g3s1; WeakCallCounterAndPersistent<Value> g3s1(&counter);
Persistent<Value> g3s2; WeakCallCounterAndPersistent<Value> g3s2(&counter);
Persistent<Value> g4s1; WeakCallCounterAndPersistent<Value> g4s1(&counter);
Persistent<Value> g4s2; WeakCallCounterAndPersistent<Value> g4s2(&counter);
{ {
HandleScope scope(iso); HandleScope scope(iso);
g1s1.Reset(iso, Object::New()); g1s1.handle.Reset(iso, Object::New());
g1s2.Reset(iso, Object::New()); g1s2.handle.Reset(iso, Object::New());
g1s1.MakeWeak(&counter, &WeakPointerCallback); g1s1.handle.SetWeak(&g1s1, &WeakPointerCallback);
g1s2.MakeWeak(&counter, &WeakPointerCallback); g1s2.handle.SetWeak(&g1s2, &WeakPointerCallback);
CHECK(g1s1.IsWeak()); CHECK(g1s1.handle.IsWeak());
CHECK(g1s2.IsWeak()); CHECK(g1s2.handle.IsWeak());
g2s1.Reset(iso, Object::New()); g2s1.handle.Reset(iso, Object::New());
g2s2.Reset(iso, Object::New()); g2s2.handle.Reset(iso, Object::New());
g2s1.MakeWeak(&counter, &WeakPointerCallback); g2s1.handle.SetWeak(&g2s1, &WeakPointerCallback);
g2s2.MakeWeak(&counter, &WeakPointerCallback); g2s2.handle.SetWeak(&g2s2, &WeakPointerCallback);
CHECK(g2s1.IsWeak()); CHECK(g2s1.handle.IsWeak());
CHECK(g2s2.IsWeak()); CHECK(g2s2.handle.IsWeak());
g3s1.Reset(iso, Object::New()); g3s1.handle.Reset(iso, Object::New());
g3s2.Reset(iso, Object::New()); g3s2.handle.Reset(iso, Object::New());
g3s1.MakeWeak(&counter, &WeakPointerCallback); g3s1.handle.SetWeak(&g3s1, &WeakPointerCallback);
g3s2.MakeWeak(&counter, &WeakPointerCallback); g3s2.handle.SetWeak(&g3s2, &WeakPointerCallback);
CHECK(g3s1.IsWeak()); CHECK(g3s1.handle.IsWeak());
CHECK(g3s2.IsWeak()); CHECK(g3s2.handle.IsWeak());
g4s1.Reset(iso, Object::New()); g4s1.handle.Reset(iso, Object::New());
g4s2.Reset(iso, Object::New()); g4s2.handle.Reset(iso, Object::New());
g4s1.MakeWeak(&counter, &WeakPointerCallback); g4s1.handle.SetWeak(&g4s1, &WeakPointerCallback);
g4s2.MakeWeak(&counter, &WeakPointerCallback); g4s2.handle.SetWeak(&g4s2, &WeakPointerCallback);
CHECK(g4s1.IsWeak()); CHECK(g4s1.handle.IsWeak());
CHECK(g4s2.IsWeak()); CHECK(g4s2.handle.IsWeak());
} }
Persistent<Value> root(iso, g1s1); // make a root. WeakCallCounterAndPersistent<Value> root(&counter);
root.handle.Reset(iso, g1s1.handle); // make a root.
// Connect groups. We're building the following cycle: // Connect groups. We're building the following cycle:
// G1: { g1s1, g2s1 }, g1s1 implicitly references g2s1, ditto for other // G1: { g1s1, g2s1 }, g1s1 implicitly references g2s1, ditto for other
// groups. // groups.
{ {
UniqueId id1 = MakeUniqueId(g1s1); UniqueId id1 = MakeUniqueId(g1s1.handle);
UniqueId id2 = MakeUniqueId(g2s1); UniqueId id2 = MakeUniqueId(g2s1.handle);
UniqueId id3 = MakeUniqueId(g3s1); UniqueId id3 = MakeUniqueId(g3s1.handle);
UniqueId id4 = MakeUniqueId(g4s1); UniqueId id4 = MakeUniqueId(g4s1.handle);
iso->SetObjectGroupId(g1s1, id1); iso->SetObjectGroupId(g1s1.handle, id1);
iso->SetObjectGroupId(g1s2, id1); iso->SetObjectGroupId(g1s2.handle, id1);
iso->SetReferenceFromGroup(id1, g2s1); iso->SetReferenceFromGroup(id1, g2s1.handle);
iso->SetObjectGroupId(g2s1, id2); iso->SetObjectGroupId(g2s1.handle, id2);
iso->SetObjectGroupId(g2s2, id2); iso->SetObjectGroupId(g2s2.handle, id2);
iso->SetReferenceFromGroup(id2, g3s1); iso->SetReferenceFromGroup(id2, g3s1.handle);
iso->SetObjectGroupId(g3s1, id3); iso->SetObjectGroupId(g3s1.handle, id3);
iso->SetObjectGroupId(g3s2, id3); iso->SetObjectGroupId(g3s2.handle, id3);
iso->SetReferenceFromGroup(id3, g4s1); iso->SetReferenceFromGroup(id3, g4s1.handle);
iso->SetObjectGroupId(g4s1, id4); iso->SetObjectGroupId(g4s1.handle, id4);
iso->SetObjectGroupId(g4s2, id4); iso->SetObjectGroupId(g4s2.handle, id4);
iso->SetReferenceFromGroup(id4, g1s1); iso->SetReferenceFromGroup(id4, g1s1.handle);
} }
// Do a single full GC // Do a single full GC
v8::internal::Heap* heap = reinterpret_cast<v8::internal::Isolate*>( v8::internal::Heap* heap = reinterpret_cast<v8::internal::Isolate*>(
...@@ -3723,26 +3736,26 @@ THREADED_TEST(ApiObjectGroupsCycle) { ...@@ -3723,26 +3736,26 @@ THREADED_TEST(ApiObjectGroupsCycle) {
CHECK_EQ(0, counter.NumberOfWeakCalls()); CHECK_EQ(0, counter.NumberOfWeakCalls());
// Weaken the root. // Weaken the root.
root.MakeWeak(&counter, &WeakPointerCallback); root.handle.SetWeak(&root, &WeakPointerCallback);
// Groups are deleted, rebuild groups. // Groups are deleted, rebuild groups.
{ {
UniqueId id1 = MakeUniqueId(g1s1); UniqueId id1 = MakeUniqueId(g1s1.handle);
UniqueId id2 = MakeUniqueId(g2s1); UniqueId id2 = MakeUniqueId(g2s1.handle);
UniqueId id3 = MakeUniqueId(g3s1); UniqueId id3 = MakeUniqueId(g3s1.handle);
UniqueId id4 = MakeUniqueId(g4s1); UniqueId id4 = MakeUniqueId(g4s1.handle);
iso->SetObjectGroupId(g1s1, id1); iso->SetObjectGroupId(g1s1.handle, id1);
iso->SetObjectGroupId(g1s2, id1); iso->SetObjectGroupId(g1s2.handle, id1);
iso->SetReferenceFromGroup(id1, g2s1); iso->SetReferenceFromGroup(id1, g2s1.handle);
iso->SetObjectGroupId(g2s1, id2); iso->SetObjectGroupId(g2s1.handle, id2);
iso->SetObjectGroupId(g2s2, id2); iso->SetObjectGroupId(g2s2.handle, id2);
iso->SetReferenceFromGroup(id2, g3s1); iso->SetReferenceFromGroup(id2, g3s1.handle);
iso->SetObjectGroupId(g3s1, id3); iso->SetObjectGroupId(g3s1.handle, id3);
iso->SetObjectGroupId(g3s2, id3); iso->SetObjectGroupId(g3s2.handle, id3);
iso->SetReferenceFromGroup(id3, g4s1); iso->SetReferenceFromGroup(id3, g4s1.handle);
iso->SetObjectGroupId(g4s1, id4); iso->SetObjectGroupId(g4s1.handle, id4);
iso->SetObjectGroupId(g4s2, id4); iso->SetObjectGroupId(g4s2.handle, id4);
iso->SetReferenceFromGroup(id4, g1s1); iso->SetReferenceFromGroup(id4, g1s1.handle);
} }
heap->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask); heap->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
...@@ -3763,58 +3776,59 @@ TEST(ApiObjectGroupsCycleForScavenger) { ...@@ -3763,58 +3776,59 @@ TEST(ApiObjectGroupsCycleForScavenger) {
WeakCallCounter counter(1234); WeakCallCounter counter(1234);
Persistent<Value> g1s1; WeakCallCounterAndPersistent<Value> g1s1(&counter);
Persistent<Value> g1s2; WeakCallCounterAndPersistent<Value> g1s2(&counter);
Persistent<Value> g2s1; WeakCallCounterAndPersistent<Value> g2s1(&counter);
Persistent<Value> g2s2; WeakCallCounterAndPersistent<Value> g2s2(&counter);
Persistent<Value> g3s1; WeakCallCounterAndPersistent<Value> g3s1(&counter);
Persistent<Value> g3s2; WeakCallCounterAndPersistent<Value> g3s2(&counter);
{ {
HandleScope scope(iso); HandleScope scope(iso);
g1s1.Reset(iso, Object::New()); g1s1.handle.Reset(iso, Object::New());
g1s2.Reset(iso, Object::New()); g1s2.handle.Reset(iso, Object::New());
g1s1.MakeWeak(&counter, &WeakPointerCallback); g1s1.handle.SetWeak(&g1s1, &WeakPointerCallback);
g1s2.MakeWeak(&counter, &WeakPointerCallback); g1s2.handle.SetWeak(&g1s2, &WeakPointerCallback);
g2s1.Reset(iso, Object::New()); g2s1.handle.Reset(iso, Object::New());
g2s2.Reset(iso, Object::New()); g2s2.handle.Reset(iso, Object::New());
g2s1.MakeWeak(&counter, &WeakPointerCallback); g2s1.handle.SetWeak(&g2s1, &WeakPointerCallback);
g2s2.MakeWeak(&counter, &WeakPointerCallback); g2s2.handle.SetWeak(&g2s2, &WeakPointerCallback);
g3s1.Reset(iso, Object::New()); g3s1.handle.Reset(iso, Object::New());
g3s2.Reset(iso, Object::New()); g3s2.handle.Reset(iso, Object::New());
g3s1.MakeWeak(&counter, &WeakPointerCallback); g3s1.handle.SetWeak(&g3s1, &WeakPointerCallback);
g3s2.MakeWeak(&counter, &WeakPointerCallback); g3s2.handle.SetWeak(&g3s2, &WeakPointerCallback);
} }
// Make a root. // Make a root.
Persistent<Value> root(iso, g1s1); WeakCallCounterAndPersistent<Value> root(&counter);
root.MarkPartiallyDependent(); root.handle.Reset(iso, g1s1.handle);
root.handle.MarkPartiallyDependent();
// Connect groups. We're building the following cycle: // Connect groups. We're building the following cycle:
// G1: { g1s1, g2s1 }, g1s1 implicitly references g2s1, ditto for other // G1: { g1s1, g2s1 }, g1s1 implicitly references g2s1, ditto for other
// groups. // groups.
{ {
HandleScope handle_scope(iso); HandleScope handle_scope(iso);
g1s1.MarkPartiallyDependent(); g1s1.handle.MarkPartiallyDependent();
g1s2.MarkPartiallyDependent(); g1s2.handle.MarkPartiallyDependent();
g2s1.MarkPartiallyDependent(); g2s1.handle.MarkPartiallyDependent();
g2s2.MarkPartiallyDependent(); g2s2.handle.MarkPartiallyDependent();
g3s1.MarkPartiallyDependent(); g3s1.handle.MarkPartiallyDependent();
g3s2.MarkPartiallyDependent(); g3s2.handle.MarkPartiallyDependent();
iso->SetObjectGroupId(g1s1, UniqueId(1)); iso->SetObjectGroupId(g1s1.handle, UniqueId(1));
iso->SetObjectGroupId(g1s2, UniqueId(1)); iso->SetObjectGroupId(g1s2.handle, UniqueId(1));
Local<Object>::New(iso, g1s1.As<Object>())->Set( Local<Object>::New(iso, g1s1.handle.As<Object>())->Set(
v8_str("x"), Local<Value>::New(iso, g2s1)); v8_str("x"), Local<Value>::New(iso, g2s1.handle));
iso->SetObjectGroupId(g2s1, UniqueId(2)); iso->SetObjectGroupId(g2s1.handle, UniqueId(2));
iso->SetObjectGroupId(g2s2, UniqueId(2)); iso->SetObjectGroupId(g2s2.handle, UniqueId(2));
Local<Object>::New(iso, g2s1.As<Object>())->Set( Local<Object>::New(iso, g2s1.handle.As<Object>())->Set(
v8_str("x"), Local<Value>::New(iso, g3s1)); v8_str("x"), Local<Value>::New(iso, g3s1.handle));
iso->SetObjectGroupId(g3s1, UniqueId(3)); iso->SetObjectGroupId(g3s1.handle, UniqueId(3));
iso->SetObjectGroupId(g3s2, UniqueId(3)); iso->SetObjectGroupId(g3s2.handle, UniqueId(3));
Local<Object>::New(iso, g3s1.As<Object>())->Set( Local<Object>::New(iso, g3s1.handle.As<Object>())->Set(
v8_str("x"), Local<Value>::New(iso, g1s1)); v8_str("x"), Local<Value>::New(iso, g1s1.handle));
} }
v8::internal::Heap* heap = reinterpret_cast<v8::internal::Isolate*>( v8::internal::Heap* heap = reinterpret_cast<v8::internal::Isolate*>(
...@@ -3825,30 +3839,30 @@ TEST(ApiObjectGroupsCycleForScavenger) { ...@@ -3825,30 +3839,30 @@ TEST(ApiObjectGroupsCycleForScavenger) {
CHECK_EQ(0, counter.NumberOfWeakCalls()); CHECK_EQ(0, counter.NumberOfWeakCalls());
// Weaken the root. // Weaken the root.
root.MakeWeak(&counter, &WeakPointerCallback); root.handle.SetWeak(&root, &WeakPointerCallback);
root.MarkPartiallyDependent(); root.handle.MarkPartiallyDependent();
// Groups are deleted, rebuild groups. // Groups are deleted, rebuild groups.
{ {
HandleScope handle_scope(iso); HandleScope handle_scope(iso);
g1s1.MarkPartiallyDependent(); g1s1.handle.MarkPartiallyDependent();
g1s2.MarkPartiallyDependent(); g1s2.handle.MarkPartiallyDependent();
g2s1.MarkPartiallyDependent(); g2s1.handle.MarkPartiallyDependent();
g2s2.MarkPartiallyDependent(); g2s2.handle.MarkPartiallyDependent();
g3s1.MarkPartiallyDependent(); g3s1.handle.MarkPartiallyDependent();
g3s2.MarkPartiallyDependent(); g3s2.handle.MarkPartiallyDependent();
iso->SetObjectGroupId(g1s1, UniqueId(1)); iso->SetObjectGroupId(g1s1.handle, UniqueId(1));
iso->SetObjectGroupId(g1s2, UniqueId(1)); iso->SetObjectGroupId(g1s2.handle, UniqueId(1));
Local<Object>::New(iso, g1s1.As<Object>())->Set( Local<Object>::New(iso, g1s1.handle.As<Object>())->Set(
v8_str("x"), Local<Value>::New(iso, g2s1)); v8_str("x"), Local<Value>::New(iso, g2s1.handle));
iso->SetObjectGroupId(g2s1, UniqueId(2)); iso->SetObjectGroupId(g2s1.handle, UniqueId(2));
iso->SetObjectGroupId(g2s2, UniqueId(2)); iso->SetObjectGroupId(g2s2.handle, UniqueId(2));
Local<Object>::New(iso, g2s1.As<Object>())->Set( Local<Object>::New(iso, g2s1.handle.As<Object>())->Set(
v8_str("x"), Local<Value>::New(iso, g3s1)); v8_str("x"), Local<Value>::New(iso, g3s1.handle));
iso->SetObjectGroupId(g3s1, UniqueId(3)); iso->SetObjectGroupId(g3s1.handle, UniqueId(3));
iso->SetObjectGroupId(g3s2, UniqueId(3)); iso->SetObjectGroupId(g3s2.handle, UniqueId(3));
Local<Object>::New(iso, g3s1.As<Object>())->Set( Local<Object>::New(iso, g3s1.handle.As<Object>())->Set(
v8_str("x"), Local<Value>::New(iso, g1s1)); v8_str("x"), Local<Value>::New(iso, g1s1.handle));
} }
heap->CollectGarbage(i::NEW_SPACE); heap->CollectGarbage(i::NEW_SPACE);
...@@ -6947,9 +6961,13 @@ THREADED_TEST(ErrorWithMissingScriptInfo) { ...@@ -6947,9 +6961,13 @@ THREADED_TEST(ErrorWithMissingScriptInfo) {
int global_index = 0; int global_index = 0;
template<typename T>
class Snorkel { class Snorkel {
public: public:
Snorkel() { index_ = global_index++; } explicit Snorkel(v8::Persistent<T>* handle) : handle_(handle) {
index_ = global_index++;
}
v8::Persistent<T>* handle_;
int index_; int index_;
}; };
...@@ -6970,11 +6988,10 @@ class Whammy { ...@@ -6970,11 +6988,10 @@ class Whammy {
v8::Persistent<Script> script_; v8::Persistent<Script> script_;
}; };
static void HandleWeakReference(v8::Isolate* isolate, static void HandleWeakReference(
v8::Persistent<v8::Value>* obj, const v8::WeakCallbackData<v8::Value, Snorkel<v8::Value> >& data) {
Snorkel* snorkel) { data.GetParameter()->handle_->ClearWeak();
delete snorkel; delete data.GetParameter();
obj->ClearWeak();
} }
void WhammyPropertyGetter(Local<String> name, void WhammyPropertyGetter(Local<String> name,
...@@ -6988,7 +7005,8 @@ void WhammyPropertyGetter(Local<String> name, ...@@ -6988,7 +7005,8 @@ void WhammyPropertyGetter(Local<String> name,
if (!prev.IsEmpty()) { if (!prev.IsEmpty()) {
v8::Local<v8::Object>::New(info.GetIsolate(), prev) v8::Local<v8::Object>::New(info.GetIsolate(), prev)
->Set(v8_str("next"), obj); ->Set(v8_str("next"), obj);
prev.MakeWeak<Value, Snorkel>(new Snorkel(), &HandleWeakReference); prev.SetWeak<Value, Snorkel<Value> >(new Snorkel<Value>(&prev.As<Value>()),
&HandleWeakReference);
} }
whammy->objects_[whammy->cursor_].Reset(info.GetIsolate(), obj); whammy->objects_[whammy->cursor_].Reset(info.GetIsolate(), obj);
whammy->cursor_ = (whammy->cursor_ + 1) % Whammy::kObjectCount; whammy->cursor_ = (whammy->cursor_ + 1) % Whammy::kObjectCount;
...@@ -7026,11 +7044,16 @@ THREADED_TEST(WeakReference) { ...@@ -7026,11 +7044,16 @@ THREADED_TEST(WeakReference) {
} }
static void DisposeAndSetFlag(v8::Isolate* isolate, struct FlagAndPersistent {
v8::Persistent<v8::Object>* obj, bool flag;
bool* data) { v8::Persistent<v8::Object> handle;
obj->Reset(); };
*(data) = true;
static void DisposeAndSetFlag(
const v8::WeakCallbackData<v8::Object, FlagAndPersistent>& data) {
data.GetParameter()->handle.Reset();
data.GetParameter()->flag = true;
} }
...@@ -7040,25 +7063,25 @@ THREADED_TEST(IndependentWeakHandle) { ...@@ -7040,25 +7063,25 @@ THREADED_TEST(IndependentWeakHandle) {
v8::Handle<Context> context = Context::New(iso); v8::Handle<Context> context = Context::New(iso);
Context::Scope context_scope(context); Context::Scope context_scope(context);
v8::Persistent<v8::Object> object_a, object_b; FlagAndPersistent object_a, object_b;
{ {
v8::HandleScope handle_scope(iso); v8::HandleScope handle_scope(iso);
object_a.Reset(iso, v8::Object::New()); object_a.handle.Reset(iso, v8::Object::New());
object_b.Reset(iso, v8::Object::New()); object_b.handle.Reset(iso, v8::Object::New());
} }
bool object_a_disposed = false; object_a.flag = false;
bool object_b_disposed = false; object_b.flag = false;
object_a.MakeWeak(&object_a_disposed, &DisposeAndSetFlag); object_a.handle.SetWeak(&object_a, &DisposeAndSetFlag);
object_b.MakeWeak(&object_b_disposed, &DisposeAndSetFlag); object_b.handle.SetWeak(&object_b, &DisposeAndSetFlag);
CHECK(!object_b.IsIndependent()); CHECK(!object_b.handle.IsIndependent());
object_a.MarkIndependent(); object_a.handle.MarkIndependent();
object_b.MarkIndependent(); object_b.handle.MarkIndependent();
CHECK(object_b.IsIndependent()); CHECK(object_b.handle.IsIndependent());
CcTest::heap()->PerformScavenge(); CcTest::heap()->PerformScavenge();
CHECK(object_a_disposed); CHECK(object_a.flag);
CHECK(object_b_disposed); CHECK(object_b.flag);
} }
...@@ -7072,20 +7095,18 @@ static void InvokeMarkSweep() { ...@@ -7072,20 +7095,18 @@ static void InvokeMarkSweep() {
} }
static void ForceScavenge(v8::Isolate* isolate, static void ForceScavenge(
v8::Persistent<v8::Object>* obj, const v8::WeakCallbackData<v8::Object, FlagAndPersistent>& data) {
bool* data) { data.GetParameter()->handle.Reset();
obj->Reset(); data.GetParameter()->flag = true;
*(data) = true;
InvokeScavenge(); InvokeScavenge();
} }
static void ForceMarkSweep(v8::Isolate* isolate, static void ForceMarkSweep(
v8::Persistent<v8::Object>* obj, const v8::WeakCallbackData<v8::Object, FlagAndPersistent>& data) {
bool* data) { data.GetParameter()->handle.Reset();
obj->Reset(); data.GetParameter()->flag = true;
*(data) = true;
InvokeMarkSweep(); InvokeMarkSweep();
} }
...@@ -7097,7 +7118,8 @@ THREADED_TEST(GCFromWeakCallbacks) { ...@@ -7097,7 +7118,8 @@ THREADED_TEST(GCFromWeakCallbacks) {
Context::Scope context_scope(context); Context::Scope context_scope(context);
static const int kNumberOfGCTypes = 2; static const int kNumberOfGCTypes = 2;
typedef v8::WeakReferenceCallbacks<v8::Object, bool>::Revivable Callback; typedef v8::WeakCallbackData<v8::Object, FlagAndPersistent>::Callback
Callback;
Callback gc_forcing_callback[kNumberOfGCTypes] = Callback gc_forcing_callback[kNumberOfGCTypes] =
{&ForceScavenge, &ForceMarkSweep}; {&ForceScavenge, &ForceMarkSweep};
...@@ -7106,26 +7128,25 @@ THREADED_TEST(GCFromWeakCallbacks) { ...@@ -7106,26 +7128,25 @@ THREADED_TEST(GCFromWeakCallbacks) {
for (int outer_gc = 0; outer_gc < kNumberOfGCTypes; outer_gc++) { for (int outer_gc = 0; outer_gc < kNumberOfGCTypes; outer_gc++) {
for (int inner_gc = 0; inner_gc < kNumberOfGCTypes; inner_gc++) { for (int inner_gc = 0; inner_gc < kNumberOfGCTypes; inner_gc++) {
v8::Persistent<v8::Object> object; FlagAndPersistent object;
{ {
v8::HandleScope handle_scope(isolate); v8::HandleScope handle_scope(isolate);
object.Reset(isolate, v8::Object::New()); object.handle.Reset(isolate, v8::Object::New());
} }
bool disposed = false; object.flag = false;
object.MakeWeak(&disposed, gc_forcing_callback[inner_gc]); object.handle.SetWeak(&object, gc_forcing_callback[inner_gc]);
object.MarkIndependent(); object.handle.MarkIndependent();
invoke_gc[outer_gc](); invoke_gc[outer_gc]();
CHECK(disposed); CHECK(object.flag);
} }
} }
} }
static void RevivingCallback(v8::Isolate* isolate, static void RevivingCallback(
v8::Persistent<v8::Object>* obj, const v8::WeakCallbackData<v8::Object, FlagAndPersistent>& data) {
bool* data) { data.GetParameter()->handle.ClearWeak();
obj->ClearWeak(); data.GetParameter()->flag = true;
*(data) = true;
} }
...@@ -7135,24 +7156,25 @@ THREADED_TEST(IndependentHandleRevival) { ...@@ -7135,24 +7156,25 @@ THREADED_TEST(IndependentHandleRevival) {
v8::Handle<Context> context = Context::New(isolate); v8::Handle<Context> context = Context::New(isolate);
Context::Scope context_scope(context); Context::Scope context_scope(context);
v8::Persistent<v8::Object> object; FlagAndPersistent object;
{ {
v8::HandleScope handle_scope(isolate); v8::HandleScope handle_scope(isolate);
v8::Local<v8::Object> o = v8::Object::New(); v8::Local<v8::Object> o = v8::Object::New();
object.Reset(isolate, o); object.handle.Reset(isolate, o);
o->Set(v8_str("x"), v8::Integer::New(1)); o->Set(v8_str("x"), v8::Integer::New(1));
v8::Local<String> y_str = v8_str("y"); v8::Local<String> y_str = v8_str("y");
o->Set(y_str, y_str); o->Set(y_str, y_str);
} }
bool revived = false; object.flag = false;
object.MakeWeak(&revived, &RevivingCallback); object.handle.SetWeak(&object, &RevivingCallback);
object.MarkIndependent(); object.handle.MarkIndependent();
CcTest::heap()->PerformScavenge(); CcTest::heap()->PerformScavenge();
CHECK(revived); CHECK(object.flag);
CcTest::heap()->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask); CcTest::heap()->CollectAllGarbage(i::Heap::kAbortIncrementalMarkingMask);
{ {
v8::HandleScope handle_scope(isolate); v8::HandleScope handle_scope(isolate);
v8::Local<v8::Object> o = v8::Local<v8::Object>::New(isolate, object); v8::Local<v8::Object> o =
v8::Local<v8::Object>::New(isolate, object.handle);
v8::Local<String> y_str = v8_str("y"); v8::Local<String> y_str = v8_str("y");
CHECK_EQ(v8::Integer::New(1), o->Get(v8_str("x"))); CHECK_EQ(v8::Integer::New(1), o->Get(v8_str("x")));
CHECK(o->Get(y_str)->Equals(y_str)); CHECK(o->Get(y_str)->Equals(y_str));
...@@ -13106,12 +13128,11 @@ TEST(WeakCallbackApi) { ...@@ -13106,12 +13128,11 @@ TEST(WeakCallbackApi) {
v8::Persistent<v8::Object> some_object; v8::Persistent<v8::Object> some_object;
v8::Persistent<v8::Object> bad_handle; v8::Persistent<v8::Object> bad_handle;
void NewPersistentHandleCallback(v8::Isolate* isolate, void NewPersistentHandleCallback(
v8::Persistent<v8::Value>* handle, const v8::WeakCallbackData<v8::Object, v8::Persistent<v8::Object> >& data) {
void*) { v8::HandleScope scope(data.GetIsolate());
v8::HandleScope scope(isolate); bad_handle.Reset(data.GetIsolate(), some_object);
bad_handle.Reset(isolate, some_object); data.GetParameter()->Reset();
handle->Reset();
} }
...@@ -13130,7 +13151,7 @@ THREADED_TEST(NewPersistentHandleFromWeakCallback) { ...@@ -13130,7 +13151,7 @@ THREADED_TEST(NewPersistentHandleFromWeakCallback) {
// global handle nodes are processed by PostGarbageCollectionProcessing // global handle nodes are processed by PostGarbageCollectionProcessing
// in reverse allocation order, so if second allocated handle is deleted, // in reverse allocation order, so if second allocated handle is deleted,
// weak callback of the first handle would be able to 'reallocate' it. // weak callback of the first handle would be able to 'reallocate' it.
handle1.MakeWeak<v8::Value, void>(NULL, NewPersistentHandleCallback); handle1.SetWeak(&handle1, NewPersistentHandleCallback);
handle2.Reset(); handle2.Reset();
CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags); CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
} }
...@@ -13138,12 +13159,11 @@ THREADED_TEST(NewPersistentHandleFromWeakCallback) { ...@@ -13138,12 +13159,11 @@ THREADED_TEST(NewPersistentHandleFromWeakCallback) {
v8::Persistent<v8::Object> to_be_disposed; v8::Persistent<v8::Object> to_be_disposed;
void DisposeAndForceGcCallback(v8::Isolate* isolate, void DisposeAndForceGcCallback(
v8::Persistent<v8::Value>* handle, const v8::WeakCallbackData<v8::Object, v8::Persistent<v8::Object> >& data) {
void*) {
to_be_disposed.Reset(); to_be_disposed.Reset();
CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags); CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
handle->Reset(); data.GetParameter()->Reset();
} }
...@@ -13157,23 +13177,21 @@ THREADED_TEST(DoNotUseDeletedNodesInSecondLevelGc) { ...@@ -13157,23 +13177,21 @@ THREADED_TEST(DoNotUseDeletedNodesInSecondLevelGc) {
handle1.Reset(isolate, v8::Object::New()); handle1.Reset(isolate, v8::Object::New());
handle2.Reset(isolate, v8::Object::New()); handle2.Reset(isolate, v8::Object::New());
} }
handle1.MakeWeak<v8::Value, void>(NULL, DisposeAndForceGcCallback); handle1.SetWeak(&handle1, DisposeAndForceGcCallback);
to_be_disposed.Reset(isolate, handle2); to_be_disposed.Reset(isolate, handle2);
CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags); CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
} }
void DisposingCallback(v8::Isolate* isolate, void DisposingCallback(
v8::Persistent<v8::Value>* handle, const v8::WeakCallbackData<v8::Object, v8::Persistent<v8::Object> >& data) {
void*) { data.GetParameter()->Reset();
handle->Reset();
} }
void HandleCreatingCallback(v8::Isolate* isolate, void HandleCreatingCallback(
v8::Persistent<v8::Value>* handle, const v8::WeakCallbackData<v8::Object, v8::Persistent<v8::Object> >& data) {
void*) { v8::HandleScope scope(data.GetIsolate());
v8::HandleScope scope(isolate); v8::Persistent<v8::Object>(data.GetIsolate(), v8::Object::New());
v8::Persistent<v8::Object>(isolate, v8::Object::New()); data.GetParameter()->Reset();
handle->Reset();
} }
...@@ -13188,8 +13206,8 @@ THREADED_TEST(NoGlobalHandlesOrphaningDueToWeakCallback) { ...@@ -13188,8 +13206,8 @@ THREADED_TEST(NoGlobalHandlesOrphaningDueToWeakCallback) {
handle2.Reset(isolate, v8::Object::New()); handle2.Reset(isolate, v8::Object::New());
handle1.Reset(isolate, v8::Object::New()); handle1.Reset(isolate, v8::Object::New());
} }
handle2.MakeWeak<v8::Value, void>(NULL, DisposingCallback); handle2.SetWeak(&handle2, DisposingCallback);
handle3.MakeWeak<v8::Value, void>(NULL, HandleCreatingCallback); handle3.SetWeak(&handle3, HandleCreatingCallback);
CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags); CcTest::heap()->CollectAllGarbage(i::Heap::kNoGCFlags);
} }
......
test/cctest/test-heap-profiler.cc
View file @ 8565d3e9
...@@ -1763,10 +1763,10 @@ bool HasWeakGlobalHandle() { ...@@ -1763,10 +1763,10 @@ bool HasWeakGlobalHandle() {
} }
static void PersistentHandleCallback(v8::Isolate* isolate, static void PersistentHandleCallback(
v8::Persistent<v8::Value>* handle, const v8::WeakCallbackData<v8::Object, v8::Persistent<v8::Object> >& data) {
void*) { data.GetParameter()->Reset();
handle->Reset(); delete data.GetParameter();
} }
...@@ -1776,8 +1776,9 @@ TEST(WeakGlobalHandle) { ...@@ -1776,8 +1776,9 @@ TEST(WeakGlobalHandle) {
CHECK(!HasWeakGlobalHandle()); CHECK(!HasWeakGlobalHandle());
v8::Persistent<v8::Object> handle(env->GetIsolate(), v8::Object::New()); v8::Persistent<v8::Object>* handle =
handle.MakeWeak<v8::Value, void>(NULL, PersistentHandleCallback); new v8::Persistent<v8::Object>(env->GetIsolate(), v8::Object::New());
handle->SetWeak(handle, PersistentHandleCallback);
CHECK(HasWeakGlobalHandle()); CHECK(HasWeakGlobalHandle());
} }
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment