first step to remove unsafe handles

test/cctest/test-api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 14 matching lines @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <limits.h>
 
 #ifndef WIN32
 #include <signal.h>  // kill
 #include <unistd.h>  // getpid
 #endif  // WIN32
 
+// TODO(dcarney): remove
+#define V8_ALLOW_ACCESS_TO_RAW_HANDLE_CONSTRUCTOR
+#define V8_ALLOW_ACCESS_TO_PERSISTENT_IMPLICIT
+#define V8_ALLOW_ACCESS_TO_PERSISTENT_ARROW
+
 #include "v8.h"
 
 #include "api.h"
 #include "isolate.h"
 #include "compilation-cache.h"
 #include "execution.h"
 #include "objects.h"
 #include "snapshot.h"
 #include "platform.h"
 #include "utils.h"
@@ skipping 109 matching lines @@
   const char* c_source = "1 + 2 + 3";
   Local<String> source = String::New(c_source);
   Local<Script> script = Script::Compile(source);
   CHECK_EQ(6, script->Run()->Int32Value());
 
   local_env->Exit();
 }
 
 
 THREADED_TEST(IsolateOfContext) {
-  v8::Persistent<Context> env = Context::New();
-  v8::HandleScope scope(env->GetIsolate());
+  v8::HandleScope scope(v8::Isolate::GetCurrent());
+  v8::Handle<Context> env = Context::New(v8::Isolate::GetCurrent());
 
   CHECK(!env->InContext());
   CHECK(env->GetIsolate() == v8::Isolate::GetCurrent());
   env->Enter();
   CHECK(env->InContext());
   CHECK(env->GetIsolate() == v8::Isolate::GetCurrent());
   env->Exit();
   CHECK(!env->InContext());
   CHECK(env->GetIsolate() == v8::Isolate::GetCurrent());
-
-  env.Dispose(env->GetIsolate());
 }
 
 
 THREADED_TEST(ReceiverSignature) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::Handle<v8::FunctionTemplate> fun = v8::FunctionTemplate::New();
   v8::Handle<v8::Signature> sig = v8::Signature::New(fun);
   fun->PrototypeTemplate()->Set(
       v8_str("m"),
@@ skipping 2285 matching lines @@
     g2s2 = Persistent<Object>::New(iso, Object::New());
     g2c1 = Persistent<Object>::New(iso, Object::New());
     g2s1.MakeWeak(iso, reinterpret_cast<void*>(&counter), &WeakPointerCallback);
     g2s2.MakeWeak(iso, reinterpret_cast<void*>(&counter), &WeakPointerCallback);
     g2c1.MakeWeak(iso, reinterpret_cast<void*>(&counter), &WeakPointerCallback);
   }
 
   Persistent<Object> root = Persistent<Object>::New(iso, g1s1);  // make a root.
 
   // Connect group 1 and 2, make a cycle.
-  CHECK(g1s2->Set(0, g2s2));
-  CHECK(g2s1->Set(0, g1s1));
+  CHECK(g1s2->Set(0, Handle<Object>(*g2s2)));
+  CHECK(g2s1->Set(0, Handle<Object>(*g1s1)));
 
   {
     Persistent<Value> g1_objects[] = { g1s1, g1s2 };
     Persistent<Value> g1_children[] = { g1c1 };
     Persistent<Value> g2_objects[] = { g2s1, g2s2 };
     Persistent<Value> g2_children[] = { g2c1 };
     V8::AddObjectGroup(g1_objects, 2);
     V8::AddImplicitReferences(g1s1, g1_children, 1);
     V8::AddObjectGroup(g2_objects, 2);
     V8::AddImplicitReferences(g2s2, g2_children, 1);
@@ skipping 190 matching lines @@
     g1s1.MarkPartiallyDependent(iso);
     g1s2.MarkPartiallyDependent(iso);
     g2s1.MarkPartiallyDependent(iso);
     g2s2.MarkPartiallyDependent(iso);
     g3s1.MarkPartiallyDependent(iso);
     g3s2.MarkPartiallyDependent(iso);
     Persistent<Value> g1_objects[] = { g1s1, g1s2 };
     Persistent<Value> g2_objects[] = { g2s1, g2s2 };
     Persistent<Value> g3_objects[] = { g3s1, g3s2 };
     V8::AddObjectGroup(g1_objects, 2);
-    g1s1->Set(v8_str("x"), g2s1);
+    g1s1->Set(v8_str("x"), Handle<Object>(*g2s1));
     V8::AddObjectGroup(g2_objects, 2);
-    g2s1->Set(v8_str("x"), g3s1);
+    g2s1->Set(v8_str("x"), Handle<Object>(*g3s1));
     V8::AddObjectGroup(g3_objects, 2);
-    g3s1->Set(v8_str("x"), g1s1);
+    g3s1->Set(v8_str("x"), Handle<Object>(*g1s1));
   }
 
   HEAP->CollectGarbage(i::NEW_SPACE);
 
   // All objects should be alive.
   CHECK_EQ(0, counter.NumberOfWeakCalls());
 
   // Weaken the root.
   root.MakeWeak(iso, reinterpret_cast<void*>(&counter), &WeakPointerCallback);
   root.MarkPartiallyDependent(iso);
 
   v8::Isolate* isolate = v8::Isolate::GetCurrent();
   // Groups are deleted, rebuild groups.
   {
     g1s1.MarkPartiallyDependent(isolate);
     g1s2.MarkPartiallyDependent(isolate);
     g2s1.MarkPartiallyDependent(isolate);
     g2s2.MarkPartiallyDependent(isolate);
     g3s1.MarkPartiallyDependent(isolate);
     g3s2.MarkPartiallyDependent(isolate);
     Persistent<Value> g1_objects[] = { g1s1, g1s2 };
     Persistent<Value> g2_objects[] = { g2s1, g2s2 };
     Persistent<Value> g3_objects[] = { g3s1, g3s2 };
     V8::AddObjectGroup(g1_objects, 2);
-    g1s1->Set(v8_str("x"), g2s1);
+    g1s1->Set(v8_str("x"), Handle<Object>(*g2s1));
     V8::AddObjectGroup(g2_objects, 2);
-    g2s1->Set(v8_str("x"), g3s1);
+    g2s1->Set(v8_str("x"), Handle<Object>(*g3s1));
     V8::AddObjectGroup(g3_objects, 2);
-    g3s1->Set(v8_str("x"), g1s1);
+    g3s1->Set(v8_str("x"), Handle<Object>(*g1s1));
   }
 
   HEAP->CollectGarbage(i::NEW_SPACE);
 
   // All objects should be gone. 7 global handles in total.
   CHECK_EQ(7, counter.NumberOfWeakCalls());
 }
 
 
 THREADED_TEST(ScriptException) {
@@ skipping 1433 matching lines @@
 THREADED_TEST(SimplePropertyWrite) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetAccessor(v8_str("x"), GetXValue, SetXValue, v8_str("donut"));
   LocalContext context;
   context->Global()->Set(v8_str("obj"), templ->NewInstance());
   Local<Script> script = Script::Compile(v8_str("obj.x = 4"));
   for (int i = 0; i < 10; i++) {
     CHECK(xValue.IsEmpty());
     script->Run();
-    CHECK_EQ(v8_num(4), xValue);
+    CHECK_EQ(v8_num(4), Handle<Value>(*xValue));
     xValue.Dispose(context->GetIsolate());
     xValue = v8::Persistent<Value>();
   }
 }
 
 
 THREADED_TEST(SetterOnly) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetAccessor(v8_str("x"), NULL, SetXValue, v8_str("donut"));
   LocalContext context;
   context->Global()->Set(v8_str("obj"), templ->NewInstance());
   Local<Script> script = Script::Compile(v8_str("obj.x = 4; obj.x"));
   for (int i = 0; i < 10; i++) {
     CHECK(xValue.IsEmpty());
     script->Run();
-    CHECK_EQ(v8_num(4), xValue);
+    CHECK_EQ(v8_num(4), Handle<Value>(*xValue));
     xValue.Dispose(context->GetIsolate());
     xValue = v8::Persistent<Value>();
   }
 }
 
 
 THREADED_TEST(NoAccessors) {
   v8::HandleScope scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> templ = ObjectTemplate::New();
   templ->SetAccessor(v8_str("x"), NULL, NULL, v8_str("donut"));
@@ skipping 870 matching lines @@
   return v8::Undefined();
 }
 
 
 THREADED_TEST(GlobalObjectTemplate) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   Local<ObjectTemplate> global_template = ObjectTemplate::New();
   global_template->Set(v8_str("JSNI_Log"),
                        v8::FunctionTemplate::New(HandleLogDelegator));
   v8::Persistent<Context> context = Context::New(0, global_template);
