When debugging Handle leaks in io.js we found it very convenient to be
able to Seal some specific (root in our case) scope to prevent Handle
allocations in it, and easily find leakage.
R=yangguo
BUG=
Review URL: https://codereview.chromium.org/
1079713002
Cr-Commit-Position: refs/heads/master@{#27766}
internal::Object** escape_slot_;
};
+class V8_EXPORT SealHandleScope {
+ public:
+ SealHandleScope(Isolate* isolate);
+ ~SealHandleScope();
+
+ private:
+ // Make it hard to create heap-allocated or illegal handle scopes by
+ // disallowing certain operations.
+ SealHandleScope(const SealHandleScope&);
+ void operator=(const SealHandleScope&);
+ void* operator new(size_t size);
+ void operator delete(void*, size_t);
+
+ internal::Isolate* isolate_;
+ int prev_level_;
+ internal::Object** prev_limit_;
+};
+
// --- Special objects ---
}
+SealHandleScope::SealHandleScope(Isolate* isolate) {
+ i::Isolate* internal_isolate = reinterpret_cast<i::Isolate*>(isolate);
+
+ isolate_ = internal_isolate;
+ i::HandleScopeData* current = internal_isolate->handle_scope_data();
+ prev_limit_ = current->limit;
+ current->limit = current->next;
+ prev_level_ = current->level;
+ current->level = 0;
+}
+
+
+SealHandleScope::~SealHandleScope() {
+ i::HandleScopeData* current = isolate_->handle_scope_data();
+ DCHECK_EQ(0, current->level);
+ current->level = prev_level_;
+ DCHECK_EQ(current->next, current->limit);
+ current->limit = prev_limit_;
+}
+
+
void Context::Enter() {
i::Handle<i::Context> env = Utils::OpenHandle(this);
i::Isolate* isolate = env->GetIsolate();
while (!blocks_.is_empty()) {
internal::Object** block_start = blocks_.last();
internal::Object** block_limit = block_start + kHandleBlockSize;
-#ifdef DEBUG
+
// SealHandleScope may make the prev_limit to point inside the block.
if (block_start <= prev_limit && prev_limit <= block_limit) {
#ifdef ENABLE_HANDLE_ZAPPING
#endif
break;
}
-#else
- if (prev_limit == block_limit) break;
-#endif
blocks_.RemoveLast();
#ifdef ENABLE_HANDLE_ZAPPING
# they don't fail then test.py has failed.
'test-serialize/TestThatAlwaysFails': [FAIL],
'test-serialize/DependentTestThatAlwaysFails': [FAIL],
+ 'test-api/SealHandleScope': [FAIL],
# This test always fails. It tests that LiveEdit causes abort when turned off.
'test-debug/LiveEditDisabled': [FAIL],
}
free(buffer);
}
+
+
+TEST(SealHandleScope) {
+ v8::Isolate* isolate = CcTest::isolate();
+ v8::HandleScope handle_scope(isolate);
+ LocalContext env;
+
+ v8::SealHandleScope seal(isolate);
+
+ // Should fail
+ v8::Local<v8::Object> obj = v8::Object::New(isolate);
+
+ USE(obj);
+}
+
+
+TEST(SealHandleScopeNested) {
+ v8::Isolate* isolate = CcTest::isolate();
+ v8::HandleScope handle_scope(isolate);
+ LocalContext env;
+
+ v8::SealHandleScope seal(isolate);
+
+ {
+ v8::HandleScope handle_scope(isolate);
+
+ // Should work
+ v8::Local<v8::Object> obj = v8::Object::New(isolate);
+
+ USE(obj);
+ }
+}