-  Context::Scope context_scope(context);
+  Context::Scope context_scope(v8::Isolate::GetCurrent(), context);
   Script::Compile(v8_str("JSNI_Log('LOG')"))->Run();
   context.Dispose(context->GetIsolate());
 }
 
 
 static const char* kSimpleExtensionSource =
   "function Foo() {"
   "  return 4;"
   "}";
 
 
 THREADED_TEST(SimpleExtensions) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   v8::RegisterExtension(new Extension("simpletest", kSimpleExtensionSource));
   const char* extension_names[] = { "simpletest" };
   v8::ExtensionConfiguration extensions(1, extension_names);
-  v8::Handle<Context> context = Context::New(&extensions);
+  v8::Handle<Context> context =
+      Context::New(v8::Isolate::GetCurrent(), &extensions);
   Context::Scope lock(context);
   v8::Handle<Value> result = Script::Compile(v8_str("Foo()"))->Run();
   CHECK_EQ(result, v8::Integer::New(4));
 }
 
 
 THREADED_TEST(NullExtensions) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   v8::RegisterExtension(new Extension("nulltest", NULL));
   const char* extension_names[] = { "nulltest" };
   v8::ExtensionConfiguration extensions(1, extension_names);
-  v8::Handle<Context> context = Context::New(&extensions);
+  v8::Handle<Context> context =
+      Context::New(v8::Isolate::GetCurrent(), &extensions);
   Context::Scope lock(context);
   v8::Handle<Value> result = Script::Compile(v8_str("1+3"))->Run();
   CHECK_EQ(result, v8::Integer::New(4));
 }
 
 
 static const char* kEmbeddedExtensionSource =
     "function Ret54321(){return 54321;}~~@@$"
     "$%% THIS IS A SERIES OF NON-NULL-TERMINATED STRINGS.";
 static const int kEmbeddedExtensionSourceValidLen = 34;
 
 
 THREADED_TEST(ExtensionMissingSourceLength) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   v8::RegisterExtension(new Extension("srclentest_fail",
                                       kEmbeddedExtensionSource));
   const char* extension_names[] = { "srclentest_fail" };
   v8::ExtensionConfiguration extensions(1, extension_names);
-  v8::Handle<Context> context = Context::New(&extensions);
+  v8::Handle<Context> context =
+      Context::New(v8::Isolate::GetCurrent(), &extensions);
   CHECK_EQ(0, *context);
 }
 
 
 THREADED_TEST(ExtensionWithSourceLength) {
   for (int source_len = kEmbeddedExtensionSourceValidLen - 1;
        source_len <= kEmbeddedExtensionSourceValidLen + 1; ++source_len) {
     v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
     i::ScopedVector<char> extension_name(32);
     i::OS::SNPrintF(extension_name, "ext #%d", source_len);
     v8::RegisterExtension(new Extension(extension_name.start(),
                                         kEmbeddedExtensionSource, 0, 0,
                                         source_len));
     const char* extension_names[1] = { extension_name.start() };
     v8::ExtensionConfiguration extensions(1, extension_names);
-    v8::Handle<Context> context = Context::New(&extensions);
+    v8::Handle<Context> context =
+      Context::New(v8::Isolate::GetCurrent(), &extensions);
     if (source_len == kEmbeddedExtensionSourceValidLen) {
       Context::Scope lock(context);
       v8::Handle<Value> result = Script::Compile(v8_str("Ret54321()"))->Run();
       CHECK_EQ(v8::Integer::New(54321), result);
     } else {
       // Anything but exactly the right length should fail to compile.
       CHECK_EQ(0, *context);
     }
   }
 }
@@ skipping 15 matching lines @@
   "  this.UseEval2 = e;"
   "})()";
 
 
 THREADED_TEST(UseEvalFromExtension) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   v8::RegisterExtension(new Extension("evaltest1", kEvalExtensionSource1));
   v8::RegisterExtension(new Extension("evaltest2", kEvalExtensionSource2));
   const char* extension_names[] = { "evaltest1", "evaltest2" };
   v8::ExtensionConfiguration extensions(2, extension_names);
-  v8::Handle<Context> context = Context::New(&extensions);
+  v8::Handle<Context> context =
+      Context::New(v8::Isolate::GetCurrent(), &extensions);
   Context::Scope lock(context);
   v8::Handle<Value> result = Script::Compile(v8_str("UseEval1()"))->Run();
   CHECK_EQ(result, v8::Integer::New(42));
   result = Script::Compile(v8_str("UseEval2()"))->Run();
   CHECK_EQ(result, v8::Integer::New(42));
 }
 
 
 static const char* kWithExtensionSource1 =
   "function UseWith1() {"
@@ skipping 12 matching lines @@
   "  this.UseWith2 = e;"
   "})()";
 
 
 THREADED_TEST(UseWithFromExtension) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   v8::RegisterExtension(new Extension("withtest1", kWithExtensionSource1));
   v8::RegisterExtension(new Extension("withtest2", kWithExtensionSource2));
   const char* extension_names[] = { "withtest1", "withtest2" };
   v8::ExtensionConfiguration extensions(2, extension_names);
-  v8::Handle<Context> context = Context::New(&extensions);
+  v8::Handle<Context> context =
+      Context::New(v8::Isolate::GetCurrent(), &extensions);
   Context::Scope lock(context);
   v8::Handle<Value> result = Script::Compile(v8_str("UseWith1()"))->Run();
   CHECK_EQ(result, v8::Integer::New(87));
   result = Script::Compile(v8_str("UseWith2()"))->Run();
   CHECK_EQ(result, v8::Integer::New(87));
 }
 
 
 THREADED_TEST(AutoExtensions) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   Extension* extension = new Extension("autotest", kSimpleExtensionSource);
   extension->set_auto_enable(true);
   v8::RegisterExtension(extension);
-  v8::Handle<Context> context = Context::New();
+  v8::Handle<Context> context =
+      Context::New(v8::Isolate::GetCurrent());
   Context::Scope lock(context);
   v8::Handle<Value> result = Script::Compile(v8_str("Foo()"))->Run();
   CHECK_EQ(result, v8::Integer::New(4));
 }
 
 
 static const char* kSyntaxErrorInExtensionSource =
     "[";
 
 
 // Test that a syntax error in an extension does not cause a fatal
 // error but results in an empty context.
 THREADED_TEST(SyntaxErrorExtensions) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   v8::RegisterExtension(new Extension("syntaxerror",
                                       kSyntaxErrorInExtensionSource));
   const char* extension_names[] = { "syntaxerror" };
   v8::ExtensionConfiguration extensions(1, extension_names);
-  v8::Handle<Context> context = Context::New(&extensions);
+  v8::Handle<Context> context =
+      Context::New(v8::Isolate::GetCurrent(), &extensions);
   CHECK(context.IsEmpty());
 }
 
 
 static const char* kExceptionInExtensionSource =
     "throw 42";
 
 
 // Test that an exception when installing an extension does not cause
 // a fatal error but results in an empty context.
 THREADED_TEST(ExceptionExtensions) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   v8::RegisterExtension(new Extension("exception",
                                       kExceptionInExtensionSource));
   const char* extension_names[] = { "exception" };
   v8::ExtensionConfiguration extensions(1, extension_names);
-  v8::Handle<Context> context = Context::New(&extensions);
+  v8::Handle<Context> context =
+      Context::New(v8::Isolate::GetCurrent(), &extensions);
   CHECK(context.IsEmpty());
 }
 
 
 static const char* kNativeCallInExtensionSource =
     "function call_runtime_last_index_of(x) {"
     "  return %StringLastIndexOf(x, 'bob', 10);"
     "}";
 
 
 static const char* kNativeCallTest =
     "call_runtime_last_index_of('bobbobboellebobboellebobbob');";
 
 // Test that a native runtime calls are supported in extensions.
 THREADED_TEST(NativeCallInExtensions) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   v8::RegisterExtension(new Extension("nativecall",
                                       kNativeCallInExtensionSource));
   const char* extension_names[] = { "nativecall" };
   v8::ExtensionConfiguration extensions(1, extension_names);
-  v8::Handle<Context> context = Context::New(&extensions);
+  v8::Handle<Context> context =
+      Context::New(v8::Isolate::GetCurrent(), &extensions);
   Context::Scope lock(context);
   v8::Handle<Value> result = Script::Compile(v8_str(kNativeCallTest))->Run();
   CHECK_EQ(result, v8::Integer::New(3));
 }
 
 
 class NativeFunctionExtension : public Extension {
  public:
   NativeFunctionExtension(const char* name,
                           const char* source,
@@ skipping 15 matching lines @@
 };
 
 
 THREADED_TEST(NativeFunctionDeclaration) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   const char* name = "nativedecl";
   v8::RegisterExtension(new NativeFunctionExtension(name,
                                                     "native function foo();"));
   const char* extension_names[] = { name };
   v8::ExtensionConfiguration extensions(1, extension_names);
-  v8::Handle<Context> context = Context::New(&extensions);
+  v8::Handle<Context> context =
+      Context::New(v8::Isolate::GetCurrent(), &extensions);
   Context::Scope lock(context);
   v8::Handle<Value> result = Script::Compile(v8_str("foo(42);"))->Run();
   CHECK_EQ(result, v8::Integer::New(42));
 }
 
 
 THREADED_TEST(NativeFunctionDeclarationError) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   const char* name = "nativedeclerr";
   // Syntax error in extension code.
   v8::RegisterExtension(new NativeFunctionExtension(name,
                                                     "native\nfunction foo();"));
   const char* extension_names[] = { name };
   v8::ExtensionConfiguration extensions(1, extension_names);
-  v8::Handle<Context> context(Context::New(&extensions));
+  v8::Handle<Context> context =
+      Context::New(v8::Isolate::GetCurrent(), &extensions);
   CHECK(context.IsEmpty());
 }
 
 
 THREADED_TEST(NativeFunctionDeclarationErrorEscape) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   const char* name = "nativedeclerresc";
   // Syntax error in extension code - escape code in "native" means that
   // it's not treated as a keyword.
   v8::RegisterExtension(new NativeFunctionExtension(
       name,
       "nativ\\u0065 function foo();"));
   const char* extension_names[] = { name };
   v8::ExtensionConfiguration extensions(1, extension_names);
-  v8::Handle<Context> context(Context::New(&extensions));
+  v8::Handle<Context> context =
+      Context::New(v8::Isolate::GetCurrent(), &extensions);
   CHECK(context.IsEmpty());
 }
 
 
 static void CheckDependencies(const char* name, const char* expected) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   v8::ExtensionConfiguration config(1, &name);
   LocalContext context(&config);
   CHECK_EQ(String::New(expected), context->Global()->Get(v8_str("loaded")));
 }
@@ skipping 119 matching lines @@
 // tests that the fatal error handler gets called.  This renders V8
 // unusable and therefore this test cannot be run in parallel.
 TEST(ErrorReporting) {
   v8::V8::SetFatalErrorHandler(StoringErrorCallback);
   static const char* aDeps[] = { "B" };
   v8::RegisterExtension(new Extension("A", "", 1, aDeps));
   static const char* bDeps[] = { "A" };
   v8::RegisterExtension(new Extension("B", "", 1, bDeps));
   last_location = NULL;
   v8::ExtensionConfiguration config(1, bDeps);
-  v8::Handle<Context> context = Context::New(&config);
+  v8::Handle<Context> context =
+      Context::New(v8::Isolate::GetCurrent(), &config);
   CHECK(context.IsEmpty());
   CHECK_NE(last_location, NULL);
 }
 
 
 static const char* js_code_causing_huge_string_flattening =
     "var str = 'X';"
     "for (var i = 0; i < 30; i++) {"
     "  str = str + str;"
     "}"
@@ skipping 95 matching lines @@
 
 THREADED_TEST(WeakReference) {
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> templ= v8::ObjectTemplate::New();
   Whammy* whammy = new Whammy(v8::Isolate::GetCurrent());
   templ->SetNamedPropertyHandler(WhammyPropertyGetter,
                                  0, 0, 0, 0,
                                  v8::External::New(whammy));
   const char* extension_list[] = { "v8/gc" };
   v8::ExtensionConfiguration extensions(1, extension_list);
-  v8::Persistent<Context> context = Context::New(&extensions);
+  v8::Handle<Context> context =
+      Context::New(v8::Isolate::GetCurrent(), &extensions);
   Context::Scope context_scope(context);
 
   v8::Handle<v8::Object> interceptor = templ->NewInstance();
   context->Global()->Set(v8_str("whammy"), interceptor);
   const char* code =
       "var last;"
       "for (var i = 0; i < 10000; i++) {"
       "  var obj = whammy.length;"
       "  if (last) last.next = obj;"
       "  last = obj;"
       "}"
       "gc();"
       "4";
   v8::Handle<Value> result = CompileRun(code);
   CHECK_EQ(4.0, result->NumberValue());
   delete whammy;
-  context.Dispose(context->GetIsolate());
 }
 
 
 static void DisposeAndSetFlag(v8::Isolate* isolate,
                               v8::Persistent<v8::Value> obj,
                               void* data) {
   obj.Dispose(isolate);
   obj.Clear();
   *(reinterpret_cast<bool*>(data)) = true;
 }
 
 
 THREADED_TEST(IndependentWeakHandle) {
-  v8::Persistent<Context> context = Context::New();
-  v8::Isolate* iso = context->GetIsolate();
+  v8::Isolate* iso = v8::Isolate::GetCurrent();
+  v8::HandleScope scope(iso);
+  v8::Handle<Context> context = Context::New(iso);
   Context::Scope context_scope(context);
 
   v8::Persistent<v8::Object> object_a, object_b;
 
   {
     v8::HandleScope handle_scope(iso);
     object_a = v8::Persistent<v8::Object>::New(iso, v8::Object::New());
     object_b = v8::Persistent<v8::Object>::New(iso, v8::Object::New());
   }
 
@@ skipping 35 matching lines @@
                            v8::Persistent<v8::Value> obj,
                            void* data) {
   obj.Dispose(isolate);
   obj.Clear();
   *(reinterpret_cast<bool*>(data)) = true;
   InvokeMarkSweep();
 }
 
 
 THREADED_TEST(GCFromWeakCallbacks) {
-  v8::Persistent<Context> context = Context::New();
-  v8::Isolate* isolate = context->GetIsolate();
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::HandleScope scope(isolate);
+  v8::Handle<Context> context = Context::New(isolate);
   Context::Scope context_scope(context);
 
   static const int kNumberOfGCTypes = 2;
   v8::NearDeathCallback gc_forcing_callback[kNumberOfGCTypes] =
       {&ForceScavenge, &ForceMarkSweep};
 
   typedef void (*GCInvoker)();
   GCInvoker invoke_gc[kNumberOfGCTypes] = {&InvokeScavenge, &InvokeMarkSweep};
 
   for (int outer_gc = 0; outer_gc < kNumberOfGCTypes; outer_gc++) {
@@ skipping 15 matching lines @@
 
 static void RevivingCallback(v8::Isolate* isolate,
                              v8::Persistent<v8::Value> obj,
                              void* data) {
   obj.ClearWeak(isolate);
   *(reinterpret_cast<bool*>(data)) = true;
 }
 
 
 THREADED_TEST(IndependentHandleRevival) {
-  v8::Persistent<Context> context = Context::New();
+  v8::Isolate* isolate = v8::Isolate::GetCurrent();
+  v8::HandleScope scope(isolate);
+  v8::Handle<Context> context = Context::New(isolate);
   Context::Scope context_scope(context);
-  v8::Isolate* isolate = context->GetIsolate();
 
   v8::Persistent<v8::Object> object;
   {
     v8::HandleScope handle_scope(isolate);
     object = v8::Persistent<v8::Object>::New(isolate, v8::Object::New());
     object->Set(v8_str("x"), v8::Integer::New(1));
     v8::Local<String> y_str = v8_str("y");
     object->Set(y_str, y_str);
   }
   bool revived = false;
@@ skipping 1034 matching lines @@
 }
 
 
 // SecurityHandler can't be run twice
 TEST(SecurityHandler) {
   v8::HandleScope scope0(v8::Isolate::GetCurrent());
   v8::Handle<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();
   global_template->SetAccessCheckCallbacks(NamedSecurityTestCallback,
                                            IndexedSecurityTestCallback);
   // Create an environment
-  v8::Persistent<Context> context0 =
-    Context::New(NULL, global_template);
+  v8::Handle<Context> context0 =
+    Context::New(v8::Isolate::GetCurrent(), NULL, global_template);
   context0->Enter();
 
   v8::Handle<v8::Object> global0 = context0->Global();
   v8::Handle<Script> script0 = v8_compile("foo = 111");
   script0->Run();
   global0->Set(v8_str("0"), v8_num(999));
   v8::Handle<Value> foo0 = global0->Get(v8_str("foo"));
   CHECK_EQ(111, foo0->Int32Value());
   v8::Handle<Value> z0 = global0->Get(v8_str("0"));
   CHECK_EQ(999, z0->Int32Value());
 
   // Create another environment, should fail security checks.
   v8::HandleScope scope1(v8::Isolate::GetCurrent());
 
-  v8::Persistent<Context> context1 =
-    Context::New(NULL, global_template);
+  v8::Handle<Context> context1 =
+    Context::New(v8::Isolate::GetCurrent(), NULL, global_template);
   context1->Enter();
 
   v8::Handle<v8::Object> global1 = context1->Global();
   global1->Set(v8_str("othercontext"), global0);
   // This set will fail the security check.
   v8::Handle<Script> script1 =
     v8_compile("othercontext.foo = 222; othercontext[0] = 888;");
   script1->Run();
   // This read will pass the security check.
   v8::Handle<Value> foo1 = global0->Get(v8_str("foo"));
@@ skipping 11 matching lines @@
     v8::Handle<Script> script2 =
         v8_compile("othercontext.foo = 333; othercontext[0] = 888;");
     script2->Run();
     v8::Handle<Value> foo2 = global0->Get(v8_str("foo"));
     CHECK_EQ(333, foo2->Int32Value());
     v8::Handle<Value> z2 = global0->Get(v8_str("0"));
     CHECK_EQ(888, z2->Int32Value());
   }
 
   context1->Exit();
-  context1.Dispose(context1->GetIsolate());
-
   context0->Exit();
-  context0.Dispose(context0->GetIsolate());
 }
 
 
 THREADED_TEST(SecurityChecks) {
   LocalContext env1;
   v8::HandleScope handle_scope(env1->GetIsolate());
-  v8::Persistent<Context> env2 = Context::New();
+  v8::Handle<Context> env2 = Context::New(env1->GetIsolate());
 
   Local<Value> foo = v8_str("foo");
   Local<Value> bar = v8_str("bar");
 
   // Set to the same domain.
   env1->SetSecurityToken(foo);
 
   // Create a function in env1.
   Script::Compile(v8_str("spy=function(){return spy;}"))->Run();
   Local<Value> spy = env1->Global()->Get(v8_str("spy"));
@@ skipping 15 matching lines @@
 
   {
     env2->SetSecurityToken(bar);
     Context::Scope scope_env2(env2);
 
     // Call cross_domain_call, it should throw an exception
     v8::TryCatch try_catch;
     Function::Cast(*spy2)->Call(env2->Global(), 0, NULL);
     CHECK(try_catch.HasCaught());
   }
-
-  env2.Dispose(env2->GetIsolate());
 }
 
 
 // Regression test case for issue 1183439.
 THREADED_TEST(SecurityChecksForPrototypeChain) {
   LocalContext current;
   v8::HandleScope scope(current->GetIsolate());
-  v8::Persistent<Context> other = Context::New();
+  v8::Handle<Context> other = Context::New(current->GetIsolate());
 
   // Change context to be able to get to the Object function in the
   // other context without hitting the security checks.
   v8::Local<Value> other_object;
   { Context::Scope scope(other);
     other_object = other->Global()->Get(v8_str("Object"));
     other->Global()->Set(v8_num(42), v8_num(87));
   }
 
   current->Global()->Set(v8_str("other"), other->Global());
@@ skipping 40 matching lines @@
   // Try to read the properties from f and make sure that the access
   // gets stopped by the security checks on the other global object.
   Local<Script> access_f2 = v8_compile("f.foo");
   Local<Script> access_f3 = v8_compile("f[99]");
   for (int k = 0; k < 5; k++) {
     CHECK(!access_f2->Run()->Equals(v8_num(100)));
     CHECK(access_f2->Run()->IsUndefined());
     CHECK(!access_f3->Run()->Equals(v8_num(101)));
     CHECK(access_f3->Run()->IsUndefined());
   }
-  other.Dispose(other->GetIsolate());
 }
 
 
 THREADED_TEST(CrossDomainDelete) {
   LocalContext env1;
   v8::HandleScope handle_scope(env1->GetIsolate());
-  v8::Persistent<Context> env2 = Context::New();
+  v8::Handle<Context> env2 = Context::New(env1->GetIsolate());
 
   Local<Value> foo = v8_str("foo");
   Local<Value> bar = v8_str("bar");
 
   // Set to the same domain.
   env1->SetSecurityToken(foo);
   env2->SetSecurityToken(foo);
 
   env1->Global()->Set(v8_str("prop"), v8_num(3));
   env2->Global()->Set(v8_str("env1"), env1->Global());
 
   // Change env2 to a different domain and delete env1.prop.
   env2->SetSecurityToken(bar);
   {
     Context::Scope scope_env2(env2);
     Local<Value> result =
         Script::Compile(v8_str("delete env1.prop"))->Run();
     CHECK(result->IsFalse());
   }
 
   // Check that env1.prop still exists.
   Local<Value> v = env1->Global()->Get(v8_str("prop"));
   CHECK(v->IsNumber());
   CHECK_EQ(3, v->Int32Value());
-
-  env2.Dispose(env2->GetIsolate());
 }
 
 
 THREADED_TEST(CrossDomainIsPropertyEnumerable) {
   LocalContext env1;
   v8::HandleScope handle_scope(env1->GetIsolate());
-  v8::Persistent<Context> env2 = Context::New();
+  v8::Handle<Context> env2 = Context::New(env1->GetIsolate());
 
   Local<Value> foo = v8_str("foo");
   Local<Value> bar = v8_str("bar");
 
   // Set to the same domain.
   env1->SetSecurityToken(foo);
   env2->SetSecurityToken(foo);
 
   env1->Global()->Set(v8_str("prop"), v8_num(3));
   env2->Global()->Set(v8_str("env1"), env1->Global());
 
   // env1.prop is enumerable in env2.
   Local<String> test = v8_str("propertyIsEnumerable.call(env1, 'prop')");
   {
     Context::Scope scope_env2(env2);
     Local<Value> result = Script::Compile(test)->Run();
     CHECK(result->IsTrue());
   }
 
   // Change env2 to a different domain and test again.
   env2->SetSecurityToken(bar);
   {
     Context::Scope scope_env2(env2);
     Local<Value> result = Script::Compile(test)->Run();
     CHECK(result->IsFalse());
   }
-
-  env2.Dispose(env2->GetIsolate());
 }
 
 
 THREADED_TEST(CrossDomainForIn) {
   LocalContext env1;
   v8::HandleScope handle_scope(env1->GetIsolate());
-  v8::Persistent<Context> env2 = Context::New();
+  v8::Handle<Context> env2 = Context::New(env1->GetIsolate());
 
   Local<Value> foo = v8_str("foo");
   Local<Value> bar = v8_str("bar");
 
   // Set to the same domain.
   env1->SetSecurityToken(foo);
   env2->SetSecurityToken(foo);
 
   env1->Global()->Set(v8_str("prop"), v8_num(3));
   env2->Global()->Set(v8_str("env1"), env1->Global());
 
   // Change env2 to a different domain and set env1's global object
   // as the __proto__ of an object in env2 and enumerate properties
   // in for-in. It shouldn't enumerate properties on env1's global
   // object.
   env2->SetSecurityToken(bar);
   {
     Context::Scope scope_env2(env2);
     Local<Value> result =
         CompileRun("(function(){var obj = {'__proto__':env1};"
                    "for (var p in obj)"
                    "   if (p == 'prop') return false;"
                    "return true;})()");
     CHECK(result->IsTrue());
   }
-  env2.Dispose(env2->GetIsolate());
 }
 
 
 TEST(ContextDetachGlobal) {
   LocalContext env1;
   v8::HandleScope handle_scope(env1->GetIsolate());
-  v8::Persistent<Context> env2 = Context::New();
+  v8::Handle<Context> env2 = Context::New(env1->GetIsolate());
 
   Local<v8::Object> global1 = env1->Global();
 
   Local<Value> foo = v8_str("foo");
 
   // Set to the same domain.
   env1->SetSecurityToken(foo);
   env2->SetSecurityToken(foo);
 
   // Enter env2
   env2->Enter();
 
   // Create a function in env2 and add a reference to it in env1.
   Local<v8::Object> global2 = env2->Global();
   global2->Set(v8_str("prop"), v8::Integer::New(1));
   CompileRun("function getProp() {return prop;}");
 
   env1->Global()->Set(v8_str("getProp"),
                       global2->Get(v8_str("getProp")));
 
   // Detach env2's global, and reuse the global object of env2
   env2->Exit();
   env2->DetachGlobal();
   // env2 has a new global object.
   CHECK(!env2->Global()->Equals(global2));
 
-  v8::Persistent<Context> env3 =
-      Context::New(0, v8::Handle<v8::ObjectTemplate>(), global2);
+  v8::Handle<Context> env3 = Context::New(env1->GetIsolate(),
+                                          0,
+                                          v8::Handle<v8::ObjectTemplate>(),
+                                          global2);
   env3->SetSecurityToken(v8_str("bar"));
   env3->Enter();
 
   Local<v8::Object> global3 = env3->Global();
   CHECK_EQ(global2, global3);
   CHECK(global3->Get(v8_str("prop"))->IsUndefined());
   CHECK(global3->Get(v8_str("getProp"))->IsUndefined());
   global3->Set(v8_str("prop"), v8::Integer::New(-1));
   global3->Set(v8_str("prop2"), v8::Integer::New(2));
   env3->Exit();
 
   // Call getProp in env1, and it should return the value 1
   {
     Local<Value> get_prop = global1->Get(v8_str("getProp"));
     CHECK(get_prop->IsFunction());
     v8::TryCatch try_catch;
     Local<Value> r = Function::Cast(*get_prop)->Call(global1, 0, NULL);
     CHECK(!try_catch.HasCaught());
     CHECK_EQ(1, r->Int32Value());
   }
 
   // Check that env3 is not accessible from env1
   {
     Local<Value> r = global3->Get(v8_str("prop2"));
     CHECK(r->IsUndefined());
   }
-
-  env2.Dispose(env2->GetIsolate());
-  env3.Dispose(env3->GetIsolate());
 }
 
 
 TEST(DetachAndReattachGlobal) {
   LocalContext env1;
   v8::HandleScope scope(env1->GetIsolate());
 
   // Create second environment.
-  v8::Persistent<Context> env2 = Context::New();
+  v8::Handle<Context> env2 = Context::New(env1->GetIsolate());
 
   Local<Value> foo = v8_str("foo");
 
   // Set same security token for env1 and env2.
   env1->SetSecurityToken(foo);
   env2->SetSecurityToken(foo);
 
   // Create a property on the global object in env2.
   {
     v8::Context::Scope scope(env2);
@@ skipping 11 matching lines @@
   // Hold on to global from env2 and detach global from env2.
   Local<v8::Object> global2 = env2->Global();
   env2->DetachGlobal();
 
   // Check that the global has been detached. No other.p property can
   // be found.
   result = CompileRun("other.p");
   CHECK(result->IsUndefined());
 
   // Reuse global2 for env3.
-  v8::Persistent<Context> env3 =
-      Context::New(0, v8::Handle<v8::ObjectTemplate>(), global2);
+  v8::Handle<Context> env3 = Context::New(env1->GetIsolate(),
+                                          0,
+                                          v8::Handle<v8::ObjectTemplate>(),
+                                          global2);
   CHECK_EQ(global2, env3->Global());
 
   // Start by using the same security token for env3 as for env1 and env2.
   env3->SetSecurityToken(foo);
 
   // Create a property on the global object in env3.
   {
     v8::Context::Scope scope(env3);
     env3->Global()->Set(v8_str("p"), v8::Integer::New(24));
   }
@@ skipping 14 matching lines @@
 
   // Detach the global for env3 and reattach it to env2.
   env3->DetachGlobal();
   env2->ReattachGlobal(global2);
 
   // Check that we have access to other.p again in env1.  |other| is now
   // the global object for env2 which has the same security token as env1.
   result = CompileRun("other.p");
   CHECK(result->IsInt32());
   CHECK_EQ(42, result->Int32Value());
-
-  env2.Dispose(env2->GetIsolate());
-  env3.Dispose(env3->GetIsolate());
 }
 
 
 static bool allowed_access_type[v8::ACCESS_KEYS + 1] = { false };
 static bool NamedAccessBlocker(Local<v8::Object> global,
                                Local<Value> name,
                                v8::AccessType type,
                                Local<Value> data) {
   return Context::GetCurrent()->Global()->Equals(global) ||
       allowed_access_type[type];
@@ skipping 2048 matching lines @@
 
 
 // Below go several tests which verify that JITing for various
 // configurations of interceptor and explicit fields works fine
 // (those cases are special cased to get better performance).
 
 static v8::Handle<Value> InterceptorLoadXICGetter(Local<String> name,
                                                  const AccessorInfo& info) {
   ApiTestFuzzer::Fuzz();
   return v8_str("x")->Equals(name)
-      ? v8::Integer::New(42) : v8::Handle<v8::Value>();
+      ? v8::Handle<v8::Value>(v8::Integer::New(42)) : v8::Handle<v8::Value>();
 }
 
 
 THREADED_TEST(InterceptorLoadICWithFieldOnHolder) {
   CheckInterceptorLoadIC(InterceptorLoadXICGetter,
     "var result = 0;"
     "o.y = 239;"
     "for (var i = 0; i < 1000; i++) {"
     "  result = o.y;"
     "}",
@@ skipping 2996 matching lines @@
   v8::HandleScope handle_scope(v8::Isolate::GetCurrent());
 
   // Create an environment with access check to the global object disabled by
   // default.
   v8::Handle<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();
   global_template->SetAccessCheckCallbacks(NamedGetAccessBlocker,
                                            IndexedGetAccessBlocker,
                                            v8::Handle<v8::Value>(),
                                            false);
   v8::Persistent<Context> context = Context::New(NULL, global_template);
-  Context::Scope context_scope(context);
+  Context::Scope context_scope(v8::Isolate::GetCurrent(), context);
 
   // Set up a property and a number of functions.
   context->Global()->Set(v8_str("a"), v8_num(1));
   CompileRun("function f1() {return a;}"
              "function f2() {return a;}"
              "function g1() {return h();}"
              "function g2() {return h();}"
              "function h() {return 1;}");
   Local<Function> f1 =
       Local<Function>::Cast(context->Global()->Get(v8_str("f1")));
@@ skipping 60 matching lines @@
 
   // Create an environment with access check to the global object disabled by
   // default. When the registered access checker will block access to properties
   // a and h.
   v8::Handle<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New();
   global_template->SetAccessCheckCallbacks(NamedGetAccessBlockAandH,
                                            IndexedGetAccessBlocker,
                                            v8::Handle<v8::Value>(),
                                            false);
   v8::Persistent<Context> context = Context::New(NULL, global_template);
-  Context::Scope context_scope(context);
+  Context::Scope context_scope(v8::Isolate::GetCurrent(), context);
 
   // Set up a property and a number of functions.
   context->Global()->Set(v8_str("a"), v8_num(1));
   static const char* source = "function f1() {return a;}"
                               "function f2() {return a;}"
                               "function g1() {return h();}"
                               "function g2() {return h();}"
                               "function h() {return 1;}";
 
   CompileRun(source);
@@ skipping 3998 matching lines @@
   CHECK_NE(last_message, NULL);
 }
 
 TEST(RunTwoIsolatesOnSingleThread) {
   // Run isolate 1.
   v8::Isolate* isolate1 = v8::Isolate::New();
   isolate1->Enter();
   v8::Persistent<v8::Context> context1 = v8::Context::New();
 
   {
-    v8::Context::Scope cscope(context1);
     v8::HandleScope scope(isolate1);
+    v8::Context::Scope cscope(isolate1, context1);
     // Run something in new isolate.
     CompileRun("var foo = 'isolate 1';");
     ExpectString("function f() { return foo; }; f()", "isolate 1");
   }
 
   // Run isolate 2.
   v8::Isolate* isolate2 = v8::Isolate::New();
   v8::Persistent<v8::Context> context2;
 
   {
     v8::Isolate::Scope iscope(isolate2);
     context2 = v8::Context::New();
-    v8::Context::Scope cscope(context2);
     v8::HandleScope scope(isolate2);
+    v8::Context::Scope cscope(isolate2, context2);
 
     // Run something in new isolate.
     CompileRun("var foo = 'isolate 2';");
     ExpectString("function f() { return foo; }; f()", "isolate 2");
   }
 
   {
-    v8::Context::Scope cscope(context1);
     v8::HandleScope scope(isolate1);
+    v8::Context::Scope cscope(isolate1, context1);
     // Now again in isolate 1
     ExpectString("function f() { return foo; }; f()", "isolate 1");
   }
 
   isolate1->Exit();
 
   // Run some stuff in default isolate.
   v8::Persistent<v8::Context> context_default = v8::Context::New();
 
   {
-    v8::Context::Scope cscope(context_default);
     v8::HandleScope scope(v8::Isolate::GetCurrent());
+    v8::Context::Scope cscope(v8::Isolate::GetCurrent(), context_default);
     // Variables in other isolates should be not available, verify there
     // is an exception.
     ExpectTrue("function f() {"
                "  try {"
                "    foo;"
                "    return false;"
                "  } catch(e) {"
                "    return true;"
                "  }"
                "};"
                "var isDefaultIsolate = true;"
                "f()");
   }
 
   isolate1->Enter();
 
   {
     v8::Isolate::Scope iscope(isolate2);
-    v8::Context::Scope cscope(context2);
     v8::HandleScope scope(v8::Isolate::GetCurrent());
+    v8::Context::Scope cscope(isolate2, context2);
     ExpectString("function f() { return foo; }; f()", "isolate 2");
   }
 
   {
-    v8::Context::Scope cscope(context1);
     v8::HandleScope scope(v8::Isolate::GetCurrent());
+    v8::Context::Scope cscope(v8::Isolate::GetCurrent(), context1);
     ExpectString("function f() { return foo; }; f()", "isolate 1");
   }
 
   {
     v8::Isolate::Scope iscope(isolate2);
     context2.Dispose(context2->GetIsolate());
   }
 
   context1.Dispose(context1->GetIsolate());
   isolate1->Exit();
 
   v8::V8::SetFatalErrorHandler(StoringErrorCallback);
   last_location = last_message = NULL;
 
   isolate1->Dispose();
   CHECK_EQ(last_location, NULL);
   CHECK_EQ(last_message, NULL);
 
   isolate2->Dispose();
   CHECK_EQ(last_location, NULL);
   CHECK_EQ(last_message, NULL);
 
   // Check that default isolate still runs.
   {
-    v8::Context::Scope cscope(context_default);
     v8::HandleScope scope(v8::Isolate::GetCurrent());
+    v8::Context::Scope cscope(v8::Isolate::GetCurrent(), context_default);
     ExpectTrue("function f() { return isDefaultIsolate; }; f()");
   }
 }
 
 static int CalcFibonacci(v8::Isolate* isolate, int limit) {
   v8::Isolate::Scope isolate_scope(isolate);
   v8::HandleScope scope(isolate);
   LocalContext context;
   i::ScopedVector<char> code(1024);
   i::OS::SNPrintF(code, "function fib(n) {"
@@ skipping 54 matching lines @@
   isolate2->Dispose();
 }
 
 TEST(IsolateDifferentContexts) {
   v8::Isolate* isolate = v8::Isolate::New();
   Persistent<v8::Context> context;
   {
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
     context = v8::Context::New();
-    v8::Context::Scope context_scope(context);
+    v8::Context::Scope context_scope(isolate, context);
     Local<Value> v = CompileRun("2");
     CHECK(v->IsNumber());
     CHECK_EQ(2, static_cast<int>(v->NumberValue()));
   }
   {
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
     context = v8::Context::New();
-    v8::Context::Scope context_scope(context);
+    v8::Context::Scope context_scope(isolate, context);
     Local<Value> v = CompileRun("22");
     CHECK(v->IsNumber());
     CHECK_EQ(22, static_cast<int>(v->NumberValue()));
   }
   isolate->Dispose();
 }
 
 class InitDefaultIsolateThread : public v8::internal::Thread {
  public:
   enum TestCase {
@@ skipping 254 matching lines @@
   explicit Visitor42(v8::Persistent<v8::Object> object)
       : counter_(0), object_(object) { }
 
   virtual void VisitPersistentHandle(Persistent<Value> value,
                                      uint16_t class_id) {
     if (class_id == 42) {
       CHECK(value->IsObject());
       v8::Persistent<v8::Object> visited =
           v8::Persistent<v8::Object>::Cast(value);
       CHECK_EQ(42, visited.WrapperClassId(v8::Isolate::GetCurrent()));
-      CHECK_EQ(object_, visited);
+      CHECK_EQ(Handle<Value>(*object_), Handle<Value>(*visited));
       ++counter_;
     }
   }
 
   int counter_;
   v8::Persistent<v8::Object> object_;
 };
 
 
 TEST(PersistentHandleVisitor) {
@@ skipping 194 matching lines @@
 }
 
 
 static void CheckContextId(v8::Handle<Object> object, int expected) {
   CHECK_EQ(expected, object->Get(v8_str("context_id"))->Int32Value());
 }
 
 
 THREADED_TEST(CreationContext) {
   HandleScope handle_scope(v8::Isolate::GetCurrent());
-  Persistent<Context> context1 = Context::New();
+  Handle<Context> context1 = Context::New(v8::Isolate::GetCurrent());
   InstallContextId(context1, 1);
-  Persistent<Context> context2 = Context::New();
+  Handle<Context> context2 = Context::New(v8::Isolate::GetCurrent());
   InstallContextId(context2, 2);
-  Persistent<Context> context3 = Context::New();
+  Handle<Context> context3 = Context::New(v8::Isolate::GetCurrent());
   InstallContextId(context3, 3);
 
   Local<v8::FunctionTemplate> tmpl = v8::FunctionTemplate::New();
 
   Local<Object> object1;
   Local<Function> func1;
   {
     Context::Scope scope(context1);
     object1 = Object::New();
     func1 = tmpl->GetFunction();
@@ skipping 53 matching lines @@
     CheckContextId(func1, 1);
     CHECK(instance1->CreationContext() == context1);
     CheckContextId(instance1, 1);
     CHECK(object2->CreationContext() == context2);
     CheckContextId(object2, 2);
     CHECK(func2->CreationContext() == context2);
     CheckContextId(func2, 2);
     CHECK(instance2->CreationContext() == context2);
     CheckContextId(instance2, 2);
   }
-
-  context1.Dispose(context1->GetIsolate());
-  context2.Dispose(context2->GetIsolate());
-  context3.Dispose(context3->GetIsolate());
 }
 
 
 THREADED_TEST(CreationContextOfJsFunction) {
   HandleScope handle_scope(v8::Isolate::GetCurrent());
-  Persistent<Context> context = Context::New();
+  Handle<Context> context = Context::New(v8::Isolate::GetCurrent());
   InstallContextId(context, 1);
 
   Local<Object> function;
   {
     Context::Scope scope(context);
     function = CompileRun("function foo() {}; foo").As<Object>();
   }
 
   CHECK(function->CreationContext() == context);
   CheckContextId(function, 1);
-
-  context.Dispose(context->GetIsolate());
 }
 
 
 Handle<Value> HasOwnPropertyIndexedPropertyGetter(uint32_t index,
                                                   const AccessorInfo& info) {
   if (index == 42) return v8_str("yes");
   return Handle<v8::Integer>();
 }
 
 
@@ skipping 1230 matching lines @@
   i::Semaphore* sem_;
   volatile int sem_value_;
 };
 
 
 THREADED_TEST(SemaphoreInterruption) {
   ThreadInterruptTest().RunTest();
 }
 
 #endif  // WIN32