Remove usage of deprecated APIs from test-api.cc.

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 42 matching lines @@
 #include "test/cctest/heap-tester.h"
 
 static const bool kLogThreading = false;
 
 using ::v8::Boolean;
 using ::v8::BooleanObject;
 using ::v8::Context;
 using ::v8::Extension;
 using ::v8::Function;
 using ::v8::FunctionTemplate;
-using ::v8::Handle;
 using ::v8::HandleScope;
 using ::v8::Local;
 using ::v8::Maybe;
 using ::v8::Message;
 using ::v8::MessageCallback;
 using ::v8::Name;
 using ::v8::None;
 using ::v8::Object;
 using ::v8::ObjectTemplate;
 using ::v8::Persistent;
@@ skipping 13 matching lines @@
   static void Test##Name();                                          \
   TEST(Name##WithProfiler) {                                         \
     RunWithProfiler(&Test##Name);                                    \
   }                                                                  \
   THREADED_TEST(Name)
 
 
 void RunWithProfiler(void (*test)()) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::Local<v8::String> profile_name =
-      v8::String::NewFromUtf8(env->GetIsolate(), "my_profile1");
+  v8::Local<v8::String> profile_name = v8_str("my_profile1");
   v8::CpuProfiler* cpu_profiler = env->GetIsolate()->GetCpuProfiler();
 
   cpu_profiler->StartProfiling(profile_name);
   (*test)();
   reinterpret_cast<i::CpuProfiler*>(cpu_profiler)->DeleteAllProfiles();
 }
 
 
 static int signature_callback_count;
 static Local<Value> signature_expected_receiver;
 static void IncrementingSignatureCallback(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   signature_callback_count++;
-  CHECK(signature_expected_receiver->Equals(args.Holder()));
-  CHECK(signature_expected_receiver->Equals(args.This()));
-  v8::Handle<v8::Array> result =
+  CHECK(signature_expected_receiver->Equals(
+                                       args.GetIsolate()->GetCurrentContext(),
+                                       args.Holder())
+            .FromJust());
+  CHECK(signature_expected_receiver->Equals(
+                                       args.GetIsolate()->GetCurrentContext(),
+                                       args.This())
+            .FromJust());
+  v8::Local<v8::Array> result =
       v8::Array::New(args.GetIsolate(), args.Length());
-  for (int i = 0; i < args.Length(); i++)
-    result->Set(v8::Integer::New(args.GetIsolate(), i), args[i]);
+  for (int i = 0; i < args.Length(); i++) {
+    CHECK(result->Set(args.GetIsolate()->GetCurrentContext(),
+                      v8::Integer::New(args.GetIsolate(), i), args[i])
+              .FromJust());
+  }
   args.GetReturnValue().Set(result);
 }
 
 
 static void Returns42(const v8::FunctionCallbackInfo<v8::Value>& info) {
   info.GetReturnValue().Set(42);
 }
 
 
 // Tests that call v8::V8::Dispose() cannot be threaded.
@@ skipping 18 matching lines @@
   Local<Context> local_env;
   {
     LocalContext env;
     local_env = env.local();
   }
 
   // Local context should still be live.
   CHECK(!local_env.IsEmpty());
   local_env->Enter();
 
-  v8::Handle<v8::Primitive> undef = v8::Undefined(CcTest::isolate());
+  v8::Local<v8::Primitive> undef = v8::Undefined(CcTest::isolate());
   CHECK(!undef.IsEmpty());
   CHECK(undef->IsUndefined());
 
   const char* source = "1 + 2 + 3";
   Local<Script> script = v8_compile(source);
-  CHECK_EQ(6, script->Run()->Int32Value());
+  CHECK_EQ(6, v8_run_int32value(script));
 
   local_env->Exit();
 }
 
 
 THREADED_TEST(IsolateOfContext) {
   v8::HandleScope scope(CcTest::isolate());
-  v8::Handle<Context> env = Context::New(CcTest::isolate());
+  v8::Local<Context> env = Context::New(CcTest::isolate());
 
   CHECK(!env->GetIsolate()->InContext());
   CHECK(env->GetIsolate() == CcTest::isolate());
   env->Enter();
   CHECK(env->GetIsolate()->InContext());
   CHECK(env->GetIsolate() == CcTest::isolate());
   env->Exit();
   CHECK(!env->GetIsolate()->InContext());
   CHECK(env->GetIsolate() == CcTest::isolate());
 }
@@ skipping 10 matching lines @@
   signature_callback_count = 0;
   signature_expected_receiver = receiver;
   bool expected_to_throw = receiver.IsEmpty();
   v8::TryCatch try_catch(isolate);
   CompileRun(source.start());
   CHECK_EQ(expected_to_throw, try_catch.HasCaught());
   if (!expected_to_throw) {
     CHECK_EQ(10, signature_callback_count);
   } else {
     CHECK(v8_str("TypeError: Illegal invocation")
-              ->Equals(try_catch.Exception()->ToString(isolate)));
+              ->Equals(isolate->GetCurrentContext(),
+                       try_catch.Exception()
+                           ->ToString(isolate->GetCurrentContext())
+                           .ToLocalChecked())
+              .FromJust());
   }
 }
 
 
 THREADED_TEST(ReceiverSignature) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   // Setup templates.
-  v8::Handle<v8::FunctionTemplate> fun = v8::FunctionTemplate::New(isolate);
-  v8::Handle<v8::Signature> sig = v8::Signature::New(isolate, fun);
-  v8::Handle<v8::FunctionTemplate> callback_sig =
-      v8::FunctionTemplate::New(
-          isolate, IncrementingSignatureCallback, Local<Value>(), sig);
-  v8::Handle<v8::FunctionTemplate> callback =
+  v8::Local<v8::FunctionTemplate> fun = v8::FunctionTemplate::New(isolate);
+  v8::Local<v8::Signature> sig = v8::Signature::New(isolate, fun);
+  v8::Local<v8::FunctionTemplate> callback_sig = v8::FunctionTemplate::New(
+      isolate, IncrementingSignatureCallback, Local<Value>(), sig);
+  v8::Local<v8::FunctionTemplate> callback =
       v8::FunctionTemplate::New(isolate, IncrementingSignatureCallback);
-  v8::Handle<v8::FunctionTemplate> sub_fun = v8::FunctionTemplate::New(isolate);
+  v8::Local<v8::FunctionTemplate> sub_fun = v8::FunctionTemplate::New(isolate);
   sub_fun->Inherit(fun);
-  v8::Handle<v8::FunctionTemplate> unrel_fun =
+  v8::Local<v8::FunctionTemplate> unrel_fun =
       v8::FunctionTemplate::New(isolate);
   // Install properties.
-  v8::Handle<v8::ObjectTemplate> fun_proto = fun->PrototypeTemplate();
+  v8::Local<v8::ObjectTemplate> fun_proto = fun->PrototypeTemplate();
   fun_proto->Set(v8_str("prop_sig"), callback_sig);
   fun_proto->Set(v8_str("prop"), callback);
   fun_proto->SetAccessorProperty(
       v8_str("accessor_sig"), callback_sig, callback_sig);
   fun_proto->SetAccessorProperty(v8_str("accessor"), callback, callback);
   // Instantiate templates.
-  Local<Value> fun_instance = fun->InstanceTemplate()->NewInstance();
-  Local<Value> sub_fun_instance = sub_fun->InstanceTemplate()->NewInstance();
+  Local<Value> fun_instance =
+      fun->InstanceTemplate()->NewInstance(env.local()).ToLocalChecked();
+  Local<Value> sub_fun_instance =
+      sub_fun->InstanceTemplate()->NewInstance(env.local()).ToLocalChecked();
   // Setup global variables.
-  env->Global()->Set(v8_str("Fun"), fun->GetFunction());
-  env->Global()->Set(v8_str("UnrelFun"), unrel_fun->GetFunction());
-  env->Global()->Set(v8_str("fun_instance"), fun_instance);
-  env->Global()->Set(v8_str("sub_fun_instance"), sub_fun_instance);
+  CHECK(env->Global()
+            ->Set(env.local(), v8_str("Fun"),
+                  fun->GetFunction(env.local()).ToLocalChecked())
+            .FromJust());
+  CHECK(env->Global()
+            ->Set(env.local(), v8_str("UnrelFun"),
+                  unrel_fun->GetFunction(env.local()).ToLocalChecked())
+            .FromJust());
+  CHECK(env->Global()
+            ->Set(env.local(), v8_str("fun_instance"), fun_instance)
+            .FromJust());
+  CHECK(env->Global()
+            ->Set(env.local(), v8_str("sub_fun_instance"), sub_fun_instance)
+            .FromJust());
   CompileRun(
       "var accessor_sig_key = 'accessor_sig';"
       "var accessor_key = 'accessor';"
       "var prop_sig_key = 'prop_sig';"
       "var prop_key = 'prop';"
       ""
       "function copy_props(obj) {"
       "  var keys = [accessor_sig_key, accessor_key, prop_sig_key, prop_key];"
       "  var source = Fun.prototype;"
       "  for (var i in keys) {"
@@ skipping 28 matching lines @@
     TestSignature("test_object.accessor_sig = 1;", test_object, isolate);
     TestSignature("test_object[accessor_sig_key] = 1;", test_object, isolate);
   }
 }
 
 
 THREADED_TEST(HulIgennem) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::Primitive> undef = v8::Undefined(isolate);
-  Local<String> undef_str = undef->ToString(isolate);
+  v8::Local<v8::Primitive> undef = v8::Undefined(isolate);
+  Local<String> undef_str = undef->ToString(env.local()).ToLocalChecked();
   char* value = i::NewArray<char>(undef_str->Utf8Length() + 1);
   undef_str->WriteUtf8(value);
   CHECK_EQ(0, strcmp(value, "undefined"));
   i::DeleteArray(value);
 }
 
 
 THREADED_TEST(Access) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   Local<v8::Object> obj = v8::Object::New(isolate);
-  Local<Value> foo_before = obj->Get(v8_str("foo"));
+  Local<Value> foo_before =
+      obj->Get(env.local(), v8_str("foo")).ToLocalChecked();
   CHECK(foo_before->IsUndefined());
   Local<String> bar_str = v8_str("bar");
-  obj->Set(v8_str("foo"), bar_str);
-  Local<Value> foo_after = obj->Get(v8_str("foo"));
+  CHECK(obj->Set(env.local(), v8_str("foo"), bar_str).FromJust());
+  Local<Value> foo_after =
+      obj->Get(env.local(), v8_str("foo")).ToLocalChecked();
   CHECK(!foo_after->IsUndefined());
   CHECK(foo_after->IsString());
-  CHECK(bar_str->Equals(foo_after));
+  CHECK(bar_str->Equals(env.local(), foo_after).FromJust());
 }
 
 
 THREADED_TEST(AccessElement) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   Local<v8::Object> obj = v8::Object::New(env->GetIsolate());
-  Local<Value> before = obj->Get(1);
+  Local<Value> before = obj->Get(env.local(), 1).ToLocalChecked();
   CHECK(before->IsUndefined());
   Local<String> bar_str = v8_str("bar");
-  obj->Set(1, bar_str);
-  Local<Value> after = obj->Get(1);
+  CHECK(obj->Set(env.local(), 1, bar_str).FromJust());
+  Local<Value> after = obj->Get(env.local(), 1).ToLocalChecked();
   CHECK(!after->IsUndefined());
   CHECK(after->IsString());
-  CHECK(bar_str->Equals(after));
+  CHECK(bar_str->Equals(env.local(), after).FromJust());
 
   Local<v8::Array> value = CompileRun("[\"a\", \"b\"]").As<v8::Array>();
-  CHECK(v8_str("a")->Equals(value->Get(0)));
-  CHECK(v8_str("b")->Equals(value->Get(1)));
+  CHECK(v8_str("a")
+            ->Equals(env.local(), value->Get(env.local(), 0).ToLocalChecked())
+            .FromJust());
+  CHECK(v8_str("b")
+            ->Equals(env.local(), value->Get(env.local(), 1).ToLocalChecked())
+            .FromJust());
 }
 
 
 THREADED_TEST(Script) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   const char* source = "1 + 2 + 3";
   Local<Script> script = v8_compile(source);
-  CHECK_EQ(6, script->Run()->Int32Value());
+  CHECK_EQ(6, v8_run_int32value(script));
 }
 
 
 class TestResource: public String::ExternalStringResource {
  public:
   explicit TestResource(uint16_t* data, int* counter = NULL,
                         bool owning_data = true)
       : data_(data), length_(0), counter_(counter), owning_data_(owning_data) {
     while (data[length_]) ++length_;
   }
@@ skipping 50 matching lines @@
 
 
 THREADED_TEST(ScriptUsingStringResource) {
   int dispose_count = 0;
   const char* c_source = "1 + 2 * 3";
   uint16_t* two_byte_source = AsciiToTwoByteString(c_source);
   {
     LocalContext env;
     v8::HandleScope scope(env->GetIsolate());
     TestResource* resource = new TestResource(two_byte_source, &dispose_count);
-    Local<String> source = String::NewExternal(env->GetIsolate(), resource);
+    Local<String> source =
+        String::NewExternalTwoByte(env->GetIsolate(), resource)
+            .ToLocalChecked();
     Local<Script> script = v8_compile(source);
-    Local<Value> value = script->Run();
+    Local<Value> value = script->Run(env.local()).ToLocalChecked();
     CHECK(value->IsNumber());
-    CHECK_EQ(7, value->Int32Value());
+    CHECK_EQ(7, value->Int32Value(env.local()).FromJust());
     CHECK(source->IsExternal());
     CHECK_EQ(resource,
              static_cast<TestResource*>(source->GetExternalStringResource()));
     String::Encoding encoding = String::UNKNOWN_ENCODING;
     CHECK_EQ(static_cast<const String::ExternalStringResourceBase*>(resource),
              source->GetExternalStringResourceBase(&encoding));
     CHECK_EQ(String::TWO_BYTE_ENCODING, encoding);
     CcTest::heap()->CollectAllGarbage();
     CHECK_EQ(0, dispose_count);
   }
   CcTest::i_isolate()->compilation_cache()->Clear();
   CcTest::heap()->CollectAllAvailableGarbage();
   CHECK_EQ(1, dispose_count);
 }
 
 
 THREADED_TEST(ScriptUsingOneByteStringResource) {
   int dispose_count = 0;
   const char* c_source = "1 + 2 * 3";
   {
     LocalContext env;
     v8::HandleScope scope(env->GetIsolate());
     TestOneByteResource* resource =
         new TestOneByteResource(i::StrDup(c_source), &dispose_count);
-    Local<String> source = String::NewExternal(env->GetIsolate(), resource);
+    Local<String> source =
+        String::NewExternalOneByte(env->GetIsolate(), resource)
+            .ToLocalChecked();
     CHECK(source->IsExternalOneByte());
     CHECK_EQ(static_cast<const String::ExternalStringResourceBase*>(resource),
              source->GetExternalOneByteStringResource());
     String::Encoding encoding = String::UNKNOWN_ENCODING;
     CHECK_EQ(static_cast<const String::ExternalStringResourceBase*>(resource),
              source->GetExternalStringResourceBase(&encoding));
     CHECK_EQ(String::ONE_BYTE_ENCODING, encoding);
     Local<Script> script = v8_compile(source);
-    Local<Value> value = script->Run();
+    Local<Value> value = script->Run(env.local()).ToLocalChecked();
     CHECK(value->IsNumber());
-    CHECK_EQ(7, value->Int32Value());
+    CHECK_EQ(7, value->Int32Value(env.local()).FromJust());
     CcTest::heap()->CollectAllGarbage();
     CHECK_EQ(0, dispose_count);
   }
   CcTest::i_isolate()->compilation_cache()->Clear();
   CcTest::heap()->CollectAllAvailableGarbage();
   CHECK_EQ(1, dispose_count);
 }
 
 
 THREADED_TEST(ScriptMakingExternalString) {
   int dispose_count = 0;
   uint16_t* two_byte_source = AsciiToTwoByteString("1 + 2 * 3");
   {
     LocalContext env;
     v8::HandleScope scope(env->GetIsolate());
     Local<String> source =
-        String::NewFromTwoByte(env->GetIsolate(), two_byte_source);
+        String::NewFromTwoByte(env->GetIsolate(), two_byte_source,
+                               v8::NewStringType::kNormal)
+            .ToLocalChecked();
     // Trigger GCs so that the newly allocated string moves to old gen.
     CcTest::heap()->CollectGarbage(i::NEW_SPACE);  // in survivor space now
     CcTest::heap()->CollectGarbage(i::NEW_SPACE);  // in old gen now
     CHECK_EQ(source->IsExternal(), false);
     CHECK_EQ(source->IsExternalOneByte(), false);
     String::Encoding encoding = String::UNKNOWN_ENCODING;
     CHECK(!source->GetExternalStringResourceBase(&encoding));
     CHECK_EQ(String::ONE_BYTE_ENCODING, encoding);
     bool success = source->MakeExternal(new TestResource(two_byte_source,
                                                          &dispose_count));
     CHECK(success);
     Local<Script> script = v8_compile(source);
-    Local<Value> value = script->Run();
+    Local<Value> value = script->Run(env.local()).ToLocalChecked();
     CHECK(value->IsNumber());
-    CHECK_EQ(7, value->Int32Value());
+    CHECK_EQ(7, value->Int32Value(env.local()).FromJust());
     CcTest::heap()->CollectAllGarbage();
     CHECK_EQ(0, dispose_count);
   }
   CcTest::i_isolate()->compilation_cache()->Clear();
   CcTest::heap()->CollectAllGarbage();
   CHECK_EQ(1, dispose_count);
 }
 
 
 THREADED_TEST(ScriptMakingExternalOneByteString) {
   int dispose_count = 0;
   const char* c_source = "1 + 2 * 3";
   {
     LocalContext env;
     v8::HandleScope scope(env->GetIsolate());
     Local<String> source = v8_str(c_source);
     // Trigger GCs so that the newly allocated string moves to old gen.
     CcTest::heap()->CollectGarbage(i::NEW_SPACE);  // in survivor space now
     CcTest::heap()->CollectGarbage(i::NEW_SPACE);  // in old gen now
     bool success = source->MakeExternal(
         new TestOneByteResource(i::StrDup(c_source), &dispose_count));
     CHECK(success);
     Local<Script> script = v8_compile(source);
-    Local<Value> value = script->Run();
+    Local<Value> value = script->Run(env.local()).ToLocalChecked();
     CHECK(value->IsNumber());
-    CHECK_EQ(7, value->Int32Value());
+    CHECK_EQ(7, value->Int32Value(env.local()).FromJust());
     CcTest::heap()->CollectAllGarbage();
     CHECK_EQ(0, dispose_count);
   }
   CcTest::i_isolate()->compilation_cache()->Clear();
   CcTest::heap()->CollectAllGarbage();
   CHECK_EQ(1, dispose_count);
 }
 
 
 TEST(MakingExternalStringConditions) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   // Free some space in the new space so that we can check freshness.
   CcTest::heap()->CollectGarbage(i::NEW_SPACE);
   CcTest::heap()->CollectGarbage(i::NEW_SPACE);
 
   uint16_t* two_byte_string = AsciiToTwoByteString("s1");
   Local<String> small_string =
-      String::NewFromTwoByte(env->GetIsolate(), two_byte_string);
+      String::NewFromTwoByte(env->GetIsolate(), two_byte_string,
+                             v8::NewStringType::kNormal)
+          .ToLocalChecked();
   i::DeleteArray(two_byte_string);
 
   // We should refuse to externalize small strings.
   CHECK(!small_string->CanMakeExternal());
   // Trigger GCs so that the newly allocated string moves to old gen.
   CcTest::heap()->CollectGarbage(i::NEW_SPACE);  // in survivor space now
   CcTest::heap()->CollectGarbage(i::NEW_SPACE);  // in old gen now
   // Old space strings should be accepted.
   CHECK(small_string->CanMakeExternal());
 
   two_byte_string = AsciiToTwoByteString("small string 2");
-  small_string = String::NewFromTwoByte(env->GetIsolate(), two_byte_string);
+  small_string = String::NewFromTwoByte(env->GetIsolate(), two_byte_string,
+                                        v8::NewStringType::kNormal)
+                     .ToLocalChecked();
   i::DeleteArray(two_byte_string);
 
   const int buf_size = 10 * 1024;
   char* buf = i::NewArray<char>(buf_size);
   memset(buf, 'a', buf_size);
   buf[buf_size - 1] = '\0';
 
   two_byte_string = AsciiToTwoByteString(buf);
   Local<String> large_string =
-      String::NewFromTwoByte(env->GetIsolate(), two_byte_string);
+      String::NewFromTwoByte(env->GetIsolate(), two_byte_string,
+                             v8::NewStringType::kNormal)
+          .ToLocalChecked();
   i::DeleteArray(buf);
   i::DeleteArray(two_byte_string);
   // Large strings should be immediately accepted.
   CHECK(large_string->CanMakeExternal());
 }
 
 
 TEST(MakingExternalOneByteStringConditions) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   // Free some space in the new space so that we can check freshness.
   CcTest::heap()->CollectGarbage(i::NEW_SPACE);
   CcTest::heap()->CollectGarbage(i::NEW_SPACE);
 
-  Local<String> small_string = String::NewFromUtf8(env->GetIsolate(), "s1");
+  Local<String> small_string = v8_str("s1");
   // We should refuse to externalize small strings.
   CHECK(!small_string->CanMakeExternal());
   // Trigger GCs so that the newly allocated string moves to old gen.
   CcTest::heap()->CollectGarbage(i::NEW_SPACE);  // in survivor space now
   CcTest::heap()->CollectGarbage(i::NEW_SPACE);  // in old gen now
   // Old space strings should be accepted.
   CHECK(small_string->CanMakeExternal());
 
   const int buf_size = 10 * 1024;
   char* buf = i::NewArray<char>(buf_size);
   memset(buf, 'a', buf_size);
   buf[buf_size - 1] = '\0';
-  Local<String> large_string = String::NewFromUtf8(env->GetIsolate(), buf);
+  Local<String> large_string = v8_str(buf);
   i::DeleteArray(buf);
   // Large strings should be immediately accepted.
   CHECK(large_string->CanMakeExternal());
 }
 
 
 TEST(MakingExternalUnalignedOneByteString) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
@@ skipping 25 matching lines @@
   CcTest::heap()->CollectAllGarbage();
   CcTest::heap()->CollectAllGarbage(i::Heap::kReduceMemoryFootprintMask);
 }
 
 
 THREADED_TEST(UsingExternalString) {
   i::Factory* factory = CcTest::i_isolate()->factory();
   {
     v8::HandleScope scope(CcTest::isolate());
     uint16_t* two_byte_string = AsciiToTwoByteString("test string");
-    Local<String> string = String::NewExternal(
-        CcTest::isolate(), new TestResource(two_byte_string));
+    Local<String> string =
+        String::NewExternalTwoByte(CcTest::isolate(),
+                                   new TestResource(two_byte_string))
+            .ToLocalChecked();
     i::Handle<i::String> istring = v8::Utils::OpenHandle(*string);
     // Trigger GCs so that the newly allocated string moves to old gen.
     CcTest::heap()->CollectGarbage(i::NEW_SPACE);  // in survivor space now
     CcTest::heap()->CollectGarbage(i::NEW_SPACE);  // in old gen now
     i::Handle<i::String> isymbol =
         factory->InternalizeString(istring);
     CHECK(isymbol->IsInternalizedString());
   }
   CcTest::heap()->CollectAllGarbage();
   CcTest::heap()->CollectAllGarbage();
 }
 
 
 THREADED_TEST(UsingExternalOneByteString) {
   i::Factory* factory = CcTest::i_isolate()->factory();
   {
     v8::HandleScope scope(CcTest::isolate());
     const char* one_byte_string = "test string";
-    Local<String> string = String::NewExternal(
-        CcTest::isolate(), new TestOneByteResource(i::StrDup(one_byte_string)));
+    Local<String> string =
+        String::NewExternalOneByte(
+            CcTest::isolate(),
+            new TestOneByteResource(i::StrDup(one_byte_string)))
+            .ToLocalChecked();
     i::Handle<i::String> istring = v8::Utils::OpenHandle(*string);
     // Trigger GCs so that the newly allocated string moves to old gen.
     CcTest::heap()->CollectGarbage(i::NEW_SPACE);  // in survivor space now
     CcTest::heap()->CollectGarbage(i::NEW_SPACE);  // in old gen now
     i::Handle<i::String> isymbol =
         factory->InternalizeString(istring);
     CHECK(isymbol->IsInternalizedString());
   }
   CcTest::heap()->CollectAllGarbage();
   CcTest::heap()->CollectAllGarbage();
@@ skipping 24 matching lines @@
   int length_;
 };
 
 
 THREADED_TEST(NewExternalForVeryLongString) {
   auto isolate = CcTest::isolate();
   {
     v8::HandleScope scope(isolate);
     v8::TryCatch try_catch(isolate);
     RandomLengthOneByteResource r(1 << 30);
-    v8::Local<v8::String> str = v8::String::NewExternal(isolate, &r);
-    CHECK(str.IsEmpty());
+    v8::MaybeLocal<v8::String> maybe_str =
+        v8::String::NewExternalOneByte(isolate, &r);
+    CHECK(maybe_str.IsEmpty());
     CHECK(!try_catch.HasCaught());
   }
 
   {
     v8::HandleScope scope(isolate);
     v8::TryCatch try_catch(isolate);
     RandomLengthResource r(1 << 30);
-    v8::Local<v8::String> str = v8::String::NewExternal(isolate, &r);
-    CHECK(str.IsEmpty());
+    v8::MaybeLocal<v8::String> maybe_str =
+        v8::String::NewExternalTwoByte(isolate, &r);
+    CHECK(maybe_str.IsEmpty());
     CHECK(!try_catch.HasCaught());
   }
 }
 
 
 THREADED_TEST(ScavengeExternalString) {
   i::FLAG_stress_compaction = false;
   i::FLAG_gc_global = false;
   int dispose_count = 0;
   bool in_new_space = false;
   {
     v8::HandleScope scope(CcTest::isolate());
     uint16_t* two_byte_string = AsciiToTwoByteString("test string");
-    Local<String> string = String::NewExternal(
-        CcTest::isolate(), new TestResource(two_byte_string, &dispose_count));
+    Local<String> string =
+        String::NewExternalTwoByte(
+            CcTest::isolate(),
+            new TestResource(two_byte_string, &dispose_count))
+            .ToLocalChecked();
     i::Handle<i::String> istring = v8::Utils::OpenHandle(*string);
     CcTest::heap()->CollectGarbage(i::NEW_SPACE);
     in_new_space = CcTest::heap()->InNewSpace(*istring);
     CHECK(in_new_space || CcTest::heap()->old_space()->Contains(*istring));
     CHECK_EQ(0, dispose_count);
   }
   CcTest::heap()->CollectGarbage(in_new_space ? i::NEW_SPACE : i::OLD_SPACE);
   CHECK_EQ(1, dispose_count);
 }
 
 
 THREADED_TEST(ScavengeExternalOneByteString) {
   i::FLAG_stress_compaction = false;
   i::FLAG_gc_global = false;
   int dispose_count = 0;
   bool in_new_space = false;
   {
     v8::HandleScope scope(CcTest::isolate());
     const char* one_byte_string = "test string";
-    Local<String> string = String::NewExternal(
-        CcTest::isolate(),
-        new TestOneByteResource(i::StrDup(one_byte_string), &dispose_count));
+    Local<String> string =
+        String::NewExternalOneByte(
+            CcTest::isolate(),
+            new TestOneByteResource(i::StrDup(one_byte_string), &dispose_count))
+            .ToLocalChecked();
     i::Handle<i::String> istring = v8::Utils::OpenHandle(*string);
     CcTest::heap()->CollectGarbage(i::NEW_SPACE);
     in_new_space = CcTest::heap()->InNewSpace(*istring);
     CHECK(in_new_space || CcTest::heap()->old_space()->Contains(*istring));
     CHECK_EQ(0, dispose_count);
   }
   CcTest::heap()->CollectGarbage(in_new_space ? i::NEW_SPACE : i::OLD_SPACE);
   CHECK_EQ(1, dispose_count);
 }
 
@@ skipping 23 matching lines @@
 TEST(ExternalStringWithDisposeHandling) {
   const char* c_source = "1 + 2 * 3";
 
   // Use a stack allocated external string resource allocated object.
   TestOneByteResourceWithDisposeControl::dispose_count = 0;
   TestOneByteResourceWithDisposeControl::dispose_calls = 0;
   TestOneByteResourceWithDisposeControl res_stack(i::StrDup(c_source), false);
   {
     LocalContext env;
     v8::HandleScope scope(env->GetIsolate());
-    Local<String> source =  String::NewExternal(env->GetIsolate(), &res_stack);
+    Local<String> source =
+        String::NewExternalOneByte(env->GetIsolate(), &res_stack)
+            .ToLocalChecked();
     Local<Script> script = v8_compile(source);
-    Local<Value> value = script->Run();
+    Local<Value> value = script->Run(env.local()).ToLocalChecked();
     CHECK(value->IsNumber());
-    CHECK_EQ(7, value->Int32Value());
+    CHECK_EQ(7, value->Int32Value(env.local()).FromJust());
     CcTest::heap()->CollectAllAvailableGarbage();
     CHECK_EQ(0, TestOneByteResourceWithDisposeControl::dispose_count);
   }
   CcTest::i_isolate()->compilation_cache()->Clear();
   CcTest::heap()->CollectAllAvailableGarbage();
   CHECK_EQ(1, TestOneByteResourceWithDisposeControl::dispose_calls);
   CHECK_EQ(0, TestOneByteResourceWithDisposeControl::dispose_count);
 
   // Use a heap allocated external string resource allocated object.
   TestOneByteResourceWithDisposeControl::dispose_count = 0;
   TestOneByteResourceWithDisposeControl::dispose_calls = 0;
   TestOneByteResource* res_heap =
       new TestOneByteResourceWithDisposeControl(i::StrDup(c_source), true);
   {
     LocalContext env;
     v8::HandleScope scope(env->GetIsolate());
-    Local<String> source =  String::NewExternal(env->GetIsolate(), res_heap);
+    Local<String> source =
+        String::NewExternalOneByte(env->GetIsolate(), res_heap)
+            .ToLocalChecked();
     Local<Script> script = v8_compile(source);
-    Local<Value> value = script->Run();
+    Local<Value> value = script->Run(env.local()).ToLocalChecked();
     CHECK(value->IsNumber());
-    CHECK_EQ(7, value->Int32Value());
+    CHECK_EQ(7, value->Int32Value(env.local()).FromJust());
     CcTest::heap()->CollectAllAvailableGarbage();
     CHECK_EQ(0, TestOneByteResourceWithDisposeControl::dispose_count);
   }
   CcTest::i_isolate()->compilation_cache()->Clear();
   CcTest::heap()->CollectAllAvailableGarbage();
   CHECK_EQ(1, TestOneByteResourceWithDisposeControl::dispose_calls);
   CHECK_EQ(1, TestOneByteResourceWithDisposeControl::dispose_count);
 }
 
 
 THREADED_TEST(StringConcat) {
   {
     LocalContext env;
     v8::HandleScope scope(env->GetIsolate());
     const char* one_byte_string_1 = "function a_times_t";
     const char* two_byte_string_1 = "wo_plus_b(a, b) {return ";
     const char* one_byte_extern_1 = "a * 2 + b;} a_times_two_plus_b(4, 8) + ";
     const char* two_byte_extern_1 = "a_times_two_plus_b(4, 8) + ";
     const char* one_byte_string_2 = "a_times_two_plus_b(4, 8) + ";
     const char* two_byte_string_2 = "a_times_two_plus_b(4, 8) + ";
     const char* two_byte_extern_2 = "a_times_two_plus_b(1, 2);";
     Local<String> left = v8_str(one_byte_string_1);
 
     uint16_t* two_byte_source = AsciiToTwoByteString(two_byte_string_1);
     Local<String> right =
-        String::NewFromTwoByte(env->GetIsolate(), two_byte_source);
+        String::NewFromTwoByte(env->GetIsolate(), two_byte_source,
+                               v8::NewStringType::kNormal)
+            .ToLocalChecked();
     i::DeleteArray(two_byte_source);
 
     Local<String> source = String::Concat(left, right);
-    right = String::NewExternal(
-        env->GetIsolate(),
-        new TestOneByteResource(i::StrDup(one_byte_extern_1)));
+    right = String::NewExternalOneByte(
+                env->GetIsolate(),
+                new TestOneByteResource(i::StrDup(one_byte_extern_1)))
+                .ToLocalChecked();
     source = String::Concat(source, right);
-    right = String::NewExternal(
-        env->GetIsolate(),
-        new TestResource(AsciiToTwoByteString(two_byte_extern_1)));
+    right = String::NewExternalTwoByte(
+                env->GetIsolate(),
+                new TestResource(AsciiToTwoByteString(two_byte_extern_1)))
+                .ToLocalChecked();
     source = String::Concat(source, right);
     right = v8_str(one_byte_string_2);
     source = String::Concat(source, right);
 
     two_byte_source = AsciiToTwoByteString(two_byte_string_2);
-    right = String::NewFromTwoByte(env->GetIsolate(), two_byte_source);
+    right = String::NewFromTwoByte(env->GetIsolate(), two_byte_source,
+                                   v8::NewStringType::kNormal)
+                .ToLocalChecked();
     i::DeleteArray(two_byte_source);
 
     source = String::Concat(source, right);
-    right = String::NewExternal(
-        env->GetIsolate(),
-        new TestResource(AsciiToTwoByteString(two_byte_extern_2)));
+    right = String::NewExternalTwoByte(
+                env->GetIsolate(),
+                new TestResource(AsciiToTwoByteString(two_byte_extern_2)))
+                .ToLocalChecked();
     source = String::Concat(source, right);
     Local<Script> script = v8_compile(source);
-    Local<Value> value = script->Run();
+    Local<Value> value = script->Run(env.local()).ToLocalChecked();
     CHECK(value->IsNumber());
-    CHECK_EQ(68, value->Int32Value());
+    CHECK_EQ(68, value->Int32Value(env.local()).FromJust());
   }
   CcTest::i_isolate()->compilation_cache()->Clear();
   CcTest::heap()->CollectAllGarbage();
   CcTest::heap()->CollectAllGarbage();
 }
 
 
 THREADED_TEST(GlobalProperties) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::Handle<v8::Object> global = env->Global();
-  global->Set(v8_str("pi"), v8_num(3.1415926));
-  Local<Value> pi = global->Get(v8_str("pi"));
-  CHECK_EQ(3.1415926, pi->NumberValue());
+  v8::Local<v8::Object> global = env->Global();
+  CHECK(global->Set(env.local(), v8_str("pi"), v8_num(3.1415926)).FromJust());
+  Local<Value> pi = global->Get(env.local(), v8_str("pi")).ToLocalChecked();
+  CHECK_EQ(3.1415926, pi->NumberValue(env.local()).FromJust());
 }
 
 
 static void handle_callback_impl(const v8::FunctionCallbackInfo<Value>& info,
                                  i::Address callback) {
   ApiTestFuzzer::Fuzz();
   CheckReturnValue(info, callback);
   info.GetReturnValue().Set(v8_str("bad value"));
   info.GetReturnValue().Set(v8_num(102));
 }
 
 
 static void handle_callback(const v8::FunctionCallbackInfo<Value>& info) {
   return handle_callback_impl(info, FUNCTION_ADDR(handle_callback));
 }
 
 
 static void handle_callback_2(const v8::FunctionCallbackInfo<Value>& info) {
   return handle_callback_impl(info, FUNCTION_ADDR(handle_callback_2));
 }
 
 static void construct_callback(
     const v8::FunctionCallbackInfo<Value>& info) {
   ApiTestFuzzer::Fuzz();
   CheckReturnValue(info, FUNCTION_ADDR(construct_callback));
-  info.This()->Set(v8_str("x"), v8_num(1));
-  info.This()->Set(v8_str("y"), v8_num(2));
+  CHECK(
+      info.This()
+          ->Set(info.GetIsolate()->GetCurrentContext(), v8_str("x"), v8_num(1))
+          .FromJust());
+  CHECK(
+      info.This()
+          ->Set(info.GetIsolate()->GetCurrentContext(), v8_str("y"), v8_num(2))
+          .FromJust());
   info.GetReturnValue().Set(v8_str("bad value"));
   info.GetReturnValue().Set(info.This());
 }
 
 
 static void Return239Callback(
     Local<String> name, const v8::PropertyCallbackInfo<Value>& info) {
   ApiTestFuzzer::Fuzz();
   CheckReturnValue(info, FUNCTION_ADDR(Return239Callback));
   info.GetReturnValue().Set(v8_str("bad value"));
   info.GetReturnValue().Set(v8_num(239));
 }
 
 
 template<typename Handler>
 static void TestFunctionTemplateInitializer(Handler handler,
                                             Handler handler_2) {
   // Test constructor calls.
   {
     LocalContext env;
     v8::Isolate* isolate = env->GetIsolate();
     v8::HandleScope scope(isolate);
 
     Local<v8::FunctionTemplate> fun_templ =
         v8::FunctionTemplate::New(isolate, handler);
-    Local<Function> fun = fun_templ->GetFunction();
-    env->Global()->Set(v8_str("obj"), fun);
+    Local<Function> fun = fun_templ->GetFunction(env.local()).ToLocalChecked();
+    CHECK(env->Global()->Set(env.local(), v8_str("obj"), fun).FromJust());
     Local<Script> script = v8_compile("obj()");
     for (int i = 0; i < 30; i++) {
-      CHECK_EQ(102, script->Run()->Int32Value());
+      CHECK_EQ(102, v8_run_int32value(script));
     }
   }
   // Use SetCallHandler to initialize a function template, should work like
   // the previous one.
   {
     LocalContext env;
     v8::Isolate* isolate = env->GetIsolate();
     v8::HandleScope scope(isolate);
 
     Local<v8::FunctionTemplate> fun_templ = v8::FunctionTemplate::New(isolate);
     fun_templ->SetCallHandler(handler_2);
-    Local<Function> fun = fun_templ->GetFunction();
-    env->Global()->Set(v8_str("obj"), fun);
+    Local<Function> fun = fun_templ->GetFunction(env.local()).ToLocalChecked();
+    CHECK(env->Global()->Set(env.local(), v8_str("obj"), fun).FromJust());
     Local<Script> script = v8_compile("obj()");
     for (int i = 0; i < 30; i++) {
-      CHECK_EQ(102, script->Run()->Int32Value());
+      CHECK_EQ(102, v8_run_int32value(script));
     }
   }
 }
 
 
 template<typename Constructor, typename Accessor>
 static void TestFunctionTemplateAccessor(Constructor constructor,
                                          Accessor accessor) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   Local<v8::FunctionTemplate> fun_templ =
       v8::FunctionTemplate::New(env->GetIsolate(), constructor);
   fun_templ->SetClassName(v8_str("funky"));
   fun_templ->InstanceTemplate()->SetAccessor(v8_str("m"), accessor);
-  Local<Function> fun = fun_templ->GetFunction();
-  env->Global()->Set(v8_str("obj"), fun);
-  Local<Value> result = v8_compile("(new obj()).toString()")->Run();
-  CHECK(v8_str("[object funky]")->Equals(result));
+  Local<Function> fun = fun_templ->GetFunction(env.local()).ToLocalChecked();
+  CHECK(env->Global()->Set(env.local(), v8_str("obj"), fun).FromJust());
+  Local<Value> result =
+      v8_compile("(new obj()).toString()")->Run(env.local()).ToLocalChecked();
+  CHECK(v8_str("[object funky]")->Equals(env.local(), result).FromJust());
   CompileRun("var obj_instance = new obj();");
   Local<Script> script;
   script = v8_compile("obj_instance.x");
   for (int i = 0; i < 30; i++) {
-    CHECK_EQ(1, script->Run()->Int32Value());
+    CHECK_EQ(1, v8_run_int32value(script));
   }
   script = v8_compile("obj_instance.m");
   for (int i = 0; i < 30; i++) {
-    CHECK_EQ(239, script->Run()->Int32Value());
+    CHECK_EQ(239, v8_run_int32value(script));
   }
 }
 
 
 THREADED_PROFILED_TEST(FunctionTemplate) {
   TestFunctionTemplateInitializer(handle_callback, handle_callback_2);
   TestFunctionTemplateAccessor(construct_callback, Return239Callback);
 }
 
 
 static void SimpleCallback(const v8::FunctionCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   CheckReturnValue(info, FUNCTION_ADDR(SimpleCallback));
   info.GetReturnValue().Set(v8_num(51423 + info.Length()));
 }
 
 
 template<typename Callback>
 static void TestSimpleCallback(Callback callback) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
-  v8::Handle<v8::ObjectTemplate> object_template =
+  v8::Local<v8::ObjectTemplate> object_template =
       v8::ObjectTemplate::New(isolate);
   object_template->Set(isolate, "callback",
                        v8::FunctionTemplate::New(isolate, callback));
-  v8::Local<v8::Object> object = object_template->NewInstance();
-  (*env)->Global()->Set(v8_str("callback_object"), object);
-  v8::Handle<v8::Script> script;
+  v8::Local<v8::Object> object =
+      object_template->NewInstance(env.local()).ToLocalChecked();
+  CHECK((*env)
+            ->Global()
+            ->Set(env.local(), v8_str("callback_object"), object)
+            .FromJust());
+  v8::Local<v8::Script> script;
   script = v8_compile("callback_object.callback(17)");
   for (int i = 0; i < 30; i++) {
-    CHECK_EQ(51424, script->Run()->Int32Value());
+    CHECK_EQ(51424, v8_run_int32value(script));
   }
   script = v8_compile("callback_object.callback(17, 24)");
   for (int i = 0; i < 30; i++) {
-    CHECK_EQ(51425, script->Run()->Int32Value());
+    CHECK_EQ(51425, v8_run_int32value(script));
   }
 }
 
 
 THREADED_PROFILED_TEST(SimpleCallback) {
   TestSimpleCallback(SimpleCallback);
 }
 
 
 template<typename T>
@@ skipping 60 matching lines @@
       break;
     case kEmptyStringReturnValue:
       info.GetReturnValue().SetEmptyString();
       break;
   }
 }
 
 template<>
 void FastReturnValueCallback<Object>(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
-  v8::Handle<v8::Object> object;
+  v8::Local<v8::Object> object;
   if (!fast_return_value_object_is_empty) {
     object = Object::New(info.GetIsolate());
   }
   info.GetReturnValue().Set(object);
 }
 
-template<typename T>
-Handle<Value> TestFastReturnValues() {
+template <typename T>
+Local<Value> TestFastReturnValues() {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::EscapableHandleScope scope(isolate);
-  v8::Handle<v8::ObjectTemplate> object_template =
+  v8::Local<v8::ObjectTemplate> object_template =
       v8::ObjectTemplate::New(isolate);
   v8::FunctionCallback callback = &FastReturnValueCallback<T>;
   object_template->Set(isolate, "callback",
                        v8::FunctionTemplate::New(isolate, callback));
-  v8::Local<v8::Object> object = object_template->NewInstance();
-  (*env)->Global()->Set(v8_str("callback_object"), object);
+  v8::Local<v8::Object> object =
+      object_template->NewInstance(env.local()).ToLocalChecked();
+  CHECK((*env)
+            ->Global()
+            ->Set(env.local(), v8_str("callback_object"), object)
+            .FromJust());
   return scope.Escape(CompileRun("callback_object.callback()"));
 }
 
 
 THREADED_PROFILED_TEST(FastReturnValues) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::Value> value;
+  v8::Local<v8::Value> value;
   // check int32_t and uint32_t
   int32_t int_values[] = {
       0, 234, -723,
       i::Smi::kMinValue, i::Smi::kMaxValue
   };
   for (size_t i = 0; i < arraysize(int_values); i++) {
     for (int modifier = -1; modifier <= 1; modifier++) {
       int int_value = int_values[i] + modifier;
       // check int32_t
       fast_return_value_int32 = int_value;
       value = TestFastReturnValues<int32_t>();
       CHECK(value->IsInt32());
-      CHECK(fast_return_value_int32 == value->Int32Value());
+      CHECK_EQ(fast_return_value_int32,
+               value->Int32Value(env.local()).FromJust());
       // check uint32_t
       fast_return_value_uint32 = static_cast<uint32_t>(int_value);
       value = TestFastReturnValues<uint32_t>();
       CHECK(value->IsUint32());
-      CHECK(fast_return_value_uint32 == value->Uint32Value());
+      CHECK_EQ(fast_return_value_uint32,
+               value->Uint32Value(env.local()).FromJust());
     }
   }
   // check double
   value = TestFastReturnValues<double>();
   CHECK(value->IsNumber());
-  CHECK_EQ(kFastReturnValueDouble, value->ToNumber(isolate)->Value());
+  CHECK_EQ(kFastReturnValueDouble,
+           value->ToNumber(env.local()).ToLocalChecked()->Value());
   // check bool values
   for (int i = 0; i < 2; i++) {
     fast_return_value_bool = i == 0;
     value = TestFastReturnValues<bool>();
     CHECK(value->IsBoolean());
-    CHECK_EQ(fast_return_value_bool, value->ToBoolean(isolate)->Value());
+    CHECK_EQ(fast_return_value_bool,
+             value->ToBoolean(env.local()).ToLocalChecked()->Value());
   }
   // check oddballs
   ReturnValueOddball oddballs[] = {
       kNullReturnValue,
       kUndefinedReturnValue,
       kEmptyStringReturnValue
   };
   for (size_t i = 0; i < arraysize(oddballs); i++) {
     fast_return_value_void = oddballs[i];
     value = TestFastReturnValues<void>();
@@ skipping 19 matching lines @@
   CHECK(value->IsUndefined());
 }
 
 
 THREADED_TEST(FunctionTemplateSetLength) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   {
     Local<v8::FunctionTemplate> fun_templ =
-        v8::FunctionTemplate::New(isolate,
-                                  handle_callback,
-                                  Handle<v8::Value>(),
-                                  Handle<v8::Signature>(),
-                                  23);
-    Local<Function> fun = fun_templ->GetFunction();
-    env->Global()->Set(v8_str("obj"), fun);
+        v8::FunctionTemplate::New(isolate, handle_callback, Local<v8::Value>(),
+                                  Local<v8::Signature>(), 23);
+    Local<Function> fun = fun_templ->GetFunction(env.local()).ToLocalChecked();
+    CHECK(env->Global()->Set(env.local(), v8_str("obj"), fun).FromJust());
     Local<Script> script = v8_compile("obj.length");
-    CHECK_EQ(23, script->Run()->Int32Value());
+    CHECK_EQ(23, v8_run_int32value(script));
   }
   {
     Local<v8::FunctionTemplate> fun_templ =
         v8::FunctionTemplate::New(isolate, handle_callback);
     fun_templ->SetLength(22);
-    Local<Function> fun = fun_templ->GetFunction();
-    env->Global()->Set(v8_str("obj"), fun);
+    Local<Function> fun = fun_templ->GetFunction(env.local()).ToLocalChecked();
+    CHECK(env->Global()->Set(env.local(), v8_str("obj"), fun).FromJust());
     Local<Script> script = v8_compile("obj.length");
-    CHECK_EQ(22, script->Run()->Int32Value());
+    CHECK_EQ(22, v8_run_int32value(script));
   }
   {
     // Without setting length it defaults to 0.
     Local<v8::FunctionTemplate> fun_templ =
         v8::FunctionTemplate::New(isolate, handle_callback);
-    Local<Function> fun = fun_templ->GetFunction();
-    env->Global()->Set(v8_str("obj"), fun);
+    Local<Function> fun = fun_templ->GetFunction(env.local()).ToLocalChecked();
+    CHECK(env->Global()->Set(env.local(), v8_str("obj"), fun).FromJust());
     Local<Script> script = v8_compile("obj.length");
-    CHECK_EQ(0, script->Run()->Int32Value());
+    CHECK_EQ(0, v8_run_int32value(script));
   }
 }
 
 
 static void* expected_ptr;
 static void callback(const v8::FunctionCallbackInfo<v8::Value>& args) {
   void* ptr = v8::External::Cast(*args.Data())->Value();
   CHECK_EQ(expected_ptr, ptr);
   args.GetReturnValue().Set(true);
 }
 
 
 static void TestExternalPointerWrapping() {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
-  v8::Handle<v8::Value> data =
-      v8::External::New(isolate, expected_ptr);
+  v8::Local<v8::Value> data = v8::External::New(isolate, expected_ptr);
 
-  v8::Handle<v8::Object> obj = v8::Object::New(isolate);
-  obj->Set(v8_str("func"),
-           v8::FunctionTemplate::New(isolate, callback, data)->GetFunction());
-  env->Global()->Set(v8_str("obj"), obj);
+  v8::Local<v8::Object> obj = v8::Object::New(isolate);
+  CHECK(obj->Set(env.local(), v8_str("func"),
+                 v8::FunctionTemplate::New(isolate, callback, data)
+                     ->GetFunction(env.local())
+                     .ToLocalChecked())
+            .FromJust());
+  CHECK(env->Global()->Set(env.local(), v8_str("obj"), obj).FromJust());
 
-  CHECK(CompileRun(
-        "function foo() {\n"
-        "  for (var i = 0; i < 13; i++) obj.func();\n"
-        "}\n"
-        "foo(), true")->BooleanValue());
+  CHECK(CompileRun("function foo() {\n"
+                   "  for (var i = 0; i < 13; i++) obj.func();\n"
+                   "}\n"
+                   "foo(), true")
+            ->BooleanValue(env.local())
+            .FromJust());
 }
 
 
 THREADED_TEST(ExternalWrap) {
   // Check heap allocated object.
   int* ptr = new int;
   expected_ptr = ptr;
   TestExternalPointerWrapping();
   delete ptr;
 
@@ skipping 39 matching lines @@
 THREADED_TEST(FindInstanceInPrototypeChain) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   Local<v8::FunctionTemplate> base = v8::FunctionTemplate::New(isolate);
   Local<v8::FunctionTemplate> derived = v8::FunctionTemplate::New(isolate);
   Local<v8::FunctionTemplate> other = v8::FunctionTemplate::New(isolate);
   derived->Inherit(base);
 
-  Local<v8::Function> base_function = base->GetFunction();
-  Local<v8::Function> derived_function = derived->GetFunction();
-  Local<v8::Function> other_function = other->GetFunction();
+  Local<v8::Function> base_function =
+      base->GetFunction(env.local()).ToLocalChecked();
+  Local<v8::Function> derived_function =
+      derived->GetFunction(env.local()).ToLocalChecked();
+  Local<v8::Function> other_function =
+      other->GetFunction(env.local()).ToLocalChecked();
 
-  Local<v8::Object> base_instance = base_function->NewInstance();
-  Local<v8::Object> derived_instance = derived_function->NewInstance();
-  Local<v8::Object> derived_instance2 = derived_function->NewInstance();
-  Local<v8::Object> other_instance = other_function->NewInstance();
-  derived_instance2->Set(v8_str("__proto__"), derived_instance);
-  other_instance->Set(v8_str("__proto__"), derived_instance2);
+  Local<v8::Object> base_instance =
+      base_function->NewInstance(env.local()).ToLocalChecked();
+  Local<v8::Object> derived_instance =
+      derived_function->NewInstance(env.local()).ToLocalChecked();
+  Local<v8::Object> derived_instance2 =
+      derived_function->NewInstance(env.local()).ToLocalChecked();
+  Local<v8::Object> other_instance =
+      other_function->NewInstance(env.local()).ToLocalChecked();
+  CHECK(
+      derived_instance2->Set(env.local(), v8_str("__proto__"), derived_instance)
+          .FromJust());
+  CHECK(other_instance->Set(env.local(), v8_str("__proto__"), derived_instance2)
+            .FromJust());
 
   // base_instance is only an instance of base.
-  CHECK(
-      base_instance->Equals(base_instance->FindInstanceInPrototypeChain(base)));
+  CHECK(base_instance->Equals(env.local(),
+                              base_instance->FindInstanceInPrototypeChain(base))
+            .FromJust());
   CHECK(base_instance->FindInstanceInPrototypeChain(derived).IsEmpty());
   CHECK(base_instance->FindInstanceInPrototypeChain(other).IsEmpty());
 
   // derived_instance is an instance of base and derived.
-  CHECK(derived_instance->Equals(
-      derived_instance->FindInstanceInPrototypeChain(base)));
-  CHECK(derived_instance->Equals(
-      derived_instance->FindInstanceInPrototypeChain(derived)));
+  CHECK(derived_instance->Equals(env.local(),
+                                 derived_instance->FindInstanceInPrototypeChain(
+                                     base))
+            .FromJust());
+  CHECK(derived_instance->Equals(env.local(),
+                                 derived_instance->FindInstanceInPrototypeChain(
+                                     derived))
+            .FromJust());
   CHECK(derived_instance->FindInstanceInPrototypeChain(other).IsEmpty());
 
   // other_instance is an instance of other and its immediate
   // prototype derived_instance2 is an instance of base and derived.
   // Note, derived_instance is an instance of base and derived too,
   // but it comes after derived_instance2 in the prototype chain of
   // other_instance.
   CHECK(derived_instance2->Equals(
-      other_instance->FindInstanceInPrototypeChain(base)));
-  CHECK(derived_instance2->Equals(
-      other_instance->FindInstanceInPrototypeChain(derived)));
+                             env.local(),
+                             other_instance->FindInstanceInPrototypeChain(base))
+            .FromJust());
+  CHECK(derived_instance2->Equals(env.local(),
+                                  other_instance->FindInstanceInPrototypeChain(
+                                      derived))
+            .FromJust());
   CHECK(other_instance->Equals(
-      other_instance->FindInstanceInPrototypeChain(other)));
+                          env.local(),
+                          other_instance->FindInstanceInPrototypeChain(other))
+            .FromJust());
 }
 
 
 THREADED_TEST(TinyInteger) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   int32_t value = 239;
   Local<v8::Integer> value_obj = v8::Integer::New(isolate, value);
@@ skipping 109 matching lines @@
   CHECK_EQ(static_cast<int64_t>(value), value_obj->Value());
 
   value_obj = v8::Integer::NewFromUnsigned(isolate, value);
   CHECK_EQ(static_cast<int64_t>(value), value_obj->Value());
 }
 
 
 THREADED_TEST(IsNativeError) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::Handle<Value> syntax_error = CompileRun(
+  v8::Local<Value> syntax_error = CompileRun(
       "var out = 0; try { eval(\"#\"); } catch(x) { out = x; } out; ");
   CHECK(syntax_error->IsNativeError());
-  v8::Handle<Value> not_error = CompileRun("{a:42}");
+  v8::Local<Value> not_error = CompileRun("{a:42}");
   CHECK(!not_error->IsNativeError());
-  v8::Handle<Value> not_object = CompileRun("42");
+  v8::Local<Value> not_object = CompileRun("42");
   CHECK(!not_object->IsNativeError());
 }
 
 
 THREADED_TEST(IsGeneratorFunctionOrObject) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   CompileRun("function *gen() { yield 1; }\nfunction func() {}");
-  v8::Handle<Value> gen = CompileRun("gen");
-  v8::Handle<Value> genObj = CompileRun("gen()");
-  v8::Handle<Value> object = CompileRun("{a:42}");
-  v8::Handle<Value> func = CompileRun("func");
+  v8::Local<Value> gen = CompileRun("gen");
+  v8::Local<Value> genObj = CompileRun("gen()");
+  v8::Local<Value> object = CompileRun("{a:42}");
+  v8::Local<Value> func = CompileRun("func");
 
   CHECK(gen->IsGeneratorFunction());
   CHECK(gen->IsFunction());
   CHECK(!gen->IsGeneratorObject());
 
   CHECK(!genObj->IsGeneratorFunction());
   CHECK(!genObj->IsFunction());
   CHECK(genObj->IsGeneratorObject());
 
   CHECK(!object->IsGeneratorFunction());
   CHECK(!object->IsFunction());
   CHECK(!object->IsGeneratorObject());
 
   CHECK(!func->IsGeneratorFunction());
   CHECK(func->IsFunction());
   CHECK(!func->IsGeneratorObject());
 }
 
 
 THREADED_TEST(ArgumentsObject) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::Handle<Value> arguments_object =
+  v8::Local<Value> arguments_object =
       CompileRun("var out = 0; (function(){ out = arguments; })(1,2,3); out;");
   CHECK(arguments_object->IsArgumentsObject());
-  v8::Handle<Value> array = CompileRun("[1,2,3]");
+  v8::Local<Value> array = CompileRun("[1,2,3]");
   CHECK(!array->IsArgumentsObject());
-  v8::Handle<Value> object = CompileRun("{a:42}");
+  v8::Local<Value> object = CompileRun("{a:42}");
   CHECK(!object->IsArgumentsObject());
 }
 
 
 THREADED_TEST(IsMapOrSet) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::Handle<Value> map = CompileRun("new Map()");
-  v8::Handle<Value> set = CompileRun("new Set()");
-  v8::Handle<Value> weak_map = CompileRun("new WeakMap()");
-  v8::Handle<Value> weak_set = CompileRun("new WeakSet()");
+  v8::Local<Value> map = CompileRun("new Map()");
+  v8::Local<Value> set = CompileRun("new Set()");
+  v8::Local<Value> weak_map = CompileRun("new WeakMap()");
+  v8::Local<Value> weak_set = CompileRun("new WeakSet()");
   CHECK(map->IsMap());
   CHECK(set->IsSet());
   CHECK(weak_map->IsWeakMap());
   CHECK(weak_set->IsWeakSet());
 
   CHECK(!map->IsSet());
   CHECK(!map->IsWeakMap());
   CHECK(!map->IsWeakSet());
 
   CHECK(!set->IsMap());
   CHECK(!set->IsWeakMap());
   CHECK(!set->IsWeakSet());
 
   CHECK(!weak_map->IsMap());
   CHECK(!weak_map->IsSet());
   CHECK(!weak_map->IsWeakSet());
 
   CHECK(!weak_set->IsMap());
   CHECK(!weak_set->IsSet());
   CHECK(!weak_set->IsWeakMap());
 
-  v8::Handle<Value> object = CompileRun("{a:42}");
+  v8::Local<Value> object = CompileRun("{a:42}");
   CHECK(!object->IsMap());
   CHECK(!object->IsSet());
   CHECK(!object->IsWeakMap());
   CHECK(!object->IsWeakSet());
 }
 
 
 THREADED_TEST(StringObject) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::Handle<Value> boxed_string = CompileRun("new String(\"test\")");
+  v8::Local<Value> boxed_string = CompileRun("new String(\"test\")");
   CHECK(boxed_string->IsStringObject());
-  v8::Handle<Value> unboxed_string = CompileRun("\"test\"");
+  v8::Local<Value> unboxed_string = CompileRun("\"test\"");
   CHECK(!unboxed_string->IsStringObject());
-  v8::Handle<Value> boxed_not_string = CompileRun("new Number(42)");
+  v8::Local<Value> boxed_not_string = CompileRun("new Number(42)");
   CHECK(!boxed_not_string->IsStringObject());
-  v8::Handle<Value> not_object = CompileRun("0");
+  v8::Local<Value> not_object = CompileRun("0");
   CHECK(!not_object->IsStringObject());
-  v8::Handle<v8::StringObject> as_boxed = boxed_string.As<v8::StringObject>();
+  v8::Local<v8::StringObject> as_boxed = boxed_string.As<v8::StringObject>();
   CHECK(!as_boxed.IsEmpty());
   Local<v8::String> the_string = as_boxed->ValueOf();
   CHECK(!the_string.IsEmpty());
   ExpectObject("\"test\"", the_string);
-  v8::Handle<v8::Value> new_boxed_string = v8::StringObject::New(the_string);
+  v8::Local<v8::Value> new_boxed_string = v8::StringObject::New(the_string);
   CHECK(new_boxed_string->IsStringObject());
   as_boxed = new_boxed_string.As<v8::StringObject>();
   the_string = as_boxed->ValueOf();
   CHECK(!the_string.IsEmpty());
   ExpectObject("\"test\"", the_string);
 }
 
 
 TEST(StringObjectDelete) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
-  v8::Handle<Value> boxed_string = CompileRun("new String(\"test\")");
+  v8::Local<Value> boxed_string = CompileRun("new String(\"test\")");
   CHECK(boxed_string->IsStringObject());
-  v8::Handle<v8::Object> str_obj = boxed_string.As<v8::Object>();
-  CHECK(!str_obj->Delete(2));
-  CHECK(!str_obj->Delete(v8_num(2)));
+  v8::Local<v8::Object> str_obj = boxed_string.As<v8::Object>();
+  CHECK(!str_obj->Delete(context.local(), 2).FromJust());
+  CHECK(!str_obj->Delete(context.local(), v8_num(2)).FromJust());
 }
 
 
 THREADED_TEST(NumberObject) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::Handle<Value> boxed_number = CompileRun("new Number(42)");
+  v8::Local<Value> boxed_number = CompileRun("new Number(42)");
   CHECK(boxed_number->IsNumberObject());
-  v8::Handle<Value> unboxed_number = CompileRun("42");
+  v8::Local<Value> unboxed_number = CompileRun("42");
   CHECK(!unboxed_number->IsNumberObject());
-  v8::Handle<Value> boxed_not_number = CompileRun("new Boolean(false)");
+  v8::Local<Value> boxed_not_number = CompileRun("new Boolean(false)");
   CHECK(!boxed_not_number->IsNumberObject());
-  v8::Handle<v8::NumberObject> as_boxed = boxed_number.As<v8::NumberObject>();
+  v8::Local<v8::NumberObject> as_boxed = boxed_number.As<v8::NumberObject>();
   CHECK(!as_boxed.IsEmpty());
   double the_number = as_boxed->ValueOf();
   CHECK_EQ(42.0, the_number);
-  v8::Handle<v8::Value> new_boxed_number =
+  v8::Local<v8::Value> new_boxed_number =
       v8::NumberObject::New(env->GetIsolate(), 43);
   CHECK(new_boxed_number->IsNumberObject());
   as_boxed = new_boxed_number.As<v8::NumberObject>();
   the_number = as_boxed->ValueOf();
   CHECK_EQ(43.0, the_number);
 }
 
 
 THREADED_TEST(BooleanObject) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::Handle<Value> boxed_boolean = CompileRun("new Boolean(true)");
+  v8::Local<Value> boxed_boolean = CompileRun("new Boolean(true)");
   CHECK(boxed_boolean->IsBooleanObject());
-  v8::Handle<Value> unboxed_boolean = CompileRun("true");
+  v8::Local<Value> unboxed_boolean = CompileRun("true");
   CHECK(!unboxed_boolean->IsBooleanObject());
-  v8::Handle<Value> boxed_not_boolean = CompileRun("new Number(42)");
+  v8::Local<Value> boxed_not_boolean = CompileRun("new Number(42)");
   CHECK(!boxed_not_boolean->IsBooleanObject());
-  v8::Handle<v8::BooleanObject> as_boxed =
-      boxed_boolean.As<v8::BooleanObject>();
+  v8::Local<v8::BooleanObject> as_boxed = boxed_boolean.As<v8::BooleanObject>();
   CHECK(!as_boxed.IsEmpty());
   bool the_boolean = as_boxed->ValueOf();
   CHECK_EQ(true, the_boolean);
-  v8::Handle<v8::Value> boxed_true = v8::BooleanObject::New(true);
-  v8::Handle<v8::Value> boxed_false = v8::BooleanObject::New(false);
+  v8::Local<v8::Value> boxed_true = v8::BooleanObject::New(true);
+  v8::Local<v8::Value> boxed_false = v8::BooleanObject::New(false);
   CHECK(boxed_true->IsBooleanObject());
   CHECK(boxed_false->IsBooleanObject());
   as_boxed = boxed_true.As<v8::BooleanObject>();
   CHECK_EQ(true, as_boxed->ValueOf());
   as_boxed = boxed_false.As<v8::BooleanObject>();
   CHECK_EQ(false, as_boxed->ValueOf());
 }
 
 
 THREADED_TEST(PrimitiveAndWrappedBooleans) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   Local<Value> primitive_false = Boolean::New(env->GetIsolate(), false);
   CHECK(primitive_false->IsBoolean());
   CHECK(!primitive_false->IsBooleanObject());
-  CHECK(!primitive_false->BooleanValue());
+  CHECK(!primitive_false->BooleanValue(env.local()).FromJust());
   CHECK(!primitive_false->IsTrue());
   CHECK(primitive_false->IsFalse());
 
   Local<Value> false_value = BooleanObject::New(false);
   CHECK(!false_value->IsBoolean());
   CHECK(false_value->IsBooleanObject());
-  CHECK(false_value->BooleanValue());
+  CHECK(false_value->BooleanValue(env.local()).FromJust());
   CHECK(!false_value->IsTrue());
   CHECK(!false_value->IsFalse());
 
   Local<BooleanObject> false_boolean_object = false_value.As<BooleanObject>();
   CHECK(!false_boolean_object->IsBoolean());
   CHECK(false_boolean_object->IsBooleanObject());
-  // TODO(svenpanne) Uncomment when BooleanObject::BooleanValue() is deleted.
-  // CHECK(false_boolean_object->BooleanValue());
+  CHECK(false_boolean_object->BooleanValue(env.local()).FromJust());
   CHECK(!false_boolean_object->ValueOf());
   CHECK(!false_boolean_object->IsTrue());
   CHECK(!false_boolean_object->IsFalse());
 
   Local<Value> primitive_true = Boolean::New(env->GetIsolate(), true);
   CHECK(primitive_true->IsBoolean());
   CHECK(!primitive_true->IsBooleanObject());
-  CHECK(primitive_true->BooleanValue());
+  CHECK(primitive_true->BooleanValue(env.local()).FromJust());
   CHECK(primitive_true->IsTrue());
   CHECK(!primitive_true->IsFalse());
 
   Local<Value> true_value = BooleanObject::New(true);
   CHECK(!true_value->IsBoolean());
   CHECK(true_value->IsBooleanObject());
-  CHECK(true_value->BooleanValue());
+  CHECK(true_value->BooleanValue(env.local()).FromJust());
   CHECK(!true_value->IsTrue());
   CHECK(!true_value->IsFalse());
 
   Local<BooleanObject> true_boolean_object = true_value.As<BooleanObject>();
   CHECK(!true_boolean_object->IsBoolean());
   CHECK(true_boolean_object->IsBooleanObject());
-  // TODO(svenpanne) Uncomment when BooleanObject::BooleanValue() is deleted.
-  // CHECK(true_boolean_object->BooleanValue());
+  CHECK(true_boolean_object->BooleanValue(env.local()).FromJust());
   CHECK(true_boolean_object->ValueOf());
   CHECK(!true_boolean_object->IsTrue());
   CHECK(!true_boolean_object->IsFalse());
 }
 
 
 THREADED_TEST(Number) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   double PI = 3.1415926;
   Local<v8::Number> pi_obj = v8::Number::New(env->GetIsolate(), PI);
-  CHECK_EQ(PI, pi_obj->NumberValue());
+  CHECK_EQ(PI, pi_obj->NumberValue(env.local()).FromJust());
 }
 
 
 THREADED_TEST(ToNumber) {
   LocalContext env;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<String> str = v8_str("3.1415926");
-  CHECK_EQ(3.1415926, str->NumberValue());
-  v8::Handle<v8::Boolean> t = v8::True(isolate);
-  CHECK_EQ(1.0, t->NumberValue());
-  v8::Handle<v8::Boolean> f = v8::False(isolate);
-  CHECK_EQ(0.0, f->NumberValue());
+  CHECK_EQ(3.1415926, str->NumberValue(env.local()).FromJust());
+  v8::Local<v8::Boolean> t = v8::True(isolate);
+  CHECK_EQ(1.0, t->NumberValue(env.local()).FromJust());
+  v8::Local<v8::Boolean> f = v8::False(isolate);
+  CHECK_EQ(0.0, f->NumberValue(env.local()).FromJust());
 }
 
 
 THREADED_TEST(Date) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   double PI = 3.1415926;
-  Local<Value> date = v8::Date::New(env->GetIsolate(), PI);
-  CHECK_EQ(3.0, date->NumberValue());
-  date.As<v8::Date>()->Set(v8_str("property"),
-                           v8::Integer::New(env->GetIsolate(), 42));
-  CHECK_EQ(42, date.As<v8::Date>()->Get(v8_str("property"))->Int32Value());
+  Local<Value> date = v8::Date::New(env.local(), PI).ToLocalChecked();
+  CHECK_EQ(3.0, date->NumberValue(env.local()).FromJust());
+  CHECK(date.As<v8::Date>()
+            ->Set(env.local(), v8_str("property"),
+                  v8::Integer::New(env->GetIsolate(), 42))
+            .FromJust());
+  CHECK_EQ(42, date.As<v8::Date>()
+                   ->Get(env.local(), v8_str("property"))
+                   .ToLocalChecked()
+                   ->Int32Value(env.local())
+                   .FromJust());
 }
 
 
 THREADED_TEST(Boolean) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::Boolean> t = v8::True(isolate);
+  v8::Local<v8::Boolean> t = v8::True(isolate);
   CHECK(t->Value());
-  v8::Handle<v8::Boolean> f = v8::False(isolate);
+  v8::Local<v8::Boolean> f = v8::False(isolate);
   CHECK(!f->Value());
-  v8::Handle<v8::Primitive> u = v8::Undefined(isolate);
-  CHECK(!u->BooleanValue());
-  v8::Handle<v8::Primitive> n = v8::Null(isolate);
-  CHECK(!n->BooleanValue());
-  v8::Handle<String> str1 = v8_str("");
-  CHECK(!str1->BooleanValue());
-  v8::Handle<String> str2 = v8_str("x");
-  CHECK(str2->BooleanValue());
-  CHECK(!v8::Number::New(isolate, 0)->BooleanValue());
-  CHECK(v8::Number::New(isolate, -1)->BooleanValue());
-  CHECK(v8::Number::New(isolate, 1)->BooleanValue());
-  CHECK(v8::Number::New(isolate, 42)->BooleanValue());
-  CHECK(!v8_compile("NaN")->Run()->BooleanValue());
+  v8::Local<v8::Primitive> u = v8::Undefined(isolate);
+  CHECK(!u->BooleanValue(env.local()).FromJust());
+  v8::Local<v8::Primitive> n = v8::Null(isolate);
+  CHECK(!n->BooleanValue(env.local()).FromJust());
+  v8::Local<String> str1 = v8_str("");
+  CHECK(!str1->BooleanValue(env.local()).FromJust());
+  v8::Local<String> str2 = v8_str("x");
+  CHECK(str2->BooleanValue(env.local()).FromJust());
+  CHECK(!v8::Number::New(isolate, 0)->BooleanValue(env.local()).FromJust());
+  CHECK(v8::Number::New(isolate, -1)->BooleanValue(env.local()).FromJust());
+  CHECK(v8::Number::New(isolate, 1)->BooleanValue(env.local()).FromJust());
+  CHECK(v8::Number::New(isolate, 42)->BooleanValue(env.local()).FromJust());
+  CHECK(!v8_compile("NaN")
+             ->Run(env.local())
+             .ToLocalChecked()
+             ->BooleanValue(env.local())
+             .FromJust());
 }
 
 
 static void DummyCallHandler(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   args.GetReturnValue().Set(v8_num(13.4));
 }
 
 
 static void GetM(Local<String> name,
                  const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   info.GetReturnValue().Set(v8_num(876));
 }
 
 
 THREADED_TEST(GlobalPrototype) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::FunctionTemplate> func_templ =
+  v8::Local<v8::FunctionTemplate> func_templ =
       v8::FunctionTemplate::New(isolate);
   func_templ->PrototypeTemplate()->Set(
       isolate, "dummy", v8::FunctionTemplate::New(isolate, DummyCallHandler));
-  v8::Handle<ObjectTemplate> templ = func_templ->InstanceTemplate();
+  v8::Local<ObjectTemplate> templ = func_templ->InstanceTemplate();
   templ->Set(isolate, "x", v8_num(200));
   templ->SetAccessor(v8_str("m"), GetM);
   LocalContext env(0, templ);
-  v8::Handle<Script> script(v8_compile("dummy()"));
-  v8::Handle<Value> result(script->Run());
-  CHECK_EQ(13.4, result->NumberValue());
-  CHECK_EQ(200, v8_compile("x")->Run()->Int32Value());
-  CHECK_EQ(876, v8_compile("m")->Run()->Int32Value());
+  v8::Local<Script> script(v8_compile("dummy()"));
+  v8::Local<Value> result(script->Run(env.local()).ToLocalChecked());
+  CHECK_EQ(13.4, result->NumberValue(env.local()).FromJust());
+  CHECK_EQ(200, v8_run_int32value(v8_compile("x")));
+  CHECK_EQ(876, v8_run_int32value(v8_compile("m")));
 }
 
 
 THREADED_TEST(ObjectTemplate) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<v8::FunctionTemplate> fun = v8::FunctionTemplate::New(isolate);
-  v8::Local<v8::String> class_name =
-      v8::String::NewFromUtf8(isolate, "the_class_name");
+  v8::Local<v8::String> class_name = v8_str("the_class_name");
   fun->SetClassName(class_name);
   Local<ObjectTemplate> templ1 = ObjectTemplate::New(isolate, fun);
   templ1->Set(isolate, "x", v8_num(10));
   templ1->Set(isolate, "y", v8_num(13));
   LocalContext env;
-  Local<v8::Object> instance1 = templ1->NewInstance();
+  Local<v8::Object> instance1 =
+      templ1->NewInstance(env.local()).ToLocalChecked();
   CHECK(class_name->StrictEquals(instance1->GetConstructorName()));
-  env->Global()->Set(v8_str("p"), instance1);
-  CHECK(v8_compile("(p.x == 10)")->Run()->BooleanValue());
-  CHECK(v8_compile("(p.y == 13)")->Run()->BooleanValue());
+  CHECK(env->Global()->Set(env.local(), v8_str("p"), instance1).FromJust());
+  CHECK(v8_compile("(p.x == 10)")
+            ->Run(env.local())
+            .ToLocalChecked()
+            ->BooleanValue(env.local())
+            .FromJust());
+  CHECK(v8_compile("(p.y == 13)")
+            ->Run(env.local())
+            .ToLocalChecked()
+            ->BooleanValue(env.local())
+            .FromJust());
   Local<v8::FunctionTemplate> fun2 = v8::FunctionTemplate::New(isolate);
   fun2->PrototypeTemplate()->Set(isolate, "nirk", v8_num(123));
   Local<ObjectTemplate> templ2 = fun2->InstanceTemplate();
   templ2->Set(isolate, "a", v8_num(12));
   templ2->Set(isolate, "b", templ1);
-  Local<v8::Object> instance2 = templ2->NewInstance();
-  env->Global()->Set(v8_str("q"), instance2);
-  CHECK(v8_compile("(q.nirk == 123)")->Run()->BooleanValue());
-  CHECK(v8_compile("(q.a == 12)")->Run()->BooleanValue());
-  CHECK(v8_compile("(q.b.x == 10)")->Run()->BooleanValue());
-  CHECK(v8_compile("(q.b.y == 13)")->Run()->BooleanValue());
+  Local<v8::Object> instance2 =
+      templ2->NewInstance(env.local()).ToLocalChecked();
+  CHECK(env->Global()->Set(env.local(), v8_str("q"), instance2).FromJust());
+  CHECK(v8_compile("(q.nirk == 123)")
+            ->Run(env.local())
+            .ToLocalChecked()
+            ->BooleanValue(env.local())
+            .FromJust());
+  CHECK(v8_compile("(q.a == 12)")
+            ->Run(env.local())
+            .ToLocalChecked()
+            ->BooleanValue(env.local())
+            .FromJust());
+  CHECK(v8_compile("(q.b.x == 10)")
+            ->Run(env.local())
+            .ToLocalChecked()
+            ->BooleanValue(env.local())
+            .FromJust());
+  CHECK(v8_compile("(q.b.y == 13)")
+            ->Run(env.local())
+            .ToLocalChecked()
+            ->BooleanValue(env.local())
+            .FromJust());
 }
 
 
 static void GetFlabby(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   args.GetReturnValue().Set(v8_num(17.2));
 }
 
 
 static void GetKnurd(Local<String> property,
                      const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   info.GetReturnValue().Set(v8_num(15.2));
 }
 
 
 THREADED_TEST(DescriptorInheritance) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::FunctionTemplate> super = v8::FunctionTemplate::New(isolate);
+  v8::Local<v8::FunctionTemplate> super = v8::FunctionTemplate::New(isolate);
   super->PrototypeTemplate()->Set(isolate, "flabby",
                                   v8::FunctionTemplate::New(isolate,
                                                             GetFlabby));
   super->PrototypeTemplate()->Set(isolate, "PI", v8_num(3.14));
 
   super->InstanceTemplate()->SetAccessor(v8_str("knurd"), GetKnurd);
 
-  v8::Handle<v8::FunctionTemplate> base1 = v8::FunctionTemplate::New(isolate);
+  v8::Local<v8::FunctionTemplate> base1 = v8::FunctionTemplate::New(isolate);
   base1->Inherit(super);
   base1->PrototypeTemplate()->Set(isolate, "v1", v8_num(20.1));
 
-  v8::Handle<v8::FunctionTemplate> base2 = v8::FunctionTemplate::New(isolate);
+  v8::Local<v8::FunctionTemplate> base2 = v8::FunctionTemplate::New(isolate);
   base2->Inherit(super);
   base2->PrototypeTemplate()->Set(isolate, "v2", v8_num(10.1));
 
   LocalContext env;
 
-  env->Global()->Set(v8_str("s"), super->GetFunction());
-  env->Global()->Set(v8_str("base1"), base1->GetFunction());
-  env->Global()->Set(v8_str("base2"), base2->GetFunction());
+  CHECK(env->Global()
+            ->Set(env.local(), v8_str("s"),
+                  super->GetFunction(env.local()).ToLocalChecked())
+            .FromJust());
+  CHECK(env->Global()
+            ->Set(env.local(), v8_str("base1"),
+                  base1->GetFunction(env.local()).ToLocalChecked())
+            .FromJust());
+  CHECK(env->Global()
+            ->Set(env.local(), v8_str("base2"),
+                  base2->GetFunction(env.local()).ToLocalChecked())
+            .FromJust());
 
   // Checks right __proto__ chain.
-  CHECK(CompileRun("base1.prototype.__proto__ == s.prototype")->BooleanValue());
-  CHECK(CompileRun("base2.prototype.__proto__ == s.prototype")->BooleanValue());
+  CHECK(CompileRun("base1.prototype.__proto__ == s.prototype")
+            ->BooleanValue(env.local())
+            .FromJust());
+  CHECK(CompileRun("base2.prototype.__proto__ == s.prototype")
+            ->BooleanValue(env.local())
+            .FromJust());
 
-  CHECK(v8_compile("s.prototype.PI == 3.14")->Run()->BooleanValue());
+  CHECK(v8_compile("s.prototype.PI == 3.14")
+            ->Run(env.local())
+            .ToLocalChecked()
+            ->BooleanValue(env.local())
+            .FromJust());
 
   // Instance accessor should not be visible on function object or its prototype
-  CHECK(CompileRun("s.knurd == undefined")->BooleanValue());
-  CHECK(CompileRun("s.prototype.knurd == undefined")->BooleanValue());
-  CHECK(CompileRun("base1.prototype.knurd == undefined")->BooleanValue());
+  CHECK(
+      CompileRun("s.knurd == undefined")->BooleanValue(env.local()).FromJust());
+  CHECK(CompileRun("s.prototype.knurd == undefined")
+            ->BooleanValue(env.local())
+            .FromJust());
+  CHECK(CompileRun("base1.prototype.knurd == undefined")
+            ->BooleanValue(env.local())
+            .FromJust());
 
-  env->Global()->Set(v8_str("obj"),
-                     base1->GetFunction()->NewInstance());
-  CHECK_EQ(17.2, v8_compile("obj.flabby()")->Run()->NumberValue());
-  CHECK(v8_compile("'flabby' in obj")->Run()->BooleanValue());
-  CHECK_EQ(15.2, v8_compile("obj.knurd")->Run()->NumberValue());
-  CHECK(v8_compile("'knurd' in obj")->Run()->BooleanValue());
-  CHECK_EQ(20.1, v8_compile("obj.v1")->Run()->NumberValue());
+  CHECK(env->Global()
+            ->Set(env.local(), v8_str("obj"), base1->GetFunction(env.local())
+                                                  .ToLocalChecked()
+                                                  ->NewInstance(env.local())
+                                                  .ToLocalChecked())
+            .FromJust());
+  CHECK_EQ(17.2, v8_compile("obj.flabby()")
+                     ->Run(env.local())
+                     .ToLocalChecked()
+                     ->NumberValue(env.local())
+                     .FromJust());
+  CHECK(v8_compile("'flabby' in obj")
+            ->Run(env.local())
+            .ToLocalChecked()
+            ->BooleanValue(env.local())
+            .FromJust());
+  CHECK_EQ(15.2, v8_compile("obj.knurd")
+                     ->Run(env.local())
+                     .ToLocalChecked()
+                     ->NumberValue(env.local())
+                     .FromJust());
+  CHECK(v8_compile("'knurd' in obj")
+            ->Run(env.local())
+            .ToLocalChecked()
+            ->BooleanValue(env.local())
+            .FromJust());
+  CHECK_EQ(20.1, v8_compile("obj.v1")
+                     ->Run(env.local())
+                     .ToLocalChecked()
+                     ->NumberValue(env.local())
+                     .FromJust());
 
-  env->Global()->Set(v8_str("obj2"),
-                     base2->GetFunction()->NewInstance());
-  CHECK_EQ(17.2, v8_compile("obj2.flabby()")->Run()->NumberValue());
-  CHECK(v8_compile("'flabby' in obj2")->Run()->BooleanValue());
-  CHECK_EQ(15.2, v8_compile("obj2.knurd")->Run()->NumberValue());
-  CHECK(v8_compile("'knurd' in obj2")->Run()->BooleanValue());
-  CHECK_EQ(10.1, v8_compile("obj2.v2")->Run()->NumberValue());
+  CHECK(env->Global()
+            ->Set(env.local(), v8_str("obj2"), base2->GetFunction(env.local())
+                                                   .ToLocalChecked()
+                                                   ->NewInstance(env.local())
+                                                   .ToLocalChecked())
+            .FromJust());
+  CHECK_EQ(17.2, v8_compile("obj2.flabby()")
+                     ->Run(env.local())
+                     .ToLocalChecked()
+                     ->NumberValue(env.local())
+                     .FromJust());
+  CHECK(v8_compile("'flabby' in obj2")
+            ->Run(env.local())
+            .ToLocalChecked()
+            ->BooleanValue(env.local())
+            .FromJust());
+  CHECK_EQ(15.2, v8_compile("obj2.knurd")
+                     ->Run(env.local())
+                     .ToLocalChecked()
+                     ->NumberValue(env.local())
+                     .FromJust());
+  CHECK(v8_compile("'knurd' in obj2")
+            ->Run(env.local())
+            .ToLocalChecked()
+            ->BooleanValue(env.local())
+            .FromJust());
+  CHECK_EQ(10.1, v8_compile("obj2.v2")
+                     ->Run(env.local())
+                     .ToLocalChecked()
+                     ->NumberValue(env.local())
+                     .FromJust());
 
   // base1 and base2 cannot cross reference to each's prototype
-  CHECK(v8_compile("obj.v2")->Run()->IsUndefined());
-  CHECK(v8_compile("obj2.v1")->Run()->IsUndefined());
+  CHECK(v8_compile("obj.v2")->Run(env.local()).ToLocalChecked()->IsUndefined());
+  CHECK(
+      v8_compile("obj2.v1")->Run(env.local()).ToLocalChecked()->IsUndefined());
 }
 
 
 // Helper functions for Interceptor/Accessor interaction tests
 
 void SimpleAccessorGetter(Local<String> name,
                           const v8::PropertyCallbackInfo<v8::Value>& info) {
-  Handle<Object> self = Handle<Object>::Cast(info.This());
-  info.GetReturnValue().Set(
-      self->Get(String::Concat(v8_str("accessor_"), name)));
+  Local<Object> self = Local<Object>::Cast(info.This());
+  info.GetReturnValue().Set(self->Get(info.GetIsolate()->GetCurrentContext(),
+                                      String::Concat(v8_str("accessor_"), name))
+                                .ToLocalChecked());
 }
 
 void SimpleAccessorSetter(Local<String> name, Local<Value> value,
                           const v8::PropertyCallbackInfo<void>& info) {
-  Handle<Object> self = Handle<Object>::Cast(info.This());
-  self->Set(String::Concat(v8_str("accessor_"), name), value);
+  Local<Object> self = Local<Object>::Cast(info.This());
+  CHECK(self->Set(info.GetIsolate()->GetCurrentContext(),
+                  String::Concat(v8_str("accessor_"), name), value)
+            .FromJust());
 }
 
 void SymbolAccessorGetter(Local<Name> name,
                           const v8::PropertyCallbackInfo<v8::Value>& info) {
   CHECK(name->IsSymbol());
   Local<Symbol> sym = Local<Symbol>::Cast(name);
   if (sym->Name()->IsUndefined())
     return;
   SimpleAccessorGetter(Local<String>::Cast(sym->Name()), info);
 }
@@ skipping 35 matching lines @@
   i::Handle<i::String> name(v8::Utils::OpenHandle(*v8_str("length")));
   i::LookupIterator it(a, name, i::LookupIterator::OWN_SKIP_INTERCEPTOR);
   CHECK_EQ(i::LookupIterator::ACCESSOR, it.state());
   CHECK(it.GetAccessors()->IsExecutableAccessorInfo());
 }
 
 
 THREADED_TEST(UndefinedIsNotEnumerable) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::Handle<Value> result = CompileRun("this.propertyIsEnumerable(undefined)");
+  v8::Local<Value> result = CompileRun("this.propertyIsEnumerable(undefined)");
   CHECK(result->IsFalse());
 }
 
 
-v8::Handle<Script> call_recursively_script;
+v8::Local<Script> call_recursively_script;
 static const int kTargetRecursionDepth = 150;  // near maximum
 
 
 static void CallScriptRecursivelyCall(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
-  int depth = args.This()->Get(v8_str("depth"))->Int32Value();
+  v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
+  int depth = args.This()
+                  ->Get(context, v8_str("depth"))
+                  .ToLocalChecked()
+                  ->Int32Value(context)
+                  .FromJust();
   if (depth == kTargetRecursionDepth) return;
-  args.This()->Set(v8_str("depth"),
-                   v8::Integer::New(args.GetIsolate(), depth + 1));
-  args.GetReturnValue().Set(call_recursively_script->Run());
+  CHECK(args.This()
+            ->Set(context, v8_str("depth"),
+                  v8::Integer::New(args.GetIsolate(), depth + 1))
+            .FromJust());
+  args.GetReturnValue().Set(
+      call_recursively_script->Run(context).ToLocalChecked());
 }
 
 
 static void CallFunctionRecursivelyCall(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
-  int depth = args.This()->Get(v8_str("depth"))->Int32Value();
+  v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
+  int depth = args.This()
+                  ->Get(context, v8_str("depth"))
+                  .ToLocalChecked()
+                  ->Int32Value(context)
+                  .FromJust();
   if (depth == kTargetRecursionDepth) {
     printf("[depth = %d]\n", depth);
     return;
   }
-  args.This()->Set(v8_str("depth"),
-                   v8::Integer::New(args.GetIsolate(), depth + 1));
-  v8::Handle<Value> function =
-      args.This()->Get(v8_str("callFunctionRecursively"));
-  args.GetReturnValue().Set(
-      function.As<Function>()->Call(args.This(), 0, NULL));
+  CHECK(args.This()
+            ->Set(context, v8_str("depth"),
+                  v8::Integer::New(args.GetIsolate(), depth + 1))
+            .FromJust());
+  v8::Local<Value> function =
+      args.This()
+          ->Get(context, v8_str("callFunctionRecursively"))
+          .ToLocalChecked();
+  args.GetReturnValue().Set(function.As<Function>()
+                                ->Call(context, args.This(), 0, NULL)
+                                .ToLocalChecked());
 }
 
 
 THREADED_TEST(DeepCrossLanguageRecursion) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::ObjectTemplate> global = ObjectTemplate::New(isolate);
+  v8::Local<v8::ObjectTemplate> global = ObjectTemplate::New(isolate);
   global->Set(v8_str("callScriptRecursively"),
               v8::FunctionTemplate::New(isolate, CallScriptRecursivelyCall));
   global->Set(v8_str("callFunctionRecursively"),
               v8::FunctionTemplate::New(isolate, CallFunctionRecursivelyCall));
   LocalContext env(NULL, global);
 
-  env->Global()->Set(v8_str("depth"), v8::Integer::New(isolate, 0));
+  CHECK(env->Global()
+            ->Set(env.local(), v8_str("depth"), v8::Integer::New(isolate, 0))
+            .FromJust());
   call_recursively_script = v8_compile("callScriptRecursively()");
-  call_recursively_script->Run();
-  call_recursively_script = v8::Handle<Script>();
+  call_recursively_script->Run(env.local()).ToLocalChecked();
+  call_recursively_script = v8::Local<Script>();
 
-  env->Global()->Set(v8_str("depth"), v8::Integer::New(isolate, 0));
+  CHECK(env->Global()
+            ->Set(env.local(), v8_str("depth"), v8::Integer::New(isolate, 0))
+            .FromJust());
   CompileRun("callFunctionRecursively()");
 }
 
 
 static void ThrowingPropertyHandlerGet(
     Local<Name> key, const v8::PropertyCallbackInfo<v8::Value>& info) {
   // Since this interceptor is used on "with" objects, the runtime will look up
   // @@unscopables.  Punt.
   if (key->IsSymbol()) return;
   ApiTestFuzzer::Fuzz();
   info.GetReturnValue().Set(info.GetIsolate()->ThrowException(key));
 }
 
 
 static void ThrowingPropertyHandlerSet(
     Local<Name> key, Local<Value>,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   info.GetIsolate()->ThrowException(key);
   info.GetReturnValue().SetUndefined();  // not the same as empty handle
 }
 
 
 THREADED_TEST(CallbackExceptionRegression) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New(isolate);
+  v8::Local<v8::ObjectTemplate> obj = ObjectTemplate::New(isolate);
   obj->SetHandler(v8::NamedPropertyHandlerConfiguration(
       ThrowingPropertyHandlerGet, ThrowingPropertyHandlerSet));
   LocalContext env;
-  env->Global()->Set(v8_str("obj"), obj->NewInstance());
-  v8::Handle<Value> otto =
+  CHECK(env->Global()
+            ->Set(env.local(), v8_str("obj"),
+                  obj->NewInstance(env.local()).ToLocalChecked())
+            .FromJust());
+  v8::Local<Value> otto =
       CompileRun("try { with (obj) { otto; } } catch (e) { e; }");
-  CHECK(v8_str("otto")->Equals(otto));
-  v8::Handle<Value> netto =
+  CHECK(v8_str("otto")->Equals(env.local(), otto).FromJust());
+  v8::Local<Value> netto =
       CompileRun("try { with (obj) { netto = 4; } } catch (e) { e; }");
-  CHECK(v8_str("netto")->Equals(netto));
+  CHECK(v8_str("netto")->Equals(env.local(), netto).FromJust());
 }
 
 
 THREADED_TEST(FunctionPrototype) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<v8::FunctionTemplate> Foo = v8::FunctionTemplate::New(isolate);
   Foo->PrototypeTemplate()->Set(v8_str("plak"), v8_num(321));
   LocalContext env;
-  env->Global()->Set(v8_str("Foo"), Foo->GetFunction());
+  CHECK(env->Global()
+            ->Set(env.local(), v8_str("Foo"),
+                  Foo->GetFunction(env.local()).ToLocalChecked())
+            .FromJust());
   Local<Script> script = v8_compile("Foo.prototype.plak");
-  CHECK_EQ(script->Run()->Int32Value(), 321);
+  CHECK_EQ(v8_run_int32value(script), 321);
 }
 
 
 THREADED_TEST(InternalFields) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New(isolate);
   Local<v8::ObjectTemplate> instance_templ = templ->InstanceTemplate();
   instance_templ->SetInternalFieldCount(1);
-  Local<v8::Object> obj = templ->GetFunction()->NewInstance();
+  Local<v8::Object> obj = templ->GetFunction(env.local())
+                              .ToLocalChecked()
+                              ->NewInstance(env.local())
+                              .ToLocalChecked();
   CHECK_EQ(1, obj->InternalFieldCount());
   CHECK(obj->GetInternalField(0)->IsUndefined());
   obj->SetInternalField(0, v8_num(17));
-  CHECK_EQ(17, obj->GetInternalField(0)->Int32Value());
+  CHECK_EQ(17, obj->GetInternalField(0)->Int32Value(env.local()).FromJust());
 }
 
 
 THREADED_TEST(GlobalObjectInternalFields) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<v8::ObjectTemplate> global_template = v8::ObjectTemplate::New(isolate);
   global_template->SetInternalFieldCount(1);
   LocalContext env(NULL, global_template);
-  v8::Handle<v8::Object> global_proxy = env->Global();
-  v8::Handle<v8::Object> global = global_proxy->GetPrototype().As<v8::Object>();
+  v8::Local<v8::Object> global_proxy = env->Global();
+  v8::Local<v8::Object> global = global_proxy->GetPrototype().As<v8::Object>();
   CHECK_EQ(1, global->InternalFieldCount());
   CHECK(global->GetInternalField(0)->IsUndefined());
   global->SetInternalField(0, v8_num(17));
-  CHECK_EQ(17, global->GetInternalField(0)->Int32Value());
+  CHECK_EQ(17, global->GetInternalField(0)->Int32Value(env.local()).FromJust());
 }
 
 
 THREADED_TEST(GlobalObjectHasRealIndexedProperty) {
   LocalContext env;
   v8::HandleScope scope(CcTest::isolate());
 
   v8::Local<v8::Object> global = env->Global();
-  global->Set(0, v8::String::NewFromUtf8(CcTest::isolate(), "value"));
-  CHECK(global->HasRealIndexedProperty(0));
+  CHECK(global->Set(env.local(), 0, v8_str("value")).FromJust());
+  CHECK(global->HasRealIndexedProperty(env.local(), 0).FromJust());
 }
 
 
-static void CheckAlignedPointerInInternalField(Handle<v8::Object> obj,
+static void CheckAlignedPointerInInternalField(Local<v8::Object> obj,
                                                void* value) {
   CHECK_EQ(0, static_cast<int>(reinterpret_cast<uintptr_t>(value) & 0x1));
   obj->SetAlignedPointerInInternalField(0, value);
   CcTest::heap()->CollectAllGarbage();
   CHECK_EQ(value, obj->GetAlignedPointerFromInternalField(0));
 }
 
 
 THREADED_TEST(InternalFieldsAlignedPointers) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New(isolate);
   Local<v8::ObjectTemplate> instance_templ = templ->InstanceTemplate();
   instance_templ->SetInternalFieldCount(1);
-  Local<v8::Object> obj = templ->GetFunction()->NewInstance();
+  Local<v8::Object> obj = templ->GetFunction(env.local())
+                              .ToLocalChecked()
+                              ->NewInstance(env.local())
+                              .ToLocalChecked();
   CHECK_EQ(1, obj->InternalFieldCount());
 
   CheckAlignedPointerInInternalField(obj, NULL);
 
   int* heap_allocated = new int[100];
   CheckAlignedPointerInInternalField(obj, heap_allocated);
   delete[] heap_allocated;
 
   int stack_allocated[100];
   CheckAlignedPointerInInternalField(obj, stack_allocated);
@@ skipping 42 matching lines @@
     env->SetAlignedPointerInEmbedderData(i, AlignedTestPointer(i));
   }
   CcTest::heap()->CollectAllGarbage();
   for (int i = 0; i < 100; i++) {
     CHECK_EQ(AlignedTestPointer(i), env->GetAlignedPointerFromEmbedderData(i));
   }
 }
 
 
 static void CheckEmbedderData(LocalContext* env, int index,
-                              v8::Handle<Value> data) {
+                              v8::Local<Value> data) {
   (*env)->SetEmbedderData(index, data);
   CHECK((*env)->GetEmbedderData(index)->StrictEquals(data));
 }
 
 
 THREADED_TEST(EmbedderData) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
-  CheckEmbedderData(
-      &env, 3, v8::String::NewFromUtf8(isolate, "The quick brown fox jumps"));
-  CheckEmbedderData(&env, 2,
-                    v8::String::NewFromUtf8(isolate, "over the lazy dog."));
+  CheckEmbedderData(&env, 3, v8_str("The quick brown fox jumps"));
+  CheckEmbedderData(&env, 2, v8_str("over the lazy dog."));
   CheckEmbedderData(&env, 1, v8::Number::New(isolate, 1.2345));
   CheckEmbedderData(&env, 0, v8::Boolean::New(isolate, true));
 }
 
 
+// TODO(vogelheim): Does this test even make sense in a post-deprecation world?
+/*
 THREADED_TEST(GetIsolate) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   Local<v8::Object> obj = v8::Object::New(isolate);
   CHECK_EQ(isolate, obj->GetIsolate());
   CHECK_EQ(isolate, CcTest::global()->GetIsolate());
 }
+*/
 
 
 THREADED_TEST(IdentityHash) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   // Ensure that the test starts with an fresh heap to test whether the hash
   // code is based on the address.
   CcTest::heap()->CollectAllGarbage();
@@ skipping 32 matching lines @@
     CHECK_NE(o1->GetIdentityHash(), o2->GetIdentityHash());
   }
 }
 
 
 void GlobalProxyIdentityHash(bool set_in_js) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   v8::HandleScope scope(isolate);
-  Handle<Object> global_proxy = env->Global();
+  Local<Object> global_proxy = env->Global();
   i::Handle<i::Object> i_global_proxy = v8::Utils::OpenHandle(*global_proxy);
-  env->Global()->Set(v8_str("global"), global_proxy);
+  CHECK(env->Global()
+            ->Set(env.local(), v8_str("global"), global_proxy)
+            .FromJust());
   i::Handle<i::Object> original_hash;
   if (set_in_js) {
     CompileRun("var m = new Set(); m.add(global);");
     original_hash = i::Handle<i::Object>(i_global_proxy->GetHash(), i_isolate);
   } else {
     original_hash = i::Handle<i::Object>(
         i::Object::GetOrCreateHash(i_isolate, i_global_proxy));
   }
   CHECK(original_hash->IsSmi());
   int32_t hash1 = i::Handle<i::Smi>::cast(original_hash)->value();
   // Hash should be retained after being detached.
   env->DetachGlobal();
   int hash2 = global_proxy->GetIdentityHash();
   CHECK_EQ(hash1, hash2);
   {
     // Re-attach global proxy to a new context, hash should stay the same.
-    LocalContext env2(NULL, Handle<ObjectTemplate>(), global_proxy);
+    LocalContext env2(NULL, Local<ObjectTemplate>(), global_proxy);
     int hash3 = global_proxy->GetIdentityHash();
     CHECK_EQ(hash1, hash3);
   }
 }
 
 
 THREADED_TEST(GlobalProxyIdentityHash) {
   GlobalProxyIdentityHash(true);
   GlobalProxyIdentityHash(false);
 }
 
 
 TEST(SymbolIdentityHash) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   {
     Local<v8::Symbol> symbol = v8::Symbol::New(isolate);
     int hash = symbol->GetIdentityHash();
     int hash1 = symbol->GetIdentityHash();
     CHECK_EQ(hash, hash1);
     CcTest::heap()->CollectAllGarbage();
     int hash3 = symbol->GetIdentityHash();
     CHECK_EQ(hash, hash3);
   }
 
   {
-    v8::Handle<v8::Symbol> js_symbol =
+    v8::Local<v8::Symbol> js_symbol =
         CompileRun("Symbol('foo')").As<v8::Symbol>();
     int hash = js_symbol->GetIdentityHash();
     int hash1 = js_symbol->GetIdentityHash();
     CHECK_EQ(hash, hash1);
     CcTest::heap()->CollectAllGarbage();
     int hash3 = js_symbol->GetIdentityHash();
     CHECK_EQ(hash, hash3);
   }
 }
 
 
 TEST(StringIdentityHash) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
-  Local<v8::String> str = v8::String::NewFromUtf8(isolate, "str1");
+  Local<v8::String> str = v8_str("str1");
   int hash = str->GetIdentityHash();
   int hash1 = str->GetIdentityHash();
   CHECK_EQ(hash, hash1);
   CcTest::heap()->CollectAllGarbage();
   int hash3 = str->GetIdentityHash();
   CHECK_EQ(hash, hash3);
 
-  Local<v8::String> str2 = v8::String::NewFromUtf8(isolate, "str1");
+  Local<v8::String> str2 = v8_str("str1");
   int hash4 = str2->GetIdentityHash();
   CHECK_EQ(hash, hash4);
 }
 
 
 THREADED_TEST(SymbolProperties) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   v8::Local<v8::Object> obj = v8::Object::New(isolate);
   v8::Local<v8::Symbol> sym1 = v8::Symbol::New(isolate);
   v8::Local<v8::Symbol> sym2 = v8::Symbol::New(isolate, v8_str("my-symbol"));
   v8::Local<v8::Symbol> sym3 = v8::Symbol::New(isolate, v8_str("sym3"));
 
   CcTest::heap()->CollectAllGarbage();
 
   // Check basic symbol functionality.
   CHECK(sym1->IsSymbol());
   CHECK(sym2->IsSymbol());
   CHECK(!obj->IsSymbol());
 
-  CHECK(sym1->Equals(sym1));
-  CHECK(sym2->Equals(sym2));
-  CHECK(!sym1->Equals(sym2));
-  CHECK(!sym2->Equals(sym1));
+  CHECK(sym1->Equals(env.local(), sym1).FromJust());
+  CHECK(sym2->Equals(env.local(), sym2).FromJust());
+  CHECK(!sym1->Equals(env.local(), sym2).FromJust());
+  CHECK(!sym2->Equals(env.local(), sym1).FromJust());
   CHECK(sym1->StrictEquals(sym1));
   CHECK(sym2->StrictEquals(sym2));
   CHECK(!sym1->StrictEquals(sym2));
   CHECK(!sym2->StrictEquals(sym1));
 
-  CHECK(sym2->Name()->Equals(v8_str("my-symbol")));
+  CHECK(sym2->Name()->Equals(env.local(), v8_str("my-symbol")).FromJust());
 
   v8::Local<v8::Value> sym_val = sym2;
   CHECK(sym_val->IsSymbol());
-  CHECK(sym_val->Equals(sym2));
+  CHECK(sym_val->Equals(env.local(), sym2).FromJust());
   CHECK(sym_val->StrictEquals(sym2));
-  CHECK(v8::Symbol::Cast(*sym_val)->Equals(sym2));
+  CHECK(v8::Symbol::Cast(*sym_val)->Equals(env.local(), sym2).FromJust());
 
   v8::Local<v8::Value> sym_obj = v8::SymbolObject::New(isolate, sym2);
   CHECK(sym_obj->IsSymbolObject());
   CHECK(!sym2->IsSymbolObject());
   CHECK(!obj->IsSymbolObject());
-  CHECK(sym_obj->Equals(sym2));
+  CHECK(sym_obj->Equals(env.local(), sym2).FromJust());
   CHECK(!sym_obj->StrictEquals(sym2));
-  CHECK(v8::SymbolObject::Cast(*sym_obj)->Equals(sym_obj));
-  CHECK(v8::SymbolObject::Cast(*sym_obj)->ValueOf()->Equals(sym2));
+  CHECK(v8::SymbolObject::Cast(*sym_obj)
+            ->Equals(env.local(), sym_obj)
+            .FromJust());
+  CHECK(v8::SymbolObject::Cast(*sym_obj)
+            ->ValueOf()
+            ->Equals(env.local(), sym2)
+            .FromJust());
 
   // Make sure delete of a non-existent symbol property works.
-  CHECK(obj->Delete(sym1));
-  CHECK(!obj->Has(sym1));
+  CHECK(obj->Delete(env.local(), sym1).FromJust());
+  CHECK(!obj->Has(env.local(), sym1).FromJust());
 
-  CHECK(obj->Set(sym1, v8::Integer::New(isolate, 1503)));
-  CHECK(obj->Has(sym1));
-  CHECK_EQ(1503, obj->Get(sym1)->Int32Value());
-  CHECK(obj->Set(sym1, v8::Integer::New(isolate, 2002)));
-  CHECK(obj->Has(sym1));
-  CHECK_EQ(2002, obj->Get(sym1)->Int32Value());
-  CHECK_EQ(v8::None, obj->GetPropertyAttributes(sym1));
+  CHECK(
+      obj->Set(env.local(), sym1, v8::Integer::New(isolate, 1503)).FromJust());
+  CHECK(obj->Has(env.local(), sym1).FromJust());
+  CHECK_EQ(1503, obj->Get(env.local(), sym1)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
+  CHECK(
+      obj->Set(env.local(), sym1, v8::Integer::New(isolate, 2002)).FromJust());
+  CHECK(obj->Has(env.local(), sym1).FromJust());
+  CHECK_EQ(2002, obj->Get(env.local(), sym1)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
+  CHECK_EQ(v8::None, obj->GetPropertyAttributes(env.local(), sym1).FromJust());
 
-  CHECK_EQ(0u, obj->GetOwnPropertyNames()->Length());
-  unsigned num_props = obj->GetPropertyNames()->Length();
-  CHECK(obj->Set(v8::String::NewFromUtf8(isolate, "bla"),
-                 v8::Integer::New(isolate, 20)));
-  CHECK_EQ(1u, obj->GetOwnPropertyNames()->Length());
-  CHECK_EQ(num_props + 1, obj->GetPropertyNames()->Length());
+  CHECK_EQ(0u,
+           obj->GetOwnPropertyNames(env.local()).ToLocalChecked()->Length());
+  unsigned num_props =
+      obj->GetPropertyNames(env.local()).ToLocalChecked()->Length();
+  CHECK(obj->Set(env.local(), v8_str("bla"), v8::Integer::New(isolate, 20))
+            .FromJust());
+  CHECK_EQ(1u,
+           obj->GetOwnPropertyNames(env.local()).ToLocalChecked()->Length());
+  CHECK_EQ(num_props + 1,
+           obj->GetPropertyNames(env.local()).ToLocalChecked()->Length());
 
   CcTest::heap()->CollectAllGarbage();
 
-  CHECK(obj->SetAccessor(sym3, SymbolAccessorGetter, SymbolAccessorSetter));
-  CHECK(obj->Get(sym3)->IsUndefined());
-  CHECK(obj->Set(sym3, v8::Integer::New(isolate, 42)));
-  CHECK(obj->Get(sym3)->Equals(v8::Integer::New(isolate, 42)));
-  CHECK(obj->Get(v8::String::NewFromUtf8(isolate, "accessor_sym3"))
-            ->Equals(v8::Integer::New(isolate, 42)));
+  CHECK(obj->SetAccessor(env.local(), sym3, SymbolAccessorGetter,
+                         SymbolAccessorSetter)
+            .FromJust());
+  CHECK(obj->Get(env.local(), sym3).ToLocalChecked()->IsUndefined());
+  CHECK(obj->Set(env.local(), sym3, v8::Integer::New(isolate, 42)).FromJust());
+  CHECK(obj->Get(env.local(), sym3)
+            .ToLocalChecked()
+            ->Equals(env.local(), v8::Integer::New(isolate, 42))
+            .FromJust());
+  CHECK(obj->Get(env.local(), v8_str("accessor_sym3"))
+            .ToLocalChecked()
+            ->Equals(env.local(), v8::Integer::New(isolate, 42))
+            .FromJust());
 
   // Add another property and delete it afterwards to force the object in
   // slow case.
-  CHECK(obj->Set(sym2, v8::Integer::New(isolate, 2008)));
-  CHECK_EQ(2002, obj->Get(sym1)->Int32Value());
-  CHECK_EQ(2008, obj->Get(sym2)->Int32Value());
-  CHECK_EQ(2002, obj->Get(sym1)->Int32Value());
-  CHECK_EQ(2u, obj->GetOwnPropertyNames()->Length());
+  CHECK(
+      obj->Set(env.local(), sym2, v8::Integer::New(isolate, 2008)).FromJust());
+  CHECK_EQ(2002, obj->Get(env.local(), sym1)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
+  CHECK_EQ(2008, obj->Get(env.local(), sym2)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
+  CHECK_EQ(2002, obj->Get(env.local(), sym1)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
+  CHECK_EQ(2u,
+           obj->GetOwnPropertyNames(env.local()).ToLocalChecked()->Length());
 
-  CHECK(obj->Has(sym1));
-  CHECK(obj->Has(sym2));
-  CHECK(obj->Has(sym3));
-  CHECK(obj->Has(v8::String::NewFromUtf8(isolate, "accessor_sym3")));
-  CHECK(obj->Delete(sym2));
-  CHECK(obj->Has(sym1));
-  CHECK(!obj->Has(sym2));
-  CHECK(obj->Has(sym3));
-  CHECK(obj->Has(v8::String::NewFromUtf8(isolate, "accessor_sym3")));
-  CHECK_EQ(2002, obj->Get(sym1)->Int32Value());
-  CHECK(obj->Get(sym3)->Equals(v8::Integer::New(isolate, 42)));
-  CHECK(obj->Get(v8::String::NewFromUtf8(isolate, "accessor_sym3"))
-            ->Equals(v8::Integer::New(isolate, 42)));
-  CHECK_EQ(2u, obj->GetOwnPropertyNames()->Length());
+  CHECK(obj->Has(env.local(), sym1).FromJust());
+  CHECK(obj->Has(env.local(), sym2).FromJust());
+  CHECK(obj->Has(env.local(), sym3).FromJust());
+  CHECK(obj->Has(env.local(), v8_str("accessor_sym3")).FromJust());
+  CHECK(obj->Delete(env.local(), sym2).FromJust());
+  CHECK(obj->Has(env.local(), sym1).FromJust());
+  CHECK(!obj->Has(env.local(), sym2).FromJust());
+  CHECK(obj->Has(env.local(), sym3).FromJust());
+  CHECK(obj->Has(env.local(), v8_str("accessor_sym3")).FromJust());
+  CHECK_EQ(2002, obj->Get(env.local(), sym1)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
+  CHECK(obj->Get(env.local(), sym3)
+            .ToLocalChecked()
+            ->Equals(env.local(), v8::Integer::New(isolate, 42))
+            .FromJust());
+  CHECK(obj->Get(env.local(), v8_str("accessor_sym3"))
+            .ToLocalChecked()
+            ->Equals(env.local(), v8::Integer::New(isolate, 42))
+            .FromJust());
+  CHECK_EQ(2u,
+           obj->GetOwnPropertyNames(env.local()).ToLocalChecked()->Length());
 
   // Symbol properties are inherited.
   v8::Local<v8::Object> child = v8::Object::New(isolate);
-  child->SetPrototype(obj);
-  CHECK(child->Has(sym1));
-  CHECK_EQ(2002, child->Get(sym1)->Int32Value());
-  CHECK(obj->Get(sym3)->Equals(v8::Integer::New(isolate, 42)));
-  CHECK(obj->Get(v8::String::NewFromUtf8(isolate, "accessor_sym3"))
-            ->Equals(v8::Integer::New(isolate, 42)));
-  CHECK_EQ(0u, child->GetOwnPropertyNames()->Length());
+  CHECK(child->SetPrototype(env.local(), obj).FromJust());
+  CHECK(child->Has(env.local(), sym1).FromJust());
+  CHECK_EQ(2002, child->Get(env.local(), sym1)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
+  CHECK(obj->Get(env.local(), sym3)
+            .ToLocalChecked()
+            ->Equals(env.local(), v8::Integer::New(isolate, 42))
+            .FromJust());
+  CHECK(obj->Get(env.local(), v8_str("accessor_sym3"))
+            .ToLocalChecked()
+            ->Equals(env.local(), v8::Integer::New(isolate, 42))
+            .FromJust());
+  CHECK_EQ(0u,
+           child->GetOwnPropertyNames(env.local()).ToLocalChecked()->Length());
 }
 
 
 THREADED_TEST(SymbolTemplateProperties) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   v8::Local<v8::FunctionTemplate> foo = v8::FunctionTemplate::New(isolate);
   v8::Local<v8::Name> name = v8::Symbol::New(isolate);
   CHECK(!name.IsEmpty());
   foo->PrototypeTemplate()->Set(name, v8::FunctionTemplate::New(isolate));
-  v8::Local<v8::Object> new_instance = foo->InstanceTemplate()->NewInstance();
+  v8::Local<v8::Object> new_instance =
+      foo->InstanceTemplate()->NewInstance(env.local()).ToLocalChecked();
   CHECK(!new_instance.IsEmpty());
-  CHECK(new_instance->Has(name));
+  CHECK(new_instance->Has(env.local(), name).FromJust());
 }
 
 
 THREADED_TEST(PrivateProperties) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   v8::Local<v8::Object> obj = v8::Object::New(isolate);
   v8::Local<v8::Private> priv1 = v8::Private::New(isolate);
   v8::Local<v8::Private> priv2 =
       v8::Private::New(isolate, v8_str("my-private"));
 
   CcTest::heap()->CollectAllGarbage();
 
-  CHECK(priv2->Name()->Equals(v8::String::NewFromUtf8(isolate, "my-private")));
+  CHECK(priv2->Name()
+            ->Equals(env.local(),
+                     v8::String::NewFromUtf8(isolate, "my-private",
+                                             v8::NewStringType::kNormal)
+                         .ToLocalChecked())
+            .FromJust());
 
   // Make sure delete of a non-existent private symbol property works.
   obj->DeletePrivate(env.local(), priv1).FromJust();
   CHECK(!obj->HasPrivate(env.local(), priv1).FromJust());
 
   CHECK(obj->SetPrivate(env.local(), priv1, v8::Integer::New(isolate, 1503))
             .FromJust());
   CHECK(obj->HasPrivate(env.local(), priv1).FromJust());
-  CHECK_EQ(1503,
-           obj->GetPrivate(env.local(), priv1).ToLocalChecked()->Int32Value());
+  CHECK_EQ(1503, obj->GetPrivate(env.local(), priv1)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
   CHECK(obj->SetPrivate(env.local(), priv1, v8::Integer::New(isolate, 2002))
             .FromJust());
   CHECK(obj->HasPrivate(env.local(), priv1).FromJust());
-  CHECK_EQ(2002,
-           obj->GetPrivate(env.local(), priv1).ToLocalChecked()->Int32Value());
+  CHECK_EQ(2002, obj->GetPrivate(env.local(), priv1)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
 
-  CHECK_EQ(0u, obj->GetOwnPropertyNames()->Length());
-  unsigned num_props = obj->GetPropertyNames()->Length();
-  CHECK(obj->Set(v8::String::NewFromUtf8(isolate, "bla"),
-                 v8::Integer::New(isolate, 20)));
-  CHECK_EQ(1u, obj->GetOwnPropertyNames()->Length());
-  CHECK_EQ(num_props + 1, obj->GetPropertyNames()->Length());
+  CHECK_EQ(0u,
+           obj->GetOwnPropertyNames(env.local()).ToLocalChecked()->Length());
+  unsigned num_props =
+      obj->GetPropertyNames(env.local()).ToLocalChecked()->Length();
+  CHECK(obj->Set(env.local(), v8::String::NewFromUtf8(
+                                  isolate, "bla", v8::NewStringType::kNormal)
+                                  .ToLocalChecked(),
+                 v8::Integer::New(isolate, 20))
+            .FromJust());
+  CHECK_EQ(1u,
+           obj->GetOwnPropertyNames(env.local()).ToLocalChecked()->Length());
+  CHECK_EQ(num_props + 1,
+           obj->GetPropertyNames(env.local()).ToLocalChecked()->Length());
 
   CcTest::heap()->CollectAllGarbage();
 
   // Add another property and delete it afterwards to force the object in
   // slow case.
   CHECK(obj->SetPrivate(env.local(), priv2, v8::Integer::New(isolate, 2008))
             .FromJust());
-  CHECK_EQ(2002,
-           obj->GetPrivate(env.local(), priv1).ToLocalChecked()->Int32Value());
-  CHECK_EQ(2008,
-           obj->GetPrivate(env.local(), priv2).ToLocalChecked()->Int32Value());
-  CHECK_EQ(2002,
-           obj->GetPrivate(env.local(), priv1).ToLocalChecked()->Int32Value());
-  CHECK_EQ(1u, obj->GetOwnPropertyNames()->Length());
+  CHECK_EQ(2002, obj->GetPrivate(env.local(), priv1)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
+  CHECK_EQ(2008, obj->GetPrivate(env.local(), priv2)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
+  CHECK_EQ(2002, obj->GetPrivate(env.local(), priv1)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
+  CHECK_EQ(1u,
+           obj->GetOwnPropertyNames(env.local()).ToLocalChecked()->Length());
 
   CHECK(obj->HasPrivate(env.local(), priv1).FromJust());
   CHECK(obj->HasPrivate(env.local(), priv2).FromJust());
   CHECK(obj->DeletePrivate(env.local(), priv2).FromJust());
   CHECK(obj->HasPrivate(env.local(), priv1).FromJust());
   CHECK(!obj->HasPrivate(env.local(), priv2).FromJust());
-  CHECK_EQ(2002,
-           obj->GetPrivate(env.local(), priv1).ToLocalChecked()->Int32Value());
-  CHECK_EQ(1u, obj->GetOwnPropertyNames()->Length());
+  CHECK_EQ(2002, obj->GetPrivate(env.local(), priv1)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
+  CHECK_EQ(1u,
+           obj->GetOwnPropertyNames(env.local()).ToLocalChecked()->Length());
 
   // Private properties are not inherited (for the time being).
   v8::Local<v8::Object> child = v8::Object::New(isolate);
-  child->SetPrototype(obj);
+  CHECK(child->SetPrototype(env.local(), obj).FromJust());
   CHECK(!child->HasPrivate(env.local(), priv1).FromJust());
-  CHECK_EQ(0u, child->GetOwnPropertyNames()->Length());
+  CHECK_EQ(0u,
+           child->GetOwnPropertyNames(env.local()).ToLocalChecked()->Length());
 }
 
 
 THREADED_TEST(GlobalSymbols) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   v8::Local<String> name = v8_str("my-symbol");
   v8::Local<v8::Symbol> glob = v8::Symbol::For(isolate, name);
   v8::Local<v8::Symbol> glob2 = v8::Symbol::For(isolate, name);
   CHECK(glob2->SameValue(glob));
 
   v8::Local<v8::Symbol> glob_api = v8::Symbol::ForApi(isolate, name);
   v8::Local<v8::Symbol> glob_api2 = v8::Symbol::ForApi(isolate, name);
   CHECK(glob_api2->SameValue(glob_api));
   CHECK(!glob_api->SameValue(glob));
 
   v8::Local<v8::Symbol> sym = v8::Symbol::New(isolate, name);
   CHECK(!sym->SameValue(glob));
 
   CompileRun("var sym2 = Symbol.for('my-symbol')");
-  v8::Local<Value> sym2 = env->Global()->Get(v8_str("sym2"));
+  v8::Local<Value> sym2 =
+      env->Global()->Get(env.local(), v8_str("sym2")).ToLocalChecked();
   CHECK(sym2->SameValue(glob));
   CHECK(!sym2->SameValue(glob_api));
 }
 
 
 static void CheckWellKnownSymbol(v8::Local<v8::Symbol>(*getter)(v8::Isolate*),
                                  const char* name) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   v8::Local<v8::Symbol> symbol = getter(isolate);
   std::string script = std::string("var sym = ") + name;
   CompileRun(script.c_str());
-  v8::Local<Value> value = env->Global()->Get(v8_str("sym"));
+  v8::Local<Value> value =
+      env->Global()->Get(env.local(), v8_str("sym")).ToLocalChecked();
 
   CHECK(!value.IsEmpty());
   CHECK(!symbol.IsEmpty());
   CHECK(value->SameValue(symbol));
 }
 
 
 THREADED_TEST(WellKnownSymbols) {
   CheckWellKnownSymbol(v8::Symbol::GetIterator, "Symbol.iterator");
   CheckWellKnownSymbol(v8::Symbol::GetUnscopables, "Symbol.unscopables");
@@ skipping 12 matching lines @@
   CHECK(obj->SetPrivate(env.local(), glob, v8::Integer::New(isolate, 3))
             .FromJust());
 
   v8::Local<v8::Private> glob2 = v8::Private::ForApi(isolate, name);
   CHECK(obj->HasPrivate(env.local(), glob2).FromJust());
 
   v8::Local<v8::Private> priv = v8::Private::New(isolate, name);
   CHECK(!obj->HasPrivate(env.local(), priv).FromJust());
 
   CompileRun("var intern = %CreatePrivateSymbol('my-private')");
-  v8::Local<Value> intern = env->Global()->Get(v8_str("intern"));
-  CHECK(!obj->Has(intern));
+  v8::Local<Value> intern =
+      env->Global()->Get(env.local(), v8_str("intern")).ToLocalChecked();
+  CHECK(!obj->Has(env.local(), intern).FromJust());
 }
 
 
 class ScopedArrayBufferContents {
  public:
   explicit ScopedArrayBufferContents(const v8::ArrayBuffer::Contents& contents)
       : contents_(contents) {}
   ~ScopedArrayBufferContents() { free(contents_.Data()); }
   void* Data() const { return contents_.Data(); }
   size_t ByteLength() const { return contents_.ByteLength(); }
 
  private:
   const v8::ArrayBuffer::Contents contents_;
 };
 
 template <typename T>
-static void CheckInternalFieldsAreZero(v8::Handle<T> value) {
+static void CheckInternalFieldsAreZero(v8::Local<T> value) {
   CHECK_EQ(T::kInternalFieldCount, value->InternalFieldCount());
   for (int i = 0; i < value->InternalFieldCount(); i++) {
-    CHECK_EQ(0, value->GetInternalField(i)->Int32Value());
+    CHECK_EQ(0, value->GetInternalField(i)
+                    ->Int32Value(CcTest::isolate()->GetCurrentContext())
+                    .FromJust());
   }
 }
 
 
 THREADED_TEST(ArrayBuffer_ApiInternalToExternal) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
   Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(isolate, 1024);
   CheckInternalFieldsAreZero(ab);
   CHECK_EQ(1024, static_cast<int>(ab->ByteLength()));
   CHECK(!ab->IsExternal());
   CcTest::heap()->CollectAllGarbage();
 
   ScopedArrayBufferContents ab_contents(ab->Externalize());
   CHECK(ab->IsExternal());
 
   CHECK_EQ(1024, static_cast<int>(ab_contents.ByteLength()));
   uint8_t* data = static_cast<uint8_t*>(ab_contents.Data());
   DCHECK(data != NULL);
-  env->Global()->Set(v8_str("ab"), ab);
+  CHECK(env->Global()->Set(env.local(), v8_str("ab"), ab).FromJust());
 
-  v8::Handle<v8::Value> result = CompileRun("ab.byteLength");
-  CHECK_EQ(1024, result->Int32Value());
+  v8::Local<v8::Value> result = CompileRun("ab.byteLength");
+  CHECK_EQ(1024, result->Int32Value(env.local()).FromJust());
 
   result = CompileRun(
       "var u8 = new Uint8Array(ab);"
       "u8[0] = 0xFF;"
       "u8[1] = 0xAA;"
       "u8.length");
-  CHECK_EQ(1024, result->Int32Value());
+  CHECK_EQ(1024, result->Int32Value(env.local()).FromJust());
   CHECK_EQ(0xFF, data[0]);
   CHECK_EQ(0xAA, data[1]);
   data[0] = 0xCC;
   data[1] = 0x11;
   result = CompileRun("u8[0] + u8[1]");
-  CHECK_EQ(0xDD, result->Int32Value());
+  CHECK_EQ(0xDD, result->Int32Value(env.local()).FromJust());
 }
 
 
 THREADED_TEST(ArrayBuffer_JSInternalToExternal) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
 
   v8::Local<v8::Value> result = CompileRun(
       "var ab1 = new ArrayBuffer(2);"
       "var u8_a = new Uint8Array(ab1);"
       "u8_a[0] = 0xAA;"
       "u8_a[1] = 0xFF; u8_a.buffer");
   Local<v8::ArrayBuffer> ab1 = Local<v8::ArrayBuffer>::Cast(result);
   CheckInternalFieldsAreZero(ab1);
   CHECK_EQ(2, static_cast<int>(ab1->ByteLength()));
   CHECK(!ab1->IsExternal());
   ScopedArrayBufferContents ab1_contents(ab1->Externalize());
   CHECK(ab1->IsExternal());
 
   result = CompileRun("ab1.byteLength");
-  CHECK_EQ(2, result->Int32Value());
+  CHECK_EQ(2, result->Int32Value(env.local()).FromJust());
   result = CompileRun("u8_a[0]");
-  CHECK_EQ(0xAA, result->Int32Value());
+  CHECK_EQ(0xAA, result->Int32Value(env.local()).FromJust());
   result = CompileRun("u8_a[1]");
-  CHECK_EQ(0xFF, result->Int32Value());
+  CHECK_EQ(0xFF, result->Int32Value(env.local()).FromJust());
   result = CompileRun(
       "var u8_b = new Uint8Array(ab1);"
       "u8_b[0] = 0xBB;"
       "u8_a[0]");
-  CHECK_EQ(0xBB, result->Int32Value());
+  CHECK_EQ(0xBB, result->Int32Value(env.local()).FromJust());
   result = CompileRun("u8_b[1]");
-  CHECK_EQ(0xFF, result->Int32Value());
+  CHECK_EQ(0xFF, result->Int32Value(env.local()).FromJust());
 
   CHECK_EQ(2, static_cast<int>(ab1_contents.ByteLength()));
   uint8_t* ab1_data = static_cast<uint8_t*>(ab1_contents.Data());
   CHECK_EQ(0xBB, ab1_data[0]);
   CHECK_EQ(0xFF, ab1_data[1]);
   ab1_data[0] = 0xCC;
   ab1_data[1] = 0x11;
   result = CompileRun("u8_a[0] + u8_a[1]");
-  CHECK_EQ(0xDD, result->Int32Value());
+  CHECK_EQ(0xDD, result->Int32Value(env.local()).FromJust());
 }
 
 
 THREADED_TEST(ArrayBuffer_External) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
   i::ScopedVector<uint8_t> my_data(100);
   memset(my_data.start(), 0, 100);
   Local<v8::ArrayBuffer> ab3 =
       v8::ArrayBuffer::New(isolate, my_data.start(), 100);
   CheckInternalFieldsAreZero(ab3);
   CHECK_EQ(100, static_cast<int>(ab3->ByteLength()));
   CHECK(ab3->IsExternal());
 
-  env->Global()->Set(v8_str("ab3"), ab3);
+  CHECK(env->Global()->Set(env.local(), v8_str("ab3"), ab3).FromJust());
 
-  v8::Handle<v8::Value> result = CompileRun("ab3.byteLength");
-  CHECK_EQ(100, result->Int32Value());
+  v8::Local<v8::Value> result = CompileRun("ab3.byteLength");
+  CHECK_EQ(100, result->Int32Value(env.local()).FromJust());
 
   result = CompileRun(
       "var u8_b = new Uint8Array(ab3);"
       "u8_b[0] = 0xBB;"
       "u8_b[1] = 0xCC;"
       "u8_b.length");
-  CHECK_EQ(100, result->Int32Value());
+  CHECK_EQ(100, result->Int32Value(env.local()).FromJust());
   CHECK_EQ(0xBB, my_data[0]);
   CHECK_EQ(0xCC, my_data[1]);
   my_data[0] = 0xCC;
   my_data[1] = 0x11;
   result = CompileRun("u8_b[0] + u8_b[1]");
-  CHECK_EQ(0xDD, result->Int32Value());
+  CHECK_EQ(0xDD, result->Int32Value(env.local()).FromJust());
 }
 
 
 THREADED_TEST(ArrayBuffer_DisableNeuter) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
   i::ScopedVector<uint8_t> my_data(100);
   memset(my_data.start(), 0, 100);
   Local<v8::ArrayBuffer> ab =
       v8::ArrayBuffer::New(isolate, my_data.start(), 100);
   CHECK(ab->IsNeuterable());
 
   i::Handle<i::JSArrayBuffer> buf = v8::Utils::OpenHandle(*ab);
   buf->set_is_neuterable(false);
 
   CHECK(!ab->IsNeuterable());
 }
 
 
-static void CheckDataViewIsNeutered(v8::Handle<v8::DataView> dv) {
+static void CheckDataViewIsNeutered(v8::Local<v8::DataView> dv) {
   CHECK_EQ(0, static_cast<int>(dv->ByteLength()));
   CHECK_EQ(0, static_cast<int>(dv->ByteOffset()));
 }
 
 
-static void CheckIsNeutered(v8::Handle<v8::TypedArray> ta) {
+static void CheckIsNeutered(v8::Local<v8::TypedArray> ta) {
   CHECK_EQ(0, static_cast<int>(ta->ByteLength()));
   CHECK_EQ(0, static_cast<int>(ta->Length()));
   CHECK_EQ(0, static_cast<int>(ta->ByteOffset()));
 }
 
 
 static void CheckIsTypedArrayVarNeutered(const char* name) {
   i::ScopedVector<char> source(1024);
   i::SNPrintF(source,
               "%s.byteLength == 0 && %s.byteOffset == 0 && %s.length == 0",
               name, name, name);
   CHECK(CompileRun(source.start())->IsTrue());
-  v8::Handle<v8::TypedArray> ta =
-      v8::Handle<v8::TypedArray>::Cast(CompileRun(name));
+  v8::Local<v8::TypedArray> ta =
+      v8::Local<v8::TypedArray>::Cast(CompileRun(name));
   CheckIsNeutered(ta);
 }
 
 
 template <typename TypedArray, int kElementSize>
-static Handle<TypedArray> CreateAndCheck(Handle<v8::ArrayBuffer> ab,
-                                         int byteOffset, int length) {
-  v8::Handle<TypedArray> ta = TypedArray::New(ab, byteOffset, length);
+static Local<TypedArray> CreateAndCheck(Local<v8::ArrayBuffer> ab,
+                                        int byteOffset, int length) {
+  v8::Local<TypedArray> ta = TypedArray::New(ab, byteOffset, length);
   CheckInternalFieldsAreZero<v8::ArrayBufferView>(ta);
   CHECK_EQ(byteOffset, static_cast<int>(ta->ByteOffset()));
   CHECK_EQ(length, static_cast<int>(ta->Length()));
   CHECK_EQ(length * kElementSize, static_cast<int>(ta->ByteLength()));
   return ta;
 }
 
 
 THREADED_TEST(ArrayBuffer_NeuteringApi) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
-  v8::Handle<v8::ArrayBuffer> buffer = v8::ArrayBuffer::New(isolate, 1024);
+  v8::Local<v8::ArrayBuffer> buffer = v8::ArrayBuffer::New(isolate, 1024);
 
-  v8::Handle<v8::Uint8Array> u8a =
+  v8::Local<v8::Uint8Array> u8a =
       CreateAndCheck<v8::Uint8Array, 1>(buffer, 1, 1023);
-  v8::Handle<v8::Uint8ClampedArray> u8c =
+  v8::Local<v8::Uint8ClampedArray> u8c =
       CreateAndCheck<v8::Uint8ClampedArray, 1>(buffer, 1, 1023);
-  v8::Handle<v8::Int8Array> i8a =
+  v8::Local<v8::Int8Array> i8a =
       CreateAndCheck<v8::Int8Array, 1>(buffer, 1, 1023);
 
-  v8::Handle<v8::Uint16Array> u16a =
+  v8::Local<v8::Uint16Array> u16a =
       CreateAndCheck<v8::Uint16Array, 2>(buffer, 2, 511);
-  v8::Handle<v8::Int16Array> i16a =
+  v8::Local<v8::Int16Array> i16a =
       CreateAndCheck<v8::Int16Array, 2>(buffer, 2, 511);
 
-  v8::Handle<v8::Uint32Array> u32a =
+  v8::Local<v8::Uint32Array> u32a =
       CreateAndCheck<v8::Uint32Array, 4>(buffer, 4, 255);
-  v8::Handle<v8::Int32Array> i32a =
+  v8::Local<v8::Int32Array> i32a =
       CreateAndCheck<v8::Int32Array, 4>(buffer, 4, 255);
 
-  v8::Handle<v8::Float32Array> f32a =
+  v8::Local<v8::Float32Array> f32a =
       CreateAndCheck<v8::Float32Array, 4>(buffer, 4, 255);
-  v8::Handle<v8::Float64Array> f64a =
+  v8::Local<v8::Float64Array> f64a =
       CreateAndCheck<v8::Float64Array, 8>(buffer, 8, 127);
 
-  v8::Handle<v8::DataView> dv = v8::DataView::New(buffer, 1, 1023);
+  v8::Local<v8::DataView> dv = v8::DataView::New(buffer, 1, 1023);
   CheckInternalFieldsAreZero<v8::ArrayBufferView>(dv);
   CHECK_EQ(1, static_cast<int>(dv->ByteOffset()));
   CHECK_EQ(1023, static_cast<int>(dv->ByteLength()));
 
   ScopedArrayBufferContents contents(buffer->Externalize());
   buffer->Neuter();
   CHECK_EQ(0, static_cast<int>(buffer->ByteLength()));
   CheckIsNeutered(u8a);
   CheckIsNeutered(u8c);
   CheckIsNeutered(i8a);
@@ skipping 18 matching lines @@
       "var u8c = new Uint8ClampedArray(ab, 1, 1023);"
       "var i8a = new Int8Array(ab, 1, 1023);"
       "var u16a = new Uint16Array(ab, 2, 511);"
       "var i16a = new Int16Array(ab, 2, 511);"
       "var u32a = new Uint32Array(ab, 4, 255);"
       "var i32a = new Int32Array(ab, 4, 255);"
       "var f32a = new Float32Array(ab, 4, 255);"
       "var f64a = new Float64Array(ab, 8, 127);"
       "var dv = new DataView(ab, 1, 1023);");
 
-  v8::Handle<v8::ArrayBuffer> ab =
+  v8::Local<v8::ArrayBuffer> ab =
       Local<v8::ArrayBuffer>::Cast(CompileRun("ab"));
 
-  v8::Handle<v8::DataView> dv =
-      v8::Handle<v8::DataView>::Cast(CompileRun("dv"));
+  v8::Local<v8::DataView> dv = v8::Local<v8::DataView>::Cast(CompileRun("dv"));
 
   ScopedArrayBufferContents contents(ab->Externalize());
   ab->Neuter();
   CHECK_EQ(0, static_cast<int>(ab->ByteLength()));
-  CHECK_EQ(0, CompileRun("ab.byteLength")->Int32Value());
+  CHECK_EQ(0, v8_run_int32value(v8_compile("ab.byteLength")));
 
   CheckIsTypedArrayVarNeutered("u8a");
   CheckIsTypedArrayVarNeutered("u8c");
   CheckIsTypedArrayVarNeutered("i8a");
   CheckIsTypedArrayVarNeutered("u16a");
   CheckIsTypedArrayVarNeutered("i16a");
   CheckIsTypedArrayVarNeutered("u32a");
   CheckIsTypedArrayVarNeutered("i32a");
   CheckIsTypedArrayVarNeutered("f32a");
   CheckIsTypedArrayVarNeutered("f64a");
@@ skipping 28 matching lines @@
   CHECK_EQ(1024, static_cast<int>(ab->ByteLength()));
   CHECK(!ab->IsExternal());
   CcTest::heap()->CollectAllGarbage();
 
   ScopedSharedArrayBufferContents ab_contents(ab->Externalize());
   CHECK(ab->IsExternal());
 
   CHECK_EQ(1024, static_cast<int>(ab_contents.ByteLength()));
   uint8_t* data = static_cast<uint8_t*>(ab_contents.Data());
   DCHECK(data != NULL);
-  env->Global()->Set(v8_str("ab"), ab);
+  CHECK(env->Global()->Set(env.local(), v8_str("ab"), ab).FromJust());
 
-  v8::Handle<v8::Value> result = CompileRun("ab.byteLength");
-  CHECK_EQ(1024, result->Int32Value());
+  v8::Local<v8::Value> result = CompileRun("ab.byteLength");
+  CHECK_EQ(1024, result->Int32Value(env.local()).FromJust());
 
   result = CompileRun(
       "var u8 = new Uint8Array(ab);"
       "u8[0] = 0xFF;"
       "u8[1] = 0xAA;"
       "u8.length");
-  CHECK_EQ(1024, result->Int32Value());
+  CHECK_EQ(1024, result->Int32Value(env.local()).FromJust());
   CHECK_EQ(0xFF, data[0]);
   CHECK_EQ(0xAA, data[1]);
   data[0] = 0xCC;
   data[1] = 0x11;
   result = CompileRun("u8[0] + u8[1]");
-  CHECK_EQ(0xDD, result->Int32Value());
+  CHECK_EQ(0xDD, result->Int32Value(env.local()).FromJust());
 }
 
 
 THREADED_TEST(SharedArrayBuffer_JSInternalToExternal) {
   i::FLAG_harmony_sharedarraybuffer = true;
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
 
   v8::Local<v8::Value> result = CompileRun(
       "var ab1 = new SharedArrayBuffer(2);"
       "var u8_a = new Uint8Array(ab1);"
       "u8_a[0] = 0xAA;"
       "u8_a[1] = 0xFF; u8_a.buffer");
   Local<v8::SharedArrayBuffer> ab1 = Local<v8::SharedArrayBuffer>::Cast(result);
   CheckInternalFieldsAreZero(ab1);
   CHECK_EQ(2, static_cast<int>(ab1->ByteLength()));
   CHECK(!ab1->IsExternal());
   ScopedSharedArrayBufferContents ab1_contents(ab1->Externalize());
   CHECK(ab1->IsExternal());
 
   result = CompileRun("ab1.byteLength");
-  CHECK_EQ(2, result->Int32Value());
+  CHECK_EQ(2, result->Int32Value(env.local()).FromJust());
   result = CompileRun("u8_a[0]");
-  CHECK_EQ(0xAA, result->Int32Value());
+  CHECK_EQ(0xAA, result->Int32Value(env.local()).FromJust());
   result = CompileRun("u8_a[1]");
-  CHECK_EQ(0xFF, result->Int32Value());
+  CHECK_EQ(0xFF, result->Int32Value(env.local()).FromJust());
   result = CompileRun(
       "var u8_b = new Uint8Array(ab1);"
       "u8_b[0] = 0xBB;"
       "u8_a[0]");
-  CHECK_EQ(0xBB, result->Int32Value());
+  CHECK_EQ(0xBB, result->Int32Value(env.local()).FromJust());
   result = CompileRun("u8_b[1]");
-  CHECK_EQ(0xFF, result->Int32Value());
+  CHECK_EQ(0xFF, result->Int32Value(env.local()).FromJust());
 
   CHECK_EQ(2, static_cast<int>(ab1_contents.ByteLength()));
   uint8_t* ab1_data = static_cast<uint8_t*>(ab1_contents.Data());
   CHECK_EQ(0xBB, ab1_data[0]);
   CHECK_EQ(0xFF, ab1_data[1]);
   ab1_data[0] = 0xCC;
   ab1_data[1] = 0x11;
   result = CompileRun("u8_a[0] + u8_a[1]");
-  CHECK_EQ(0xDD, result->Int32Value());
+  CHECK_EQ(0xDD, result->Int32Value(env.local()).FromJust());
 }
 
 
 THREADED_TEST(SharedArrayBuffer_External) {
   i::FLAG_harmony_sharedarraybuffer = true;
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
   i::ScopedVector<uint8_t> my_data(100);
   memset(my_data.start(), 0, 100);
   Local<v8::SharedArrayBuffer> ab3 =
       v8::SharedArrayBuffer::New(isolate, my_data.start(), 100);
   CheckInternalFieldsAreZero(ab3);
   CHECK_EQ(100, static_cast<int>(ab3->ByteLength()));
   CHECK(ab3->IsExternal());
 
-  env->Global()->Set(v8_str("ab3"), ab3);
+  CHECK(env->Global()->Set(env.local(), v8_str("ab3"), ab3).FromJust());
 
-  v8::Handle<v8::Value> result = CompileRun("ab3.byteLength");
-  CHECK_EQ(100, result->Int32Value());
+  v8::Local<v8::Value> result = CompileRun("ab3.byteLength");
+  CHECK_EQ(100, result->Int32Value(env.local()).FromJust());
 
   result = CompileRun(
       "var u8_b = new Uint8Array(ab3);"
       "u8_b[0] = 0xBB;"
       "u8_b[1] = 0xCC;"
       "u8_b.length");
-  CHECK_EQ(100, result->Int32Value());
+  CHECK_EQ(100, result->Int32Value(env.local()).FromJust());
   CHECK_EQ(0xBB, my_data[0]);
   CHECK_EQ(0xCC, my_data[1]);
   my_data[0] = 0xCC;
   my_data[1] = 0x11;
   result = CompileRun("u8_b[0] + u8_b[1]");
-  CHECK_EQ(0xDD, result->Int32Value());
+  CHECK_EQ(0xDD, result->Int32Value(env.local()).FromJust());
 }
 
 
 THREADED_TEST(HiddenProperties) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   v8::Local<v8::Object> obj = v8::Object::New(env->GetIsolate());
   v8::Local<v8::Private> key =
       v8::Private::ForApi(isolate, v8_str("api-test::hidden-key"));
   v8::Local<v8::String> empty = v8_str("");
   v8::Local<v8::String> prop_name = v8_str("prop_name");
 
   CcTest::heap()->CollectAllGarbage();
 
   // Make sure delete of a non-existent hidden value works
   obj->DeletePrivate(env.local(), key).FromJust();
 
   CHECK(obj->SetPrivate(env.local(), key, v8::Integer::New(isolate, 1503))
             .FromJust());
-  CHECK_EQ(1503,
-           obj->GetPrivate(env.local(), key).ToLocalChecked()->Int32Value());
+  CHECK_EQ(1503, obj->GetPrivate(env.local(), key)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
   CHECK(obj->SetPrivate(env.local(), key, v8::Integer::New(isolate, 2002))
             .FromJust());
-  CHECK_EQ(2002,
-           obj->GetPrivate(env.local(), key).ToLocalChecked()->Int32Value());
+  CHECK_EQ(2002, obj->GetPrivate(env.local(), key)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
 
   CcTest::heap()->CollectAllGarbage();
 
   // Make sure we do not find the hidden property.
-  CHECK(!obj->Has(empty));
-  CHECK_EQ(2002,
-           obj->GetPrivate(env.local(), key).ToLocalChecked()->Int32Value());
-  CHECK(obj->Get(empty)->IsUndefined());
-  CHECK_EQ(2002,
-           obj->GetPrivate(env.local(), key).ToLocalChecked()->Int32Value());
-  CHECK(obj->Set(empty, v8::Integer::New(isolate, 2003)));
-  CHECK_EQ(2002,
-           obj->GetPrivate(env.local(), key).ToLocalChecked()->Int32Value());
-  CHECK_EQ(2003, obj->Get(empty)->Int32Value());
+  CHECK(!obj->Has(env.local(), empty).FromJust());
+  CHECK_EQ(2002, obj->GetPrivate(env.local(), key)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
+  CHECK(obj->Get(env.local(), empty).ToLocalChecked()->IsUndefined());
+  CHECK_EQ(2002, obj->GetPrivate(env.local(), key)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
+  CHECK(
+      obj->Set(env.local(), empty, v8::Integer::New(isolate, 2003)).FromJust());
+  CHECK_EQ(2002, obj->GetPrivate(env.local(), key)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
+  CHECK_EQ(2003, obj->Get(env.local(), empty)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
 
   CcTest::heap()->CollectAllGarbage();
 
   // Add another property and delete it afterwards to force the object in
   // slow case.
-  CHECK(obj->Set(prop_name, v8::Integer::New(isolate, 2008)));
-  CHECK_EQ(2002,
-           obj->GetPrivate(env.local(), key).ToLocalChecked()->Int32Value());
-  CHECK_EQ(2008, obj->Get(prop_name)->Int32Value());
-  CHECK_EQ(2002,
-           obj->GetPrivate(env.local(), key).ToLocalChecked()->Int32Value());
-  CHECK(obj->Delete(prop_name));
-  CHECK_EQ(2002,
-           obj->GetPrivate(env.local(), key).ToLocalChecked()->Int32Value());
+  CHECK(obj->Set(env.local(), prop_name, v8::Integer::New(isolate, 2008))
+            .FromJust());
+  CHECK_EQ(2002, obj->GetPrivate(env.local(), key)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
+  CHECK_EQ(2008, obj->Get(env.local(), prop_name)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
+  CHECK_EQ(2002, obj->GetPrivate(env.local(), key)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
+  CHECK(obj->Delete(env.local(), prop_name).FromJust());
+  CHECK_EQ(2002, obj->GetPrivate(env.local(), key)
+                     .ToLocalChecked()
+                     ->Int32Value(env.local())
+                     .FromJust());
 
   CcTest::heap()->CollectAllGarbage();
 
   CHECK(obj->SetPrivate(env.local(), key, v8::Integer::New(isolate, 2002))
             .FromJust());
   CHECK(obj->DeletePrivate(env.local(), key).FromJust());
   CHECK(!obj->HasPrivate(env.local(), key).FromJust());
 }
 
 
@@ skipping 17 matching lines @@
       "     set: function() { set_called = true; }})");
 
   CHECK(!obj->HasPrivate(env.local(), key).FromJust());
   // Make sure that the getter and setter from Object.prototype is not invoked.
   // If it did we would have full access to the hidden properties in
   // the accessor.
   CHECK(
       obj->SetPrivate(env.local(), key, v8::Integer::New(env->GetIsolate(), 42))
           .FromJust());
   ExpectFalse("set_called");
-  CHECK_EQ(42,
-           obj->GetPrivate(env.local(), key).ToLocalChecked()->Int32Value());
+  CHECK_EQ(42, obj->GetPrivate(env.local(), key)
+                   .ToLocalChecked()
+                   ->Int32Value(env.local())
+                   .FromJust());
 }
 
 
 THREADED_TEST(External) {
   v8::HandleScope scope(CcTest::isolate());
   int x = 3;
   Local<v8::External> ext = v8::External::New(CcTest::isolate(), &x);
   LocalContext env;
-  env->Global()->Set(v8_str("ext"), ext);
+  CHECK(env->Global()->Set(env.local(), v8_str("ext"), ext).FromJust());
   Local<Value> reext_obj = CompileRun("this.ext");
-  v8::Handle<v8::External> reext = reext_obj.As<v8::External>();
+  v8::Local<v8::External> reext = reext_obj.As<v8::External>();
   int* ptr = static_cast<int*>(reext->Value());
   CHECK_EQ(x, 3);
   *ptr = 10;
   CHECK_EQ(x, 10);
 
   // Make sure unaligned pointers are wrapped properly.
   char* data = i::StrDup("0123456789");
   Local<v8::Value> zero = v8::External::New(CcTest::isolate(), &data[0]);
   Local<v8::Value> one = v8::External::New(CcTest::isolate(), &data[1]);
   Local<v8::Value> two = v8::External::New(CcTest::isolate(), &data[2]);
@@ skipping 275 matching lines @@
 
 namespace {
 
 void* IntKeyToVoidPointer(int key) { return reinterpret_cast<void*>(key << 1); }
 
 
 Local<v8::Object> NewObjectForIntKey(
     v8::Isolate* isolate, const v8::Global<v8::ObjectTemplate>& templ,
     int key) {
   auto local = Local<v8::ObjectTemplate>::New(isolate, templ);
-  auto obj = local->NewInstance();
+  auto obj = local->NewInstance(isolate->GetCurrentContext()).ToLocalChecked();
   obj->SetAlignedPointerInInternalField(0, IntKeyToVoidPointer(key));
   return obj;
 }
 
 
 template <typename K, typename V>
 class PhantomStdMapTraits : public v8::StdMapTraits<K, V> {
  public:
   typedef typename v8::GlobalValueMap<K, V, PhantomStdMapTraits<K, V>> MapType;
   static const v8::PersistentContainerCallbackType kCallbackType =
@@ skipping 50 matching lines @@
   int initial_handle_count = global_handles->global_handles_count();
   CHECK_EQ(0, static_cast<int>(map.Size()));
   {
     HandleScope scope(isolate);
     Local<v8::Object> obj = map.Get(7);
     CHECK(obj.IsEmpty());
     Local<v8::Object> expected = v8::Object::New(isolate);
     map.Set(7, expected);
     CHECK_EQ(1, static_cast<int>(map.Size()));
     obj = map.Get(7);
-    CHECK(expected->Equals(obj));
+    CHECK(expected->Equals(env.local(), obj).FromJust());
     {
       typename Map::PersistentValueReference ref = map.GetReference(7);
       CHECK(expected->Equals(ref.NewLocal(isolate)));
     }
     v8::Global<v8::Object> removed = map.Remove(7);
     CHECK_EQ(0, static_cast<int>(map.Size()));
     CHECK(expected == removed);
     removed = map.Remove(7);
     CHECK(removed.IsEmpty());
     map.Set(8, expected);
@@ skipping 64 matching lines @@
 
   vector.Append(obj1);
   vector.Append(obj2);
   vector.Append(obj1);
   vector.Append(obj3.Pass());
   vector.Append(obj1);
 
   CHECK(!vector.IsEmpty());
   CHECK_EQ(5, static_cast<int>(vector.Size()));
   CHECK(obj3.IsEmpty());
-  CHECK(obj1->Equals(vector.Get(0)));
-  CHECK(obj1->Equals(vector.Get(2)));
-  CHECK(obj1->Equals(vector.Get(4)));
-  CHECK(obj2->Equals(vector.Get(1)));
+  CHECK(obj1->Equals(env.local(), vector.Get(0)).FromJust());
+  CHECK(obj1->Equals(env.local(), vector.Get(2)).FromJust());
+  CHECK(obj1->Equals(env.local(), vector.Get(4)).FromJust());
+  CHECK(obj2->Equals(env.local(), vector.Get(1)).FromJust());
 
   CHECK_EQ(5 + handle_count, global_handles->global_handles_count());
 
   vector.Clear();
   CHECK(vector.IsEmpty());
   CHECK_EQ(0, static_cast<int>(vector.Size()));
   CHECK_EQ(handle_count, global_handles->global_handles_count());
 }
 
 
@@ skipping 130 matching lines @@
                         v8::WeakCallbackType::kParameter);
   }
 
   WeakCallCounterAndPersistent<Value> root(&counter);
   root.handle.Reset(iso, g1s1.handle);  // make a root.
 
   // Connect group 1 and 2, make a cycle.
   {
     HandleScope scope(iso);
     CHECK(Local<Object>::New(iso, g1s2.handle.As<Object>())
-              ->Set(0, Local<Value>::New(iso, g2s2.handle)));
+              ->Set(env.local(), 0, Local<Value>::New(iso, g2s2.handle))
+              .FromJust());
     CHECK(Local<Object>::New(iso, g2s1.handle.As<Object>())
-              ->Set(0, Local<Value>::New(iso, g1s1.handle)));
+              ->Set(env.local(), 0, Local<Value>::New(iso, g1s1.handle))
+              .FromJust());
   }
 
   {
     UniqueId id1 = MakeUniqueId(g1s1.handle);
     UniqueId id2 = MakeUniqueId(g2s2.handle);
     iso->SetObjectGroupId(g1s1.handle, id1);
     iso->SetObjectGroupId(g1s2.handle, id1);
     iso->SetReferenceFromGroup(id1, g1c1.handle);
     iso->SetObjectGroupId(g2s1.handle, id2);
     iso->SetObjectGroupId(g2s2.handle, id2);
@@ skipping 53 matching lines @@
   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);
     g1s1.handle.Reset(iso, Object::New(iso));
-    g1s2.handle.Reset(iso, String::NewFromUtf8(iso, "foo1"));
-    g1c1.handle.Reset(iso, String::NewFromUtf8(iso, "foo2"));
+    g1s2.handle.Reset(iso, v8_str("foo1"));
+    g1c1.handle.Reset(iso, v8_str("foo2"));
     g1s1.handle.SetWeak(&g1s1, &WeakPointerCallback,
                         v8::WeakCallbackType::kParameter);
     g1s2.handle.SetWeak(&g1s2, &WeakPointerCallback,
                         v8::WeakCallbackType::kParameter);
     g1c1.handle.SetWeak(&g1c1, &WeakPointerCallback,
                         v8::WeakCallbackType::kParameter);
 
     g2s1.handle.Reset(iso, Object::New(iso));
-    g2s2.handle.Reset(iso, String::NewFromUtf8(iso, "foo3"));
-    g2c1.handle.Reset(iso, String::NewFromUtf8(iso, "foo4"));
+    g2s2.handle.Reset(iso, v8_str("foo3"));
+    g2c1.handle.Reset(iso, v8_str("foo4"));
     g2s1.handle.SetWeak(&g2s1, &WeakPointerCallback,
                         v8::WeakCallbackType::kParameter);
     g2s2.handle.SetWeak(&g2s2, &WeakPointerCallback,
                         v8::WeakCallbackType::kParameter);
     g2c1.handle.SetWeak(&g2c1, &WeakPointerCallback,
                         v8::WeakCallbackType::kParameter);
   }
 
   WeakCallCounterAndPersistent<Value> root(&counter);
   root.handle.Reset(iso, g1s1.handle);  // make a root.
 
   // Connect group 1 and 2, make a cycle.
   {
     HandleScope scope(iso);
     CHECK(Local<Object>::New(iso, g1s1.handle)
-              ->Set(0, Local<Object>::New(iso, g2s1.handle)));
+              ->Set(env.local(), 0, Local<Object>::New(iso, g2s1.handle))
+              .FromJust());
     CHECK(Local<Object>::New(iso, g2s1.handle)
-              ->Set(0, Local<Object>::New(iso, g1s1.handle)));
+              ->Set(env.local(), 0, Local<Object>::New(iso, g1s1.handle))
+              .FromJust());
   }
 
   {
     UniqueId id1 = MakeUniqueId(g1s1.handle);
     UniqueId id2 = MakeUniqueId(g2s2.handle);
     iso->SetObjectGroupId(g1s1.handle, id1);
     iso->SetObjectGroupId(g1s2.handle, id1);
     iso->SetReference(g1s1.handle, g1c1.handle);
     iso->SetObjectGroupId(g2s1.handle, id2);
     iso->SetObjectGroupId(g2s2.handle, id2);
@@ skipping 215 matching lines @@
     HandleScope handle_scope(iso);
     g1s1.handle.MarkPartiallyDependent();
     g1s2.handle.MarkPartiallyDependent();
     g2s1.handle.MarkPartiallyDependent();
     g2s2.handle.MarkPartiallyDependent();
     g3s1.handle.MarkPartiallyDependent();
     g3s2.handle.MarkPartiallyDependent();
     iso->SetObjectGroupId(g1s1.handle, UniqueId(1));
     iso->SetObjectGroupId(g1s2.handle, UniqueId(1));
     Local<Object>::New(iso, g1s1.handle.As<Object>())
-        ->Set(v8_str("x"), Local<Value>::New(iso, g2s1.handle));
+        ->Set(env.local(), v8_str("x"), Local<Value>::New(iso, g2s1.handle))
+        .FromJust();
     iso->SetObjectGroupId(g2s1.handle, UniqueId(2));
     iso->SetObjectGroupId(g2s2.handle, UniqueId(2));
     Local<Object>::New(iso, g2s1.handle.As<Object>())
-        ->Set(v8_str("x"), Local<Value>::New(iso, g3s1.handle));
+        ->Set(env.local(), v8_str("x"), Local<Value>::New(iso, g3s1.handle))
+        .FromJust();
     iso->SetObjectGroupId(g3s1.handle, UniqueId(3));
     iso->SetObjectGroupId(g3s2.handle, UniqueId(3));
     Local<Object>::New(iso, g3s1.handle.As<Object>())
-        ->Set(v8_str("x"), Local<Value>::New(iso, g1s1.handle));
+        ->Set(env.local(), v8_str("x"), Local<Value>::New(iso, g1s1.handle))
+        .FromJust();
   }
 
   v8::internal::Heap* heap =
       reinterpret_cast<v8::internal::Isolate*>(iso)->heap();
   heap->CollectAllGarbage();
 
   // All objects should be alive.
   CHECK_EQ(0, counter.NumberOfWeakCalls());
 
   // Weaken the root.
   root.handle.SetWeak(&root, &WeakPointerCallback,
                       v8::WeakCallbackType::kParameter);
   root.handle.MarkPartiallyDependent();
 
   // Groups are deleted, rebuild groups.
   {
     HandleScope handle_scope(iso);
     g1s1.handle.MarkPartiallyDependent();
     g1s2.handle.MarkPartiallyDependent();
     g2s1.handle.MarkPartiallyDependent();
     g2s2.handle.MarkPartiallyDependent();
     g3s1.handle.MarkPartiallyDependent();
     g3s2.handle.MarkPartiallyDependent();
     iso->SetObjectGroupId(g1s1.handle, UniqueId(1));
     iso->SetObjectGroupId(g1s2.handle, UniqueId(1));
     Local<Object>::New(iso, g1s1.handle.As<Object>())
-        ->Set(v8_str("x"), Local<Value>::New(iso, g2s1.handle));
+        ->Set(env.local(), v8_str("x"), Local<Value>::New(iso, g2s1.handle))
+        .FromJust();
     iso->SetObjectGroupId(g2s1.handle, UniqueId(2));
     iso->SetObjectGroupId(g2s2.handle, UniqueId(2));
     Local<Object>::New(iso, g2s1.handle.As<Object>())
-        ->Set(v8_str("x"), Local<Value>::New(iso, g3s1.handle));
+        ->Set(env.local(), v8_str("x"), Local<Value>::New(iso, g3s1.handle))
+        .FromJust();
     iso->SetObjectGroupId(g3s1.handle, UniqueId(3));
     iso->SetObjectGroupId(g3s2.handle, UniqueId(3));
     Local<Object>::New(iso, g3s1.handle.As<Object>())
-        ->Set(v8_str("x"), Local<Value>::New(iso, g1s1.handle));
+        ->Set(env.local(), v8_str("x"), Local<Value>::New(iso, g1s1.handle))
+        .FromJust();
   }
 
   heap->CollectAllGarbage();
 
   // All objects should be gone. 7 global handles in total.
   CHECK_EQ(7, counter.NumberOfWeakCalls());
 }
 
 
 THREADED_TEST(ScriptException) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   Local<Script> script = v8_compile("throw 'panama!';");
   v8::TryCatch try_catch(env->GetIsolate());
-  Local<Value> result = script->Run();
+  v8::MaybeLocal<Value> result = script->Run(env.local());
   CHECK(result.IsEmpty());
   CHECK(try_catch.HasCaught());
   String::Utf8Value exception_value(try_catch.Exception());
   CHECK_EQ(0, strcmp(*exception_value, "panama!"));
 }
 
 
 TEST(TryCatchCustomException) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   v8::TryCatch try_catch(isolate);
   CompileRun(
       "function CustomError() { this.a = 'b'; }"
       "(function f() { throw new CustomError(); })();");
   CHECK(try_catch.HasCaught());
   CHECK(try_catch.Exception()
-            ->ToObject(isolate)
-            ->Get(v8_str("a"))
-            ->Equals(v8_str("b")));
+            ->ToObject(env.local())
+            .ToLocalChecked()
+            ->Get(env.local(), v8_str("a"))
+            .ToLocalChecked()
+            ->Equals(env.local(), v8_str("b"))
+            .FromJust());
 }
 
 
 bool message_received;
 
 
-static void check_message_0(v8::Handle<v8::Message> message,
-                            v8::Handle<Value> data) {
-  CHECK_EQ(5.76, data->NumberValue());
-  CHECK_EQ(6.75, message->GetScriptOrigin().ResourceName()->NumberValue());
+static void check_message_0(v8::Local<v8::Message> message,
+                            v8::Local<Value> data) {
+  CHECK_EQ(5.76, data->NumberValue(CcTest::isolate()->GetCurrentContext())
+                     .FromJust());
+  CHECK_EQ(6.75, message->GetScriptOrigin()
+                     .ResourceName()
+                     ->NumberValue(CcTest::isolate()->GetCurrentContext())
+                     .FromJust());
   CHECK(!message->IsSharedCrossOrigin());
   message_received = true;
 }
 
 
 THREADED_TEST(MessageHandler0) {
   message_received = false;
   v8::HandleScope scope(CcTest::isolate());
   CHECK(!message_received);
   LocalContext context;
-  v8::V8::AddMessageListener(check_message_0, v8_num(5.76));
-  v8::Handle<v8::Script> script = CompileWithOrigin("throw 'error'", "6.75");
-  script->Run();
+  CcTest::isolate()->AddMessageListener(check_message_0, v8_num(5.76));
+  v8::Local<v8::Script> script = CompileWithOrigin("throw 'error'", "6.75");
+  CHECK(script->Run(context.local()).IsEmpty());
   CHECK(message_received);
   // clear out the message listener
-  v8::V8::RemoveMessageListeners(check_message_0);
+  CcTest::isolate()->RemoveMessageListeners(check_message_0);
 }
 
 
-static void check_message_1(v8::Handle<v8::Message> message,
-                            v8::Handle<Value> data) {
+static void check_message_1(v8::Local<v8::Message> message,
+                            v8::Local<Value> data) {
   CHECK(data->IsNumber());
-  CHECK_EQ(1337, data->Int32Value());
+  CHECK_EQ(1337,
+           data->Int32Value(CcTest::isolate()->GetCurrentContext()).FromJust());
   CHECK(!message->IsSharedCrossOrigin());
   message_received = true;
 }
 
 
 TEST(MessageHandler1) {
   message_received = false;
   v8::HandleScope scope(CcTest::isolate());
   CHECK(!message_received);
-  v8::V8::AddMessageListener(check_message_1);
+  CcTest::isolate()->AddMessageListener(check_message_1);
   LocalContext context;
   CompileRun("throw 1337;");
   CHECK(message_received);
   // clear out the message listener
-  v8::V8::RemoveMessageListeners(check_message_1);
+  CcTest::isolate()->RemoveMessageListeners(check_message_1);
 }
 
 
-static void check_message_2(v8::Handle<v8::Message> message,
-                            v8::Handle<Value> data) {
+static void check_message_2(v8::Local<v8::Message> message,
+                            v8::Local<Value> data) {
   LocalContext context;
   CHECK(data->IsObject());
   v8::Local<v8::Value> hidden_property =
       v8::Object::Cast(*data)
           ->GetPrivate(
               context.local(),
               v8::Private::ForApi(CcTest::isolate(), v8_str("hidden key")))
           .ToLocalChecked();
-  CHECK(v8_str("hidden value")->Equals(hidden_property));
+  CHECK(v8_str("hidden value")
+            ->Equals(context.local(), hidden_property)
+            .FromJust());
   CHECK(!message->IsSharedCrossOrigin());
   message_received = true;
 }
 
 
 TEST(MessageHandler2) {
   message_received = false;
   v8::HandleScope scope(CcTest::isolate());
   CHECK(!message_received);
-  v8::V8::AddMessageListener(check_message_2);
+  CcTest::isolate()->AddMessageListener(check_message_2);
   LocalContext context;
   v8::Local<v8::Value> error = v8::Exception::Error(v8_str("custom error"));
   v8::Object::Cast(*error)
       ->SetPrivate(context.local(),
                    v8::Private::ForApi(CcTest::isolate(), v8_str("hidden key")),
                    v8_str("hidden value"))
       .FromJust();
-  context->Global()->Set(v8_str("error"), error);
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("error"), error)
+            .FromJust());
   CompileRun("throw error;");
   CHECK(message_received);
   // clear out the message listener
-  v8::V8::RemoveMessageListeners(check_message_2);
+  CcTest::isolate()->RemoveMessageListeners(check_message_2);
 }
 
 
-static void check_message_3(v8::Handle<v8::Message> message,
-                            v8::Handle<Value> data) {
+static void check_message_3(v8::Local<v8::Message> message,
+                            v8::Local<Value> data) {
   CHECK(message->IsSharedCrossOrigin());
   CHECK(message->GetScriptOrigin().Options().IsSharedCrossOrigin());
   CHECK(message->GetScriptOrigin().Options().IsEmbedderDebugScript());
   CHECK(message->GetScriptOrigin().Options().IsOpaque());
-  CHECK_EQ(6.75, message->GetScriptOrigin().ResourceName()->NumberValue());
-  CHECK_EQ(7.40, message->GetScriptOrigin().SourceMapUrl()->NumberValue());
+  CHECK_EQ(6.75, message->GetScriptOrigin()
+                     .ResourceName()
+                     ->NumberValue(CcTest::isolate()->GetCurrentContext())
+                     .FromJust());
+  CHECK_EQ(7.40, message->GetScriptOrigin()
+                     .SourceMapUrl()
+                     ->NumberValue(CcTest::isolate()->GetCurrentContext())
+                     .FromJust());
   message_received = true;
 }
 
 
 TEST(MessageHandler3) {
   message_received = false;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   CHECK(!message_received);
-  v8::V8::AddMessageListener(check_message_3);
+  isolate->AddMessageListener(check_message_3);
   LocalContext context;
   v8::ScriptOrigin origin = v8::ScriptOrigin(
       v8_str("6.75"), v8::Integer::New(isolate, 1),
-      v8::Integer::New(isolate, 2), v8::True(isolate), Handle<v8::Integer>(),
+      v8::Integer::New(isolate, 2), v8::True(isolate), Local<v8::Integer>(),
       v8::True(isolate), v8_str("7.40"), v8::True(isolate));
-  v8::Handle<v8::Script> script =
-      Script::Compile(v8_str("throw 'error'"), &origin);
-  script->Run();
+  v8::Local<v8::Script> script =
+      Script::Compile(context.local(), v8_str("throw 'error'"), &origin)
+          .ToLocalChecked();
+  CHECK(script->Run(context.local()).IsEmpty());
   CHECK(message_received);
   // clear out the message listener
-  v8::V8::RemoveMessageListeners(check_message_3);
+  isolate->RemoveMessageListeners(check_message_3);
 }
 
 
-static void check_message_4(v8::Handle<v8::Message> message,
-                            v8::Handle<Value> data) {
+static void check_message_4(v8::Local<v8::Message> message,
+                            v8::Local<Value> data) {
   CHECK(!message->IsSharedCrossOrigin());
-  CHECK_EQ(6.75, message->GetScriptOrigin().ResourceName()->NumberValue());
+  CHECK_EQ(6.75, message->GetScriptOrigin()
+                     .ResourceName()
+                     ->NumberValue(CcTest::isolate()->GetCurrentContext())
+                     .FromJust());
   message_received = true;
 }
 
 
 TEST(MessageHandler4) {
   message_received = false;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   CHECK(!message_received);
-  v8::V8::AddMessageListener(check_message_4);
+  isolate->AddMessageListener(check_message_4);
   LocalContext context;
   v8::ScriptOrigin origin =
       v8::ScriptOrigin(v8_str("6.75"), v8::Integer::New(isolate, 1),
                        v8::Integer::New(isolate, 2), v8::False(isolate));
-  v8::Handle<v8::Script> script =
-      Script::Compile(v8_str("throw 'error'"), &origin);
-  script->Run();
+  v8::Local<v8::Script> script =
+      Script::Compile(context.local(), v8_str("throw 'error'"), &origin)
+          .ToLocalChecked();
+  CHECK(script->Run(context.local()).IsEmpty());
   CHECK(message_received);
   // clear out the message listener
-  v8::V8::RemoveMessageListeners(check_message_4);
+  isolate->RemoveMessageListeners(check_message_4);
 }
 
 
-static void check_message_5a(v8::Handle<v8::Message> message,
-                             v8::Handle<Value> data) {
+static void check_message_5a(v8::Local<v8::Message> message,
+                             v8::Local<Value> data) {
   CHECK(message->IsSharedCrossOrigin());
-  CHECK_EQ(6.75, message->GetScriptOrigin().ResourceName()->NumberValue());
+  CHECK_EQ(6.75, message->GetScriptOrigin()
+                     .ResourceName()
+                     ->NumberValue(CcTest::isolate()->GetCurrentContext())
+                     .FromJust());
   message_received = true;
 }
 
 
-static void check_message_5b(v8::Handle<v8::Message> message,
-                             v8::Handle<Value> data) {
+static void check_message_5b(v8::Local<v8::Message> message,
+                             v8::Local<Value> data) {
   CHECK(!message->IsSharedCrossOrigin());
-  CHECK_EQ(6.75, message->GetScriptOrigin().ResourceName()->NumberValue());
+  CHECK_EQ(6.75, message->GetScriptOrigin()
+                     .ResourceName()
+                     ->NumberValue(CcTest::isolate()->GetCurrentContext())
+                     .FromJust());
   message_received = true;
 }
 
 
 TEST(MessageHandler5) {
   message_received = false;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   CHECK(!message_received);
-  v8::V8::AddMessageListener(check_message_5a);
+  isolate->AddMessageListener(check_message_5a);
   LocalContext context;
   v8::ScriptOrigin origin1 =
       v8::ScriptOrigin(v8_str("6.75"), v8::Integer::New(isolate, 1),
                        v8::Integer::New(isolate, 2), v8::True(isolate));
-  v8::Handle<v8::Script> script =
-      Script::Compile(v8_str("throw 'error'"), &origin1);
-  script->Run();
+  v8::Local<v8::Script> script =
+      Script::Compile(context.local(), v8_str("throw 'error'"), &origin1)
+          .ToLocalChecked();
+  CHECK(script->Run(context.local()).IsEmpty());
   CHECK(message_received);
   // clear out the message listener
-  v8::V8::RemoveMessageListeners(check_message_5a);
+  isolate->RemoveMessageListeners(check_message_5a);
 
   message_received = false;
-  v8::V8::AddMessageListener(check_message_5b);
+  isolate->AddMessageListener(check_message_5b);
   v8::ScriptOrigin origin2 =
       v8::ScriptOrigin(v8_str("6.75"), v8::Integer::New(isolate, 1),
                        v8::Integer::New(isolate, 2), v8::False(isolate));
-  script = Script::Compile(v8_str("throw 'error'"), &origin2);
-  script->Run();
+  script = Script::Compile(context.local(), v8_str("throw 'error'"), &origin2)
+               .ToLocalChecked();
+  CHECK(script->Run(context.local()).IsEmpty());
   CHECK(message_received);
   // clear out the message listener
-  v8::V8::RemoveMessageListeners(check_message_5b);
+  isolate->RemoveMessageListeners(check_message_5b);
 }
 
 
 TEST(NativeWeakMap) {
   v8::Isolate* isolate = CcTest::isolate();
   HandleScope scope(isolate);
   Local<v8::NativeWeakMap> weak_map(v8::NativeWeakMap::New(isolate));
   CHECK(!weak_map.IsEmpty());
 
   LocalContext env;
   Local<Object> value = v8::Object::New(isolate);
 
   Local<Object> local1 = v8::Object::New(isolate);
   CHECK(!weak_map->Has(local1));
   CHECK(weak_map->Get(local1)->IsUndefined());
   weak_map->Set(local1, value);
   CHECK(weak_map->Has(local1));
-  CHECK(value->Equals(weak_map->Get(local1)));
+  CHECK(value->Equals(env.local(), weak_map->Get(local1)).FromJust());
 
   WeakCallCounter counter(1234);
   WeakCallCounterAndPersistent<Value> o1(&counter);
   WeakCallCounterAndPersistent<Value> o2(&counter);
   WeakCallCounterAndPersistent<Value> s1(&counter);
   {
     HandleScope scope(isolate);
     Local<v8::Object> obj1 = v8::Object::New(isolate);
     Local<v8::Object> obj2 = v8::Object::New(isolate);
     Local<v8::Symbol> sym1 = v8::Symbol::New(isolate);
 
     weak_map->Set(obj1, value);
     weak_map->Set(obj2, value);
     weak_map->Set(sym1, value);
 
     o1.handle.Reset(isolate, obj1);
     o2.handle.Reset(isolate, obj2);
     s1.handle.Reset(isolate, sym1);
 
     CHECK(weak_map->Has(local1));
     CHECK(weak_map->Has(obj1));
     CHECK(weak_map->Has(obj2));
     CHECK(weak_map->Has(sym1));
 
-    CHECK(value->Equals(weak_map->Get(local1)));
-    CHECK(value->Equals(weak_map->Get(obj1)));
-    CHECK(value->Equals(weak_map->Get(obj2)));
-    CHECK(value->Equals(weak_map->Get(sym1)));
+    CHECK(value->Equals(env.local(), weak_map->Get(local1)).FromJust());
+    CHECK(value->Equals(env.local(), weak_map->Get(obj1)).FromJust());
+    CHECK(value->Equals(env.local(), weak_map->Get(obj2)).FromJust());
+    CHECK(value->Equals(env.local(), weak_map->Get(sym1)).FromJust());
   }
   CcTest::heap()->CollectAllGarbage();
   {
     HandleScope scope(isolate);
-    CHECK(value->Equals(weak_map->Get(local1)));
-    CHECK(value->Equals(weak_map->Get(Local<Value>::New(isolate, o1.handle))));
-    CHECK(value->Equals(weak_map->Get(Local<Value>::New(isolate, o2.handle))));
-    CHECK(value->Equals(weak_map->Get(Local<Value>::New(isolate, s1.handle))));
+    CHECK(value->Equals(env.local(), weak_map->Get(local1)).FromJust());
+    CHECK(value->Equals(env.local(),
+                        weak_map->Get(Local<Value>::New(isolate, o1.handle)))
+              .FromJust());
+    CHECK(value->Equals(env.local(),
+                        weak_map->Get(Local<Value>::New(isolate, o2.handle)))
+              .FromJust());
+    CHECK(value->Equals(env.local(),
+                        weak_map->Get(Local<Value>::New(isolate, s1.handle)))
+              .FromJust());
   }
 
   o1.handle.SetWeak(&o1, &WeakPointerCallback,
                     v8::WeakCallbackType::kParameter);
   o2.handle.SetWeak(&o2, &WeakPointerCallback,
                     v8::WeakCallbackType::kParameter);
   s1.handle.SetWeak(&s1, &WeakPointerCallback,
                     v8::WeakCallbackType::kParameter);
 
   CcTest::heap()->CollectAllGarbage();
   CHECK_EQ(3, counter.NumberOfWeakCalls());
 
   CHECK(o1.handle.IsEmpty());
   CHECK(o2.handle.IsEmpty());
   CHECK(s1.handle.IsEmpty());
 
-  CHECK(value->Equals(weak_map->Get(local1)));
+  CHECK(value->Equals(env.local(), weak_map->Get(local1)).FromJust());
   CHECK(weak_map->Delete(local1));
   CHECK(!weak_map->Has(local1));
   CHECK(weak_map->Get(local1)->IsUndefined());
 }
 
 
 THREADED_TEST(GetSetProperty) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
-  context->Global()->Set(v8_str("foo"), v8_num(14));
-  context->Global()->Set(v8_str("12"), v8_num(92));
-  context->Global()->Set(v8::Integer::New(isolate, 16), v8_num(32));
-  context->Global()->Set(v8_num(13), v8_num(56));
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("foo"), v8_num(14))
+            .FromJust());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("12"), v8_num(92))
+            .FromJust());
+  CHECK(context->Global()
+            ->Set(context.local(), v8::Integer::New(isolate, 16), v8_num(32))
+            .FromJust());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_num(13), v8_num(56))
+            .FromJust());
   Local<Value> foo = CompileRun("this.foo");
-  CHECK_EQ(14, foo->Int32Value());
+  CHECK_EQ(14, foo->Int32Value(context.local()).FromJust());
   Local<Value> twelve = CompileRun("this[12]");
-  CHECK_EQ(92, twelve->Int32Value());
+  CHECK_EQ(92, twelve->Int32Value(context.local()).FromJust());
   Local<Value> sixteen = CompileRun("this[16]");
-  CHECK_EQ(32, sixteen->Int32Value());
+  CHECK_EQ(32, sixteen->Int32Value(context.local()).FromJust());
   Local<Value> thirteen = CompileRun("this[13]");
-  CHECK_EQ(56, thirteen->Int32Value());
-  CHECK_EQ(92,
-           context->Global()->Get(v8::Integer::New(isolate, 12))->Int32Value());
-  CHECK_EQ(92, context->Global()->Get(v8_str("12"))->Int32Value());
-  CHECK_EQ(92, context->Global()->Get(v8_num(12))->Int32Value());
-  CHECK_EQ(32,
-           context->Global()->Get(v8::Integer::New(isolate, 16))->Int32Value());
-  CHECK_EQ(32, context->Global()->Get(v8_str("16"))->Int32Value());
-  CHECK_EQ(32, context->Global()->Get(v8_num(16))->Int32Value());
-  CHECK_EQ(56,
-           context->Global()->Get(v8::Integer::New(isolate, 13))->Int32Value());
-  CHECK_EQ(56, context->Global()->Get(v8_str("13"))->Int32Value());
-  CHECK_EQ(56, context->Global()->Get(v8_num(13))->Int32Value());
+  CHECK_EQ(56, thirteen->Int32Value(context.local()).FromJust());
+  CHECK_EQ(92, context->Global()
+                   ->Get(context.local(), v8::Integer::New(isolate, 12))
+                   .ToLocalChecked()
+                   ->Int32Value(context.local())
+                   .FromJust());
+  CHECK_EQ(92, context->Global()
+                   ->Get(context.local(), v8_str("12"))
+                   .ToLocalChecked()
+                   ->Int32Value(context.local())
+                   .FromJust());
+  CHECK_EQ(92, context->Global()
+                   ->Get(context.local(), v8_num(12))
+                   .ToLocalChecked()
+                   ->Int32Value(context.local())
+                   .FromJust());
+  CHECK_EQ(32, context->Global()
+                   ->Get(context.local(), v8::Integer::New(isolate, 16))
+                   .ToLocalChecked()
+                   ->Int32Value(context.local())
+                   .FromJust());
+  CHECK_EQ(32, context->Global()
+                   ->Get(context.local(), v8_str("16"))
+                   .ToLocalChecked()
+                   ->Int32Value(context.local())
+                   .FromJust());
+  CHECK_EQ(32, context->Global()
+                   ->Get(context.local(), v8_num(16))
+                   .ToLocalChecked()
+                   ->Int32Value(context.local())
+                   .FromJust());
+  CHECK_EQ(56, context->Global()
+                   ->Get(context.local(), v8::Integer::New(isolate, 13))
+                   .ToLocalChecked()
+                   ->Int32Value(context.local())
+                   .FromJust());
+  CHECK_EQ(56, context->Global()
+                   ->Get(context.local(), v8_str("13"))
+                   .ToLocalChecked()
+                   ->Int32Value(context.local())
+                   .FromJust());
+  CHECK_EQ(56, context->Global()
+                   ->Get(context.local(), v8_num(13))
+                   .ToLocalChecked()
+                   ->Int32Value(context.local())
+                   .FromJust());
 }
 
 
 THREADED_TEST(PropertyAttributes) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   // none
   Local<String> prop = v8_str("none");
-  context->Global()->Set(prop, v8_num(7));
-  CHECK_EQ(v8::None, context->Global()->GetPropertyAttributes(prop));
+  CHECK(context->Global()->Set(context.local(), prop, v8_num(7)).FromJust());
+  CHECK_EQ(v8::None, context->Global()->GetPropertyAttributes(context.local(),
+prop).FromJust());
   // read-only
   prop = v8_str("read_only");
-  context->Global()->ForceSet(prop, v8_num(7), v8::ReadOnly);
-  CHECK_EQ(7, context->Global()->Get(prop)->Int32Value());
-  CHECK_EQ(v8::ReadOnly, context->Global()->GetPropertyAttributes(prop));
+  context->Global()->ForceSet(context.local(), prop, v8_num(7),
+v8::ReadOnly).FromJust();
+  CHECK_EQ(7, context->Global()->Get(context.local(),
+prop).ToLocalChecked()->Int32Value(context.local()).FromJust());
+  CHECK_EQ(v8::ReadOnly,
+context->Global()->GetPropertyAttributes(context.local(), prop).FromJust());
   CompileRun("read_only = 9");
-  CHECK_EQ(7, context->Global()->Get(prop)->Int32Value());
-  context->Global()->Set(prop, v8_num(10));
-  CHECK_EQ(7, context->Global()->Get(prop)->Int32Value());
+  CHECK_EQ(7, context->Global()->Get(context.local(),
+prop).ToLocalChecked()->Int32Value(context.local()).FromJust());
+  CHECK(context->Global()->Set(context.local(), prop, v8_num(10)).FromJust());
+  CHECK_EQ(7, context->Global()->Get(context.local(),
+prop).ToLocalChecked()->Int32Value(context.local()).FromJust());
   // dont-delete
   prop = v8_str("dont_delete");
-  context->Global()->ForceSet(prop, v8_num(13), v8::DontDelete);
-  CHECK_EQ(13, context->Global()->Get(prop)->Int32Value());
+  context->Global()->ForceSet(context.local(), prop, v8_num(13),
+v8::DontDelete).FromJust();
+  CHECK_EQ(13, context->Global()->Get(context.local(),
+prop).ToLocalChecked()->Int32Value(context.local()).FromJust());
   CompileRun("delete dont_delete");
-  CHECK_EQ(13, context->Global()->Get(prop)->Int32Value());
-  CHECK_EQ(v8::DontDelete, context->Global()->GetPropertyAttributes(prop));
+  CHECK_EQ(13, context->Global()->Get(context.local(),
+prop).ToLocalChecked()->Int32Value(context.local()).FromJust());
+  CHECK_EQ(v8::DontDelete,
+context->Global()->GetPropertyAttributes(context.local(), prop).FromJust());
   // dont-enum
   prop = v8_str("dont_enum");
   context->Global()->ForceSet(prop, v8_num(28), v8::DontEnum);
-  CHECK_EQ(v8::DontEnum, context->Global()->GetPropertyAttributes(prop));
+  CHECK_EQ(v8::DontEnum,
+context->Global()->GetPropertyAttributes(context.local(), prop).FromJust());
   // absent
   prop = v8_str("absent");
-  CHECK_EQ(v8::None, context->Global()->GetPropertyAttributes(prop));
+  CHECK_EQ(v8::None, context->Global()->GetPropertyAttributes(context.local(),
+prop).FromJust());
   Local<Value> fake_prop = v8_num(1);
-  CHECK_EQ(v8::None, context->Global()->GetPropertyAttributes(fake_prop));
+  CHECK_EQ(v8::None, context->Global()->GetPropertyAttributes(context.local(),
+fake_prop).FromJust());
   // exception
   TryCatch try_catch(context->GetIsolate());
   Local<Value> exception =
       CompileRun("({ toString: function() { throw 'exception';} })");
-  CHECK_EQ(v8::None, context->Global()->GetPropertyAttributes(exception));
+  CHECK_EQ(v8::None, context->Global()->GetPropertyAttributes(context.local(),
+exception).FromJust());
   CHECK(try_catch.HasCaught());
   String::Utf8Value exception_value(try_catch.Exception());
   CHECK_EQ(0, strcmp("exception", *exception_value));
   try_catch.Reset();
 }
 
 
 THREADED_TEST(Array) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   Local<v8::Array> array = v8::Array::New(context->GetIsolate());
   CHECK_EQ(0u, array->Length());
-  CHECK(array->Get(0)->IsUndefined());
-  CHECK(!array->Has(0));
-  CHECK(array->Get(100)->IsUndefined());
-  CHECK(!array->Has(100));
-  array->Set(2, v8_num(7));
+  CHECK(array->Get(context.local(), 0).ToLocalChecked()->IsUndefined());
+  CHECK(!array->Has(context.local(), 0).FromJust());
+  CHECK(array->Get(context.local(), 100).ToLocalChecked()->IsUndefined());
+  CHECK(!array->Has(context.local(), 100).FromJust());
+  CHECK(array->Set(context.local(), 2, v8_num(7)).FromJust());
   CHECK_EQ(3u, array->Length());
-  CHECK(!array->Has(0));
-  CHECK(!array->Has(1));
-  CHECK(array->Has(2));
-  CHECK_EQ(7, array->Get(2)->Int32Value());
+  CHECK(!array->Has(context.local(), 0).FromJust());
+  CHECK(!array->Has(context.local(), 1).FromJust());
+  CHECK(array->Has(context.local(), 2).FromJust());
+  CHECK_EQ(7, array->Get(context.local(), 2)
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
   Local<Value> obj = CompileRun("[1, 2, 3]");
   Local<v8::Array> arr = obj.As<v8::Array>();
   CHECK_EQ(3u, arr->Length());
-  CHECK_EQ(1, arr->Get(0)->Int32Value());
-  CHECK_EQ(2, arr->Get(1)->Int32Value());
-  CHECK_EQ(3, arr->Get(2)->Int32Value());
+  CHECK_EQ(1, arr->Get(context.local(), 0)
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK_EQ(2, arr->Get(context.local(), 1)
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK_EQ(3, arr->Get(context.local(), 2)
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
   array = v8::Array::New(context->GetIsolate(), 27);
   CHECK_EQ(27u, array->Length());
   array = v8::Array::New(context->GetIsolate(), -27);
   CHECK_EQ(0u, array->Length());
 }
 
 
 void HandleF(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::EscapableHandleScope scope(args.GetIsolate());
   ApiTestFuzzer::Fuzz();
   Local<v8::Array> result = v8::Array::New(args.GetIsolate(), args.Length());
-  for (int i = 0; i < args.Length(); i++) result->Set(i, args[i]);
+  for (int i = 0; i < args.Length(); i++) {
+    CHECK(result->Set(CcTest::isolate()->GetCurrentContext(), i, args[i])
+              .FromJust());
+  }
   args.GetReturnValue().Set(scope.Escape(result));
 }
 
 
 THREADED_TEST(Vector) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> global = ObjectTemplate::New(isolate);
   global->Set(v8_str("f"), v8::FunctionTemplate::New(isolate, HandleF));
   LocalContext context(0, global);
 
   const char* fun = "f()";
   Local<v8::Array> a0 = CompileRun(fun).As<v8::Array>();
   CHECK_EQ(0u, a0->Length());
 
   const char* fun2 = "f(11)";
   Local<v8::Array> a1 = CompileRun(fun2).As<v8::Array>();
   CHECK_EQ(1u, a1->Length());
-  CHECK_EQ(11, a1->Get(0)->Int32Value());
+  CHECK_EQ(11, a1->Get(context.local(), 0)
+                   .ToLocalChecked()
+                   ->Int32Value(context.local())
+                   .FromJust());
 
   const char* fun3 = "f(12, 13)";
   Local<v8::Array> a2 = CompileRun(fun3).As<v8::Array>();
   CHECK_EQ(2u, a2->Length());
-  CHECK_EQ(12, a2->Get(0)->Int32Value());
-  CHECK_EQ(13, a2->Get(1)->Int32Value());
+  CHECK_EQ(12, a2->Get(context.local(), 0)
+                   .ToLocalChecked()
+                   ->Int32Value(context.local())
+                   .FromJust());
+  CHECK_EQ(13, a2->Get(context.local(), 1)
+                   .ToLocalChecked()
+                   ->Int32Value(context.local())
+                   .FromJust());
 
   const char* fun4 = "f(14, 15, 16)";
   Local<v8::Array> a3 = CompileRun(fun4).As<v8::Array>();
   CHECK_EQ(3u, a3->Length());
-  CHECK_EQ(14, a3->Get(0)->Int32Value());
-  CHECK_EQ(15, a3->Get(1)->Int32Value());
-  CHECK_EQ(16, a3->Get(2)->Int32Value());
+  CHECK_EQ(14, a3->Get(context.local(), 0)
+                   .ToLocalChecked()
+                   ->Int32Value(context.local())
+                   .FromJust());
+  CHECK_EQ(15, a3->Get(context.local(), 1)
+                   .ToLocalChecked()
+                   ->Int32Value(context.local())
+                   .FromJust());
+  CHECK_EQ(16, a3->Get(context.local(), 2)
+                   .ToLocalChecked()
+                   ->Int32Value(context.local())
+                   .FromJust());
 
   const char* fun5 = "f(17, 18, 19, 20)";
   Local<v8::Array> a4 = CompileRun(fun5).As<v8::Array>();
   CHECK_EQ(4u, a4->Length());
-  CHECK_EQ(17, a4->Get(0)->Int32Value());
-  CHECK_EQ(18, a4->Get(1)->Int32Value());
-  CHECK_EQ(19, a4->Get(2)->Int32Value());
-  CHECK_EQ(20, a4->Get(3)->Int32Value());
+  CHECK_EQ(17, a4->Get(context.local(), 0)
+                   .ToLocalChecked()
+                   ->Int32Value(context.local())
+                   .FromJust());
+  CHECK_EQ(18, a4->Get(context.local(), 1)
+                   .ToLocalChecked()
+                   ->Int32Value(context.local())
+                   .FromJust());
+  CHECK_EQ(19, a4->Get(context.local(), 2)
+                   .ToLocalChecked()
+                   ->Int32Value(context.local())
+                   .FromJust());
+  CHECK_EQ(20, a4->Get(context.local(), 3)
+                   .ToLocalChecked()
+                   ->Int32Value(context.local())
+                   .FromJust());
 }
 
 
 THREADED_TEST(FunctionCall) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
   CompileRun(
       "function Foo() {"
       "  var result = [];"
       "  for (var i = 0; i < arguments.length; i++) {"
       "    result.push(arguments[i]);"
       "  }"
       "  return result;"
       "}"
       "function ReturnThisSloppy() {"
       "  return this;"
       "}"
       "function ReturnThisStrict() {"
       "  'use strict';"
       "  return this;"
       "}");
-  Local<Function> Foo =
-      Local<Function>::Cast(context->Global()->Get(v8_str("Foo")));
-  Local<Function> ReturnThisSloppy =
-      Local<Function>::Cast(context->Global()->Get(v8_str("ReturnThisSloppy")));
-  Local<Function> ReturnThisStrict =
-      Local<Function>::Cast(context->Global()->Get(v8_str("ReturnThisStrict")));
+  Local<Function> Foo = Local<Function>::Cast(
+      context->Global()->Get(context.local(), v8_str("Foo")).ToLocalChecked());
+  Local<Function> ReturnThisSloppy = Local<Function>::Cast(
+      context->Global()
+          ->Get(context.local(), v8_str("ReturnThisSloppy"))
+          .ToLocalChecked());
+  Local<Function> ReturnThisStrict = Local<Function>::Cast(
+      context->Global()
+          ->Get(context.local(), v8_str("ReturnThisStrict"))
+          .ToLocalChecked());
 
-  v8::Handle<Value>* args0 = NULL;
-  Local<v8::Array> a0 = Local<v8::Array>::Cast(Foo->Call(Foo, 0, args0));
+  v8::Local<Value>* args0 = NULL;
+  Local<v8::Array> a0 = Local<v8::Array>::Cast(
+      Foo->Call(context.local(), Foo, 0, args0).ToLocalChecked());
   CHECK_EQ(0u, a0->Length());
 
-  v8::Handle<Value> args1[] = {v8_num(1.1)};
-  Local<v8::Array> a1 = Local<v8::Array>::Cast(Foo->Call(Foo, 1, args1));
+  v8::Local<Value> args1[] = {v8_num(1.1)};
+  Local<v8::Array> a1 = Local<v8::Array>::Cast(
+      Foo->Call(context.local(), Foo, 1, args1).ToLocalChecked());
   CHECK_EQ(1u, a1->Length());
-  CHECK_EQ(1.1, a1->Get(v8::Integer::New(isolate, 0))->NumberValue());
+  CHECK_EQ(1.1, a1->Get(context.local(), v8::Integer::New(isolate, 0))
+                    .ToLocalChecked()
+                    ->NumberValue(context.local())
+                    .FromJust());
 
-  v8::Handle<Value> args2[] = {v8_num(2.2), v8_num(3.3)};
-  Local<v8::Array> a2 = Local<v8::Array>::Cast(Foo->Call(Foo, 2, args2));
+  v8::Local<Value> args2[] = {v8_num(2.2), v8_num(3.3)};
+  Local<v8::Array> a2 = Local<v8::Array>::Cast(
+      Foo->Call(context.local(), Foo, 2, args2).ToLocalChecked());
   CHECK_EQ(2u, a2->Length());
-  CHECK_EQ(2.2, a2->Get(v8::Integer::New(isolate, 0))->NumberValue());
-  CHECK_EQ(3.3, a2->Get(v8::Integer::New(isolate, 1))->NumberValue());
+  CHECK_EQ(2.2, a2->Get(context.local(), v8::Integer::New(isolate, 0))
+                    .ToLocalChecked()
+                    ->NumberValue(context.local())
+                    .FromJust());
+  CHECK_EQ(3.3, a2->Get(context.local(), v8::Integer::New(isolate, 1))
+                    .ToLocalChecked()
+                    ->NumberValue(context.local())
+                    .FromJust());
 
-  v8::Handle<Value> args3[] = {v8_num(4.4), v8_num(5.5), v8_num(6.6)};
-  Local<v8::Array> a3 = Local<v8::Array>::Cast(Foo->Call(Foo, 3, args3));
+  v8::Local<Value> args3[] = {v8_num(4.4), v8_num(5.5), v8_num(6.6)};
+  Local<v8::Array> a3 = Local<v8::Array>::Cast(
+      Foo->Call(context.local(), Foo, 3, args3).ToLocalChecked());
   CHECK_EQ(3u, a3->Length());
-  CHECK_EQ(4.4, a3->Get(v8::Integer::New(isolate, 0))->NumberValue());
-  CHECK_EQ(5.5, a3->Get(v8::Integer::New(isolate, 1))->NumberValue());
-  CHECK_EQ(6.6, a3->Get(v8::Integer::New(isolate, 2))->NumberValue());
+  CHECK_EQ(4.4, a3->Get(context.local(), v8::Integer::New(isolate, 0))
+                    .ToLocalChecked()
+                    ->NumberValue(context.local())
+                    .FromJust());
+  CHECK_EQ(5.5, a3->Get(context.local(), v8::Integer::New(isolate, 1))
+                    .ToLocalChecked()
+                    ->NumberValue(context.local())
+                    .FromJust());
+  CHECK_EQ(6.6, a3->Get(context.local(), v8::Integer::New(isolate, 2))
+                    .ToLocalChecked()
+                    ->NumberValue(context.local())
+                    .FromJust());
 
-  v8::Handle<Value> args4[] = {v8_num(7.7), v8_num(8.8), v8_num(9.9),
-                               v8_num(10.11)};
-  Local<v8::Array> a4 = Local<v8::Array>::Cast(Foo->Call(Foo, 4, args4));
+  v8::Local<Value> args4[] = {v8_num(7.7), v8_num(8.8), v8_num(9.9),
+                              v8_num(10.11)};
+  Local<v8::Array> a4 = Local<v8::Array>::Cast(
+      Foo->Call(context.local(), Foo, 4, args4).ToLocalChecked());
   CHECK_EQ(4u, a4->Length());
-  CHECK_EQ(7.7, a4->Get(v8::Integer::New(isolate, 0))->NumberValue());
-  CHECK_EQ(8.8, a4->Get(v8::Integer::New(isolate, 1))->NumberValue());
-  CHECK_EQ(9.9, a4->Get(v8::Integer::New(isolate, 2))->NumberValue());
-  CHECK_EQ(10.11, a4->Get(v8::Integer::New(isolate, 3))->NumberValue());
+  CHECK_EQ(7.7, a4->Get(context.local(), v8::Integer::New(isolate, 0))
+                    .ToLocalChecked()
+                    ->NumberValue(context.local())
+                    .FromJust());
+  CHECK_EQ(8.8, a4->Get(context.local(), v8::Integer::New(isolate, 1))
+                    .ToLocalChecked()
+                    ->NumberValue(context.local())
+                    .FromJust());
+  CHECK_EQ(9.9, a4->Get(context.local(), v8::Integer::New(isolate, 2))
+                    .ToLocalChecked()
+                    ->NumberValue(context.local())
+                    .FromJust());
+  CHECK_EQ(10.11, a4->Get(context.local(), v8::Integer::New(isolate, 3))
+                      .ToLocalChecked()
+                      ->NumberValue(context.local())
+                      .FromJust());
 
-  Local<v8::Value> r1 = ReturnThisSloppy->Call(v8::Undefined(isolate), 0, NULL);
+  Local<v8::Value> r1 =
+      ReturnThisSloppy->Call(context.local(), v8::Undefined(isolate), 0, NULL)
+          .ToLocalChecked();
   CHECK(r1->StrictEquals(context->Global()));
-  Local<v8::Value> r2 = ReturnThisSloppy->Call(v8::Null(isolate), 0, NULL);
+  Local<v8::Value> r2 =
+      ReturnThisSloppy->Call(context.local(), v8::Null(isolate), 0, NULL)
+          .ToLocalChecked();
   CHECK(r2->StrictEquals(context->Global()));
-  Local<v8::Value> r3 = ReturnThisSloppy->Call(v8_num(42), 0, NULL);
+  Local<v8::Value> r3 =
+      ReturnThisSloppy->Call(context.local(), v8_num(42), 0, NULL)
+          .ToLocalChecked();
   CHECK(r3->IsNumberObject());
   CHECK_EQ(42.0, r3.As<v8::NumberObject>()->ValueOf());
-  Local<v8::Value> r4 = ReturnThisSloppy->Call(v8_str("hello"), 0, NULL);
+  Local<v8::Value> r4 =
+      ReturnThisSloppy->Call(context.local(), v8_str("hello"), 0, NULL)
+          .ToLocalChecked();
   CHECK(r4->IsStringObject());
   CHECK(r4.As<v8::StringObject>()->ValueOf()->StrictEquals(v8_str("hello")));
-  Local<v8::Value> r5 = ReturnThisSloppy->Call(v8::True(isolate), 0, NULL);
+  Local<v8::Value> r5 =
+      ReturnThisSloppy->Call(context.local(), v8::True(isolate), 0, NULL)
+          .ToLocalChecked();
   CHECK(r5->IsBooleanObject());
   CHECK(r5.As<v8::BooleanObject>()->ValueOf());
 
-  Local<v8::Value> r6 = ReturnThisStrict->Call(v8::Undefined(isolate), 0, NULL);
+  Local<v8::Value> r6 =
+      ReturnThisStrict->Call(context.local(), v8::Undefined(isolate), 0, NULL)
+          .ToLocalChecked();
   CHECK(r6->IsUndefined());
-  Local<v8::Value> r7 = ReturnThisStrict->Call(v8::Null(isolate), 0, NULL);
+  Local<v8::Value> r7 =
+      ReturnThisStrict->Call(context.local(), v8::Null(isolate), 0, NULL)
+          .ToLocalChecked();
   CHECK(r7->IsNull());
-  Local<v8::Value> r8 = ReturnThisStrict->Call(v8_num(42), 0, NULL);
+  Local<v8::Value> r8 =
+      ReturnThisStrict->Call(context.local(), v8_num(42), 0, NULL)
+          .ToLocalChecked();
   CHECK(r8->StrictEquals(v8_num(42)));
-  Local<v8::Value> r9 = ReturnThisStrict->Call(v8_str("hello"), 0, NULL);
+  Local<v8::Value> r9 =
+      ReturnThisStrict->Call(context.local(), v8_str("hello"), 0, NULL)
+          .ToLocalChecked();
   CHECK(r9->StrictEquals(v8_str("hello")));
-  Local<v8::Value> r10 = ReturnThisStrict->Call(v8::True(isolate), 0, NULL);
+  Local<v8::Value> r10 =
+      ReturnThisStrict->Call(context.local(), v8::True(isolate), 0, NULL)
+          .ToLocalChecked();
   CHECK(r10->StrictEquals(v8::True(isolate)));
 }
 
 
 THREADED_TEST(ConstructCall) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
   CompileRun(
       "function Foo() {"
       "  var result = [];"
       "  for (var i = 0; i < arguments.length; i++) {"
       "    result.push(arguments[i]);"
       "  }"
       "  return result;"
       "}");
-  Local<Function> Foo =
-      Local<Function>::Cast(context->Global()->Get(v8_str("Foo")));
+  Local<Function> Foo = Local<Function>::Cast(
+      context->Global()->Get(context.local(), v8_str("Foo")).ToLocalChecked());
 
-  v8::Handle<Value>* args0 = NULL;
-  Local<v8::Array> a0 = Local<v8::Array>::Cast(Foo->NewInstance(0, args0));
+  v8::Local<Value>* args0 = NULL;
+  Local<v8::Array> a0 = Local<v8::Array>::Cast(
+      Foo->NewInstance(context.local(), 0, args0).ToLocalChecked());
   CHECK_EQ(0u, a0->Length());
 
-  v8::Handle<Value> args1[] = {v8_num(1.1)};
-  Local<v8::Array> a1 = Local<v8::Array>::Cast(Foo->NewInstance(1, args1));
+  v8::Local<Value> args1[] = {v8_num(1.1)};
+  Local<v8::Array> a1 = Local<v8::Array>::Cast(
+      Foo->NewInstance(context.local(), 1, args1).ToLocalChecked());
   CHECK_EQ(1u, a1->Length());
-  CHECK_EQ(1.1, a1->Get(v8::Integer::New(isolate, 0))->NumberValue());
+  CHECK_EQ(1.1, a1->Get(context.local(), v8::Integer::New(isolate, 0))
+                    .ToLocalChecked()
+                    ->NumberValue(context.local())
+                    .FromJust());
 
-  v8::Handle<Value> args2[] = {v8_num(2.2), v8_num(3.3)};
-  Local<v8::Array> a2 = Local<v8::Array>::Cast(Foo->NewInstance(2, args2));
+  v8::Local<Value> args2[] = {v8_num(2.2), v8_num(3.3)};
+  Local<v8::Array> a2 = Local<v8::Array>::Cast(
+      Foo->NewInstance(context.local(), 2, args2).ToLocalChecked());
   CHECK_EQ(2u, a2->Length());
-  CHECK_EQ(2.2, a2->Get(v8::Integer::New(isolate, 0))->NumberValue());
-  CHECK_EQ(3.3, a2->Get(v8::Integer::New(isolate, 1))->NumberValue());
+  CHECK_EQ(2.2, a2->Get(context.local(), v8::Integer::New(isolate, 0))
+                    .ToLocalChecked()
+                    ->NumberValue(context.local())
+                    .FromJust());
+  CHECK_EQ(3.3, a2->Get(context.local(), v8::Integer::New(isolate, 1))
+                    .ToLocalChecked()
+                    ->NumberValue(context.local())
+                    .FromJust());
 
-  v8::Handle<Value> args3[] = {v8_num(4.4), v8_num(5.5), v8_num(6.6)};
-  Local<v8::Array> a3 = Local<v8::Array>::Cast(Foo->NewInstance(3, args3));
+  v8::Local<Value> args3[] = {v8_num(4.4), v8_num(5.5), v8_num(6.6)};
+  Local<v8::Array> a3 = Local<v8::Array>::Cast(
+      Foo->NewInstance(context.local(), 3, args3).ToLocalChecked());
   CHECK_EQ(3u, a3->Length());
-  CHECK_EQ(4.4, a3->Get(v8::Integer::New(isolate, 0))->NumberValue());
-  CHECK_EQ(5.5, a3->Get(v8::Integer::New(isolate, 1))->NumberValue());
-  CHECK_EQ(6.6, a3->Get(v8::Integer::New(isolate, 2))->NumberValue());
+  CHECK_EQ(4.4, a3->Get(context.local(), v8::Integer::New(isolate, 0))
+                    .ToLocalChecked()
+                    ->NumberValue(context.local())
+                    .FromJust());
+  CHECK_EQ(5.5, a3->Get(context.local(), v8::Integer::New(isolate, 1))
+                    .ToLocalChecked()
+                    ->NumberValue(context.local())
+                    .FromJust());
+  CHECK_EQ(6.6, a3->Get(context.local(), v8::Integer::New(isolate, 2))
+                    .ToLocalChecked()
+                    ->NumberValue(context.local())
+                    .FromJust());
 
-  v8::Handle<Value> args4[] = {v8_num(7.7), v8_num(8.8), v8_num(9.9),
-                               v8_num(10.11)};
-  Local<v8::Array> a4 = Local<v8::Array>::Cast(Foo->NewInstance(4, args4));
+  v8::Local<Value> args4[] = {v8_num(7.7), v8_num(8.8), v8_num(9.9),
+                              v8_num(10.11)};
+  Local<v8::Array> a4 = Local<v8::Array>::Cast(
+      Foo->NewInstance(context.local(), 4, args4).ToLocalChecked());
   CHECK_EQ(4u, a4->Length());
-  CHECK_EQ(7.7, a4->Get(v8::Integer::New(isolate, 0))->NumberValue());
-  CHECK_EQ(8.8, a4->Get(v8::Integer::New(isolate, 1))->NumberValue());
-  CHECK_EQ(9.9, a4->Get(v8::Integer::New(isolate, 2))->NumberValue());
-  CHECK_EQ(10.11, a4->Get(v8::Integer::New(isolate, 3))->NumberValue());
+  CHECK_EQ(7.7, a4->Get(context.local(), v8::Integer::New(isolate, 0))
+                    .ToLocalChecked()
+                    ->NumberValue(context.local())
+                    .FromJust());
+  CHECK_EQ(8.8, a4->Get(context.local(), v8::Integer::New(isolate, 1))
+                    .ToLocalChecked()
+                    ->NumberValue(context.local())
+                    .FromJust());
+  CHECK_EQ(9.9, a4->Get(context.local(), v8::Integer::New(isolate, 2))
+                    .ToLocalChecked()
+                    ->NumberValue(context.local())
+                    .FromJust());
+  CHECK_EQ(10.11, a4->Get(context.local(), v8::Integer::New(isolate, 3))
+                      .ToLocalChecked()
+                      ->NumberValue(context.local())
+                      .FromJust());
 }
 
 
-static void CheckUncle(v8::TryCatch* try_catch) {
-  CHECK(try_catch->HasCaught());
-  String::Utf8Value str_value(try_catch->Exception());
-  CHECK_EQ(0, strcmp(*str_value, "uncle?"));
-  try_catch->Reset();
-}
-
-
 THREADED_TEST(ConversionNumber) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   // Very large number.
   CompileRun("var obj = Math.pow(2,32) * 1237;");
-  Local<Value> obj = env->Global()->Get(v8_str("obj"));
-  CHECK_EQ(5312874545152.0, obj->ToNumber(isolate)->Value());
-  CHECK_EQ(0, obj->ToInt32(isolate)->Value());
+  Local<Value> obj =
+      env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
+  CHECK_EQ(5312874545152.0,
+           obj->ToNumber(env.local()).ToLocalChecked()->Value());
+  CHECK_EQ(0, obj->ToInt32(env.local()).ToLocalChecked()->Value());
   CHECK(0u ==
-        obj->ToUint32(isolate)->Value());  // NOLINT - no CHECK_EQ for unsigned.
+        obj->ToUint32(env.local())
+            .ToLocalChecked()
+            ->Value());  // NOLINT - no CHECK_EQ for unsigned.
   // Large number.
   CompileRun("var obj = -1234567890123;");
-  obj = env->Global()->Get(v8_str("obj"));
-  CHECK_EQ(-1234567890123.0, obj->ToNumber(isolate)->Value());
-  CHECK_EQ(-1912276171, obj->ToInt32(isolate)->Value());
-  CHECK(2382691125u == obj->ToUint32(isolate)->Value());  // NOLINT
+  obj = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
+  CHECK_EQ(-1234567890123.0,
+           obj->ToNumber(env.local()).ToLocalChecked()->Value());
+  CHECK_EQ(-1912276171, obj->ToInt32(env.local()).ToLocalChecked()->Value());
+  CHECK(2382691125u ==
+        obj->ToUint32(env.local()).ToLocalChecked()->Value());  // NOLINT
   // Small positive integer.
   CompileRun("var obj = 42;");
-  obj = env->Global()->Get(v8_str("obj"));
-  CHECK_EQ(42.0, obj->ToNumber(isolate)->Value());
-  CHECK_EQ(42, obj->ToInt32(isolate)->Value());
-  CHECK(42u == obj->ToUint32(isolate)->Value());  // NOLINT
+  obj = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
+  CHECK_EQ(42.0, obj->ToNumber(env.local()).ToLocalChecked()->Value());
+  CHECK_EQ(42, obj->ToInt32(env.local()).ToLocalChecked()->Value());
+  CHECK(42u == obj->ToUint32(env.local()).ToLocalChecked()->Value());  // NOLINT
   // Negative integer.
   CompileRun("var obj = -37;");
-  obj = env->Global()->Get(v8_str("obj"));
-  CHECK_EQ(-37.0, obj->ToNumber(isolate)->Value());
-  CHECK_EQ(-37, obj->ToInt32(isolate)->Value());
-  CHECK(4294967259u == obj->ToUint32(isolate)->Value());  // NOLINT
+  obj = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
+  CHECK_EQ(-37.0, obj->ToNumber(env.local()).ToLocalChecked()->Value());
+  CHECK_EQ(-37, obj->ToInt32(env.local()).ToLocalChecked()->Value());
+  CHECK(4294967259u ==
+        obj->ToUint32(env.local()).ToLocalChecked()->Value());  // NOLINT
   // Positive non-int32 integer.
   CompileRun("var obj = 0x81234567;");
-  obj = env->Global()->Get(v8_str("obj"));
-  CHECK_EQ(2166572391.0, obj->ToNumber(isolate)->Value());
-  CHECK_EQ(-2128394905, obj->ToInt32(isolate)->Value());
-  CHECK(2166572391u == obj->ToUint32(isolate)->Value());  // NOLINT
+  obj = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
+  CHECK_EQ(2166572391.0, obj->ToNumber(env.local()).ToLocalChecked()->Value());
+  CHECK_EQ(-2128394905, obj->ToInt32(env.local()).ToLocalChecked()->Value());
+  CHECK(2166572391u ==
+        obj->ToUint32(env.local()).ToLocalChecked()->Value());  // NOLINT
   // Fraction.
   CompileRun("var obj = 42.3;");
-  obj = env->Global()->Get(v8_str("obj"));
-  CHECK_EQ(42.3, obj->ToNumber(isolate)->Value());
-  CHECK_EQ(42, obj->ToInt32(isolate)->Value());
-  CHECK(42u == obj->ToUint32(isolate)->Value());  // NOLINT
+  obj = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
+  CHECK_EQ(42.3, obj->ToNumber(env.local()).ToLocalChecked()->Value());
+  CHECK_EQ(42, obj->ToInt32(env.local()).ToLocalChecked()->Value());
+  CHECK(42u == obj->ToUint32(env.local()).ToLocalChecked()->Value());  // NOLINT
   // Large negative fraction.
   CompileRun("var obj = -5726623061.75;");
-  obj = env->Global()->Get(v8_str("obj"));
-  CHECK_EQ(-5726623061.75, obj->ToNumber(isolate)->Value());
-  CHECK_EQ(-1431655765, obj->ToInt32(isolate)->Value());
-  CHECK(2863311531u == obj->ToUint32(isolate)->Value());  // NOLINT
+  obj = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
+  CHECK_EQ(-5726623061.75,
+           obj->ToNumber(env.local()).ToLocalChecked()->Value());
+  CHECK_EQ(-1431655765, obj->ToInt32(env.local()).ToLocalChecked()->Value());
+  CHECK(2863311531u ==
+        obj->ToUint32(env.local()).ToLocalChecked()->Value());  // NOLINT
 }
 
 
 THREADED_TEST(isNumberType) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   // Very large number.
   CompileRun("var obj = Math.pow(2,32) * 1237;");
-  Local<Value> obj = env->Global()->Get(v8_str("obj"));
+  Local<Value> obj =
+      env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
   CHECK(!obj->IsInt32());
   CHECK(!obj->IsUint32());
   // Large negative number.
   CompileRun("var obj = -1234567890123;");
-  obj = env->Global()->Get(v8_str("obj"));
+  obj = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
   CHECK(!obj->IsInt32());
   CHECK(!obj->IsUint32());
   // Small positive integer.
   CompileRun("var obj = 42;");
-  obj = env->Global()->Get(v8_str("obj"));
+  obj = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
   CHECK(obj->IsInt32());
   CHECK(obj->IsUint32());
   // Negative integer.
   CompileRun("var obj = -37;");
-  obj = env->Global()->Get(v8_str("obj"));
+  obj = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
   CHECK(obj->IsInt32());
   CHECK(!obj->IsUint32());
   // Positive non-int32 integer.
   CompileRun("var obj = 0x81234567;");
-  obj = env->Global()->Get(v8_str("obj"));
+  obj = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
   CHECK(!obj->IsInt32());
   CHECK(obj->IsUint32());
   // Fraction.
   CompileRun("var obj = 42.3;");
-  obj = env->Global()->Get(v8_str("obj"));
+  obj = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
   CHECK(!obj->IsInt32());
   CHECK(!obj->IsUint32());
   // Large negative fraction.
   CompileRun("var obj = -5726623061.75;");
-  obj = env->Global()->Get(v8_str("obj"));
+  obj = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
   CHECK(!obj->IsInt32());
   CHECK(!obj->IsUint32());
   // Positive zero
   CompileRun("var obj = 0.0;");
-  obj = env->Global()->Get(v8_str("obj"));
+  obj = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
   CHECK(obj->IsInt32());
   CHECK(obj->IsUint32());
   // Positive zero
   CompileRun("var obj = -0.0;");
-  obj = env->Global()->Get(v8_str("obj"));
+  obj = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
   CHECK(!obj->IsInt32());
   CHECK(!obj->IsUint32());
 }
 
 
+static void CheckUncle(v8::TryCatch* try_catch) {
+  CHECK(try_catch->HasCaught());
+  String::Utf8Value str_value(try_catch->Exception());
+  CHECK_EQ(0, strcmp(*str_value, "uncle?"));
+  try_catch->Reset();
+}
+
+
 THREADED_TEST(ConversionException) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   CompileRun(
       "function TestClass() { };"
       "TestClass.prototype.toString = function () { throw 'uncle?'; };"
       "var obj = new TestClass();");
-  Local<Value> obj = env->Global()->Get(v8_str("obj"));
+  Local<Value> obj =
+      env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
 
   v8::TryCatch try_catch(isolate);
 
-  Local<Value> to_string_result = obj->ToString(isolate);
-  CHECK(to_string_result.IsEmpty());
+  CHECK(obj->ToString(env.local()).IsEmpty());
   CheckUncle(&try_catch);
 
-  Local<Value> to_number_result = obj->ToNumber(isolate);
-  CHECK(to_number_result.IsEmpty());
+  CHECK(obj->ToNumber(env.local()).IsEmpty());
   CheckUncle(&try_catch);
 
-  Local<Value> to_integer_result = obj->ToInteger(isolate);
-  CHECK(to_integer_result.IsEmpty());
+  CHECK(obj->ToInteger(env.local()).IsEmpty());
   CheckUncle(&try_catch);
 
-  Local<Value> to_uint32_result = obj->ToUint32(isolate);
-  CHECK(to_uint32_result.IsEmpty());
+  CHECK(obj->ToUint32(env.local()).IsEmpty());
   CheckUncle(&try_catch);
 
-  Local<Value> to_int32_result = obj->ToInt32(isolate);
-  CHECK(to_int32_result.IsEmpty());
+  CHECK(obj->ToInt32(env.local()).IsEmpty());
   CheckUncle(&try_catch);
 
-  Local<Value> to_object_result = v8::Undefined(isolate)->ToObject(isolate);
-  CHECK(to_object_result.IsEmpty());
+  CHECK(v8::Undefined(isolate)->ToObject(env.local()).IsEmpty());
   CHECK(try_catch.HasCaught());
   try_catch.Reset();
 
-  int32_t int32_value = obj->Int32Value();
-  CHECK_EQ(0, int32_value);
+  CHECK(obj->Int32Value(env.local()).IsNothing());
   CheckUncle(&try_catch);
 
-  uint32_t uint32_value = obj->Uint32Value();
-  CHECK_EQ(0u, uint32_value);
+  CHECK(obj->Uint32Value(env.local()).IsNothing());
   CheckUncle(&try_catch);
 
-  double number_value = obj->NumberValue();
-  CHECK(std::isnan(number_value));
+  CHECK(obj->NumberValue(env.local()).IsNothing());
   CheckUncle(&try_catch);
 
-  int64_t integer_value = obj->IntegerValue();
-  CHECK_EQ(0, integer_value);
+  CHECK(obj->IntegerValue(env.local()).IsNothing());
   CheckUncle(&try_catch);
 }
 
 
 void ThrowFromC(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   args.GetIsolate()->ThrowException(v8_str("konto"));
 }
 
 
 void CCatcher(const v8::FunctionCallbackInfo<v8::Value>& args) {
   if (args.Length() < 1) {
     args.GetReturnValue().Set(false);
     return;
   }
   v8::HandleScope scope(args.GetIsolate());
   v8::TryCatch try_catch(args.GetIsolate());
-  Local<Value> result = CompileRun(args[0]->ToString(args.GetIsolate()));
+  Local<Value> result =
+      CompileRun(args[0]
+                     ->ToString(args.GetIsolate()->GetCurrentContext())
+                     .ToLocalChecked());
   CHECK(!try_catch.HasCaught() || result.IsEmpty());
   args.GetReturnValue().Set(try_catch.HasCaught());
 }
 
 
 THREADED_TEST(APICatch) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->Set(v8_str("ThrowFromC"),
              v8::FunctionTemplate::New(isolate, ThrowFromC));
   LocalContext context(0, templ);
   CompileRun(
       "var thrown = false;"
       "try {"
       "  ThrowFromC();"
       "} catch (e) {"
       "  thrown = true;"
       "}");
-  Local<Value> thrown = context->Global()->Get(v8_str("thrown"));
-  CHECK(thrown->BooleanValue());
+  Local<Value> thrown = context->Global()
+                            ->Get(context.local(), v8_str("thrown"))
+                            .ToLocalChecked();
+  CHECK(thrown->BooleanValue(context.local()).FromJust());
 }
 
 
 THREADED_TEST(APIThrowTryCatch) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->Set(v8_str("ThrowFromC"),
              v8::FunctionTemplate::New(isolate, ThrowFromC));
   LocalContext context(0, templ);
@@ skipping 21 matching lines @@
       "  try {"
       "    CCatcher('throw 7;');"
       "  } finally {"
       "  }"
       "} catch (e) {"
       "}");
   CHECK(result->IsTrue());
 }
 
 
-static void check_reference_error_message(v8::Handle<v8::Message> message,
-                                          v8::Handle<v8::Value> data) {
+static void check_reference_error_message(v8::Local<v8::Message> message,
+                                          v8::Local<v8::Value> data) {
   const char* reference_error = "Uncaught ReferenceError: asdf is not defined";
-  CHECK(message->Get()->Equals(v8_str(reference_error)));
+  CHECK(message->Get()
+            ->Equals(CcTest::isolate()->GetCurrentContext(),
+                     v8_str(reference_error))
+            .FromJust());
 }
 
 
 static void Fail(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   CHECK(false);
 }
 
 
 // Test that overwritten methods are not invoked on uncaught exception
 // formatting. However, they are invoked when performing normal error
 // string conversions.
 TEST(APIThrowMessageOverwrittenToString) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::V8::AddMessageListener(check_reference_error_message);
+  isolate->AddMessageListener(check_reference_error_message);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->Set(v8_str("fail"), v8::FunctionTemplate::New(isolate, Fail));
   LocalContext context(NULL, templ);
   CompileRun("asdf;");
   CompileRun(
       "var limit = {};"
       "limit.valueOf = fail;"
       "Error.stackTraceLimit = limit;");
   CompileRun("asdf");
   CompileRun("Array.prototype.pop = fail;");
   CompileRun("Object.prototype.hasOwnProperty = fail;");
   CompileRun("Object.prototype.toString = function f() { return 'Yikes'; }");
   CompileRun("Number.prototype.toString = function f() { return 'Yikes'; }");
   CompileRun("String.prototype.toString = function f() { return 'Yikes'; }");
   CompileRun(
       "ReferenceError.prototype.toString ="
       "  function() { return 'Whoops' }");
   CompileRun("asdf;");
   CompileRun("ReferenceError.prototype.constructor.name = void 0;");
   CompileRun("asdf;");
   CompileRun("ReferenceError.prototype.constructor = void 0;");
   CompileRun("asdf;");
   CompileRun("ReferenceError.prototype.__proto__ = new Object();");
   CompileRun("asdf;");
   CompileRun("ReferenceError.prototype = new Object();");
   CompileRun("asdf;");
-  v8::Handle<Value> string = CompileRun("try { asdf; } catch(e) { e + ''; }");
-  CHECK(string->Equals(v8_str("Whoops")));
+  v8::Local<Value> string = CompileRun("try { asdf; } catch(e) { e + ''; }");
+  CHECK(string->Equals(context.local(), v8_str("Whoops")).FromJust());
   CompileRun(
       "ReferenceError.prototype.constructor = new Object();"
       "ReferenceError.prototype.constructor.name = 1;"
       "Number.prototype.toString = function() { return 'Whoops'; };"
       "ReferenceError.prototype.toString = Object.prototype.toString;");
   CompileRun("asdf;");
-  v8::V8::RemoveMessageListeners(check_reference_error_message);
+  isolate->RemoveMessageListeners(check_reference_error_message);
 }
 
 
-static void check_custom_error_tostring(v8::Handle<v8::Message> message,
-                                        v8::Handle<v8::Value> data) {
+static void check_custom_error_tostring(v8::Local<v8::Message> message,
+                                        v8::Local<v8::Value> data) {
   const char* uncaught_error = "Uncaught MyError toString";
-  CHECK(message->Get()->Equals(v8_str(uncaught_error)));
+  CHECK(message->Get()
+            ->Equals(CcTest::isolate()->GetCurrentContext(),
+                     v8_str(uncaught_error))
+            .FromJust());
 }
 
 
 TEST(CustomErrorToString) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
-  v8::V8::AddMessageListener(check_custom_error_tostring);
+  context->GetIsolate()->AddMessageListener(check_custom_error_tostring);
   CompileRun(
       "function MyError(name, message) {                   "
       "  this.name = name;                                 "
       "  this.message = message;                           "
       "}                                                   "
       "MyError.prototype = Object.create(Error.prototype); "
       "MyError.prototype.toString = function() {           "
       "  return 'MyError toString';                        "
       "};                                                  "
       "throw new MyError('my name', 'my message');         ");
-  v8::V8::RemoveMessageListeners(check_custom_error_tostring);
+  context->GetIsolate()->RemoveMessageListeners(check_custom_error_tostring);
 }
 
 
-static void check_custom_error_message(v8::Handle<v8::Message> message,
-                                       v8::Handle<v8::Value> data) {
+static void check_custom_error_message(v8::Local<v8::Message> message,
+                                       v8::Local<v8::Value> data) {
   const char* uncaught_error = "Uncaught MyError: my message";
   printf("%s\n", *v8::String::Utf8Value(message->Get()));
-  CHECK(message->Get()->Equals(v8_str(uncaught_error)));
+  CHECK(message->Get()
+            ->Equals(CcTest::isolate()->GetCurrentContext(),
+                     v8_str(uncaught_error))
+            .FromJust());
 }
 
 
 TEST(CustomErrorMessage) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
-  v8::V8::AddMessageListener(check_custom_error_message);
+  context->GetIsolate()->AddMessageListener(check_custom_error_message);
 
   // Handlebars.
   CompileRun(
       "function MyError(msg) {                             "
       "  this.name = 'MyError';                            "
       "  this.message = msg;                               "
       "}                                                   "
       "MyError.prototype = new Error();                    "
       "throw new MyError('my message');                    ");
 
@@ skipping 15 matching lines @@
 
   // Object.create.
   CompileRun(
       "function MyError(msg) {                             "
       "  this.name = 'MyError';                            "
       "  this.message = msg;                               "
       "}                                                   "
       "MyError.prototype = Object.create(Error.prototype); "
       "throw new MyError('my message');                    ");
 
-  v8::V8::RemoveMessageListeners(check_custom_error_message);
+  context->GetIsolate()->RemoveMessageListeners(check_custom_error_message);
 }
 
 
-static void check_custom_rethrowing_message(v8::Handle<v8::Message> message,
-                                            v8::Handle<v8::Value> data) {
+static void check_custom_rethrowing_message(v8::Local<v8::Message> message,
+                                            v8::Local<v8::Value> data) {
   const char* uncaught_error = "Uncaught exception";
-  CHECK(message->Get()->Equals(v8_str(uncaught_error)));
+  CHECK(message->Get()
+            ->Equals(CcTest::isolate()->GetCurrentContext(),
+                     v8_str(uncaught_error))
+            .FromJust());
 }
 
 
 TEST(CustomErrorRethrowsOnToString) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
-  v8::V8::AddMessageListener(check_custom_rethrowing_message);
+  context->GetIsolate()->AddMessageListener(check_custom_rethrowing_message);
 
   CompileRun(
       "var e = { toString: function() { throw e; } };"
       "try { throw e; } finally {}");
 
-  v8::V8::RemoveMessageListeners(check_custom_rethrowing_message);
+  context->GetIsolate()->RemoveMessageListeners(
+      check_custom_rethrowing_message);
 }
 
 
-static void receive_message(v8::Handle<v8::Message> message,
-                            v8::Handle<v8::Value> data) {
+static void receive_message(v8::Local<v8::Message> message,
+                            v8::Local<v8::Value> data) {
   message->Get();
   message_received = true;
 }
 
 
 TEST(APIThrowMessage) {
   message_received = false;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::V8::AddMessageListener(receive_message);
+  isolate->AddMessageListener(receive_message);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->Set(v8_str("ThrowFromC"),
              v8::FunctionTemplate::New(isolate, ThrowFromC));
   LocalContext context(0, templ);
   CompileRun("ThrowFromC();");
   CHECK(message_received);
-  v8::V8::RemoveMessageListeners(receive_message);
+  isolate->RemoveMessageListeners(receive_message);
 }
 
 
 TEST(APIThrowMessageAndVerboseTryCatch) {
   message_received = false;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::V8::AddMessageListener(receive_message);
+  isolate->AddMessageListener(receive_message);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->Set(v8_str("ThrowFromC"),
              v8::FunctionTemplate::New(isolate, ThrowFromC));
   LocalContext context(0, templ);
   v8::TryCatch try_catch(isolate);
   try_catch.SetVerbose(true);
   Local<Value> result = CompileRun("ThrowFromC();");
   CHECK(try_catch.HasCaught());
   CHECK(result.IsEmpty());
   CHECK(message_received);
-  v8::V8::RemoveMessageListeners(receive_message);
+  isolate->RemoveMessageListeners(receive_message);
 }
 
 
 TEST(APIStackOverflowAndVerboseTryCatch) {
   message_received = false;
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
-  v8::V8::AddMessageListener(receive_message);
+  context->GetIsolate()->AddMessageListener(receive_message);
   v8::TryCatch try_catch(context->GetIsolate());
   try_catch.SetVerbose(true);
   Local<Value> result = CompileRun("function foo() { foo(); } foo();");
   CHECK(try_catch.HasCaught());
   CHECK(result.IsEmpty());
   CHECK(message_received);
-  v8::V8::RemoveMessageListeners(receive_message);
+  context->GetIsolate()->RemoveMessageListeners(receive_message);
 }
 
 
 THREADED_TEST(ExternalScriptException) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->Set(v8_str("ThrowFromC"),
              v8::FunctionTemplate::New(isolate, ThrowFromC));
   LocalContext context(0, templ);
 
   v8::TryCatch try_catch(isolate);
   Local<Value> result = CompileRun("ThrowFromC(); throw 'panama';");
   CHECK(result.IsEmpty());
   CHECK(try_catch.HasCaught());
   String::Utf8Value exception_value(try_catch.Exception());
   CHECK_EQ(0, strcmp("konto", *exception_value));
 }
 
 
 void CThrowCountDown(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   CHECK_EQ(4, args.Length());
-  int count = args[0]->Int32Value();
-  int cInterval = args[2]->Int32Value();
+  v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
+  int count = args[0]->Int32Value(context).FromJust();
+  int cInterval = args[2]->Int32Value(context).FromJust();
   if (count == 0) {
     args.GetIsolate()->ThrowException(v8_str("FromC"));
     return;
   } else {
-    Local<v8::Object> global = args.GetIsolate()->GetCurrentContext()->Global();
-    Local<Value> fun = global->Get(v8_str("JSThrowCountDown"));
-    v8::Handle<Value> argv[] = {v8_num(count - 1), args[1], args[2], args[3]};
+    Local<v8::Object> global = context->Global();
+    Local<Value> fun =
+        global->Get(context, v8_str("JSThrowCountDown")).ToLocalChecked();
+    v8::Local<Value> argv[] = {v8_num(count - 1), args[1], args[2], args[3]};
     if (count % cInterval == 0) {
       v8::TryCatch try_catch(args.GetIsolate());
-      Local<Value> result = fun.As<Function>()->Call(global, 4, argv);
-      int expected = args[3]->Int32Value();
+      Local<Value> result = fun.As<Function>()
+                                ->Call(context, global, 4, argv)
+                                .FromMaybe(Local<Value>());
+      int expected = args[3]->Int32Value(context).FromJust();
       if (try_catch.HasCaught()) {
         CHECK_EQ(expected, count);
         CHECK(result.IsEmpty());
         CHECK(!CcTest::i_isolate()->has_scheduled_exception());
       } else {
         CHECK_NE(expected, count);
       }
       args.GetReturnValue().Set(result);
       return;
     } else {
-      args.GetReturnValue().Set(fun.As<Function>()->Call(global, 4, argv));
+      args.GetReturnValue().Set(fun.As<Function>()
+                                    ->Call(context, global, 4, argv)
+                                    .FromMaybe(v8::Local<v8::Value>()));
       return;
     }
   }
 }
 
 
 void JSCheck(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   CHECK_EQ(3, args.Length());
-  bool equality = args[0]->BooleanValue();
-  int count = args[1]->Int32Value();
-  int expected = args[2]->Int32Value();
+  v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
+  bool equality = args[0]->BooleanValue(context).FromJust();
+  int count = args[1]->Int32Value(context).FromJust();
+  int expected = args[2]->Int32Value(context).FromJust();
   if (equality) {
     CHECK_EQ(count, expected);
   } else {
     CHECK_NE(count, expected);
   }
 }
 
 
 THREADED_TEST(EvalInTryFinally) {
   LocalContext context;
@@ skipping 50 matching lines @@
       "                                  expected);"
       "      check(false, count, expected);"
       "      return value;"
       "    } catch (e) {"
       "      check(true, count, expected);"
       "    }"
       "  } else {"
       "    return CThrowCountDown(count - 1, jsInterval, cInterval, expected);"
       "  }"
       "}");
-  Local<Function> fun =
-      Local<Function>::Cast(context->Global()->Get(v8_str("JSThrowCountDown")));
+  Local<Function> fun = Local<Function>::Cast(
+      context->Global()
+          ->Get(context.local(), v8_str("JSThrowCountDown"))
+          .ToLocalChecked());
 
   const int argc = 4;
   //                             count      jsInterval cInterval  expected
 
   // *JS[4] *C[3] @JS[2] C[1] JS[0]
-  v8::Handle<Value> a0[argc] = {v8_num(4), v8_num(2), v8_num(3), v8_num(2)};
-  fun->Call(fun, argc, a0);
+  v8::Local<Value> a0[argc] = {v8_num(4), v8_num(2), v8_num(3), v8_num(2)};
+  fun->Call(context.local(), fun, argc, a0).ToLocalChecked();
 
   // JS[5] *C[4] JS[3] @C[2] JS[1] C[0]
-  v8::Handle<Value> a1[argc] = {v8_num(5), v8_num(6), v8_num(1), v8_num(2)};
-  fun->Call(fun, argc, a1);
+  v8::Local<Value> a1[argc] = {v8_num(5), v8_num(6), v8_num(1), v8_num(2)};
+  fun->Call(context.local(), fun, argc, a1).ToLocalChecked();
 
   // JS[6] @C[5] JS[4] C[3] JS[2] C[1] JS[0]
-  v8::Handle<Value> a2[argc] = {v8_num(6), v8_num(7), v8_num(5), v8_num(5)};
-  fun->Call(fun, argc, a2);
+  v8::Local<Value> a2[argc] = {v8_num(6), v8_num(7), v8_num(5), v8_num(5)};
+  fun->Call(context.local(), fun, argc, a2).ToLocalChecked();
 
   // @JS[6] C[5] JS[4] C[3] JS[2] C[1] JS[0]
-  v8::Handle<Value> a3[argc] = {v8_num(6), v8_num(6), v8_num(7), v8_num(6)};
-  fun->Call(fun, argc, a3);
+  v8::Local<Value> a3[argc] = {v8_num(6), v8_num(6), v8_num(7), v8_num(6)};
+  fun->Call(context.local(), fun, argc, a3).ToLocalChecked();
 
   // JS[6] *C[5] @JS[4] C[3] JS[2] C[1] JS[0]
-  v8::Handle<Value> a4[argc] = {v8_num(6), v8_num(4), v8_num(5), v8_num(4)};
-  fun->Call(fun, argc, a4);
+  v8::Local<Value> a4[argc] = {v8_num(6), v8_num(4), v8_num(5), v8_num(4)};
+  fun->Call(context.local(), fun, argc, a4).ToLocalChecked();
 
   // JS[6] C[5] *JS[4] @C[3] JS[2] C[1] JS[0]
-  v8::Handle<Value> a5[argc] = {v8_num(6), v8_num(4), v8_num(3), v8_num(3)};
-  fun->Call(fun, argc, a5);
+  v8::Local<Value> a5[argc] = {v8_num(6), v8_num(4), v8_num(3), v8_num(3)};
+  fun->Call(context.local(), fun, argc, a5).ToLocalChecked();
 }
 
 
 void ThrowValue(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   CHECK_EQ(1, args.Length());
   args.GetIsolate()->ThrowException(args[0]);
 }
 
 
 THREADED_TEST(ThrowValues) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->Set(v8_str("Throw"), v8::FunctionTemplate::New(isolate, ThrowValue));
   LocalContext context(0, templ);
-  v8::Handle<v8::Array> result = v8::Handle<v8::Array>::Cast(CompileRun(
-      "function Run(obj) {"
-      "  try {"
-      "    Throw(obj);"
-      "  } catch (e) {"
-      "    return e;"
-      "  }"
-      "  return 'no exception';"
-      "}"
-      "[Run('str'), Run(1), Run(0), Run(null), Run(void 0)];"));
+  v8::Local<v8::Array> result = v8::Local<v8::Array>::Cast(
+      CompileRun("function Run(obj) {"
+                 "  try {"
+                 "    Throw(obj);"
+                 "  } catch (e) {"
+                 "    return e;"
+                 "  }"
+                 "  return 'no exception';"
+                 "}"
+                 "[Run('str'), Run(1), Run(0), Run(null), Run(void 0)];"));
   CHECK_EQ(5u, result->Length());
-  CHECK(result->Get(v8::Integer::New(isolate, 0))->IsString());
-  CHECK(result->Get(v8::Integer::New(isolate, 1))->IsNumber());
-  CHECK_EQ(1, result->Get(v8::Integer::New(isolate, 1))->Int32Value());
-  CHECK(result->Get(v8::Integer::New(isolate, 2))->IsNumber());
-  CHECK_EQ(0, result->Get(v8::Integer::New(isolate, 2))->Int32Value());
-  CHECK(result->Get(v8::Integer::New(isolate, 3))->IsNull());
-  CHECK(result->Get(v8::Integer::New(isolate, 4))->IsUndefined());
+  CHECK(result->Get(context.local(), v8::Integer::New(isolate, 0))
+            .ToLocalChecked()
+            ->IsString());
+  CHECK(result->Get(context.local(), v8::Integer::New(isolate, 1))
+            .ToLocalChecked()
+            ->IsNumber());
+  CHECK_EQ(1, result->Get(context.local(), v8::Integer::New(isolate, 1))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK(result->Get(context.local(), v8::Integer::New(isolate, 2))
+            .ToLocalChecked()
+            ->IsNumber());
+  CHECK_EQ(0, result->Get(context.local(), v8::Integer::New(isolate, 2))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK(result->Get(context.local(), v8::Integer::New(isolate, 3))
+            .ToLocalChecked()
+            ->IsNull());
+  CHECK(result->Get(context.local(), v8::Integer::New(isolate, 4))
+            .ToLocalChecked()
+            ->IsUndefined());
 }
 
 
 THREADED_TEST(CatchZero) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   v8::TryCatch try_catch(context->GetIsolate());
   CHECK(!try_catch.HasCaught());
   CompileRun("throw 10");
   CHECK(try_catch.HasCaught());
-  CHECK_EQ(10, try_catch.Exception()->Int32Value());
+  CHECK_EQ(10, try_catch.Exception()->Int32Value(context.local()).FromJust());
   try_catch.Reset();
   CHECK(!try_catch.HasCaught());
   CompileRun("throw 0");
   CHECK(try_catch.HasCaught());
-  CHECK_EQ(0, try_catch.Exception()->Int32Value());
+  CHECK_EQ(0, try_catch.Exception()->Int32Value(context.local()).FromJust());
 }
 
 
 THREADED_TEST(CatchExceptionFromWith) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   v8::TryCatch try_catch(context->GetIsolate());
   CHECK(!try_catch.HasCaught());
   CompileRun("var o = {}; with (o) { throw 42; }");
   CHECK(try_catch.HasCaught());
@@ skipping 13 matching lines @@
 
 void WithTryCatch(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::TryCatch try_catch(args.GetIsolate());
 }
 
 
 THREADED_TEST(TryCatchAndFinally) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
-  context->Global()->Set(
-      v8_str("native_with_try_catch"),
-      v8::FunctionTemplate::New(isolate, WithTryCatch)->GetFunction());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("native_with_try_catch"),
+                  v8::FunctionTemplate::New(isolate, WithTryCatch)
+                      ->GetFunction(context.local())
+                      .ToLocalChecked())
+            .FromJust());
   v8::TryCatch try_catch(isolate);
   CHECK(!try_catch.HasCaught());
   CompileRun(
       "try {\n"
       "  throw new Error('a');\n"
       "} finally {\n"
       "  native_with_try_catch();\n"
       "}\n");
   CHECK(try_catch.HasCaught());
 }
@@ skipping 43 matching lines @@
     v8::TryCatch try_catch(context->GetIsolate());
     TryCatchNested2Helper(5);
     CHECK(try_catch.HasCaught());
     CHECK_EQ(0, strcmp(*v8::String::Utf8Value(try_catch.Exception()), "E2"));
   }
 }
 
 
 void TryCatchMixedNestingCheck(v8::TryCatch* try_catch) {
   CHECK(try_catch->HasCaught());
-  Handle<Message> message = try_catch->Message();
-  Handle<Value> resource = message->GetScriptOrigin().ResourceName();
+  Local<Message> message = try_catch->Message();
+  Local<Value> resource = message->GetScriptOrigin().ResourceName();
   CHECK_EQ(0, strcmp(*v8::String::Utf8Value(resource), "inner"));
   CHECK_EQ(0,
            strcmp(*v8::String::Utf8Value(message->Get()), "Uncaught Error: a"));
-  CHECK_EQ(1, message->GetLineNumber());
-  CHECK_EQ(0, message->GetStartColumn());
+  CHECK_EQ(1, message->GetLineNumber(CcTest::isolate()->GetCurrentContext())
+                  .FromJust());
+  CHECK_EQ(0, message->GetStartColumn(CcTest::isolate()->GetCurrentContext())
+                  .FromJust());
 }
 
 
 void TryCatchMixedNestingHelper(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   v8::TryCatch try_catch(args.GetIsolate());
   CompileRunWithOrigin("throw new Error('a');\n", "inner", 0, 0);
   CHECK(try_catch.HasCaught());
   TryCatchMixedNestingCheck(&try_catch);
@@ skipping 65 matching lines @@
   CompileRun("TryCatchNativeResetHelper();");
   CHECK(!try_catch.HasCaught());
 }
 
 
 THREADED_TEST(Equality) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(context->GetIsolate());
   // Check that equality works at all before relying on CHECK_EQ
-  CHECK(v8_str("a")->Equals(v8_str("a")));
-  CHECK(!v8_str("a")->Equals(v8_str("b")));
+  CHECK(v8_str("a")->Equals(context.local(), v8_str("a")).FromJust());
+  CHECK(!v8_str("a")->Equals(context.local(), v8_str("b")).FromJust());
 
-  CHECK(v8_str("a")->Equals(v8_str("a")));
-  CHECK(!v8_str("a")->Equals(v8_str("b")));
-  CHECK(v8_num(1)->Equals(v8_num(1)));
-  CHECK(v8_num(1.00)->Equals(v8_num(1)));
-  CHECK(!v8_num(1)->Equals(v8_num(2)));
+  CHECK(v8_str("a")->Equals(context.local(), v8_str("a")).FromJust());
+  CHECK(!v8_str("a")->Equals(context.local(), v8_str("b")).FromJust());
+  CHECK(v8_num(1)->Equals(context.local(), v8_num(1)).FromJust());
+  CHECK(v8_num(1.00)->Equals(context.local(), v8_num(1)).FromJust());
+  CHECK(!v8_num(1)->Equals(context.local(), v8_num(2)).FromJust());
 
   // Assume String is not internalized.
   CHECK(v8_str("a")->StrictEquals(v8_str("a")));
   CHECK(!v8_str("a")->StrictEquals(v8_str("b")));
   CHECK(!v8_str("5")->StrictEquals(v8_num(5)));
   CHECK(v8_num(1)->StrictEquals(v8_num(1)));
   CHECK(!v8_num(1)->StrictEquals(v8_num(2)));
   CHECK(v8_num(0.0)->StrictEquals(v8_num(-0.0)));
   Local<Value> not_a_number = v8_num(std::numeric_limits<double>::quiet_NaN());
   CHECK(!not_a_number->StrictEquals(not_a_number));
   CHECK(v8::False(isolate)->StrictEquals(v8::False(isolate)));
   CHECK(!v8::False(isolate)->StrictEquals(v8::Undefined(isolate)));
 
-  v8::Handle<v8::Object> obj = v8::Object::New(isolate);
+  v8::Local<v8::Object> obj = v8::Object::New(isolate);
   v8::Persistent<v8::Object> alias(isolate, obj);
   CHECK(v8::Local<v8::Object>::New(isolate, alias)->StrictEquals(obj));
   alias.Reset();
 
   CHECK(v8_str("a")->SameValue(v8_str("a")));
   CHECK(!v8_str("a")->SameValue(v8_str("b")));
   CHECK(!v8_str("5")->SameValue(v8_num(5)));
   CHECK(v8_num(1)->SameValue(v8_num(1)));
   CHECK(!v8_num(1)->SameValue(v8_num(2)));
   CHECK(!v8_num(0.0)->SameValue(v8_num(-0.0)));
   CHECK(not_a_number->SameValue(not_a_number));
   CHECK(v8::False(isolate)->SameValue(v8::False(isolate)));
   CHECK(!v8::False(isolate)->SameValue(v8::Undefined(isolate)));
 }
 
 
 THREADED_TEST(MultiRun) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   Local<Script> script = v8_compile("x");
-  for (int i = 0; i < 10; i++) script->Run();
+  for (int i = 0; i < 10; i++) {
+    script->Run(context.local()).IsEmpty();
+  }
 }
 
 
-static void GetXValue(Local<String> name,
+static void GetXValue(Local<Name> name,
                       const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
-  CHECK(info.Data()->Equals(v8_str("donut")));
-  CHECK(name->Equals(v8_str("x")));
+  CHECK(info.Data()
+            ->Equals(CcTest::isolate()->GetCurrentContext(), v8_str("donut"))
+            .FromJust());
+  CHECK(name->Equals(CcTest::isolate()->GetCurrentContext(), v8_str("x"))
+            .FromJust());
   info.GetReturnValue().Set(name);
 }
 
 
 THREADED_TEST(SimplePropertyRead) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->SetAccessor(v8_str("x"), GetXValue, NULL, v8_str("donut"));
-  context->Global()->Set(v8_str("obj"), templ->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("obj"),
+                  templ->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   Local<Script> script = v8_compile("obj.x");
   for (int i = 0; i < 10; i++) {
-    Local<Value> result = script->Run();
-    CHECK(result->Equals(v8_str("x")));
+    Local<Value> result = script->Run(context.local()).ToLocalChecked();
+    CHECK(result->Equals(context.local(), v8_str("x")).FromJust());
   }
 }
 
 
 THREADED_TEST(DefinePropertyOnAPIAccessor) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->SetAccessor(v8_str("x"), GetXValue, NULL, v8_str("donut"));
-  context->Global()->Set(v8_str("obj"), templ->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("obj"),
+                  templ->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
 
   // Uses getOwnPropertyDescriptor to check the configurable status
   Local<Script> script_desc = v8_compile(
       "var prop = Object.getOwnPropertyDescriptor( "
       "obj, 'x');"
       "prop.configurable;");
-  Local<Value> result = script_desc->Run();
-  CHECK_EQ(result->BooleanValue(), true);
+  Local<Value> result = script_desc->Run(context.local()).ToLocalChecked();
+  CHECK_EQ(result->BooleanValue(context.local()).FromJust(), true);
 
   // Redefine get - but still configurable
   Local<Script> script_define = v8_compile(
       "var desc = { get: function(){return 42; },"
       "            configurable: true };"
       "Object.defineProperty(obj, 'x', desc);"
       "obj.x");
-  result = script_define->Run();
-  CHECK(result->Equals(v8_num(42)));
+  result = script_define->Run(context.local()).ToLocalChecked();
+  CHECK(result->Equals(context.local(), v8_num(42)).FromJust());
 
   // Check that the accessor is still configurable
-  result = script_desc->Run();
-  CHECK_EQ(result->BooleanValue(), true);
+  result = script_desc->Run(context.local()).ToLocalChecked();
+  CHECK_EQ(result->BooleanValue(context.local()).FromJust(), true);
 
   // Redefine to a non-configurable
   script_define = v8_compile(
       "var desc = { get: function(){return 43; },"
       "             configurable: false };"
       "Object.defineProperty(obj, 'x', desc);"
       "obj.x");
-  result = script_define->Run();
-  CHECK(result->Equals(v8_num(43)));
-  result = script_desc->Run();
-  CHECK_EQ(result->BooleanValue(), false);
+  result = script_define->Run(context.local()).ToLocalChecked();
+  CHECK(result->Equals(context.local(), v8_num(43)).FromJust());
+  result = script_desc->Run(context.local()).ToLocalChecked();
+  CHECK_EQ(result->BooleanValue(context.local()).FromJust(), false);
 
   // Make sure that it is not possible to redefine again
   v8::TryCatch try_catch(isolate);
-  result = script_define->Run();
+  CHECK(script_define->Run(context.local()).IsEmpty());
   CHECK(try_catch.HasCaught());
   String::Utf8Value exception_value(try_catch.Exception());
   CHECK_EQ(0,
            strcmp(*exception_value, "TypeError: Cannot redefine property: x"));
 }
 
 
 THREADED_TEST(DefinePropertyOnDefineGetterSetter) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->SetAccessor(v8_str("x"), GetXValue, NULL, v8_str("donut"));
   LocalContext context;
-  context->Global()->Set(v8_str("obj"), templ->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("obj"),
+                  templ->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
 
   Local<Script> script_desc = v8_compile(
       "var prop ="
       "Object.getOwnPropertyDescriptor( "
       "obj, 'x');"
       "prop.configurable;");
-  Local<Value> result = script_desc->Run();
-  CHECK_EQ(result->BooleanValue(), true);
+  Local<Value> result = script_desc->Run(context.local()).ToLocalChecked();
+  CHECK_EQ(result->BooleanValue(context.local()).FromJust(), true);
 
   Local<Script> script_define = v8_compile(
       "var desc = {get: function(){return 42; },"
       "            configurable: true };"
       "Object.defineProperty(obj, 'x', desc);"
       "obj.x");
-  result = script_define->Run();
-  CHECK(result->Equals(v8_num(42)));
+  result = script_define->Run(context.local()).ToLocalChecked();
+  CHECK(result->Equals(context.local(), v8_num(42)).FromJust());
 
-
-  result = script_desc->Run();
-  CHECK_EQ(result->BooleanValue(), true);
-
+  result = script_desc->Run(context.local()).ToLocalChecked();
+  CHECK_EQ(result->BooleanValue(context.local()).FromJust(), true);
 
   script_define = v8_compile(
       "var desc = {get: function(){return 43; },"
       "            configurable: false };"
       "Object.defineProperty(obj, 'x', desc);"
       "obj.x");
-  result = script_define->Run();
-  CHECK(result->Equals(v8_num(43)));
-  result = script_desc->Run();
+  result = script_define->Run(context.local()).ToLocalChecked();
+  CHECK(result->Equals(context.local(), v8_num(43)).FromJust());
 
-  CHECK_EQ(result->BooleanValue(), false);
+  result = script_desc->Run(context.local()).ToLocalChecked();
+  CHECK_EQ(result->BooleanValue(context.local()).FromJust(), false);
 
   v8::TryCatch try_catch(isolate);
-  result = script_define->Run();
+  CHECK(script_define->Run(context.local()).IsEmpty());
   CHECK(try_catch.HasCaught());
   String::Utf8Value exception_value(try_catch.Exception());
   CHECK_EQ(0,
            strcmp(*exception_value, "TypeError: Cannot redefine property: x"));
 }
 
 
-static v8::Handle<v8::Object> GetGlobalProperty(LocalContext* context,
-                                                char const* name) {
-  return v8::Handle<v8::Object>::Cast((*context)->Global()->Get(v8_str(name)));
+static v8::Local<v8::Object> GetGlobalProperty(LocalContext* context,
+                                               char const* name) {
+  return v8::Local<v8::Object>::Cast(
+      (*context)
+          ->Global()
+          ->Get(CcTest::isolate()->GetCurrentContext(), v8_str(name))
+          .ToLocalChecked());
 }
 
 
 THREADED_TEST(DefineAPIAccessorOnObject) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   LocalContext context;
 
-  context->Global()->Set(v8_str("obj1"), templ->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("obj1"),
+                  templ->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   CompileRun("var obj2 = {};");
 
   CHECK(CompileRun("obj1.x")->IsUndefined());
   CHECK(CompileRun("obj2.x")->IsUndefined());
 
   CHECK(GetGlobalProperty(&context, "obj1")
-            ->SetAccessor(v8_str("x"), GetXValue, NULL, v8_str("donut")));
+            ->SetAccessor(context.local(), v8_str("x"), GetXValue, NULL,
+                          v8_str("donut"))
+            .FromJust());
 
   ExpectString("obj1.x", "x");
   CHECK(CompileRun("obj2.x")->IsUndefined());
 
   CHECK(GetGlobalProperty(&context, "obj2")
-            ->SetAccessor(v8_str("x"), GetXValue, NULL, v8_str("donut")));
+            ->SetAccessor(context.local(), v8_str("x"), GetXValue, NULL,
+                          v8_str("donut"))
+            .FromJust());
 
   ExpectString("obj1.x", "x");
   ExpectString("obj2.x", "x");
 
   ExpectTrue("Object.getOwnPropertyDescriptor(obj1, 'x').configurable");
   ExpectTrue("Object.getOwnPropertyDescriptor(obj2, 'x').configurable");
 
   CompileRun(
       "Object.defineProperty(obj1, 'x',"
       "{ get: function() { return 'y'; }, configurable: true })");
 
   ExpectString("obj1.x", "y");
   ExpectString("obj2.x", "x");
 
   CompileRun(
       "Object.defineProperty(obj2, 'x',"
       "{ get: function() { return 'y'; }, configurable: true })");
 
   ExpectString("obj1.x", "y");
   ExpectString("obj2.x", "y");
 
   ExpectTrue("Object.getOwnPropertyDescriptor(obj1, 'x').configurable");
   ExpectTrue("Object.getOwnPropertyDescriptor(obj2, 'x').configurable");
 
   CHECK(GetGlobalProperty(&context, "obj1")
-            ->SetAccessor(v8_str("x"), GetXValue, NULL, v8_str("donut")));
+            ->SetAccessor(context.local(), v8_str("x"), GetXValue, NULL,
+                          v8_str("donut"))
+            .FromJust());
   CHECK(GetGlobalProperty(&context, "obj2")
-            ->SetAccessor(v8_str("x"), GetXValue, NULL, v8_str("donut")));
+            ->SetAccessor(context.local(), v8_str("x"), GetXValue, NULL,
+                          v8_str("donut"))
+            .FromJust());
 
   ExpectString("obj1.x", "x");
   ExpectString("obj2.x", "x");
 
   ExpectTrue("Object.getOwnPropertyDescriptor(obj1, 'x').configurable");
   ExpectTrue("Object.getOwnPropertyDescriptor(obj2, 'x').configurable");
 
   // Define getters/setters, but now make them not configurable.
   CompileRun(
       "Object.defineProperty(obj1, 'x',"
       "{ get: function() { return 'z'; }, configurable: false })");
   CompileRun(
       "Object.defineProperty(obj2, 'x',"
       "{ get: function() { return 'z'; }, configurable: false })");
-
   ExpectTrue("!Object.getOwnPropertyDescriptor(obj1, 'x').configurable");
   ExpectTrue("!Object.getOwnPropertyDescriptor(obj2, 'x').configurable");
 
   ExpectString("obj1.x", "z");
   ExpectString("obj2.x", "z");
 
-  CHECK(!GetGlobalProperty(&context, "obj1")
-             ->SetAccessor(v8_str("x"), GetXValue, NULL, v8_str("donut")));
-  CHECK(!GetGlobalProperty(&context, "obj2")
-             ->SetAccessor(v8_str("x"), GetXValue, NULL, v8_str("donut")));
+  CHECK(GetGlobalProperty(&context, "obj1")
+            ->SetAccessor(context.local(), v8_str("x"), GetXValue, NULL,
+                          v8_str("donut"))
+            .IsNothing());
+  CHECK(GetGlobalProperty(&context, "obj2")
+            ->SetAccessor(context.local(), v8_str("x"), GetXValue, NULL,
+                          v8_str("donut"))
+            .IsNothing());
 
   ExpectString("obj1.x", "z");
   ExpectString("obj2.x", "z");
 }
 
 
 THREADED_TEST(DontDeleteAPIAccessorsCannotBeOverriden) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   LocalContext context;
 
-  context->Global()->Set(v8_str("obj1"), templ->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("obj1"),
+                  templ->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   CompileRun("var obj2 = {};");
 
   CHECK(GetGlobalProperty(&context, "obj1")
-            ->SetAccessor(v8_str("x"), GetXValue, NULL, v8_str("donut"),
-                          v8::DEFAULT, v8::DontDelete));
+            ->SetAccessor(context.local(), v8_str("x"), GetXValue, NULL,
+                          v8_str("donut"), v8::DEFAULT, v8::DontDelete)
+            .FromJust());
   CHECK(GetGlobalProperty(&context, "obj2")
-            ->SetAccessor(v8_str("x"), GetXValue, NULL, v8_str("donut"),
-                          v8::DEFAULT, v8::DontDelete));
+            ->SetAccessor(context.local(), v8_str("x"), GetXValue, NULL,
+                          v8_str("donut"), v8::DEFAULT, v8::DontDelete)
+            .FromJust());
 
   ExpectString("obj1.x", "x");
   ExpectString("obj2.x", "x");
 
   ExpectTrue("!Object.getOwnPropertyDescriptor(obj1, 'x').configurable");
   ExpectTrue("!Object.getOwnPropertyDescriptor(obj2, 'x').configurable");
 
-  CHECK(!GetGlobalProperty(&context, "obj1")
-             ->SetAccessor(v8_str("x"), GetXValue, NULL, v8_str("donut")));
-  CHECK(!GetGlobalProperty(&context, "obj2")
-             ->SetAccessor(v8_str("x"), GetXValue, NULL, v8_str("donut")));
+  CHECK(GetGlobalProperty(&context, "obj1")
+            ->SetAccessor(context.local(), v8_str("x"), GetXValue, NULL,
+                          v8_str("donut"))
+            .IsNothing());
+  CHECK(GetGlobalProperty(&context, "obj2")
+            ->SetAccessor(context.local(), v8_str("x"), GetXValue, NULL,
+                          v8_str("donut"))
+            .IsNothing());
 
   {
     v8::TryCatch try_catch(isolate);
     CompileRun(
         "Object.defineProperty(obj1, 'x',"
         "{get: function() { return 'func'; }})");
     CHECK(try_catch.HasCaught());
     String::Utf8Value exception_value(try_catch.Exception());
     CHECK_EQ(
         0, strcmp(*exception_value, "TypeError: Cannot redefine property: x"));
   }
   {
     v8::TryCatch try_catch(isolate);
     CompileRun(
         "Object.defineProperty(obj2, 'x',"
         "{get: function() { return 'func'; }})");
     CHECK(try_catch.HasCaught());
     String::Utf8Value exception_value(try_catch.Exception());
     CHECK_EQ(
         0, strcmp(*exception_value, "TypeError: Cannot redefine property: x"));
   }
 }
 
 
-static void Get239Value(Local<String> name,
+static void Get239Value(Local<Name> name,
                         const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
-  CHECK(info.Data()->Equals(v8_str("donut")));
-  CHECK(name->Equals(v8_str("239")));
+  CHECK(info.Data()
+            ->Equals(info.GetIsolate()->GetCurrentContext(), v8_str("donut"))
+            .FromJust());
+  CHECK(name->Equals(info.GetIsolate()->GetCurrentContext(), v8_str("239"))
+            .FromJust());
   info.GetReturnValue().Set(name);
 }
 
 
 THREADED_TEST(ElementAPIAccessor) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   LocalContext context;
 
-  context->Global()->Set(v8_str("obj1"), templ->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("obj1"),
+                  templ->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   CompileRun("var obj2 = {};");
 
   CHECK(GetGlobalProperty(&context, "obj1")
-            ->SetAccessor(v8_str("239"), Get239Value, NULL, v8_str("donut")));
+            ->SetAccessor(context.local(), v8_str("239"), Get239Value, NULL,
+                          v8_str("donut"))
+            .FromJust());
   CHECK(GetGlobalProperty(&context, "obj2")
-            ->SetAccessor(v8_str("239"), Get239Value, NULL, v8_str("donut")));
+            ->SetAccessor(context.local(), v8_str("239"), Get239Value, NULL,
+                          v8_str("donut"))
+            .FromJust());
 
   ExpectString("obj1[239]", "239");
   ExpectString("obj2[239]", "239");
   ExpectString("obj1['239']", "239");
   ExpectString("obj2['239']", "239");
 }
 
 
 v8::Persistent<Value> xValue;
 
 
-static void SetXValue(Local<String> name, Local<Value> value,
+static void SetXValue(Local<Name> name, Local<Value> value,
                       const v8::PropertyCallbackInfo<void>& info) {
-  CHECK(value->Equals(v8_num(4)));
-  CHECK(info.Data()->Equals(v8_str("donut")));
-  CHECK(name->Equals(v8_str("x")));
+  Local<Context> context = info.GetIsolate()->GetCurrentContext();
+  CHECK(value->Equals(context, v8_num(4)).FromJust());
+  CHECK(info.Data()->Equals(context, v8_str("donut")).FromJust());
+  CHECK(name->Equals(context, v8_str("x")).FromJust());
   CHECK(xValue.IsEmpty());
   xValue.Reset(info.GetIsolate(), value);
 }
 
 
 THREADED_TEST(SimplePropertyWrite) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->SetAccessor(v8_str("x"), GetXValue, SetXValue, v8_str("donut"));
   LocalContext context;
-  context->Global()->Set(v8_str("obj"), templ->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("obj"),
+                  templ->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   Local<Script> script = v8_compile("obj.x = 4");
   for (int i = 0; i < 10; i++) {
     CHECK(xValue.IsEmpty());
-    script->Run();
-    CHECK(v8_num(4)->Equals(Local<Value>::New(CcTest::isolate(), xValue)));
+    script->Run(context.local()).ToLocalChecked();
+    CHECK(v8_num(4)
+              ->Equals(context.local(),
+                       Local<Value>::New(CcTest::isolate(), xValue))
+              .FromJust());
     xValue.Reset();
   }
 }
 
 
 THREADED_TEST(SetterOnly) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->SetAccessor(v8_str("x"), NULL, SetXValue, v8_str("donut"));
   LocalContext context;
-  context->Global()->Set(v8_str("obj"), templ->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("obj"),
+                  templ->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   Local<Script> script = v8_compile("obj.x = 4; obj.x");
   for (int i = 0; i < 10; i++) {
     CHECK(xValue.IsEmpty());
-    script->Run();
-    CHECK(v8_num(4)->Equals(Local<Value>::New(CcTest::isolate(), xValue)));
+    script->Run(context.local()).ToLocalChecked();
+    CHECK(v8_num(4)
+              ->Equals(context.local(),
+                       Local<Value>::New(CcTest::isolate(), xValue))
+              .FromJust());
     xValue.Reset();
   }
 }
 
 
 THREADED_TEST(NoAccessors) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->SetAccessor(v8_str("x"), static_cast<v8::AccessorGetterCallback>(NULL),
                      NULL, v8_str("donut"));
   LocalContext context;
-  context->Global()->Set(v8_str("obj"), templ->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("obj"),
+                  templ->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   Local<Script> script = v8_compile("obj.x = 4; obj.x");
   for (int i = 0; i < 10; i++) {
-    script->Run();
+    script->Run(context.local()).ToLocalChecked();
   }
 }
 
 
 THREADED_TEST(MultiContexts) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<ObjectTemplate> templ = ObjectTemplate::New(isolate);
+  v8::Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->Set(v8_str("dummy"),
              v8::FunctionTemplate::New(isolate, DummyCallHandler));
 
   Local<String> password = v8_str("Password");
 
   // Create an environment
   LocalContext context0(0, templ);
   context0->SetSecurityToken(password);
-  v8::Handle<v8::Object> global0 = context0->Global();
-  global0->Set(v8_str("custom"), v8_num(1234));
-  CHECK_EQ(1234, global0->Get(v8_str("custom"))->Int32Value());
+  v8::Local<v8::Object> global0 = context0->Global();
+  CHECK(global0->Set(context0.local(), v8_str("custom"), v8_num(1234))
+            .FromJust());
+  CHECK_EQ(1234, global0->Get(context0.local(), v8_str("custom"))
+                     .ToLocalChecked()
+                     ->Int32Value(context0.local())
+                     .FromJust());
 
   // Create an independent environment
   LocalContext context1(0, templ);
   context1->SetSecurityToken(password);
-  v8::Handle<v8::Object> global1 = context1->Global();
-  global1->Set(v8_str("custom"), v8_num(1234));
-  CHECK(!global0->Equals(global1));
-  CHECK_EQ(1234, global0->Get(v8_str("custom"))->Int32Value());
-  CHECK_EQ(1234, global1->Get(v8_str("custom"))->Int32Value());
+  v8::Local<v8::Object> global1 = context1->Global();
+  CHECK(global1->Set(context1.local(), v8_str("custom"), v8_num(1234))
+            .FromJust());
+  CHECK(!global0->Equals(context1.local(), global1).FromJust());
+  CHECK_EQ(1234, global0->Get(context1.local(), v8_str("custom"))
+                     .ToLocalChecked()
+                     ->Int32Value(context0.local())
+                     .FromJust());
+  CHECK_EQ(1234, global1->Get(context1.local(), v8_str("custom"))
+                     .ToLocalChecked()
+                     ->Int32Value(context1.local())
+                     .FromJust());
 
   // Now create a new context with the old global
   LocalContext context2(0, templ, global1);
   context2->SetSecurityToken(password);
-  v8::Handle<v8::Object> global2 = context2->Global();
-  CHECK(global1->Equals(global2));
-  CHECK_EQ(0, global1->Get(v8_str("custom"))->Int32Value());
-  CHECK_EQ(0, global2->Get(v8_str("custom"))->Int32Value());
+  v8::Local<v8::Object> global2 = context2->Global();
+  CHECK(global1->Equals(context2.local(), global2).FromJust());
+  CHECK_EQ(0, global1->Get(context2.local(), v8_str("custom"))
+                  .ToLocalChecked()
+                  ->Int32Value(context1.local())
+                  .FromJust());
+  CHECK_EQ(0, global2->Get(context2.local(), v8_str("custom"))
+                  .ToLocalChecked()
+                  ->Int32Value(context2.local())
+                  .FromJust());
 }
 
 
 THREADED_TEST(FunctionPrototypeAcrossContexts) {
   // Make sure that functions created by cloning boilerplates cannot
   // communicate through their __proto__ field.
 
   v8::HandleScope scope(CcTest::isolate());
 
   LocalContext env0;
-  v8::Handle<v8::Object> global0 = env0->Global();
-  v8::Handle<v8::Object> object0 =
-      global0->Get(v8_str("Object")).As<v8::Object>();
-  v8::Handle<v8::Object> tostring0 =
-      object0->Get(v8_str("toString")).As<v8::Object>();
-  v8::Handle<v8::Object> proto0 =
-      tostring0->Get(v8_str("__proto__")).As<v8::Object>();
-  proto0->Set(v8_str("custom"), v8_num(1234));
+  v8::Local<v8::Object> global0 = env0->Global();
+  v8::Local<v8::Object> object0 = global0->Get(env0.local(), v8_str("Object"))
+                                      .ToLocalChecked()
+                                      .As<v8::Object>();
+  v8::Local<v8::Object> tostring0 =
+      object0->Get(env0.local(), v8_str("toString"))
+          .ToLocalChecked()
+          .As<v8::Object>();
+  v8::Local<v8::Object> proto0 =
+      tostring0->Get(env0.local(), v8_str("__proto__"))
+          .ToLocalChecked()
+          .As<v8::Object>();
+  CHECK(proto0->Set(env0.local(), v8_str("custom"), v8_num(1234)).FromJust());
 
   LocalContext env1;
-  v8::Handle<v8::Object> global1 = env1->Global();
-  v8::Handle<v8::Object> object1 =
-      global1->Get(v8_str("Object")).As<v8::Object>();
-  v8::Handle<v8::Object> tostring1 =
-      object1->Get(v8_str("toString")).As<v8::Object>();
-  v8::Handle<v8::Object> proto1 =
-      tostring1->Get(v8_str("__proto__")).As<v8::Object>();
-  CHECK(!proto1->Has(v8_str("custom")));
+  v8::Local<v8::Object> global1 = env1->Global();
+  v8::Local<v8::Object> object1 = global1->Get(env1.local(), v8_str("Object"))
+                                      .ToLocalChecked()
+                                      .As<v8::Object>();
+  v8::Local<v8::Object> tostring1 =
+      object1->Get(env1.local(), v8_str("toString"))
+          .ToLocalChecked()
+          .As<v8::Object>();
+  v8::Local<v8::Object> proto1 =
+      tostring1->Get(env1.local(), v8_str("__proto__"))
+          .ToLocalChecked()
+          .As<v8::Object>();
+  CHECK(!proto1->Has(env1.local(), v8_str("custom")).FromJust());
 }
 
 
 THREADED_TEST(Regress892105) {
   // Make sure that object and array literals created by cloning
   // boilerplates cannot communicate through their __proto__
   // field. This is rather difficult to check, but we try to add stuff
   // to Object.prototype and Array.prototype and create a new
   // environment. This should succeed.
 
   v8::HandleScope scope(CcTest::isolate());
 
   Local<String> source = v8_str(
       "Object.prototype.obj = 1234;"
       "Array.prototype.arr = 4567;"
       "8901");
 
   LocalContext env0;
   Local<Script> script0 = v8_compile(source);
-  CHECK_EQ(8901.0, script0->Run()->NumberValue());
+  CHECK_EQ(8901.0, script0->Run(env0.local())
+                       .ToLocalChecked()
+                       ->NumberValue(env0.local())
+                       .FromJust());
 
   LocalContext env1;
   Local<Script> script1 = v8_compile(source);
-  CHECK_EQ(8901.0, script1->Run()->NumberValue());
+  CHECK_EQ(8901.0, script1->Run(env1.local())
+                       .ToLocalChecked()
+                       ->NumberValue(env1.local())
+                       .FromJust());
 }
 
 
 THREADED_TEST(UndetectableObject) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
 
   Local<v8::FunctionTemplate> desc =
       v8::FunctionTemplate::New(env->GetIsolate());
   desc->InstanceTemplate()->MarkAsUndetectable();  // undetectable
 
-  Local<v8::Object> obj = desc->GetFunction()->NewInstance();
-  env->Global()->Set(v8_str("undetectable"), obj);
+  Local<v8::Object> obj = desc->GetFunction(env.local())
+                              .ToLocalChecked()
+                              ->NewInstance(env.local())
+                              .ToLocalChecked();
+  CHECK(
+      env->Global()->Set(env.local(), v8_str("undetectable"), obj).FromJust());
 
   ExpectString("undetectable.toString()", "[object Object]");
   ExpectString("typeof undetectable", "undefined");
   ExpectString("typeof(undetectable)", "undefined");
   ExpectBoolean("typeof undetectable == 'undefined'", true);
   ExpectBoolean("typeof undetectable == 'object'", false);
   ExpectBoolean("if (undetectable) { true; } else { false; }", false);
   ExpectBoolean("!undetectable", true);
 
   ExpectObject("true&&undetectable", obj);
@@ skipping 22 matching lines @@
 
 
 THREADED_TEST(VoidLiteral) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   Local<v8::FunctionTemplate> desc = v8::FunctionTemplate::New(isolate);
   desc->InstanceTemplate()->MarkAsUndetectable();  // undetectable
 
-  Local<v8::Object> obj = desc->GetFunction()->NewInstance();
-  env->Global()->Set(v8_str("undetectable"), obj);
+  Local<v8::Object> obj = desc->GetFunction(env.local())
+                              .ToLocalChecked()
+                              ->NewInstance(env.local())
+                              .ToLocalChecked();
+  CHECK(
+      env->Global()->Set(env.local(), v8_str("undetectable"), obj).FromJust());
 
   ExpectBoolean("undefined == void 0", true);
   ExpectBoolean("undetectable == void 0", true);
   ExpectBoolean("null == void 0", true);
   ExpectBoolean("undefined === void 0", true);
   ExpectBoolean("undetectable === void 0", false);
   ExpectBoolean("null === void 0", false);
 
   ExpectBoolean("void 0 == undefined", true);
   ExpectBoolean("void 0 == undetectable", true);
@@ skipping 24 matching lines @@
 
 
 THREADED_TEST(ExtensibleOnUndetectable) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   Local<v8::FunctionTemplate> desc = v8::FunctionTemplate::New(isolate);
   desc->InstanceTemplate()->MarkAsUndetectable();  // undetectable
 
-  Local<v8::Object> obj = desc->GetFunction()->NewInstance();
-  env->Global()->Set(v8_str("undetectable"), obj);
+  Local<v8::Object> obj = desc->GetFunction(env.local())
+                              .ToLocalChecked()
+                              ->NewInstance(env.local())
+                              .ToLocalChecked();
+  CHECK(
+      env->Global()->Set(env.local(), v8_str("undetectable"), obj).FromJust());
 
   Local<String> source = v8_str(
       "undetectable.x = 42;"
       "undetectable.x");
 
   Local<Script> script = v8_compile(source);
 
-  CHECK(v8::Integer::New(isolate, 42)->Equals(script->Run()));
+  CHECK(v8::Integer::New(isolate, 42)
+            ->Equals(env.local(), script->Run(env.local()).ToLocalChecked())
+            .FromJust());
 
   ExpectBoolean("Object.isExtensible(undetectable)", true);
 
   source = v8_str("Object.preventExtensions(undetectable);");
   script = v8_compile(source);
-  script->Run();
+  script->Run(env.local()).ToLocalChecked();
   ExpectBoolean("Object.isExtensible(undetectable)", false);
 
   source = v8_str("undetectable.y = 2000;");
   script = v8_compile(source);
-  script->Run();
+  script->Run(env.local()).ToLocalChecked();
   ExpectBoolean("undetectable.y == undefined", true);
 }
 
 
 // The point of this test is type checking. We run it only so compilers
 // don't complain about an unused function.
 TEST(PersistentHandles) {
   LocalContext env;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
@@ skipping 31 matching lines @@
     "function Foo() {"
     "  return 4;"
     "}";
 
 
 TEST(SimpleExtensions) {
   v8::HandleScope handle_scope(CcTest::isolate());
   v8::RegisterExtension(new Extension("simpletest", kSimpleExtensionSource));
   const char* extension_names[] = {"simpletest"};
   v8::ExtensionConfiguration extensions(1, extension_names);
-  v8::Handle<Context> context = Context::New(CcTest::isolate(), &extensions);
+  v8::Local<Context> context = Context::New(CcTest::isolate(), &extensions);
   Context::Scope lock(context);
-  v8::Handle<Value> result = CompileRun("Foo()");
-  CHECK(result->Equals(v8::Integer::New(CcTest::isolate(), 4)));
+  v8::Local<Value> result = CompileRun("Foo()");
+  CHECK(result->Equals(context, v8::Integer::New(CcTest::isolate(), 4))
+            .FromJust());
 }
 
 
 static const char* kStackTraceFromExtensionSource =
     "function foo() {"
     "  throw new Error();"
     "}"
     "function bar() {"
     "  foo();"
     "}";
 
 
 TEST(StackTraceInExtension) {
   v8::HandleScope handle_scope(CcTest::isolate());
   v8::RegisterExtension(
       new Extension("stacktracetest", kStackTraceFromExtensionSource));
   const char* extension_names[] = {"stacktracetest"};
   v8::ExtensionConfiguration extensions(1, extension_names);
-  v8::Handle<Context> context = Context::New(CcTest::isolate(), &extensions);
+  v8::Local<Context> context = Context::New(CcTest::isolate(), &extensions);
   Context::Scope lock(context);
   CompileRun(
       "function user() { bar(); }"
       "var error;"
       "try{ user(); } catch (e) { error = e; }");
-  CHECK_EQ(-1, CompileRun("error.stack.indexOf('foo')")->Int32Value());
-  CHECK_EQ(-1, CompileRun("error.stack.indexOf('bar')")->Int32Value());
-  CHECK_NE(-1, CompileRun("error.stack.indexOf('user')")->Int32Value());
+  CHECK_EQ(-1, v8_run_int32value(v8_compile("error.stack.indexOf('foo')")));
+  CHECK_EQ(-1, v8_run_int32value(v8_compile("error.stack.indexOf('bar')")));
+  CHECK_NE(-1, v8_run_int32value(v8_compile("error.stack.indexOf('user')")));
 }
 
 
 TEST(NullExtensions) {
   v8::HandleScope handle_scope(CcTest::isolate());
   v8::RegisterExtension(new Extension("nulltest", NULL));
   const char* extension_names[] = {"nulltest"};
   v8::ExtensionConfiguration extensions(1, extension_names);
-  v8::Handle<Context> context = Context::New(CcTest::isolate(), &extensions);
+  v8::Local<Context> context = Context::New(CcTest::isolate(), &extensions);
   Context::Scope lock(context);
-  v8::Handle<Value> result = CompileRun("1+3");
-  CHECK(result->Equals(v8::Integer::New(CcTest::isolate(), 4)));
+  v8::Local<Value> result = CompileRun("1+3");
+  CHECK(result->Equals(context, v8::Integer::New(CcTest::isolate(), 4))
+            .FromJust());
 }
 
 
 static const char* kEmbeddedExtensionSource =
     "function Ret54321(){return 54321;}~~@@$"
     "$%% THIS IS A SERIES OF NON-NULL-TERMINATED STRINGS.";
 static const int kEmbeddedExtensionSourceValidLen = 34;
 
 
 TEST(ExtensionMissingSourceLength) {
   v8::HandleScope handle_scope(CcTest::isolate());
   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(CcTest::isolate(), &extensions);
+  v8::Local<Context> context = Context::New(CcTest::isolate(), &extensions);
   CHECK(0 == *context);
 }
 
 
 TEST(ExtensionWithSourceLength) {
   for (int source_len = kEmbeddedExtensionSourceValidLen - 1;
        source_len <= kEmbeddedExtensionSourceValidLen + 1; ++source_len) {
     v8::HandleScope handle_scope(CcTest::isolate());
     i::ScopedVector<char> extension_name(32);
     i::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(CcTest::isolate(), &extensions);
+    v8::Local<Context> context = Context::New(CcTest::isolate(), &extensions);
     if (source_len == kEmbeddedExtensionSourceValidLen) {
       Context::Scope lock(context);
-      v8::Handle<Value> result = CompileRun("Ret54321()");
-      CHECK(v8::Integer::New(CcTest::isolate(), 54321)->Equals(result));
+      v8::Local<Value> result = CompileRun("Ret54321()");
+      CHECK(v8::Integer::New(CcTest::isolate(), 54321)
+                ->Equals(context, result)
+                .FromJust());
     } else {
       // Anything but exactly the right length should fail to compile.
       CHECK(0 == *context);
     }
   }
 }
 
 
 static const char* kEvalExtensionSource1 =
     "function UseEval1() {"
@@ skipping 11 matching lines @@
     "  this.UseEval2 = e;"
     "})()";
 
 
 TEST(UseEvalFromExtension) {
   v8::HandleScope handle_scope(CcTest::isolate());
   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(CcTest::isolate(), &extensions);
+  v8::Local<Context> context = Context::New(CcTest::isolate(), &extensions);
   Context::Scope lock(context);
-  v8::Handle<Value> result = CompileRun("UseEval1()");
-  CHECK(result->Equals(v8::Integer::New(CcTest::isolate(), 42)));
+  v8::Local<Value> result = CompileRun("UseEval1()");
+  CHECK(result->Equals(context, v8::Integer::New(CcTest::isolate(), 42))
+            .FromJust());
   result = CompileRun("UseEval2()");
-  CHECK(result->Equals(v8::Integer::New(CcTest::isolate(), 42)));
+  CHECK(result->Equals(context, v8::Integer::New(CcTest::isolate(), 42))
+            .FromJust());
 }
 
 
 static const char* kWithExtensionSource1 =
     "function UseWith1() {"
     "  var x = 42;"
     "  with({x:87}) { return x; }"
     "}";
 
 
 static const char* kWithExtensionSource2 =
     "(function() {"
     "  var x = 42;"
     "  function e() {"
     "    with ({x:87}) { return x; }"
     "  }"
     "  this.UseWith2 = e;"
     "})()";
 
 
 TEST(UseWithFromExtension) {
   v8::HandleScope handle_scope(CcTest::isolate());
   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(CcTest::isolate(), &extensions);
+  v8::Local<Context> context = Context::New(CcTest::isolate(), &extensions);
   Context::Scope lock(context);
-  v8::Handle<Value> result = CompileRun("UseWith1()");
-  CHECK(result->Equals(v8::Integer::New(CcTest::isolate(), 87)));
+  v8::Local<Value> result = CompileRun("UseWith1()");
+  CHECK(result->Equals(context, v8::Integer::New(CcTest::isolate(), 87))
+            .FromJust());
   result = CompileRun("UseWith2()");
-  CHECK(result->Equals(v8::Integer::New(CcTest::isolate(), 87)));
+  CHECK(result->Equals(context, v8::Integer::New(CcTest::isolate(), 87))
+            .FromJust());
 }
 
 
 TEST(AutoExtensions) {
   v8::HandleScope handle_scope(CcTest::isolate());
   Extension* extension = new Extension("autotest", kSimpleExtensionSource);
   extension->set_auto_enable(true);
   v8::RegisterExtension(extension);
-  v8::Handle<Context> context = Context::New(CcTest::isolate());
+  v8::Local<Context> context = Context::New(CcTest::isolate());
   Context::Scope lock(context);
-  v8::Handle<Value> result = CompileRun("Foo()");
-  CHECK(result->Equals(v8::Integer::New(CcTest::isolate(), 4)));
+  v8::Local<Value> result = CompileRun("Foo()");
+  CHECK(result->Equals(context, v8::Integer::New(CcTest::isolate(), 4))
+            .FromJust());
 }
 
 
 static const char* kSyntaxErrorInExtensionSource = "[";
 
 
 // Test that a syntax error in an extension does not cause a fatal
 // error but results in an empty context.
 TEST(SyntaxErrorExtensions) {
   v8::HandleScope handle_scope(CcTest::isolate());
   v8::RegisterExtension(
       new Extension("syntaxerror", kSyntaxErrorInExtensionSource));
   const char* extension_names[] = {"syntaxerror"};
   v8::ExtensionConfiguration extensions(1, extension_names);
-  v8::Handle<Context> context = Context::New(CcTest::isolate(), &extensions);
+  v8::Local<Context> context = Context::New(CcTest::isolate(), &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.
 TEST(ExceptionExtensions) {
   v8::HandleScope handle_scope(CcTest::isolate());
   v8::RegisterExtension(
       new Extension("exception", kExceptionInExtensionSource));
   const char* extension_names[] = {"exception"};
   v8::ExtensionConfiguration extensions(1, extension_names);
-  v8::Handle<Context> context = Context::New(CcTest::isolate(), &extensions);
+  v8::Local<Context> context = Context::New(CcTest::isolate(), &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.
 TEST(NativeCallInExtensions) {
   v8::HandleScope handle_scope(CcTest::isolate());
   v8::RegisterExtension(
       new Extension("nativecall", kNativeCallInExtensionSource));
   const char* extension_names[] = {"nativecall"};
   v8::ExtensionConfiguration extensions(1, extension_names);
-  v8::Handle<Context> context = Context::New(CcTest::isolate(), &extensions);
+  v8::Local<Context> context = Context::New(CcTest::isolate(), &extensions);
   Context::Scope lock(context);
-  v8::Handle<Value> result = CompileRun(kNativeCallTest);
-  CHECK(result->Equals(v8::Integer::New(CcTest::isolate(), 3)));
+  v8::Local<Value> result = CompileRun(kNativeCallTest);
+  CHECK(result->Equals(context, v8::Integer::New(CcTest::isolate(), 3))
+            .FromJust());
 }
 
 
 class NativeFunctionExtension : public Extension {
  public:
   NativeFunctionExtension(const char* name, const char* source,
                           v8::FunctionCallback fun = &Echo)
       : Extension(name, source), function_(fun) {}
 
-  virtual v8::Handle<v8::FunctionTemplate> GetNativeFunctionTemplate(
-      v8::Isolate* isolate, v8::Handle<v8::String> name) {
+  virtual v8::Local<v8::FunctionTemplate> GetNativeFunctionTemplate(
+      v8::Isolate* isolate, v8::Local<v8::String> name) {
     return v8::FunctionTemplate::New(isolate, function_);
   }
 
   static void Echo(const v8::FunctionCallbackInfo<v8::Value>& args) {
     if (args.Length() >= 1) args.GetReturnValue().Set(args[0]);
   }
 
  private:
   v8::FunctionCallback function_;
 };
 
 
 TEST(NativeFunctionDeclaration) {
   v8::HandleScope handle_scope(CcTest::isolate());
   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(CcTest::isolate(), &extensions);
+  v8::Local<Context> context = Context::New(CcTest::isolate(), &extensions);
   Context::Scope lock(context);
-  v8::Handle<Value> result = CompileRun("foo(42);");
-  CHECK(result->Equals(v8::Integer::New(CcTest::isolate(), 42)));
+  v8::Local<Value> result = CompileRun("foo(42);");
+  CHECK(result->Equals(context, v8::Integer::New(CcTest::isolate(), 42))
+            .FromJust());
 }
 
 
 TEST(NativeFunctionDeclarationError) {
   v8::HandleScope handle_scope(CcTest::isolate());
   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(CcTest::isolate(), &extensions);
+  v8::Local<Context> context = Context::New(CcTest::isolate(), &extensions);
   CHECK(context.IsEmpty());
 }
 
 
 TEST(NativeFunctionDeclarationErrorEscape) {
   v8::HandleScope handle_scope(CcTest::isolate());
   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(CcTest::isolate(), &extensions);
+  v8::Local<Context> context = Context::New(CcTest::isolate(), &extensions);
   CHECK(context.IsEmpty());
 }
 
 
 static void CheckDependencies(const char* name, const char* expected) {
   v8::HandleScope handle_scope(CcTest::isolate());
   v8::ExtensionConfiguration config(1, &name);
   LocalContext context(&config);
-  CHECK(String::NewFromUtf8(CcTest::isolate(), expected)
-            ->Equals(context->Global()->Get(v8_str("loaded"))));
+  CHECK(
+      v8_str(expected)
+          ->Equals(context.local(), context->Global()
+                                        ->Get(context.local(), v8_str("loaded"))
+                                        .ToLocalChecked())
+          .FromJust());
 }
 
 
 /*
  * Configuration:
  *
  *     /-- B <--\
  * A <-          -- D <-- E
  *     \-- C <--/
  */
 THREADED_TEST(ExtensionDependency) {
   static const char* kEDeps[] = {"D"};
   v8::RegisterExtension(new Extension("E", "this.loaded += 'E';", 1, kEDeps));
   static const char* kDDeps[] = {"B", "C"};
   v8::RegisterExtension(new Extension("D", "this.loaded += 'D';", 2, kDDeps));
   static const char* kBCDeps[] = {"A"};
   v8::RegisterExtension(new Extension("B", "this.loaded += 'B';", 1, kBCDeps));
   v8::RegisterExtension(new Extension("C", "this.loaded += 'C';", 1, kBCDeps));
   v8::RegisterExtension(new Extension("A", "this.loaded += 'A';"));
   CheckDependencies("A", "undefinedA");
   CheckDependencies("B", "undefinedAB");
   CheckDependencies("C", "undefinedAC");
   CheckDependencies("D", "undefinedABCD");
   CheckDependencies("E", "undefinedABCDE");
   v8::HandleScope handle_scope(CcTest::isolate());
   static const char* exts[2] = {"C", "E"};
   v8::ExtensionConfiguration config(2, exts);
   LocalContext context(&config);
-  CHECK(v8_str("undefinedACBDE")
-            ->Equals(context->Global()->Get(v8_str("loaded"))));
+  CHECK(
+      v8_str("undefinedACBDE")
+          ->Equals(context.local(), context->Global()
+                                        ->Get(context.local(), v8_str("loaded"))
+                                        .ToLocalChecked())
+          .FromJust());
 }
 
 
 static const char* kExtensionTestScript =
     "native function A();"
     "native function B();"
     "native function C();"
     "function Foo(i) {"
     "  if (i == 0) return A();"
     "  if (i == 1) return B();"
     "  if (i == 2) return C();"
     "}";
 
 
 static void CallFun(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   if (args.IsConstructCall()) {
-    args.This()->Set(v8_str("data"), args.Data());
+    CHECK(args.This()
+              ->Set(args.GetIsolate()->GetCurrentContext(), v8_str("data"),
+                    args.Data())
+              .FromJust());
     args.GetReturnValue().SetNull();
     return;
   }
   args.GetReturnValue().Set(args.Data());
 }
 
 
 class FunctionExtension : public Extension {
  public:
   FunctionExtension() : Extension("functiontest", kExtensionTestScript) {}
-  virtual v8::Handle<v8::FunctionTemplate> GetNativeFunctionTemplate(
-      v8::Isolate* isolate, v8::Handle<String> name);
+  virtual v8::Local<v8::FunctionTemplate> GetNativeFunctionTemplate(
+      v8::Isolate* isolate, v8::Local<String> name);
 };
 
 
 static int lookup_count = 0;
-v8::Handle<v8::FunctionTemplate> FunctionExtension::GetNativeFunctionTemplate(
-    v8::Isolate* isolate, v8::Handle<String> name) {
+v8::Local<v8::FunctionTemplate> FunctionExtension::GetNativeFunctionTemplate(
+    v8::Isolate* isolate, v8::Local<String> name) {
   lookup_count++;
-  if (name->Equals(v8_str("A"))) {
+  if (name->Equals(isolate->GetCurrentContext(), v8_str("A")).FromJust()) {
     return v8::FunctionTemplate::New(isolate, CallFun,
                                      v8::Integer::New(isolate, 8));
-  } else if (name->Equals(v8_str("B"))) {
+  } else if (name->Equals(isolate->GetCurrentContext(), v8_str("B"))
+                 .FromJust()) {
     return v8::FunctionTemplate::New(isolate, CallFun,
                                      v8::Integer::New(isolate, 7));
-  } else if (name->Equals(v8_str("C"))) {
+  } else if (name->Equals(isolate->GetCurrentContext(), v8_str("C"))
+                 .FromJust()) {
     return v8::FunctionTemplate::New(isolate, CallFun,
                                      v8::Integer::New(isolate, 6));
   } else {
-    return v8::Handle<v8::FunctionTemplate>();
+    return v8::Local<v8::FunctionTemplate>();
   }
 }
 
 
 THREADED_TEST(FunctionLookup) {
   v8::RegisterExtension(new FunctionExtension());
   v8::HandleScope handle_scope(CcTest::isolate());
   static const char* exts[1] = {"functiontest"};
   v8::ExtensionConfiguration config(1, exts);
   LocalContext context(&config);
   CHECK_EQ(3, lookup_count);
-  CHECK(v8::Integer::New(CcTest::isolate(), 8)->Equals(CompileRun("Foo(0)")));
-  CHECK(v8::Integer::New(CcTest::isolate(), 7)->Equals(CompileRun("Foo(1)")));
-  CHECK(v8::Integer::New(CcTest::isolate(), 6)->Equals(CompileRun("Foo(2)")));
+  CHECK(v8::Integer::New(CcTest::isolate(), 8)
+            ->Equals(context.local(), CompileRun("Foo(0)"))
+            .FromJust());
+  CHECK(v8::Integer::New(CcTest::isolate(), 7)
+            ->Equals(context.local(), CompileRun("Foo(1)"))
+            .FromJust());
+  CHECK(v8::Integer::New(CcTest::isolate(), 6)
+            ->Equals(context.local(), CompileRun("Foo(2)"))
+            .FromJust());
 }
 
 
 THREADED_TEST(NativeFunctionConstructCall) {
   v8::RegisterExtension(new FunctionExtension());
   v8::HandleScope handle_scope(CcTest::isolate());
   static const char* exts[1] = {"functiontest"};
   v8::ExtensionConfiguration config(1, exts);
   LocalContext context(&config);
   for (int i = 0; i < 10; i++) {
     // Run a few times to ensure that allocation of objects doesn't
     // change behavior of a constructor function.
     CHECK(v8::Integer::New(CcTest::isolate(), 8)
-              ->Equals(CompileRun("(new A()).data")));
+              ->Equals(context.local(), CompileRun("(new A()).data"))
+              .FromJust());
     CHECK(v8::Integer::New(CcTest::isolate(), 7)
-              ->Equals(CompileRun("(new B()).data")));
+              ->Equals(context.local(), CompileRun("(new B()).data"))
+              .FromJust());
     CHECK(v8::Integer::New(CcTest::isolate(), 6)
-              ->Equals(CompileRun("(new C()).data")));
+              ->Equals(context.local(), CompileRun("(new C()).data"))
+              .FromJust());
   }
 }
 
 
 static const char* last_location;
 static const char* last_message;
 void StoringErrorCallback(const char* location, const char* message) {
   if (last_location == NULL) {
     last_location = location;
     last_message = message;
   }
 }
 
 
 // ErrorReporting creates a circular extensions configuration and
 // 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);
+  CcTest::isolate()->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(CcTest::isolate(), &config);
+  v8::Local<Context> context = Context::New(CcTest::isolate(), &config);
   CHECK(context.IsEmpty());
   CHECK(last_location);
 }
 
 
-static void MissingScriptInfoMessageListener(v8::Handle<v8::Message> message,
-                                             v8::Handle<Value> data) {
+static void MissingScriptInfoMessageListener(v8::Local<v8::Message> message,
+                                             v8::Local<Value> data) {
+  v8::Isolate* isolate = CcTest::isolate();
+  Local<Context> context = isolate->GetCurrentContext();
   CHECK(message->GetScriptOrigin().ResourceName()->IsUndefined());
-  CHECK(v8::Undefined(CcTest::isolate())
-            ->Equals(message->GetScriptOrigin().ResourceName()));
-  message->GetLineNumber();
-  message->GetSourceLine();
+  CHECK(v8::Undefined(isolate)
+            ->Equals(context, message->GetScriptOrigin().ResourceName())
+            .FromJust());
+  message->GetLineNumber(context).FromJust();
+  message->GetSourceLine(context).ToLocalChecked();
 }
 
 
 THREADED_TEST(ErrorWithMissingScriptInfo) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
-  v8::V8::AddMessageListener(MissingScriptInfoMessageListener);
+  context->GetIsolate()->AddMessageListener(MissingScriptInfoMessageListener);
   CompileRun("throw Error()");
-  v8::V8::RemoveMessageListeners(MissingScriptInfoMessageListener);
+  context->GetIsolate()->RemoveMessageListeners(
+      MissingScriptInfoMessageListener);
 }
 
 
 struct FlagAndPersistent {
   bool flag;
   v8::Global<v8::Object> handle;
 };
 
 
 static void SetFlag(const v8::WeakCallbackInfo<FlagAndPersistent>& data) {
   data.GetParameter()->flag = true;
   data.GetParameter()->handle.Reset();
 }
 
 
 static void IndependentWeakHandle(bool global_gc, bool interlinked) {
   v8::Isolate* iso = CcTest::isolate();
   v8::HandleScope scope(iso);
-  v8::Handle<Context> context = Context::New(iso);
+  v8::Local<Context> context = Context::New(iso);
   Context::Scope context_scope(context);
 
   FlagAndPersistent object_a, object_b;
 
   intptr_t big_heap_size;
 
   {
     v8::HandleScope handle_scope(iso);
     Local<Object> a(v8::Object::New(iso));
     Local<Object> b(v8::Object::New(iso));
     object_a.handle.Reset(iso, a);
     object_b.handle.Reset(iso, b);
     if (interlinked) {
-      a->Set(v8_str("x"), b);
-      b->Set(v8_str("x"), a);
+      a->Set(context, v8_str("x"), b).FromJust();
+      b->Set(context, v8_str("x"), a).FromJust();
     }
     if (global_gc) {
       CcTest::heap()->CollectAllGarbage();
     } else {
       CcTest::heap()->CollectGarbage(i::NEW_SPACE);
     }
     // We are relying on this creating a big flag array and reserving the space
     // up front.
-    v8::Handle<Value> big_array = CompileRun("new Array(5000)");
-    a->Set(v8_str("y"), big_array);
+    v8::Local<Value> big_array = CompileRun("new Array(5000)");
+    a->Set(context, v8_str("y"), big_array).FromJust();
     big_heap_size = CcTest::heap()->SizeOfObjects();
   }
 
   object_a.flag = false;
   object_b.flag = false;
   object_a.handle.SetWeak(&object_a, &SetFlag,
                           v8::WeakCallbackType::kParameter);
   object_b.handle.SetWeak(&object_b, &SetFlag,
                           v8::WeakCallbackType::kParameter);
   CHECK(!object_b.handle.IsIndependent());
@@ skipping 46 matching lines @@
  private:
   int y_;
   int x_;
 };
 
 
 void CheckInternalFields(
     const v8::WeakCallbackInfo<v8::Persistent<v8::Object>>& data) {
   v8::Persistent<v8::Object>* handle = data.GetParameter();
   handle->Reset();
-  Trivial* t1 = reinterpret_cast<Trivial*>(data.GetInternalField1());
-  Trivial2* t2 = reinterpret_cast<Trivial2*>(data.GetInternalField2());
+  Trivial* t1 = reinterpret_cast<Trivial*>(data.GetInternalField(0));
+  Trivial2* t2 = reinterpret_cast<Trivial2*>(data.GetInternalField(1));
   CHECK_EQ(42, t1->x());
   CHECK_EQ(103, t2->x());
   t1->set_x(1729);
   t2->set_x(33550336);
 }
 
 
 void InternalFieldCallback(bool global_gc) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
   Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New(isolate);
   Local<v8::ObjectTemplate> instance_templ = templ->InstanceTemplate();
   Trivial* t1;
   Trivial2* t2;
   instance_templ->SetInternalFieldCount(2);
   {
     v8::HandleScope scope(isolate);
-    Local<v8::Object> obj = templ->GetFunction()->NewInstance();
+    Local<v8::Object> obj = templ->GetFunction(env.local())
+                                .ToLocalChecked()
+                                ->NewInstance(env.local())
+                                .ToLocalChecked();
     v8::Persistent<v8::Object> handle(isolate, obj);
     CHECK_EQ(2, obj->InternalFieldCount());
     CHECK(obj->GetInternalField(0)->IsUndefined());
     t1 = new Trivial(42);
     t2 = new Trivial2(103, 9);
 
     obj->SetAlignedPointerInInternalField(0, t1);
     t1 = reinterpret_cast<Trivial*>(obj->GetAlignedPointerFromInternalField(0));
     CHECK_EQ(42, t1->x());
 
@@ skipping 37 matching lines @@
 }
 
 
 void v8::internal::HeapTester::ResetWeakHandle(bool global_gc) {
   using v8::Context;
   using v8::Local;
   using v8::Object;
 
   v8::Isolate* iso = CcTest::isolate();
   v8::HandleScope scope(iso);
-  v8::Handle<Context> context = Context::New(iso);
+  v8::Local<Context> context = Context::New(iso);
   Context::Scope context_scope(context);
 
   FlagAndPersistent object_a, object_b;
 
   {
     v8::HandleScope handle_scope(iso);
     Local<Object> a(v8::Object::New(iso));
     Local<Object> b(v8::Object::New(iso));
     object_a.handle.Reset(iso, a);
     object_b.handle.Reset(iso, b);
@@ skipping 60 matching lines @@
     const v8::WeakCallbackInfo<FlagAndPersistent>& data) {
   data.GetParameter()->handle.Reset();
   data.SetSecondPassCallback(ForceMarkSweep2);
 }
 
 
 THREADED_TEST(GCFromWeakCallbacks) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::Locker locker(CcTest::isolate());
   v8::HandleScope scope(isolate);
-  v8::Handle<Context> context = Context::New(isolate);
+  v8::Local<Context> context = Context::New(isolate);
   Context::Scope context_scope(context);
 
   static const int kNumberOfGCTypes = 2;
   typedef v8::WeakCallbackInfo<FlagAndPersistent>::Callback Callback;
   Callback gc_forcing_callback[kNumberOfGCTypes] = {&ForceScavenge1,
                                                     &ForceMarkSweep1};
 
   typedef void (*GCInvoker)();
   GCInvoker invoke_gc[kNumberOfGCTypes] = {&InvokeScavenge, &InvokeMarkSweep};
 
   for (int outer_gc = 0; outer_gc < kNumberOfGCTypes; outer_gc++) {
     for (int inner_gc = 0; inner_gc < kNumberOfGCTypes; inner_gc++) {
       FlagAndPersistent object;
       {
         v8::HandleScope handle_scope(isolate);
         object.handle.Reset(isolate, v8::Object::New(isolate));
       }
       object.flag = false;
       object.handle.SetWeak(&object, gc_forcing_callback[inner_gc],
                             v8::WeakCallbackType::kParameter);
       object.handle.MarkIndependent();
       invoke_gc[outer_gc]();
       EmptyMessageQueues(isolate);
       CHECK(object.flag);
     }
   }
 }
 
 
-v8::Handle<Function> args_fun;
+v8::Local<Function> args_fun;
 
 
 static void ArgumentsTestCallback(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   v8::Isolate* isolate = args.GetIsolate();
-  CHECK(args_fun->Equals(args.Callee()));
+  Local<Context> context = isolate->GetCurrentContext();
+  CHECK(args_fun->Equals(context, args.Callee()).FromJust());
   CHECK_EQ(3, args.Length());
-  CHECK(v8::Integer::New(isolate, 1)->Equals(args[0]));
-  CHECK(v8::Integer::New(isolate, 2)->Equals(args[1]));
-  CHECK(v8::Integer::New(isolate, 3)->Equals(args[2]));
-  CHECK(v8::Undefined(isolate)->Equals(args[3]));
+  CHECK(v8::Integer::New(isolate, 1)->Equals(context, args[0]).FromJust());
+  CHECK(v8::Integer::New(isolate, 2)->Equals(context, args[1]).FromJust());
+  CHECK(v8::Integer::New(isolate, 3)->Equals(context, args[2]).FromJust());
+  CHECK(v8::Undefined(isolate)->Equals(context, args[3]).FromJust());
   v8::HandleScope scope(args.GetIsolate());
   CcTest::heap()->CollectAllGarbage();
 }
 
 
 THREADED_TEST(Arguments) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::ObjectTemplate> global = ObjectTemplate::New(isolate);
+  v8::Local<v8::ObjectTemplate> global = ObjectTemplate::New(isolate);
   global->Set(v8_str("f"),
               v8::FunctionTemplate::New(isolate, ArgumentsTestCallback));
   LocalContext context(NULL, global);
-  args_fun = context->Global()->Get(v8_str("f")).As<Function>();
-  v8_compile("f(1, 2, 3)")->Run();
+  args_fun = context->Global()
+                 ->Get(context.local(), v8_str("f"))
+                 .ToLocalChecked()
+                 .As<Function>();
+  v8_compile("f(1, 2, 3)")->Run(context.local()).ToLocalChecked();
 }
 
 
 static int p_getter_count;
 static int p_getter_count2;
 
 
-static void PGetter(Local<String> name,
+static void PGetter(Local<Name> name,
                     const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   p_getter_count++;
-  v8::Handle<v8::Object> global =
-      info.GetIsolate()->GetCurrentContext()->Global();
-  CHECK(info.Holder()->Equals(global->Get(v8_str("o1"))));
-  if (name->Equals(v8_str("p1"))) {
-    CHECK(info.This()->Equals(global->Get(v8_str("o1"))));
-  } else if (name->Equals(v8_str("p2"))) {
-    CHECK(info.This()->Equals(global->Get(v8_str("o2"))));
-  } else if (name->Equals(v8_str("p3"))) {
-    CHECK(info.This()->Equals(global->Get(v8_str("o3"))));
-  } else if (name->Equals(v8_str("p4"))) {
-    CHECK(info.This()->Equals(global->Get(v8_str("o4"))));
+  v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
+  v8::Local<v8::Object> global = context->Global();
+  CHECK(
+      info.Holder()
+          ->Equals(context, global->Get(context, v8_str("o1")).ToLocalChecked())
+          .FromJust());
+  if (name->Equals(context, v8_str("p1")).FromJust()) {
+    CHECK(info.This()
+              ->Equals(context,
+                       global->Get(context, v8_str("o1")).ToLocalChecked())
+              .FromJust());
+  } else if (name->Equals(context, v8_str("p2")).FromJust()) {
+    CHECK(info.This()
+              ->Equals(context,
+                       global->Get(context, v8_str("o2")).ToLocalChecked())
+              .FromJust());
+  } else if (name->Equals(context, v8_str("p3")).FromJust()) {
+    CHECK(info.This()
+              ->Equals(context,
+                       global->Get(context, v8_str("o3")).ToLocalChecked())
+              .FromJust());
+  } else if (name->Equals(context, v8_str("p4")).FromJust()) {
+    CHECK(info.This()
+              ->Equals(context,
+                       global->Get(context, v8_str("o4")).ToLocalChecked())
+              .FromJust());
   }
 }
 
 
-static void RunHolderTest(v8::Handle<v8::ObjectTemplate> obj) {
+static void RunHolderTest(v8::Local<v8::ObjectTemplate> obj) {
   ApiTestFuzzer::Fuzz();
   LocalContext context;
-  context->Global()->Set(v8_str("o1"), obj->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("o1"),
+                  obj->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   CompileRun(
     "o1.__proto__ = { };"
     "var o2 = { __proto__: o1 };"
     "var o3 = { __proto__: o2 };"
     "var o4 = { __proto__: o3 };"
     "for (var i = 0; i < 10; i++) o4.p4;"
     "for (var i = 0; i < 10; i++) o3.p3;"
     "for (var i = 0; i < 10; i++) o2.p2;"
     "for (var i = 0; i < 10; i++) o1.p1;");
 }
 
 
 static void PGetter2(Local<Name> name,
                      const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   p_getter_count2++;
-  v8::Handle<v8::Object> global =
-      info.GetIsolate()->GetCurrentContext()->Global();
-  CHECK(info.Holder()->Equals(global->Get(v8_str("o1"))));
-  if (name->Equals(v8_str("p1"))) {
-    CHECK(info.This()->Equals(global->Get(v8_str("o1"))));
-  } else if (name->Equals(v8_str("p2"))) {
-    CHECK(info.This()->Equals(global->Get(v8_str("o2"))));
-  } else if (name->Equals(v8_str("p3"))) {
-    CHECK(info.This()->Equals(global->Get(v8_str("o3"))));
-  } else if (name->Equals(v8_str("p4"))) {
-    CHECK(info.This()->Equals(global->Get(v8_str("o4"))));
+  v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
+  v8::Local<v8::Object> global = context->Global();
+  CHECK(
+      info.Holder()
+          ->Equals(context, global->Get(context, v8_str("o1")).ToLocalChecked())
+          .FromJust());
+  if (name->Equals(context, v8_str("p1")).FromJust()) {
+    CHECK(info.This()
+              ->Equals(context,
+                       global->Get(context, v8_str("o1")).ToLocalChecked())
+              .FromJust());
+  } else if (name->Equals(context, v8_str("p2")).FromJust()) {
+    CHECK(info.This()
+              ->Equals(context,
+                       global->Get(context, v8_str("o2")).ToLocalChecked())
+              .FromJust());
+  } else if (name->Equals(context, v8_str("p3")).FromJust()) {
+    CHECK(info.This()
+              ->Equals(context,
+                       global->Get(context, v8_str("o3")).ToLocalChecked())
+              .FromJust());
+  } else if (name->Equals(context, v8_str("p4")).FromJust()) {
+    CHECK(info.This()
+              ->Equals(context,
+                       global->Get(context, v8_str("o4")).ToLocalChecked())
+              .FromJust());
   }
 }
 
 
 THREADED_TEST(GetterHolders) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New(isolate);
+  v8::Local<v8::ObjectTemplate> obj = ObjectTemplate::New(isolate);
   obj->SetAccessor(v8_str("p1"), PGetter);
   obj->SetAccessor(v8_str("p2"), PGetter);
   obj->SetAccessor(v8_str("p3"), PGetter);
   obj->SetAccessor(v8_str("p4"), PGetter);
   p_getter_count = 0;
   RunHolderTest(obj);
   CHECK_EQ(40, p_getter_count);
 }
 
 
 THREADED_TEST(PreInterceptorHolders) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New(isolate);
+  v8::Local<v8::ObjectTemplate> obj = ObjectTemplate::New(isolate);
   obj->SetHandler(v8::NamedPropertyHandlerConfiguration(PGetter2));
   p_getter_count2 = 0;
   RunHolderTest(obj);
   CHECK_EQ(40, p_getter_count2);
 }
 
 
 THREADED_TEST(ObjectInstantiation) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::ObjectTemplate> templ = ObjectTemplate::New(isolate);
+  v8::Local<v8::ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->SetAccessor(v8_str("t"), PGetter2);
   LocalContext context;
-  context->Global()->Set(v8_str("o"), templ->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("o"),
+                  templ->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   for (int i = 0; i < 100; i++) {
     v8::HandleScope inner_scope(CcTest::isolate());
-    v8::Handle<v8::Object> obj = templ->NewInstance();
-    CHECK(!obj->Equals(context->Global()->Get(v8_str("o"))));
-    context->Global()->Set(v8_str("o2"), obj);
-    v8::Handle<Value> value =
-        CompileRun("o.__proto__ === o2.__proto__");
-    CHECK(v8::True(isolate)->Equals(value));
-    context->Global()->Set(v8_str("o"), obj);
+    v8::Local<v8::Object> obj =
+        templ->NewInstance(context.local()).ToLocalChecked();
+    CHECK(!obj->Equals(context.local(), context->Global()
+                                            ->Get(context.local(), v8_str("o"))
+                                            .ToLocalChecked())
+               .FromJust());
+    CHECK(
+        context->Global()->Set(context.local(), v8_str("o2"), obj).FromJust());
+    v8::Local<Value> value = CompileRun("o.__proto__ === o2.__proto__");
+    CHECK(v8::True(isolate)->Equals(context.local(), value).FromJust());
+    CHECK(context->Global()->Set(context.local(), v8_str("o"), obj).FromJust());
   }
 }
 
 
 static int StrCmp16(uint16_t* a, uint16_t* b) {
   while (true) {
     if (*a == 0 && *b == 0) return 0;
     if (*a != *b) return 0 + *a - *b;
     a++;
     b++;
   }
 }
 
 
 static int StrNCmp16(uint16_t* a, uint16_t* b, int n) {
   while (true) {
     if (n-- == 0) return 0;
     if (*a == 0 && *b == 0) return 0;
     if (*a != *b) return 0 + *a - *b;
     a++;
     b++;
   }
 }
 
 
-int GetUtf8Length(Handle<String> str) {
+int GetUtf8Length(Local<String> str) {
   int len = str->Utf8Length();
   if (len < 0) {
     i::Handle<i::String> istr(v8::Utils::OpenHandle(*str));
     i::String::Flatten(istr);
     len = str->Utf8Length();
   }
   return len;
 }
 
 
 THREADED_TEST(StringWrite) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
-  v8::Handle<String> str = v8_str("abcde");
+  v8::Local<String> str = v8_str("abcde");
   // abc<Icelandic eth><Unicode snowman>.
-  v8::Handle<String> str2 = v8_str("abc\303\260\342\230\203");
-  v8::Handle<String> str3 = v8::String::NewFromUtf8(
-      context->GetIsolate(), "abc\0def", v8::String::kNormalString, 7);
+  v8::Local<String> str2 = v8_str("abc\303\260\342\230\203");
+  v8::Local<String> str3 =
+      v8::String::NewFromUtf8(context->GetIsolate(), "abc\0def",
+                              v8::NewStringType::kNormal, 7)
+          .ToLocalChecked();
   // "ab" + lead surrogate + "cd" + trail surrogate + "ef"
   uint16_t orphans[8] = { 0x61, 0x62, 0xd800, 0x63, 0x64, 0xdc00, 0x65, 0x66 };
-  v8::Handle<String> orphans_str = v8::String::NewFromTwoByte(
-      context->GetIsolate(), orphans, v8::String::kNormalString, 8);
+  v8::Local<String> orphans_str =
+      v8::String::NewFromTwoByte(context->GetIsolate(), orphans,
+                                 v8::NewStringType::kNormal, 8)
+          .ToLocalChecked();
   // single lead surrogate
   uint16_t lead[1] = { 0xd800 };
-  v8::Handle<String> lead_str = v8::String::NewFromTwoByte(
-      context->GetIsolate(), lead, v8::String::kNormalString, 1);
+  v8::Local<String> lead_str =
+      v8::String::NewFromTwoByte(context->GetIsolate(), lead,
+                                 v8::NewStringType::kNormal, 1)
+          .ToLocalChecked();
   // single trail surrogate
   uint16_t trail[1] = { 0xdc00 };
-  v8::Handle<String> trail_str = v8::String::NewFromTwoByte(
-      context->GetIsolate(), trail, v8::String::kNormalString, 1);
+  v8::Local<String> trail_str =
+      v8::String::NewFromTwoByte(context->GetIsolate(), trail,
+                                 v8::NewStringType::kNormal, 1)
+          .ToLocalChecked();
   // surrogate pair
   uint16_t pair[2] = { 0xd800,  0xdc00 };
-  v8::Handle<String> pair_str = v8::String::NewFromTwoByte(
-      context->GetIsolate(), pair, v8::String::kNormalString, 2);
+  v8::Local<String> pair_str =
+      v8::String::NewFromTwoByte(context->GetIsolate(), pair,
+                                 v8::NewStringType::kNormal, 2)
+          .ToLocalChecked();
   const int kStride = 4;  // Must match stride in for loops in JS below.
   CompileRun(
       "var left = '';"
       "for (var i = 0; i < 0xd800; i += 4) {"
       "  left = left + String.fromCharCode(i);"
       "}");
   CompileRun(
       "var right = '';"
       "for (var i = 0; i < 0xd800; i += 4) {"
       "  right = String.fromCharCode(i) + right;"
       "}");
-  v8::Handle<v8::Object> global = context->Global();
-  Handle<String> left_tree = global->Get(v8_str("left")).As<String>();
-  Handle<String> right_tree = global->Get(v8_str("right")).As<String>();
+  v8::Local<v8::Object> global = context->Global();
+  Local<String> left_tree = global->Get(context.local(), v8_str("left"))
+                                .ToLocalChecked()
+                                .As<String>();
+  Local<String> right_tree = global->Get(context.local(), v8_str("right"))
+                                 .ToLocalChecked()
+                                 .As<String>();
 
   CHECK_EQ(5, str2->Length());
   CHECK_EQ(0xd800 / kStride, left_tree->Length());
   CHECK_EQ(0xd800 / kStride, right_tree->Length());
 
   char buf[100];
   char utf8buf[0xd800 * 3];
   uint16_t wbuf[100];
   int len;
   int charlen;
@@ skipping 255 matching lines @@
   CHECK_EQ(0, str->WriteUtf8(NULL, 0, 0, String::NO_NULL_TERMINATION));
   CHECK_EQ(0, str->Write(NULL, 0, 0, String::NO_NULL_TERMINATION));
 }
 
 
 static void Utf16Helper(
     LocalContext& context,  // NOLINT
     const char* name,
     const char* lengths_name,
     int len) {
-  Local<v8::Array> a =
-      Local<v8::Array>::Cast(context->Global()->Get(v8_str(name)));
+  Local<v8::Array> a = Local<v8::Array>::Cast(
+      context->Global()->Get(context.local(), v8_str(name)).ToLocalChecked());
   Local<v8::Array> alens =
-      Local<v8::Array>::Cast(context->Global()->Get(v8_str(lengths_name)));
+      Local<v8::Array>::Cast(context->Global()
+                                 ->Get(context.local(), v8_str(lengths_name))
+                                 .ToLocalChecked());
   for (int i = 0; i < len; i++) {
     Local<v8::String> string =
-      Local<v8::String>::Cast(a->Get(i));
-    Local<v8::Number> expected_len =
-      Local<v8::Number>::Cast(alens->Get(i));
+        Local<v8::String>::Cast(a->Get(context.local(), i).ToLocalChecked());
+    Local<v8::Number> expected_len = Local<v8::Number>::Cast(
+        alens->Get(context.local(), i).ToLocalChecked());
     int length = GetUtf8Length(string);
     CHECK_EQ(static_cast<int>(expected_len->Value()), length);
   }
 }
 
 
 THREADED_TEST(Utf16) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   CompileRun(
@@ skipping 35 matching lines @@
            // The 'm's that end with 0xd8.. are 1, 4 and 7
       "    if ((m % 3) == 1 && n >= 6) utf -= 2;"
       "    a2lens.push(utf);"
       "  }"
       "}");
   Utf16Helper(context, "a", "alens", 9);
   Utf16Helper(context, "a2", "a2lens", 81);
 }
 
 
-static bool SameSymbol(Handle<String> s1, Handle<String> s2) {
+static bool SameSymbol(Local<String> s1, Local<String> s2) {
   i::Handle<i::String> is1(v8::Utils::OpenHandle(*s1));
   i::Handle<i::String> is2(v8::Utils::OpenHandle(*s2));
   return *is1 == *is2;
 }
 
 
 THREADED_TEST(Utf16Symbol) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
 
-  Handle<String> symbol1 = v8::String::NewFromUtf8(
-      context->GetIsolate(), "abc", v8::String::kInternalizedString);
-  Handle<String> symbol2 = v8::String::NewFromUtf8(
-      context->GetIsolate(), "abc", v8::String::kInternalizedString);
+  Local<String> symbol1 =
+      v8::String::NewFromUtf8(context->GetIsolate(), "abc",
+                              v8::NewStringType::kInternalized)
+          .ToLocalChecked();
+  Local<String> symbol2 =
+      v8::String::NewFromUtf8(context->GetIsolate(), "abc",
+                              v8::NewStringType::kInternalized)
+          .ToLocalChecked();
   CHECK(SameSymbol(symbol1, symbol2));
 
   CompileRun(
       "var sym0 = 'benedictus';"
       "var sym0b = 'S\303\270ren';"
       "var sym1 = '\355\240\201\355\260\207';"
       "var sym2 = '\360\220\220\210';"
       "var sym3 = 'x\355\240\201\355\260\207';"
       "var sym4 = 'x\360\220\220\210';"
       "if (sym1.length != 2) throw sym1;"
       "if (sym1.charCodeAt(1) != 0xdc07) throw sym1.charCodeAt(1);"
       "if (sym2.length != 2) throw sym2;"
       "if (sym2.charCodeAt(1) != 0xdc08) throw sym2.charCodeAt(2);"
       "if (sym3.length != 3) throw sym3;"
       "if (sym3.charCodeAt(2) != 0xdc07) throw sym1.charCodeAt(2);"
       "if (sym4.length != 3) throw sym4;"
       "if (sym4.charCodeAt(2) != 0xdc08) throw sym2.charCodeAt(2);");
-  Handle<String> sym0 = v8::String::NewFromUtf8(
-      context->GetIsolate(), "benedictus", v8::String::kInternalizedString);
-  Handle<String> sym0b = v8::String::NewFromUtf8(
-      context->GetIsolate(), "S\303\270ren", v8::String::kInternalizedString);
-  Handle<String> sym1 =
+  Local<String> sym0 =
+      v8::String::NewFromUtf8(context->GetIsolate(), "benedictus",
+                              v8::NewStringType::kInternalized)
+          .ToLocalChecked();
+  Local<String> sym0b =
+      v8::String::NewFromUtf8(context->GetIsolate(), "S\303\270ren",
+                              v8::NewStringType::kInternalized)
+          .ToLocalChecked();
+  Local<String> sym1 =
       v8::String::NewFromUtf8(context->GetIsolate(), "\355\240\201\355\260\207",
-                              v8::String::kInternalizedString);
-  Handle<String> sym2 =
+                              v8::NewStringType::kInternalized)
+          .ToLocalChecked();
+  Local<String> sym2 =
       v8::String::NewFromUtf8(context->GetIsolate(), "\360\220\220\210",
-                              v8::String::kInternalizedString);
-  Handle<String> sym3 = v8::String::NewFromUtf8(
-      context->GetIsolate(), "x\355\240\201\355\260\207",
-      v8::String::kInternalizedString);
-  Handle<String> sym4 =
+                              v8::NewStringType::kInternalized)
+          .ToLocalChecked();
+  Local<String> sym3 = v8::String::NewFromUtf8(context->GetIsolate(),
+                                               "x\355\240\201\355\260\207",
+                                               v8::NewStringType::kInternalized)
+                           .ToLocalChecked();
+  Local<String> sym4 =
       v8::String::NewFromUtf8(context->GetIsolate(), "x\360\220\220\210",
-                              v8::String::kInternalizedString);
+                              v8::NewStringType::kInternalized)
+          .ToLocalChecked();
   v8::Local<v8::Object> global = context->Global();
-  Local<Value> s0 = global->Get(v8_str("sym0"));
-  Local<Value> s0b = global->Get(v8_str("sym0b"));
-  Local<Value> s1 = global->Get(v8_str("sym1"));
-  Local<Value> s2 = global->Get(v8_str("sym2"));
-  Local<Value> s3 = global->Get(v8_str("sym3"));
-  Local<Value> s4 = global->Get(v8_str("sym4"));
-  CHECK(SameSymbol(sym0, Handle<String>::Cast(s0)));
-  CHECK(SameSymbol(sym0b, Handle<String>::Cast(s0b)));
-  CHECK(SameSymbol(sym1, Handle<String>::Cast(s1)));
-  CHECK(SameSymbol(sym2, Handle<String>::Cast(s2)));
-  CHECK(SameSymbol(sym3, Handle<String>::Cast(s3)));
-  CHECK(SameSymbol(sym4, Handle<String>::Cast(s4)));
+  Local<Value> s0 =
+      global->Get(context.local(), v8_str("sym0")).ToLocalChecked();
+  Local<Value> s0b =
+      global->Get(context.local(), v8_str("sym0b")).ToLocalChecked();
+  Local<Value> s1 =
+      global->Get(context.local(), v8_str("sym1")).ToLocalChecked();
+  Local<Value> s2 =
+      global->Get(context.local(), v8_str("sym2")).ToLocalChecked();
+  Local<Value> s3 =
+      global->Get(context.local(), v8_str("sym3")).ToLocalChecked();
+  Local<Value> s4 =
+      global->Get(context.local(), v8_str("sym4")).ToLocalChecked();
+  CHECK(SameSymbol(sym0, Local<String>::Cast(s0)));
+  CHECK(SameSymbol(sym0b, Local<String>::Cast(s0b)));
+  CHECK(SameSymbol(sym1, Local<String>::Cast(s1)));
+  CHECK(SameSymbol(sym2, Local<String>::Cast(s2)));
+  CHECK(SameSymbol(sym3, Local<String>::Cast(s3)));
+  CHECK(SameSymbol(sym4, Local<String>::Cast(s4)));
 }
 
 
 THREADED_TEST(Utf16MissingTrailing) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
 
   // Make sure it will go past the buffer, so it will call `WriteUtf16Slow`
   int size = 1024 * 64;
   uint8_t* buffer = new uint8_t[size];
@@ skipping 39 matching lines @@
 
   delete[] buffer;
 }
 
 
 THREADED_TEST(ToArrayIndex) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
 
-  v8::Handle<String> str = v8_str("42");
-  v8::Handle<v8::Uint32> index = str->ToArrayIndex();
+  v8::Local<String> str = v8_str("42");
+  v8::MaybeLocal<v8::Uint32> index = str->ToArrayIndex(context.local());
   CHECK(!index.IsEmpty());
-  CHECK_EQ(42.0, index->Uint32Value());
+  CHECK_EQ(42.0,
+           index.ToLocalChecked()->Uint32Value(context.local()).FromJust());
   str = v8_str("42asdf");
-  index = str->ToArrayIndex();
+  index = str->ToArrayIndex(context.local());
   CHECK(index.IsEmpty());
   str = v8_str("-42");
-  index = str->ToArrayIndex();
+  index = str->ToArrayIndex(context.local());
   CHECK(index.IsEmpty());
   str = v8_str("4294967294");
-  index = str->ToArrayIndex();
+  index = str->ToArrayIndex(context.local());
   CHECK(!index.IsEmpty());
-  CHECK_EQ(4294967294.0, index->Uint32Value());
-  v8::Handle<v8::Number> num = v8::Number::New(isolate, 1);
-  index = num->ToArrayIndex();
+  CHECK_EQ(4294967294.0,
+           index.ToLocalChecked()->Uint32Value(context.local()).FromJust());
+  v8::Local<v8::Number> num = v8::Number::New(isolate, 1);
+  index = num->ToArrayIndex(context.local());
   CHECK(!index.IsEmpty());
-  CHECK_EQ(1.0, index->Uint32Value());
+  CHECK_EQ(1.0,
+           index.ToLocalChecked()->Uint32Value(context.local()).FromJust());
   num = v8::Number::New(isolate, -1);
-  index = num->ToArrayIndex();
+  index = num->ToArrayIndex(context.local());
   CHECK(index.IsEmpty());
-  v8::Handle<v8::Object> obj = v8::Object::New(isolate);
-  index = obj->ToArrayIndex();
+  v8::Local<v8::Object> obj = v8::Object::New(isolate);
+  index = obj->ToArrayIndex(context.local());
   CHECK(index.IsEmpty());
 }
 
 
 THREADED_TEST(ErrorConstruction) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
 
-  v8::Handle<String> foo = v8_str("foo");
-  v8::Handle<String> message = v8_str("message");
-  v8::Handle<Value> range_error = v8::Exception::RangeError(foo);
+  v8::Local<String> foo = v8_str("foo");
+  v8::Local<String> message = v8_str("message");
+  v8::Local<Value> range_error = v8::Exception::RangeError(foo);
   CHECK(range_error->IsObject());
-  CHECK(range_error.As<v8::Object>()->Get(message)->Equals(foo));
-  v8::Handle<Value> reference_error = v8::Exception::ReferenceError(foo);
+  CHECK(range_error.As<v8::Object>()
+            ->Get(context.local(), message)
+            .ToLocalChecked()
+            ->Equals(context.local(), foo)
+            .FromJust());
+  v8::Local<Value> reference_error = v8::Exception::ReferenceError(foo);
   CHECK(reference_error->IsObject());
-  CHECK(reference_error.As<v8::Object>()->Get(message)->Equals(foo));
-  v8::Handle<Value> syntax_error = v8::Exception::SyntaxError(foo);
+  CHECK(reference_error.As<v8::Object>()
+            ->Get(context.local(), message)
+            .ToLocalChecked()
+            ->Equals(context.local(), foo)
+            .FromJust());
+  v8::Local<Value> syntax_error = v8::Exception::SyntaxError(foo);
   CHECK(syntax_error->IsObject());
-  CHECK(syntax_error.As<v8::Object>()->Get(message)->Equals(foo));
-  v8::Handle<Value> type_error = v8::Exception::TypeError(foo);
+  CHECK(syntax_error.As<v8::Object>()
+            ->Get(context.local(), message)
+            .ToLocalChecked()
+            ->Equals(context.local(), foo)
+            .FromJust());
+  v8::Local<Value> type_error = v8::Exception::TypeError(foo);
   CHECK(type_error->IsObject());
-  CHECK(type_error.As<v8::Object>()->Get(message)->Equals(foo));
-  v8::Handle<Value> error = v8::Exception::Error(foo);
+  CHECK(type_error.As<v8::Object>()
+            ->Get(context.local(), message)
+            .ToLocalChecked()
+            ->Equals(context.local(), foo)
+            .FromJust());
+  v8::Local<Value> error = v8::Exception::Error(foo);
   CHECK(error->IsObject());
-  CHECK(error.As<v8::Object>()->Get(message)->Equals(foo));
+  CHECK(error.As<v8::Object>()
+            ->Get(context.local(), message)
+            .ToLocalChecked()
+            ->Equals(context.local(), foo)
+            .FromJust());
 }
 
 
 static void ThrowV8Exception(const v8::FunctionCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
-  v8::Handle<String> foo = v8_str("foo");
-  v8::Handle<String> message = v8_str("message");
-  v8::Handle<Value> error = v8::Exception::Error(foo);
+  v8::Local<String> foo = v8_str("foo");
+  v8::Local<String> message = v8_str("message");
+  v8::Local<Value> error = v8::Exception::Error(foo);
   CHECK(error->IsObject());
-  CHECK(error.As<v8::Object>()->Get(message)->Equals(foo));
+  v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
+  CHECK(error.As<v8::Object>()
+            ->Get(context, message)
+            .ToLocalChecked()
+            ->Equals(context, foo)
+            .FromJust());
   info.GetIsolate()->ThrowException(error);
   info.GetReturnValue().SetUndefined();
 }
 
 
 THREADED_TEST(ExceptionCreateMessage) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
-  v8::Handle<String> foo_str = v8_str("foo");
-  v8::Handle<String> message_str = v8_str("message");
+  v8::Local<String> foo_str = v8_str("foo");
+  v8::Local<String> message_str = v8_str("message");
 
-  v8::V8::SetCaptureStackTraceForUncaughtExceptions(true);
+  context->GetIsolate()->SetCaptureStackTraceForUncaughtExceptions(true);
 
   Local<v8::FunctionTemplate> fun =
       v8::FunctionTemplate::New(context->GetIsolate(), ThrowV8Exception);
   v8::Local<v8::Object> global = context->Global();
-  global->Set(v8_str("throwV8Exception"), fun->GetFunction());
+  CHECK(global->Set(context.local(), v8_str("throwV8Exception"),
+                    fun->GetFunction(context.local()).ToLocalChecked())
+            .FromJust());
 
   TryCatch try_catch(context->GetIsolate());
   CompileRun(
       "function f1() {\n"
       "  throwV8Exception();\n"
       "};\n"
       "f1();");
   CHECK(try_catch.HasCaught());
 
-  v8::Handle<v8::Value> error = try_catch.Exception();
+  v8::Local<v8::Value> error = try_catch.Exception();
   CHECK(error->IsObject());
-  CHECK(error.As<v8::Object>()->Get(message_str)->Equals(foo_str));
+  CHECK(error.As<v8::Object>()
+            ->Get(context.local(), message_str)
+            .ToLocalChecked()
+            ->Equals(context.local(), foo_str)
+            .FromJust());
 
-  v8::Handle<v8::Message> message = v8::Exception::CreateMessage(error);
+  v8::Local<v8::Message> message = v8::Exception::CreateMessage(error);
   CHECK(!message.IsEmpty());
-  CHECK_EQ(2, message->GetLineNumber());
-  CHECK_EQ(2, message->GetStartColumn());
+  CHECK_EQ(2, message->GetLineNumber(context.local()).FromJust());
+  CHECK_EQ(2, message->GetStartColumn(context.local()).FromJust());
 
-  v8::Handle<v8::StackTrace> stackTrace = message->GetStackTrace();
+  v8::Local<v8::StackTrace> stackTrace = message->GetStackTrace();
   CHECK(!stackTrace.IsEmpty());
   CHECK_EQ(2, stackTrace->GetFrameCount());
 
   stackTrace = v8::Exception::GetStackTrace(error);
   CHECK(!stackTrace.IsEmpty());
   CHECK_EQ(2, stackTrace->GetFrameCount());
 
-  v8::V8::SetCaptureStackTraceForUncaughtExceptions(false);
+  context->GetIsolate()->SetCaptureStackTraceForUncaughtExceptions(false);
 
   // Now check message location when SetCaptureStackTraceForUncaughtExceptions
   // is false.
   try_catch.Reset();
 
   CompileRun(
       "function f2() {\n"
       "  return throwV8Exception();\n"
       "};\n"
       "f2();");
   CHECK(try_catch.HasCaught());
 
   error = try_catch.Exception();
   CHECK(error->IsObject());
-  CHECK(error.As<v8::Object>()->Get(message_str)->Equals(foo_str));
+  CHECK(error.As<v8::Object>()
+            ->Get(context.local(), message_str)
+            .ToLocalChecked()
+            ->Equals(context.local(), foo_str)
+            .FromJust());
 
   message = v8::Exception::CreateMessage(error);
   CHECK(!message.IsEmpty());
-  CHECK_EQ(2, message->GetLineNumber());
-  CHECK_EQ(9, message->GetStartColumn());
+  CHECK_EQ(2, message->GetLineNumber(context.local()).FromJust());
+  CHECK_EQ(9, message->GetStartColumn(context.local()).FromJust());
 
   // Should be empty stack trace.
   stackTrace = message->GetStackTrace();
   CHECK(stackTrace.IsEmpty());
   CHECK(v8::Exception::GetStackTrace(error).IsEmpty());
 }
 
 
 THREADED_TEST(ExceptionCreateMessageLength) {
   LocalContext context;
@@ skipping 15 matching lines @@
                     const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
   info.GetReturnValue().Set(v8_num(10));
 }
 
 
 static void YSetter(Local<String> name,
                     Local<Value> value,
                     const v8::PropertyCallbackInfo<void>& info) {
   Local<Object> this_obj = Local<Object>::Cast(info.This());
-  if (this_obj->Has(name)) this_obj->Delete(name);
-  this_obj->Set(name, value);
+  v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
+  if (this_obj->Has(context, name).FromJust())
+    this_obj->Delete(context, name).FromJust();
+  CHECK(this_obj->Set(context, name, value).FromJust());
 }
 
 
 THREADED_TEST(DeleteAccessor) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::ObjectTemplate> obj = ObjectTemplate::New(isolate);
+  v8::Local<v8::ObjectTemplate> obj = ObjectTemplate::New(isolate);
   obj->SetAccessor(v8_str("y"), YGetter, YSetter);
   LocalContext context;
-  v8::Handle<v8::Object> holder = obj->NewInstance();
-  context->Global()->Set(v8_str("holder"), holder);
-  v8::Handle<Value> result = CompileRun(
-      "holder.y = 11; holder.y = 12; holder.y");
-  CHECK_EQ(12u, result->Uint32Value());
+  v8::Local<v8::Object> holder =
+      obj->NewInstance(context.local()).ToLocalChecked();
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("holder"), holder)
+            .FromJust());
+  v8::Local<Value> result =
+      CompileRun("holder.y = 11; holder.y = 12; holder.y");
+  CHECK_EQ(12u, result->Uint32Value(context.local()).FromJust());
 }
 
 
 THREADED_TEST(TypeSwitch) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::FunctionTemplate> templ1 = v8::FunctionTemplate::New(isolate);
-  v8::Handle<v8::FunctionTemplate> templ2 = v8::FunctionTemplate::New(isolate);
-  v8::Handle<v8::FunctionTemplate> templ3 = v8::FunctionTemplate::New(isolate);
-  v8::Handle<v8::FunctionTemplate> templs[3] = { templ1, templ2, templ3 };
-  v8::Handle<v8::TypeSwitch> type_switch = v8::TypeSwitch::New(3, templs);
+  v8::Local<v8::FunctionTemplate> templ1 = v8::FunctionTemplate::New(isolate);
+  v8::Local<v8::FunctionTemplate> templ2 = v8::FunctionTemplate::New(isolate);
+  v8::Local<v8::FunctionTemplate> templ3 = v8::FunctionTemplate::New(isolate);
+  v8::Local<v8::FunctionTemplate> templs[3] = {templ1, templ2, templ3};
+  v8::Local<v8::TypeSwitch> type_switch = v8::TypeSwitch::New(3, templs);
   LocalContext context;
-  v8::Handle<v8::Object> obj0 = v8::Object::New(isolate);
-  v8::Handle<v8::Object> obj1 = templ1->GetFunction()->NewInstance();
-  v8::Handle<v8::Object> obj2 = templ2->GetFunction()->NewInstance();
-  v8::Handle<v8::Object> obj3 = templ3->GetFunction()->NewInstance();
+  v8::Local<v8::Object> obj0 = v8::Object::New(isolate);
+  v8::Local<v8::Object> obj1 = templ1->GetFunction(context.local())
+                                   .ToLocalChecked()
+                                   ->NewInstance(context.local())
+                                   .ToLocalChecked();
+  v8::Local<v8::Object> obj2 = templ2->GetFunction(context.local())
+                                   .ToLocalChecked()
+                                   ->NewInstance(context.local())
+                                   .ToLocalChecked();
+  v8::Local<v8::Object> obj3 = templ3->GetFunction(context.local())
+                                   .ToLocalChecked()
+                                   ->NewInstance(context.local())
+                                   .ToLocalChecked();
   for (int i = 0; i < 10; i++) {
     CHECK_EQ(0, type_switch->match(obj0));
     CHECK_EQ(1, type_switch->match(obj1));
     CHECK_EQ(2, type_switch->match(obj2));
     CHECK_EQ(3, type_switch->match(obj3));
     CHECK_EQ(3, type_switch->match(obj3));
     CHECK_EQ(2, type_switch->match(obj2));
     CHECK_EQ(1, type_switch->match(obj1));
     CHECK_EQ(0, type_switch->match(obj0));
   }
 }
 
 
 static int trouble_nesting = 0;
 static void TroubleCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   trouble_nesting++;
 
   // Call a JS function that throws an uncaught exception.
-  Local<v8::Object> arg_this =
-      args.GetIsolate()->GetCurrentContext()->Global();
-  Local<Value> trouble_callee = (trouble_nesting == 3) ?
-    arg_this->Get(v8_str("trouble_callee")) :
-    arg_this->Get(v8_str("trouble_caller"));
+  Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
+  Local<v8::Object> arg_this = context->Global();
+  Local<Value> trouble_callee =
+      (trouble_nesting == 3)
+          ? arg_this->Get(context, v8_str("trouble_callee")).ToLocalChecked()
+          : arg_this->Get(context, v8_str("trouble_caller")).ToLocalChecked();
   CHECK(trouble_callee->IsFunction());
-  args.GetReturnValue().Set(
-      Function::Cast(*trouble_callee)->Call(arg_this, 0, NULL));
+  args.GetReturnValue().Set(Function::Cast(*trouble_callee)
+                                ->Call(context, arg_this, 0, NULL)
+                                .FromMaybe(v8::Local<v8::Value>()));
 }
 
 
 static int report_count = 0;
-static void ApiUncaughtExceptionTestListener(v8::Handle<v8::Message>,
-                                             v8::Handle<Value>) {
+static void ApiUncaughtExceptionTestListener(v8::Local<v8::Message>,
+                                             v8::Local<Value>) {
   report_count++;
 }
 
 
 // Counts uncaught exceptions, but other tests running in parallel
 // also have uncaught exceptions.
 TEST(ApiUncaughtException) {
   report_count = 0;
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
-  v8::V8::AddMessageListener(ApiUncaughtExceptionTestListener);
+  isolate->AddMessageListener(ApiUncaughtExceptionTestListener);
 
   Local<v8::FunctionTemplate> fun =
       v8::FunctionTemplate::New(isolate, TroubleCallback);
   v8::Local<v8::Object> global = env->Global();
-  global->Set(v8_str("trouble"), fun->GetFunction());
+  CHECK(global->Set(env.local(), v8_str("trouble"),
+                    fun->GetFunction(env.local()).ToLocalChecked())
+            .FromJust());
 
   CompileRun(
       "function trouble_callee() {"
       "  var x = null;"
       "  return x.foo;"
       "};"
       "function trouble_caller() {"
       "  trouble();"
       "};");
-  Local<Value> trouble = global->Get(v8_str("trouble"));
+  Local<Value> trouble =
+      global->Get(env.local(), v8_str("trouble")).ToLocalChecked();
   CHECK(trouble->IsFunction());
-  Local<Value> trouble_callee = global->Get(v8_str("trouble_callee"));
+  Local<Value> trouble_callee =
+      global->Get(env.local(), v8_str("trouble_callee")).ToLocalChecked();
   CHECK(trouble_callee->IsFunction());
-  Local<Value> trouble_caller = global->Get(v8_str("trouble_caller"));
+  Local<Value> trouble_caller =
+      global->Get(env.local(), v8_str("trouble_caller")).ToLocalChecked();
   CHECK(trouble_caller->IsFunction());
-  Function::Cast(*trouble_caller)->Call(global, 0, NULL);
+  Function::Cast(*trouble_caller)
+      ->Call(env.local(), global, 0, NULL)
+      .FromMaybe(v8::Local<v8::Value>());
   CHECK_EQ(1, report_count);
-  v8::V8::RemoveMessageListeners(ApiUncaughtExceptionTestListener);
+  isolate->RemoveMessageListeners(ApiUncaughtExceptionTestListener);
 }
 
 
 TEST(ApiUncaughtExceptionInObjectObserve) {
   v8::internal::FLAG_stack_size = 150;
   report_count = 0;
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
-  v8::V8::AddMessageListener(ApiUncaughtExceptionTestListener);
+  isolate->AddMessageListener(ApiUncaughtExceptionTestListener);
   CompileRun(
       "var obj = {};"
       "var observe_count = 0;"
       "function observer1() { ++observe_count; };"
       "function observer2() { ++observe_count; };"
       "function observer_throws() { throw new Error(); };"
       "function stack_overflow() { return (function f(x) { f(x+1); })(0); };"
       "Object.observe(obj, observer_throws.bind());"
       "Object.observe(obj, observer1);"
       "Object.observe(obj, stack_overflow);"
       "Object.observe(obj, observer2);"
       "Object.observe(obj, observer_throws.bind());"
       "obj.foo = 'bar';");
   CHECK_EQ(3, report_count);
   ExpectInt32("observe_count", 2);
-  v8::V8::RemoveMessageListeners(ApiUncaughtExceptionTestListener);
+  isolate->RemoveMessageListeners(ApiUncaughtExceptionTestListener);
 }
 
 
 static const char* script_resource_name = "ExceptionInNativeScript.js";
-static void ExceptionInNativeScriptTestListener(v8::Handle<v8::Message> message,
-                                                v8::Handle<Value>) {
-  v8::Handle<v8::Value> name_val = message->GetScriptOrigin().ResourceName();
+static void ExceptionInNativeScriptTestListener(v8::Local<v8::Message> message,
+                                                v8::Local<Value>) {
+  v8::Local<v8::Value> name_val = message->GetScriptOrigin().ResourceName();
   CHECK(!name_val.IsEmpty() && name_val->IsString());
   v8::String::Utf8Value name(message->GetScriptOrigin().ResourceName());
   CHECK_EQ(0, strcmp(script_resource_name, *name));
-  CHECK_EQ(3, message->GetLineNumber());
-  v8::String::Utf8Value source_line(message->GetSourceLine());
+  v8::Local<v8::Context> context =
+      v8::Isolate::GetCurrent()->GetCurrentContext();
+  CHECK_EQ(3, message->GetLineNumber(context).FromJust());
+  v8::String::Utf8Value source_line(
+      message->GetSourceLine(context).ToLocalChecked());
   CHECK_EQ(0, strcmp("  new o.foo();", *source_line));
 }
 
 
 TEST(ExceptionInNativeScript) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
-  v8::V8::AddMessageListener(ExceptionInNativeScriptTestListener);
+  isolate->AddMessageListener(ExceptionInNativeScriptTestListener);
 
   Local<v8::FunctionTemplate> fun =
       v8::FunctionTemplate::New(isolate, TroubleCallback);
   v8::Local<v8::Object> global = env->Global();
-  global->Set(v8_str("trouble"), fun->GetFunction());
+  CHECK(global->Set(env.local(), v8_str("trouble"),
+                    fun->GetFunction(env.local()).ToLocalChecked())
+            .FromJust());
 
   CompileRunWithOrigin(
       "function trouble() {\n"
       "  var o = {};\n"
       "  new o.foo();\n"
       "};",
       script_resource_name);
-  Local<Value> trouble = global->Get(v8_str("trouble"));
+  Local<Value> trouble =
+      global->Get(env.local(), v8_str("trouble")).ToLocalChecked();
   CHECK(trouble->IsFunction());
-  Function::Cast(*trouble)->Call(global, 0, NULL);
-  v8::V8::RemoveMessageListeners(ExceptionInNativeScriptTestListener);
+  CHECK(Function::Cast(*trouble)->Call(env.local(), global, 0, NULL).IsEmpty());
+  isolate->RemoveMessageListeners(ExceptionInNativeScriptTestListener);
 }
 
 
 TEST(CompilationErrorUsingTryCatchHandler) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::TryCatch try_catch(env->GetIsolate());
   v8_compile("This doesn't &*&@#$&*^ compile.");
   CHECK(*try_catch.Exception());
   CHECK(try_catch.HasCaught());
@@ skipping 17 matching lines @@
   CompileRun(
       "(function()"
       "  { try { throw ''; } finally { throw 0; }"
       "})()");
   CHECK(try_catch.HasCaught());
 }
 
 
 void CEvaluate(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::HandleScope scope(args.GetIsolate());
-  CompileRun(args[0]->ToString(args.GetIsolate()));
+  CompileRun(args[0]
+                 ->ToString(args.GetIsolate()->GetCurrentContext())
+                 .ToLocalChecked());
 }
 
 
 TEST(TryCatchFinallyStoresMessageUsingTryCatchHandler) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->Set(v8_str("CEvaluate"),
              v8::FunctionTemplate::New(isolate, CEvaluate));
   LocalContext context(0, templ);
@@ skipping 25 matching lines @@
                                  Local<v8::Object> accessed_object) {
   printf("a\n");
   return g_security_callback_result;
 }
 
 
 // SecurityHandler can't be run twice
 TEST(SecurityHandler) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope0(isolate);
-  v8::Handle<v8::ObjectTemplate> global_template =
+  v8::Local<v8::ObjectTemplate> global_template =
       v8::ObjectTemplate::New(isolate);
   global_template->SetAccessCheckCallback(SecurityTestCallback);
   // Create an environment
-  v8::Handle<Context> context0 = Context::New(isolate, NULL, global_template);
+  v8::Local<Context> context0 = Context::New(isolate, 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());
+  v8::Local<v8::Object> global0 = context0->Global();
+  v8::Local<Script> script0 = v8_compile("foo = 111");
+  script0->Run(context0).ToLocalChecked();
+  CHECK(global0->Set(context0, v8_str("0"), v8_num(999)).FromJust());
+  v8::Local<Value> foo0 =
+      global0->Get(context0, v8_str("foo")).ToLocalChecked();
+  CHECK_EQ(111, foo0->Int32Value(context0).FromJust());
+  v8::Local<Value> z0 = global0->Get(context0, v8_str("0")).ToLocalChecked();
+  CHECK_EQ(999, z0->Int32Value(context0).FromJust());
 
   // Create another environment, should fail security checks.
   v8::HandleScope scope1(isolate);
 
-  v8::Handle<Context> context1 =
-    Context::New(isolate, NULL, global_template);
+  v8::Local<Context> context1 = Context::New(isolate, NULL, global_template);
   context1->Enter();
 
-  v8::Handle<v8::Object> global1 = context1->Global();
-  global1->Set(v8_str("othercontext"), global0);
+  v8::Local<v8::Object> global1 = context1->Global();
+  global1->Set(context1, v8_str("othercontext"), global0).FromJust();
   // This set will fail the security check.
-  v8::Handle<Script> script1 =
-    v8_compile("othercontext.foo = 222; othercontext[0] = 888;");
-  script1->Run();
+  v8::Local<Script> script1 =
+      v8_compile("othercontext.foo = 222; othercontext[0] = 888;");
+  CHECK(script1->Run(context1).IsEmpty());
   g_security_callback_result = true;
   // This read will pass the security check.
-  v8::Handle<Value> foo1 = global0->Get(v8_str("foo"));
-  CHECK_EQ(111, foo1->Int32Value());
+  v8::Local<Value> foo1 =
+      global0->Get(context0, v8_str("foo")).ToLocalChecked();
+  CHECK_EQ(111, foo1->Int32Value(context0).FromJust());
   // This read will pass the security check.
-  v8::Handle<Value> z1 = global0->Get(v8_str("0"));
-  CHECK_EQ(999, z1->Int32Value());
+  v8::Local<Value> z1 = global0->Get(context0, v8_str("0")).ToLocalChecked();
+  CHECK_EQ(999, z1->Int32Value(context0).FromJust());
 
   // Create another environment, should pass security checks.
   {
     v8::HandleScope scope2(isolate);
     LocalContext context2;
-    v8::Handle<v8::Object> global2 = context2->Global();
-    global2->Set(v8_str("othercontext"), global0);
-    v8::Handle<Script> script2 =
+    v8::Local<v8::Object> global2 = context2->Global();
+    CHECK(global2->Set(context2.local(), v8_str("othercontext"), global0)
+              .FromJust());
+    v8::Local<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());
+    script2->Run(context2.local()).ToLocalChecked();
+    v8::Local<Value> foo2 =
+        global0->Get(context2.local(), v8_str("foo")).ToLocalChecked();
+    CHECK_EQ(333, foo2->Int32Value(context2.local()).FromJust());
+    v8::Local<Value> z2 =
+        global0->Get(context2.local(), v8_str("0")).ToLocalChecked();
+    CHECK_EQ(888, z2->Int32Value(context2.local()).FromJust());
   }
 
   context1->Exit();
   context0->Exit();
 }
 
 
 THREADED_TEST(SecurityChecks) {
   LocalContext env1;
   v8::HandleScope handle_scope(env1->GetIsolate());
-  v8::Handle<Context> env2 = Context::New(env1->GetIsolate());
+  v8::Local<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.
   CompileRun("spy=function(){return spy;}");
-  Local<Value> spy = env1->Global()->Get(v8_str("spy"));
+  Local<Value> spy =
+      env1->Global()->Get(env1.local(), v8_str("spy")).ToLocalChecked();
   CHECK(spy->IsFunction());
 
   // Create another function accessing global objects.
   CompileRun("spy2=function(){return new this.Array();}");
-  Local<Value> spy2 = env1->Global()->Get(v8_str("spy2"));
+  Local<Value> spy2 =
+      env1->Global()->Get(env1.local(), v8_str("spy2")).ToLocalChecked();
   CHECK(spy2->IsFunction());
 
   // Switch to env2 in the same domain and invoke spy on env2.
   {
     env2->SetSecurityToken(foo);
     // Enter env2
     Context::Scope scope_env2(env2);
-    Local<Value> result = Function::Cast(*spy)->Call(env2->Global(), 0, NULL);
+    Local<Value> result = Function::Cast(*spy)
+                              ->Call(env2, env2->Global(), 0, NULL)
+                              .ToLocalChecked();
     CHECK(result->IsFunction());
   }
 
   {
     env2->SetSecurityToken(bar);
     Context::Scope scope_env2(env2);
 
     // Call cross_domain_call, it should throw an exception
     v8::TryCatch try_catch(env1->GetIsolate());
-    Function::Cast(*spy2)->Call(env2->Global(), 0, NULL);
+    CHECK(Function::Cast(*spy2)->Call(env2, env2->Global(), 0, NULL).IsEmpty());
     CHECK(try_catch.HasCaught());
   }
 }
 
 
 // Regression test case for issue 1183439.
 THREADED_TEST(SecurityChecksForPrototypeChain) {
   LocalContext current;
   v8::HandleScope scope(current->GetIsolate());
-  v8::Handle<Context> other = Context::New(current->GetIsolate());
+  v8::Local<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));
+    other_object =
+        other->Global()->Get(other, v8_str("Object")).ToLocalChecked();
+    CHECK(other->Global()->Set(other, v8_num(42), v8_num(87)).FromJust());
   }
 
-  current->Global()->Set(v8_str("other"), other->Global());
-  CHECK(v8_compile("other")->Run()->Equals(other->Global()));
+  CHECK(current->Global()
+            ->Set(current.local(), v8_str("other"), other->Global())
+            .FromJust());
+  CHECK(v8_compile("other")
+            ->Run(current.local())
+            .ToLocalChecked()
+            ->Equals(current.local(), other->Global())
+            .FromJust());
 
   // Make sure the security check fails here and we get an undefined
   // result instead of getting the Object function. Repeat in a loop
   // to make sure to exercise the IC code.
   v8::Local<Script> access_other0 = v8_compile("other.Object");
   v8::Local<Script> access_other1 = v8_compile("other[42]");
   for (int i = 0; i < 5; i++) {
-    CHECK(access_other0->Run().IsEmpty());
-    CHECK(access_other1->Run().IsEmpty());
+    CHECK(access_other0->Run(current.local()).IsEmpty());
+    CHECK(access_other1->Run(current.local()).IsEmpty());
   }
 
   // Create an object that has 'other' in its prototype chain and make
   // sure we cannot access the Object function indirectly through
   // that. Repeat in a loop to make sure to exercise the IC code.
-  v8_compile("function F() { };"
-             "F.prototype = other;"
-             "var f = new F();")->Run();
+  v8_compile(
+      "function F() { };"
+      "F.prototype = other;"
+      "var f = new F();")
+      ->Run(current.local())
+      .ToLocalChecked();
   v8::Local<Script> access_f0 = v8_compile("f.Object");
   v8::Local<Script> access_f1 = v8_compile("f[42]");
   for (int j = 0; j < 5; j++) {
-    CHECK(access_f0->Run().IsEmpty());
-    CHECK(access_f1->Run().IsEmpty());
+    CHECK(access_f0->Run(current.local()).IsEmpty());
+    CHECK(access_f1->Run(current.local()).IsEmpty());
   }
 
   // Now it gets hairy: Set the prototype for the other global object
   // to be the current global object. The prototype chain for 'f' now
   // goes through 'other' but ends up in the current global object.
   { Context::Scope scope(other);
-    other->Global()->Set(v8_str("__proto__"), current->Global());
+    CHECK(other->Global()
+              ->Set(other, v8_str("__proto__"), current->Global())
+              .FromJust());
   }
   // Set a named and an index property on the current global
   // object. To force the lookup to go through the other global object,
   // the properties must not exist in the other global object.
-  current->Global()->Set(v8_str("foo"), v8_num(100));
-  current->Global()->Set(v8_num(99), v8_num(101));
+  CHECK(current->Global()
+            ->Set(current.local(), v8_str("foo"), v8_num(100))
+            .FromJust());
+  CHECK(current->Global()
+            ->Set(current.local(), v8_num(99), v8_num(101))
+            .FromJust());
   // 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().IsEmpty());
-    CHECK(access_f3->Run().IsEmpty());
+    CHECK(access_f2->Run(current.local()).IsEmpty());
+    CHECK(access_f3->Run(current.local()).IsEmpty());
   }
 }
 
 
 static bool security_check_with_gc_called;
 
 static bool SecurityTestCallbackWithGC(Local<v8::Context> accessing_context,
                                        Local<v8::Object> accessed_object) {
   CcTest::heap()->CollectAllGarbage();
   security_check_with_gc_called = true;
   return true;
 }
 
 
 TEST(SecurityTestGCAllowed) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
-  v8::Handle<v8::ObjectTemplate> object_template =
+  v8::Local<v8::ObjectTemplate> object_template =
       v8::ObjectTemplate::New(isolate);
   object_template->SetAccessCheckCallback(SecurityTestCallbackWithGC);
 
-  v8::Handle<Context> context = Context::New(isolate);
+  v8::Local<Context> context = Context::New(isolate);
   v8::Context::Scope context_scope(context);
 
-  context->Global()->Set(v8_str("obj"), object_template->NewInstance());
+  CHECK(context->Global()
+            ->Set(context, v8_str("obj"),
+                  object_template->NewInstance(context).ToLocalChecked())
+            .FromJust());
 
   security_check_with_gc_called = false;
   CompileRun("obj[0] = new String(1002);");
   CHECK(security_check_with_gc_called);
 
   security_check_with_gc_called = false;
-  CHECK(CompileRun("obj[0]")->ToString(isolate)->Equals(v8_str("1002")));
+  CHECK(CompileRun("obj[0]")
+            ->ToString(context)
+            .ToLocalChecked()
+            ->Equals(context, v8_str("1002"))
+            .FromJust());
   CHECK(security_check_with_gc_called);
 }
 
 
 THREADED_TEST(CrossDomainDelete) {
   LocalContext env1;
   v8::HandleScope handle_scope(env1->GetIsolate());
-  v8::Handle<Context> env2 = Context::New(env1->GetIsolate());
+  v8::Local<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());
+  CHECK(env1->Global()->Set(env2, v8_str("prop"), v8_num(3)).FromJust());

[jochen (gone - plz use gerrit), 2015/11/24 12:42:25]

should be env1 here 

[vogelheim, 2015/11/26 10:57:32]

Done.

+  CHECK(env2->Global()->Set(env2, v8_str("env1"), env1->Global()).FromJust());
 
   // Change env2 to a different domain and delete env1.prop.
   env2->SetSecurityToken(bar);
   {
     Context::Scope scope_env2(env2);
     Local<Value> result =
         CompileRun("delete env1.prop");
     CHECK(result.IsEmpty());
   }
 
   // Check that env1.prop still exists.
-  Local<Value> v = env1->Global()->Get(v8_str("prop"));
+  Local<Value> v =
+      env1->Global()->Get(env1.local(), v8_str("prop")).ToLocalChecked();
   CHECK(v->IsNumber());
-  CHECK_EQ(3, v->Int32Value());
+  CHECK_EQ(3, v->Int32Value(env1.local()).FromJust());
 }
 
 
 THREADED_TEST(CrossDomainIsPropertyEnumerable) {
   LocalContext env1;
   v8::HandleScope handle_scope(env1->GetIsolate());
-  v8::Handle<Context> env2 = Context::New(env1->GetIsolate());
+  v8::Local<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());
+  CHECK(
+      env1->Global()->Set(env1.local(), v8_str("prop"), v8_num(3)).FromJust());
+  CHECK(env2->Global()->Set(env2, v8_str("env1"), env1->Global()).FromJust());
 
   // env1.prop is enumerable in env2.
   Local<String> test = v8_str("propertyIsEnumerable.call(env1, 'prop')");
   {
     Context::Scope scope_env2(env2);
     Local<Value> result = CompileRun(test);
     CHECK(result->IsTrue());
   }
 
   // Change env2 to a different domain and test again.
   env2->SetSecurityToken(bar);
   {
     Context::Scope scope_env2(env2);
     Local<Value> result = CompileRun(test);
     CHECK(result.IsEmpty());
   }
 }
 
 
 THREADED_TEST(CrossDomainFor) {
   LocalContext env1;
   v8::HandleScope handle_scope(env1->GetIsolate());
-  v8::Handle<Context> env2 = Context::New(env1->GetIsolate());
+  v8::Local<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());
+  CHECK(
+      env1->Global()->Set(env1.local(), v8_str("prop"), v8_num(3)).FromJust());
+  CHECK(env2->Global()->Set(env2, v8_str("env1"), env1->Global()).FromJust());
 
   // 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() {"
         "  try {"
         "    for (var p in env1) {"
         "      if (p == 'prop') return false;"
         "    }"
         "    return true;"
         "  } catch (e) {"
         "    return false;"
         "  }"
         "})()");
     CHECK(result->IsTrue());
   }
 }
 
 
 THREADED_TEST(CrossDomainForInOnPrototype) {
   LocalContext env1;
   v8::HandleScope handle_scope(env1->GetIsolate());
-  v8::Handle<Context> env2 = Context::New(env1->GetIsolate());
+  v8::Local<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());
+  CHECK(
+      env1->Global()->Set(env1.local(), v8_str("prop"), v8_num(3)).FromJust());
+  CHECK(env2->Global()->Set(env2, v8_str("env1"), env1->Global()).FromJust());
 
   // 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 };"
         "  try {"
         "    for (var p in obj) {"
         "      if (p == 'prop') return false;"
         "    }"
         "    return false;"
         "  } catch (e) {"
         "    return true;"
         "  }"
         "})()");
     CHECK(result->IsTrue());
   }
 }
 
 
 TEST(ContextDetachGlobal) {
   LocalContext env1;
   v8::HandleScope handle_scope(env1->GetIsolate());
-  v8::Handle<Context> env2 = Context::New(env1->GetIsolate());
+  v8::Local<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(env2->GetIsolate(), 1));
+  CHECK(global2->Set(env2, v8_str("prop"),
+                     v8::Integer::New(env2->GetIsolate(), 1))
+            .FromJust());
   CompileRun("function getProp() {return prop;}");
 
-  env1->Global()->Set(v8_str("getProp"),
-                      global2->Get(v8_str("getProp")));
+  CHECK(env1->Global()
+            ->Set(env1.local(), v8_str("getProp"),
+                  global2->Get(env2, v8_str("getProp")).ToLocalChecked())
+            .FromJust());
 
   // Detach env2's global, and reuse the global object of env2
   env2->Exit();
   env2->DetachGlobal();
 
-  v8::Handle<Context> env3 = Context::New(env1->GetIsolate(),
-                                          0,
-                                          v8::Handle<v8::ObjectTemplate>(),
-                                          global2);
+  v8::Local<Context> env3 = Context::New(
+      env1->GetIsolate(), 0, v8::Local<v8::ObjectTemplate>(), global2);
   env3->SetSecurityToken(v8_str("bar"));
+
   env3->Enter();
-
   Local<v8::Object> global3 = env3->Global();
-  CHECK(global2->Equals(global3));
-  CHECK(global3->Get(v8_str("prop"))->IsUndefined());
-  CHECK(global3->Get(v8_str("getProp"))->IsUndefined());
-  global3->Set(v8_str("prop"), v8::Integer::New(env3->GetIsolate(), -1));
-  global3->Set(v8_str("prop2"), v8::Integer::New(env3->GetIsolate(), 2));
+  CHECK(global2->Equals(env3, global3).FromJust());
+  CHECK(global3->Get(env3, v8_str("prop")).ToLocalChecked()->IsUndefined());
+  CHECK(global3->Get(env3, v8_str("getProp")).ToLocalChecked()->IsUndefined());
+  CHECK(global3->Set(env3, v8_str("prop"),
+                     v8::Integer::New(env3->GetIsolate(), -1))
+            .FromJust());
+  CHECK(global3->Set(env3, v8_str("prop2"),
+                     v8::Integer::New(env3->GetIsolate(), 2))
+            .FromJust());
   env3->Exit();
 
   // Call getProp in env1, and it should return the value 1
   {
-    Local<Value> get_prop = global1->Get(v8_str("getProp"));
+    Local<v8::Object> global1 = env1->Global();
+    Local<Value> get_prop =
+        global1->Get(env1.local(), v8_str("getProp")).ToLocalChecked();
     CHECK(get_prop->IsFunction());
     v8::TryCatch try_catch(env1->GetIsolate());
-    Local<Value> r = Function::Cast(*get_prop)->Call(global1, 0, NULL);
+    Local<Value> r = Function::Cast(*get_prop)
+                         ->Call(env1.local(), global1, 0, NULL)
+                         .ToLocalChecked();
     CHECK(!try_catch.HasCaught());
-    CHECK_EQ(1, r->Int32Value());
+    CHECK_EQ(1, r->Int32Value(env1.local()).FromJust());
   }
 
   // Check that env3 is not accessible from env1
   {
-    Local<Value> r = global3->Get(v8_str("prop2"));
+    v8::MaybeLocal<Value> r = global3->Get(env1.local(), v8_str("prop2"));
     CHECK(r.IsEmpty());
   }
 }
 
 
 TEST(DetachGlobal) {
   LocalContext env1;
   v8::HandleScope scope(env1->GetIsolate());
 
   // Create second environment.
-  v8::Handle<Context> env2 = Context::New(env1->GetIsolate());
+  v8::Local<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);
-    env2->Global()->Set(v8_str("p"), v8::Integer::New(env2->GetIsolate(), 42));
+    CHECK(env2->Global()
+              ->Set(env2, v8_str("p"), v8::Integer::New(env2->GetIsolate(), 42))
+              .FromJust());
   }
 
   // Create a reference to env2 global from env1 global.
-  env1->Global()->Set(v8_str("other"), env2->Global());
+  CHECK(env1->Global()
+            ->Set(env1.local(), v8_str("other"), env2->Global())
+            .FromJust());
 
   // Check that we have access to other.p in env2 from env1.
   Local<Value> result = CompileRun("other.p");
   CHECK(result->IsInt32());
-  CHECK_EQ(42, result->Int32Value());
+  CHECK_EQ(42, result->Int32Value(env1.local()).FromJust());
 
   // 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.IsEmpty());
 
   // Reuse global2 for env3.
-  v8::Handle<Context> env3 = Context::New(env1->GetIsolate(),
-                                          0,
-                                          v8::Handle<v8::ObjectTemplate>(),
-                                          global2);
-  CHECK(global2->Equals(env3->Global()));
+  v8::Local<Context> env3 = Context::New(
+      env1->GetIsolate(), 0, v8::Local<v8::ObjectTemplate>(), global2);
+  CHECK(global2->Equals(env1.local(), env3->Global()).FromJust());
 
   // 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(env3->GetIsolate(), 24));
+    CHECK(env3->Global()
+              ->Set(env3, v8_str("p"), v8::Integer::New(env3->GetIsolate(), 24))
+              .FromJust());
   }
 
   // Check that other.p is now the property in env3 and that we have access.
   result = CompileRun("other.p");
   CHECK(result->IsInt32());
-  CHECK_EQ(24, result->Int32Value());
+  CHECK_EQ(24, result->Int32Value(env3).FromJust());
 
   // Change security token for env3 to something different from env1 and env2.
   env3->SetSecurityToken(v8_str("bar"));
 
   // Check that we do not have access to other.p in env1. |other| is now
   // the global object for env3 which has a different security token,
   // so access should be blocked.
   result = CompileRun("other.p");
   CHECK(result.IsEmpty());
 }
 
 
 void GetThisX(const v8::FunctionCallbackInfo<v8::Value>& info) {
+  v8::Local<v8::Context> context = info.GetIsolate()->GetCurrentContext();
   info.GetReturnValue().Set(
-      info.GetIsolate()->GetCurrentContext()->Global()->Get(v8_str("x")));
+      context->Global()->Get(context, v8_str("x")).ToLocalChecked());
 }
 
 
 TEST(DetachedAccesses) {
   LocalContext env1;
   v8::HandleScope scope(env1->GetIsolate());
 
   // Create second environment.
   Local<ObjectTemplate> inner_global_template =
       FunctionTemplate::New(env1->GetIsolate())->InstanceTemplate();
   inner_global_template ->SetAccessorProperty(
       v8_str("this_x"), FunctionTemplate::New(env1->GetIsolate(), GetThisX));
   v8::Local<Context> env2 =
       Context::New(env1->GetIsolate(), NULL, inner_global_template);
 
   Local<Value> foo = v8_str("foo");
 
   // Set same security token for env1 and env2.
   env1->SetSecurityToken(foo);
   env2->SetSecurityToken(foo);
 
-  env1->Global()->Set(v8_str("x"), v8_str("env1_x"));
+  CHECK(env1->Global()
+            ->Set(env1.local(), v8_str("x"), v8_str("env1_x"))
+            .FromJust());
 
   {
     v8::Context::Scope scope(env2);
-    env2->Global()->Set(v8_str("x"), v8_str("env2_x"));
+    CHECK(env2->Global()->Set(env2, v8_str("x"), v8_str("env2_x")).FromJust());
     CompileRun(
         "function bound_x() { return x; }"
         "function get_x()   { return this.x; }"
         "function get_x_w() { return (function() {return this.x;})(); }");
-    env1->Global()->Set(v8_str("bound_x"), CompileRun("bound_x"));
-    env1->Global()->Set(v8_str("get_x"), CompileRun("get_x"));
-    env1->Global()->Set(v8_str("get_x_w"), CompileRun("get_x_w"));
-    env1->Global()->Set(
-        v8_str("this_x"),
-        CompileRun("Object.getOwnPropertyDescriptor(this, 'this_x').get"));
+    // SHOULD BE env2 ???

[jochen (gone - plz use gerrit), 2015/11/24 12:42:25]

env1 is ok here

[vogelheim, 2015/11/26 10:57:32]

Done.

+    CHECK(env1->Global()
+              ->Set(env1.local(), v8_str("bound_x"), CompileRun("bound_x"))
+              .FromJust());
+    CHECK(env1->Global()
+              ->Set(env1.local(), v8_str("get_x"), CompileRun("get_x"))
+              .FromJust());
+    CHECK(env1->Global()
+              ->Set(env1.local(), v8_str("get_x_w"), CompileRun("get_x_w"))
+              .FromJust());
+    env1->Global()
+        ->Set(env1.local(), v8_str("this_x"),
+              CompileRun("Object.getOwnPropertyDescriptor(this, 'this_x').get"))
+        .FromJust();
   }
 
   Local<Object> env2_global = env2->Global();
   env2->DetachGlobal();
 
   Local<Value> result;
   result = CompileRun("bound_x()");
-  CHECK(v8_str("env2_x")->Equals(result));
+  CHECK(v8_str("env2_x")->Equals(env1.local(), result).FromJust());
   result = CompileRun("get_x()");
   CHECK(result.IsEmpty());
   result = CompileRun("get_x_w()");
   CHECK(result.IsEmpty());
   result = CompileRun("this_x()");
-  CHECK(v8_str("env2_x")->Equals(result));
+  CHECK(v8_str("env2_x")->Equals(env1.local(), result).FromJust());
 
   // Reattach env2's proxy
-  env2 = Context::New(env1->GetIsolate(),
-                      0,
-                      v8::Handle<v8::ObjectTemplate>(),
+  env2 = Context::New(env1->GetIsolate(), 0, v8::Local<v8::ObjectTemplate>(),
                       env2_global);
   env2->SetSecurityToken(foo);
   {
     v8::Context::Scope scope(env2);
-    env2->Global()->Set(v8_str("x"), v8_str("env3_x"));
-    env2->Global()->Set(v8_str("env1"), env1->Global());
+    CHECK(env2->Global()->Set(env2, v8_str("x"), v8_str("env3_x")).FromJust());
+    CHECK(env2->Global()->Set(env2, v8_str("env1"), env1->Global()).FromJust());
     result = CompileRun(
         "results = [];"
         "for (var i = 0; i < 4; i++ ) {"
         "  results.push(env1.bound_x());"
         "  results.push(env1.get_x());"
         "  results.push(env1.get_x_w());"
         "  results.push(env1.this_x());"
         "}"
         "results");
     Local<v8::Array> results = Local<v8::Array>::Cast(result);
     CHECK_EQ(16u, results->Length());
     for (int i = 0; i < 16; i += 4) {
-      CHECK(v8_str("env2_x")->Equals(results->Get(i + 0)));
-      CHECK(v8_str("env1_x")->Equals(results->Get(i + 1)));
-      CHECK(v8_str("env3_x")->Equals(results->Get(i + 2)));
-      CHECK(v8_str("env2_x")->Equals(results->Get(i + 3)));
+      CHECK(v8_str("env2_x")
+                ->Equals(env2, results->Get(env2, i + 0).ToLocalChecked())
+                .FromJust());
+      CHECK(v8_str("env1_x")
+                ->Equals(env2, results->Get(env2, i + 1).ToLocalChecked())
+                .FromJust());
+      CHECK(v8_str("env3_x")
+                ->Equals(env2, results->Get(env2, i + 2).ToLocalChecked())
+                .FromJust());
+      CHECK(v8_str("env2_x")
+                ->Equals(env2, results->Get(env2, i + 3).ToLocalChecked())
+                .FromJust());
     }
   }
 
   result = CompileRun(
       "results = [];"
       "for (var i = 0; i < 4; i++ ) {"
       "  results.push(bound_x());"
       "  results.push(get_x());"
       "  results.push(get_x_w());"
       "  results.push(this_x());"
       "}"
       "results");
   Local<v8::Array> results = Local<v8::Array>::Cast(result);
   CHECK_EQ(16u, results->Length());
   for (int i = 0; i < 16; i += 4) {
-    CHECK(v8_str("env2_x")->Equals(results->Get(i + 0)));
-    CHECK(v8_str("env3_x")->Equals(results->Get(i + 1)));
-    CHECK(v8_str("env3_x")->Equals(results->Get(i + 2)));
-    CHECK(v8_str("env2_x")->Equals(results->Get(i + 3)));
+    CHECK(v8_str("env2_x")
+              ->Equals(env1.local(),
+                       results->Get(env1.local(), i + 0).ToLocalChecked())
+              .FromJust());
+    CHECK(v8_str("env3_x")
+              ->Equals(env1.local(),
+                       results->Get(env1.local(), i + 1).ToLocalChecked())
+              .FromJust());
+    CHECK(v8_str("env3_x")
+              ->Equals(env1.local(),
+                       results->Get(env1.local(), i + 2).ToLocalChecked())
+              .FromJust());
+    CHECK(v8_str("env2_x")
+              ->Equals(env1.local(),
+                       results->Get(env1.local(), i + 3).ToLocalChecked())
+              .FromJust());
   }
 
   result = CompileRun(
       "results = [];"
       "for (var i = 0; i < 4; i++ ) {"
       "  results.push(this.bound_x());"
       "  results.push(this.get_x());"
       "  results.push(this.get_x_w());"
       "  results.push(this.this_x());"
       "}"
       "results");
   results = Local<v8::Array>::Cast(result);
   CHECK_EQ(16u, results->Length());
   for (int i = 0; i < 16; i += 4) {
-    CHECK(v8_str("env2_x")->Equals(results->Get(i + 0)));
-    CHECK(v8_str("env1_x")->Equals(results->Get(i + 1)));
-    CHECK(v8_str("env3_x")->Equals(results->Get(i + 2)));
-    CHECK(v8_str("env2_x")->Equals(results->Get(i + 3)));
+    CHECK(v8_str("env2_x")
+              ->Equals(env1.local(),
+                       results->Get(env1.local(), i + 0).ToLocalChecked())
+              .FromJust());
+    CHECK(v8_str("env1_x")
+              ->Equals(env1.local(),
+                       results->Get(env1.local(), i + 1).ToLocalChecked())
+              .FromJust());
+    CHECK(v8_str("env3_x")
+              ->Equals(env1.local(),
+                       results->Get(env1.local(), i + 2).ToLocalChecked())
+              .FromJust());
+    CHECK(v8_str("env2_x")
+              ->Equals(env1.local(),
+                       results->Get(env1.local(), i + 3).ToLocalChecked())
+              .FromJust());
   }
 }
 
 
 static bool allowed_access = false;
 static bool AccessBlocker(Local<v8::Context> accessing_context,
                           Local<v8::Object> accessed_object) {
-  return CcTest::isolate()->GetCurrentContext()->Global()->Equals(
-             accessed_object) ||
+  v8::Local<v8::Context> context = CcTest::isolate()->GetCurrentContext();
+  return context->Global()->Equals(context, accessed_object).FromJust() ||
          allowed_access;
 }
 
 
 static int g_echo_value = -1;
 
 
 static void EchoGetter(
     Local<String> name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   info.GetReturnValue().Set(v8_num(g_echo_value));
 }
 
 
-static void EchoSetter(Local<String> name,
-                       Local<Value> value,
-                       const v8::PropertyCallbackInfo<void>&) {
+static void EchoSetter(Local<String> name, Local<Value> value,
+                       const v8::PropertyCallbackInfo<void>& args) {
   if (value->IsNumber())
-    g_echo_value = value->Int32Value();
+    g_echo_value =
+        value->Int32Value(args.GetIsolate()->GetCurrentContext()).FromJust();
 }
 
 
 static void UnreachableGetter(
     Local<String> name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   CHECK(false);  // This function should not be called..
 }
 
 
 static void UnreachableSetter(Local<String>,
                               Local<Value>,
                               const v8::PropertyCallbackInfo<void>&) {
   CHECK(false);  // This function should nto be called.
 }
 
 
 static void UnreachableFunction(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
   CHECK(false);  // This function should not be called..
 }
 
 
 TEST(AccessControl) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
-  v8::Handle<v8::ObjectTemplate> global_template =
+  v8::Local<v8::ObjectTemplate> global_template =
       v8::ObjectTemplate::New(isolate);
 
   global_template->SetAccessCheckCallback(AccessBlocker);
 
   // Add an accessor accessible by cross-domain JS code.
   global_template->SetAccessor(
-      v8_str("accessible_prop"),
-      EchoGetter, EchoSetter,
-      v8::Handle<Value>(),
+      v8_str("accessible_prop"), EchoGetter, EchoSetter, v8::Local<Value>(),
       v8::AccessControl(v8::ALL_CAN_READ | v8::ALL_CAN_WRITE));
 
 
   // Add an accessor that is not accessible by cross-domain JS code.
-  global_template->SetAccessor(v8_str("blocked_prop"),
-                               UnreachableGetter, UnreachableSetter,
-                               v8::Handle<Value>(),
+  global_template->SetAccessor(v8_str("blocked_prop"), UnreachableGetter,
+                               UnreachableSetter, v8::Local<Value>(),
                                v8::DEFAULT);
 
   global_template->SetAccessorProperty(
       v8_str("blocked_js_prop"),
       v8::FunctionTemplate::New(isolate, UnreachableFunction),
       v8::FunctionTemplate::New(isolate, UnreachableFunction),
       v8::None,
       v8::DEFAULT);
 
   // Create an environment
   v8::Local<Context> context0 = Context::New(isolate, NULL, global_template);
   context0->Enter();
 
-  v8::Handle<v8::Object> global0 = context0->Global();
+  v8::Local<v8::Object> global0 = context0->Global();
 
   // Define a property with JS getter and setter.
   CompileRun(
       "function getter() { return 'getter'; };\n"
       "function setter() { return 'setter'; }\n"
       "Object.defineProperty(this, 'js_accessor_p', {get:getter, set:setter})");
 
-  Local<Value> getter = global0->Get(v8_str("getter"));
-  Local<Value> setter = global0->Get(v8_str("setter"));
+  Local<Value> getter =
+      global0->Get(context0, v8_str("getter")).ToLocalChecked();
+  Local<Value> setter =
+      global0->Get(context0, v8_str("setter")).ToLocalChecked();
 
   // And define normal element.
-  global0->Set(239, v8_str("239"));
+  CHECK(global0->Set(context0, 239, v8_str("239")).FromJust());
 
   // Define an element with JS getter and setter.
   CompileRun(
       "function el_getter() { return 'el_getter'; };\n"
       "function el_setter() { return 'el_setter'; };\n"
       "Object.defineProperty(this, '42', {get: el_getter, set: el_setter});");
 
-  Local<Value> el_getter = global0->Get(v8_str("el_getter"));
-  Local<Value> el_setter = global0->Get(v8_str("el_setter"));
+  Local<Value> el_getter =
+      global0->Get(context0, v8_str("el_getter")).ToLocalChecked();
+  Local<Value> el_setter =
+      global0->Get(context0, v8_str("el_setter")).ToLocalChecked();
 
   v8::HandleScope scope1(isolate);
 
   v8::Local<Context> context1 = Context::New(isolate);
   context1->Enter();
 
-  v8::Handle<v8::Object> global1 = context1->Global();
-  global1->Set(v8_str("other"), global0);
+  v8::Local<v8::Object> global1 = context1->Global();
+  CHECK(global1->Set(context1, v8_str("other"), global0).FromJust());
 
   // Access blocked property.
   CompileRun("other.blocked_prop = 1");
 
   CHECK(CompileRun("other.blocked_prop").IsEmpty());
   CHECK(CompileRun("Object.getOwnPropertyDescriptor(other, 'blocked_prop')")
             .IsEmpty());
   CHECK(
       CompileRun("propertyIsEnumerable.call(other, 'blocked_prop')").IsEmpty());
 
@@ skipping 36 matching lines @@
 
   allowed_access = true;
 
   ExpectString("other[42]", "el_getter");
   ExpectObject("Object.getOwnPropertyDescriptor(other, '42').get", el_getter);
   ExpectObject("Object.getOwnPropertyDescriptor(other, '42').set", el_setter);
   ExpectUndefined("Object.getOwnPropertyDescriptor(other, '42').value");
 
   allowed_access = false;
 
-  v8::Handle<Value> value;
+  v8::Local<Value> value;
 
   // Access accessible property
   value = CompileRun("other.accessible_prop = 3");
   CHECK(value->IsNumber());
-  CHECK_EQ(3, value->Int32Value());
+  CHECK_EQ(3, value->Int32Value(context1).FromJust());
   CHECK_EQ(3, g_echo_value);
 
   value = CompileRun("other.accessible_prop");
   CHECK(value->IsNumber());
-  CHECK_EQ(3, value->Int32Value());
+  CHECK_EQ(3, value->Int32Value(context1).FromJust());
 
   value = CompileRun(
       "Object.getOwnPropertyDescriptor(other, 'accessible_prop').value");
   CHECK(value->IsNumber());
-  CHECK_EQ(3, value->Int32Value());
+  CHECK_EQ(3, value->Int32Value(context1).FromJust());
 
   value = CompileRun("propertyIsEnumerable.call(other, 'accessible_prop')");
   CHECK(value->IsTrue());
 
   // Enumeration doesn't enumerate accessors from inaccessible objects in
   // the prototype chain even if the accessors are in themselves accessible.
   value = CompileRun(
       "(function() {"
       "  var obj = { '__proto__': other };"
       "  try {"
       "    for (var p in obj) {"
       "      if (p == 'accessible_prop' ||"
       "          p == 'blocked_js_prop' ||"
       "          p == 'blocked_js_prop') {"
       "        return false;"
       "      }"
       "    }"
       "    return false;"
       "  } catch (e) {"
       "    return true;"
       "  }"
       "})()");
   CHECK(value->IsTrue());
 
   // Test that preventExtensions fails on a non-accessible object even if that
   // object is already non-extensible.
-  global1->Set(v8_str("checked_object"), global_template->NewInstance());
+  CHECK(global1->Set(context1, v8_str("checked_object"),
+                     global_template->NewInstance(context1).ToLocalChecked())
+            .FromJust());
   allowed_access = true;
   CompileRun("Object.preventExtensions(checked_object)");
   ExpectFalse("Object.isExtensible(checked_object)");
   allowed_access = false;
   CHECK(CompileRun("Object.preventExtensions(checked_object)").IsEmpty());
 
   context1->Exit();
   context0->Exit();
 }
 
 
 TEST(AccessControlES5) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
-  v8::Handle<v8::ObjectTemplate> global_template =
+  v8::Local<v8::ObjectTemplate> global_template =
       v8::ObjectTemplate::New(isolate);
 
   global_template->SetAccessCheckCallback(AccessBlocker);
 
   // Add accessible accessor.
   global_template->SetAccessor(
-      v8_str("accessible_prop"),
-      EchoGetter, EchoSetter,
-      v8::Handle<Value>(),
+      v8_str("accessible_prop"), EchoGetter, EchoSetter, v8::Local<Value>(),
       v8::AccessControl(v8::ALL_CAN_READ | v8::ALL_CAN_WRITE));
 
 
   // Add an accessor that is not accessible by cross-domain JS code.
-  global_template->SetAccessor(v8_str("blocked_prop"),
-                               UnreachableGetter, UnreachableSetter,
-                               v8::Handle<Value>(),
+  global_template->SetAccessor(v8_str("blocked_prop"), UnreachableGetter,
+                               UnreachableSetter, v8::Local<Value>(),
                                v8::DEFAULT);
 
   // Create an environment
   v8::Local<Context> context0 = Context::New(isolate, NULL, global_template);
   context0->Enter();
 
-  v8::Handle<v8::Object> global0 = context0->Global();
+  v8::Local<v8::Object> global0 = context0->Global();
 
   v8::Local<Context> context1 = Context::New(isolate);
   context1->Enter();
-  v8::Handle<v8::Object> global1 = context1->Global();
-  global1->Set(v8_str("other"), global0);
+  v8::Local<v8::Object> global1 = context1->Global();
+  CHECK(global1->Set(context1, v8_str("other"), global0).FromJust());
 
   // Regression test for issue 1154.
-  CHECK(CompileRun("Object.keys(other).length == 0")->BooleanValue());
+  CHECK(CompileRun("Object.keys(other).length == 0")
+            ->BooleanValue(context1)
+            .FromJust());
   CHECK(CompileRun("other.blocked_prop").IsEmpty());
 
   // Regression test for issue 1027.
   CompileRun("Object.defineProperty(\n"
              "  other, 'blocked_prop', {configurable: false})");
   CHECK(CompileRun("other.blocked_prop").IsEmpty());
   CHECK(CompileRun("Object.getOwnPropertyDescriptor(other, 'blocked_prop')")
             .IsEmpty());
 
   // Regression test for issue 1171.
@@ skipping 26 matching lines @@
 static bool AccessAlwaysBlocked(Local<v8::Context> accessing_context,
                                 Local<v8::Object> global) {
   i::PrintF("Access blocked.\n");
   return false;
 }
 
 
 THREADED_TEST(AccessControlGetOwnPropertyNames) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
-  v8::Handle<v8::ObjectTemplate> obj_template =
-      v8::ObjectTemplate::New(isolate);
+  v8::Local<v8::ObjectTemplate> obj_template = v8::ObjectTemplate::New(isolate);
 
   obj_template->Set(v8_str("x"), v8::Integer::New(isolate, 42));
   obj_template->SetAccessCheckCallback(AccessAlwaysBlocked);
 
   // Add an accessor accessible by cross-domain JS code.
   obj_template->SetAccessor(
-      v8_str("accessible_prop"), EchoGetter, EchoSetter, v8::Handle<Value>(),
+      v8_str("accessible_prop"), EchoGetter, EchoSetter, v8::Local<Value>(),
       v8::AccessControl(v8::ALL_CAN_READ | v8::ALL_CAN_WRITE));
 
   // Create an environment
   v8::Local<Context> context0 = Context::New(isolate, NULL, obj_template);
   context0->Enter();
 
-  v8::Handle<v8::Object> global0 = context0->Global();
+  v8::Local<v8::Object> global0 = context0->Global();
 
   v8::HandleScope scope1(CcTest::isolate());
 
   v8::Local<Context> context1 = Context::New(isolate);
   context1->Enter();
 
-  v8::Handle<v8::Object> global1 = context1->Global();
-  global1->Set(v8_str("other"), global0);
-  global1->Set(v8_str("object"), obj_template->NewInstance());
+  v8::Local<v8::Object> global1 = context1->Global();
+  CHECK(global1->Set(context1, v8_str("other"), global0).FromJust());
+  CHECK(global1->Set(context1, v8_str("object"),
+                     obj_template->NewInstance(context1).ToLocalChecked())
+            .FromJust());
 
-  v8::Handle<Value> value;
+  v8::Local<Value> value;
 
   // Attempt to get the property names of the other global object and
   // of an object that requires access checks.  Accessing the other
   // global object should be blocked by access checks on the global
   // proxy object.  Accessing the object that requires access checks
   // is blocked by the access checks on the object itself.
   value = CompileRun(
       "var names = Object.getOwnPropertyNames(other);"
       "names.length == 1 && names[0] == 'accessible_prop';");
-  CHECK(value->BooleanValue());
+  CHECK(value->BooleanValue(context1).FromJust());
 
   value = CompileRun(
       "var names = Object.getOwnPropertyNames(object);"
       "names.length == 1 && names[0] == 'accessible_prop';");
-  CHECK(value->BooleanValue());
+  CHECK(value->BooleanValue(context1).FromJust());
 
   context1->Exit();
   context0->Exit();
 }
 
 
 TEST(Regress470113) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
-  v8::Handle<v8::ObjectTemplate> obj_template =
-      v8::ObjectTemplate::New(isolate);
+  v8::Local<v8::ObjectTemplate> obj_template = v8::ObjectTemplate::New(isolate);
   obj_template->SetAccessCheckCallback(AccessAlwaysBlocked);
   LocalContext env;
-  env->Global()->Set(v8_str("prohibited"), obj_template->NewInstance());
+  CHECK(env->Global()
+            ->Set(env.local(), v8_str("prohibited"),
+                  obj_template->NewInstance(env.local()).ToLocalChecked())
+            .FromJust());
 
   {
     v8::TryCatch try_catch(isolate);
     CompileRun(
         "'use strict';\n"
         "class C extends Object {\n"
         "   m() { super.powned = 'Powned!'; }\n"
         "}\n"
         "let c = new C();\n"
         "c.m.call(prohibited)");
 
     CHECK(try_catch.HasCaught());
   }
 }
 
 
 static void ConstTenGetter(Local<String> name,
                            const v8::PropertyCallbackInfo<v8::Value>& info) {
   info.GetReturnValue().Set(v8_num(10));
 }
 
 
 THREADED_TEST(CrossDomainAccessors) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
 
-  v8::Handle<v8::FunctionTemplate> func_template =
+  v8::Local<v8::FunctionTemplate> func_template =
       v8::FunctionTemplate::New(isolate);
 
-  v8::Handle<v8::ObjectTemplate> global_template =
+  v8::Local<v8::ObjectTemplate> global_template =
       func_template->InstanceTemplate();
 
-  v8::Handle<v8::ObjectTemplate> proto_template =
+  v8::Local<v8::ObjectTemplate> proto_template =
       func_template->PrototypeTemplate();
 
   // Add an accessor to proto that's accessible by cross-domain JS code.
-  proto_template->SetAccessor(v8_str("accessible"),
-                              ConstTenGetter, 0,
-                              v8::Handle<Value>(),
-                              v8::ALL_CAN_READ);
+  proto_template->SetAccessor(v8_str("accessible"), ConstTenGetter, 0,
+                              v8::Local<Value>(), v8::ALL_CAN_READ);
 
   // Add an accessor that is not accessible by cross-domain JS code.
-  global_template->SetAccessor(v8_str("unreachable"),
-                               UnreachableGetter, 0,
-                               v8::Handle<Value>(),
-                               v8::DEFAULT);
+  global_template->SetAccessor(v8_str("unreachable"), UnreachableGetter, 0,
+                               v8::Local<Value>(), v8::DEFAULT);
 
   v8::Local<Context> context0 = Context::New(isolate, NULL, global_template);
   context0->Enter();
 
   Local<v8::Object> global = context0->Global();
   // Add a normal property that shadows 'accessible'
-  global->Set(v8_str("accessible"), v8_num(11));
+  CHECK(global->Set(context0, v8_str("accessible"), v8_num(11)).FromJust());
 
   // Enter a new context.
   v8::HandleScope scope1(CcTest::isolate());
   v8::Local<Context> context1 = Context::New(isolate);
   context1->Enter();
 
-  v8::Handle<v8::Object> global1 = context1->Global();
-  global1->Set(v8_str("other"), global);
+  v8::Local<v8::Object> global1 = context1->Global();
+  CHECK(global1->Set(context1, v8_str("other"), global).FromJust());
 
   // Should return 10, instead of 11
-  v8::Handle<Value> value = v8_compile("other.accessible")->Run();
+  v8::Local<Value> value =
+      v8_compile("other.accessible")->Run(context1).ToLocalChecked();
   CHECK(value->IsNumber());
-  CHECK_EQ(10, value->Int32Value());
+  CHECK_EQ(10, value->Int32Value(context1).FromJust());
 
-  value = v8_compile("other.unreachable")->Run();
-  CHECK(value.IsEmpty());
+  v8::MaybeLocal<v8::Value> maybe_value =
+      v8_compile("other.unreachable")->Run(context1);
+  CHECK(maybe_value.IsEmpty());
 
   context1->Exit();
   context0->Exit();
 }
 
 
 static int access_count = 0;
 
 static bool AccessCounter(Local<v8::Context> accessing_context,
                           Local<v8::Object> accessed_object) {
   access_count++;
   return true;
 }
 
 
 // This one is too easily disturbed by other tests.
 TEST(AccessControlIC) {
   access_count = 0;
 
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
 
   // Create an environment.
   v8::Local<Context> context0 = Context::New(isolate);
   context0->Enter();
 
   // Create an object that requires access-check functions to be
   // called for cross-domain access.
-  v8::Handle<v8::ObjectTemplate> object_template =
+  v8::Local<v8::ObjectTemplate> object_template =
       v8::ObjectTemplate::New(isolate);
   object_template->SetAccessCheckCallback(AccessCounter);
-  Local<v8::Object> object = object_template->NewInstance();
+  Local<v8::Object> object =
+      object_template->NewInstance(context0).ToLocalChecked();
 
   v8::HandleScope scope1(isolate);
 
   // Create another environment.
   v8::Local<Context> context1 = Context::New(isolate);
   context1->Enter();
 
   // Make easy access to the object from the other environment.
-  v8::Handle<v8::Object> global1 = context1->Global();
-  global1->Set(v8_str("obj"), object);
+  v8::Local<v8::Object> global1 = context1->Global();
+  CHECK(global1->Set(context1, v8_str("obj"), object).FromJust());
 
-  v8::Handle<Value> value;
+  v8::Local<Value> value;
 
   // Check that the named access-control function is called every time.
   CompileRun("function testProp(obj) {"
              "  for (var i = 0; i < 10; i++) obj.prop = 1;"
              "  for (var j = 0; j < 10; j++) obj.prop;"
              "  return obj.prop"
              "}");
   value = CompileRun("testProp(obj)");
   CHECK(value->IsNumber());
-  CHECK_EQ(1, value->Int32Value());
+  CHECK_EQ(1, value->Int32Value(context1).FromJust());
   CHECK_EQ(21, access_count);
 
   // Check that the named access-control function is called every time.
   CompileRun("var p = 'prop';"
              "function testKeyed(obj) {"
              "  for (var i = 0; i < 10; i++) obj[p] = 1;"
              "  for (var j = 0; j < 10; j++) obj[p];"
              "  return obj[p];"
              "}");
   // Use obj which requires access checks.  No inline caching is used
   // in that case.
   value = CompileRun("testKeyed(obj)");
   CHECK(value->IsNumber());
-  CHECK_EQ(1, value->Int32Value());
+  CHECK_EQ(1, value->Int32Value(context1).FromJust());
   CHECK_EQ(42, access_count);
   // Force the inline caches into generic state and try again.
   CompileRun("testKeyed({ a: 0 })");
   CompileRun("testKeyed({ b: 0 })");
   value = CompileRun("testKeyed(obj)");
   CHECK(value->IsNumber());
-  CHECK_EQ(1, value->Int32Value());
+  CHECK_EQ(1, value->Int32Value(context1).FromJust());
   CHECK_EQ(63, access_count);
 
   // Check that the indexed access-control function is called every time.
   access_count = 0;
 
   CompileRun("function testIndexed(obj) {"
              "  for (var i = 0; i < 10; i++) obj[0] = 1;"
              "  for (var j = 0; j < 10; j++) obj[0];"
              "  return obj[0]"
              "}");
   value = CompileRun("testIndexed(obj)");
   CHECK(value->IsNumber());
-  CHECK_EQ(1, value->Int32Value());
+  CHECK_EQ(1, value->Int32Value(context1).FromJust());
   CHECK_EQ(21, access_count);
   // Force the inline caches into generic state.
   CompileRun("testIndexed(new Array(1))");
   // Test that the indexed access check is called.
   value = CompileRun("testIndexed(obj)");
   CHECK(value->IsNumber());
-  CHECK_EQ(1, value->Int32Value());
+  CHECK_EQ(1, value->Int32Value(context1).FromJust());
   CHECK_EQ(42, access_count);
 
   access_count = 0;
   // Check that the named access check is called when invoking
   // functions on an object that requires access checks.
   CompileRun("obj.f = function() {}");
   CompileRun("function testCallNormal(obj) {"
              "  for (var i = 0; i < 10; i++) obj.f();"
              "}");
   CompileRun("testCallNormal(obj)");
   printf("%i\n", access_count);
   CHECK_EQ(11, access_count);
 
   // Force obj into slow case.
   value = CompileRun("delete obj.prop");
-  CHECK(value->BooleanValue());
+  CHECK(value->BooleanValue(context1).FromJust());
   // Force inline caches into dictionary probing mode.
   CompileRun("var o = { x: 0 }; delete o.x; testProp(o);");
   // Test that the named access check is called.
   value = CompileRun("testProp(obj);");
   CHECK(value->IsNumber());
-  CHECK_EQ(1, value->Int32Value());
+  CHECK_EQ(1, value->Int32Value(context1).FromJust());
   CHECK_EQ(33, access_count);
 
   // Force the call inline cache into dictionary probing mode.
   CompileRun("o.f = function() {}; testCallNormal(o)");
   // Test that the named access check is still called for each
   // invocation of the function.
   value = CompileRun("testCallNormal(obj)");
   CHECK_EQ(43, access_count);
 
   context1->Exit();
@@ skipping 16 matching lines @@
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
   Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate);
   Local<ObjectTemplate> instance = t->InstanceTemplate();
 
   instance->Set(v8_str("x"), v8_num(42));
   instance->Set(v8_str("f"),
                 v8::FunctionTemplate::New(isolate, InstanceFunctionCallback));
 
-  Local<Value> o = t->GetFunction()->NewInstance();
+  Local<Value> o = t->GetFunction(context.local())
+                       .ToLocalChecked()
+                       ->NewInstance(context.local())
+                       .ToLocalChecked();
 
-  context->Global()->Set(v8_str("i"), o);
+  CHECK(context->Global()->Set(context.local(), v8_str("i"), o).FromJust());
   Local<Value> value = CompileRun("i.x");
-  CHECK_EQ(42, value->Int32Value());
+  CHECK_EQ(42, value->Int32Value(context.local()).FromJust());
 
   value = CompileRun("i.f()");
-  CHECK_EQ(12, value->Int32Value());
+  CHECK_EQ(12, value->Int32Value(context.local()).FromJust());
 }
 
 
 static void GlobalObjectInstancePropertiesGet(
     Local<Name> key, const v8::PropertyCallbackInfo<v8::Value>&) {
   ApiTestFuzzer::Fuzz();
 }
 
 
 THREADED_TEST(GlobalObjectInstanceProperties) {
@@ skipping 27 matching lines @@
       "try { wrapper(true); } catch (e) { thrown = 1; };"
       "thrown";
 
   {
     LocalContext env(NULL, instance_template);
     // Hold on to the global object so it can be used again in another
     // environment initialization.
     global_object = env->Global();
 
     Local<Value> value = CompileRun("x");
-    CHECK_EQ(42, value->Int32Value());
+    CHECK_EQ(42, value->Int32Value(env.local()).FromJust());
     value = CompileRun("f()");
-    CHECK_EQ(12, value->Int32Value());
+    CHECK_EQ(12, value->Int32Value(env.local()).FromJust());
     value = CompileRun(script);
-    CHECK_EQ(1, value->Int32Value());
+    CHECK_EQ(1, value->Int32Value(env.local()).FromJust());
   }
 
   {
     // Create new environment reusing the global object.
     LocalContext env(NULL, instance_template, global_object);
     Local<Value> value = CompileRun("x");
-    CHECK_EQ(42, value->Int32Value());
+    CHECK_EQ(42, value->Int32Value(env.local()).FromJust());
     value = CompileRun("f()");
-    CHECK_EQ(12, value->Int32Value());
+    CHECK_EQ(12, value->Int32Value(env.local()).FromJust());
     value = CompileRun(script);
-    CHECK_EQ(1, value->Int32Value());
+    CHECK_EQ(1, value->Int32Value(env.local()).FromJust());
   }
 }
 
 
 THREADED_TEST(CallKnownGlobalReceiver) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
 
   Local<Value> global_object;
 
@@ skipping 19 matching lines @@
     LocalContext env(NULL, instance_template);
     // Hold on to the global object so it can be used again in another
     // environment initialization.
     global_object = env->Global();
     foo = CompileRun(script);
   }
 
   {
     // Create new environment reusing the global object.
     LocalContext env(NULL, instance_template, global_object);
-    env->Global()->Set(v8_str("foo"), foo);
+    CHECK(env->Global()->Set(env.local(), v8_str("foo"), foo).FromJust());
     CompileRun("foo()");
   }
 }
 
 
 static void ShadowFunctionCallback(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   args.GetReturnValue().Set(v8_num(42));
 }
@@ skipping 46 matching lines @@
   Local<ObjectTemplate> instance = t->InstanceTemplate();
 
   proto->Set(v8_str("f"),
              v8::FunctionTemplate::New(isolate,
                                        ShadowFunctionCallback,
                                        Local<Value>()));
   proto->Set(v8_str("x"), v8_num(12));
 
   instance->SetAccessor(v8_str("y"), ShadowYGetter, ShadowYSetter);
 
-  Local<Value> o = t->GetFunction()->NewInstance();
-  context->Global()->Set(v8_str("__proto__"), o);
+  Local<Value> o = t->GetFunction(context.local())
+                       .ToLocalChecked()
+                       ->NewInstance(context.local())
+                       .ToLocalChecked();
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("__proto__"), o)
+            .FromJust());
 
   Local<Value> value =
       CompileRun("this.propertyIsEnumerable(0)");
   CHECK(value->IsBoolean());
-  CHECK(!value->BooleanValue());
+  CHECK(!value->BooleanValue(context.local()).FromJust());
 
   value = CompileRun("x");
-  CHECK_EQ(12, value->Int32Value());
+  CHECK_EQ(12, value->Int32Value(context.local()).FromJust());
 
   value = CompileRun("f()");
-  CHECK_EQ(42, value->Int32Value());
+  CHECK_EQ(42, value->Int32Value(context.local()).FromJust());
 
   CompileRun("y = 43");
   CHECK_EQ(1, shadow_y_setter_call_count);
   value = CompileRun("y");
   CHECK_EQ(1, shadow_y_getter_call_count);
-  CHECK_EQ(42, value->Int32Value());
+  CHECK_EQ(42, value->Int32Value(context.local()).FromJust());
 }
 
 
 THREADED_TEST(HiddenPrototype) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
   Local<v8::FunctionTemplate> t0 = v8::FunctionTemplate::New(isolate);
   t0->InstanceTemplate()->Set(v8_str("x"), v8_num(0));
   Local<v8::FunctionTemplate> t1 = v8::FunctionTemplate::New(isolate);
   t1->SetHiddenPrototype(true);
   t1->InstanceTemplate()->Set(v8_str("y"), v8_num(1));
   Local<v8::FunctionTemplate> t2 = v8::FunctionTemplate::New(isolate);
   t2->SetHiddenPrototype(true);
   t2->InstanceTemplate()->Set(v8_str("z"), v8_num(2));
   Local<v8::FunctionTemplate> t3 = v8::FunctionTemplate::New(isolate);
   t3->InstanceTemplate()->Set(v8_str("u"), v8_num(3));
 
-  Local<v8::Object> o0 = t0->GetFunction()->NewInstance();
-  Local<v8::Object> o1 = t1->GetFunction()->NewInstance();
-  Local<v8::Object> o2 = t2->GetFunction()->NewInstance();
-  Local<v8::Object> o3 = t3->GetFunction()->NewInstance();
+  Local<v8::Object> o0 = t0->GetFunction(context.local())
+                             .ToLocalChecked()
+                             ->NewInstance(context.local())
+                             .ToLocalChecked();
+  Local<v8::Object> o1 = t1->GetFunction(context.local())
+                             .ToLocalChecked()
+                             ->NewInstance(context.local())
+                             .ToLocalChecked();
+  Local<v8::Object> o2 = t2->GetFunction(context.local())
+                             .ToLocalChecked()
+                             ->NewInstance(context.local())
+                             .ToLocalChecked();
+  Local<v8::Object> o3 = t3->GetFunction(context.local())
+                             .ToLocalChecked()
+                             ->NewInstance(context.local())
+                             .ToLocalChecked();
 
   // Setting the prototype on an object skips hidden prototypes.
-  CHECK_EQ(0, o0->Get(v8_str("x"))->Int32Value());
-  o0->Set(v8_str("__proto__"), o1);
-  CHECK_EQ(0, o0->Get(v8_str("x"))->Int32Value());
-  CHECK_EQ(1, o0->Get(v8_str("y"))->Int32Value());
-  o0->Set(v8_str("__proto__"), o2);
-  CHECK_EQ(0, o0->Get(v8_str("x"))->Int32Value());
-  CHECK_EQ(1, o0->Get(v8_str("y"))->Int32Value());
-  CHECK_EQ(2, o0->Get(v8_str("z"))->Int32Value());
-  o0->Set(v8_str("__proto__"), o3);
-  CHECK_EQ(0, o0->Get(v8_str("x"))->Int32Value());
-  CHECK_EQ(1, o0->Get(v8_str("y"))->Int32Value());
-  CHECK_EQ(2, o0->Get(v8_str("z"))->Int32Value());
-  CHECK_EQ(3, o0->Get(v8_str("u"))->Int32Value());
+  CHECK_EQ(0, o0->Get(context.local(), v8_str("x"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK(o0->Set(context.local(), v8_str("__proto__"), o1).FromJust());
+  CHECK_EQ(0, o0->Get(context.local(), v8_str("x"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK_EQ(1, o0->Get(context.local(), v8_str("y"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK(o0->Set(context.local(), v8_str("__proto__"), o2).FromJust());
+  CHECK_EQ(0, o0->Get(context.local(), v8_str("x"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK_EQ(1, o0->Get(context.local(), v8_str("y"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK_EQ(2, o0->Get(context.local(), v8_str("z"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK(o0->Set(context.local(), v8_str("__proto__"), o3).FromJust());
+  CHECK_EQ(0, o0->Get(context.local(), v8_str("x"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK_EQ(1, o0->Get(context.local(), v8_str("y"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK_EQ(2, o0->Get(context.local(), v8_str("z"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK_EQ(3, o0->Get(context.local(), v8_str("u"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
 
   // Getting the prototype of o0 should get the first visible one
   // which is o3.  Therefore, z should not be defined on the prototype
   // object.
-  Local<Value> proto = o0->Get(v8_str("__proto__"));
+  Local<Value> proto =
+      o0->Get(context.local(), v8_str("__proto__")).ToLocalChecked();
   CHECK(proto->IsObject());
-  CHECK(proto.As<v8::Object>()->Get(v8_str("z"))->IsUndefined());
+  CHECK(proto.As<v8::Object>()
+            ->Get(context.local(), v8_str("z"))
+            .ToLocalChecked()
+            ->IsUndefined());
 }
 
 
 THREADED_TEST(HiddenPrototypeSet) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
   Local<v8::FunctionTemplate> ot = v8::FunctionTemplate::New(isolate);
   Local<v8::FunctionTemplate> ht = v8::FunctionTemplate::New(isolate);
   ht->SetHiddenPrototype(true);
   Local<v8::FunctionTemplate> pt = v8::FunctionTemplate::New(isolate);
   ht->InstanceTemplate()->Set(v8_str("x"), v8_num(0));
 
-  Local<v8::Object> o = ot->GetFunction()->NewInstance();
-  Local<v8::Object> h = ht->GetFunction()->NewInstance();
-  Local<v8::Object> p = pt->GetFunction()->NewInstance();
-  o->Set(v8_str("__proto__"), h);
-  h->Set(v8_str("__proto__"), p);
+  Local<v8::Object> o = ot->GetFunction(context.local())
+                            .ToLocalChecked()
+                            ->NewInstance(context.local())
+                            .ToLocalChecked();
+  Local<v8::Object> h = ht->GetFunction(context.local())
+                            .ToLocalChecked()
+                            ->NewInstance(context.local())
+                            .ToLocalChecked();
+  Local<v8::Object> p = pt->GetFunction(context.local())
+                            .ToLocalChecked()
+                            ->NewInstance(context.local())
+                            .ToLocalChecked();
+  CHECK(o->Set(context.local(), v8_str("__proto__"), h).FromJust());
+  CHECK(h->Set(context.local(), v8_str("__proto__"), p).FromJust());
 
   // Setting a property that exists on the hidden prototype goes there.
-  o->Set(v8_str("x"), v8_num(7));
-  CHECK_EQ(7, o->Get(v8_str("x"))->Int32Value());
-  CHECK_EQ(7, h->Get(v8_str("x"))->Int32Value());
-  CHECK(p->Get(v8_str("x"))->IsUndefined());
+  CHECK(o->Set(context.local(), v8_str("x"), v8_num(7)).FromJust());
+  CHECK_EQ(7, o->Get(context.local(), v8_str("x"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK_EQ(7, h->Get(context.local(), v8_str("x"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK(p->Get(context.local(), v8_str("x")).ToLocalChecked()->IsUndefined());
 
   // Setting a new property should not be forwarded to the hidden prototype.
-  o->Set(v8_str("y"), v8_num(6));
-  CHECK_EQ(6, o->Get(v8_str("y"))->Int32Value());
-  CHECK(h->Get(v8_str("y"))->IsUndefined());
-  CHECK(p->Get(v8_str("y"))->IsUndefined());
+  CHECK(o->Set(context.local(), v8_str("y"), v8_num(6)).FromJust());
+  CHECK_EQ(6, o->Get(context.local(), v8_str("y"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK(h->Get(context.local(), v8_str("y")).ToLocalChecked()->IsUndefined());
+  CHECK(p->Get(context.local(), v8_str("y")).ToLocalChecked()->IsUndefined());
 
   // Setting a property that only exists on a prototype of the hidden prototype
   // is treated normally again.
-  p->Set(v8_str("z"), v8_num(8));
-  CHECK_EQ(8, o->Get(v8_str("z"))->Int32Value());
-  CHECK_EQ(8, h->Get(v8_str("z"))->Int32Value());
-  CHECK_EQ(8, p->Get(v8_str("z"))->Int32Value());
-  o->Set(v8_str("z"), v8_num(9));
-  CHECK_EQ(9, o->Get(v8_str("z"))->Int32Value());
-  CHECK_EQ(8, h->Get(v8_str("z"))->Int32Value());
-  CHECK_EQ(8, p->Get(v8_str("z"))->Int32Value());
+  CHECK(p->Set(context.local(), v8_str("z"), v8_num(8)).FromJust());
+  CHECK_EQ(8, o->Get(context.local(), v8_str("z"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK_EQ(8, h->Get(context.local(), v8_str("z"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK_EQ(8, p->Get(context.local(), v8_str("z"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK(o->Set(context.local(), v8_str("z"), v8_num(9)).FromJust());
+  CHECK_EQ(9, o->Get(context.local(), v8_str("z"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK_EQ(8, h->Get(context.local(), v8_str("z"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK_EQ(8, p->Get(context.local(), v8_str("z"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
 }
 
 
 // Regression test for issue 2457.
 THREADED_TEST(HiddenPrototypeIdentityHash) {
   LocalContext context;
   v8::HandleScope handle_scope(context->GetIsolate());
 
-  Handle<FunctionTemplate> t = FunctionTemplate::New(context->GetIsolate());
+  Local<FunctionTemplate> t = FunctionTemplate::New(context->GetIsolate());
   t->SetHiddenPrototype(true);
   t->InstanceTemplate()->Set(v8_str("foo"), v8_num(75));
-  Handle<Object> p = t->GetFunction()->NewInstance();
-  Handle<Object> o = Object::New(context->GetIsolate());
-  o->SetPrototype(p);
+  Local<Object> p = t->GetFunction(context.local())
+                        .ToLocalChecked()
+                        ->NewInstance(context.local())
+                        .ToLocalChecked();
+  Local<Object> o = Object::New(context->GetIsolate());
+  CHECK(o->SetPrototype(context.local(), p).FromJust());
 
   int hash = o->GetIdentityHash();
   USE(hash);
-  o->Set(v8_str("foo"), v8_num(42));
+  CHECK(o->Set(context.local(), v8_str("foo"), v8_num(42)).FromJust());
   DCHECK_EQ(hash, o->GetIdentityHash());
 }
 
 
 THREADED_TEST(SetPrototype) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
   Local<v8::FunctionTemplate> t0 = v8::FunctionTemplate::New(isolate);
   t0->InstanceTemplate()->Set(v8_str("x"), v8_num(0));
   Local<v8::FunctionTemplate> t1 = v8::FunctionTemplate::New(isolate);
   t1->SetHiddenPrototype(true);
   t1->InstanceTemplate()->Set(v8_str("y"), v8_num(1));
   Local<v8::FunctionTemplate> t2 = v8::FunctionTemplate::New(isolate);
   t2->SetHiddenPrototype(true);
   t2->InstanceTemplate()->Set(v8_str("z"), v8_num(2));
   Local<v8::FunctionTemplate> t3 = v8::FunctionTemplate::New(isolate);
   t3->InstanceTemplate()->Set(v8_str("u"), v8_num(3));
 
-  Local<v8::Object> o0 = t0->GetFunction()->NewInstance();
-  Local<v8::Object> o1 = t1->GetFunction()->NewInstance();
-  Local<v8::Object> o2 = t2->GetFunction()->NewInstance();
-  Local<v8::Object> o3 = t3->GetFunction()->NewInstance();
+  Local<v8::Object> o0 = t0->GetFunction(context.local())
+                             .ToLocalChecked()
+                             ->NewInstance(context.local())
+                             .ToLocalChecked();
+  Local<v8::Object> o1 = t1->GetFunction(context.local())
+                             .ToLocalChecked()
+                             ->NewInstance(context.local())
+                             .ToLocalChecked();
+  Local<v8::Object> o2 = t2->GetFunction(context.local())
+                             .ToLocalChecked()
+                             ->NewInstance(context.local())
+                             .ToLocalChecked();
+  Local<v8::Object> o3 = t3->GetFunction(context.local())
+                             .ToLocalChecked()
+                             ->NewInstance(context.local())
+                             .ToLocalChecked();
 
   // Setting the prototype on an object does not skip hidden prototypes.
-  CHECK_EQ(0, o0->Get(v8_str("x"))->Int32Value());
-  CHECK(o0->SetPrototype(o1));
-  CHECK_EQ(0, o0->Get(v8_str("x"))->Int32Value());
-  CHECK_EQ(1, o0->Get(v8_str("y"))->Int32Value());
-  CHECK(o1->SetPrototype(o2));
-  CHECK_EQ(0, o0->Get(v8_str("x"))->Int32Value());
-  CHECK_EQ(1, o0->Get(v8_str("y"))->Int32Value());
-  CHECK_EQ(2, o0->Get(v8_str("z"))->Int32Value());
-  CHECK(o2->SetPrototype(o3));
-  CHECK_EQ(0, o0->Get(v8_str("x"))->Int32Value());
-  CHECK_EQ(1, o0->Get(v8_str("y"))->Int32Value());
-  CHECK_EQ(2, o0->Get(v8_str("z"))->Int32Value());
-  CHECK_EQ(3, o0->Get(v8_str("u"))->Int32Value());
+  CHECK_EQ(0, o0->Get(context.local(), v8_str("x"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK(o0->SetPrototype(context.local(), o1).FromJust());
+  CHECK_EQ(0, o0->Get(context.local(), v8_str("x"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK_EQ(1, o0->Get(context.local(), v8_str("y"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK(o1->SetPrototype(context.local(), o2).FromJust());
+  CHECK_EQ(0, o0->Get(context.local(), v8_str("x"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK_EQ(1, o0->Get(context.local(), v8_str("y"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK_EQ(2, o0->Get(context.local(), v8_str("z"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK(o2->SetPrototype(context.local(), o3).FromJust());
+  CHECK_EQ(0, o0->Get(context.local(), v8_str("x"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK_EQ(1, o0->Get(context.local(), v8_str("y"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK_EQ(2, o0->Get(context.local(), v8_str("z"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
+  CHECK_EQ(3, o0->Get(context.local(), v8_str("u"))
+                  .ToLocalChecked()
+                  ->Int32Value(context.local())
+                  .FromJust());
 
   // Getting the prototype of o0 should get the first visible one
   // which is o3.  Therefore, z should not be defined on the prototype
   // object.
-  Local<Value> proto = o0->Get(v8_str("__proto__"));
+  Local<Value> proto =
+      o0->Get(context.local(), v8_str("__proto__")).ToLocalChecked();
   CHECK(proto->IsObject());
-  CHECK(proto.As<v8::Object>()->Equals(o3));
+  CHECK(proto.As<v8::Object>()->Equals(context.local(), o3).FromJust());
 
   // However, Object::GetPrototype ignores hidden prototype.
   Local<Value> proto0 = o0->GetPrototype();
   CHECK(proto0->IsObject());
-  CHECK(proto0.As<v8::Object>()->Equals(o1));
+  CHECK(proto0.As<v8::Object>()->Equals(context.local(), o1).FromJust());
 
   Local<Value> proto1 = o1->GetPrototype();
   CHECK(proto1->IsObject());
-  CHECK(proto1.As<v8::Object>()->Equals(o2));
+  CHECK(proto1.As<v8::Object>()->Equals(context.local(), o2).FromJust());
 
   Local<Value> proto2 = o2->GetPrototype();
   CHECK(proto2->IsObject());
-  CHECK(proto2.As<v8::Object>()->Equals(o3));
+  CHECK(proto2.As<v8::Object>()->Equals(context.local(), o3).FromJust());
 }
 
 
 // Getting property names of an object with a prototype chain that
 // triggers dictionary elements in GetOwnPropertyNames() shouldn't
 // crash the runtime.
 THREADED_TEST(Regress91517) {
   i::FLAG_allow_natives_syntax = true;
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
@@ skipping 13 matching lines @@
   Local<v8::FunctionTemplate> t4 = v8::FunctionTemplate::New(isolate);
   t4->InstanceTemplate()->Set(v8_str("baz"), v8_num(4));
 
   // Force dictionary-based properties.
   i::ScopedVector<char> name_buf(1024);
   for (int i = 1; i <= 1000; i++) {
     i::SNPrintF(name_buf, "sdf%d", i);
     t2->InstanceTemplate()->Set(v8_str(name_buf.start()), v8_num(2));
   }
 
-  Local<v8::Object> o1 = t1->GetFunction()->NewInstance();
-  Local<v8::Object> o2 = t2->GetFunction()->NewInstance();
-  Local<v8::Object> o3 = t3->GetFunction()->NewInstance();
-  Local<v8::Object> o4 = t4->GetFunction()->NewInstance();
+  Local<v8::Object> o1 = t1->GetFunction(context.local())
+                             .ToLocalChecked()
+                             ->NewInstance(context.local())
+                             .ToLocalChecked();
+  Local<v8::Object> o2 = t2->GetFunction(context.local())
+                             .ToLocalChecked()
+                             ->NewInstance(context.local())
+                             .ToLocalChecked();
+  Local<v8::Object> o3 = t3->GetFunction(context.local())
+                             .ToLocalChecked()
+                             ->NewInstance(context.local())
+                             .ToLocalChecked();
+  Local<v8::Object> o4 = t4->GetFunction(context.local())
+                             .ToLocalChecked()
+                             ->NewInstance(context.local())
+                             .ToLocalChecked();
 
   // Create prototype chain of hidden prototypes.
-  CHECK(o4->SetPrototype(o3));
-  CHECK(o3->SetPrototype(o2));
-  CHECK(o2->SetPrototype(o1));
+  CHECK(o4->SetPrototype(context.local(), o3).FromJust());
+  CHECK(o3->SetPrototype(context.local(), o2).FromJust());
+  CHECK(o2->SetPrototype(context.local(), o1).FromJust());
 
   // Call the runtime version of GetOwnPropertyNames() on the natively
   // created object through JavaScript.
-  context->Global()->Set(v8_str("obj"), o4);
+  CHECK(context->Global()->Set(context.local(), v8_str("obj"), o4).FromJust());
   // PROPERTY_ATTRIBUTES_NONE = 0
   CompileRun("var names = %GetOwnPropertyNames(obj, 0);");
 
   ExpectInt32("names.length", 1006);
   ExpectTrue("names.indexOf(\"baz\") >= 0");
   ExpectTrue("names.indexOf(\"boo\") >= 0");
   ExpectTrue("names.indexOf(\"foo\") >= 0");
   ExpectTrue("names.indexOf(\"fuz1\") >= 0");
   ExpectTrue("names.indexOf(\"fuz2\") >= 0");
   ExpectFalse("names[1005] == undefined");
@@ skipping 14 matching lines @@
   Local<v8::ObjectTemplate> i1 = t1->InstanceTemplate();
   i1->SetAccessor(v8_str("foo"),
                   SimpleAccessorGetter, SimpleAccessorSetter);
   i1->SetAccessor(v8_str("bar"),
                   SimpleAccessorGetter, SimpleAccessorSetter);
   i1->SetAccessor(v8_str("baz"),
                   SimpleAccessorGetter, SimpleAccessorSetter);
   i1->Set(v8_str("n1"), v8_num(1));
   i1->Set(v8_str("n2"), v8_num(2));
 
-  Local<v8::Object> o1 = t1->GetFunction()->NewInstance();
+  Local<v8::Object> o1 = t1->GetFunction(context.local())
+                             .ToLocalChecked()
+                             ->NewInstance(context.local())
+                             .ToLocalChecked();
   Local<v8::FunctionTemplate> t2 =
       v8::FunctionTemplate::New(context->GetIsolate());
   t2->SetHiddenPrototype(true);
 
   // Inherit from t1 and mark prototype as hidden.
   t2->Inherit(t1);
   t2->InstanceTemplate()->Set(v8_str("mine"), v8_num(4));
 
-  Local<v8::Object> o2 = t2->GetFunction()->NewInstance();
-  CHECK(o2->SetPrototype(o1));
+  Local<v8::Object> o2 = t2->GetFunction(context.local())
+                             .ToLocalChecked()
+                             ->NewInstance(context.local())
+                             .ToLocalChecked();
+  CHECK(o2->SetPrototype(context.local(), o1).FromJust());
 
   v8::Local<v8::Symbol> sym =
       v8::Symbol::New(context->GetIsolate(), v8_str("s1"));
-  o1->Set(sym, v8_num(3));
+  CHECK(o1->Set(context.local(), sym, v8_num(3)).FromJust());
   o1->SetPrivate(context.local(),
                  v8::Private::New(context->GetIsolate(), v8_str("h1")),
                  v8::Integer::New(context->GetIsolate(), 2013))
       .FromJust();
 
   // Call the runtime version of GetOwnPropertyNames() on
   // the natively created object through JavaScript.
-  context->Global()->Set(v8_str("obj"), o2);
-  context->Global()->Set(v8_str("sym"), sym);
+  CHECK(context->Global()->Set(context.local(), v8_str("obj"), o2).FromJust());
+  CHECK(context->Global()->Set(context.local(), v8_str("sym"), sym).FromJust());
   // PROPERTY_ATTRIBUTES_NONE = 0
   CompileRun("var names = %GetOwnPropertyNames(obj, 0);");
 
   ExpectInt32("names.length", 7);
   ExpectTrue("names.indexOf(\"foo\") >= 0");
   ExpectTrue("names.indexOf(\"bar\") >= 0");
   ExpectTrue("names.indexOf(\"baz\") >= 0");
   ExpectTrue("names.indexOf(\"n1\") >= 0");
   ExpectTrue("names.indexOf(\"n2\") >= 0");
   ExpectTrue("names.indexOf(sym) >= 0");
   ExpectTrue("names.indexOf(\"mine\") >= 0");
 }
 
 
 THREADED_TEST(FunctionReadOnlyPrototype) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
   Local<v8::FunctionTemplate> t1 = v8::FunctionTemplate::New(isolate);
   t1->PrototypeTemplate()->Set(v8_str("x"), v8::Integer::New(isolate, 42));
   t1->ReadOnlyPrototype();
-  context->Global()->Set(v8_str("func1"), t1->GetFunction());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("func1"),
+                  t1->GetFunction(context.local()).ToLocalChecked())
+            .FromJust());
   // Configured value of ReadOnly flag.
-  CHECK(CompileRun(
-      "(function() {"
-      "  descriptor = Object.getOwnPropertyDescriptor(func1, 'prototype');"
-      "  return (descriptor['writable'] == false);"
-      "})()")->BooleanValue());
-  CHECK_EQ(42, CompileRun("func1.prototype.x")->Int32Value());
-  CHECK_EQ(42,
-           CompileRun("func1.prototype = {}; func1.prototype.x")->Int32Value());
+  CHECK(
+      CompileRun(
+          "(function() {"
+          "  descriptor = Object.getOwnPropertyDescriptor(func1, 'prototype');"
+          "  return (descriptor['writable'] == false);"
+          "})()")
+          ->BooleanValue(context.local())
+          .FromJust());
+  CHECK_EQ(
+      42,
+      CompileRun("func1.prototype.x")->Int32Value(context.local()).FromJust());
+  CHECK_EQ(42, CompileRun("func1.prototype = {}; func1.prototype.x")
+                   ->Int32Value(context.local())
+                   .FromJust());
 
   Local<v8::FunctionTemplate> t2 = v8::FunctionTemplate::New(isolate);
   t2->PrototypeTemplate()->Set(v8_str("x"), v8::Integer::New(isolate, 42));
-  context->Global()->Set(v8_str("func2"), t2->GetFunction());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("func2"),
+                  t2->GetFunction(context.local()).ToLocalChecked())
+            .FromJust());
   // Default value of ReadOnly flag.
-  CHECK(CompileRun(
-      "(function() {"
-      "  descriptor = Object.getOwnPropertyDescriptor(func2, 'prototype');"
-      "  return (descriptor['writable'] == true);"
-      "})()")->BooleanValue());
-  CHECK_EQ(42, CompileRun("func2.prototype.x")->Int32Value());
+  CHECK(
+      CompileRun(
+          "(function() {"
+          "  descriptor = Object.getOwnPropertyDescriptor(func2, 'prototype');"
+          "  return (descriptor['writable'] == true);"
+          "})()")
+          ->BooleanValue(context.local())
+          .FromJust());
+  CHECK_EQ(
+      42,
+      CompileRun("func2.prototype.x")->Int32Value(context.local()).FromJust());
 }
 
 
 THREADED_TEST(SetPrototypeThrows) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
   Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate);
 
-  Local<v8::Object> o0 = t->GetFunction()->NewInstance();
-  Local<v8::Object> o1 = t->GetFunction()->NewInstance();
+  Local<v8::Object> o0 = t->GetFunction(context.local())
+                             .ToLocalChecked()
+                             ->NewInstance(context.local())
+                             .ToLocalChecked();
+  Local<v8::Object> o1 = t->GetFunction(context.local())
+                             .ToLocalChecked()
+                             ->NewInstance(context.local())
+                             .ToLocalChecked();
 
-  CHECK(o0->SetPrototype(o1));
+  CHECK(o0->SetPrototype(context.local(), o1).FromJust());
   // If setting the prototype leads to the cycle, SetPrototype should
   // return false and keep VM in sane state.
   v8::TryCatch try_catch(isolate);
-  CHECK(!o1->SetPrototype(o0));
+  CHECK(o1->SetPrototype(context.local(), o0).IsNothing());
   CHECK(!try_catch.HasCaught());
   DCHECK(!CcTest::i_isolate()->has_pending_exception());
 
-  CHECK_EQ(42, CompileRun("function f() { return 42; }; f()")->Int32Value());
+  CHECK_EQ(42, CompileRun("function f() { return 42; }; f()")
+                   ->Int32Value(context.local())
+                   .FromJust());
 }
 
 
 THREADED_TEST(FunctionRemovePrototype) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
   Local<v8::FunctionTemplate> t1 = v8::FunctionTemplate::New(isolate);
   t1->RemovePrototype();
-  Local<v8::Function> fun = t1->GetFunction();
-  context->Global()->Set(v8_str("fun"), fun);
-  CHECK(!CompileRun("'prototype' in fun")->BooleanValue());
+  Local<v8::Function> fun = t1->GetFunction(context.local()).ToLocalChecked();
+  CHECK(context->Global()->Set(context.local(), v8_str("fun"), fun).FromJust());
+  CHECK(!CompileRun("'prototype' in fun")
+             ->BooleanValue(context.local())
+             .FromJust());
 
   v8::TryCatch try_catch(isolate);
   CompileRun("new fun()");
   CHECK(try_catch.HasCaught());
 
   try_catch.Reset();
-  fun->NewInstance();
+  CHECK(fun->NewInstance(context.local()).IsEmpty());
   CHECK(try_catch.HasCaught());
 }
 
 
 THREADED_TEST(GetterSetterExceptions) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope handle_scope(isolate);
   CompileRun(
       "function Foo() { };"
       "function Throw() { throw 5; };"
       "var x = { };"
       "x.__defineSetter__('set', Throw);"
       "x.__defineGetter__('get', Throw);");
-  Local<v8::Object> x =
-      Local<v8::Object>::Cast(context->Global()->Get(v8_str("x")));
+  Local<v8::Object> x = Local<v8::Object>::Cast(
+      context->Global()->Get(context.local(), v8_str("x")).ToLocalChecked());
   v8::TryCatch try_catch(isolate);
-  x->Set(v8_str("set"), v8::Integer::New(isolate, 8));
-  x->Get(v8_str("get"));
-  x->Set(v8_str("set"), v8::Integer::New(isolate, 8));
-  x->Get(v8_str("get"));
-  x->Set(v8_str("set"), v8::Integer::New(isolate, 8));
-  x->Get(v8_str("get"));
-  x->Set(v8_str("set"), v8::Integer::New(isolate, 8));
-  x->Get(v8_str("get"));
+  CHECK(x->Set(context.local(), v8_str("set"), v8::Integer::New(isolate, 8))
+            .IsNothing());
+  CHECK(x->Get(context.local(), v8_str("get")).IsEmpty());
+  CHECK(x->Set(context.local(), v8_str("set"), v8::Integer::New(isolate, 8))
+            .IsNothing());
+  CHECK(x->Get(context.local(), v8_str("get")).IsEmpty());
+  CHECK(x->Set(context.local(), v8_str("set"), v8::Integer::New(isolate, 8))
+            .IsNothing());
+  CHECK(x->Get(context.local(), v8_str("get")).IsEmpty());
+  CHECK(x->Set(context.local(), v8_str("set"), v8::Integer::New(isolate, 8))
+            .IsNothing());
+  CHECK(x->Get(context.local(), v8_str("get")).IsEmpty());
 }
 
 
 THREADED_TEST(Constructor) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope handle_scope(isolate);
   Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New(isolate);
   templ->SetClassName(v8_str("Fun"));
-  Local<Function> cons = templ->GetFunction();
-  context->Global()->Set(v8_str("Fun"), cons);
-  Local<v8::Object> inst = cons->NewInstance();
+  Local<Function> cons = templ->GetFunction(context.local()).ToLocalChecked();
+  CHECK(
+      context->Global()->Set(context.local(), v8_str("Fun"), cons).FromJust());
+  Local<v8::Object> inst = cons->NewInstance(context.local()).ToLocalChecked();
   i::Handle<i::JSReceiver> obj(v8::Utils::OpenHandle(*inst));
   CHECK(obj->IsJSObject());
   Local<Value> value = CompileRun("(new Fun()).constructor === Fun");
-  CHECK(value->BooleanValue());
+  CHECK(value->BooleanValue(context.local()).FromJust());
 }
 
 
 static void ConstructorCallback(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   Local<Object> This;
 
+  v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
   if (args.IsConstructCall()) {
     Local<Object> Holder = args.Holder();
     This = Object::New(args.GetIsolate());
     Local<Value> proto = Holder->GetPrototype();
     if (proto->IsObject()) {
-      This->SetPrototype(proto);
+      This->SetPrototype(context, proto).FromJust();
     }
   } else {
     This = args.This();
   }
 
-  This->Set(v8_str("a"), args[0]);
+  This->Set(context, v8_str("a"), args[0]).FromJust();
   args.GetReturnValue().Set(This);
 }
 
 
 static void FakeConstructorCallback(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   args.GetReturnValue().Set(args[0]);
 }
 
 
 THREADED_TEST(ConstructorForObject) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
   {
     Local<ObjectTemplate> instance_template = ObjectTemplate::New(isolate);
     instance_template->SetCallAsFunctionHandler(ConstructorCallback);
-    Local<Object> instance = instance_template->NewInstance();
-    context->Global()->Set(v8_str("obj"), instance);
+    Local<Object> instance =
+        instance_template->NewInstance(context.local()).ToLocalChecked();
+    CHECK(context->Global()
+              ->Set(context.local(), v8_str("obj"), instance)
+              .FromJust());
     v8::TryCatch try_catch(isolate);
     Local<Value> value;
     CHECK(!try_catch.HasCaught());
 
     // Call the Object's constructor with a 32-bit signed integer.
     value = CompileRun("(function() { var o = new obj(28); return o.a; })()");
     CHECK(!try_catch.HasCaught());
     CHECK(value->IsInt32());
-    CHECK_EQ(28, value->Int32Value());
+    CHECK_EQ(28, value->Int32Value(context.local()).FromJust());
 
     Local<Value> args1[] = {v8_num(28)};
-    Local<Value> value_obj1 = instance->CallAsConstructor(1, args1);
+    Local<Value> value_obj1 =
+        instance->CallAsConstructor(context.local(), 1, args1).ToLocalChecked();
     CHECK(value_obj1->IsObject());
     Local<Object> object1 = Local<Object>::Cast(value_obj1);
-    value = object1->Get(v8_str("a"));
+    value = object1->Get(context.local(), v8_str("a")).ToLocalChecked();
     CHECK(value->IsInt32());
     CHECK(!try_catch.HasCaught());
-    CHECK_EQ(28, value->Int32Value());
+    CHECK_EQ(28, value->Int32Value(context.local()).FromJust());
 
     // Call the Object's constructor with a String.
     value =
         CompileRun("(function() { var o = new obj('tipli'); return o.a; })()");
     CHECK(!try_catch.HasCaught());
     CHECK(value->IsString());
-    String::Utf8Value string_value1(value->ToString(isolate));
+    String::Utf8Value string_value1(
+        value->ToString(context.local()).ToLocalChecked());
     CHECK_EQ(0, strcmp("tipli", *string_value1));
 
     Local<Value> args2[] = {v8_str("tipli")};
-    Local<Value> value_obj2 = instance->CallAsConstructor(1, args2);
+    Local<Value> value_obj2 =
+        instance->CallAsConstructor(context.local(), 1, args2).ToLocalChecked();
     CHECK(value_obj2->IsObject());
     Local<Object> object2 = Local<Object>::Cast(value_obj2);
-    value = object2->Get(v8_str("a"));
+    value = object2->Get(context.local(), v8_str("a")).ToLocalChecked();
     CHECK(!try_catch.HasCaught());
     CHECK(value->IsString());
-    String::Utf8Value string_value2(value->ToString(isolate));
+    String::Utf8Value string_value2(
+        value->ToString(context.local()).ToLocalChecked());
     CHECK_EQ(0, strcmp("tipli", *string_value2));
 
     // Call the Object's constructor with a Boolean.
     value = CompileRun("(function() { var o = new obj(true); return o.a; })()");
     CHECK(!try_catch.HasCaught());
     CHECK(value->IsBoolean());
-    CHECK_EQ(true, value->BooleanValue());
+    CHECK_EQ(true, value->BooleanValue(context.local()).FromJust());
 
-    Handle<Value> args3[] = {v8::True(isolate)};
-    Local<Value> value_obj3 = instance->CallAsConstructor(1, args3);
+    Local<Value> args3[] = {v8::True(isolate)};
+    Local<Value> value_obj3 =
+        instance->CallAsConstructor(context.local(), 1, args3).ToLocalChecked();
     CHECK(value_obj3->IsObject());
     Local<Object> object3 = Local<Object>::Cast(value_obj3);
-    value = object3->Get(v8_str("a"));
+    value = object3->Get(context.local(), v8_str("a")).ToLocalChecked();
     CHECK(!try_catch.HasCaught());
     CHECK(value->IsBoolean());
-    CHECK_EQ(true, value->BooleanValue());
+    CHECK_EQ(true, value->BooleanValue(context.local()).FromJust());
 
     // Call the Object's constructor with undefined.
-    Handle<Value> args4[] = {v8::Undefined(isolate)};
-    Local<Value> value_obj4 = instance->CallAsConstructor(1, args4);
+    Local<Value> args4[] = {v8::Undefined(isolate)};
+    Local<Value> value_obj4 =
+        instance->CallAsConstructor(context.local(), 1, args4).ToLocalChecked();
     CHECK(value_obj4->IsObject());
     Local<Object> object4 = Local<Object>::Cast(value_obj4);
-    value = object4->Get(v8_str("a"));
+    value = object4->Get(context.local(), v8_str("a")).ToLocalChecked();
     CHECK(!try_catch.HasCaught());
     CHECK(value->IsUndefined());
 
     // Call the Object's constructor with null.
-    Handle<Value> args5[] = {v8::Null(isolate)};
-    Local<Value> value_obj5 = instance->CallAsConstructor(1, args5);
+    Local<Value> args5[] = {v8::Null(isolate)};
+    Local<Value> value_obj5 =
+        instance->CallAsConstructor(context.local(), 1, args5).ToLocalChecked();
     CHECK(value_obj5->IsObject());
     Local<Object> object5 = Local<Object>::Cast(value_obj5);
-    value = object5->Get(v8_str("a"));
+    value = object5->Get(context.local(), v8_str("a")).ToLocalChecked();
     CHECK(!try_catch.HasCaught());
     CHECK(value->IsNull());
   }
 
   // Check exception handling when there is no constructor set for the Object.
   {
     Local<ObjectTemplate> instance_template = ObjectTemplate::New(isolate);
-    Local<Object> instance = instance_template->NewInstance();
-    context->Global()->Set(v8_str("obj2"), instance);
+    Local<Object> instance =
+        instance_template->NewInstance(context.local()).ToLocalChecked();
+    CHECK(context->Global()
+              ->Set(context.local(), v8_str("obj2"), instance)
+              .FromJust());
     v8::TryCatch try_catch(isolate);
     Local<Value> value;
     CHECK(!try_catch.HasCaught());
 
     value = CompileRun("new obj2(28)");
     CHECK(try_catch.HasCaught());
     String::Utf8Value exception_value1(try_catch.Exception());
     CHECK_EQ(0, strcmp("TypeError: obj2 is not a function", *exception_value1));
     try_catch.Reset();
 
     Local<Value> args[] = {v8_num(29)};
-    value = instance->CallAsConstructor(1, args);
+    CHECK(instance->CallAsConstructor(context.local(), 1, args).IsEmpty());
     CHECK(try_catch.HasCaught());
     String::Utf8Value exception_value2(try_catch.Exception());
     CHECK_EQ(0,
              strcmp("TypeError: object is not a function", *exception_value2));
     try_catch.Reset();
   }
 
   // Check the case when constructor throws exception.
   {
     Local<ObjectTemplate> instance_template = ObjectTemplate::New(isolate);
     instance_template->SetCallAsFunctionHandler(ThrowValue);
-    Local<Object> instance = instance_template->NewInstance();
-    context->Global()->Set(v8_str("obj3"), instance);
+    Local<Object> instance =
+        instance_template->NewInstance(context.local()).ToLocalChecked();
+    CHECK(context->Global()
+              ->Set(context.local(), v8_str("obj3"), instance)
+              .FromJust());
     v8::TryCatch try_catch(isolate);
     Local<Value> value;
     CHECK(!try_catch.HasCaught());
 
     value = CompileRun("new obj3(22)");
     CHECK(try_catch.HasCaught());
     String::Utf8Value exception_value1(try_catch.Exception());
     CHECK_EQ(0, strcmp("22", *exception_value1));
     try_catch.Reset();
 
     Local<Value> args[] = {v8_num(23)};
-    value = instance->CallAsConstructor(1, args);
+    CHECK(instance->CallAsConstructor(context.local(), 1, args).IsEmpty());
     CHECK(try_catch.HasCaught());
     String::Utf8Value exception_value2(try_catch.Exception());
     CHECK_EQ(0, strcmp("23", *exception_value2));
     try_catch.Reset();
   }
 
   // Check whether constructor returns with an object or non-object.
   {
     Local<FunctionTemplate> function_template =
         FunctionTemplate::New(isolate, FakeConstructorCallback);
-    Local<Function> function = function_template->GetFunction();
+    Local<Function> function =
+        function_template->GetFunction(context.local()).ToLocalChecked();
     Local<Object> instance1 = function;
-    context->Global()->Set(v8_str("obj4"), instance1);
+    CHECK(context->Global()
+              ->Set(context.local(), v8_str("obj4"), instance1)
+              .FromJust());
     v8::TryCatch try_catch(isolate);
     Local<Value> value;
     CHECK(!try_catch.HasCaught());
 
     CHECK(instance1->IsObject());
     CHECK(instance1->IsFunction());
 
     value = CompileRun("new obj4(28)");
     CHECK(!try_catch.HasCaught());
     CHECK(value->IsObject());
 
     Local<Value> args1[] = {v8_num(28)};
-    value = instance1->CallAsConstructor(1, args1);
+    value = instance1->CallAsConstructor(context.local(), 1, args1)
+                .ToLocalChecked();
     CHECK(!try_catch.HasCaught());
     CHECK(value->IsObject());
 
     Local<ObjectTemplate> instance_template = ObjectTemplate::New(isolate);
     instance_template->SetCallAsFunctionHandler(FakeConstructorCallback);
-    Local<Object> instance2 = instance_template->NewInstance();
-    context->Global()->Set(v8_str("obj5"), instance2);
+    Local<Object> instance2 =
+        instance_template->NewInstance(context.local()).ToLocalChecked();
+    CHECK(context->Global()
+              ->Set(context.local(), v8_str("obj5"), instance2)
+              .FromJust());
     CHECK(!try_catch.HasCaught());
 
     CHECK(instance2->IsObject());
     CHECK(instance2->IsFunction());
 
     value = CompileRun("new obj5(28)");
     CHECK(!try_catch.HasCaught());
     CHECK(!value->IsObject());
 
     Local<Value> args2[] = {v8_num(28)};
-    value = instance2->CallAsConstructor(1, args2);
+    value = instance2->CallAsConstructor(context.local(), 1, args2)
+                .ToLocalChecked();
     CHECK(!try_catch.HasCaught());
     CHECK(!value->IsObject());
   }
 }
 
 
 THREADED_TEST(FunctionDescriptorException) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope handle_scope(isolate);
   Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New(isolate);
   templ->SetClassName(v8_str("Fun"));
-  Local<Function> cons = templ->GetFunction();
-  context->Global()->Set(v8_str("Fun"), cons);
+  Local<Function> cons = templ->GetFunction(context.local()).ToLocalChecked();
+  CHECK(
+      context->Global()->Set(context.local(), v8_str("Fun"), cons).FromJust());
   Local<Value> value = CompileRun(
       "function test() {"
       "  try {"
       "    (new Fun()).blah()"
       "  } catch (e) {"
       "    var str = String(e);"
       // "    if (str.indexOf('TypeError') == -1) return 1;"
       // "    if (str.indexOf('[object Fun]') != -1) return 2;"
       // "    if (str.indexOf('#<Fun>') == -1) return 3;"
       "    return 0;"
       "  }"
       "  return 4;"
       "}"
       "test();");
-  CHECK_EQ(0, value->Int32Value());
+  CHECK_EQ(0, value->Int32Value(context.local()).FromJust());
 }
 
 
 THREADED_TEST(EvalAliasedDynamic) {
   LocalContext current;
   v8::HandleScope scope(current->GetIsolate());
 
   // Tests where aliased eval can only be resolved dynamically.
   Local<Script> script = v8_compile(
       "function f(x) { "
       "  var foo = 2;"
       "  with (x) { return eval('foo'); }"
       "}"
       "foo = 0;"
       "result1 = f(new Object());"
       "result2 = f(this);"
       "var x = new Object();"
       "x.eval = function(x) { return 1; };"
       "result3 = f(x);");
-  script->Run();
-  CHECK_EQ(2, current->Global()->Get(v8_str("result1"))->Int32Value());
-  CHECK_EQ(0, current->Global()->Get(v8_str("result2"))->Int32Value());
-  CHECK_EQ(1, current->Global()->Get(v8_str("result3"))->Int32Value());
+  script->Run(current.local()).ToLocalChecked();
+  CHECK_EQ(2, current->Global()
+                  ->Get(current.local(), v8_str("result1"))
+                  .ToLocalChecked()
+                  ->Int32Value(current.local())
+                  .FromJust());
+  CHECK_EQ(0, current->Global()
+                  ->Get(current.local(), v8_str("result2"))
+                  .ToLocalChecked()
+                  ->Int32Value(current.local())
+                  .FromJust());
+  CHECK_EQ(1, current->Global()
+                  ->Get(current.local(), v8_str("result3"))
+                  .ToLocalChecked()
+                  ->Int32Value(current.local())
+                  .FromJust());
 
   v8::TryCatch try_catch(current->GetIsolate());
   script = v8_compile(
       "function f(x) { "
       "  var bar = 2;"
       "  with (x) { return eval('bar'); }"
       "}"
       "result4 = f(this)");
-  script->Run();
+  script->Run(current.local()).ToLocalChecked();
   CHECK(!try_catch.HasCaught());
-  CHECK_EQ(2, current->Global()->Get(v8_str("result4"))->Int32Value());
+  CHECK_EQ(2, current->Global()
+                  ->Get(current.local(), v8_str("result4"))
+                  .ToLocalChecked()
+                  ->Int32Value(current.local())
+                  .FromJust());
 
   try_catch.Reset();
 }
 
 
 THREADED_TEST(CrossEval) {
   v8::HandleScope scope(CcTest::isolate());
   LocalContext other;
   LocalContext current;
 
   Local<String> token = v8_str("<security token>");
   other->SetSecurityToken(token);
   current->SetSecurityToken(token);
 
   // Set up reference from current to other.
-  current->Global()->Set(v8_str("other"), other->Global());
+  CHECK(current->Global()
+            ->Set(current.local(), v8_str("other"), other->Global())
+            .FromJust());
 
   // Check that new variables are introduced in other context.
   Local<Script> script = v8_compile("other.eval('var foo = 1234')");
-  script->Run();
+  script->Run(current.local()).ToLocalChecked();
   Local<Value> foo = other->Global()->Get(v8_str("foo"));
-  CHECK_EQ(1234, foo->Int32Value());
+  CHECK_EQ(1234, foo->Int32Value(other.local()).FromJust());
   CHECK(!current->Global()->Has(v8_str("foo")));
 
   // Check that writing to non-existing properties introduces them in
   // the other context.
   script = v8_compile("other.eval('na = 1234')");
   script->Run();
-  CHECK_EQ(1234, other->Global()->Get(v8_str("na"))->Int32Value());
+  CHECK_EQ(
+      1234,
+      other->Global()->Get(v8_str("na"))->Int32Value(other.local()).FromJust());
   CHECK(!current->Global()->Has(v8_str("na")));
 
   // Check that global variables in current context are not visible in other
   // context.
   v8::TryCatch try_catch(CcTest::isolate());
   script = v8_compile("var bar = 42; other.eval('bar');");
   Local<Value> result = script->Run();
   CHECK(try_catch.HasCaught());
   try_catch.Reset();
 
   // Check that local variables in current context are not visible in other
   // context.
   script = v8_compile(
       "(function() { "
       "  var baz = 87;"
       "  return other.eval('baz');"
       "})();");
   result = script->Run();
   CHECK(try_catch.HasCaught());
   try_catch.Reset();
 
   // Check that global variables in the other environment are visible
   // when evaluting code.
-  other->Global()->Set(v8_str("bis"), v8_num(1234));
+  CHECK(other->Global()
+            ->Set(other.local(), v8_str("bis"), v8_num(1234))
+            .FromJust());
   script = v8_compile("other.eval('bis')");
-  CHECK_EQ(1234, script->Run()->Int32Value());
+  CHECK_EQ(1234, script->Run()->Int32Value(other.local()).FromJust());
   CHECK(!try_catch.HasCaught());
 
   // Check that the 'this' pointer points to the global object evaluating
   // code.
-  other->Global()->Set(v8_str("t"), other->Global());
+  CHECK(other->Global()
+            ->Set(other.local(), v8_str("t"), other->Global())
+            .FromJust());
   script = v8_compile("other.eval('this == t')");
   result = script->Run();
   CHECK(result->IsTrue());
   CHECK(!try_catch.HasCaught());
 
   // Check that variables introduced in with-statement are not visible in
   // other context.
   script = v8_compile("with({x:2}){other.eval('x')}");
   result = script->Run();
   CHECK(try_catch.HasCaught());
@@ skipping 11 matching lines @@
 // its global proxy works.
 THREADED_TEST(EvalInDetachedGlobal) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
 
   v8::Local<Context> context0 = Context::New(isolate);
   v8::Local<Context> context1 = Context::New(isolate);
 
   // Set up function in context0 that uses eval from context0.
   context0->Enter();
-  v8::Handle<v8::Value> fun = CompileRun(
+  v8::Local<v8::Value> fun = CompileRun(
       "var x = 42;"
       "(function() {"
       "  var e = eval;"
       "  return function(s) { return e(s); }"
       "})()");
   context0->Exit();
 
   // Put the function into context1 and call it before and after
   // detaching the global.  Before detaching, the call succeeds and
   // after detaching and exception is thrown.
   context1->Enter();
-  context1->Global()->Set(v8_str("fun"), fun);
-  v8::Handle<v8::Value> x_value = CompileRun("fun('x')");
-  CHECK_EQ(42, x_value->Int32Value());
+  CHECK(context1->Global()->Set(context1, v8_str("fun"), fun).FromJust());
+  v8::Local<v8::Value> x_value = CompileRun("fun('x')");
+  CHECK_EQ(42, x_value->Int32Value(context1).FromJust());
   context0->DetachGlobal();
   v8::TryCatch catcher(isolate);
   x_value = CompileRun("fun('x')");
-  CHECK_EQ(42, x_value->Int32Value());
+  CHECK_EQ(42, x_value->Int32Value(context1).FromJust());
   context1->Exit();
 }
 
 
 THREADED_TEST(CrossLazyLoad) {
   v8::HandleScope scope(CcTest::isolate());
   LocalContext other;
   LocalContext current;
 
   Local<String> token = v8_str("<security token>");
   other->SetSecurityToken(token);
   current->SetSecurityToken(token);
 
   // Set up reference from current to other.
-  current->Global()->Set(v8_str("other"), other->Global());
+  CHECK(current->Global()
+            ->Set(current.local(), v8_str("other"), other->Global())
+            .FromJust());
 
   // Trigger lazy loading in other context.
   Local<Script> script = v8_compile("other.eval('new Date(42)')");
   Local<Value> value = script->Run();
   CHECK_EQ(42.0, value->NumberValue());
 }
 
 
 static void call_as_function(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   if (args.IsConstructCall()) {
     if (args[0]->IsInt32()) {
-      args.GetReturnValue().Set(v8_num(-args[0]->Int32Value()));
+      args.GetReturnValue().Set(
+          v8_num(-args[0]
+                      ->Int32Value(args.GetIsolate()->GetCurrentContext())
+                      .FromJust()));
       return;
     }
   }
 
   args.GetReturnValue().Set(args[0]);
 }
 
 
 static void ReturnThis(const v8::FunctionCallbackInfo<v8::Value>& args) {
   args.GetReturnValue().Set(args.This());
 }
 
 
 // Test that a call handler can be set for objects which will allow
 // non-function objects created through the API to be called as
 // functions.
 THREADED_TEST(CallAsFunction) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
 
   {
     Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate);
     Local<ObjectTemplate> instance_template = t->InstanceTemplate();
     instance_template->SetCallAsFunctionHandler(call_as_function);
-    Local<v8::Object> instance = t->GetFunction()->NewInstance();
-    context->Global()->Set(v8_str("obj"), instance);
+    Local<v8::Object> instance = t->GetFunction(context.local())
+                                     .ToLocalChecked()
+                                     ->NewInstance(context.local())
+                                     .ToLocalChecked();
+    CHECK(context->Global()
+              ->Set(context.local(), v8_str("obj"), instance)
+              .FromJust());
     v8::TryCatch try_catch(isolate);
     Local<Value> value;
     CHECK(!try_catch.HasCaught());
 
     value = CompileRun("obj(42)");
     CHECK(!try_catch.HasCaught());
-    CHECK_EQ(42, value->Int32Value());
+    CHECK_EQ(42, value->Int32Value(context.local()).FromJust());
 
     value = CompileRun("(function(o){return o(49)})(obj)");
     CHECK(!try_catch.HasCaught());
-    CHECK_EQ(49, value->Int32Value());
+    CHECK_EQ(49, value->Int32Value(context.local()).FromJust());
 
     // test special case of call as function
     value = CompileRun("[obj]['0'](45)");
     CHECK(!try_catch.HasCaught());
-    CHECK_EQ(45, value->Int32Value());
+    CHECK_EQ(45, value->Int32Value(context.local()).FromJust());
 
     value = CompileRun(
         "obj.call = Function.prototype.call;"
         "obj.call(null, 87)");
     CHECK(!try_catch.HasCaught());
-    CHECK_EQ(87, value->Int32Value());
+    CHECK_EQ(87, value->Int32Value(context.local()).FromJust());
 
     // Regression tests for bug #1116356: Calling call through call/apply
     // must work for non-function receivers.
     const char* apply_99 = "Function.prototype.call.apply(obj, [this, 99])";
     value = CompileRun(apply_99);
     CHECK(!try_catch.HasCaught());
-    CHECK_EQ(99, value->Int32Value());
+    CHECK_EQ(99, value->Int32Value(context.local()).FromJust());
 
     const char* call_17 = "Function.prototype.call.call(obj, this, 17)";
     value = CompileRun(call_17);
     CHECK(!try_catch.HasCaught());
-    CHECK_EQ(17, value->Int32Value());
+    CHECK_EQ(17, value->Int32Value(context.local()).FromJust());
 
     // Check that the call-as-function handler can be called through
     // new.
     value = CompileRun("new obj(43)");
     CHECK(!try_catch.HasCaught());
-    CHECK_EQ(-43, value->Int32Value());
+    CHECK_EQ(-43, value->Int32Value(context.local()).FromJust());
 
     // Check that the call-as-function handler can be called through
     // the API.
-    v8::Handle<Value> args[] = {v8_num(28)};
+    v8::Local<Value> args[] = {v8_num(28)};
     value = instance->CallAsFunction(instance, 1, args);
     CHECK(!try_catch.HasCaught());
-    CHECK_EQ(28, value->Int32Value());
+    CHECK_EQ(28, value->Int32Value(context.local()).FromJust());
   }
 
   {
     Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate);
     Local<ObjectTemplate> instance_template(t->InstanceTemplate());
     USE(instance_template);
-    Local<v8::Object> instance = t->GetFunction()->NewInstance();
-    context->Global()->Set(v8_str("obj2"), instance);
+    Local<v8::Object> instance = t->GetFunction(context.local())
+                                     .ToLocalChecked()
+                                     ->NewInstance(context.local())
+                                     .ToLocalChecked();
+    CHECK(context->Global()
+              ->Set(context.local(), v8_str("obj2"), instance)
+              .FromJust());
     v8::TryCatch try_catch(isolate);
     Local<Value> value;
     CHECK(!try_catch.HasCaught());
 
     // Call an object without call-as-function handler through the JS
     value = CompileRun("obj2(28)");
     CHECK(value.IsEmpty());
     CHECK(try_catch.HasCaught());
     String::Utf8Value exception_value1(try_catch.Exception());
     // TODO(verwaest): Better message
     CHECK_EQ(0, strcmp("TypeError: obj2 is not a function", *exception_value1));
     try_catch.Reset();
 
     // Call an object without call-as-function handler through the API
     value = CompileRun("obj2(28)");
-    v8::Handle<Value> args[] = {v8_num(28)};
+    v8::Local<Value> args[] = {v8_num(28)};
     value = instance->CallAsFunction(instance, 1, args);
     CHECK(value.IsEmpty());
     CHECK(try_catch.HasCaught());
     String::Utf8Value exception_value2(try_catch.Exception());
     CHECK_EQ(0,
              strcmp("TypeError: object is not a function", *exception_value2));
     try_catch.Reset();
   }
 
   {
     Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate);
     Local<ObjectTemplate> instance_template = t->InstanceTemplate();
     instance_template->SetCallAsFunctionHandler(ThrowValue);
-    Local<v8::Object> instance = t->GetFunction()->NewInstance();
-    context->Global()->Set(v8_str("obj3"), instance);
+    Local<v8::Object> instance = t->GetFunction(context.local())
+                                     .ToLocalChecked()
+                                     ->NewInstance(context.local())
+                                     .ToLocalChecked();
+    CHECK(context->Global()
+              ->Set(context.local(), v8_str("obj3"), instance)
+              .FromJust());
     v8::TryCatch try_catch(isolate);
     Local<Value> value;
     CHECK(!try_catch.HasCaught());
 
     // Catch the exception which is thrown by call-as-function handler
     value = CompileRun("obj3(22)");
     CHECK(try_catch.HasCaught());
     String::Utf8Value exception_value1(try_catch.Exception());
     CHECK_EQ(0, strcmp("22", *exception_value1));
     try_catch.Reset();
 
-    v8::Handle<Value> args[] = {v8_num(23)};
+    v8::Local<Value> args[] = {v8_num(23)};
     value = instance->CallAsFunction(instance, 1, args);
     CHECK(try_catch.HasCaught());
     String::Utf8Value exception_value2(try_catch.Exception());
     CHECK_EQ(0, strcmp("23", *exception_value2));
     try_catch.Reset();
   }
 
   {
     Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate);
     Local<ObjectTemplate> instance_template = t->InstanceTemplate();
     instance_template->SetCallAsFunctionHandler(ReturnThis);
-    Local<v8::Object> instance = t->GetFunction()->NewInstance();
+    Local<v8::Object> instance = t->GetFunction(context.local())
+                                     .ToLocalChecked()
+                                     ->NewInstance(context.local())
+                                     .ToLocalChecked();
 
     Local<v8::Value> a1 =
         instance->CallAsFunction(v8::Undefined(isolate), 0, NULL);
     CHECK(a1->StrictEquals(instance));
     Local<v8::Value> a2 = instance->CallAsFunction(v8::Null(isolate), 0, NULL);
     CHECK(a2->StrictEquals(instance));
     Local<v8::Value> a3 = instance->CallAsFunction(v8_num(42), 0, NULL);
     CHECK(a3->StrictEquals(instance));
     Local<v8::Value> a4 = instance->CallAsFunction(v8_str("hello"), 0, NULL);
     CHECK(a4->StrictEquals(instance));
@@ skipping 53 matching lines @@
 
 // Check whether a non-function object is callable.
 THREADED_TEST(CallableObject) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
 
   {
     Local<ObjectTemplate> instance_template = ObjectTemplate::New(isolate);
     instance_template->SetCallAsFunctionHandler(call_as_function);
-    Local<Object> instance = instance_template->NewInstance();
+    Local<Object> instance =
+        instance_template->NewInstance(context.local()).ToLocalChecked();
     v8::TryCatch try_catch(isolate);
 
     CHECK(instance->IsCallable());
     CHECK(!try_catch.HasCaught());
   }
 
   {
     Local<ObjectTemplate> instance_template = ObjectTemplate::New(isolate);
-    Local<Object> instance = instance_template->NewInstance();
+    Local<Object> instance =
+        instance_template->NewInstance(context.local()).ToLocalChecked();
     v8::TryCatch try_catch(isolate);
 
     CHECK(!instance->IsCallable());
     CHECK(!try_catch.HasCaught());
   }
 
   {
     Local<FunctionTemplate> function_template =
         FunctionTemplate::New(isolate, call_as_function);
-    Local<Function> function = function_template->GetFunction();
+    Local<Function> function =
+        function_template->GetFunction(context.local()).ToLocalChecked();
     Local<Object> instance = function;
     v8::TryCatch try_catch(isolate);
 
     CHECK(instance->IsCallable());
     CHECK(!try_catch.HasCaught());
   }
 
   {
     Local<FunctionTemplate> function_template = FunctionTemplate::New(isolate);
-    Local<Function> function = function_template->GetFunction();
+    Local<Function> function =
+        function_template->GetFunction(context.local()).ToLocalChecked();
     Local<Object> instance = function;
     v8::TryCatch try_catch(isolate);
 
     CHECK(instance->IsCallable());
     CHECK(!try_catch.HasCaught());
   }
 }
 
 
 static int Recurse(v8::Isolate* isolate, int depth, int iterations) {
@@ skipping 50 matching lines @@
 }
 
 static void FastApiCallback_TrivialSignature(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   CheckReturnValue(args, FUNCTION_ADDR(FastApiCallback_TrivialSignature));
   v8::Isolate* isolate = CcTest::isolate();
   CHECK_EQ(isolate, args.GetIsolate());
   CHECK(args.This()->Equals(args.Holder()));
   CHECK(args.Data()->Equals(v8_str("method_data")));
-  args.GetReturnValue().Set(args[0]->Int32Value() + 1);
+  args.GetReturnValue().Set(
+      args[0]->Int32Value(isolate->GetCurrentContext()).FromJust() + 1);
 }
 
 static void FastApiCallback_SimpleSignature(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   CheckReturnValue(args, FUNCTION_ADDR(FastApiCallback_SimpleSignature));
   v8::Isolate* isolate = CcTest::isolate();
   CHECK_EQ(isolate, args.GetIsolate());
   CHECK(args.This()->GetPrototype()->Equals(args.Holder()));
   CHECK(args.Data()->Equals(v8_str("method_data")));
   // Note, we're using HasRealNamedProperty instead of Has to avoid
   // invoking the interceptor again.
   CHECK(args.Holder()->HasRealNamedProperty(v8_str("foo")));
-  args.GetReturnValue().Set(args[0]->Int32Value() + 1);
+  args.GetReturnValue().Set(
+      args[0]->Int32Value(isolate->GetCurrentContext()).FromJust() + 1);
 }
 
 
 // Helper to maximize the odds of object moving.
 static void GenerateSomeGarbage() {
   CompileRun(
       "var garbage;"
       "for (var i = 0; i < 1000; i++) {"
       "  garbage = [1/i, \"garbage\" + i, garbage, {foo: garbage}];"
       "}"
       "garbage = undefined;");
 }
 
 
 void DirectApiCallback(const v8::FunctionCallbackInfo<v8::Value>& args) {
   static int count = 0;
   if (count++ % 3 == 0) {
     CcTest::heap()->CollectAllGarbage();
         // This should move the stub
     GenerateSomeGarbage();  // This should ensure the old stub memory is flushed
   }
 }
 
 
 THREADED_TEST(CallICFastApi_DirectCall_GCMoveStub) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::ObjectTemplate> nativeobject_templ =
+  v8::Local<v8::ObjectTemplate> nativeobject_templ =
       v8::ObjectTemplate::New(isolate);
   nativeobject_templ->Set(isolate, "callback",
                           v8::FunctionTemplate::New(isolate,
                                                     DirectApiCallback));
-  v8::Local<v8::Object> nativeobject_obj = nativeobject_templ->NewInstance();
-  context->Global()->Set(v8_str("nativeobject"), nativeobject_obj);
+  v8::Local<v8::Object> nativeobject_obj =
+      nativeobject_templ->NewInstance(context.local()).ToLocalChecked();
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("nativeobject"), nativeobject_obj)
+            .FromJust());
   // call the api function multiple times to ensure direct call stub creation.
   CompileRun(
         "function f() {"
         "  for (var i = 1; i <= 30; i++) {"
         "    nativeobject.callback();"
         "  }"
         "}"
         "f();");
 }
 
 
 void ThrowingDirectApiCallback(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   args.GetIsolate()->ThrowException(v8_str("g"));
 }
 
 
 THREADED_TEST(CallICFastApi_DirectCall_Throw) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::ObjectTemplate> nativeobject_templ =
+  v8::Local<v8::ObjectTemplate> nativeobject_templ =
       v8::ObjectTemplate::New(isolate);
   nativeobject_templ->Set(isolate, "callback",
                           v8::FunctionTemplate::New(isolate,
                                                     ThrowingDirectApiCallback));
-  v8::Local<v8::Object> nativeobject_obj = nativeobject_templ->NewInstance();
-  context->Global()->Set(v8_str("nativeobject"), nativeobject_obj);
+  v8::Local<v8::Object> nativeobject_obj =
+      nativeobject_templ->NewInstance(context.local()).ToLocalChecked();
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("nativeobject"), nativeobject_obj)
+            .FromJust());
   // call the api function multiple times to ensure direct call stub creation.
-  v8::Handle<Value> result = CompileRun(
+  v8::Local<Value> result = CompileRun(
       "var result = '';"
       "function f() {"
       "  for (var i = 1; i <= 5; i++) {"
       "    try { nativeobject.callback(); } catch (e) { result += e; }"
       "  }"
       "}"
       "f(); result;");
   CHECK(v8_str("ggggg")->Equals(result));
 }
 
 
 static int p_getter_count_3;
 
 
-static Handle<Value> DoDirectGetter() {
+static Local<Value> DoDirectGetter() {
   if (++p_getter_count_3 % 3 == 0) {
     CcTest::heap()->CollectAllGarbage();
     GenerateSomeGarbage();
   }
   return v8_str("Direct Getter Result");
 }
 
 
 static void DirectGetterCallback(
     Local<String> name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   CheckReturnValue(info, FUNCTION_ADDR(DirectGetterCallback));
   info.GetReturnValue().Set(DoDirectGetter());
 }
 
 
 template<typename Accessor>
 static void LoadICFastApi_DirectCall_GCMoveStub(Accessor accessor) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::ObjectTemplate> obj = v8::ObjectTemplate::New(isolate);
+  v8::Local<v8::ObjectTemplate> obj = v8::ObjectTemplate::New(isolate);
   obj->SetAccessor(v8_str("p1"), accessor);
-  context->Global()->Set(v8_str("o1"), obj->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("o1"),
+                  obj->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   p_getter_count_3 = 0;
-  v8::Handle<v8::Value> result = CompileRun(
+  v8::Local<v8::Value> result = CompileRun(
       "function f() {"
       "  for (var i = 0; i < 30; i++) o1.p1;"
       "  return o1.p1"
       "}"
       "f();");
   CHECK(v8_str("Direct Getter Result")->Equals(result));
   CHECK_EQ(31, p_getter_count_3);
 }
 
 
 THREADED_PROFILED_TEST(LoadICFastApi_DirectCall_GCMoveStub) {
   LoadICFastApi_DirectCall_GCMoveStub(DirectGetterCallback);
 }
 
 
 void ThrowingDirectGetterCallback(
     Local<String> name,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   info.GetIsolate()->ThrowException(v8_str("g"));
 }
 
 
 THREADED_TEST(LoadICFastApi_DirectCall_Throw) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::ObjectTemplate> obj = v8::ObjectTemplate::New(isolate);
+  v8::Local<v8::ObjectTemplate> obj = v8::ObjectTemplate::New(isolate);
   obj->SetAccessor(v8_str("p1"), ThrowingDirectGetterCallback);
-  context->Global()->Set(v8_str("o1"), obj->NewInstance());
-  v8::Handle<Value> result = CompileRun(
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("o1"),
+                  obj->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
+  v8::Local<Value> result = CompileRun(
       "var result = '';"
       "for (var i = 0; i < 5; i++) {"
       "    try { o1.p1; } catch (e) { result += e; }"
       "}"
       "result;");
   CHECK(v8_str("ggggg")->Equals(result));
 }
 
 
 THREADED_PROFILED_TEST(InterceptorCallICFastApi_TrivialSignature) {
   int interceptor_call_count = 0;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::FunctionTemplate> fun_templ =
+  v8::Local<v8::FunctionTemplate> fun_templ =
       v8::FunctionTemplate::New(isolate);
-  v8::Handle<v8::FunctionTemplate> method_templ =
-      v8::FunctionTemplate::New(isolate,
-                                FastApiCallback_TrivialSignature,
-                                v8_str("method_data"),
-                                v8::Handle<v8::Signature>());
-  v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
+  v8::Local<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
+      isolate, FastApiCallback_TrivialSignature, v8_str("method_data"),
+      v8::Local<v8::Signature>());
+  v8::Local<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
-  v8::Handle<v8::ObjectTemplate> templ = fun_templ->InstanceTemplate();
+  v8::Local<v8::ObjectTemplate> templ = fun_templ->InstanceTemplate();
   templ->SetHandler(v8::NamedPropertyHandlerConfiguration(
       InterceptorCallICFastApi, NULL, NULL, NULL, NULL,
       v8::External::New(isolate, &interceptor_call_count)));
   LocalContext context;
-  v8::Handle<v8::Function> fun = fun_templ->GetFunction();
+  v8::Local<v8::Function> fun =
+      fun_templ->GetFunction(context.local()).ToLocalChecked();
   GenerateSomeGarbage();
-  context->Global()->Set(v8_str("o"), fun->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("o"),
+                  fun->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   CompileRun(
       "var result = 0;"
       "for (var i = 0; i < 100; i++) {"
       "  result = o.method(41);"
       "}");
-  CHECK_EQ(42, context->Global()->Get(v8_str("result"))->Int32Value());
+  CHECK_EQ(42, context->Global()
+                   ->Get(v8_str("result"))
+                   ->Int32Value(context.local())
+                   .FromJust());
   CHECK_EQ(100, interceptor_call_count);
 }
 
 
 THREADED_PROFILED_TEST(InterceptorCallICFastApi_SimpleSignature) {
   int interceptor_call_count = 0;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::FunctionTemplate> fun_templ =
+  v8::Local<v8::FunctionTemplate> fun_templ =
       v8::FunctionTemplate::New(isolate);
-  v8::Handle<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
+  v8::Local<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
       isolate, FastApiCallback_SimpleSignature, v8_str("method_data"),
       v8::Signature::New(isolate, fun_templ));
-  v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
+  v8::Local<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   fun_templ->SetHiddenPrototype(true);
-  v8::Handle<v8::ObjectTemplate> templ = fun_templ->InstanceTemplate();
+  v8::Local<v8::ObjectTemplate> templ = fun_templ->InstanceTemplate();
   templ->SetHandler(v8::NamedPropertyHandlerConfiguration(
       InterceptorCallICFastApi, NULL, NULL, NULL, NULL,
       v8::External::New(isolate, &interceptor_call_count)));
   LocalContext context;
-  v8::Handle<v8::Function> fun = fun_templ->GetFunction();
+  v8::Local<v8::Function> fun =
+      fun_templ->GetFunction(context.local()).ToLocalChecked();
   GenerateSomeGarbage();
-  context->Global()->Set(v8_str("o"), fun->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("o"),
+                  fun->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   CompileRun(
       "o.foo = 17;"
       "var receiver = {};"
       "receiver.__proto__ = o;"
       "var result = 0;"
       "for (var i = 0; i < 100; i++) {"
       "  result = receiver.method(41);"
       "}");
-  CHECK_EQ(42, context->Global()->Get(v8_str("result"))->Int32Value());
+  CHECK_EQ(42, context->Global()
+                   ->Get(v8_str("result"))
+                   ->Int32Value(context.local())
+                   .FromJust());
   CHECK_EQ(100, interceptor_call_count);
 }
 
 
 THREADED_PROFILED_TEST(InterceptorCallICFastApi_SimpleSignature_Miss1) {
   int interceptor_call_count = 0;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::FunctionTemplate> fun_templ =
+  v8::Local<v8::FunctionTemplate> fun_templ =
       v8::FunctionTemplate::New(isolate);
-  v8::Handle<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
+  v8::Local<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
       isolate, FastApiCallback_SimpleSignature, v8_str("method_data"),
       v8::Signature::New(isolate, fun_templ));
-  v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
+  v8::Local<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   fun_templ->SetHiddenPrototype(true);
-  v8::Handle<v8::ObjectTemplate> templ = fun_templ->InstanceTemplate();
+  v8::Local<v8::ObjectTemplate> templ = fun_templ->InstanceTemplate();
   templ->SetHandler(v8::NamedPropertyHandlerConfiguration(
       InterceptorCallICFastApi, NULL, NULL, NULL, NULL,
       v8::External::New(isolate, &interceptor_call_count)));
   LocalContext context;
-  v8::Handle<v8::Function> fun = fun_templ->GetFunction();
+  v8::Local<v8::Function> fun =
+      fun_templ->GetFunction(context.local()).ToLocalChecked();
   GenerateSomeGarbage();
-  context->Global()->Set(v8_str("o"), fun->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("o"),
+                  fun->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   CompileRun(
       "o.foo = 17;"
       "var receiver = {};"
       "receiver.__proto__ = o;"
       "var result = 0;"
       "var saved_result = 0;"
       "for (var i = 0; i < 100; i++) {"
       "  result = receiver.method(41);"
       "  if (i == 50) {"
       "    saved_result = result;"
       "    receiver = {method: function(x) { return x - 1 }};"
       "  }"
       "}");
-  CHECK_EQ(40, context->Global()->Get(v8_str("result"))->Int32Value());
-  CHECK_EQ(42, context->Global()->Get(v8_str("saved_result"))->Int32Value());
+  CHECK_EQ(40, context->Global()
+                   ->Get(v8_str("result"))
+                   ->Int32Value(context.local())
+                   .FromJust());
+  CHECK_EQ(42, context->Global()
+                   ->Get(v8_str("saved_result"))
+                   ->Int32Value(context.local())
+                   .FromJust());
   CHECK_GE(interceptor_call_count, 50);
 }
 
 
 THREADED_PROFILED_TEST(InterceptorCallICFastApi_SimpleSignature_Miss2) {
   int interceptor_call_count = 0;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::FunctionTemplate> fun_templ =
+  v8::Local<v8::FunctionTemplate> fun_templ =
       v8::FunctionTemplate::New(isolate);
-  v8::Handle<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
+  v8::Local<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
       isolate, FastApiCallback_SimpleSignature, v8_str("method_data"),
       v8::Signature::New(isolate, fun_templ));
-  v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
+  v8::Local<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   fun_templ->SetHiddenPrototype(true);
-  v8::Handle<v8::ObjectTemplate> templ = fun_templ->InstanceTemplate();
+  v8::Local<v8::ObjectTemplate> templ = fun_templ->InstanceTemplate();
   templ->SetHandler(v8::NamedPropertyHandlerConfiguration(
       InterceptorCallICFastApi, NULL, NULL, NULL, NULL,
       v8::External::New(isolate, &interceptor_call_count)));
   LocalContext context;
-  v8::Handle<v8::Function> fun = fun_templ->GetFunction();
+  v8::Local<v8::Function> fun =
+      fun_templ->GetFunction(context.local()).ToLocalChecked();
   GenerateSomeGarbage();
-  context->Global()->Set(v8_str("o"), fun->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("o"),
+                  fun->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   CompileRun(
       "o.foo = 17;"
       "var receiver = {};"
       "receiver.__proto__ = o;"
       "var result = 0;"
       "var saved_result = 0;"
       "for (var i = 0; i < 100; i++) {"
       "  result = receiver.method(41);"
       "  if (i == 50) {"
       "    saved_result = result;"
       "    o.method = function(x) { return x - 1 };"
       "  }"
       "}");
-  CHECK_EQ(40, context->Global()->Get(v8_str("result"))->Int32Value());
-  CHECK_EQ(42, context->Global()->Get(v8_str("saved_result"))->Int32Value());
+  CHECK_EQ(40, context->Global()
+                   ->Get(v8_str("result"))
+                   ->Int32Value(context.local())
+                   .FromJust());
+  CHECK_EQ(42, context->Global()
+                   ->Get(v8_str("saved_result"))
+                   ->Int32Value(context.local())
+                   .FromJust());
   CHECK_GE(interceptor_call_count, 50);
 }
 
 
 THREADED_PROFILED_TEST(InterceptorCallICFastApi_SimpleSignature_Miss3) {
   int interceptor_call_count = 0;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::FunctionTemplate> fun_templ =
+  v8::Local<v8::FunctionTemplate> fun_templ =
       v8::FunctionTemplate::New(isolate);
-  v8::Handle<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
+  v8::Local<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
       isolate, FastApiCallback_SimpleSignature, v8_str("method_data"),
       v8::Signature::New(isolate, fun_templ));
-  v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
+  v8::Local<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   fun_templ->SetHiddenPrototype(true);
-  v8::Handle<v8::ObjectTemplate> templ = fun_templ->InstanceTemplate();
+  v8::Local<v8::ObjectTemplate> templ = fun_templ->InstanceTemplate();
   templ->SetHandler(v8::NamedPropertyHandlerConfiguration(
       InterceptorCallICFastApi, NULL, NULL, NULL, NULL,
       v8::External::New(isolate, &interceptor_call_count)));
   LocalContext context;
-  v8::Handle<v8::Function> fun = fun_templ->GetFunction();
+  v8::Local<v8::Function> fun =
+      fun_templ->GetFunction(context.local()).ToLocalChecked();
   GenerateSomeGarbage();
-  context->Global()->Set(v8_str("o"), fun->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("o"),
+                  fun->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   v8::TryCatch try_catch(isolate);
   CompileRun(
       "o.foo = 17;"
       "var receiver = {};"
       "receiver.__proto__ = o;"
       "var result = 0;"
       "var saved_result = 0;"
       "for (var i = 0; i < 100; i++) {"
       "  result = receiver.method(41);"
       "  if (i == 50) {"
       "    saved_result = result;"
       "    receiver = 333;"
       "  }"
       "}");
   CHECK(try_catch.HasCaught());
   // TODO(verwaest): Adjust message.
   CHECK(v8_str("TypeError: receiver.method is not a function")
             ->Equals(try_catch.Exception()->ToString(isolate)));
-  CHECK_EQ(42, context->Global()->Get(v8_str("saved_result"))->Int32Value());
+  CHECK_EQ(42, context->Global()
+                   ->Get(v8_str("saved_result"))
+                   ->Int32Value(context.local())
+                   .FromJust());
   CHECK_GE(interceptor_call_count, 50);
 }
 
 
 THREADED_PROFILED_TEST(InterceptorCallICFastApi_SimpleSignature_TypeError) {
   int interceptor_call_count = 0;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::FunctionTemplate> fun_templ =
+  v8::Local<v8::FunctionTemplate> fun_templ =
       v8::FunctionTemplate::New(isolate);
-  v8::Handle<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
+  v8::Local<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
       isolate, FastApiCallback_SimpleSignature, v8_str("method_data"),
       v8::Signature::New(isolate, fun_templ));
-  v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
+  v8::Local<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   fun_templ->SetHiddenPrototype(true);
-  v8::Handle<v8::ObjectTemplate> templ = fun_templ->InstanceTemplate();
+  v8::Local<v8::ObjectTemplate> templ = fun_templ->InstanceTemplate();
   templ->SetHandler(v8::NamedPropertyHandlerConfiguration(
       InterceptorCallICFastApi, NULL, NULL, NULL, NULL,
       v8::External::New(isolate, &interceptor_call_count)));
   LocalContext context;
-  v8::Handle<v8::Function> fun = fun_templ->GetFunction();
+  v8::Local<v8::Function> fun =
+      fun_templ->GetFunction(context.local()).ToLocalChecked();
   GenerateSomeGarbage();
-  context->Global()->Set(v8_str("o"), fun->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("o"),
+                  fun->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   v8::TryCatch try_catch(isolate);
   CompileRun(
       "o.foo = 17;"
       "var receiver = {};"
       "receiver.__proto__ = o;"
       "var result = 0;"
       "var saved_result = 0;"
       "for (var i = 0; i < 100; i++) {"
       "  result = receiver.method(41);"
       "  if (i == 50) {"
       "    saved_result = result;"
       "    receiver = {method: receiver.method};"
       "  }"
       "}");
   CHECK(try_catch.HasCaught());
   CHECK(v8_str("TypeError: Illegal invocation")
             ->Equals(try_catch.Exception()->ToString(isolate)));
-  CHECK_EQ(42, context->Global()->Get(v8_str("saved_result"))->Int32Value());
+  CHECK_EQ(42, context->Global()
+                   ->Get(v8_str("saved_result"))
+                   ->Int32Value(context.local())
+                   .FromJust());
   CHECK_GE(interceptor_call_count, 50);
 }
 
 
 THREADED_PROFILED_TEST(CallICFastApi_TrivialSignature) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::FunctionTemplate> fun_templ =
+  v8::Local<v8::FunctionTemplate> fun_templ =
       v8::FunctionTemplate::New(isolate);
-  v8::Handle<v8::FunctionTemplate> method_templ =
-      v8::FunctionTemplate::New(isolate,
-                                FastApiCallback_TrivialSignature,
-                                v8_str("method_data"),
-                                v8::Handle<v8::Signature>());
-  v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
+  v8::Local<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
+      isolate, FastApiCallback_TrivialSignature, v8_str("method_data"),
+      v8::Local<v8::Signature>());
+  v8::Local<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
-  v8::Handle<v8::ObjectTemplate> templ(fun_templ->InstanceTemplate());
+  v8::Local<v8::ObjectTemplate> templ(fun_templ->InstanceTemplate());
   USE(templ);
   LocalContext context;
-  v8::Handle<v8::Function> fun = fun_templ->GetFunction();
+  v8::Local<v8::Function> fun =
+      fun_templ->GetFunction(context.local()).ToLocalChecked();
   GenerateSomeGarbage();
-  context->Global()->Set(v8_str("o"), fun->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("o"),
+                  fun->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   CompileRun(
       "var result = 0;"
       "for (var i = 0; i < 100; i++) {"
       "  result = o.method(41);"
       "}");
 
-  CHECK_EQ(42, context->Global()->Get(v8_str("result"))->Int32Value());
+  CHECK_EQ(42, context->Global()
+                   ->Get(v8_str("result"))
+                   ->Int32Value(context.local())
+                   .FromJust());
 }
 
 
 THREADED_PROFILED_TEST(CallICFastApi_SimpleSignature) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::FunctionTemplate> fun_templ =
+  v8::Local<v8::FunctionTemplate> fun_templ =
       v8::FunctionTemplate::New(isolate);
-  v8::Handle<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
+  v8::Local<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
       isolate, FastApiCallback_SimpleSignature, v8_str("method_data"),
       v8::Signature::New(isolate, fun_templ));
-  v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
+  v8::Local<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   fun_templ->SetHiddenPrototype(true);
-  v8::Handle<v8::ObjectTemplate> templ(fun_templ->InstanceTemplate());
+  v8::Local<v8::ObjectTemplate> templ(fun_templ->InstanceTemplate());
   CHECK(!templ.IsEmpty());
   LocalContext context;
-  v8::Handle<v8::Function> fun = fun_templ->GetFunction();
+  v8::Local<v8::Function> fun =
+      fun_templ->GetFunction(context.local()).ToLocalChecked();
   GenerateSomeGarbage();
-  context->Global()->Set(v8_str("o"), fun->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("o"),
+                  fun->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   CompileRun(
       "o.foo = 17;"
       "var receiver = {};"
       "receiver.__proto__ = o;"
       "var result = 0;"
       "for (var i = 0; i < 100; i++) {"
       "  result = receiver.method(41);"
       "}");
 
-  CHECK_EQ(42, context->Global()->Get(v8_str("result"))->Int32Value());
+  CHECK_EQ(42, context->Global()
+                   ->Get(v8_str("result"))
+                   ->Int32Value(context.local())
+                   .FromJust());
 }
 
 
 THREADED_PROFILED_TEST(CallICFastApi_SimpleSignature_Miss1) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::FunctionTemplate> fun_templ =
+  v8::Local<v8::FunctionTemplate> fun_templ =
       v8::FunctionTemplate::New(isolate);
-  v8::Handle<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
+  v8::Local<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
       isolate, FastApiCallback_SimpleSignature, v8_str("method_data"),
       v8::Signature::New(isolate, fun_templ));
-  v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
+  v8::Local<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   fun_templ->SetHiddenPrototype(true);
-  v8::Handle<v8::ObjectTemplate> templ(fun_templ->InstanceTemplate());
+  v8::Local<v8::ObjectTemplate> templ(fun_templ->InstanceTemplate());
   CHECK(!templ.IsEmpty());
   LocalContext context;
-  v8::Handle<v8::Function> fun = fun_templ->GetFunction();
+  v8::Local<v8::Function> fun =
+      fun_templ->GetFunction(context.local()).ToLocalChecked();
   GenerateSomeGarbage();
-  context->Global()->Set(v8_str("o"), fun->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("o"),
+                  fun->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   CompileRun(
       "o.foo = 17;"
       "var receiver = {};"
       "receiver.__proto__ = o;"
       "var result = 0;"
       "var saved_result = 0;"
       "for (var i = 0; i < 100; i++) {"
       "  result = receiver.method(41);"
       "  if (i == 50) {"
       "    saved_result = result;"
       "    receiver = {method: function(x) { return x - 1 }};"
       "  }"
       "}");
-  CHECK_EQ(40, context->Global()->Get(v8_str("result"))->Int32Value());
-  CHECK_EQ(42, context->Global()->Get(v8_str("saved_result"))->Int32Value());
+  CHECK_EQ(40, context->Global()
+                   ->Get(v8_str("result"))
+                   ->Int32Value(context.local())
+                   .FromJust());
+  CHECK_EQ(42, context->Global()
+                   ->Get(v8_str("saved_result"))
+                   ->Int32Value(context.local())
+                   .FromJust());
 }
 
 
 THREADED_PROFILED_TEST(CallICFastApi_SimpleSignature_Miss2) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::FunctionTemplate> fun_templ =
+  v8::Local<v8::FunctionTemplate> fun_templ =
       v8::FunctionTemplate::New(isolate);
-  v8::Handle<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
+  v8::Local<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
       isolate, FastApiCallback_SimpleSignature, v8_str("method_data"),
       v8::Signature::New(isolate, fun_templ));
-  v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
+  v8::Local<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   fun_templ->SetHiddenPrototype(true);
-  v8::Handle<v8::ObjectTemplate> templ(fun_templ->InstanceTemplate());
+  v8::Local<v8::ObjectTemplate> templ(fun_templ->InstanceTemplate());
   CHECK(!templ.IsEmpty());
   LocalContext context;
-  v8::Handle<v8::Function> fun = fun_templ->GetFunction();
+  v8::Local<v8::Function> fun =
+      fun_templ->GetFunction(context.local()).ToLocalChecked();
   GenerateSomeGarbage();
-  context->Global()->Set(v8_str("o"), fun->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("o"),
+                  fun->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   v8::TryCatch try_catch(isolate);
   CompileRun(
       "o.foo = 17;"
       "var receiver = {};"
       "receiver.__proto__ = o;"
       "var result = 0;"
       "var saved_result = 0;"
       "for (var i = 0; i < 100; i++) {"
       "  result = receiver.method(41);"
       "  if (i == 50) {"
       "    saved_result = result;"
       "    receiver = 333;"
       "  }"
       "}");
   CHECK(try_catch.HasCaught());
   // TODO(verwaest): Adjust message.
   CHECK(v8_str("TypeError: receiver.method is not a function")
             ->Equals(try_catch.Exception()->ToString(isolate)));
-  CHECK_EQ(42, context->Global()->Get(v8_str("saved_result"))->Int32Value());
+  CHECK_EQ(42, context->Global()
+                   ->Get(v8_str("saved_result"))
+                   ->Int32Value(context.local())
+                   .FromJust());
 }
 
 
 THREADED_PROFILED_TEST(CallICFastApi_SimpleSignature_TypeError) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::FunctionTemplate> fun_templ =
+  v8::Local<v8::FunctionTemplate> fun_templ =
       v8::FunctionTemplate::New(isolate);
-  v8::Handle<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
+  v8::Local<v8::FunctionTemplate> method_templ = v8::FunctionTemplate::New(
       isolate, FastApiCallback_SimpleSignature, v8_str("method_data"),
       v8::Signature::New(isolate, fun_templ));
-  v8::Handle<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
+  v8::Local<v8::ObjectTemplate> proto_templ = fun_templ->PrototypeTemplate();
   proto_templ->Set(v8_str("method"), method_templ);
   fun_templ->SetHiddenPrototype(true);
-  v8::Handle<v8::ObjectTemplate> templ(fun_templ->InstanceTemplate());
+  v8::Local<v8::ObjectTemplate> templ(fun_templ->InstanceTemplate());
   CHECK(!templ.IsEmpty());
   LocalContext context;
-  v8::Handle<v8::Function> fun = fun_templ->GetFunction();
+  v8::Local<v8::Function> fun =
+      fun_templ->GetFunction(context.local()).ToLocalChecked();
   GenerateSomeGarbage();
-  context->Global()->Set(v8_str("o"), fun->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("o"),
+                  fun->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   v8::TryCatch try_catch(isolate);
   CompileRun(
       "o.foo = 17;"
       "var receiver = {};"
       "receiver.__proto__ = o;"
       "var result = 0;"
       "var saved_result = 0;"
       "for (var i = 0; i < 100; i++) {"
       "  result = receiver.method(41);"
       "  if (i == 50) {"
       "    saved_result = result;"
       "    receiver = Object.create(receiver);"
       "  }"
       "}");
   CHECK(try_catch.HasCaught());
   CHECK(v8_str("TypeError: Illegal invocation")
             ->Equals(try_catch.Exception()->ToString(isolate)));
-  CHECK_EQ(42, context->Global()->Get(v8_str("saved_result"))->Int32Value());
+  CHECK_EQ(42, context->Global()
+                   ->Get(v8_str("saved_result"))
+                   ->Int32Value(context.local())
+                   .FromJust());
 }
 
 
 static void ThrowingGetter(Local<String> name,
                            const v8::PropertyCallbackInfo<v8::Value>& info) {
   ApiTestFuzzer::Fuzz();
-  info.GetIsolate()->ThrowException(Handle<Value>());
+  info.GetIsolate()->ThrowException(Local<Value>());
   info.GetReturnValue().SetUndefined();
 }
 
 
 THREADED_TEST(VariousGetPropertiesAndThrowingCallbacks) {
   LocalContext context;
   HandleScope scope(context->GetIsolate());
 
   Local<FunctionTemplate> templ = FunctionTemplate::New(context->GetIsolate());
   Local<ObjectTemplate> instance_templ = templ->InstanceTemplate();
   instance_templ->SetAccessor(v8_str("f"), ThrowingGetter);
 
-  Local<Object> instance = templ->GetFunction()->NewInstance();
+  Local<Object> instance = templ->GetFunction(context.local())
+                               .ToLocalChecked()
+                               ->NewInstance(context.local())
+                               .ToLocalChecked();
 
   Local<Object> another = Object::New(context->GetIsolate());
   another->SetPrototype(instance);
 
   Local<Object> with_js_getter = CompileRun(
       "o = {};\n"
       "o.__defineGetter__('f', function() { throw undefined; });\n"
       "o\n").As<Object>();
   CHECK(!with_js_getter.IsEmpty());
 
@@ skipping 57 matching lines @@
   CompileRun("throw 'from JS';");
   CHECK(try_catch.HasCaught());
   CHECK(!CcTest::i_isolate()->has_pending_exception());
   CHECK(!CcTest::i_isolate()->has_scheduled_exception());
 }
 
 
 static int call_depth;
 
 
-static void WithTryCatch(Handle<Message> message, Handle<Value> data) {
+static void WithTryCatch(Local<Message> message, Local<Value> data) {
   TryCatch try_catch(CcTest::isolate());
 }
 
 
-static void ThrowFromJS(Handle<Message> message, Handle<Value> data) {
+static void ThrowFromJS(Local<Message> message, Local<Value> data) {
   if (--call_depth) CompileRun("throw 'ThrowInJS';");
 }
 
 
-static void ThrowViaApi(Handle<Message> message, Handle<Value> data) {
+static void ThrowViaApi(Local<Message> message, Local<Value> data) {
   if (--call_depth) CcTest::isolate()->ThrowException(v8_str("ThrowViaApi"));
 }
 
 
-static void WebKitLike(Handle<Message> message, Handle<Value> data) {
-  Handle<String> errorMessageString = message->Get();
+static void WebKitLike(Local<Message> message, Local<Value> data) {
+  Local<String> errorMessageString = message->Get();
   CHECK(!errorMessageString.IsEmpty());
   message->GetStackTrace();
   message->GetScriptOrigin().ResourceName();
 }
 
 
 THREADED_TEST(ExceptionsDoNotPropagatePastTryCatch) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   HandleScope scope(isolate);
 
   Local<Function> func =
-      FunctionTemplate::New(isolate,
-                            ThrowingCallbackWithTryCatch)->GetFunction();
-  context->Global()->Set(v8_str("func"), func);
+      FunctionTemplate::New(isolate, ThrowingCallbackWithTryCatch)
+          ->GetFunction(context.local())
+          .ToLocalChecked();
+  CHECK(
+      context->Global()->Set(context.local(), v8_str("func"), func).FromJust());
 
   MessageCallback callbacks[] =
       { NULL, WebKitLike, ThrowViaApi, ThrowFromJS, WithTryCatch };
   for (unsigned i = 0; i < sizeof(callbacks)/sizeof(callbacks[0]); i++) {
     MessageCallback callback = callbacks[i];
     if (callback != NULL) {
       V8::AddMessageListener(callback);
     }
     // Some small number to control number of times message handler should
     // throw an exception.
@@ skipping 43 matching lines @@
   // instances.
   child_instance_templ->SetAccessor(v8_str("f"), ChildGetter);
   // Add 'g' twice.  The 'g' added last should get called for instances.
   child_instance_templ->SetAccessor(v8_str("g"), ParentGetter);
   child_instance_templ->SetAccessor(v8_str("g"), ChildGetter);
 
   // Add 'h' as an accessor to the proto template with ReadOnly attributes
   // so 'h' can be shadowed on the instance object.
   Local<ObjectTemplate> child_proto_templ = child_templ->PrototypeTemplate();
   child_proto_templ->SetAccessor(v8_str("h"), ParentGetter, 0,
-      v8::Handle<Value>(), v8::DEFAULT, v8::ReadOnly);
+                                 v8::Local<Value>(), v8::DEFAULT, v8::ReadOnly);
 
   // Add 'i' as an accessor to the instance template with ReadOnly attributes
   // but the attribute does not have effect because it is duplicated with
   // NULL setter.
   child_instance_templ->SetAccessor(v8_str("i"), ChildGetter, 0,
-      v8::Handle<Value>(), v8::DEFAULT, v8::ReadOnly);
-
+                                    v8::Local<Value>(), v8::DEFAULT,
+                                    v8::ReadOnly);
 
 
   // Instantiate the child template.
-  Local<v8::Object> instance = child_templ->GetFunction()->NewInstance();
+  Local<v8::Object> instance = child_templ->GetFunction(context.local())
+                                   .ToLocalChecked()
+                                   ->NewInstance(context.local())
+                                   .ToLocalChecked();
 
   // Check that the child function overrides the parent one.
-  context->Global()->Set(v8_str("o"), instance);
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("o"), instance)
+            .FromJust());
   Local<Value> value = v8_compile("o.f")->Run();
   // Check that the 'g' that was added last is hit.
-  CHECK_EQ(42, value->Int32Value());
+  CHECK_EQ(42, value->Int32Value(context.local()).FromJust());
   value = v8_compile("o.g")->Run();
-  CHECK_EQ(42, value->Int32Value());
+  CHECK_EQ(42, value->Int32Value(context.local()).FromJust());
 
   // Check that 'h' cannot be shadowed.
   value = v8_compile("o.h = 3; o.h")->Run();
-  CHECK_EQ(1, value->Int32Value());
+  CHECK_EQ(1, value->Int32Value(context.local()).FromJust());
 
   // Check that 'i' cannot be shadowed or changed.
   value = v8_compile("o.i = 3; o.i")->Run();
-  CHECK_EQ(42, value->Int32Value());
+  CHECK_EQ(42, value->Int32Value(context.local()).FromJust());
 }
 
 
 static void IsConstructHandler(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   args.GetReturnValue().Set(args.IsConstructCall());
 }
 
 
 THREADED_TEST(IsConstructCall) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
 
   // Function template with call handler.
   Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New(isolate);
   templ->SetCallHandler(IsConstructHandler);
 
   LocalContext context;
 
-  context->Global()->Set(v8_str("f"), templ->GetFunction());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("f"),
+                  templ->GetFunction(context.local()).ToLocalChecked())
+            .FromJust());
   Local<Value> value = v8_compile("f()")->Run();
   CHECK(!value->BooleanValue());
   value = v8_compile("new f()")->Run();
   CHECK(value->BooleanValue());
 }
 
 
 THREADED_TEST(ObjectProtoToString) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<v8::FunctionTemplate> templ = v8::FunctionTemplate::New(isolate);
   templ->SetClassName(v8_str("MyClass"));
 
   LocalContext context;
 
   Local<String> customized_tostring = v8_str("customized toString");
 
   // Replace Object.prototype.toString
   v8_compile("Object.prototype.toString = function() {"
                   "  return 'customized toString';"
                   "}")->Run();
 
   // Normal ToString call should call replaced Object.prototype.toString
-  Local<v8::Object> instance = templ->GetFunction()->NewInstance();
+  Local<v8::Object> instance = templ->GetFunction(context.local())
+                                   .ToLocalChecked()
+                                   ->NewInstance(context.local())
+                                   .ToLocalChecked();
   Local<String> value = instance->ToString(isolate);
   CHECK(value->IsString() && value->Equals(customized_tostring));
 
   // ObjectProtoToString should not call replace toString function.
   value = instance->ObjectProtoToString();
   CHECK(value->IsString() && value->Equals(v8_str("[object MyClass]")));
 
   // Check global
   value = context->Global()->ObjectProtoToString();
   CHECK(value->IsString() && value->Equals(v8_str("[object global]")));
@@ skipping 16 matching lines @@
 
   Local<String> customized_tostring = v8_str("customized toString");
 
   // Replace Object.prototype.toString
   CompileRun(
       "Object.prototype.toString = function() {"
       "  return 'customized toString';"
       "}");
 
   // Normal ToString call should call replaced Object.prototype.toString
-  Local<v8::Object> instance = templ->GetFunction()->NewInstance();
+  Local<v8::Object> instance = templ->GetFunction(context.local())
+                                   .ToLocalChecked()
+                                   ->NewInstance(context.local())
+                                   .ToLocalChecked();
   Local<String> value = instance->ToString(isolate);
   CHECK(value->IsString() && value->Equals(customized_tostring));
 
   // ObjectProtoToString should not call replace toString function.
   value = instance->ObjectProtoToString();
   CHECK(value->IsString() && value->Equals(v8_str("[object MyClass]")));
 
   // Check global
   value = context->Global()->ObjectProtoToString();
   CHECK(value->IsString() && value->Equals(v8_str("[object global]")));
@@ skipping 322 matching lines @@
 
 static void ThrowInJS(const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::Isolate* isolate = args.GetIsolate();
   CHECK(v8::Locker::IsLocked(isolate));
   ApiTestFuzzer::Fuzz();
   v8::Unlocker unlocker(isolate);
   const char* code = "throw 7;";
   {
     v8::Locker nested_locker(isolate);
     v8::HandleScope scope(isolate);
-    v8::Handle<Value> exception;
+    v8::Local<Value> exception;
     {
       v8::TryCatch try_catch(isolate);
-      v8::Handle<Value> value = CompileRun(code);
+      v8::Local<Value> value = CompileRun(code);
       CHECK(value.IsEmpty());
       CHECK(try_catch.HasCaught());
       // Make sure to wrap the exception in a new handle because
       // the handle returned from the TryCatch is destroyed
       // when the TryCatch is destroyed.
       exception = Local<Value>::New(isolate, try_catch.Exception());
     }
     args.GetIsolate()->ThrowException(exception);
   }
 }
 
 
 static void ThrowInJSNoCatch(const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK(v8::Locker::IsLocked(CcTest::isolate()));
   ApiTestFuzzer::Fuzz();
   v8::Unlocker unlocker(CcTest::isolate());
   const char* code = "throw 7;";
   {
     v8::Locker nested_locker(CcTest::isolate());
     v8::HandleScope scope(args.GetIsolate());
-    v8::Handle<Value> value = CompileRun(code);
+    v8::Local<Value> value = CompileRun(code);
     CHECK(value.IsEmpty());
     args.GetReturnValue().Set(v8_str("foo"));
   }
 }
 
 
 // These are locking tests that don't need to be run again
 // as part of the locking aggregation tests.
 TEST(NestedLockers) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::Locker locker(isolate);
   CHECK(v8::Locker::IsLocked(isolate));
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   Local<v8::FunctionTemplate> fun_templ =
       v8::FunctionTemplate::New(isolate, ThrowInJS);
-  Local<Function> fun = fun_templ->GetFunction();
-  env->Global()->Set(v8_str("throw_in_js"), fun);
+  Local<Function> fun = fun_templ->GetFunction(env.local()).ToLocalChecked();
+  CHECK(env->Global()->Set(env.local(), v8_str("throw_in_js"), fun).FromJust());
   Local<Script> script = v8_compile("(function () {"
                                     "  try {"
                                     "    throw_in_js();"
                                     "    return 42;"
                                     "  } catch (e) {"
                                     "    return e * 13;"
                                     "  }"
                                     "})();");
-  CHECK_EQ(91, script->Run()->Int32Value());
+  CHECK_EQ(91, script->Run()->Int32Value(env.local()).FromJust());
 }
 
 
 // These are locking tests that don't need to be run again
 // as part of the locking aggregation tests.
 TEST(NestedLockersNoTryCatch) {
   v8::Locker locker(CcTest::isolate());
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   Local<v8::FunctionTemplate> fun_templ =
       v8::FunctionTemplate::New(env->GetIsolate(), ThrowInJSNoCatch);
-  Local<Function> fun = fun_templ->GetFunction();
-  env->Global()->Set(v8_str("throw_in_js"), fun);
+  Local<Function> fun = fun_templ->GetFunction(env.local()).ToLocalChecked();
+  CHECK(env->Global()->Set(env.local(), v8_str("throw_in_js"), fun).FromJust());
   Local<Script> script = v8_compile("(function () {"
                                     "  try {"
                                     "    throw_in_js();"
                                     "    return 42;"
                                     "  } catch (e) {"
                                     "    return e * 13;"
                                     "  }"
                                     "})();");
-  CHECK_EQ(91, script->Run()->Int32Value());
+  CHECK_EQ(91, script->Run()->Int32Value(env.local()).FromJust());
 }
 
 
 THREADED_TEST(RecursiveLocking) {
   v8::Locker locker(CcTest::isolate());
   {
     v8::Locker locker2(CcTest::isolate());
     CHECK(v8::Locker::IsLocked(CcTest::isolate()));
   }
 }
 
 
 static void UnlockForAMoment(const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   v8::Unlocker unlocker(CcTest::isolate());
 }
 
 
 THREADED_TEST(LockUnlockLock) {
   {
     v8::Locker locker(CcTest::isolate());
     v8::HandleScope scope(CcTest::isolate());
     LocalContext env;
     Local<v8::FunctionTemplate> fun_templ =
         v8::FunctionTemplate::New(CcTest::isolate(), UnlockForAMoment);
-    Local<Function> fun = fun_templ->GetFunction();
-    env->Global()->Set(v8_str("unlock_for_a_moment"), fun);
+    Local<Function> fun = fun_templ->GetFunction(env.local()).ToLocalChecked();
+    CHECK(env->Global()
+              ->Set(env.local(), v8_str("unlock_for_a_moment"), fun)
+              .FromJust());
     Local<Script> script = v8_compile("(function () {"
                                       "  unlock_for_a_moment();"
                                       "  return 42;"
                                       "})();");
-    CHECK_EQ(42, script->Run()->Int32Value());
+    CHECK_EQ(42, script->Run()->Int32Value(env.local()).FromJust());
   }
   {
     v8::Locker locker(CcTest::isolate());
     v8::HandleScope scope(CcTest::isolate());
     LocalContext env;
     Local<v8::FunctionTemplate> fun_templ =
         v8::FunctionTemplate::New(CcTest::isolate(), UnlockForAMoment);
-    Local<Function> fun = fun_templ->GetFunction();
-    env->Global()->Set(v8_str("unlock_for_a_moment"), fun);
+    Local<Function> fun = fun_templ->GetFunction(env.local()).ToLocalChecked();
+    CHECK(env->Global()
+              ->Set(env.local(), v8_str("unlock_for_a_moment"), fun)
+              .FromJust());
     Local<Script> script = v8_compile("(function () {"
                                       "  unlock_for_a_moment();"
                                       "  return 42;"
                                       "})();");
-    CHECK_EQ(42, script->Run()->Int32Value());
+    CHECK_EQ(42, script->Run()->Int32Value(env.local()).FromJust());
   }
 }
 
 
 static int GetGlobalObjectsCount() {
   int count = 0;
   i::HeapIterator it(CcTest::heap());
   for (i::HeapObject* object = it.next(); object != NULL; object = it.next())
     if (object->IsJSGlobalObject()) {
       i::JSGlobalObject* g = i::JSGlobalObject::cast(object);
@@ skipping 248 matching lines @@
       CompileRun(source);
     }
     { v8::HandleScope scope(CcTest::isolate());
       LocalContext context;
       CompileRun(source);
     }
   }
 }
 
 
-static v8::Handle<Value> NestedScope(v8::Local<Context> env) {
+static v8::Local<Value> NestedScope(v8::Local<Context> env) {
   v8::EscapableHandleScope inner(env->GetIsolate());
   env->Enter();
   v8::Local<Value> three = v8_num(3);
   v8::Local<Value> value = inner.Escape(three);
   env->Exit();
   return value;
 }
 
 
 THREADED_TEST(NestedHandleScopeAndContexts) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope outer(isolate);
   v8::Local<Context> env = Context::New(isolate);
   env->Enter();
-  v8::Handle<Value> value = NestedScope(env);
-  v8::Handle<String> str(value->ToString(isolate));
+  v8::Local<Value> value = NestedScope(env);
+  v8::Local<String> str(value->ToString(isolate));
   CHECK(!str.IsEmpty());
   env->Exit();
 }
 
 
 static bool MatchPointers(void* key1, void* key2) {
   return key1 == key2;
 }
 
 
@@ skipping 226 matching lines @@
 }
 
 
 void SetFunctionEntryHookTest::RunLoopInNewEnv(v8::Isolate* isolate) {
   v8::HandleScope outer(isolate);
   v8::Local<Context> env = Context::New(isolate);
   env->Enter();
 
   Local<ObjectTemplate> t = ObjectTemplate::New(isolate);
   t->Set(v8_str("asdf"), v8::FunctionTemplate::New(isolate, RuntimeCallback));
-  env->Global()->Set(v8_str("obj"), t->NewInstance());
+  CHECK(env->Global()
+            ->Set(env, v8_str("obj"), t->NewInstance(env).ToLocalChecked())
+            .FromJust());
 
   const char* script =
       "function bar() {\n"
       "  var sum = 0;\n"
       "  for (i = 0; i < 100; ++i)\n"
       "    sum = foo(i);\n"
       "  return sum;\n"
       "}\n"
       "function foo(i) { return i * i; }\n"
       "// Invoke on the runtime function.\n"
       "obj.asdf()";
   CompileRun(script);
   bar_func_ = i::Handle<i::JSFunction>::cast(
           v8::Utils::OpenHandle(*env->Global()->Get(v8_str("bar"))));
   DCHECK(!bar_func_.is_null());
 
   foo_func_ =
       i::Handle<i::JSFunction>::cast(
            v8::Utils::OpenHandle(*env->Global()->Get(v8_str("foo"))));
   DCHECK(!foo_func_.is_null());
 
-  v8::Handle<v8::Value> value = CompileRun("bar();");
+  v8::Local<v8::Value> value = CompileRun("bar();");
   CHECK(value->IsNumber());
   CHECK_EQ(9801.0, v8::Number::Cast(*value)->Value());
 
   // Test the optimized codegen path.
   value = CompileRun("%OptimizeFunctionOnNextCall(foo);"
                      "bar();");
   CHECK(value->IsNumber());
   CHECK_EQ(9801.0, v8::Number::Cast(*value)->Value());
 
   env->Exit();
@@ skipping 344 matching lines @@
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope outer(isolate);
   static v8::Persistent<v8::ObjectTemplate> templ;
   if (templ.IsEmpty()) {
     v8::EscapableHandleScope inner(isolate);
     v8::Local<v8::ObjectTemplate> local = v8::ObjectTemplate::New(isolate);
     local->SetInternalFieldCount(1);
     templ.Reset(isolate, inner.Escape(local));
   }
-  v8::Handle<v8::Object> result =
-      v8::Local<v8::ObjectTemplate>::New(isolate, templ)->NewInstance();
+  v8::Local<v8::Object> result =
+      v8::Local<v8::ObjectTemplate>::New(isolate, templ)
+          ->NewInstance(context.local())
+          .ToLocalChecked();
   CHECK_EQ(1, result->InternalFieldCount());
 }
 
 
 // If part of the threaded tests, this test makes ThreadingTest fail
 // on mac.
 TEST(CatchStackOverflow) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   v8::TryCatch try_catch(context->GetIsolate());
-  v8::Handle<v8::Value> result = CompileRun(
-    "function f() {"
-    "  return f();"
-    "}"
-    ""
-    "f();");
+  v8::Local<v8::Value> result = CompileRun(
+      "function f() {"
+      "  return f();"
+      "}"
+      ""
+      "f();");
   CHECK(result.IsEmpty());
 }
 
 
-static void CheckTryCatchSourceInfo(v8::Handle<v8::Script> script,
+static void CheckTryCatchSourceInfo(v8::Local<v8::Script> script,
                                     const char* resource_name,
                                     int line_offset) {
   v8::HandleScope scope(CcTest::isolate());
   v8::TryCatch try_catch(CcTest::isolate());
-  v8::Handle<v8::Value> result = script->Run();
+  v8::Local<v8::Value> result = script->Run();
   CHECK(result.IsEmpty());
   CHECK(try_catch.HasCaught());
-  v8::Handle<v8::Message> message = try_catch.Message();
+  v8::Local<v8::Message> message = try_catch.Message();
   CHECK(!message.IsEmpty());
   CHECK_EQ(10 + line_offset, message->GetLineNumber());
   CHECK_EQ(91, message->GetStartPosition());
   CHECK_EQ(92, message->GetEndPosition());
   CHECK_EQ(2, message->GetStartColumn());
   CHECK_EQ(3, message->GetEndColumn());
   v8::String::Utf8Value line(message->GetSourceLine());
   CHECK_EQ(0, strcmp("  throw 'nirk';", *line));
   v8::String::Utf8Value name(message->GetScriptOrigin().ResourceName());
   CHECK_EQ(0, strcmp(resource_name, *name));
@@ skipping 12 matching lines @@
       "  return Baz();\n"
       "}\n"
       "\n"
       "function Baz() {\n"
       "  throw 'nirk';\n"
       "}\n"
       "\n"
       "Foo();\n");
 
   const char* resource_name;
-  v8::Handle<v8::Script> script;
+  v8::Local<v8::Script> script;
   resource_name = "test.js";
   script = CompileWithOrigin(source, resource_name);
   CheckTryCatchSourceInfo(script, resource_name, 0);
 
   resource_name = "test1.js";
-  v8::ScriptOrigin origin1(
-      v8::String::NewFromUtf8(context->GetIsolate(), resource_name));
+  v8::ScriptOrigin origin1(v8_str(resource_name));
   script = v8::Script::Compile(source, &origin1);
   CheckTryCatchSourceInfo(script, resource_name, 0);
 
   resource_name = "test2.js";
-  v8::ScriptOrigin origin2(
-      v8::String::NewFromUtf8(context->GetIsolate(), resource_name),
-      v8::Integer::New(context->GetIsolate(), 7));
+  v8::ScriptOrigin origin2(v8_str(resource_name),
+                           v8::Integer::New(context->GetIsolate(), 7));
   script = v8::Script::Compile(source, &origin2);
   CheckTryCatchSourceInfo(script, resource_name, 7);
 }
 
 
 THREADED_TEST(TryCatchSourceInfoForEOSError) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   v8::TryCatch try_catch(context->GetIsolate());
   v8::Script::Compile(v8_str("!\n"));
   CHECK(try_catch.HasCaught());
-  v8::Handle<v8::Message> message = try_catch.Message();
+  v8::Local<v8::Message> message = try_catch.Message();
   CHECK_EQ(1, message->GetLineNumber());
   CHECK_EQ(0, message->GetStartColumn());
 }
 
 
 THREADED_TEST(CompilationCache) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
-  v8::Handle<v8::String> source0 =
-      v8::String::NewFromUtf8(context->GetIsolate(), "1234");
-  v8::Handle<v8::String> source1 =
-      v8::String::NewFromUtf8(context->GetIsolate(), "1234");
-  v8::Handle<v8::Script> script0 = CompileWithOrigin(source0, "test.js");
-  v8::Handle<v8::Script> script1 = CompileWithOrigin(source1, "test.js");
-  v8::Handle<v8::Script> script2 =
+  v8::Local<v8::String> source0 = v8_str("1234");
+  v8::Local<v8::String> source1 = v8_str("1234");
+  v8::Local<v8::Script> script0 = CompileWithOrigin(source0, "test.js");
+  v8::Local<v8::Script> script1 = CompileWithOrigin(source1, "test.js");
+  v8::Local<v8::Script> script2 =
       v8::Script::Compile(source0);  // different origin
-  CHECK_EQ(1234, script0->Run()->Int32Value());
-  CHECK_EQ(1234, script1->Run()->Int32Value());
-  CHECK_EQ(1234, script2->Run()->Int32Value());
+  CHECK_EQ(1234, script0->Run()->Int32Value(context.local()).FromJust());
+  CHECK_EQ(1234, script1->Run()->Int32Value(context.local()).FromJust());
+  CHECK_EQ(1234, script2->Run()->Int32Value(context.local()).FromJust());
 }
 
 
 static void FunctionNameCallback(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   ApiTestFuzzer::Fuzz();
   args.GetReturnValue().Set(v8_num(42));
 }
 
 
 THREADED_TEST(CallbackFunctionName) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> t = ObjectTemplate::New(isolate);
   t->Set(v8_str("asdf"),
          v8::FunctionTemplate::New(isolate, FunctionNameCallback));
-  context->Global()->Set(v8_str("obj"), t->NewInstance());
-  v8::Handle<v8::Value> value = CompileRun("obj.asdf.name");
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("obj"),
+                  t->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
+  v8::Local<v8::Value> value = CompileRun("obj.asdf.name");
   CHECK(value->IsString());
   v8::String::Utf8Value name(value);
   CHECK_EQ(0, strcmp("asdf", *name));
 }
 
 
 THREADED_TEST(DateAccess) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
-  v8::Handle<v8::Value> date =
+  v8::Local<v8::Value> date =
       v8::Date::New(context->GetIsolate(), 1224744689038.0);
   CHECK(date->IsDate());
   CHECK_EQ(1224744689038.0, date.As<v8::Date>()->ValueOf());
 }
 
 
-void CheckProperties(v8::Isolate* isolate, v8::Handle<v8::Value> val,
+void CheckProperties(v8::Isolate* isolate, v8::Local<v8::Value> val,
                      unsigned elmc, const char* elmv[]) {
-  v8::Handle<v8::Object> obj = val.As<v8::Object>();
-  v8::Handle<v8::Array> props = obj->GetPropertyNames();
+  v8::Local<v8::Object> obj = val.As<v8::Object>();
+  v8::Local<v8::Array> props = obj->GetPropertyNames();
   CHECK_EQ(elmc, props->Length());
   for (unsigned i = 0; i < elmc; i++) {
     v8::String::Utf8Value elm(props->Get(v8::Integer::New(isolate, i)));
     CHECK_EQ(0, strcmp(elmv[i], *elm));
   }
 }
 
 
-void CheckOwnProperties(v8::Isolate* isolate, v8::Handle<v8::Value> val,
+void CheckOwnProperties(v8::Isolate* isolate, v8::Local<v8::Value> val,
                         unsigned elmc, const char* elmv[]) {
-  v8::Handle<v8::Object> obj = val.As<v8::Object>();
-  v8::Handle<v8::Array> props = obj->GetOwnPropertyNames();
+  v8::Local<v8::Object> obj = val.As<v8::Object>();
+  v8::Local<v8::Array> props = obj->GetOwnPropertyNames();
   CHECK_EQ(elmc, props->Length());
   for (unsigned i = 0; i < elmc; i++) {
     v8::String::Utf8Value elm(props->Get(v8::Integer::New(isolate, i)));
     CHECK_EQ(0, strcmp(elmv[i], *elm));
   }
 }
 
 
 THREADED_TEST(PropertyEnumeration) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::Value> obj = CompileRun(
+  v8::Local<v8::Value> obj = CompileRun(
       "var result = [];"
       "result[0] = {};"
       "result[1] = {a: 1, b: 2};"
       "result[2] = [1, 2, 3];"
       "var proto = {x: 1, y: 2, z: 3};"
       "var x = { __proto__: proto, w: 0, z: 1 };"
       "result[3] = x;"
       "result;");
-  v8::Handle<v8::Array> elms = obj.As<v8::Array>();
+  v8::Local<v8::Array> elms = obj.As<v8::Array>();
   CHECK_EQ(4u, elms->Length());
   int elmc0 = 0;
   const char** elmv0 = NULL;
   CheckProperties(
       isolate, elms->Get(v8::Integer::New(isolate, 0)), elmc0, elmv0);
   CheckOwnProperties(
       isolate, elms->Get(v8::Integer::New(isolate, 0)), elmc0, elmv0);
   int elmc1 = 2;
   const char* elmv1[] = {"a", "b"};
   CheckProperties(
@@ skipping 14 matching lines @@
   const char* elmv4[] = {"w", "z"};
   CheckOwnProperties(
       isolate, elms->Get(v8::Integer::New(isolate, 3)), elmc4, elmv4);
 }
 
 
 THREADED_TEST(PropertyEnumeration2) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::Value> obj = CompileRun(
+  v8::Local<v8::Value> obj = CompileRun(
       "var result = [];"
       "result[0] = {};"
       "result[1] = {a: 1, b: 2};"
       "result[2] = [1, 2, 3];"
       "var proto = {x: 1, y: 2, z: 3};"
       "var x = { __proto__: proto, w: 0, z: 1 };"
       "result[3] = x;"
       "result;");
-  v8::Handle<v8::Array> elms = obj.As<v8::Array>();
+  v8::Local<v8::Array> elms = obj.As<v8::Array>();
   CHECK_EQ(4u, elms->Length());
   int elmc0 = 0;
   const char** elmv0 = NULL;
   CheckProperties(isolate,
                   elms->Get(v8::Integer::New(isolate, 0)), elmc0, elmv0);
 
-  v8::Handle<v8::Value> val = elms->Get(v8::Integer::New(isolate, 0));
-  v8::Handle<v8::Array> props = val.As<v8::Object>()->GetPropertyNames();
+  v8::Local<v8::Value> val = elms->Get(v8::Integer::New(isolate, 0));
+  v8::Local<v8::Array> props = val.As<v8::Object>()->GetPropertyNames();
   CHECK_EQ(0u, props->Length());
   for (uint32_t i = 0; i < props->Length(); i++) {
     printf("p[%u]\n", i);
   }
 }
 
 
 THREADED_TEST(AccessChecksReenabledCorrectly) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
@@ skipping 10 matching lines @@
     for (char j = '0'; j <= '9'; j++) {
       buf[1] = j;
       for (char k = '0'; k <= '9'; k++) {
         buf[2] = k;
         buf[3] = 0;
         templ->Set(v8_str(buf), v8::Number::New(isolate, k));
       }
     }
   }
 
-  Local<v8::Object> instance_1 = templ->NewInstance();
-  context->Global()->Set(v8_str("obj_1"), instance_1);
+  Local<v8::Object> instance_1 =
+      templ->NewInstance(context.local()).ToLocalChecked();
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("obj_1"), instance_1)
+            .FromJust());
 
   Local<Value> value_1 = CompileRun("obj_1.a");
   CHECK(value_1.IsEmpty());
 
-  Local<v8::Object> instance_2 = templ->NewInstance();
-  context->Global()->Set(v8_str("obj_2"), instance_2);
+  Local<v8::Object> instance_2 =
+      templ->NewInstance(context.local()).ToLocalChecked();
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("obj_2"), instance_2)
+            .FromJust());
 
   Local<Value> value_2 = CompileRun("obj_2.a");
   CHECK(value_2.IsEmpty());
 }
 
 
 // Tests that ScriptData can be serialized and deserialized.
 TEST(PreCompileSerialization) {
   v8::V8::Initialize();
   LocalContext env;
@@ skipping 25 matching lines @@
 // This tests that we do not allow dictionary load/call inline caches
 // to use functions that have not yet been compiled.  The potential
 // problem of loading a function that has not yet been compiled can
 // arise because we share code between contexts via the compilation
 // cache.
 THREADED_TEST(DictionaryICLoadedFunction) {
   v8::HandleScope scope(CcTest::isolate());
   // Test LoadIC.
   for (int i = 0; i < 2; i++) {
     LocalContext context;
-    context->Global()->Set(v8_str("tmp"), v8::True(CcTest::isolate()));
+    CHECK(context->Global()
+              ->Set(context.local(), v8_str("tmp"), v8::True(CcTest::isolate()))
+              .FromJust());
     context->Global()->Delete(v8_str("tmp"));
     CompileRun("for (var j = 0; j < 10; j++) new RegExp('');");
   }
   // Test CallIC.
   for (int i = 0; i < 2; i++) {
     LocalContext context;
-    context->Global()->Set(v8_str("tmp"), v8::True(CcTest::isolate()));
+    CHECK(context->Global()
+              ->Set(context.local(), v8_str("tmp"), v8::True(CcTest::isolate()))
+              .FromJust());
     context->Global()->Delete(v8_str("tmp"));
     CompileRun("for (var j = 0; j < 10; j++) RegExp('')");
   }
 }
 
 
 // Test that cross-context new calls use the context of the callee to
 // create the new JavaScript object.
 THREADED_TEST(CrossContextNew) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   v8::Local<Context> context0 = Context::New(isolate);
   v8::Local<Context> context1 = Context::New(isolate);
 
   // Allow cross-domain access.
   Local<String> token = v8_str("<security token>");
   context0->SetSecurityToken(token);
   context1->SetSecurityToken(token);
 
   // Set an 'x' property on the Object prototype and define a
   // constructor function in context0.
   context0->Enter();
   CompileRun("Object.prototype.x = 42; function C() {};");
   context0->Exit();
 
   // Call the constructor function from context0 and check that the
   // result has the 'x' property.
   context1->Enter();
-  context1->Global()->Set(v8_str("other"), context0->Global());
+  CHECK(context1->Global()
+            ->Set(context1, v8_str("other"), context0->Global())
+            .FromJust());
   Local<Value> value = CompileRun("var instance = new other.C(); instance.x");
   CHECK(value->IsInt32());
-  CHECK_EQ(42, value->Int32Value());
+  CHECK_EQ(42, value->Int32Value(context1).FromJust());
   context1->Exit();
 }
 
 
 // Verify that we can clone an object
 TEST(ObjectClone) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
 
@@ skipping 90 matching lines @@
         i::Vector<const uint16_t>(two_byte_string,
                                   i::StrLength(c_string)));
 
     Local<String> lhs(
         v8::Utils::ToLocal(factory->NewExternalStringFromOneByte(
                                         &one_byte_resource).ToHandleChecked()));
     Local<String> rhs(
         v8::Utils::ToLocal(factory->NewExternalStringFromOneByte(
                                         &one_byte_resource).ToHandleChecked()));
 
-    env->Global()->Set(v8_str("lhs"), lhs);
-    env->Global()->Set(v8_str("rhs"), rhs);
+    CHECK(env->Global()->Set(env.local(), v8_str("lhs"), lhs).FromJust());
+    CHECK(env->Global()->Set(env.local(), v8_str("rhs"), rhs).FromJust());
 
     CompileRun(
         "var cons = lhs + rhs;"
         "var slice = lhs.substring(1, lhs.length - 1);"
         "var slice_on_cons = (lhs + rhs).substring(1, lhs.length *2 - 1);");
 
     CHECK(lhs->IsOneByte());
     CHECK(rhs->IsOneByte());
 
     MorphAString(*v8::Utils::OpenHandle(*lhs), &one_byte_resource,
                  &uc16_resource);
     MorphAString(*v8::Utils::OpenHandle(*rhs), &one_byte_resource,
                  &uc16_resource);
 
     // This should UTF-8 without flattening, since everything is ASCII.
-    Handle<String> cons = v8_compile("cons")->Run().As<String>();
+    Local<String> cons = v8_compile("cons")->Run().As<String>();
     CHECK_EQ(128, cons->Utf8Length());
     int nchars = -1;
     CHECK_EQ(129, cons->WriteUtf8(utf_buffer, -1, &nchars));
     CHECK_EQ(128, nchars);
     CHECK_EQ(0, strcmp(
         utf_buffer,
         "Now is the time for all good men to come to the aid of the party"
         "Now is the time for all good men to come to the aid of the party"));
 
     // Now do some stuff to make sure the strings are flattened, etc.
     CompileRun(
         "/[^a-z]/.test(cons);"
         "/[^a-z]/.test(slice);"
         "/[^a-z]/.test(slice_on_cons);");
     const char* expected_cons =
         "Now is the time for all good men to come to the aid of the party"
         "Now is the time for all good men to come to the aid of the party";
     const char* expected_slice =
         "ow is the time for all good men to come to the aid of the part";
     const char* expected_slice_on_cons =
         "ow is the time for all good men to come to the aid of the party"
         "Now is the time for all good men to come to the aid of the part";
-    CHECK(String::NewFromUtf8(env->GetIsolate(), expected_cons)
-              ->Equals(env->Global()->Get(v8_str("cons"))));
-    CHECK(String::NewFromUtf8(env->GetIsolate(), expected_slice)
-              ->Equals(env->Global()->Get(v8_str("slice"))));
-    CHECK(String::NewFromUtf8(env->GetIsolate(), expected_slice_on_cons)
+    CHECK(v8_str(expected_cons)->Equals(env->Global()->Get(v8_str("cons"))));
+    CHECK(v8_str(expected_slice)->Equals(env->Global()->Get(v8_str("slice"))));
+    CHECK(v8_str(expected_slice_on_cons)
               ->Equals(env->Global()->Get(v8_str("slice_on_cons"))));
   }
   i::DeleteArray(two_byte_string);
 }
 
 
 TEST(CompileExternalTwoByteSource) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
 
@@ skipping 93 matching lines @@
 }
 
 #endif  // V8_INTERPRETED_REGEXP
 
 
 // Test that we cannot set a property on the global object if there
 // is a read-only property in the prototype chain.
 TEST(ReadOnlyPropertyInGlobalProto) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::ObjectTemplate> templ = v8::ObjectTemplate::New(isolate);
+  v8::Local<v8::ObjectTemplate> templ = v8::ObjectTemplate::New(isolate);
   LocalContext context(0, templ);
-  v8::Handle<v8::Object> global = context->Global();
-  v8::Handle<v8::Object> global_proto =
-      v8::Handle<v8::Object>::Cast(global->Get(v8_str("__proto__")));
+  v8::Local<v8::Object> global = context->Global();
+  v8::Local<v8::Object> global_proto =
+      v8::Local<v8::Object>::Cast(global->Get(v8_str("__proto__")));
   global_proto->ForceSet(v8_str("x"), v8::Integer::New(isolate, 0),
                          v8::ReadOnly);
   global_proto->ForceSet(v8_str("y"), v8::Integer::New(isolate, 0),
                          v8::ReadOnly);
   // Check without 'eval' or 'with'.
-  v8::Handle<v8::Value> res =
+  v8::Local<v8::Value> res =
       CompileRun("function f() { x = 42; return x; }; f()");
   CHECK(v8::Integer::New(isolate, 0)->Equals(res));
   // Check with 'eval'.
   res = CompileRun("function f() { eval('1'); y = 43; return y; }; f()");
   CHECK(v8::Integer::New(isolate, 0)->Equals(res));
   // Check with 'with'.
   res = CompileRun("function f() { with (this) { y = 44 }; return y; }; f()");
   CHECK(v8::Integer::New(isolate, 0)->Equals(res));
 }
 
@@ skipping 30 matching lines @@
 }
 
 
 TEST(ForceSet) {
   force_set_get_count = 0;
   force_set_set_count = 0;
   pass_on_get = false;
 
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::ObjectTemplate> templ = v8::ObjectTemplate::New(isolate);
-  v8::Handle<v8::String> access_property =
-      v8::String::NewFromUtf8(isolate, "a");
+  v8::Local<v8::ObjectTemplate> templ = v8::ObjectTemplate::New(isolate);
+  v8::Local<v8::String> access_property = v8_str("a");
   templ->SetAccessor(access_property, ForceSetGetter, ForceSetSetter);
   LocalContext context(NULL, templ);
-  v8::Handle<v8::Object> global = context->Global();
+  v8::Local<v8::Object> global = context->Global();
 
   // Ordinary properties
-  v8::Handle<v8::String> simple_property =
-      v8::String::NewFromUtf8(isolate, "p");
+  v8::Local<v8::String> simple_property = v8_str("p");
   global->ForceSet(simple_property, v8::Int32::New(isolate, 4), v8::ReadOnly);
-  CHECK_EQ(4, global->Get(simple_property)->Int32Value());
+  CHECK_EQ(
+      4, global->Get(simple_property)->Int32Value(context.local()).FromJust());
   // This should fail because the property is read-only
   global->Set(simple_property, v8::Int32::New(isolate, 5));
-  CHECK_EQ(4, global->Get(simple_property)->Int32Value());
+  CHECK_EQ(
+      4, global->Get(simple_property)->Int32Value(context.local()).FromJust());
   // This should succeed even though the property is read-only
   global->ForceSet(simple_property, v8::Int32::New(isolate, 6));
-  CHECK_EQ(6, global->Get(simple_property)->Int32Value());
+  CHECK_EQ(
+      6, global->Get(simple_property)->Int32Value(context.local()).FromJust());
 
   // Accessors
   CHECK_EQ(0, force_set_set_count);
   CHECK_EQ(0, force_set_get_count);
-  CHECK_EQ(3, global->Get(access_property)->Int32Value());
+  CHECK_EQ(
+      3, global->Get(access_property)->Int32Value(context.local()).FromJust());
   // CHECK_EQ the property shouldn't override it, just call the setter
   // which in this case does nothing.
   global->Set(access_property, v8::Int32::New(isolate, 7));
-  CHECK_EQ(3, global->Get(access_property)->Int32Value());
+  CHECK_EQ(
+      3, global->Get(access_property)->Int32Value(context.local()).FromJust());
   CHECK_EQ(1, force_set_set_count);
   CHECK_EQ(2, force_set_get_count);
   // ForceSet doesn't call the accessors for now.
   // TODO(verwaest): Update once blink doesn't rely on ForceSet to delete api
   // accessors.
   global->ForceSet(access_property, v8::Int32::New(isolate, 8));
-  CHECK_EQ(8, global->Get(access_property)->Int32Value());
+  CHECK_EQ(
+      8, global->Get(access_property)->Int32Value(context.local()).FromJust());
   CHECK_EQ(1, force_set_set_count);
   CHECK_EQ(2, force_set_get_count);
 }
 
 
 TEST(ForceSetWithInterceptor) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::ObjectTemplate> templ = v8::ObjectTemplate::New(isolate);
+  v8::Local<v8::ObjectTemplate> templ = v8::ObjectTemplate::New(isolate);
   templ->SetHandler(v8::NamedPropertyHandlerConfiguration(
       ForceSetInterceptGetter, ForceSetInterceptSetter));
   pass_on_get = true;
   LocalContext context(NULL, templ);
-  v8::Handle<v8::Object> global = context->Global();
+  v8::Local<v8::Object> global = context->Global();
 
   force_set_get_count = 0;
   force_set_set_count = 0;
   pass_on_get = false;
 
-  v8::Handle<v8::String> some_property =
-      v8::String::NewFromUtf8(isolate, "a");
+  v8::Local<v8::String> some_property = v8_str("a");
   CHECK_EQ(0, force_set_set_count);
   CHECK_EQ(0, force_set_get_count);
-  CHECK_EQ(3, global->Get(some_property)->Int32Value());
+  CHECK_EQ(3,
+           global->Get(some_property)->Int32Value(context.local()).FromJust());
   // Setting the property shouldn't override it, just call the setter
   // which in this case does nothing.
   global->Set(some_property, v8::Int32::New(isolate, 7));
-  CHECK_EQ(3, global->Get(some_property)->Int32Value());
+  CHECK_EQ(3,
+           global->Get(some_property)->Int32Value(context.local()).FromJust());
   CHECK_EQ(1, force_set_set_count);
   CHECK_EQ(2, force_set_get_count);
   // Getting the property when the interceptor returns an empty handle
   // should yield undefined, since the property isn't present on the
   // object itself yet.
   pass_on_get = true;
   CHECK(global->Get(some_property)->IsUndefined());
   CHECK_EQ(1, force_set_set_count);
   CHECK_EQ(3, force_set_get_count);
   // Forcing the property to be set should cause the value to be
   // set locally without calling the interceptor.
   global->ForceSet(some_property, v8::Int32::New(isolate, 8));
-  CHECK_EQ(8, global->Get(some_property)->Int32Value());
+  CHECK_EQ(8,
+           global->Get(some_property)->Int32Value(context.local()).FromJust());
   CHECK_EQ(1, force_set_set_count);
   CHECK_EQ(4, force_set_get_count);
   // Reenabling the interceptor should cause it to take precedence over
   // the property
   pass_on_get = false;
-  CHECK_EQ(3, global->Get(some_property)->Int32Value());
+  CHECK_EQ(3,
+           global->Get(some_property)->Int32Value(context.local()).FromJust());
   CHECK_EQ(1, force_set_set_count);
   CHECK_EQ(5, force_set_get_count);
   // The interceptor should also work for other properties
-  CHECK_EQ(3, global->Get(v8::String::NewFromUtf8(isolate, "b"))
-                  ->Int32Value());
+  CHECK_EQ(3, global->Get(v8_str("b"))->Int32Value(context.local()).FromJust());
   CHECK_EQ(1, force_set_set_count);
   CHECK_EQ(6, force_set_get_count);
 }
 
 
 TEST(CreateDataProperty) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
@@ skipping 226 matching lines @@
 }
 
 
 // Check that a variable declaration with no explicit initialization
 // value does shadow an existing property in the prototype chain.
 THREADED_TEST(InitGlobalVarInProtoChain) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   // Introduce a variable in the prototype chain.
   CompileRun("__proto__.x = 42");
-  v8::Handle<v8::Value> result = CompileRun("var x = 43; x");
+  v8::Local<v8::Value> result = CompileRun("var x = 43; x");
   CHECK(!result->IsUndefined());
-  CHECK_EQ(43, result->Int32Value());
+  CHECK_EQ(43, result->Int32Value(context.local()).FromJust());
 }
 
 
 // Regression test for issue 398.
 // If a function is added to an object, creating a constant function
 // field, and the result is cloned, replacing the constant function on the
 // original should not affect the clone.
 // See http://code.google.com/p/v8/issues/detail?id=398
 THREADED_TEST(ReplaceConstantFunction) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::Object> obj = v8::Object::New(isolate);
-  v8::Handle<v8::FunctionTemplate> func_templ =
+  v8::Local<v8::Object> obj = v8::Object::New(isolate);
+  v8::Local<v8::FunctionTemplate> func_templ =
       v8::FunctionTemplate::New(isolate);
-  v8::Handle<v8::String> foo_string =
-      v8::String::NewFromUtf8(isolate, "foo");
-  obj->Set(foo_string, func_templ->GetFunction());
-  v8::Handle<v8::Object> obj_clone = obj->Clone();
-  obj_clone->Set(foo_string,
-                 v8::String::NewFromUtf8(isolate, "Hello"));
+  v8::Local<v8::String> foo_string = v8_str("foo");
+  obj->Set(foo_string,
+           func_templ->GetFunction(context.local()).ToLocalChecked());
+  v8::Local<v8::Object> obj_clone = obj->Clone();
+  obj_clone->Set(foo_string, v8_str("Hello"));
   CHECK(!obj->Get(foo_string)->IsUndefined());
 }
 
 
 static void CheckElementValue(i::Isolate* isolate,
                               int expected,
                               i::Handle<i::Object> obj,
                               int offset) {
   i::Object* element =
       *i::Object::GetElement(isolate, obj, offset).ToHandleChecked();
   CHECK_EQ(expected, i::Smi::cast(element)->value());
 }
 
 
 template <class ExternalArrayClass, class ElementType>
-static void ObjectWithExternalArrayTestHelper(Handle<Context> context,
-                                              v8::Handle<Object> obj,
+static void ObjectWithExternalArrayTestHelper(Local<Context> context,
+                                              v8::Local<Object> obj,
                                               int element_count,
                                               i::ExternalArrayType array_type,
                                               int64_t low, int64_t high) {
   i::Handle<i::JSReceiver> jsobj = v8::Utils::OpenHandle(*obj);
   i::Isolate* isolate = jsobj->GetIsolate();
   obj->Set(v8_str("field"),
            v8::Int32::New(reinterpret_cast<v8::Isolate*>(isolate), 1503));
-  context->Global()->Set(v8_str("ext_array"), obj);
-  v8::Handle<v8::Value> result = CompileRun("ext_array.field");
-  CHECK_EQ(1503, result->Int32Value());
+  CHECK(context->Global()->Set(context, v8_str("ext_array"), obj).FromJust());
+  v8::Local<v8::Value> result = CompileRun("ext_array.field");
+  CHECK_EQ(1503, result->Int32Value(context).FromJust());
   result = CompileRun("ext_array[1]");
-  CHECK_EQ(1, result->Int32Value());
+  CHECK_EQ(1, result->Int32Value(context).FromJust());
 
   // Check assigned smis
   result = CompileRun("for (var i = 0; i < 8; i++) {"
                       "  ext_array[i] = i;"
                       "}"
                       "var sum = 0;"
                       "for (var i = 0; i < 8; i++) {"
                       "  sum += ext_array[i];"
                       "}"
                       "sum;");
 
-  CHECK_EQ(28, result->Int32Value());
+  CHECK_EQ(28, result->Int32Value(context).FromJust());
   // Check pass through of assigned smis
   result = CompileRun("var sum = 0;"
                       "for (var i = 0; i < 8; i++) {"
                       "  sum += ext_array[i] = ext_array[i] = -i;"
                       "}"
                       "sum;");
-  CHECK_EQ(-28, result->Int32Value());
+  CHECK_EQ(-28, result->Int32Value(context).FromJust());
 
 
   // Check assigned smis in reverse order
   result = CompileRun("for (var i = 8; --i >= 0; ) {"
                       "  ext_array[i] = i;"
                       "}"
                       "var sum = 0;"
                       "for (var i = 0; i < 8; i++) {"
                       "  sum += ext_array[i];"
                       "}"
                       "sum;");
-  CHECK_EQ(28, result->Int32Value());
+  CHECK_EQ(28, result->Int32Value(context).FromJust());
 
   // Check pass through of assigned HeapNumbers
   result = CompileRun("var sum = 0;"
                       "for (var i = 0; i < 16; i+=2) {"
                       "  sum += ext_array[i] = ext_array[i] = (-i * 0.5);"
                       "}"
                       "sum;");
-  CHECK_EQ(-28, result->Int32Value());
+  CHECK_EQ(-28, result->Int32Value(context).FromJust());
 
   // Check assigned HeapNumbers
   result = CompileRun("for (var i = 0; i < 16; i+=2) {"
                       "  ext_array[i] = (i * 0.5);"
                       "}"
                       "var sum = 0;"
                       "for (var i = 0; i < 16; i+=2) {"
                       "  sum += ext_array[i];"
                       "}"
                       "sum;");
-  CHECK_EQ(28, result->Int32Value());
+  CHECK_EQ(28, result->Int32Value(context).FromJust());
 
   // Check assigned HeapNumbers in reverse order
   result = CompileRun("for (var i = 14; i >= 0; i-=2) {"
                       "  ext_array[i] = (i * 0.5);"
                       "}"
                       "var sum = 0;"
                       "for (var i = 0; i < 16; i+=2) {"
                       "  sum += ext_array[i];"
                       "}"
                       "sum;");
-  CHECK_EQ(28, result->Int32Value());
+  CHECK_EQ(28, result->Int32Value(context).FromJust());
 
   i::ScopedVector<char> test_buf(1024);
 
   // Check legal boundary conditions.
   // The repeated loads and stores ensure the ICs are exercised.
   const char* boundary_program =
       "var res = 0;"
       "for (var i = 0; i < 16; i++) {"
       "  ext_array[i] = %lld;"
       "  if (i > 8) {"
@@ skipping 19 matching lines @@
                       "for (var i = 0; i < 8; i++) {"
                       "  tmp_array[i] = i;"
                       "  sum += tmp_array[i];"
                       "  if (i == 4) {"
                       "    tmp_array = {};"
                       "  }"
                       "}"
                       "sum;");
   // Force GC to trigger verification.
   CcTest::heap()->CollectAllGarbage();
-  CHECK_EQ(28, result->Int32Value());
+  CHECK_EQ(28, result->Int32Value(context).FromJust());
 
   // Make sure out-of-range loads do not throw.
   i::SNPrintF(test_buf,
               "var caught_exception = false;"
               "try {"
               "  ext_array[%d];"
               "} catch (e) {"
               "  caught_exception = true;"
               "}"
               "caught_exception;",
@@ skipping 12 matching lines @@
               "caught_exception;",
               element_count);
   result = CompileRun(test_buf.start());
   CHECK_EQ(false, result->BooleanValue());
 
   // Check other boundary conditions, values and operations.
   result = CompileRun("for (var i = 0; i < 8; i++) {"
                       "  ext_array[7] = undefined;"
                       "}"
                       "ext_array[7];");
-  CHECK_EQ(0, result->Int32Value());
+  CHECK_EQ(0, result->Int32Value(context).FromJust());
   if (array_type == i::kExternalFloat64Array ||
       array_type == i::kExternalFloat32Array) {
     CHECK(std::isnan(
         i::Object::GetElement(isolate, jsobj, 7).ToHandleChecked()->Number()));
   } else {
     CheckElementValue(isolate, 0, jsobj, 7);
   }
 
   result = CompileRun("for (var i = 0; i < 8; i++) {"
                       "  ext_array[6] = '2.3';"
                       "}"
                       "ext_array[6];");
-  CHECK_EQ(2, result->Int32Value());
+  CHECK_EQ(2, result->Int32Value(context).FromJust());
   CHECK_EQ(2,
            static_cast<int>(
                i::Object::GetElement(
                    isolate, jsobj, 6).ToHandleChecked()->Number()));
 
   if (array_type != i::kExternalFloat32Array &&
       array_type != i::kExternalFloat64Array) {
     // Though the specification doesn't state it, be explicit about
     // converting NaNs and +/-Infinity to zero.
     result = CompileRun("for (var i = 0; i < 8; i++) {"
                         "  ext_array[i] = 5;"
                         "}"
                         "for (var i = 0; i < 8; i++) {"
                         "  ext_array[i] = NaN;"
                         "}"
                         "ext_array[5];");
-    CHECK_EQ(0, result->Int32Value());
+    CHECK_EQ(0, result->Int32Value(context).FromJust());
     CheckElementValue(isolate, 0, jsobj, 5);
 
     result = CompileRun("for (var i = 0; i < 8; i++) {"
                         "  ext_array[i] = 5;"
                         "}"
                         "for (var i = 0; i < 8; i++) {"
                         "  ext_array[i] = Infinity;"
                         "}"
                         "ext_array[5];");
     int expected_value =
         (array_type == i::kExternalUint8ClampedArray) ? 255 : 0;
-    CHECK_EQ(expected_value, result->Int32Value());
+    CHECK_EQ(expected_value, result->Int32Value(context).FromJust());
     CheckElementValue(isolate, expected_value, jsobj, 5);
 
     result = CompileRun("for (var i = 0; i < 8; i++) {"
                         "  ext_array[i] = 5;"
                         "}"
                         "for (var i = 0; i < 8; i++) {"
                         "  ext_array[i] = -Infinity;"
                         "}"
                         "ext_array[5];");
-    CHECK_EQ(0, result->Int32Value());
+    CHECK_EQ(0, result->Int32Value(context).FromJust());
     CheckElementValue(isolate, 0, jsobj, 5);
 
     // Check truncation behavior of integral arrays.
     const char* unsigned_data =
         "var source_data = [0.6, 10.6];"
         "var expected_results = [0, 10];";
     const char* signed_data =
         "var source_data = [0.6, 10.6, -0.6, -10.6];"
         "var expected_results = [0, 10, 0, -10];";
     const char* pixel_data =
@@ skipping 34 matching lines @@
                       "   sum += (ext_array[i] += 1);"
                       "   sum += (ext_array[i] -= 1);"
                       " } "
                       " return sum;"
                       "}"
                       "sum=0;"
                       "for (var i=0;i<10000;++i) {"
                       "  sum=ee_op_test_complex_func(sum);"
                       "}"
                       "sum;");
-  CHECK_EQ(16000000, result->Int32Value());
+  CHECK_EQ(16000000, result->Int32Value(context).FromJust());
 
   // Test count operations
   result = CompileRun("function ee_op_test_count_func(sum) {"
                       " for (var i = 0; i < 40; ++i) {"
                       "   sum += (++ext_array[i]);"
                       "   sum += (--ext_array[i]);"
                       " } "
                       " return sum;"
                       "}"
                       "sum=0;"
                       "for (var i=0;i<10000;++i) {"
                       "  sum=ee_op_test_count_func(sum);"
                       "}"
                       "sum;");
-  CHECK_EQ(16000000, result->Int32Value());
+  CHECK_EQ(16000000, result->Int32Value(context).FromJust());
 
   result = CompileRun("ext_array[3] = 33;"
                       "delete ext_array[3];"
                       "ext_array[3];");
-  CHECK_EQ(33, result->Int32Value());
+  CHECK_EQ(33, result->Int32Value(context).FromJust());
 
   result = CompileRun("ext_array[0] = 10; ext_array[1] = 11;"
                       "ext_array[2] = 12; ext_array[3] = 13;"
                       "ext_array.__defineGetter__('2',"
                       "function() { return 120; });"
                       "ext_array[2];");
-  CHECK_EQ(12, result->Int32Value());
+  CHECK_EQ(12, result->Int32Value(context).FromJust());
 
   result = CompileRun("var js_array = new Array(40);"
                       "js_array[0] = 77;"
                       "js_array;");
-  CHECK_EQ(77, v8::Object::Cast(*result)->Get(v8_str("0"))->Int32Value());
+  CHECK_EQ(77, v8::Object::Cast(*result)
+                   ->Get(v8_str("0"))
+                   ->Int32Value(context)
+                   .FromJust());
 
   result = CompileRun("ext_array[1] = 23;"
                       "ext_array.__proto__ = [];"
                       "js_array.__proto__ = ext_array;"
                       "js_array.concat(ext_array);");
-  CHECK_EQ(77, v8::Object::Cast(*result)->Get(v8_str("0"))->Int32Value());
-  CHECK_EQ(23, v8::Object::Cast(*result)->Get(v8_str("1"))->Int32Value());
+  CHECK_EQ(77, v8::Object::Cast(*result)
+                   ->Get(v8_str("0"))
+                   ->Int32Value(context)
+                   .FromJust());
+  CHECK_EQ(23, v8::Object::Cast(*result)
+                   ->Get(v8_str("1"))
+                   ->Int32Value(context)
+                   .FromJust());
 
   result = CompileRun("ext_array[1] = 23;");
-  CHECK_EQ(23, result->Int32Value());
+  CHECK_EQ(23, result->Int32Value(context).FromJust());
 }
 
 
 template <class FixedTypedArrayClass, i::ElementsKind elements_kind,
           class ElementType>
 static void FixedTypedArrayTestHelper(i::ExternalArrayType array_type,
                                       ElementType low, ElementType high) {
   i::FLAG_allow_natives_syntax = true;
   LocalContext context;
   i::Isolate* isolate = CcTest::i_isolate();
@@ skipping 10 matching lines @@
   CcTest::heap()->CollectAllGarbage();
   for (int i = 0; i < kElementCount; i++) {
     fixed_array->set(i, static_cast<ElementType>(i));
   }
   // Force GC to trigger verification.
   CcTest::heap()->CollectAllGarbage();
   for (int i = 0; i < kElementCount; i++) {
     CHECK_EQ(static_cast<int64_t>(static_cast<ElementType>(i)),
              static_cast<int64_t>(fixed_array->get_scalar(i)));
   }
-  v8::Handle<v8::Object> obj = v8::Utils::ToLocal(jsobj);
+  v8::Local<v8::Object> obj = v8::Utils::ToLocal(jsobj);
 
   ObjectWithExternalArrayTestHelper<FixedTypedArrayClass, ElementType>(
       context.local(), obj, kElementCount, array_type,
       static_cast<int64_t>(low),
       static_cast<int64_t>(high));
 }
 
 
 THREADED_TEST(FixedUint8Array) {
   FixedTypedArrayTestHelper<i::FixedUint8Array, i::UINT8_ELEMENTS, uint8_t>(
@@ skipping 292 matching lines @@
       v8::SharedArrayBuffer::New(isolate, backing_store.start(), 2 + kSize);
   Local<v8::DataView> dv =
       v8::DataView::New(ab, 2, kSize);
   CheckInternalFieldsAreZero<v8::ArrayBufferView>(dv);
   CHECK_EQ(2u, dv->ByteOffset());
   CHECK_EQ(kSize, static_cast<int>(dv->ByteLength()));
   CHECK(ab->Equals(dv->Buffer()));
 }
 
 
-#define IS_ARRAY_BUFFER_VIEW_TEST(View)                                       \
-  THREADED_TEST(Is##View) {                                                   \
-    LocalContext env;                                                         \
-    v8::Isolate* isolate = env->GetIsolate();                                 \
-    v8::HandleScope handle_scope(isolate);                                    \
-                                                                              \
-    Handle<Value> result = CompileRun(                                        \
-        "var ab = new ArrayBuffer(128);"                                      \
-        "new " #View "(ab)");                                                 \
-    CHECK(result->IsArrayBufferView());                                       \
-    CHECK(result->Is##View());                                                \
-    CheckInternalFieldsAreZero<v8::ArrayBufferView>(result.As<v8::View>());   \
+#define IS_ARRAY_BUFFER_VIEW_TEST(View)                                     \
+  THREADED_TEST(Is##View) {                                                 \
+    LocalContext env;                                                       \
+    v8::Isolate* isolate = env->GetIsolate();                               \
+    v8::HandleScope handle_scope(isolate);                                  \
+                                                                            \
+    Local<Value> result = CompileRun(                                       \
+        "var ab = new ArrayBuffer(128);"                                    \
+        "new " #View "(ab)");                                               \
+    CHECK(result->IsArrayBufferView());                                     \
+    CHECK(result->Is##View());                                              \
+    CheckInternalFieldsAreZero<v8::ArrayBufferView>(result.As<v8::View>()); \
   }
 
 IS_ARRAY_BUFFER_VIEW_TEST(Uint8Array)
 IS_ARRAY_BUFFER_VIEW_TEST(Int8Array)
 IS_ARRAY_BUFFER_VIEW_TEST(Uint16Array)
 IS_ARRAY_BUFFER_VIEW_TEST(Int16Array)
 IS_ARRAY_BUFFER_VIEW_TEST(Uint32Array)
 IS_ARRAY_BUFFER_VIEW_TEST(Int32Array)
 IS_ARRAY_BUFFER_VIEW_TEST(Float32Array)
 IS_ARRAY_BUFFER_VIEW_TEST(Float64Array)
 IS_ARRAY_BUFFER_VIEW_TEST(Uint8ClampedArray)
 IS_ARRAY_BUFFER_VIEW_TEST(DataView)
 
 #undef IS_ARRAY_BUFFER_VIEW_TEST
 
 
 
 THREADED_TEST(ScriptContextDependence) {
   LocalContext c1;
   v8::HandleScope scope(c1->GetIsolate());
   const char *source = "foo";
-  v8::Handle<v8::Script> dep = v8_compile(source);
-  v8::ScriptCompiler::Source script_source(v8::String::NewFromUtf8(
-      c1->GetIsolate(), source));
-  v8::Handle<v8::UnboundScript> indep =
+  v8::Local<v8::Script> dep = v8_compile(source);
+  v8::ScriptCompiler::Source script_source(
+      v8::String::NewFromUtf8(c1->GetIsolate(), source,
+                              v8::NewStringType::kNormal)
+          .ToLocalChecked());
+  v8::Local<v8::UnboundScript> indep =
       v8::ScriptCompiler::CompileUnbound(c1->GetIsolate(), &script_source);
-  c1->Global()->Set(v8::String::NewFromUtf8(c1->GetIsolate(), "foo"),
+  c1->Global()->Set(v8::String::NewFromUtf8(c1->GetIsolate(), "foo",
+                                            v8::NewStringType::kNormal)
+                        .ToLocalChecked(),
                     v8::Integer::New(c1->GetIsolate(), 100));
-  CHECK_EQ(dep->Run()->Int32Value(), 100);
-  CHECK_EQ(indep->BindToCurrentContext()->Run()->Int32Value(), 100);
+  CHECK_EQ(dep->Run()->Int32Value(c1.local()).FromJust(), 100);
+  CHECK_EQ(
+      indep->BindToCurrentContext()->Run()->Int32Value(c1.local()).FromJust(),
+      100);
   LocalContext c2;
-  c2->Global()->Set(v8::String::NewFromUtf8(c2->GetIsolate(), "foo"),
+  c2->Global()->Set(v8::String::NewFromUtf8(c2->GetIsolate(), "foo",
+                                            v8::NewStringType::kNormal)
+                        .ToLocalChecked(),
                     v8::Integer::New(c2->GetIsolate(), 101));
-  CHECK_EQ(dep->Run()->Int32Value(), 100);
-  CHECK_EQ(indep->BindToCurrentContext()->Run()->Int32Value(), 101);
+  CHECK_EQ(dep->Run()->Int32Value(c2.local()).FromJust(), 100);
+  CHECK_EQ(
+      indep->BindToCurrentContext()->Run()->Int32Value(c2.local()).FromJust(),
+      101);
 }
 
 
 THREADED_TEST(StackTrace) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   v8::TryCatch try_catch(context->GetIsolate());
   const char *source = "function foo() { FAIL.FAIL; }; foo();";
-  v8::Handle<v8::String> src =
-      v8::String::NewFromUtf8(context->GetIsolate(), source);
-  v8::Handle<v8::String> origin =
-      v8::String::NewFromUtf8(context->GetIsolate(), "stack-trace-test");
+  v8::Local<v8::String> src = v8_str(source);
+  v8::Local<v8::String> origin = v8_str("stack-trace-test");
   v8::ScriptCompiler::Source script_source(src, v8::ScriptOrigin(origin));
   v8::ScriptCompiler::CompileUnbound(context->GetIsolate(), &script_source)
       ->BindToCurrentContext()
       ->Run();
   CHECK(try_catch.HasCaught());
   v8::String::Utf8Value stack(try_catch.StackTrace());
   CHECK(strstr(*stack, "at foo (stack-trace-test") != NULL);
 }
 
 
 // Checks that a StackFrame has certain expected values.
 void checkStackFrame(const char* expected_script_name,
-    const char* expected_func_name, int expected_line_number,
-    int expected_column, bool is_eval, bool is_constructor,
-    v8::Handle<v8::StackFrame> frame) {
+                     const char* expected_func_name, int expected_line_number,
+                     int expected_column, bool is_eval, bool is_constructor,
+                     v8::Local<v8::StackFrame> frame) {
   v8::HandleScope scope(CcTest::isolate());
   v8::String::Utf8Value func_name(frame->GetFunctionName());
   v8::String::Utf8Value script_name(frame->GetScriptName());
   if (*script_name == NULL) {
     // The situation where there is no associated script, like for evals.
     CHECK(expected_script_name == NULL);
   } else {
     CHECK(strstr(*script_name, expected_script_name) != NULL);
   }
   CHECK(strstr(*func_name, expected_func_name) != NULL);
@@ skipping 10 matching lines @@
   const int kOverviewTest = 1;
   const int kDetailedTest = 2;
   const int kFunctionName = 3;
   const int kDisplayName = 4;
   const int kFunctionNameAndDisplayName = 5;
   const int kDisplayNameIsNotString = 6;
   const int kFunctionNameIsNotString = 7;
 
   DCHECK(args.Length() == 1);
 
-  int testGroup = args[0]->Int32Value();
+  v8::Local<v8::Context> context = args.GetIsolate()->GetCurrentContext();
+  int testGroup = args[0]->Int32Value(context).FromJust();
   if (testGroup == kOverviewTest) {
-    v8::Handle<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(
+    v8::Local<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(
         args.GetIsolate(), 10, v8::StackTrace::kOverview);
     CHECK_EQ(4, stackTrace->GetFrameCount());
     checkStackFrame(origin, "bar", 2, 10, false, false,
                     stackTrace->GetFrame(0));
     checkStackFrame(origin, "foo", 6, 3, false, false,
                     stackTrace->GetFrame(1));
     // This is the source string inside the eval which has the call to foo.
     checkStackFrame(NULL, "", 1, 1, false, false, stackTrace->GetFrame(2));
     // The last frame is an anonymous function which has the initial eval call.
     checkStackFrame(origin, "", 8, 7, false, false, stackTrace->GetFrame(3));
 
     CHECK(stackTrace->AsArray()->IsArray());
   } else if (testGroup == kDetailedTest) {
-    v8::Handle<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(
+    v8::Local<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(
         args.GetIsolate(), 10, v8::StackTrace::kDetailed);
     CHECK_EQ(4, stackTrace->GetFrameCount());
     checkStackFrame(origin, "bat", 4, 22, false, false,
                     stackTrace->GetFrame(0));
     checkStackFrame(origin, "baz", 8, 3, false, true,
                     stackTrace->GetFrame(1));
     bool is_eval = true;
     // This is the source string inside the eval which has the call to baz.
     checkStackFrame(NULL, "", 1, 1, is_eval, false, stackTrace->GetFrame(2));
     // The last frame is an anonymous function which has the initial eval call.
@@ skipping 32 matching lines @@
   }
 }
 
 
 // Tests the C++ StackTrace API.
 // TODO(3074796): Reenable this as a THREADED_TEST once it passes.
 // THREADED_TEST(CaptureStackTrace) {
 TEST(CaptureStackTrace) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::String> origin =
-      v8::String::NewFromUtf8(isolate, "capture-stack-trace-test");
+  v8::Local<v8::String> origin = v8_str("capture-stack-trace-test");
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->Set(v8_str("AnalyzeStackInNativeCode"),
              v8::FunctionTemplate::New(isolate, AnalyzeStackInNativeCode));
   LocalContext context(0, templ);
 
   // Test getting OVERVIEW information. Should ignore information that is not
   // script name, function name, line number, and column offset.
   const char *overview_source =
     "function bar() {\n"
     "  var y; AnalyzeStackInNativeCode(1);\n"
     "}\n"
     "function foo() {\n"
     "\n"
     "  bar();\n"
     "}\n"
     "var x;eval('new foo();');";
-  v8::Handle<v8::String> overview_src =
-      v8::String::NewFromUtf8(isolate, overview_source);
+  v8::Local<v8::String> overview_src = v8_str(overview_source);
   v8::ScriptCompiler::Source script_source(overview_src,
                                            v8::ScriptOrigin(origin));
-  v8::Handle<Value> overview_result(
+  v8::Local<Value> overview_result(
       v8::ScriptCompiler::CompileUnbound(isolate, &script_source)
           ->BindToCurrentContext()
           ->Run());
   CHECK(!overview_result.IsEmpty());
   CHECK(overview_result->IsObject());
 
   // Test getting DETAILED information.
   const char *detailed_source =
     "function bat() {AnalyzeStackInNativeCode(2);\n"
     "}\n"
     "\n"
     "function baz() {\n"
     "  bat();\n"
     "}\n"
     "eval('new baz();');";
-  v8::Handle<v8::String> detailed_src =
-      v8::String::NewFromUtf8(isolate, detailed_source);
+  v8::Local<v8::String> detailed_src = v8_str(detailed_source);
   // Make the script using a non-zero line and column offset.
-  v8::Handle<v8::Integer> line_offset = v8::Integer::New(isolate, 3);
-  v8::Handle<v8::Integer> column_offset = v8::Integer::New(isolate, 5);
+  v8::Local<v8::Integer> line_offset = v8::Integer::New(isolate, 3);
+  v8::Local<v8::Integer> column_offset = v8::Integer::New(isolate, 5);
   v8::ScriptOrigin detailed_origin(origin, line_offset, column_offset);
   v8::ScriptCompiler::Source script_source2(detailed_src, detailed_origin);
-  v8::Handle<v8::UnboundScript> detailed_script(
+  v8::Local<v8::UnboundScript> detailed_script(
       v8::ScriptCompiler::CompileUnbound(isolate, &script_source2));
-  v8::Handle<Value> detailed_result(
+  v8::Local<Value> detailed_result(
       detailed_script->BindToCurrentContext()->Run());
   CHECK(!detailed_result.IsEmpty());
   CHECK(detailed_result->IsObject());
 
   // Test using function.name and function.displayName in stack trace
   const char* function_name_source =
       "function bar(function_name, display_name, testGroup) {\n"
       "  var f = function() { AnalyzeStackInNativeCode(testGroup); };\n"
       "  if (function_name) {\n"
       "    Object.defineProperty(f, 'name', { value: function_name });\n"
@@ skipping 14 matching lines @@
                                             v8::ScriptOrigin(origin));
   v8::Handle<Value> function_name_result(
       v8::ScriptCompiler::CompileUnbound(isolate, &script_source3)
           ->BindToCurrentContext()
           ->Run());
   CHECK(!function_name_result.IsEmpty());
 }
 
 
 static void StackTraceForUncaughtExceptionListener(
-    v8::Handle<v8::Message> message,
-    v8::Handle<Value>) {
+    v8::Local<v8::Message> message, v8::Local<Value>) {
   report_count++;
-  v8::Handle<v8::StackTrace> stack_trace = message->GetStackTrace();
+  v8::Local<v8::StackTrace> stack_trace = message->GetStackTrace();
   CHECK_EQ(2, stack_trace->GetFrameCount());
   checkStackFrame("origin", "foo", 2, 3, false, false,
                   stack_trace->GetFrame(0));
   checkStackFrame("origin", "bar", 5, 3, false, false,
                   stack_trace->GetFrame(1));
 }
 
 
 TEST(CaptureStackTraceForUncaughtException) {
   report_count = 0;
@@ skipping 64 matching lines @@
       "    'isConstructor'];\n"
       "for (var i = 0; i < setters.length; i++) {\n"
       "  var prop = setters[i];\n"
       "  Object.prototype.__defineSetter__(prop, function() { throw prop; });\n"
       "}\n");
   CompileRun("throw 'exception';");
   v8::V8::SetCaptureStackTraceForUncaughtExceptions(false);
 }
 
 
-static void StackTraceFunctionNameListener(v8::Handle<v8::Message> message,
-                                           v8::Handle<Value>) {
-  v8::Handle<v8::StackTrace> stack_trace = message->GetStackTrace();
+static void StackTraceFunctionNameListener(v8::Local<v8::Message> message,
+                                           v8::Local<Value>) {
+  v8::Local<v8::StackTrace> stack_trace = message->GetStackTrace();
   CHECK_EQ(5, stack_trace->GetFrameCount());
   checkStackFrame("origin", "foo:0", 4, 7, false, false,
                   stack_trace->GetFrame(0));
   checkStackFrame("origin", "foo:1", 5, 27, false, false,
                   stack_trace->GetFrame(1));
   checkStackFrame("origin", "foo", 5, 27, false, false,
                   stack_trace->GetFrame(2));
   checkStackFrame("origin", "foo", 5, 27, false, false,
                   stack_trace->GetFrame(3));
   checkStackFrame("origin", "", 1, 14, false, false, stack_trace->GetFrame(4));
@@ skipping 25 matching lines @@
       "origin");
 
   v8::V8::AddMessageListener(StackTraceFunctionNameListener);
   v8::V8::SetCaptureStackTraceForUncaughtExceptions(true);
   CompileRunWithOrigin("gen('foo', 3)();", "origin");
   v8::V8::SetCaptureStackTraceForUncaughtExceptions(false);
   v8::V8::RemoveMessageListeners(StackTraceFunctionNameListener);
 }
 
 
-static void RethrowStackTraceHandler(v8::Handle<v8::Message> message,
-                                     v8::Handle<v8::Value> data) {
+static void RethrowStackTraceHandler(v8::Local<v8::Message> message,
+                                     v8::Local<v8::Value> data) {
   // Use the frame where JavaScript is called from.
-  v8::Handle<v8::StackTrace> stack_trace = message->GetStackTrace();
+  v8::Local<v8::StackTrace> stack_trace = message->GetStackTrace();
   CHECK(!stack_trace.IsEmpty());
   int frame_count = stack_trace->GetFrameCount();
   CHECK_EQ(3, frame_count);
   int line_number[] = {1, 2, 5};
   for (int i = 0; i < frame_count; i++) {
     CHECK_EQ(line_number[i], stack_trace->GetFrame(i)->GetLineNumber());
   }
 }
 
 
@@ skipping 20 matching lines @@
       "  }                              \n"
       "}                                \n";
   v8::V8::AddMessageListener(RethrowStackTraceHandler);
   v8::V8::SetCaptureStackTraceForUncaughtExceptions(true);
   CompileRun(source);
   v8::V8::SetCaptureStackTraceForUncaughtExceptions(false);
   v8::V8::RemoveMessageListeners(RethrowStackTraceHandler);
 }
 
 
-static void RethrowPrimitiveStackTraceHandler(v8::Handle<v8::Message> message,
-                                              v8::Handle<v8::Value> data) {
-  v8::Handle<v8::StackTrace> stack_trace = message->GetStackTrace();
+static void RethrowPrimitiveStackTraceHandler(v8::Local<v8::Message> message,
+                                              v8::Local<v8::Value> data) {
+  v8::Local<v8::StackTrace> stack_trace = message->GetStackTrace();
   CHECK(!stack_trace.IsEmpty());
   int frame_count = stack_trace->GetFrameCount();
   CHECK_EQ(2, frame_count);
   int line_number[] = {3, 7};
   for (int i = 0; i < frame_count; i++) {
     CHECK_EQ(line_number[i], stack_trace->GetFrame(i)->GetLineNumber());
   }
 }
 
 
@@ skipping 13 matching lines @@
       "  t(e1)                          \n"
       "}                                \n";
   v8::V8::AddMessageListener(RethrowPrimitiveStackTraceHandler);
   v8::V8::SetCaptureStackTraceForUncaughtExceptions(true);
   CompileRun(source);
   v8::V8::SetCaptureStackTraceForUncaughtExceptions(false);
   v8::V8::RemoveMessageListeners(RethrowPrimitiveStackTraceHandler);
 }
 
 
-static void RethrowExistingStackTraceHandler(v8::Handle<v8::Message> message,
-                                              v8::Handle<v8::Value> data) {
+static void RethrowExistingStackTraceHandler(v8::Local<v8::Message> message,
+                                             v8::Local<v8::Value> data) {
   // Use the frame where JavaScript is called from.
-  v8::Handle<v8::StackTrace> stack_trace = message->GetStackTrace();
+  v8::Local<v8::StackTrace> stack_trace = message->GetStackTrace();
   CHECK(!stack_trace.IsEmpty());
   CHECK_EQ(1, stack_trace->GetFrameCount());
   CHECK_EQ(1, stack_trace->GetFrame(0)->GetLineNumber());
 }
 
 
 // Test that the stack trace is captured when the error object is created and
 // not where it is thrown.
 TEST(RethrowExistingStackTrace) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   const char* source =
       "var e = new Error();           \n"
       "throw e;                       \n";
   v8::V8::AddMessageListener(RethrowExistingStackTraceHandler);
   v8::V8::SetCaptureStackTraceForUncaughtExceptions(true);
   CompileRun(source);
   v8::V8::SetCaptureStackTraceForUncaughtExceptions(false);
   v8::V8::RemoveMessageListeners(RethrowExistingStackTraceHandler);
 }
 
 
-static void RethrowBogusErrorStackTraceHandler(v8::Handle<v8::Message> message,
-                                               v8::Handle<v8::Value> data) {
+static void RethrowBogusErrorStackTraceHandler(v8::Local<v8::Message> message,
+                                               v8::Local<v8::Value> data) {
   // Use the frame where JavaScript is called from.
-  v8::Handle<v8::StackTrace> stack_trace = message->GetStackTrace();
+  v8::Local<v8::StackTrace> stack_trace = message->GetStackTrace();
   CHECK(!stack_trace.IsEmpty());
   CHECK_EQ(1, stack_trace->GetFrameCount());
   CHECK_EQ(2, stack_trace->GetFrame(0)->GetLineNumber());
 }
 
 
 // Test that the stack trace is captured where the bogus Error object is thrown.
 TEST(RethrowBogusErrorStackTrace) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
@@ skipping 15 matching lines @@
 int promise_reject_msg_column_number = -1;
 int promise_reject_line_number = -1;
 int promise_reject_column_number = -1;
 int promise_reject_frame_count = -1;
 
 void PromiseRejectCallback(v8::PromiseRejectMessage reject_message) {
   if (reject_message.GetEvent() == v8::kPromiseRejectWithNoHandler) {
     promise_reject_counter++;
     CcTest::global()->Set(v8_str("rejected"), reject_message.GetPromise());
     CcTest::global()->Set(v8_str("value"), reject_message.GetValue());
-    v8::Handle<v8::Message> message =
+    v8::Local<v8::Message> message =
         v8::Exception::CreateMessage(reject_message.GetValue());
-    v8::Handle<v8::StackTrace> stack_trace = message->GetStackTrace();
+    v8::Local<v8::StackTrace> stack_trace = message->GetStackTrace();
 
     promise_reject_msg_line_number = message->GetLineNumber();
     promise_reject_msg_column_number = message->GetStartColumn() + 1;
 
     if (!stack_trace.IsEmpty()) {
       promise_reject_frame_count = stack_trace->GetFrameCount();
       if (promise_reject_frame_count > 0) {
         CHECK(stack_trace->GetFrame(0)->GetScriptName()->Equals(v8_str("pro")));
         promise_reject_line_number = stack_trace->GetFrame(0)->GetLineNumber();
         promise_reject_column_number = stack_trace->GetFrame(0)->GetColumn();
       } else {
         promise_reject_line_number = -1;
         promise_reject_column_number = -1;
       }
     }
   } else {
     promise_revoke_counter++;
     CcTest::global()->Set(v8_str("revoked"), reject_message.GetPromise());
     CHECK(reject_message.GetValue().IsEmpty());
   }
 }
 
 
-v8::Handle<v8::Promise> GetPromise(const char* name) {
-  return v8::Handle<v8::Promise>::Cast(CcTest::global()->Get(v8_str(name)));
+v8::Local<v8::Promise> GetPromise(const char* name) {
+  return v8::Local<v8::Promise>::Cast(CcTest::global()->Get(v8_str(name)));
 }
 
 
-v8::Handle<v8::Value> RejectValue() {
+v8::Local<v8::Value> RejectValue() {
   return CcTest::global()->Get(v8_str("value"));
 }
 
 
 void ResetPromiseStates() {
   promise_reject_counter = 0;
   promise_revoke_counter = 0;
   promise_reject_msg_line_number = -1;
   promise_reject_msg_column_number = -1;
   promise_reject_line_number = -1;
@@ skipping 318 matching lines @@
   CHECK_EQ(5, promise_reject_line_number);
   CHECK_EQ(10, promise_reject_column_number);
   CHECK_EQ(2, promise_reject_msg_line_number);
   CHECK_EQ(7, promise_reject_msg_column_number);
 }
 
 
 void AnalyzeStackOfEvalWithSourceURL(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::HandleScope scope(args.GetIsolate());
-  v8::Handle<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(
+  v8::Local<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(
       args.GetIsolate(), 10, v8::StackTrace::kDetailed);
   CHECK_EQ(5, stackTrace->GetFrameCount());
-  v8::Handle<v8::String> url = v8_str("eval_url");
+  v8::Local<v8::String> url = v8_str("eval_url");
   for (int i = 0; i < 3; i++) {
-    v8::Handle<v8::String> name =
+    v8::Local<v8::String> name =
         stackTrace->GetFrame(i)->GetScriptNameOrSourceURL();
     CHECK(!name.IsEmpty());
     CHECK(url->Equals(name));
   }
 }
 
 
 TEST(SourceURLInStackTrace) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
@@ skipping 22 matching lines @@
   i::SNPrintF(code, source, "//@ sourceURL=eval_url");
   CHECK(CompileRun(code.start())->IsUndefined());
 }
 
 
 static int scriptIdInStack[2];
 
 void AnalyzeScriptIdInStack(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::HandleScope scope(args.GetIsolate());
-  v8::Handle<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(
+  v8::Local<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(
       args.GetIsolate(), 10, v8::StackTrace::kScriptId);
   CHECK_EQ(2, stackTrace->GetFrameCount());
   for (int i = 0; i < 2; i++) {
     scriptIdInStack[i] = stackTrace->GetFrame(i)->GetScriptId();
   }
 }
 
 
 TEST(ScriptIdInStackTrace) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->Set(v8_str("AnalyzeScriptIdInStack"),
              v8::FunctionTemplate::New(isolate, AnalyzeScriptIdInStack));
   LocalContext context(0, templ);
 
-  v8::Handle<v8::String> scriptSource = v8::String::NewFromUtf8(
-    isolate,
-    "function foo() {\n"
-    "  AnalyzeScriptIdInStack();"
-    "}\n"
-    "foo();\n");
+  v8::Local<v8::String> scriptSource = v8_str(
+      "function foo() {\n"
+      "  AnalyzeScriptIdInStack();"
+      "}\n"
+      "foo();\n");
   v8::Local<v8::Script> script = CompileWithOrigin(scriptSource, "test");
   script->Run();
   for (int i = 0; i < 2; i++) {
     CHECK(scriptIdInStack[i] != v8::Message::kNoScriptIdInfo);
     CHECK_EQ(scriptIdInStack[i], script->GetUnboundScript()->GetId());
   }
 }
 
 
 void AnalyzeStackOfInlineScriptWithSourceURL(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::HandleScope scope(args.GetIsolate());
-  v8::Handle<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(
+  v8::Local<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(
       args.GetIsolate(), 10, v8::StackTrace::kDetailed);
   CHECK_EQ(4, stackTrace->GetFrameCount());
-  v8::Handle<v8::String> url = v8_str("source_url");
+  v8::Local<v8::String> url = v8_str("source_url");
   for (int i = 0; i < 3; i++) {
-    v8::Handle<v8::String> name =
+    v8::Local<v8::String> name =
         stackTrace->GetFrame(i)->GetScriptNameOrSourceURL();
     CHECK(!name.IsEmpty());
     CHECK(url->Equals(name));
   }
 }
 
 
 TEST(InlineScriptWithSourceURLInStackTrace) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
@@ skipping 20 matching lines @@
   i::SNPrintF(code, source, "//# sourceURL=source_url");
   CHECK(CompileRunWithOrigin(code.start(), "url", 0, 1)->IsUndefined());
   i::SNPrintF(code, source, "//@ sourceURL=source_url");
   CHECK(CompileRunWithOrigin(code.start(), "url", 0, 1)->IsUndefined());
 }
 
 
 void AnalyzeStackOfDynamicScriptWithSourceURL(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::HandleScope scope(args.GetIsolate());
-  v8::Handle<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(
+  v8::Local<v8::StackTrace> stackTrace = v8::StackTrace::CurrentStackTrace(
       args.GetIsolate(), 10, v8::StackTrace::kDetailed);
   CHECK_EQ(4, stackTrace->GetFrameCount());
-  v8::Handle<v8::String> url = v8_str("source_url");
+  v8::Local<v8::String> url = v8_str("source_url");
   for (int i = 0; i < 3; i++) {
-    v8::Handle<v8::String> name =
+    v8::Local<v8::String> name =
         stackTrace->GetFrame(i)->GetScriptNameOrSourceURL();
     CHECK(!name.IsEmpty());
     CHECK(url->Equals(name));
   }
 }
 
 
 TEST(DynamicWithSourceURLInStackTrace) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
@@ skipping 58 matching lines @@
     "  eval(scriptContents);\n"
     "  foo(); }\n"
     "outer();\n"
     "//# sourceURL=outer_url";
 
   v8::TryCatch try_catch(context->GetIsolate());
   CompileRun(source);
   CHECK(try_catch.HasCaught());
 
   Local<v8::Message> message = try_catch.Message();
-  Handle<Value> sourceURL =
-    message->GetScriptOrigin().ResourceName();
+  Local<Value> sourceURL = message->GetScriptOrigin().ResourceName();
   CHECK_EQ(0, strcmp(*v8::String::Utf8Value(sourceURL), "source_url"));
 }
 
 
 TEST(RecursionWithSourceURLInMessageScriptResourceNameOrSourceURL) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
 
   const char *source =
     "function outer() {\n"
     "  var scriptContents = \"function boo(){ boo(); }\\\n"
     "  //# sourceURL=source_url\";\n"
     "  eval(scriptContents);\n"
     "  boo(); }\n"
     "outer();\n"
     "//# sourceURL=outer_url";
 
   v8::TryCatch try_catch(context->GetIsolate());
   CompileRun(source);
   CHECK(try_catch.HasCaught());
 
   Local<v8::Message> message = try_catch.Message();
-  Handle<Value> sourceURL =
-    message->GetScriptOrigin().ResourceName();
+  Local<Value> sourceURL = message->GetScriptOrigin().ResourceName();
   CHECK_EQ(0, strcmp(*v8::String::Utf8Value(sourceURL), "source_url"));
 }
 
 
 static void CreateGarbageInOldSpace() {
   i::Factory* factory = CcTest::i_isolate()->factory();
   v8::HandleScope scope(CcTest::isolate());
   i::AlwaysAllocateScope always_allocate(CcTest::i_isolate());
   for (int i = 0; i < 1000; i++) {
     factory->NewFixedArray(1000, i::TENURED);
@@ skipping 69 matching lines @@
   uint32_t* set_limit = ComputeStackLimit(stack_breathing_room);
 
   // Set stack limit.
   CcTest::isolate()->SetStackLimit(reinterpret_cast<uintptr_t>(set_limit));
 
   // Execute a script.
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   Local<v8::FunctionTemplate> fun_templ =
       v8::FunctionTemplate::New(env->GetIsolate(), GetStackLimitCallback);
-  Local<Function> fun = fun_templ->GetFunction();
-  env->Global()->Set(v8_str("get_stack_limit"), fun);
+  Local<Function> fun = fun_templ->GetFunction(env.local()).ToLocalChecked();
+  CHECK(env->Global()
+            ->Set(env.local(), v8_str("get_stack_limit"), fun)
+            .FromJust());
   CompileRun("get_stack_limit();");
 
   CHECK(stack_limit == set_limit);
 }
 
 
 TEST(SetStackLimitInThread) {
   uint32_t* set_limit;
   {
     v8::Locker locker(CcTest::isolate());
     set_limit = ComputeStackLimit(stack_breathing_room);
 
     // Set stack limit.
     CcTest::isolate()->SetStackLimit(reinterpret_cast<uintptr_t>(set_limit));
 
     // Execute a script.
     v8::HandleScope scope(CcTest::isolate());
     LocalContext env;
     Local<v8::FunctionTemplate> fun_templ =
         v8::FunctionTemplate::New(CcTest::isolate(), GetStackLimitCallback);
-    Local<Function> fun = fun_templ->GetFunction();
-    env->Global()->Set(v8_str("get_stack_limit"), fun);
+    Local<Function> fun = fun_templ->GetFunction(env.local()).ToLocalChecked();
+    CHECK(env->Global()
+              ->Set(env.local(), v8_str("get_stack_limit"), fun)
+              .FromJust());
     CompileRun("get_stack_limit();");
 
     CHECK(stack_limit == set_limit);
   }
   {
     v8::Locker locker(CcTest::isolate());
     CHECK(stack_limit == set_limit);
   }
 }
 
@@ skipping 12 matching lines @@
 
 class VisitorImpl : public v8::ExternalResourceVisitor {
  public:
   explicit VisitorImpl(TestResource** resource) {
     for (int i = 0; i < 4; i++) {
       resource_[i] = resource[i];
       found_resource_[i] = false;
     }
   }
   virtual ~VisitorImpl() {}
-  virtual void VisitExternalString(v8::Handle<v8::String> string) {
+  virtual void VisitExternalString(v8::Local<v8::String> string) {
     if (!string->IsExternal()) {
       CHECK(string->IsExternalOneByte());
       return;
     }
     v8::String::ExternalStringResource* resource =
         string->GetExternalStringResource();
     CHECK(resource);
     for (int i = 0; i < 4; i++) {
       if (resource_[i] == resource) {
         CHECK(!found_resource_[i]);
@@ skipping 66 matching lines @@
   TestResource* resource[4];
   resource[0] = new TestResource(two_byte_string);
   v8::Local<v8::String> string0 =
       v8::String::NewExternal(env->GetIsolate(), resource[0]);
   resource[1] = new TestResource(two_byte_string, NULL, false);
   v8::Local<v8::String> string1 =
       v8::String::NewExternal(env->GetIsolate(), resource[1]);
 
   // Externalized symbol.
   resource[2] = new TestResource(two_byte_string, NULL, false);
-  v8::Local<v8::String> string2 = v8::String::NewFromUtf8(
-      env->GetIsolate(), string, v8::String::kInternalizedString);
+  v8::Local<v8::String> string2 =
+      v8::String::NewFromUtf8(env->GetIsolate(), string,
+                              v8::NewStringType::kInternalized)
+          .ToLocalChecked();
   CHECK(string2->MakeExternal(resource[2]));
 
   // Symbolized External.
   resource[3] = new TestResource(AsciiToTwoByteString("Some other string"));
   v8::Local<v8::String> string3 =
       v8::String::NewExternal(env->GetIsolate(), resource[3]);
   CcTest::heap()->CollectAllAvailableGarbage();  // Tenure string.
   // Turn into a symbol.
   i::Handle<i::String> string3_i = v8::Utils::OpenHandle(*string3);
   CHECK(!CcTest::i_isolate()->factory()->InternalizeString(
@@ skipping 155 matching lines @@
       -infinity,
       -qnan,
       -snan
   };
   int num_test_values = 20;
 
   for (int i = 0; i < num_test_values; i++) {
     double test_value = test_values[i];
 
     // Check that Number::New preserves non-NaNs and quiets SNaNs.
-    v8::Handle<v8::Value> number = v8::Number::New(isolate, test_value);
+    v8::Local<v8::Value> number = v8::Number::New(isolate, test_value);
     double stored_number = number->NumberValue();
     if (!std::isnan(test_value)) {
       CHECK_EQ(test_value, stored_number);
     } else {
       uint64_t stored_bits = DoubleToBits(stored_number);
       // Check if quiet nan (bits 51..62 all set).
 #if (defined(V8_TARGET_ARCH_MIPS) || defined(V8_TARGET_ARCH_MIPS64)) && \
     !defined(_MIPS_ARCH_MIPS64R6) && !defined(_MIPS_ARCH_MIPS32R6) &&   \
     !defined(USE_SIMULATOR)
       // Most significant fraction bit for quiet nan is set to 0
       // on MIPS architecture. Allowed by IEEE-754.
       CHECK_EQ(0xffe, static_cast<int>((stored_bits >> 51) & 0xfff));
 #else
       CHECK_EQ(0xfff, static_cast<int>((stored_bits >> 51) & 0xfff));
 #endif
     }
 
     // Check that Date::New preserves non-NaNs in the date range and
     // quiets SNaNs.
-    v8::Handle<v8::Value> date =
-        v8::Date::New(isolate, test_value);
+    v8::Local<v8::Value> date = v8::Date::New(isolate, test_value);
     double expected_stored_date = DoubleToDateTime(test_value);
     double stored_date = date->NumberValue();
     if (!std::isnan(expected_stored_date)) {
       CHECK_EQ(expected_stored_date, stored_date);
     } else {
       uint64_t stored_bits = DoubleToBits(stored_date);
       // Check if quiet nan (bits 51..62 all set).
 #if (defined(V8_TARGET_ARCH_MIPS) || defined(V8_TARGET_ARCH_MIPS64)) && \
     !defined(_MIPS_ARCH_MIPS64R6) && !defined(_MIPS_ARCH_MIPS32R6) &&   \
     !defined(USE_SIMULATOR)
       // Most significant fraction bit for quiet nan is set to 0
       // on MIPS architecture. Allowed by IEEE-754.
       CHECK_EQ(0xffe, static_cast<int>((stored_bits >> 51) & 0xfff));
 #else
       CHECK_EQ(0xfff, static_cast<int>((stored_bits >> 51) & 0xfff));
 #endif
     }
   }
 }
 
 
 static void SpaghettiIncident(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   v8::HandleScope scope(args.GetIsolate());
   v8::TryCatch tc(args.GetIsolate());
-  v8::Handle<v8::String> str(args[0]->ToString(args.GetIsolate()));
+  v8::Local<v8::String> str(args[0]->ToString(args.GetIsolate()));
   USE(str);
   if (tc.HasCaught())
     tc.ReThrow();
 }
 
 
 // Test that an exception can be propagated down through a spaghetti
 // stack using ReThrow.
 THREADED_TEST(SpaghettiStackReThrow) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   LocalContext context;
-  context->Global()->Set(
-      v8::String::NewFromUtf8(isolate, "s"),
-      v8::FunctionTemplate::New(isolate, SpaghettiIncident)->GetFunction());
+  context->Global()->Set(v8_str("s"),
+                         v8::FunctionTemplate::New(isolate, SpaghettiIncident)
+                             ->GetFunction(context.local())
+                             .ToLocalChecked());
   v8::TryCatch try_catch(isolate);
   CompileRun(
       "var i = 0;"
       "var o = {"
       "  toString: function () {"
       "    if (i == 10) {"
       "      throw 'Hey!';"
       "    } else {"
       "      i++;"
       "      return s(o);"
@@ skipping 20 matching lines @@
   other_context = Context::New(isolate);
 
   // Context-dependent context data creates reference from the compilation
   // cache to the global object.
   const char* source_simple = "1";
   {
     v8::HandleScope scope(isolate);
     v8::Local<Context> context = Context::New(isolate);
 
     context->Enter();
-    Local<v8::String> obj = v8::String::NewFromUtf8(isolate, "");
+    Local<v8::String> obj = v8_str("");
     context->SetEmbedderData(0, obj);
     CompileRun(source_simple);
     context->Exit();
   }
   isolate->ContextDisposedNotification();
   for (gc_count = 1; gc_count < 10; gc_count++) {
     other_context->Enter();
     CompileRun(source_simple);
     other_context->Exit();
     CcTest::heap()->CollectAllGarbage();
@@ skipping 28 matching lines @@
   // compilation cache to the global object.
   const char* source_exception = "function f(){throw 1;} f()";
   {
     v8::HandleScope scope(isolate);
     v8::Local<Context> context = Context::New(isolate);
 
     context->Enter();
     v8::TryCatch try_catch(isolate);
     CompileRun(source_exception);
     CHECK(try_catch.HasCaught());
-    v8::Handle<v8::Message> message = try_catch.Message();
+    v8::Local<v8::Message> message = try_catch.Message();
     CHECK(!message.IsEmpty());
     CHECK_EQ(1, message->GetLineNumber());
     context->Exit();
   }
   isolate->ContextDisposedNotification();
   for (gc_count = 1; gc_count < 10; gc_count++) {
     other_context->Enter();
     CompileRun(source_exception);
     other_context->Exit();
     CcTest::heap()->CollectAllGarbage();
     if (GetGlobalObjectsCount() == 1) break;
   }
   CHECK_GE(2, gc_count);
   CHECK_EQ(1, GetGlobalObjectsCount());
 
   isolate->ContextDisposedNotification();
 }
 
 
 THREADED_TEST(ScriptOrigin) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   v8::ScriptOrigin origin = v8::ScriptOrigin(
-      v8::String::NewFromUtf8(env->GetIsolate(), "test"),
-      v8::Integer::New(env->GetIsolate(), 1),
+      v8_str("test"), v8::Integer::New(env->GetIsolate(), 1),
       v8::Integer::New(env->GetIsolate(), 1), v8::True(env->GetIsolate()),
-      v8::Handle<v8::Integer>(), v8::True(env->GetIsolate()),
-      v8::String::NewFromUtf8(env->GetIsolate(), "http://sourceMapUrl"),
-      v8::True(env->GetIsolate()));
-  v8::Handle<v8::String> script = v8::String::NewFromUtf8(
-      env->GetIsolate(), "function f() {}\n\nfunction g() {}");
+      v8::Local<v8::Integer>(), v8::True(env->GetIsolate()),
+      v8_str("http://sourceMapUrl"), v8::True(env->GetIsolate()));
+  v8::Local<v8::String> script = v8_str("function f() {}\n\nfunction g() {}");
   v8::Script::Compile(script, &origin)->Run();
-  v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
-  v8::Local<v8::Function> g = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "g")));
+  v8::Local<v8::Function> f =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("f")));
+  v8::Local<v8::Function> g =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("g")));
 
   v8::ScriptOrigin script_origin_f = f->GetScriptOrigin();
   CHECK_EQ(0, strcmp("test",
                      *v8::String::Utf8Value(script_origin_f.ResourceName())));
-  CHECK_EQ(1, script_origin_f.ResourceLineOffset()->Int32Value());
+  CHECK_EQ(
+      1,
+      script_origin_f.ResourceLineOffset()->Int32Value(env.local()).FromJust());
   CHECK(script_origin_f.Options().IsSharedCrossOrigin());
   CHECK(script_origin_f.Options().IsEmbedderDebugScript());
   CHECK(script_origin_f.Options().IsOpaque());
   printf("is name = %d\n", script_origin_f.SourceMapUrl()->IsUndefined());
 
   CHECK_EQ(0, strcmp("http://sourceMapUrl",
                      *v8::String::Utf8Value(script_origin_f.SourceMapUrl())));
 
   v8::ScriptOrigin script_origin_g = g->GetScriptOrigin();
   CHECK_EQ(0, strcmp("test",
                      *v8::String::Utf8Value(script_origin_g.ResourceName())));
-  CHECK_EQ(1, script_origin_g.ResourceLineOffset()->Int32Value());
+  CHECK_EQ(
+      1,
+      script_origin_g.ResourceLineOffset()->Int32Value(env.local()).FromJust());
   CHECK(script_origin_g.Options().IsSharedCrossOrigin());
   CHECK(script_origin_g.Options().IsEmbedderDebugScript());
   CHECK(script_origin_g.Options().IsOpaque());
   CHECK_EQ(0, strcmp("http://sourceMapUrl",
                      *v8::String::Utf8Value(script_origin_g.SourceMapUrl())));
 }
 
 
 THREADED_TEST(FunctionGetInferredName) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::ScriptOrigin origin =
-      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "test"));
-  v8::Handle<v8::String> script = v8::String::NewFromUtf8(
-      env->GetIsolate(),
-      "var foo = { bar : { baz : function() {}}}; var f = foo.bar.baz;");
+  v8::ScriptOrigin origin = v8::ScriptOrigin(v8_str("test"));
+  v8::Local<v8::String> script =
+      v8_str("var foo = { bar : { baz : function() {}}}; var f = foo.bar.baz;");
   v8::Script::Compile(script, &origin)->Run();
-  v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
+  v8::Local<v8::Function> f =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("f")));
   CHECK_EQ(0,
            strcmp("foo.bar.baz", *v8::String::Utf8Value(f->GetInferredName())));
 }
 
 
 THREADED_TEST(FunctionGetDebugName) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   const char* code =
       "var error = false;"
@@ skipping 93 matching lines @@
                      "  throw new Error();"
                      "});"
                      "function f() {};"
                      "f.displayName = { 'foo': 6, toString: function() {"
                      "  error = true;"
                      "  return 'wrong_display_name';"
                      "}};"
                      "var g = function() {"
                      "  arguments.callee.displayName = 'set_in_runtime';"
                      "}; g();";
-  v8::ScriptOrigin origin =
-      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "test"));
-  v8::Script::Compile(v8::String::NewFromUtf8(env->GetIsolate(), code), &origin)
-      ->Run();
-  v8::Local<v8::Value> error =
-      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "error"));
-  v8::Local<v8::Function> a = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "a")));
-  v8::Local<v8::Function> b = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "b")));
-  v8::Local<v8::Function> c = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "c")));
-  v8::Local<v8::Function> d = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "d")));
-  v8::Local<v8::Function> e = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "e")));
-  v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
-  v8::Local<v8::Function> g = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "g")));
+  v8::ScriptOrigin origin = v8::ScriptOrigin(v8_str("test"));
+  v8::Script::Compile(v8_str(code), &origin)->Run();
+  v8::Local<v8::Value> error = env->Global()->Get(v8_str("error"));
+  v8::Local<v8::Function> a =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("a")));
+  v8::Local<v8::Function> b =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("b")));
+  v8::Local<v8::Function> c =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("c")));
+  v8::Local<v8::Function> d =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("d")));
+  v8::Local<v8::Function> e =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("e")));
+  v8::Local<v8::Function> f =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("f")));
+  v8::Local<v8::Function> g =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("g")));
   CHECK_EQ(false, error->BooleanValue());
   CHECK_EQ(0, strcmp("display_a", *v8::String::Utf8Value(a->GetDisplayName())));
   CHECK_EQ(0, strcmp("display_b", *v8::String::Utf8Value(b->GetDisplayName())));
   CHECK(c->GetDisplayName()->IsUndefined());
   CHECK(d->GetDisplayName()->IsUndefined());
   CHECK(e->GetDisplayName()->IsUndefined());
   CHECK(f->GetDisplayName()->IsUndefined());
   CHECK_EQ(
       0, strcmp("set_in_runtime", *v8::String::Utf8Value(g->GetDisplayName())));
 }
 
 
 THREADED_TEST(ScriptLineNumber) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::ScriptOrigin origin =
-      v8::ScriptOrigin(v8::String::NewFromUtf8(env->GetIsolate(), "test"));
-  v8::Handle<v8::String> script = v8::String::NewFromUtf8(
-      env->GetIsolate(), "function f() {}\n\nfunction g() {}");
+  v8::ScriptOrigin origin = v8::ScriptOrigin(v8_str("test"));
+  v8::Local<v8::String> script = v8_str("function f() {}\n\nfunction g() {}");
   v8::Script::Compile(script, &origin)->Run();
-  v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
-  v8::Local<v8::Function> g = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "g")));
+  v8::Local<v8::Function> f =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("f")));
+  v8::Local<v8::Function> g =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("g")));
   CHECK_EQ(0, f->GetScriptLineNumber());
   CHECK_EQ(2, g->GetScriptLineNumber());
 }
 
 
 THREADED_TEST(ScriptColumnNumber) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   v8::ScriptOrigin origin =
-      v8::ScriptOrigin(v8::String::NewFromUtf8(isolate, "test"),
-                       v8::Integer::New(isolate, 3),
+      v8::ScriptOrigin(v8_str("test"), v8::Integer::New(isolate, 3),
                        v8::Integer::New(isolate, 2));
-  v8::Handle<v8::String> script = v8::String::NewFromUtf8(
-      isolate, "function foo() {}\n\n     function bar() {}");
+  v8::Local<v8::String> script =
+      v8_str("function foo() {}\n\n     function bar() {}");
   v8::Script::Compile(script, &origin)->Run();
-  v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::NewFromUtf8(isolate, "foo")));
-  v8::Local<v8::Function> bar = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::NewFromUtf8(isolate, "bar")));
+  v8::Local<v8::Function> foo =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("foo")));
+  v8::Local<v8::Function> bar =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("bar")));
   CHECK_EQ(14, foo->GetScriptColumnNumber());
   CHECK_EQ(17, bar->GetScriptColumnNumber());
 }
 
 
 THREADED_TEST(FunctionIsBuiltin) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   v8::Local<v8::Function> f;
   f = v8::Local<v8::Function>::Cast(CompileRun("Math.floor"));
   CHECK(f->IsBuiltin());
   f = v8::Local<v8::Function>::Cast(CompileRun("Object"));
   CHECK(f->IsBuiltin());
   f = v8::Local<v8::Function>::Cast(CompileRun("Object.__defineSetter__"));
   CHECK(f->IsBuiltin());
   f = v8::Local<v8::Function>::Cast(CompileRun("Array.prototype.toString"));
   CHECK(f->IsBuiltin());
   f = v8::Local<v8::Function>::Cast(CompileRun("function a() {}; a;"));
   CHECK(!f->IsBuiltin());
 }
 
 
 THREADED_TEST(FunctionGetScriptId) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   v8::ScriptOrigin origin =
-      v8::ScriptOrigin(v8::String::NewFromUtf8(isolate, "test"),
-                       v8::Integer::New(isolate, 3),
+      v8::ScriptOrigin(v8_str("test"), v8::Integer::New(isolate, 3),
                        v8::Integer::New(isolate, 2));
-  v8::Handle<v8::String> scriptSource = v8::String::NewFromUtf8(
-      isolate, "function foo() {}\n\n     function bar() {}");
+  v8::Local<v8::String> scriptSource =
+      v8_str("function foo() {}\n\n     function bar() {}");
   v8::Local<v8::Script> script(v8::Script::Compile(scriptSource, &origin));
   script->Run();
-  v8::Local<v8::Function> foo = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::NewFromUtf8(isolate, "foo")));
-  v8::Local<v8::Function> bar = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::NewFromUtf8(isolate, "bar")));
+  v8::Local<v8::Function> foo =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("foo")));
+  v8::Local<v8::Function> bar =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("bar")));
   CHECK_EQ(script->GetUnboundScript()->GetId(), foo->ScriptId());
   CHECK_EQ(script->GetUnboundScript()->GetId(), bar->ScriptId());
 }
 
 
 THREADED_TEST(FunctionGetBoundFunction) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::ScriptOrigin origin = v8::ScriptOrigin(v8::String::NewFromUtf8(
-      env->GetIsolate(), "test"));
-  v8::Handle<v8::String> script = v8::String::NewFromUtf8(
-      env->GetIsolate(),
+  v8::ScriptOrigin origin = v8::ScriptOrigin(v8_str("test"));
+  v8::Local<v8::String> script = v8_str(
       "var a = new Object();\n"
       "a.x = 1;\n"
       "function f () { return this.x };\n"
       "var g = f.bind(a);\n"
       "var b = g();");
   v8::Script::Compile(script, &origin)->Run();
-  v8::Local<v8::Function> f = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "f")));
-  v8::Local<v8::Function> g = v8::Local<v8::Function>::Cast(
-      env->Global()->Get(v8::String::NewFromUtf8(env->GetIsolate(), "g")));
+  v8::Local<v8::Function> f =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("f")));
+  v8::Local<v8::Function> g =
+      v8::Local<v8::Function>::Cast(env->Global()->Get(v8_str("g")));
   CHECK(g->GetBoundFunction()->IsFunction());
   Local<v8::Function> original_function = Local<v8::Function>::Cast(
       g->GetBoundFunction());
   CHECK(f->GetName()->Equals(original_function->GetName()));
   CHECK_EQ(f->GetScriptLineNumber(), original_function->GetScriptLineNumber());
   CHECK_EQ(f->GetScriptColumnNumber(),
            original_function->GetScriptColumnNumber());
 }
 
 
@@ skipping 35 matching lines @@
 }
 
 
 TEST(SetterOnConstructorPrototype) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->SetAccessor(v8_str("x"), GetterWhichReturns42,
                      SetterWhichSetsYOnThisTo23);
   LocalContext context;
-  context->Global()->Set(v8_str("P"), templ->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("P"),
+                  templ->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   CompileRun("function C1() {"
              "  this.x = 23;"
              "};"
              "C1.prototype = P;"
              "function C2() {"
              "  this.x = 23"
              "};"
              "C2.prototype = { };"
              "C2.prototype.__proto__ = P;");
 
   v8::Local<v8::Script> script;
   script = v8_compile("new C1();");
   for (int i = 0; i < 10; i++) {
-    v8::Handle<v8::Object> c1 = v8::Handle<v8::Object>::Cast(script->Run());
-    CHECK_EQ(42, c1->Get(v8_str("x"))->Int32Value());
-    CHECK_EQ(23, c1->Get(v8_str("y"))->Int32Value());
+    v8::Local<v8::Object> c1 = v8::Local<v8::Object>::Cast(script->Run());
+    CHECK_EQ(42, c1->Get(v8_str("x"))->Int32Value(context.local()).FromJust());
+    CHECK_EQ(23, c1->Get(v8_str("y"))->Int32Value(context.local()).FromJust());
   }
 
-script = v8_compile("new C2();");
+  script = v8_compile("new C2();");
   for (int i = 0; i < 10; i++) {
-    v8::Handle<v8::Object> c2 = v8::Handle<v8::Object>::Cast(script->Run());
-    CHECK_EQ(42, c2->Get(v8_str("x"))->Int32Value());
-    CHECK_EQ(23, c2->Get(v8_str("y"))->Int32Value());
+    v8::Local<v8::Object> c2 = v8::Local<v8::Object>::Cast(script->Run());
+    CHECK_EQ(42, c2->Get(v8_str("x"))->Int32Value(context.local()).FromJust());
+    CHECK_EQ(23, c2->Get(v8_str("y"))->Int32Value(context.local()).FromJust());
   }
 }
 
 
 static void NamedPropertyGetterWhichReturns42(
     Local<Name> name, const v8::PropertyCallbackInfo<v8::Value>& info) {
   info.GetReturnValue().Set(v8_num(42));
 }
 
 
 static void NamedPropertySetterWhichSetsYOnThisTo23(
     Local<Name> name, Local<Value> value,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   if (name->Equals(v8_str("x"))) {
     Local<Object>::Cast(info.This())->Set(v8_str("y"), v8_num(23));
   }
 }
 
 
 THREADED_TEST(InterceptorOnConstructorPrototype) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->SetHandler(v8::NamedPropertyHandlerConfiguration(
       NamedPropertyGetterWhichReturns42,
       NamedPropertySetterWhichSetsYOnThisTo23));
   LocalContext context;
-  context->Global()->Set(v8_str("P"), templ->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("P"),
+                  templ->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   CompileRun("function C1() {"
              "  this.x = 23;"
              "};"
              "C1.prototype = P;"
              "function C2() {"
              "  this.x = 23"
              "};"
              "C2.prototype = { };"
              "C2.prototype.__proto__ = P;");
 
   v8::Local<v8::Script> script;
   script = v8_compile("new C1();");
   for (int i = 0; i < 10; i++) {
-    v8::Handle<v8::Object> c1 = v8::Handle<v8::Object>::Cast(script->Run());
-    CHECK_EQ(23, c1->Get(v8_str("x"))->Int32Value());
-    CHECK_EQ(42, c1->Get(v8_str("y"))->Int32Value());
+    v8::Local<v8::Object> c1 = v8::Local<v8::Object>::Cast(script->Run());
+    CHECK_EQ(23, c1->Get(v8_str("x"))->Int32Value(context.local()).FromJust());
+    CHECK_EQ(42, c1->Get(v8_str("y"))->Int32Value(context.local()).FromJust());
   }
 
   script = v8_compile("new C2();");
   for (int i = 0; i < 10; i++) {
-    v8::Handle<v8::Object> c2 = v8::Handle<v8::Object>::Cast(script->Run());
-    CHECK_EQ(23, c2->Get(v8_str("x"))->Int32Value());
-    CHECK_EQ(42, c2->Get(v8_str("y"))->Int32Value());
+    v8::Local<v8::Object> c2 = v8::Local<v8::Object>::Cast(script->Run());
+    CHECK_EQ(23, c2->Get(v8_str("x"))->Int32Value(context.local()).FromJust());
+    CHECK_EQ(42, c2->Get(v8_str("y"))->Int32Value(context.local()).FromJust());
   }
 }
 
 
 TEST(Regress618) {
   const char* source = "function C1() {"
                        "  this.x = 23;"
                        "};"
                        "C1.prototype = P;";
 
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
   v8::Local<v8::Script> script;
 
   // Use a simple object as prototype.
   v8::Local<v8::Object> prototype = v8::Object::New(isolate);
   prototype->Set(v8_str("y"), v8_num(42));
-  context->Global()->Set(v8_str("P"), prototype);
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("P"), prototype)
+            .FromJust());
 
   // This compile will add the code to the compilation cache.
   CompileRun(source);
 
   script = v8_compile("new C1();");
   // Allow enough iterations for the inobject slack tracking logic
   // to finalize instance size and install the fast construct stub.
   for (int i = 0; i < 256; i++) {
-    v8::Handle<v8::Object> c1 = v8::Handle<v8::Object>::Cast(script->Run());
-    CHECK_EQ(23, c1->Get(v8_str("x"))->Int32Value());
-    CHECK_EQ(42, c1->Get(v8_str("y"))->Int32Value());
+    v8::Local<v8::Object> c1 = v8::Local<v8::Object>::Cast(script->Run());
+    CHECK_EQ(23, c1->Get(v8_str("x"))->Int32Value(context.local()).FromJust());
+    CHECK_EQ(42, c1->Get(v8_str("y"))->Int32Value(context.local()).FromJust());
   }
 
   // Use an API object with accessors as prototype.
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->SetAccessor(v8_str("x"), GetterWhichReturns42,
                      SetterWhichSetsYOnThisTo23);
-  context->Global()->Set(v8_str("P"), templ->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("P"),
+                  templ->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
 
   // This compile will get the code from the compilation cache.
   CompileRun(source);
 
   script = v8_compile("new C1();");
   for (int i = 0; i < 10; i++) {
-    v8::Handle<v8::Object> c1 = v8::Handle<v8::Object>::Cast(script->Run());
-    CHECK_EQ(42, c1->Get(v8_str("x"))->Int32Value());
-    CHECK_EQ(23, c1->Get(v8_str("y"))->Int32Value());
+    v8::Local<v8::Object> c1 = v8::Local<v8::Object>::Cast(script->Run());
+    CHECK_EQ(42, c1->Get(v8_str("x"))->Int32Value(context.local()).FromJust());
+    CHECK_EQ(23, c1->Get(v8_str("y"))->Int32Value(context.local()).FromJust());
   }
 }
 
 v8::Isolate* gc_callbacks_isolate = NULL;
 int prologue_call_count = 0;
 int epilogue_call_count = 0;
 int prologue_call_count_second = 0;
 int epilogue_call_count_second = 0;
 int prologue_call_count_alloc = 0;
 int epilogue_call_count_alloc = 0;
@@ skipping 223 matching lines @@
     CHECK(string->IsOneByteRepresentation());
     i::ConsString* cons = i::ConsString::cast(*string);
     CHECK_EQ(0, cons->second()->length());
     CHECK(cons->first()->IsTwoByteRepresentation());
   }
 
   // Check that some string operations work.
 
   // Atom RegExp.
   Local<Value> reresult = CompileRun("str2.match(/abel/g).length;");
-  CHECK_EQ(6, reresult->Int32Value());
+  CHECK_EQ(6, reresult->Int32Value(context.local()).FromJust());
 
   // Nonatom RegExp.
   reresult = CompileRun("str2.match(/abe./g).length;");
-  CHECK_EQ(6, reresult->Int32Value());
+  CHECK_EQ(6, reresult->Int32Value(context.local()).FromJust());
 
   reresult = CompileRun("str2.search(/bel/g);");
-  CHECK_EQ(1, reresult->Int32Value());
+  CHECK_EQ(1, reresult->Int32Value(context.local()).FromJust());
 
   reresult = CompileRun("str2.search(/be./g);");
-  CHECK_EQ(1, reresult->Int32Value());
+  CHECK_EQ(1, reresult->Int32Value(context.local()).FromJust());
 
   ExpectTrue("/bel/g.test(str2);");
 
   ExpectTrue("/be./g.test(str2);");
 
   reresult = CompileRun("/bel/g.exec(str2);");
   CHECK(!reresult->IsNull());
 
   reresult = CompileRun("/be./g.exec(str2);");
   CHECK(!reresult->IsNull());
 
   ExpectString("str2.substring(2, 10);", "elspenda");
 
   ExpectString("str2.substring(2, 20);", "elspendabelabelspe");
 
   ExpectString("str2.charAt(2);", "e");
 
   ExpectObject("str2.indexOf('els');", indexof);
 
   ExpectObject("str2.lastIndexOf('dab');", lastindexof);
 
   reresult = CompileRun("str2.charCodeAt(2);");
-  CHECK_EQ(static_cast<int32_t>('e'), reresult->Int32Value());
+  CHECK_EQ(static_cast<int32_t>('e'),
+           reresult->Int32Value(context.local()).FromJust());
 }
 
 
 TEST(ContainsOnlyOneByte) {
   v8::V8::Initialize();
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   // Make a buffer long enough that it won't automatically be converted.
   const int length = 512;
   // Ensure word aligned assignment.
   const int aligned_length = length*sizeof(uintptr_t)/sizeof(uint16_t);
   v8::base::SmartArrayPointer<uintptr_t> aligned_contents(
       new uintptr_t[aligned_length]);
   uint16_t* string_contents =
       reinterpret_cast<uint16_t*>(aligned_contents.get());
   // Set to contain only one byte.
   for (int i = 0; i < length-1; i++) {
     string_contents[i] = 0x41;
   }
   string_contents[length-1] = 0;
   // Simple case.
-  Handle<String> string =
-      String::NewExternal(isolate,
-                          new TestResource(string_contents, NULL, false));
+  Local<String> string = String::NewExternal(
+      isolate, new TestResource(string_contents, NULL, false));
   CHECK(!string->IsOneByte() && string->ContainsOnlyOneByte());
   // Counter example.
   string = String::NewFromTwoByte(isolate, string_contents);
   CHECK(string->IsOneByte() && string->ContainsOnlyOneByte());
   // Test left right and balanced cons strings.
-  Handle<String> base = String::NewFromUtf8(isolate, "a");
-  Handle<String> left = base;
-  Handle<String> right = base;
+  Local<String> base = v8_str("a");
+  Local<String> left = base;
+  Local<String> right = base;
   for (int i = 0; i < 1000; i++) {
     left = String::Concat(base, left);
     right = String::Concat(right, base);
   }
-  Handle<String> balanced = String::Concat(left, base);
+  Local<String> balanced = String::Concat(left, base);
   balanced = String::Concat(balanced, right);
-  Handle<String> cons_strings[] = {left, balanced, right};
-  Handle<String> two_byte =
-      String::NewExternal(isolate,
-                          new TestResource(string_contents, NULL, false));
+  Local<String> cons_strings[] = {left, balanced, right};
+  Local<String> two_byte = String::NewExternal(
+      isolate, new TestResource(string_contents, NULL, false));
   USE(two_byte); USE(cons_strings);
   for (size_t i = 0; i < arraysize(cons_strings); i++) {
     // Base assumptions.
     string = cons_strings[i];
     CHECK(string->IsOneByte() && string->ContainsOnlyOneByte());
     // Test left and right concatentation.
     string = String::Concat(two_byte, cons_strings[i]);
     CHECK(!string->IsOneByte() && string->ContainsOnlyOneByte());
     string = String::Concat(cons_strings[i], two_byte);
     CHECK(!string->IsOneByte() && string->ContainsOnlyOneByte());
@@ skipping 35 matching lines @@
   // invocation. Then force the callback to be called from va
 
   v8::V8::Initialize();
   v8::V8::SetFailedAccessCheckCallbackFunction(&FailedAccessCheckCallbackGC);
 
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
 
   // Create an ObjectTemplate for global objects and install access
   // check callbacks that will block access.
-  v8::Handle<v8::ObjectTemplate> global_template =
+  v8::Local<v8::ObjectTemplate> global_template =
       v8::ObjectTemplate::New(isolate);
   global_template->SetAccessCheckCallback(AccessAlwaysBlocked);
 
   // Create a context and set an x property on it's global object.
   LocalContext context0(NULL, global_template);
-  context0->Global()->Set(v8_str("x"), v8_num(42));
-  v8::Handle<v8::Object> global0 = context0->Global();
+  CHECK(context0->Global()
+            ->Set(context0.local(), v8_str("x"), v8_num(42))
+            .FromJust());
+  v8::Local<v8::Object> global0 = context0->Global();
 
   // Create a context with a different security token so that the
   // failed access check callback will be called on each access.
   LocalContext context1(NULL, global_template);
-  context1->Global()->Set(v8_str("other"), global0);
+  CHECK(context1->Global()
+            ->Set(context1.local(), v8_str("other"), global0)
+            .FromJust());
 
   v8::TryCatch try_catch(isolate);
 
   // Get property with failed access check.
   CHECK(CompileRun("other.x").IsEmpty());
   CHECK(try_catch.HasCaught());
   try_catch.Reset();
 
   // Get element with failed access check.
   CHECK(CompileRun("other[0]").IsEmpty());
@@ skipping 572 matching lines @@
  public:
   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) return;
     CHECK_EQ(42, value->WrapperClassId());
     v8::Isolate* isolate = CcTest::isolate();
     v8::HandleScope handle_scope(isolate);
-    v8::Handle<v8::Value> handle = v8::Local<v8::Value>::New(isolate, *value);
-    v8::Handle<v8::Value> object =
-        v8::Local<v8::Object>::New(isolate, *object_);
+    v8::Local<v8::Value> handle = v8::Local<v8::Value>::New(isolate, *value);
+    v8::Local<v8::Value> object = v8::Local<v8::Object>::New(isolate, *object_);
     CHECK(handle->IsObject());
-    CHECK(Handle<Object>::Cast(handle)->Equals(object));
+    CHECK(Local<Object>::Cast(handle)->Equals(object));
     ++counter_;
   }
 
   int counter_;
   v8::Persistent<v8::Object>* object_;
 };
 
 
 TEST(PersistentHandleVisitor) {
   LocalContext context;
@@ skipping 49 matching lines @@
   object2.Reset();
 }
 
 
 TEST(RegExp) {
   i::FLAG_harmony_regexps = true;
   i::FLAG_harmony_unicode_regexps = true;
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
 
-  v8::Handle<v8::RegExp> re = v8::RegExp::New(v8_str("foo"), v8::RegExp::kNone);
+  v8::Local<v8::RegExp> re = v8::RegExp::New(v8_str("foo"), v8::RegExp::kNone);
   CHECK(re->IsRegExp());
   CHECK(re->GetSource()->Equals(v8_str("foo")));
   CHECK_EQ(v8::RegExp::kNone, re->GetFlags());
 
   re = v8::RegExp::New(v8_str("bar"),
                        static_cast<v8::RegExp::Flags>(v8::RegExp::kIgnoreCase |
                                                       v8::RegExp::kGlobal));
   CHECK(re->IsRegExp());
   CHECK(re->GetSource()->Equals(v8_str("bar")));
   CHECK_EQ(v8::RegExp::kIgnoreCase | v8::RegExp::kGlobal,
@@ skipping 36 matching lines @@
   CHECK_EQ(v8::RegExp::kNone, re->GetFlags());
 
   re = v8::RegExp::New(v8_str("foobarbaz"),
                        static_cast<v8::RegExp::Flags>(v8::RegExp::kIgnoreCase |
                                                       v8::RegExp::kMultiline));
   CHECK(re->IsRegExp());
   CHECK(re->GetSource()->Equals(v8_str("foobarbaz")));
   CHECK_EQ(v8::RegExp::kIgnoreCase | v8::RegExp::kMultiline,
            static_cast<int>(re->GetFlags()));
 
-  context->Global()->Set(v8_str("re"), re);
+  CHECK(context->Global()->Set(context.local(), v8_str("re"), re).FromJust());
   ExpectTrue("re.test('FoobarbaZ')");
 
   // RegExps are objects on which you can set properties.
   re->Set(v8_str("property"), v8::Integer::New(context->GetIsolate(), 32));
-  v8::Handle<v8::Value> value(CompileRun("re.property"));
-  CHECK_EQ(32, value->Int32Value());
+  v8::Local<v8::Value> value(CompileRun("re.property"));
+  CHECK_EQ(32, value->Int32Value(context.local()).FromJust());
 
   v8::TryCatch try_catch(context->GetIsolate());
   re = v8::RegExp::New(v8_str("foo["), v8::RegExp::kNone);
   CHECK(re.IsEmpty());
   CHECK(try_catch.HasCaught());
-  context->Global()->Set(v8_str("ex"), try_catch.Exception());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("ex"), try_catch.Exception())
+            .FromJust());
   ExpectTrue("ex instanceof SyntaxError");
 }
 
 
 THREADED_TEST(Equals) {
   LocalContext localContext;
   v8::HandleScope handleScope(localContext->GetIsolate());
 
-  v8::Handle<v8::Object> globalProxy = localContext->Global();
-  v8::Handle<Value> global = globalProxy->GetPrototype();
+  v8::Local<v8::Object> globalProxy = localContext->Global();
+  v8::Local<Value> global = globalProxy->GetPrototype();
 
   CHECK(global->StrictEquals(global));
   CHECK(!global->StrictEquals(globalProxy));
   CHECK(!globalProxy->StrictEquals(global));
   CHECK(globalProxy->StrictEquals(globalProxy));
 
   CHECK(global->Equals(global));
   CHECK(!global->Equals(globalProxy));
   CHECK(!globalProxy->Equals(global));
   CHECK(globalProxy->Equals(globalProxy));
 }
 
 
 static void Getter(v8::Local<v8::Name> property,
                    const v8::PropertyCallbackInfo<v8::Value>& info) {
   info.GetReturnValue().Set(v8_str("42!"));
 }
 
 
 static void Enumerator(const v8::PropertyCallbackInfo<v8::Array>& info) {
-  v8::Handle<v8::Array> result = v8::Array::New(info.GetIsolate());
+  v8::Local<v8::Array> result = v8::Array::New(info.GetIsolate());
   result->Set(0, v8_str("universalAnswer"));
   info.GetReturnValue().Set(result);
 }
 
 
 TEST(NamedEnumeratorAndForIn) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope handle_scope(isolate);
   v8::Context::Scope context_scope(context.local());
 
-  v8::Handle<v8::ObjectTemplate> tmpl = v8::ObjectTemplate::New(isolate);
+  v8::Local<v8::ObjectTemplate> tmpl = v8::ObjectTemplate::New(isolate);
   tmpl->SetHandler(v8::NamedPropertyHandlerConfiguration(Getter, NULL, NULL,
                                                          NULL, Enumerator));
-  context->Global()->Set(v8_str("o"), tmpl->NewInstance());
-  v8::Handle<v8::Array> result = v8::Handle<v8::Array>::Cast(CompileRun(
-        "var result = []; for (var k in o) result.push(k); result"));
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("o"),
+                  tmpl->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
+  v8::Local<v8::Array> result = v8::Local<v8::Array>::Cast(
+      CompileRun("var result = []; for (var k in o) result.push(k); result"));
   CHECK_EQ(1u, result->Length());
   CHECK(v8_str("universalAnswer")->Equals(result->Get(0)));
 }
 
 
 TEST(DefinePropertyPostDetach) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
-  v8::Handle<v8::Object> proxy = context->Global();
-  v8::Handle<v8::Function> define_property =
-      CompileRun("(function() {"
-                 "  Object.defineProperty("
-                 "    this,"
-                 "    1,"
-                 "    { configurable: true, enumerable: true, value: 3 });"
-                 "})").As<Function>();
+  v8::Local<v8::Object> proxy = context->Global();
+  v8::Local<v8::Function> define_property =
+      CompileRun(
+          "(function() {"
+          "  Object.defineProperty("
+          "    this,"
+          "    1,"
+          "    { configurable: true, enumerable: true, value: 3 });"
+          "})")
+          .As<Function>();
   context->DetachGlobal();
   define_property->Call(proxy, 0, NULL);
 }
 
 
-static void InstallContextId(v8::Handle<Context> context, int id) {
+static void InstallContextId(v8::Local<Context> context, int id) {
   Context::Scope scope(context);
-  CompileRun("Object.prototype").As<Object>()->
-      Set(v8_str("context_id"), v8::Integer::New(context->GetIsolate(), id));
+  CHECK(CompileRun("Object.prototype")
+            .As<Object>()
+            ->Set(context, v8_str("context_id"),
+                  v8::Integer::New(context->GetIsolate(), id))
+            .FromJust());
 }
 
 
-static void CheckContextId(v8::Handle<Object> object, int expected) {
-  CHECK_EQ(expected, object->Get(v8_str("context_id"))->Int32Value());
+static void CheckContextId(v8::Local<Object> object, int expected) {
+  CHECK_EQ(expected, object->Get(v8_str("context_id"))
+                         ->Int32Value(CcTest::isolate()->GetCurrentContext())
+                         .FromJust());
 }
 
 
 THREADED_TEST(CreationContext) {
   v8::Isolate* isolate = CcTest::isolate();
   HandleScope handle_scope(isolate);
-  Handle<Context> context1 = Context::New(isolate);
+  Local<Context> context1 = Context::New(isolate);
   InstallContextId(context1, 1);
-  Handle<Context> context2 = Context::New(isolate);
+  Local<Context> context2 = Context::New(isolate);
   InstallContextId(context2, 2);
-  Handle<Context> context3 = Context::New(isolate);
+  Local<Context> context3 = Context::New(isolate);
   InstallContextId(context3, 3);
 
   Local<v8::FunctionTemplate> tmpl = v8::FunctionTemplate::New(isolate);
 
   Local<Object> object1;
   Local<Function> func1;
   {
     Context::Scope scope(context1);
     object1 = Object::New(isolate);
-    func1 = tmpl->GetFunction();
+    func1 = tmpl->GetFunction(context1).ToLocalChecked();
   }
 
   Local<Object> object2;
   Local<Function> func2;
   {
     Context::Scope scope(context2);
     object2 = Object::New(isolate);
-    func2 = tmpl->GetFunction();
+    func2 = tmpl->GetFunction(context2).ToLocalChecked();
   }
 
   Local<Object> instance1;
   Local<Object> instance2;
 
   {
     Context::Scope scope(context3);
-    instance1 = func1->NewInstance();
-    instance2 = func2->NewInstance();
+    instance1 = func1->NewInstance(context3).ToLocalChecked();
+    instance2 = func2->NewInstance(context3).ToLocalChecked();
   }
 
   {
-    Handle<Context> other_context = Context::New(isolate);
+    Local<Context> other_context = Context::New(isolate);
     Context::Scope scope(other_context);
     CHECK(object1->CreationContext() == context1);
     CheckContextId(object1, 1);
     CHECK(func1->CreationContext() == context1);
     CheckContextId(func1, 1);
     CHECK(instance1->CreationContext() == context1);
     CheckContextId(instance1, 1);
     CHECK(object2->CreationContext() == context2);
     CheckContextId(object2, 2);
     CHECK(func2->CreationContext() == context2);
@@ skipping 31 matching lines @@
     CHECK(func2->CreationContext() == context2);
     CheckContextId(func2, 2);
     CHECK(instance2->CreationContext() == context2);
     CheckContextId(instance2, 2);
   }
 }
 
 
 THREADED_TEST(CreationContextOfJsFunction) {
   HandleScope handle_scope(CcTest::isolate());
-  Handle<Context> context = Context::New(CcTest::isolate());
+  Local<Context> context = Context::New(CcTest::isolate());
   InstallContextId(context, 1);
 
   Local<Object> function;
   {
     Context::Scope scope(context);
     function = CompileRun("function foo() {}; foo").As<Object>();
   }
 
-  Handle<Context> other_context = Context::New(CcTest::isolate());
+  Local<Context> other_context = Context::New(CcTest::isolate());
   Context::Scope scope(other_context);
   CHECK(function->CreationContext() == context);
   CheckContextId(function, 1);
 }
 
 
 void HasOwnPropertyIndexedPropertyGetter(
     uint32_t index,
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   if (index == 42) info.GetReturnValue().Set(v8_str("yes"));
@@ skipping 29 matching lines @@
     const v8::PropertyCallbackInfo<v8::Value>& info) {
   info.GetReturnValue().Set(v8_str("yes"));
 }
 
 
 TEST(HasOwnProperty) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   { // Check normal properties and defined getters.
-    Handle<Value> value = CompileRun(
+    Local<Value> value = CompileRun(
         "function Foo() {"
         "    this.foo = 11;"
         "    this.__defineGetter__('baz', function() { return 1; });"
         "};"
         "function Bar() { "
         "    this.bar = 13;"
         "    this.__defineGetter__('bla', function() { return 2; });"
         "};"
         "Bar.prototype = new Foo();"
         "new Bar();");
     CHECK(value->IsObject());
-    Handle<Object> object = value->ToObject(isolate);
+    Local<Object> object = value->ToObject(isolate);
     CHECK(object->Has(v8_str("foo")));
     CHECK(!object->HasOwnProperty(v8_str("foo")));
     CHECK(object->HasOwnProperty(v8_str("bar")));
     CHECK(object->Has(v8_str("baz")));
     CHECK(!object->HasOwnProperty(v8_str("baz")));
     CHECK(object->HasOwnProperty(v8_str("bla")));
   }
   { // Check named getter interceptors.
-    Handle<ObjectTemplate> templ = ObjectTemplate::New(isolate);
+    Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
     templ->SetHandler(v8::NamedPropertyHandlerConfiguration(
         HasOwnPropertyNamedPropertyGetter));
-    Handle<Object> instance = templ->NewInstance();
+    Local<Object> instance = templ->NewInstance(env.local()).ToLocalChecked();
     CHECK(!instance->HasOwnProperty(v8_str("42")));
     CHECK(instance->HasOwnProperty(v8_str("foo")));
     CHECK(!instance->HasOwnProperty(v8_str("bar")));
   }
   { // Check indexed getter interceptors.
-    Handle<ObjectTemplate> templ = ObjectTemplate::New(isolate);
+    Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
     templ->SetHandler(v8::IndexedPropertyHandlerConfiguration(
         HasOwnPropertyIndexedPropertyGetter));
-    Handle<Object> instance = templ->NewInstance();
+    Local<Object> instance = templ->NewInstance(env.local()).ToLocalChecked();
     CHECK(instance->HasOwnProperty(v8_str("42")));
     CHECK(!instance->HasOwnProperty(v8_str("43")));
     CHECK(!instance->HasOwnProperty(v8_str("foo")));
   }
   { // Check named query interceptors.
-    Handle<ObjectTemplate> templ = ObjectTemplate::New(isolate);
+    Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
     templ->SetHandler(v8::NamedPropertyHandlerConfiguration(
         0, 0, HasOwnPropertyNamedPropertyQuery));
-    Handle<Object> instance = templ->NewInstance();
+    Local<Object> instance = templ->NewInstance(env.local()).ToLocalChecked();
     CHECK(instance->HasOwnProperty(v8_str("foo")));
     CHECK(!instance->HasOwnProperty(v8_str("bar")));
   }
   { // Check indexed query interceptors.
-    Handle<ObjectTemplate> templ = ObjectTemplate::New(isolate);
+    Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
     templ->SetHandler(v8::IndexedPropertyHandlerConfiguration(
         0, 0, HasOwnPropertyIndexedPropertyQuery));
-    Handle<Object> instance = templ->NewInstance();
+    Local<Object> instance = templ->NewInstance(env.local()).ToLocalChecked();
     CHECK(instance->HasOwnProperty(v8_str("42")));
     CHECK(!instance->HasOwnProperty(v8_str("41")));
   }
   { // Check callbacks.
-    Handle<ObjectTemplate> templ = ObjectTemplate::New(isolate);
+    Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
     templ->SetAccessor(v8_str("foo"), HasOwnPropertyAccessorGetter);
-    Handle<Object> instance = templ->NewInstance();
+    Local<Object> instance = templ->NewInstance(env.local()).ToLocalChecked();
     CHECK(instance->HasOwnProperty(v8_str("foo")));
     CHECK(!instance->HasOwnProperty(v8_str("bar")));
   }
   { // Check that query wins on disagreement.
-    Handle<ObjectTemplate> templ = ObjectTemplate::New(isolate);
+    Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
     templ->SetHandler(v8::NamedPropertyHandlerConfiguration(
         HasOwnPropertyNamedPropertyGetter, 0,
         HasOwnPropertyNamedPropertyQuery2));
-    Handle<Object> instance = templ->NewInstance();
+    Local<Object> instance = templ->NewInstance(env.local()).ToLocalChecked();
     CHECK(!instance->HasOwnProperty(v8_str("foo")));
     CHECK(instance->HasOwnProperty(v8_str("bar")));
   }
 }
 
 
 TEST(IndexedInterceptorWithStringProto) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  Handle<ObjectTemplate> templ = ObjectTemplate::New(isolate);
+  Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->SetHandler(v8::IndexedPropertyHandlerConfiguration(
       NULL, NULL, HasOwnPropertyIndexedPropertyQuery));
   LocalContext context;
-  context->Global()->Set(v8_str("obj"), templ->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("obj"),
+                  templ->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   CompileRun("var s = new String('foobar'); obj.__proto__ = s;");
   // These should be intercepted.
   CHECK(CompileRun("42 in obj")->BooleanValue());
   CHECK(CompileRun("'42' in obj")->BooleanValue());
   // These should fall through to the String prototype.
   CHECK(CompileRun("0 in obj")->BooleanValue());
   CHECK(CompileRun("'0' in obj")->BooleanValue());
   // And these should both fail.
   CHECK(!CompileRun("32 in obj")->BooleanValue());
   CHECK(!CompileRun("'32' in obj")->BooleanValue());
 }
 
 
 void CheckCodeGenerationAllowed() {
-  Handle<Value> result = CompileRun("eval('42')");
-  CHECK_EQ(42, result->Int32Value());
+  Local<v8::Context> context = CcTest::isolate()->GetCurrentContext();
+  Local<Value> result = CompileRun("eval('42')");
+  CHECK_EQ(42, result->Int32Value(context).FromJust());
   result = CompileRun("(function(e) { return e('42'); })(eval)");
-  CHECK_EQ(42, result->Int32Value());
+  CHECK_EQ(42, result->Int32Value(context).FromJust());
   result = CompileRun("var f = new Function('return 42'); f()");
-  CHECK_EQ(42, result->Int32Value());
+  CHECK_EQ(42, result->Int32Value(context).FromJust());
 }
 
 
 void CheckCodeGenerationDisallowed() {
   TryCatch try_catch(CcTest::isolate());
 
-  Handle<Value> result = CompileRun("eval('42')");
+  Local<Value> result = CompileRun("eval('42')");
   CHECK(result.IsEmpty());
   CHECK(try_catch.HasCaught());
   try_catch.Reset();
 
   result = CompileRun("(function(e) { return e('42'); })(eval)");
   CHECK(result.IsEmpty());
   CHECK(try_catch.HasCaught());
   try_catch.Reset();
 
   result = CompileRun("var f = new Function('return 42'); f()");
@@ skipping 42 matching lines @@
   CHECK(!context->IsCodeGenerationFromStringsAllowed());
   CheckCodeGenerationDisallowed();
 }
 
 
 TEST(SetErrorMessageForCodeGenFromStrings) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
   TryCatch try_catch(context->GetIsolate());
 
-  Handle<String> message = v8_str("Message");
-  Handle<String> expected_message = v8_str("Uncaught EvalError: Message");
+  Local<String> message = v8_str("Message");
+  Local<String> expected_message = v8_str("Uncaught EvalError: Message");
   V8::SetAllowCodeGenerationFromStringsCallback(&CodeGenerationDisallowed);
   context->AllowCodeGenerationFromStrings(false);
   context->SetErrorMessageForCodeGenerationFromStrings(message);
-  Handle<Value> result = CompileRun("eval('42')");
+  Local<Value> result = CompileRun("eval('42')");
   CHECK(result.IsEmpty());
   CHECK(try_catch.HasCaught());
-  Handle<String> actual_message = try_catch.Message()->Get();
+  Local<String> actual_message = try_catch.Message()->Get();
   CHECK(expected_message->Equals(actual_message));
 }
 
 
 static void NonObjectThis(const v8::FunctionCallbackInfo<v8::Value>& args) {
 }
 
 
 THREADED_TEST(CallAPIFunctionOnNonObject) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
-  Handle<FunctionTemplate> templ =
+  Local<FunctionTemplate> templ =
       v8::FunctionTemplate::New(isolate, NonObjectThis);
-  Handle<Function> function = templ->GetFunction();
-  context->Global()->Set(v8_str("f"), function);
+  Local<Function> function =
+      templ->GetFunction(context.local()).ToLocalChecked();
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("f"), function)
+            .FromJust());
   TryCatch try_catch(isolate);
   CompileRun("f.call(2)");
 }
 
 
 // Regression test for issue 1470.
 THREADED_TEST(ReadOnlyIndexedProperties) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
 
   LocalContext context;
-  Local<v8::Object> obj = templ->NewInstance();
-  context->Global()->Set(v8_str("obj"), obj);
+  Local<v8::Object> obj = templ->NewInstance(context.local()).ToLocalChecked();
+  CHECK(context->Global()->Set(context.local(), v8_str("obj"), obj).FromJust());
   obj->ForceSet(v8_str("1"), v8_str("DONT_CHANGE"), v8::ReadOnly);
   obj->Set(v8_str("1"), v8_str("foobar"));
   CHECK(v8_str("DONT_CHANGE")->Equals(obj->Get(v8_str("1"))));
   obj->ForceSet(v8_num(2), v8_str("DONT_CHANGE"), v8::ReadOnly);
   obj->Set(v8_num(2), v8_str("foobar"));
   CHECK(v8_str("DONT_CHANGE")->Equals(obj->Get(v8_num(2))));
 
   // Test non-smi case.
   obj->ForceSet(v8_str("2000000000"), v8_str("DONT_CHANGE"), v8::ReadOnly);
   obj->Set(v8_str("2000000000"), v8_str("foobar"));
@@ skipping 58 matching lines @@
   protected_hidden_proto_template->SetHiddenPrototype(true);
 
   // Context for "foreign" objects used in test.
   Local<Context> context = v8::Context::New(isolate);
   context->Enter();
 
   // Plain object, no security check.
   Local<Object> simple_object = Object::New(isolate);
 
   // Object with explicit security check.
-  Local<Object> protected_object = no_proto_template->NewInstance();
+  Local<Object> protected_object =
+      no_proto_template->NewInstance(context).ToLocalChecked();
 
   // JSGlobalProxy object, always have security check.
   Local<Object> proxy_object = context->Global();
 
   // Global object, the  prototype of proxy_object. No security checks.
   Local<Object> global_object = proxy_object->GetPrototype()->ToObject(isolate);
 
   // Hidden prototype without security check.
-  Local<Object> hidden_prototype =
-      hidden_proto_template->GetFunction()->NewInstance();
+  Local<Object> hidden_prototype = hidden_proto_template->GetFunction(context)
+                                       .ToLocalChecked()
+                                       ->NewInstance(context)
+                                       .ToLocalChecked();
   Local<Object> object_with_hidden =
     Object::New(isolate);
   object_with_hidden->SetPrototype(hidden_prototype);
 
   context->Exit();
 
   // Template for object for second context. Values to test are put on it as
   // properties.
   Local<ObjectTemplate> global_template = ObjectTemplate::New(isolate);
   global_template->Set(v8_str("simple"), simple_object);
@@ skipping 70 matching lines @@
 
   CompileRun("function ownfunc() { return { 0: this.id, "
              "                              1: this, "
              "                              toString: function() { "
              "                                  return this[0];"
              "                              }"
              "                             };"
              "}"
              "var id = 'o';"
              "ownfunc");
-  context->Global()->Set(v8_str("func"), foreign_function);
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("func"), foreign_function)
+            .FromJust());
 
   // Sanity check the contexts.
   CHECK(i->Equals(foreign_context->Global()->Get(id)));
   CHECK(o->Equals(context->Global()->Get(id)));
 
   // Checking local function's receiver.
   // Calling function using its call/apply methods.
   TestReceiver(o, context->Global(), "ownfunc.call()");
   TestReceiver(o, context->Global(), "ownfunc.apply()");
   // Making calls through built-in functions.
@@ skipping 42 matching lines @@
 }
 
 
 void CallCompletedCallback2() {
   v8::base::OS::Print("Firing callback 2.\n");
   callback_fired ^= 2;  // Toggle second bit.
 }
 
 
 void RecursiveCall(const v8::FunctionCallbackInfo<v8::Value>& args) {
-  int32_t level = args[0]->Int32Value();
+  int32_t level =
+      args[0]->Int32Value(args.GetIsolate()->GetCurrentContext()).FromJust();
   if (level < 3) {
     level++;
     v8::base::OS::Print("Entering recursion level %d.\n", level);
     char script[64];
     i::Vector<char> script_vector(script, sizeof(script));
     i::SNPrintF(script_vector, "recursion(%d)", level);
     CompileRun(script_vector.start());
     v8::base::OS::Print("Leaving recursion level %d.\n", level);
     CHECK_EQ(0, callback_fired);
   } else {
     v8::base::OS::Print("Recursion ends.\n");
     CHECK_EQ(0, callback_fired);
   }
 }
 
 
 TEST(CallCompletedCallback) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
-  v8::Handle<v8::FunctionTemplate> recursive_runtime =
+  v8::Local<v8::FunctionTemplate> recursive_runtime =
       v8::FunctionTemplate::New(env->GetIsolate(), RecursiveCall);
-  env->Global()->Set(v8_str("recursion"),
-                     recursive_runtime->GetFunction());
+  env->Global()->Set(
+      v8_str("recursion"),
+      recursive_runtime->GetFunction(env.local()).ToLocalChecked());
   // Adding the same callback a second time has no effect.
   env->GetIsolate()->AddCallCompletedCallback(CallCompletedCallback1);
   env->GetIsolate()->AddCallCompletedCallback(CallCompletedCallback1);
   env->GetIsolate()->AddCallCompletedCallback(CallCompletedCallback2);
   v8::base::OS::Print("--- Script (1) ---\n");
-  Local<Script> script = v8::Script::Compile(
-      v8::String::NewFromUtf8(env->GetIsolate(), "recursion(0)"));
+  Local<Script> script = v8::Script::Compile(v8_str("recursion(0)"));
   script->Run();
   CHECK_EQ(3, callback_fired);
 
   v8::base::OS::Print("\n--- Script (2) ---\n");
   callback_fired = 0;
   env->GetIsolate()->RemoveCallCompletedCallback(CallCompletedCallback1);
   script->Run();
   CHECK_EQ(2, callback_fired);
 
   v8::base::OS::Print("\n--- Function ---\n");
   callback_fired = 0;
   Local<Function> recursive_function =
       Local<Function>::Cast(env->Global()->Get(v8_str("recursion")));
-  v8::Handle<Value> args[] = { v8_num(0) };
+  v8::Local<Value> args[] = {v8_num(0)};
   recursive_function->Call(env->Global(), 1, args);
   CHECK_EQ(2, callback_fired);
 }
 
 
 void CallCompletedCallbackNoException() {
   v8::HandleScope scope(CcTest::isolate());
   CompileRun("1+1;");
 }
 
@@ skipping 40 matching lines @@
 }
 
 
 TEST(EnqueueMicrotask) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   CompileRun(
       "var ext1Calls = 0;"
       "var ext2Calls = 0;");
   CompileRun("1+1;");
-  CHECK_EQ(0, CompileRun("ext1Calls")->Int32Value());
-  CHECK_EQ(0, CompileRun("ext2Calls")->Int32Value());
+  CHECK_EQ(0, CompileRun("ext1Calls")->Int32Value(env.local()).FromJust());
+  CHECK_EQ(0, CompileRun("ext2Calls")->Int32Value(env.local()).FromJust());
 
   env->GetIsolate()->EnqueueMicrotask(
       Function::New(env->GetIsolate(), MicrotaskOne));
   CompileRun("1+1;");
-  CHECK_EQ(1, CompileRun("ext1Calls")->Int32Value());
-  CHECK_EQ(0, CompileRun("ext2Calls")->Int32Value());
+  CHECK_EQ(1, CompileRun("ext1Calls")->Int32Value(env.local()).FromJust());
+  CHECK_EQ(0, CompileRun("ext2Calls")->Int32Value(env.local()).FromJust());
 
   env->GetIsolate()->EnqueueMicrotask(
       Function::New(env->GetIsolate(), MicrotaskOne));
   env->GetIsolate()->EnqueueMicrotask(
       Function::New(env->GetIsolate(), MicrotaskTwo));
   CompileRun("1+1;");
-  CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
-  CHECK_EQ(1, CompileRun("ext2Calls")->Int32Value());
+  CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value(env.local()).FromJust());
+  CHECK_EQ(1, CompileRun("ext2Calls")->Int32Value(env.local()).FromJust());
 
   env->GetIsolate()->EnqueueMicrotask(
       Function::New(env->GetIsolate(), MicrotaskTwo));
   CompileRun("1+1;");
-  CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
-  CHECK_EQ(2, CompileRun("ext2Calls")->Int32Value());
+  CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value(env.local()).FromJust());
+  CHECK_EQ(2, CompileRun("ext2Calls")->Int32Value(env.local()).FromJust());
 
   CompileRun("1+1;");
-  CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
-  CHECK_EQ(2, CompileRun("ext2Calls")->Int32Value());
+  CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value(env.local()).FromJust());
+  CHECK_EQ(2, CompileRun("ext2Calls")->Int32Value(env.local()).FromJust());
 
   g_passed_to_three = NULL;
   env->GetIsolate()->EnqueueMicrotask(MicrotaskThree);
   CompileRun("1+1;");
   CHECK(!g_passed_to_three);
-  CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
-  CHECK_EQ(2, CompileRun("ext2Calls")->Int32Value());
+  CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value(env.local()).FromJust());
+  CHECK_EQ(2, CompileRun("ext2Calls")->Int32Value(env.local()).FromJust());
 
   int dummy;
   env->GetIsolate()->EnqueueMicrotask(
       Function::New(env->GetIsolate(), MicrotaskOne));
   env->GetIsolate()->EnqueueMicrotask(MicrotaskThree, &dummy);
   env->GetIsolate()->EnqueueMicrotask(
       Function::New(env->GetIsolate(), MicrotaskTwo));
   CompileRun("1+1;");
   CHECK_EQ(&dummy, g_passed_to_three);
-  CHECK_EQ(3, CompileRun("ext1Calls")->Int32Value());
-  CHECK_EQ(3, CompileRun("ext2Calls")->Int32Value());
+  CHECK_EQ(3, CompileRun("ext1Calls")->Int32Value(env.local()).FromJust());
+  CHECK_EQ(3, CompileRun("ext2Calls")->Int32Value(env.local()).FromJust());
   g_passed_to_three = NULL;
 }
 
 
 static void MicrotaskExceptionOne(
     const v8::FunctionCallbackInfo<Value>& info) {
   v8::HandleScope scope(info.GetIsolate());
   CompileRun("exception1Calls++;");
   info.GetIsolate()->ThrowException(
       v8::Exception::Error(v8_str("first")));
@@ skipping 16 matching lines @@
   CompileRun(
       "var exception1Calls = 0;"
       "var exception2Calls = 0;");
   isolate->EnqueueMicrotask(
       Function::New(isolate, MicrotaskExceptionOne));
   isolate->EnqueueMicrotask(
       Function::New(isolate, MicrotaskExceptionTwo));
   TryCatch try_catch(isolate);
   CompileRun("1+1;");
   CHECK(!try_catch.HasCaught());
-  CHECK_EQ(1, CompileRun("exception1Calls")->Int32Value());
-  CHECK_EQ(1, CompileRun("exception2Calls")->Int32Value());
+  CHECK_EQ(1,
+           CompileRun("exception1Calls")->Int32Value(env.local()).FromJust());
+  CHECK_EQ(1,
+           CompileRun("exception2Calls")->Int32Value(env.local()).FromJust());
 }
 
 
 TEST(SetAutorunMicrotasks) {
   LocalContext env;
   v8::HandleScope scope(env->GetIsolate());
   CompileRun(
       "var ext1Calls = 0;"
       "var ext2Calls = 0;");
   CompileRun("1+1;");
-  CHECK_EQ(0, CompileRun("ext1Calls")->Int32Value());
-  CHECK_EQ(0, CompileRun("ext2Calls")->Int32Value());
+  CHECK_EQ(0, CompileRun("ext1Calls")->Int32Value(env.local()).FromJust());
+  CHECK_EQ(0, CompileRun("ext2Calls")->Int32Value(env.local()).FromJust());
 
   env->GetIsolate()->EnqueueMicrotask(
       Function::New(env->GetIsolate(), MicrotaskOne));
   CompileRun("1+1;");
-  CHECK_EQ(1, CompileRun("ext1Calls")->Int32Value());
-  CHECK_EQ(0, CompileRun("ext2Calls")->Int32Value());
+  CHECK_EQ(1, CompileRun("ext1Calls")->Int32Value(env.local()).FromJust());
+  CHECK_EQ(0, CompileRun("ext2Calls")->Int32Value(env.local()).FromJust());
 
   env->GetIsolate()->SetAutorunMicrotasks(false);
   env->GetIsolate()->EnqueueMicrotask(
       Function::New(env->GetIsolate(), MicrotaskOne));
   env->GetIsolate()->EnqueueMicrotask(
       Function::New(env->GetIsolate(), MicrotaskTwo));
   CompileRun("1+1;");
-  CHECK_EQ(1, CompileRun("ext1Calls")->Int32Value());
-  CHECK_EQ(0, CompileRun("ext2Calls")->Int32Value());
+  CHECK_EQ(1, CompileRun("ext1Calls")->Int32Value(env.local()).FromJust());
+  CHECK_EQ(0, CompileRun("ext2Calls")->Int32Value(env.local()).FromJust());
 
   env->GetIsolate()->RunMicrotasks();
-  CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
-  CHECK_EQ(1, CompileRun("ext2Calls")->Int32Value());
+  CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value(env.local()).FromJust());
+  CHECK_EQ(1, CompileRun("ext2Calls")->Int32Value(env.local()).FromJust());
 
   env->GetIsolate()->EnqueueMicrotask(
       Function::New(env->GetIsolate(), MicrotaskTwo));
   CompileRun("1+1;");
-  CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
-  CHECK_EQ(1, CompileRun("ext2Calls")->Int32Value());
+  CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value(env.local()).FromJust());
+  CHECK_EQ(1, CompileRun("ext2Calls")->Int32Value(env.local()).FromJust());
 
   env->GetIsolate()->RunMicrotasks();
-  CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
-  CHECK_EQ(2, CompileRun("ext2Calls")->Int32Value());
+  CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value(env.local()).FromJust());
+  CHECK_EQ(2, CompileRun("ext2Calls")->Int32Value(env.local()).FromJust());
 
   env->GetIsolate()->SetAutorunMicrotasks(true);
   env->GetIsolate()->EnqueueMicrotask(
       Function::New(env->GetIsolate(), MicrotaskTwo));
   CompileRun("1+1;");
-  CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
-  CHECK_EQ(3, CompileRun("ext2Calls")->Int32Value());
+  CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value(env.local()).FromJust());
+  CHECK_EQ(3, CompileRun("ext2Calls")->Int32Value(env.local()).FromJust());
 
   env->GetIsolate()->EnqueueMicrotask(
       Function::New(env->GetIsolate(), MicrotaskTwo));
   {
     v8::Isolate::SuppressMicrotaskExecutionScope scope(env->GetIsolate());
     CompileRun("1+1;");
-    CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
-    CHECK_EQ(3, CompileRun("ext2Calls")->Int32Value());
+    CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value(env.local()).FromJust());
+    CHECK_EQ(3, CompileRun("ext2Calls")->Int32Value(env.local()).FromJust());
   }
 
   CompileRun("1+1;");
-  CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value());
-  CHECK_EQ(4, CompileRun("ext2Calls")->Int32Value());
+  CHECK_EQ(2, CompileRun("ext1Calls")->Int32Value(env.local()).FromJust());
+  CHECK_EQ(4, CompileRun("ext2Calls")->Int32Value(env.local()).FromJust());
 }
 
 
 TEST(RunMicrotasksWithoutEnteringContext) {
   v8::Isolate* isolate = CcTest::isolate();
   HandleScope handle_scope(isolate);
   isolate->SetAutorunMicrotasks(false);
-  Handle<Context> context = Context::New(isolate);
+  Local<Context> context = Context::New(isolate);
   {
     Context::Scope context_scope(context);
     CompileRun("var ext1Calls = 0;");
     isolate->EnqueueMicrotask(Function::New(isolate, MicrotaskOne));
   }
   isolate->RunMicrotasks();
   {
     Context::Scope context_scope(context);
-    CHECK_EQ(1, CompileRun("ext1Calls")->Int32Value());
+    CHECK_EQ(1, CompileRun("ext1Calls")->Int32Value(context).FromJust());
   }
   isolate->SetAutorunMicrotasks(true);
 }
 
 
 static void DebugEventInObserver(const v8::Debug::EventDetails& event_details) {
   v8::DebugEvent event = event_details.GetEvent();
   if (event != v8::Break) return;
-  Handle<Object> exec_state = event_details.GetExecutionState();
-  Handle<Value> break_id = exec_state->Get(v8_str("break_id"));
+  Local<Object> exec_state = event_details.GetExecutionState();
+  Local<Value> break_id = exec_state->Get(v8_str("break_id"));
   CompileRun("function f(id) { new FrameDetails(id, 0); }");
-  Handle<Function> fun =
-      Handle<Function>::Cast(CcTest::global()->Get(v8_str("f")));
+  Local<Function> fun =
+      Local<Function>::Cast(CcTest::global()->Get(v8_str("f")));
   fun->Call(CcTest::global(), 1, &break_id);
 }
 
 
 TEST(Regress385349) {
   i::FLAG_allow_natives_syntax = true;
   v8::Isolate* isolate = CcTest::isolate();
   HandleScope handle_scope(isolate);
   isolate->SetAutorunMicrotasks(false);
-  Handle<Context> context = Context::New(isolate);
+  Local<Context> context = Context::New(isolate);
   v8::Debug::SetDebugEventListener(DebugEventInObserver);
   {
     Context::Scope context_scope(context);
     CompileRun("var obj = {};"
                "Object.observe(obj, function(changes) { debugger; });"
                "obj.a = 0;");
   }
   isolate->RunMicrotasks();
   isolate->SetAutorunMicrotasks(true);
   v8::Debug::SetDebugEventListener(NULL);
@@ skipping 242 matching lines @@
 }
 
 
 THREADED_TEST(InstanceCheckOnInstanceAccessor) {
   v8::internal::FLAG_allow_natives_syntax = true;
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
 
   Local<FunctionTemplate> templ = FunctionTemplate::New(context->GetIsolate());
   Local<ObjectTemplate> inst = templ->InstanceTemplate();
-  inst->SetAccessor(v8_str("foo"),
-                    InstanceCheckedGetter, InstanceCheckedSetter,
-                    Handle<Value>(),
-                    v8::DEFAULT,
-                    v8::None,
+  inst->SetAccessor(v8_str("foo"), InstanceCheckedGetter, InstanceCheckedSetter,
+                    Local<Value>(), v8::DEFAULT, v8::None,
                     v8::AccessorSignature::New(context->GetIsolate(), templ));
-  context->Global()->Set(v8_str("f"), templ->GetFunction());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("f"),
+                  templ->GetFunction(context.local()).ToLocalChecked())
+            .FromJust());
 
   printf("Testing positive ...\n");
   CompileRun("var obj = new f();");
   CHECK(templ->HasInstance(context->Global()->Get(v8_str("obj"))));
   CheckInstanceCheckedAccessors(true);
 
   printf("Testing negative ...\n");
   CompileRun("var obj = {};"
              "obj.__proto__ = new f();");
   CHECK(!templ->HasInstance(context->Global()->Get(v8_str("obj"))));
@@ skipping 12 matching lines @@
 
 THREADED_TEST(InstanceCheckOnInstanceAccessorWithInterceptor) {
   v8::internal::FLAG_allow_natives_syntax = true;
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
 
   Local<FunctionTemplate> templ = FunctionTemplate::New(context->GetIsolate());
   Local<ObjectTemplate> inst = templ->InstanceTemplate();
   templ->InstanceTemplate()->SetNamedPropertyHandler(EmptyInterceptorGetter,
                                                      EmptyInterceptorSetter);
-  inst->SetAccessor(v8_str("foo"),
-                    InstanceCheckedGetter, InstanceCheckedSetter,
-                    Handle<Value>(),
-                    v8::DEFAULT,
-                    v8::None,
+  inst->SetAccessor(v8_str("foo"), InstanceCheckedGetter, InstanceCheckedSetter,
+                    Local<Value>(), v8::DEFAULT, v8::None,
                     v8::AccessorSignature::New(context->GetIsolate(), templ));
-  context->Global()->Set(v8_str("f"), templ->GetFunction());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("f"),
+                  templ->GetFunction(context.local()).ToLocalChecked())
+            .FromJust());
 
   printf("Testing positive ...\n");
   CompileRun("var obj = new f();");
   CHECK(templ->HasInstance(context->Global()->Get(v8_str("obj"))));
   CheckInstanceCheckedAccessors(true);
 
   printf("Testing negative ...\n");
   CompileRun("var obj = {};"
              "obj.__proto__ = new f();");
   CHECK(!templ->HasInstance(context->Global()->Get(v8_str("obj"))));
   CheckInstanceCheckedAccessors(false);
 }
 
 
 THREADED_TEST(InstanceCheckOnPrototypeAccessor) {
   v8::internal::FLAG_allow_natives_syntax = true;
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
 
   Local<FunctionTemplate> templ = FunctionTemplate::New(context->GetIsolate());
   Local<ObjectTemplate> proto = templ->PrototypeTemplate();
   proto->SetAccessor(v8_str("foo"), InstanceCheckedGetter,
-                     InstanceCheckedSetter, Handle<Value>(), v8::DEFAULT,
+                     InstanceCheckedSetter, Local<Value>(), v8::DEFAULT,
                      v8::None,
                      v8::AccessorSignature::New(context->GetIsolate(), templ));
-  context->Global()->Set(v8_str("f"), templ->GetFunction());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("f"),
+                  templ->GetFunction(context.local()).ToLocalChecked())
+            .FromJust());
 
   printf("Testing positive ...\n");
   CompileRun("var obj = new f();");
   CHECK(templ->HasInstance(context->Global()->Get(v8_str("obj"))));
   CheckInstanceCheckedAccessors(true);
 
   printf("Testing negative ...\n");
   CompileRun("var obj = {};"
              "obj.__proto__ = new f();");
   CHECK(!templ->HasInstance(context->Global()->Get(v8_str("obj"))));
@@ skipping 59 matching lines @@
   LocalContext context;
   Local<ObjectTemplate> templ = ObjectTemplate::New(context->GetIsolate());
   if (interceptor) {
     templ->SetHandler(v8::NamedPropertyHandlerConfiguration(FooGetInterceptor,
                                                             FooSetInterceptor));
   } else {
     templ->SetAccessor(v8_str("foo"),
                        GetterWhichReturns42,
                        SetterWhichSetsYOnThisTo23);
   }
-  context->Global()->Set(v8_str("obj"), templ->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("obj"),
+                  templ->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
 
   // Turn monomorphic on slow object with native accessor, then turn
   // polymorphic, finally optimize to create negative lookup and fail.
   CompileRun(do_store ?
              "function f(x) { x.foo = void 0; }" :
              "function f(x) { return x.foo; }");
   CompileRun("obj.y = void 0;");
   if (!interceptor) {
     CompileRun("%OptimizeObjectForAddingMultipleProperties(obj, 1);");
   }
   CompileRun("obj.__proto__ = null;"
              "f(obj); f(obj); f(obj);");
   if (polymorphic) {
     CompileRun("f({});");
   }
   CompileRun("obj.y = void 0;"
              "%OptimizeFunctionOnNextCall(f);");
   if (remove_accessor) {
     CompileRun("delete obj.foo;");
   }
   CompileRun("var result = f(obj);");
   if (do_store) {
     CompileRun("result = obj.y;");
   }
   if (remove_accessor && !interceptor) {
     CHECK(context->Global()->Get(v8_str("result"))->IsUndefined());
   } else {
-    CHECK_EQ(do_store ? 23 : 42,
-             context->Global()->Get(v8_str("result"))->Int32Value());
+    CHECK_EQ(do_store ? 23 : 42, context->Global()
+                                     ->Get(v8_str("result"))
+                                     ->Int32Value(context.local())
+                                     .FromJust());
   }
 }
 
 
 THREADED_TEST(Regress137002a) {
   i::FLAG_allow_natives_syntax = true;
   i::FLAG_compilation_cache = false;
   v8::HandleScope scope(CcTest::isolate());
   for (int i = 0; i < 16; i++) {
     Helper137002(i & 8, i & 4, i & 2, i & 1);
   }
 }
 
 
 THREADED_TEST(Regress137002b) {
   i::FLAG_allow_natives_syntax = true;
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->SetAccessor(v8_str("foo"),
                      GetterWhichReturns42,
                      SetterWhichSetsYOnThisTo23);
-  context->Global()->Set(v8_str("obj"), templ->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("obj"),
+                  templ->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
 
   // Turn monomorphic on slow object with native accessor, then just
   // delete the property and fail.
   CompileRun("function load(x) { return x.foo; }"
              "function store(x) { x.foo = void 0; }"
              "function keyed_load(x, key) { return x[key]; }"
              // Second version of function has a different source (add void 0)
              // so that it does not share code with the first version.  This
              // ensures that the ICs are monomorphic.
              "function load2(x) { void 0; return x.foo; }"
@@ skipping 48 matching lines @@
 
 THREADED_TEST(Regress142088) {
   i::FLAG_allow_natives_syntax = true;
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->SetAccessor(v8_str("foo"),
                      GetterWhichReturns42,
                      SetterWhichSetsYOnThisTo23);
-  context->Global()->Set(v8_str("obj"), templ->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("obj"),
+                  templ->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
 
   CompileRun("function load(x) { return x.foo; }"
              "var o = Object.create(obj);"
              "%OptimizeObjectForAddingMultipleProperties(obj, 1);"
              "load(o); load(o); load(o); load(o);");
 }
 
 
 THREADED_TEST(Regress137496) {
   i::FLAG_expose_gc = true;
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
 
   // Compile a try-finally clause where the finally block causes a GC
   // while there still is a message pending for external reporting.
   TryCatch try_catch(context->GetIsolate());
   try_catch.SetVerbose(true);
   CompileRun("try { throw new Error(); } finally { gc(); }");
   CHECK(try_catch.HasCaught());
 }
 
 
 THREADED_TEST(Regress157124) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
-  Local<Object> obj = templ->NewInstance();
+  Local<Object> obj = templ->NewInstance(context.local()).ToLocalChecked();
   obj->GetIdentityHash();
   obj->DeletePrivate(context.local(),
                      v8::Private::ForApi(isolate, v8_str("Bug")))
       .FromJust();
 }
 
 
 THREADED_TEST(Regress2535) {
   LocalContext context;
   v8::HandleScope scope(context->GetIsolate());
@@ skipping 20 matching lines @@
 }
 
 
 THREADED_TEST(Regress260106) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
   Local<FunctionTemplate> templ = FunctionTemplate::New(isolate,
                                                         DummyCallHandler);
   CompileRun("for (var i = 0; i < 128; i++) Object.prototype[i] = 0;");
-  Local<Function> function = templ->GetFunction();
+  Local<Function> function =
+      templ->GetFunction(context.local()).ToLocalChecked();
   CHECK(!function.IsEmpty());
   CHECK(function->IsFunction());
 }
 
 
 THREADED_TEST(JSONParseObject) {
   LocalContext context;
   HandleScope scope(context->GetIsolate());
   Local<Value> obj = v8::JSON::Parse(v8_str("{\"x\":42}"));
-  Handle<Object> global = context->Global();
+  Local<Object> global = context->Global();
   global->Set(v8_str("obj"), obj);
   ExpectString("JSON.stringify(obj)", "{\"x\":42}");
 }
 
 
 THREADED_TEST(JSONParseNumber) {
   LocalContext context;
   HandleScope scope(context->GetIsolate());
   Local<Value> obj = v8::JSON::Parse(v8_str("42"));
-  Handle<Object> global = context->Global();
+  Local<Object> global = context->Global();
   global->Set(v8_str("obj"), obj);
   ExpectString("JSON.stringify(obj)", "42");
 }
 
 
 #if V8_OS_POSIX && !V8_OS_NACL
 class ThreadInterruptTest {
  public:
   ThreadInterruptTest() : sem_(0), sem_value_(0) { }
   ~ThreadInterruptTest() {}
@@ skipping 61 matching lines @@
 }
 
 
 TEST(JSONStringifyAccessCheck) {
   v8::V8::Initialize();
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
 
   // Create an ObjectTemplate for global objects and install access
   // check callbacks that will block access.
-  v8::Handle<v8::ObjectTemplate> global_template =
+  v8::Local<v8::ObjectTemplate> global_template =
       v8::ObjectTemplate::New(isolate);
   global_template->SetAccessCheckCallback(AccessAlwaysBlocked);
 
   // Create a context and set an x property on it's global object.
   LocalContext context0(NULL, global_template);
-  v8::Handle<v8::Object> global0 = context0->Global();
+  v8::Local<v8::Object> global0 = context0->Global();
   global0->Set(v8_str("x"), v8_num(42));
   ExpectString("JSON.stringify(this)", "{\"x\":42}");
 
   for (int i = 0; i < 2; i++) {
     if (i == 1) {
       // Install a toJSON function on the second run.
-      v8::Handle<v8::FunctionTemplate> toJSON =
+      v8::Local<v8::FunctionTemplate> toJSON =
           v8::FunctionTemplate::New(isolate, UnreachableCallback);
 
-      global0->Set(v8_str("toJSON"), toJSON->GetFunction());
+      global0->Set(v8_str("toJSON"),
+                   toJSON->GetFunction(context0.local()).ToLocalChecked());
     }
     // Create a context with a different security token so that the
     // failed access check callback will be called on each access.
     LocalContext context1(NULL, global_template);
-    context1->Global()->Set(v8_str("other"), global0);
+    CHECK(context1->Global()
+              ->Set(context1.local(), v8_str("other"), global0)
+              .FromJust());
 
     CHECK(CompileRun("JSON.stringify(other)").IsEmpty());
     CHECK(CompileRun("JSON.stringify({ 'a' : other, 'b' : ['c'] })").IsEmpty());
     CHECK(CompileRun("JSON.stringify([other, 'b', 'c'])").IsEmpty());
   }
 }
 
 
 bool access_check_fail_thrown = false;
 bool catch_callback_called = false;
@@ skipping 46 matching lines @@
 
 TEST(AccessCheckThrows) {
   i::FLAG_allow_natives_syntax = true;
   v8::V8::Initialize();
   v8::V8::SetFailedAccessCheckCallbackFunction(&FailedAccessCheckThrows);
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
 
   // Create an ObjectTemplate for global objects and install access
   // check callbacks that will block access.
-  v8::Handle<v8::ObjectTemplate> global_template =
+  v8::Local<v8::ObjectTemplate> global_template =
       v8::ObjectTemplate::New(isolate);
   global_template->SetAccessCheckCallback(AccessAlwaysBlocked);
 
   // Create a context and set an x property on it's global object.
   LocalContext context0(NULL, global_template);
-  v8::Handle<v8::Object> global0 = context0->Global();
+  v8::Local<v8::Object> global0 = context0->Global();
 
   // Create a context with a different security token so that the
   // failed access check callback will be called on each access.
   LocalContext context1(NULL, global_template);
-  context1->Global()->Set(v8_str("other"), global0);
+  CHECK(context1->Global()
+            ->Set(context1.local(), v8_str("other"), global0)
+            .FromJust());
 
-  v8::Handle<v8::FunctionTemplate> catcher_fun =
+  v8::Local<v8::FunctionTemplate> catcher_fun =
       v8::FunctionTemplate::New(isolate, CatcherCallback);
-  context1->Global()->Set(v8_str("catcher"), catcher_fun->GetFunction());
+  CHECK(context1->Global()
+            ->Set(context1.local(), v8_str("catcher"),
+                  catcher_fun->GetFunction(context1.local()).ToLocalChecked())
+            .FromJust());
 
-  v8::Handle<v8::FunctionTemplate> has_own_property_fun =
+  v8::Local<v8::FunctionTemplate> has_own_property_fun =
       v8::FunctionTemplate::New(isolate, HasOwnPropertyCallback);
-  context1->Global()->Set(v8_str("has_own_property"),
-                          has_own_property_fun->GetFunction());
+  CHECK(context1->Global()
+            ->Set(context1.local(), v8_str("has_own_property"),
+                  has_own_property_fun->GetFunction(context1.local())
+                      .ToLocalChecked())
+            .FromJust());
 
   {
     v8::TryCatch try_catch(isolate);
     access_check_fail_thrown = false;
     CompileRun("other.x;");
     CHECK(access_check_fail_thrown);
     CHECK(try_catch.HasCaught());
   }
 
   CheckCorrectThrow("other.x");
@@ skipping 112 matching lines @@
   InterruptThread i_thread;
 };
 
 
 class RequestInterruptTestWithFunctionCall
     : public RequestInterruptTestBaseWithSimpleInterrupt {
  public:
   virtual void TestBody() {
     Local<Function> func = Function::New(
         isolate_, ShouldContinueCallback, v8::External::New(isolate_, this));
-    env_->Global()->Set(v8_str("ShouldContinue"), func);
+    CHECK(env_->Global()
+              ->Set(env_.local(), v8_str("ShouldContinue"), func)
+              .FromJust());
 
     CompileRun("while (ShouldContinue()) { }");
   }
 };
 
 
 class RequestInterruptTestWithMethodCall
     : public RequestInterruptTestBaseWithSimpleInterrupt {
  public:
   virtual void TestBody() {
     v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate_);
     v8::Local<v8::Template> proto = t->PrototypeTemplate();
     proto->Set(v8_str("shouldContinue"), Function::New(
         isolate_, ShouldContinueCallback, v8::External::New(isolate_, this)));
-    env_->Global()->Set(v8_str("Klass"), t->GetFunction());
+    CHECK(env_->Global()
+              ->Set(env_.local(), v8_str("Klass"),
+                    t->GetFunction(env_.local()).ToLocalChecked())
+              .FromJust());
 
     CompileRun("var obj = new Klass; while (obj.shouldContinue()) { }");
   }
 };
 
 
 class RequestInterruptTestWithAccessor
     : public RequestInterruptTestBaseWithSimpleInterrupt {
  public:
   virtual void TestBody() {
     v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate_);
     v8::Local<v8::Template> proto = t->PrototypeTemplate();
     proto->SetAccessorProperty(v8_str("shouldContinue"), FunctionTemplate::New(
         isolate_, ShouldContinueCallback, v8::External::New(isolate_, this)));
-    env_->Global()->Set(v8_str("Klass"), t->GetFunction());
+    CHECK(env_->Global()
+              ->Set(env_.local(), v8_str("Klass"),
+                    t->GetFunction(env_.local()).ToLocalChecked())
+              .FromJust());
 
     CompileRun("var obj = new Klass; while (obj.shouldContinue) { }");
   }
 };
 
 
 class RequestInterruptTestWithNativeAccessor
     : public RequestInterruptTestBaseWithSimpleInterrupt {
  public:
   virtual void TestBody() {
     v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate_);
     t->InstanceTemplate()->SetNativeDataProperty(
         v8_str("shouldContinue"),
         &ShouldContinueNativeGetter,
         NULL,
         v8::External::New(isolate_, this));
-    env_->Global()->Set(v8_str("Klass"), t->GetFunction());
+    CHECK(env_->Global()
+              ->Set(env_.local(), v8_str("Klass"),
+                    t->GetFunction(env_.local()).ToLocalChecked())
+              .FromJust());
 
     CompileRun("var obj = new Klass; while (obj.shouldContinue) { }");
   }
 
  private:
   static void ShouldContinueNativeGetter(
       Local<String> property,
       const v8::PropertyCallbackInfo<v8::Value>& info) {
     RequestInterruptTestBase* test =
         reinterpret_cast<RequestInterruptTestBase*>(
             info.Data().As<v8::External>()->Value());
     info.GetReturnValue().Set(test->ShouldContinue());
   }
 };
 
 
 class RequestInterruptTestWithMethodCallAndInterceptor
     : public RequestInterruptTestBaseWithSimpleInterrupt {
  public:
   virtual void TestBody() {
     v8::Local<v8::FunctionTemplate> t = v8::FunctionTemplate::New(isolate_);
     v8::Local<v8::Template> proto = t->PrototypeTemplate();
     proto->Set(v8_str("shouldContinue"), Function::New(
         isolate_, ShouldContinueCallback, v8::External::New(isolate_, this)));
     v8::Local<v8::ObjectTemplate> instance_template = t->InstanceTemplate();
     instance_template->SetHandler(
         v8::NamedPropertyHandlerConfiguration(EmptyInterceptor));
 
-    env_->Global()->Set(v8_str("Klass"), t->GetFunction());
+    CHECK(env_->Global()
+              ->Set(env_.local(), v8_str("Klass"),
+                    t->GetFunction(env_.local()).ToLocalChecked())
+              .FromJust());
 
     CompileRun("var obj = new Klass; while (obj.shouldContinue()) { }");
   }
 
  private:
   static void EmptyInterceptor(
       Local<Name> property, const v8::PropertyCallbackInfo<v8::Value>& info) {}
 };
 
 
@@ skipping 86 matching lines @@
  public:
   RequestMultipleInterrupts() : i_thread(this), counter_(0) {}
 
   virtual void StartInterruptThread() {
     i_thread.Start();
   }
 
   virtual void TestBody() {
     Local<Function> func = Function::New(
         isolate_, ShouldContinueCallback, v8::External::New(isolate_, this));
-    env_->Global()->Set(v8_str("ShouldContinue"), func);
+    CHECK(env_->Global()
+              ->Set(env_.local(), v8_str("ShouldContinue"), func)
+              .FromJust());
 
     CompileRun("while (ShouldContinue()) { }");
   }
 
  private:
   class InterruptThread : public v8::base::Thread {
    public:
     enum { NUM_INTERRUPTS = 10 };
     explicit InterruptThread(RequestMultipleInterrupts* test)
         : Thread(Options("RequestInterruptTest")), test_(test) {}
@@ skipping 50 matching lines @@
 }
 
 
 THREADED_TEST(FunctionNew) {
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
   v8::HandleScope scope(isolate);
   Local<Object> data = v8::Object::New(isolate);
   function_new_expected_env = data;
   Local<Function> func = Function::New(isolate, FunctionNewCallback, data);
-  env->Global()->Set(v8_str("func"), func);
+  CHECK(env->Global()->Set(env.local(), v8_str("func"), func).FromJust());
   Local<Value> result = CompileRun("func();");
   CHECK(v8::Integer::New(isolate, 17)->Equals(result));
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   // Verify function not cached
   auto serial_number = handle(
       i::Smi::cast(i::Handle<i::JSFunction>::cast(v8::Utils::OpenHandle(*func))
                        ->shared()
                        ->get_api_func_data()
                        ->serial_number()),
       i_isolate);
   auto cache = i_isolate->function_cache();
   CHECK(cache->Lookup(serial_number)->IsTheHole());
   // Verify that each Function::New creates a new function instance
   Local<Object> data2 = v8::Object::New(isolate);
   function_new_expected_env = data2;
   Local<Function> func2 = Function::New(isolate, FunctionNewCallback, data2);
   CHECK(!func2->IsNull());
   CHECK(!func->Equals(func2));
-  env->Global()->Set(v8_str("func2"), func2);
+  CHECK(env->Global()->Set(env.local(), v8_str("func2"), func2).FromJust());
   Local<Value> result2 = CompileRun("func2();");
   CHECK(v8::Integer::New(isolate, 17)->Equals(result2));
 }
 
 
 TEST(EscapeableHandleScope) {
   HandleScope outer_scope(CcTest::isolate());
   LocalContext context;
   const int runs = 10;
   Local<String> values[runs];
@@ skipping 19 matching lines @@
   CHECK(info.Holder() != info.This());
 }
 
 
 TEST(Regress239669) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
   Local<ObjectTemplate> templ = ObjectTemplate::New(isolate);
   templ->SetAccessor(v8_str("x"), 0, SetterWhichExpectsThisAndHolderToDiffer);
-  context->Global()->Set(v8_str("P"), templ->NewInstance());
+  CHECK(context->Global()
+            ->Set(context.local(), v8_str("P"),
+                  templ->NewInstance(context.local()).ToLocalChecked())
+            .FromJust());
   CompileRun(
       "function C1() {"
       "  this.x = 23;"
       "};"
       "C1.prototype = P;"
       "for (var i = 0; i < 4; i++ ) {"
       "  new C1();"
       "}");
 }
 
@@ skipping 63 matching lines @@
           signature = v8::Signature::New(isolate, parent_template);
           break;
       }
       signature_template = function_template->InstanceTemplate();
     }
     // Global object must pass checks.
     Local<v8::Context> context =
         v8::Context::New(isolate, NULL, signature_template);
     v8::Context::Scope context_scope(context);
     // Install regular object that can pass signature checks.
-    Local<Object> function_receiver = signature_template->NewInstance();
-    context->Global()->Set(v8_str("function_receiver"), function_receiver);
+    Local<Object> function_receiver =
+        signature_template->NewInstance(context).ToLocalChecked();
+    CHECK(context->Global()
+              ->Set(context, v8_str("function_receiver"), function_receiver)
+              .FromJust());
     // Get the holder objects.
     Local<Object> inner_global =
         Local<Object>::Cast(context->Global()->GetPrototype());
     // Install functions on hidden prototype object if there is one.
     data = Object::New(isolate);
     Local<FunctionTemplate> function_template = FunctionTemplate::New(
         isolate, OptimizationCallback, data, signature);
-    Local<Function> function = function_template->GetFunction();
+    Local<Function> function =
+        function_template->GetFunction(context).ToLocalChecked();
     Local<Object> global_holder = inner_global;
     Local<Object> function_holder = function_receiver;
     if (signature_type == kSignatureOnPrototype) {
       function_holder = Local<Object>::Cast(function_holder->GetPrototype());
       global_holder = Local<Object>::Cast(global_holder->GetPrototype());
     }
     global_holder->Set(v8_str("g_f"), function);
     global_holder->SetAccessorProperty(v8_str("g_acc"), function, function);
     function_holder->Set(v8_str("f"), function);
     function_holder->SetAccessorProperty(v8_str("acc"), function, function);
@@ skipping 87 matching lines @@
   ApiCallOptimizationChecker checker;
   checker.RunAll();
 }
 
 
 TEST(FunctionCallOptimizationMultipleArgs) {
   i::FLAG_allow_natives_syntax = true;
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
-  Handle<Object> global = context->Global();
+  Local<Object> global = context->Global();
   Local<v8::Function> function = Function::New(isolate, Returns42);
   global->Set(v8_str("x"), function);
   CompileRun(
       "function x_wrap() {\n"
       "  for (var i = 0; i < 5; i++) {\n"
       "    x(1,2,3);\n"
       "  }\n"
       "}\n"
       "x_wrap();\n"
       "%OptimizeFunctionOnNextCall(x_wrap);"
       "x_wrap();\n");
 }
 
 
 static void ReturnsSymbolCallback(
     const v8::FunctionCallbackInfo<v8::Value>& info) {
   info.GetReturnValue().Set(v8::Symbol::New(info.GetIsolate()));
 }
 
 
 TEST(ApiCallbackCanReturnSymbols) {
   i::FLAG_allow_natives_syntax = true;
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
-  Handle<Object> global = context->Global();
+  Local<Object> global = context->Global();
   Local<v8::Function> function = Function::New(isolate, ReturnsSymbolCallback);
   global->Set(v8_str("x"), function);
   CompileRun(
       "function x_wrap() {\n"
       "  for (var i = 0; i < 5; i++) {\n"
       "    x();\n"
       "  }\n"
       "}\n"
       "x_wrap();\n"
       "%OptimizeFunctionOnNextCall(x_wrap);"
       "x_wrap();\n");
 }
 
 
 TEST(EmptyApiCallback) {
   LocalContext context;
   auto isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
   auto global = context->Global();
-  auto function = FunctionTemplate::New(isolate)->GetFunction();
+  auto function = FunctionTemplate::New(isolate)
+                      ->GetFunction(context.local())
+                      .ToLocalChecked();
   global->Set(v8_str("x"), function);
 
   auto result = CompileRun("x()");
   CHECK(v8::Utils::OpenHandle(*result)->IsJSGlobalProxy());
 
   result = CompileRun("x(1,2,3)");
   CHECK(v8::Utils::OpenHandle(*result)->IsJSGlobalProxy());
 
   result = CompileRun("7 + x.call(3) + 11");
   CHECK(result->IsInt32());
-  CHECK_EQ(21, result->Int32Value());
+  CHECK_EQ(21, result->Int32Value(context.local()).FromJust());
 
   result = CompileRun("7 + x.call(3, 101, 102, 103, 104) + 11");
   CHECK(result->IsInt32());
-  CHECK_EQ(21, result->Int32Value());
+  CHECK_EQ(21, result->Int32Value(context.local()).FromJust());
 
   result = CompileRun("var y = []; x.call(y)");
   CHECK(result->IsArray());
 
   result = CompileRun("x.call(y, 1, 2, 3, 4)");
   CHECK(result->IsArray());
 }
 
 
 TEST(SimpleSignatureCheck) {
   LocalContext context;
   auto isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
   auto global = context->Global();
   auto sig_obj = FunctionTemplate::New(isolate);
   auto sig = v8::Signature::New(isolate, sig_obj);
-  auto x = FunctionTemplate::New(isolate, Returns42, Handle<Value>(), sig);
-  global->Set(v8_str("sig_obj"), sig_obj->GetFunction());
-  global->Set(v8_str("x"), x->GetFunction());
+  auto x = FunctionTemplate::New(isolate, Returns42, Local<Value>(), sig);
+  global->Set(v8_str("sig_obj"),
+              sig_obj->GetFunction(context.local()).ToLocalChecked());
+  global->Set(v8_str("x"), x->GetFunction(context.local()).ToLocalChecked());
   CompileRun("var s = new sig_obj();");
   {
     TryCatch try_catch(isolate);
     CompileRun("x()");
     CHECK(try_catch.HasCaught());
   }
   {
     TryCatch try_catch(isolate);
     CompileRun("x.call(1)");
     CHECK(try_catch.HasCaught());
   }
   {
     TryCatch try_catch(isolate);
     auto result = CompileRun("s.x = x; s.x()");
     CHECK(!try_catch.HasCaught());
-    CHECK_EQ(42, result->Int32Value());
+    CHECK_EQ(42, result->Int32Value(context.local()).FromJust());
   }
   {
     TryCatch try_catch(isolate);
     auto result = CompileRun("x.call(s)");
     CHECK(!try_catch.HasCaught());
-    CHECK_EQ(42, result->Int32Value());
+    CHECK_EQ(42, result->Int32Value(context.local()).FromJust());
   }
 }
 
 
 TEST(ChainSignatureCheck) {
   LocalContext context;
   auto isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
   auto global = context->Global();
   auto sig_obj = FunctionTemplate::New(isolate);
   auto sig = v8::Signature::New(isolate, sig_obj);
   for (int i = 0; i < 4; ++i) {
     auto temp = FunctionTemplate::New(isolate);
     temp->Inherit(sig_obj);
     sig_obj = temp;
   }
-  auto x = FunctionTemplate::New(isolate, Returns42, Handle<Value>(), sig);
-  global->Set(v8_str("sig_obj"), sig_obj->GetFunction());
-  global->Set(v8_str("x"), x->GetFunction());
+  auto x = FunctionTemplate::New(isolate, Returns42, Local<Value>(), sig);
+  global->Set(v8_str("sig_obj"),
+              sig_obj->GetFunction(context.local()).ToLocalChecked());
+  global->Set(v8_str("x"), x->GetFunction(context.local()).ToLocalChecked());
   CompileRun("var s = new sig_obj();");
   {
     TryCatch try_catch(isolate);
     CompileRun("x()");
     CHECK(try_catch.HasCaught());
   }
   {
     TryCatch try_catch(isolate);
     CompileRun("x.call(1)");
     CHECK(try_catch.HasCaught());
   }
   {
     TryCatch try_catch(isolate);
     auto result = CompileRun("s.x = x; s.x()");
     CHECK(!try_catch.HasCaught());
-    CHECK_EQ(42, result->Int32Value());
+    CHECK_EQ(42, result->Int32Value(context.local()).FromJust());
   }
   {
     TryCatch try_catch(isolate);
     auto result = CompileRun("x.call(s)");
     CHECK(!try_catch.HasCaught());
-    CHECK_EQ(42, result->Int32Value());
+    CHECK_EQ(42, result->Int32Value(context.local()).FromJust());
   }
 }
 
 
 TEST(PrototypeSignatureCheck) {
   LocalContext context;
   auto isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
   auto global = context->Global();
   auto sig_obj = FunctionTemplate::New(isolate);
   sig_obj->SetHiddenPrototype(true);
   auto sig = v8::Signature::New(isolate, sig_obj);
-  auto x = FunctionTemplate::New(isolate, Returns42, Handle<Value>(), sig);
-  global->Set(v8_str("sig_obj"), sig_obj->GetFunction());
-  global->Set(v8_str("x"), x->GetFunction());
+  auto x = FunctionTemplate::New(isolate, Returns42, Local<Value>(), sig);
+  global->Set(v8_str("sig_obj"),
+              sig_obj->GetFunction(context.local()).ToLocalChecked());
+  global->Set(v8_str("x"), x->GetFunction(context.local()).ToLocalChecked());
   CompileRun("s = {}; s.__proto__ = new sig_obj();");
   {
     TryCatch try_catch(isolate);
     CompileRun("x()");
     CHECK(try_catch.HasCaught());
   }
   {
     TryCatch try_catch(isolate);
     CompileRun("x.call(1)");
     CHECK(try_catch.HasCaught());
   }
   {
     TryCatch try_catch(isolate);
     auto result = CompileRun("s.x = x; s.x()");
     CHECK(!try_catch.HasCaught());
-    CHECK_EQ(42, result->Int32Value());
+    CHECK_EQ(42, result->Int32Value(context.local()).FromJust());
   }
   {
     TryCatch try_catch(isolate);
     auto result = CompileRun("x.call(s)");
     CHECK(!try_catch.HasCaught());
-    CHECK_EQ(42, result->Int32Value());
+    CHECK_EQ(42, result->Int32Value(context.local()).FromJust());
   }
 }
 
 
 static const char* last_event_message;
 static int last_event_status;
 void StoringEventLoggerCallback(const char* message, int status) {
     last_event_message = message;
     last_event_status = status;
 }
@@ skipping 11 matching lines @@
   histogramTimer.Stop();
   CHECK_EQ(0, strcmp("V8.Test", last_event_message));
   CHECK_EQ(1, last_event_status);
 }
 
 
 TEST(Promises) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
-  Handle<Object> global = context->Global();
+  Local<Object> global = context->Global();
 
   // Creation.
-  Handle<v8::Promise::Resolver> pr = v8::Promise::Resolver::New(isolate);
-  Handle<v8::Promise::Resolver> rr = v8::Promise::Resolver::New(isolate);
-  Handle<v8::Promise> p = pr->GetPromise();
-  Handle<v8::Promise> r = rr->GetPromise();
+  Local<v8::Promise::Resolver> pr = v8::Promise::Resolver::New(isolate);
+  Local<v8::Promise::Resolver> rr = v8::Promise::Resolver::New(isolate);
+  Local<v8::Promise> p = pr->GetPromise();
+  Local<v8::Promise> r = rr->GetPromise();
   CHECK_EQ(isolate, p->GetIsolate());
 
   // IsPromise predicate.
   CHECK(p->IsPromise());
   CHECK(r->IsPromise());
-  Handle<Value> o = v8::Object::New(isolate);
+  Local<Value> o = v8::Object::New(isolate);
   CHECK(!o->IsPromise());
 
   // Resolution and rejection.
   pr->Resolve(v8::Integer::New(isolate, 1));
   CHECK(p->IsPromise());
   rr->Reject(v8::Integer::New(isolate, 2));
   CHECK(r->IsPromise());
 
   // Chaining non-pending promises.
   CompileRun(
       "var x1 = 0;\n"
       "var x2 = 0;\n"
       "function f1(x) { x1 = x; return x+1 };\n"
       "function f2(x) { x2 = x; return x+1 };\n");
-  Handle<Function> f1 = Handle<Function>::Cast(global->Get(v8_str("f1")));
-  Handle<Function> f2 = Handle<Function>::Cast(global->Get(v8_str("f2")));
+  Local<Function> f1 = Local<Function>::Cast(global->Get(v8_str("f1")));
+  Local<Function> f2 = Local<Function>::Cast(global->Get(v8_str("f2")));
 
   p->Chain(f1);
-  CHECK_EQ(0, global->Get(v8_str("x1"))->Int32Value());
+  CHECK_EQ(0,
+           global->Get(v8_str("x1"))->Int32Value(context.local()).FromJust());
   isolate->RunMicrotasks();
-  CHECK_EQ(1, global->Get(v8_str("x1"))->Int32Value());
+  CHECK_EQ(1,
+           global->Get(v8_str("x1"))->Int32Value(context.local()).FromJust());
 
   p->Catch(f2);
   isolate->RunMicrotasks();
-  CHECK_EQ(0, global->Get(v8_str("x2"))->Int32Value());
+  CHECK_EQ(0,
+           global->Get(v8_str("x2"))->Int32Value(context.local()).FromJust());
 
   r->Catch(f2);
-  CHECK_EQ(0, global->Get(v8_str("x2"))->Int32Value());
+  CHECK_EQ(0,
+           global->Get(v8_str("x2"))->Int32Value(context.local()).FromJust());
   isolate->RunMicrotasks();
-  CHECK_EQ(2, global->Get(v8_str("x2"))->Int32Value());
+  CHECK_EQ(2,
+           global->Get(v8_str("x2"))->Int32Value(context.local()).FromJust());
 
   r->Chain(f1);
   isolate->RunMicrotasks();
-  CHECK_EQ(1, global->Get(v8_str("x1"))->Int32Value());
+  CHECK_EQ(1,
+           global->Get(v8_str("x1"))->Int32Value(context.local()).FromJust());
 
   // Chaining pending promises.
   CompileRun("x1 = x2 = 0;");
   pr = v8::Promise::Resolver::New(isolate);
   rr = v8::Promise::Resolver::New(isolate);
 
   pr->GetPromise()->Chain(f1);
   rr->GetPromise()->Catch(f2);
   isolate->RunMicrotasks();
-  CHECK_EQ(0, global->Get(v8_str("x1"))->Int32Value());
-  CHECK_EQ(0, global->Get(v8_str("x2"))->Int32Value());
+  CHECK_EQ(0,
+           global->Get(v8_str("x1"))->Int32Value(context.local()).FromJust());
+  CHECK_EQ(0,
+           global->Get(v8_str("x2"))->Int32Value(context.local()).FromJust());
 
   pr->Resolve(v8::Integer::New(isolate, 1));
   rr->Reject(v8::Integer::New(isolate, 2));
-  CHECK_EQ(0, global->Get(v8_str("x1"))->Int32Value());
-  CHECK_EQ(0, global->Get(v8_str("x2"))->Int32Value());
+  CHECK_EQ(0,
+           global->Get(v8_str("x1"))->Int32Value(context.local()).FromJust());
+  CHECK_EQ(0,
+           global->Get(v8_str("x2"))->Int32Value(context.local()).FromJust());
 
   isolate->RunMicrotasks();
-  CHECK_EQ(1, global->Get(v8_str("x1"))->Int32Value());
-  CHECK_EQ(2, global->Get(v8_str("x2"))->Int32Value());
+  CHECK_EQ(1,
+           global->Get(v8_str("x1"))->Int32Value(context.local()).FromJust());
+  CHECK_EQ(2,
+           global->Get(v8_str("x2"))->Int32Value(context.local()).FromJust());
 
   // Multi-chaining.
   CompileRun("x1 = x2 = 0;");
   pr = v8::Promise::Resolver::New(isolate);
   pr->GetPromise()->Chain(f1)->Chain(f2);
   pr->Resolve(v8::Integer::New(isolate, 3));
-  CHECK_EQ(0, global->Get(v8_str("x1"))->Int32Value());
-  CHECK_EQ(0, global->Get(v8_str("x2"))->Int32Value());
+  CHECK_EQ(0,
+           global->Get(v8_str("x1"))->Int32Value(context.local()).FromJust());
+  CHECK_EQ(0,
+           global->Get(v8_str("x2"))->Int32Value(context.local()).FromJust());
   isolate->RunMicrotasks();
-  CHECK_EQ(3, global->Get(v8_str("x1"))->Int32Value());
-  CHECK_EQ(4, global->Get(v8_str("x2"))->Int32Value());
+  CHECK_EQ(3,
+           global->Get(v8_str("x1"))->Int32Value(context.local()).FromJust());
+  CHECK_EQ(4,
+           global->Get(v8_str("x2"))->Int32Value(context.local()).FromJust());
 
   CompileRun("x1 = x2 = 0;");
   rr = v8::Promise::Resolver::New(isolate);
   rr->GetPromise()->Catch(f1)->Chain(f2);
   rr->Reject(v8::Integer::New(isolate, 3));
-  CHECK_EQ(0, global->Get(v8_str("x1"))->Int32Value());
-  CHECK_EQ(0, global->Get(v8_str("x2"))->Int32Value());
+  CHECK_EQ(0,
+           global->Get(v8_str("x1"))->Int32Value(context.local()).FromJust());
+  CHECK_EQ(0,
+           global->Get(v8_str("x2"))->Int32Value(context.local()).FromJust());
   isolate->RunMicrotasks();
-  CHECK_EQ(3, global->Get(v8_str("x1"))->Int32Value());
-  CHECK_EQ(4, global->Get(v8_str("x2"))->Int32Value());
+  CHECK_EQ(3,
+           global->Get(v8_str("x1"))->Int32Value(context.local()).FromJust());
+  CHECK_EQ(4,
+           global->Get(v8_str("x2"))->Int32Value(context.local()).FromJust());
 }
 
 
 TEST(PromiseThen) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
-  Handle<Object> global = context->Global();
+  Local<Object> global = context->Global();
 
   // Creation.
-  Handle<v8::Promise::Resolver> pr = v8::Promise::Resolver::New(isolate);
-  Handle<v8::Promise::Resolver> qr = v8::Promise::Resolver::New(isolate);
-  Handle<v8::Promise> p = pr->GetPromise();
-  Handle<v8::Promise> q = qr->GetPromise();
+  Local<v8::Promise::Resolver> pr = v8::Promise::Resolver::New(isolate);
+  Local<v8::Promise::Resolver> qr = v8::Promise::Resolver::New(isolate);
+  Local<v8::Promise> p = pr->GetPromise();
+  Local<v8::Promise> q = qr->GetPromise();
 
   CHECK(p->IsPromise());
   CHECK(q->IsPromise());
 
   pr->Resolve(v8::Integer::New(isolate, 1));
   qr->Resolve(p);
 
   // Chaining non-pending promises.
   CompileRun(
       "var x1 = 0;\n"
       "var x2 = 0;\n"
       "function f1(x) { x1 = x; return x+1 };\n"
       "function f2(x) { x2 = x; return x+1 };\n");
-  Handle<Function> f1 = Handle<Function>::Cast(global->Get(v8_str("f1")));
-  Handle<Function> f2 = Handle<Function>::Cast(global->Get(v8_str("f2")));
+  Local<Function> f1 = Local<Function>::Cast(global->Get(v8_str("f1")));
+  Local<Function> f2 = Local<Function>::Cast(global->Get(v8_str("f2")));
 
   // TODO(caitp): remove tests once PromiseChain is removed, per bug 3237
   /* q->Chain(f1);
   CHECK(global->Get(v8_str2("x1"))->IsNumber());
   CHECK_EQ(0, global->Get(v8_str("x1"))->Int32Value());
   isolate->RunMicrotasks();
   CHECK(!global->Get(v8_str("x1"))->IsNumber());
   CHECK(p->Equals(global->Get(v8_str("x1")))); */
 
   // Then
   CompileRun("x1 = x2 = 0;");
   q->Then(f1);
-  CHECK_EQ(0, global->Get(v8_str("x1"))->Int32Value());
+  CHECK_EQ(0,
+           global->Get(v8_str("x1"))->Int32Value(context.local()).FromJust());
   isolate->RunMicrotasks();
-  CHECK_EQ(1, global->Get(v8_str("x1"))->Int32Value());
+  CHECK_EQ(1,
+           global->Get(v8_str("x1"))->Int32Value(context.local()).FromJust());
 
   // Then
   CompileRun("x1 = x2 = 0;");
   pr = v8::Promise::Resolver::New(isolate);
   qr = v8::Promise::Resolver::New(isolate);
 
   qr->Resolve(pr);
   qr->GetPromise()->Then(f1)->Then(f2);
 
-  CHECK_EQ(0, global->Get(v8_str("x1"))->Int32Value());
-  CHECK_EQ(0, global->Get(v8_str("x2"))->Int32Value());
+  CHECK_EQ(0,
+           global->Get(v8_str("x1"))->Int32Value(context.local()).FromJust());
+  CHECK_EQ(0,
+           global->Get(v8_str("x2"))->Int32Value(context.local()).FromJust());
   isolate->RunMicrotasks();
-  CHECK_EQ(0, global->Get(v8_str("x1"))->Int32Value());
-  CHECK_EQ(0, global->Get(v8_str("x2"))->Int32Value());
+  CHECK_EQ(0,
+           global->Get(v8_str("x1"))->Int32Value(context.local()).FromJust());
+  CHECK_EQ(0,
+           global->Get(v8_str("x2"))->Int32Value(context.local()).FromJust());
 
   pr->Resolve(v8::Integer::New(isolate, 3));
 
-  CHECK_EQ(0, global->Get(v8_str("x1"))->Int32Value());
-  CHECK_EQ(0, global->Get(v8_str("x2"))->Int32Value());
+  CHECK_EQ(0,
+           global->Get(v8_str("x1"))->Int32Value(context.local()).FromJust());
+  CHECK_EQ(0,
+           global->Get(v8_str("x2"))->Int32Value(context.local()).FromJust());
   isolate->RunMicrotasks();
-  CHECK_EQ(3, global->Get(v8_str("x1"))->Int32Value());
-  CHECK_EQ(4, global->Get(v8_str("x2"))->Int32Value());
+  CHECK_EQ(3,
+           global->Get(v8_str("x1"))->Int32Value(context.local()).FromJust());
+  CHECK_EQ(4,
+           global->Get(v8_str("x2"))->Int32Value(context.local()).FromJust());
 }
 
 
 TEST(DisallowJavascriptExecutionScope) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope scope(isolate);
   v8::Isolate::DisallowJavascriptExecutionScope no_js(
       isolate, v8::Isolate::DisallowJavascriptExecutionScope::CRASH_ON_FAILURE);
   CompileRun("2+2");
@@ skipping 24 matching lines @@
   CompileRun("1+1");
   CHECK(try_catch.HasCaught());
 }
 
 
 TEST(Regress354123) {
   LocalContext current;
   v8::Isolate* isolate = current->GetIsolate();
   v8::HandleScope scope(isolate);
 
-  v8::Handle<v8::ObjectTemplate> templ = v8::ObjectTemplate::New(isolate);
+  v8::Local<v8::ObjectTemplate> templ = v8::ObjectTemplate::New(isolate);
   templ->SetAccessCheckCallback(AccessCounter);
-  current->Global()->Set(v8_str("friend"), templ->NewInstance());
+  CHECK(current->Global()
+            ->Set(current.local(), v8_str("friend"),
+                  templ->NewInstance(current.local()).ToLocalChecked())
+            .FromJust());
 
   // Test access using __proto__ from the prototype chain.
   access_count = 0;
   CompileRun("friend.__proto__ = {};");
   CHECK_EQ(2, access_count);
   CompileRun("friend.__proto__;");
   CHECK_EQ(4, access_count);
 
   // Test access using __proto__ as a hijacked function (A).
   access_count = 0;
@@ skipping 48 matching lines @@
       isolate, &script_source);
   Local<Value> script_name = script->GetUnboundScript()->GetScriptName();
   CHECK(!script_name.IsEmpty());
   CHECK(script_name->IsString());
   String::Utf8Value utf8_name(script_name);
   CHECK_EQ(0, strcmp(url, *utf8_name));
   int line_number = script->GetUnboundScript()->GetLineNumber(0);
   CHECK_EQ(13, line_number);
 }
 
-void CheckMagicComments(Handle<Script> script, const char* expected_source_url,
+void CheckMagicComments(Local<Script> script, const char* expected_source_url,
                         const char* expected_source_mapping_url) {
   if (expected_source_url != NULL) {
     v8::String::Utf8Value url(script->GetUnboundScript()->GetSourceURL());
     CHECK_EQ(0, strcmp(expected_source_url, *url));
   } else {
     CHECK(script->GetUnboundScript()->GetSourceURL()->IsUndefined());
   }
   if (expected_source_mapping_url != NULL) {
     v8::String::Utf8Value url(
         script->GetUnboundScript()->GetSourceMappingURL());
@@ skipping 88 matching lines @@
   Local<Value> desc = x->GetOwnPropertyDescriptor(v8_str("no_prop"));
   CHECK(desc->IsUndefined());
   desc = x->GetOwnPropertyDescriptor(v8_str("p0"));
   CHECK(v8_num(12)->Equals(Local<Object>::Cast(desc)->Get(v8_str("value"))));
   desc = x->GetOwnPropertyDescriptor(v8_str("p1"));
   Local<Function> set =
     Local<Function>::Cast(Local<Object>::Cast(desc)->Get(v8_str("set")));
   Local<Function> get =
     Local<Function>::Cast(Local<Object>::Cast(desc)->Get(v8_str("get")));
   CHECK(v8_num(13)->Equals(get->Call(x, 0, NULL)));
-  Handle<Value> args[] = { v8_num(14) };
+  Local<Value> args[] = {v8_num(14)};
   set->Call(x, 1, args);
   CHECK(v8_num(14)->Equals(get->Call(x, 0, NULL)));
 }
 
 
 TEST(Regress411877) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
-  v8::Handle<v8::ObjectTemplate> object_template =
+  v8::Local<v8::ObjectTemplate> object_template =
       v8::ObjectTemplate::New(isolate);
   object_template->SetAccessCheckCallback(AccessCounter);
 
-  v8::Handle<Context> context = Context::New(isolate);
+  v8::Local<Context> context = Context::New(isolate);
   v8::Context::Scope context_scope(context);
 
-  context->Global()->Set(v8_str("o"), object_template->NewInstance());
+  CHECK(context->Global()
+            ->Set(context, v8_str("o"),
+                  object_template->NewInstance(context).ToLocalChecked())
+            .FromJust());
   CompileRun("Object.getOwnPropertyNames(o)");
 }
 
 
 TEST(GetHiddenPropertyTableAfterAccessCheck) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
-  v8::Handle<v8::ObjectTemplate> object_template =
+  v8::Local<v8::ObjectTemplate> object_template =
       v8::ObjectTemplate::New(isolate);
   object_template->SetAccessCheckCallback(AccessCounter);
 
-  v8::Handle<Context> context = Context::New(isolate);
+  v8::Local<Context> context = Context::New(isolate);
   v8::Context::Scope context_scope(context);
 
-  v8::Handle<v8::Object> obj = object_template->NewInstance();
+  v8::Local<v8::Object> obj =
+      object_template->NewInstance(context).ToLocalChecked();
   obj->Set(v8_str("key"), v8_str("value"));
   obj->Delete(v8_str("key"));
 
   obj->SetPrivate(context, v8::Private::New(isolate, v8_str("hidden key 2")),
                   v8_str("hidden value 2"))
       .FromJust();
 }
 
 
 TEST(Regress411793) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
-  v8::Handle<v8::ObjectTemplate> object_template =
+  v8::Local<v8::ObjectTemplate> object_template =
       v8::ObjectTemplate::New(isolate);
   object_template->SetAccessCheckCallback(AccessCounter);
 
-  v8::Handle<Context> context = Context::New(isolate);
+  v8::Local<Context> context = Context::New(isolate);
   v8::Context::Scope context_scope(context);
 
-  context->Global()->Set(v8_str("o"), object_template->NewInstance());
+  CHECK(context->Global()
+            ->Set(context, v8_str("o"),
+                  object_template->NewInstance(context).ToLocalChecked())
+            .FromJust());
   CompileRun(
       "Object.defineProperty(o, 'key', "
       "    { get: function() {}, set: function() {} });");
 }
 
 class TestSourceStream : public v8::ScriptCompiler::ExternalSourceStream {
  public:
   explicit TestSourceStream(const char** chunks) : chunks_(chunks), index_(0) {}
 
   virtual size_t GetMoreData(const uint8_t** src) {
@@ skipping 55 matching lines @@
   // TestSourceStream::GetMoreData won't block, so it's OK to just run the
   // task here in the main thread.
   task->Run();
   delete task;
 
   // Possible errors are only produced while compiling.
   CHECK_EQ(false, try_catch.HasCaught());
 
   v8::ScriptOrigin origin(v8_str("http://foo.com"));
   char* full_source = TestSourceStream::FullSourceString(chunks);
-  v8::Handle<Script> script = v8::ScriptCompiler::Compile(
+  v8::Local<Script> script = v8::ScriptCompiler::Compile(
       isolate, &source, v8_str(full_source), origin);
   if (expected_success) {
     CHECK(!script.IsEmpty());
-    v8::Handle<Value> result(script->Run());
+    v8::Local<Value> result(script->Run());
     // All scripts are supposed to return the fixed value 13 when ran.
-    CHECK_EQ(13, result->Int32Value());
+    CHECK_EQ(13, result->Int32Value(env.local()).FromJust());
     CheckMagicComments(script, expected_source_url,
                        expected_source_mapping_url);
   } else {
     CHECK(script.IsEmpty());
     CHECK(try_catch.HasCaught());
   }
   delete[] full_source;
 }
 
 
@@ skipping 248 matching lines @@
   task->Run();
   delete task;
 
   CHECK(!try_catch.HasCaught());
 
   v8::ScriptOrigin origin(v8_str("http://foo.com"));
   char* full_source = TestSourceStream::FullSourceString(chunks);
 
   EnableDebugger();
 
-  v8::Handle<Script> script = v8::ScriptCompiler::Compile(
+  v8::Local<Script> script = v8::ScriptCompiler::Compile(
       isolate, &source, v8_str(full_source), origin);
 
   Maybe<uint32_t> result =
       script->Run(env.local()).ToLocalChecked()->Uint32Value(env.local());
   CHECK_EQ(3U, result.FromMaybe(0));
 
   delete[] full_source;
 
   DisableDebugger();
 }
@@ skipping 83 matching lines @@
       v8::ScriptCompiler::StartStreamingScript(isolate, &source);
   task->Run();
   delete task;
 
   // Parsing should succeed (the script will be parsed and compiled in a context
   // independent way, so the error is not detected).
   CHECK_EQ(false, try_catch.HasCaught());
 
   v8::ScriptOrigin origin(v8_str("http://foo.com"));
   char* full_source = TestSourceStream::FullSourceString(chunks);
-  v8::Handle<Script> script = v8::ScriptCompiler::Compile(
+  v8::Local<Script> script = v8::ScriptCompiler::Compile(
       isolate, &source, v8_str(full_source), origin);
   CHECK(!script.IsEmpty());
   CHECK_EQ(false, try_catch.HasCaught());
 
   // Running the script exposes the error.
-  v8::Handle<Value> result(script->Run());
+  v8::Local<Value> result(script->Run());
   CHECK(result.IsEmpty());
   CHECK(try_catch.HasCaught());
   delete[] full_source;
 }
 
 
 TEST(CodeCache) {
   v8::Isolate::CreateParams create_params;
   create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
 
@@ skipping 32 matching lines @@
     v8::ScriptCompiler::Source source(source_string, script_origin, cache);
     v8::ScriptCompiler::CompileOptions option =
         v8::ScriptCompiler::kConsumeCodeCache;
     v8::Local<v8::Script> script;
     {
       i::DisallowCompilation no_compile(
           reinterpret_cast<i::Isolate*>(isolate2));
       script = v8::ScriptCompiler::Compile(context, &source, option)
                    .ToLocalChecked();
     }
-    CHECK_EQ(2, script->Run()->ToInt32(isolate2)->Int32Value());
+    CHECK_EQ(2,
+             script->Run()->ToInt32(isolate2)->Int32Value(context).FromJust());
   }
   isolate2->Dispose();
 }
 
 
 void TestInvalidCacheData(v8::ScriptCompiler::CompileOptions option) {
   const char* garbage = "garbage garbage garbage garbage garbage garbage";
   const uint8_t* data = reinterpret_cast<const uint8_t*>(garbage);
   int length = 16;
   v8::ScriptCompiler::CachedData* cached_data =
       new v8::ScriptCompiler::CachedData(data, length);
   DCHECK(!cached_data->rejected);
   v8::ScriptOrigin origin(v8_str("origin"));
   v8::ScriptCompiler::Source source(v8_str("42"), origin, cached_data);
-  v8::Handle<v8::Script> script =
+  v8::Local<v8::Script> script =
       v8::ScriptCompiler::Compile(CcTest::isolate(), &source, option);
   CHECK(cached_data->rejected);
-  CHECK_EQ(42, script->Run()->Int32Value());
+  CHECK_EQ(42, script->Run()
+                   ->Int32Value(CcTest::isolate()->GetCurrentContext())
+                   .FromJust());
 }
 
 
 TEST(InvalidCacheData) {
   v8::V8::Initialize();
   v8::HandleScope scope(CcTest::isolate());
   LocalContext context;
   TestInvalidCacheData(v8::ScriptCompiler::kConsumeParserCache);
   TestInvalidCacheData(v8::ScriptCompiler::kConsumeCodeCache);
 }
 
 
 TEST(ParserCacheRejectedGracefully) {
   i::FLAG_min_preparse_length = 0;
   v8::V8::Initialize();
   v8::HandleScope scope(CcTest::isolate());
   LocalContext context;
   // Produce valid cached data.
   v8::ScriptOrigin origin(v8_str("origin"));
   v8::Local<v8::String> source_str = v8_str("function foo() {}");
   v8::ScriptCompiler::Source source(source_str, origin);
-  v8::Handle<v8::Script> script = v8::ScriptCompiler::Compile(
+  v8::Local<v8::Script> script = v8::ScriptCompiler::Compile(
       CcTest::isolate(), &source, v8::ScriptCompiler::kProduceParserCache);
   CHECK(!script.IsEmpty());
   const v8::ScriptCompiler::CachedData* original_cached_data =
       source.GetCachedData();
   CHECK(original_cached_data != NULL);
   CHECK(original_cached_data->data != NULL);
   CHECK(!original_cached_data->rejected);
   CHECK_GT(original_cached_data->length, 0);
   // Recompiling the same script with it won't reject the data.
   {
     v8::ScriptCompiler::Source source_with_cached_data(
         source_str, origin,
         new v8::ScriptCompiler::CachedData(original_cached_data->data,
                                            original_cached_data->length));
-    v8::Handle<v8::Script> script =
+    v8::Local<v8::Script> script =
         v8::ScriptCompiler::Compile(CcTest::isolate(), &source_with_cached_data,
                                     v8::ScriptCompiler::kConsumeParserCache);
     CHECK(!script.IsEmpty());
     const v8::ScriptCompiler::CachedData* new_cached_data =
         source_with_cached_data.GetCachedData();
     CHECK(new_cached_data != NULL);
     CHECK(!new_cached_data->rejected);
   }
   // Compile an incompatible script with the cached data. The new script doesn't
   // have the same starting position for the function as the old one, so the old
   // cached data will be incompatible with it and will be rejected.
   {
     v8::Local<v8::String> incompatible_source_str =
         v8_str("   function foo() {}");
     v8::ScriptCompiler::Source source_with_cached_data(
         incompatible_source_str, origin,
         new v8::ScriptCompiler::CachedData(original_cached_data->data,
                                            original_cached_data->length));
-    v8::Handle<v8::Script> script =
+    v8::Local<v8::Script> script =
         v8::ScriptCompiler::Compile(CcTest::isolate(), &source_with_cached_data,
                                     v8::ScriptCompiler::kConsumeParserCache);
     CHECK(!script.IsEmpty());
     const v8::ScriptCompiler::CachedData* new_cached_data =
         source_with_cached_data.GetCachedData();
     CHECK(new_cached_data != NULL);
     CHECK(new_cached_data->rejected);
   }
 }
 
@@ skipping 48 matching lines @@
   CHECK_EQ(should_be_neuterable, result->IsNeuterable());
 }
 
 
 TEST(GetPrototypeAccessControl) {
   i::FLAG_allow_natives_syntax = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   LocalContext env;
 
-  v8::Handle<v8::ObjectTemplate> obj_template =
-      v8::ObjectTemplate::New(isolate);
+  v8::Local<v8::ObjectTemplate> obj_template = v8::ObjectTemplate::New(isolate);
   obj_template->SetAccessCheckCallback(AccessAlwaysBlocked);
 
-  env->Global()->Set(v8_str("prohibited"), obj_template->NewInstance());
+  CHECK(env->Global()
+            ->Set(env.local(), v8_str("prohibited"),
+                  obj_template->NewInstance(env.local()).ToLocalChecked())
+            .FromJust());
 
   CHECK(CompileRun(
             "function f() { return %_GetPrototype(prohibited); }"
             "%OptimizeFunctionOnNextCall(f);"
             "f();")->IsNull());
 }
 
 
 TEST(GetPrototypeHidden) {
   i::FLAG_allow_natives_syntax = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   LocalContext env;
 
-  Handle<FunctionTemplate> t = FunctionTemplate::New(isolate);
+  Local<FunctionTemplate> t = FunctionTemplate::New(isolate);
   t->SetHiddenPrototype(true);
-  Handle<Object> proto = t->GetFunction()->NewInstance();
-  Handle<Object> object = Object::New(isolate);
-  Handle<Object> proto2 = Object::New(isolate);
+  Local<Object> proto = t->GetFunction(env.local())
+                            .ToLocalChecked()
+                            ->NewInstance(env.local())
+                            .ToLocalChecked();
+  Local<Object> object = Object::New(isolate);
+  Local<Object> proto2 = Object::New(isolate);
   object->SetPrototype(proto);
   proto->SetPrototype(proto2);
 
-  env->Global()->Set(v8_str("object"), object);
-  env->Global()->Set(v8_str("proto"), proto);
-  env->Global()->Set(v8_str("proto2"), proto2);
+  CHECK(env->Global()->Set(env.local(), v8_str("object"), object).FromJust());
+  CHECK(env->Global()->Set(env.local(), v8_str("proto"), proto).FromJust());
+  CHECK(env->Global()->Set(env.local(), v8_str("proto2"), proto2).FromJust());
 
-  v8::Handle<v8::Value> result = CompileRun("%_GetPrototype(object)");
+  v8::Local<v8::Value> result = CompileRun("%_GetPrototype(object)");
   CHECK(result->Equals(proto2));
 
   result = CompileRun(
       "function f() { return %_GetPrototype(object); }"
       "%OptimizeFunctionOnNextCall(f);"
       "f()");
   CHECK(result->Equals(proto2));
 }
 
 
 TEST(ClassPrototypeCreationContext) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   LocalContext env;
 
-  Handle<Object> result = Handle<Object>::Cast(
+  Local<Object> result = Local<Object>::Cast(
       CompileRun("'use strict'; class Example { }; Example.prototype"));
   CHECK(env.local() == result->CreationContext());
 }
 
 
 TEST(SimpleStreamingScriptWithSourceURL) {
   const char* chunks[] = {"function foo() { ret", "urn 13; } f", "oo();\n",
                           "//# sourceURL=bar2.js\n", NULL};
   RunStreamingTest(chunks, v8::ScriptCompiler::StreamedSource::UTF8, true,
                    "bar2.js");
@@ skipping 20 matching lines @@
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   const int length = i::String::kMaxLength + 1;
   const int buffer_size = length * sizeof(uint16_t);
   void* buffer = malloc(buffer_size);
   if (buffer == NULL) return;
   memset(buffer, 'A', buffer_size);
   {
     v8::TryCatch try_catch(isolate);
     char* data = reinterpret_cast<char*>(buffer);
-    CHECK(v8::String::NewFromUtf8(isolate, data, v8::String::kNormalString,
-                                  length).IsEmpty());
+    CHECK(v8::String::NewFromUtf8(isolate, data, v8::NewStringType::kNormal,
+                                  length)
+              .IsEmpty());
     CHECK(!try_catch.HasCaught());
   }
   {
     v8::TryCatch try_catch(isolate);
     uint8_t* data = reinterpret_cast<uint8_t*>(buffer);
-    CHECK(v8::String::NewFromOneByte(isolate, data, v8::String::kNormalString,
-                                     length).IsEmpty());
+    CHECK(v8::String::NewFromOneByte(isolate, data, v8::NewStringType::kNormal,
+                                     length)
+              .IsEmpty());
     CHECK(!try_catch.HasCaught());
   }
   {
     v8::TryCatch try_catch(isolate);
     uint16_t* data = reinterpret_cast<uint16_t*>(buffer);
-    CHECK(v8::String::NewFromTwoByte(isolate, data, v8::String::kNormalString,
-                                     length).IsEmpty());
+    CHECK(v8::String::NewFromTwoByte(isolate, data, v8::NewStringType::kNormal,
+                                     length)
+              .IsEmpty());
     CHECK(!try_catch.HasCaught());
   }
   free(buffer);
 }
 
 
 TEST(SealHandleScope) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   LocalContext env;
@@ skipping 39 matching lines @@
                                         Local<v8::Object> accessed_object) {
   access_was_called = true;
   return false;
 }
 
 
 TEST(StrongModeAccessCheckAllowed) {
   i::FLAG_strong_mode = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
-  v8::Handle<Value> value;
+  v8::Local<Value> value;
   access_was_called = false;
 
-  v8::Handle<v8::ObjectTemplate> obj_template =
-      v8::ObjectTemplate::New(isolate);
+  v8::Local<v8::ObjectTemplate> obj_template = v8::ObjectTemplate::New(isolate);
 
   obj_template->Set(v8_str("x"), v8::Integer::New(isolate, 42));
   obj_template->SetAccessCheckCallback(AccessAlwaysAllowedWithFlag);
 
   // Create an environment
   v8::Local<Context> context0 = Context::New(isolate, NULL, obj_template);
   context0->Enter();
-  v8::Handle<v8::Object> global0 = context0->Global();
-  global0->Set(v8_str("object"), obj_template->NewInstance());
+  v8::Local<v8::Object> global0 = context0->Global();
+  global0->Set(v8_str("object"),
+               obj_template->NewInstance(context0).ToLocalChecked());
   {
     v8::TryCatch try_catch(isolate);
     value = CompileRun("'use strong'; object.x");
     CHECK(!try_catch.HasCaught());
     CHECK(!access_was_called);
-    CHECK_EQ(42, value->Int32Value());
+    CHECK_EQ(42, value->Int32Value(context0).FromJust());
   }
   {
     v8::TryCatch try_catch(isolate);
     value = CompileRun("'use strong'; object.foo");
     CHECK(try_catch.HasCaught());
     CHECK(!access_was_called);
   }
   {
     v8::TryCatch try_catch(isolate);
     value = CompileRun("'use strong'; object[10]");
     CHECK(try_catch.HasCaught());
     CHECK(!access_was_called);
   }
 
   // Create an environment
   v8::Local<Context> context1 = Context::New(isolate);
   context1->Enter();
-  v8::Handle<v8::Object> global1 = context1->Global();
-  global1->Set(v8_str("object"), obj_template->NewInstance());
+  v8::Local<v8::Object> global1 = context1->Global();
+  global1->Set(v8_str("object"),
+               obj_template->NewInstance(context1).ToLocalChecked());
   {
     v8::TryCatch try_catch(isolate);
     value = CompileRun("'use strong'; object.x");
     CHECK(!try_catch.HasCaught());
     CHECK(access_was_called);
-    CHECK_EQ(42, value->Int32Value());
+    CHECK_EQ(42, value->Int32Value(context1).FromJust());
   }
   access_was_called = false;
   {
     v8::TryCatch try_catch(isolate);
     value = CompileRun("'use strong'; object.foo");
     CHECK(try_catch.HasCaught());
     CHECK(access_was_called);
   }
   access_was_called = false;
   {
     v8::TryCatch try_catch(isolate);
     value = CompileRun("'use strong'; object[10]");
     CHECK(try_catch.HasCaught());
     CHECK(access_was_called);
   }
 
   context1->Exit();
   context0->Exit();
 }
 
 
 TEST(StrongModeAccessCheckBlocked) {
   i::FLAG_strong_mode = true;
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
-  v8::Handle<Value> value;
+  v8::Local<Value> value;
   access_was_called = false;
 
-  v8::Handle<v8::ObjectTemplate> obj_template =
-      v8::ObjectTemplate::New(isolate);
+  v8::Local<v8::ObjectTemplate> obj_template = v8::ObjectTemplate::New(isolate);
 
   obj_template->Set(v8_str("x"), v8::Integer::New(isolate, 42));
   obj_template->SetAccessCheckCallback(AccessAlwaysBlockedWithFlag);
 
   // Create an environment
   v8::Local<Context> context0 = Context::New(isolate, NULL, obj_template);
   context0->Enter();
-  v8::Handle<v8::Object> global0 = context0->Global();
-  global0->Set(v8_str("object"), obj_template->NewInstance());
+  v8::Local<v8::Object> global0 = context0->Global();
+  global0->Set(v8_str("object"),
+               obj_template->NewInstance(context0).ToLocalChecked());
   {
     v8::TryCatch try_catch(isolate);
     value = CompileRun("'use strong'; object.x");
     CHECK(!try_catch.HasCaught());
     CHECK(!access_was_called);
-    CHECK_EQ(42, value->Int32Value());
+    CHECK_EQ(42, value->Int32Value(context0).FromJust());
   }
   {
     v8::TryCatch try_catch(isolate);
     value = CompileRun("'use strong'; object.foo");
     CHECK(try_catch.HasCaught());
     CHECK(!access_was_called);
   }
   {
     v8::TryCatch try_catch(isolate);
     value = CompileRun("'use strong'; object[10]");
     CHECK(try_catch.HasCaught());
     CHECK(!access_was_called);
   }
 
   // Create an environment
   v8::Local<Context> context1 = Context::New(isolate);
   context1->Enter();
-  v8::Handle<v8::Object> global1 = context1->Global();
-  global1->Set(v8_str("object"), obj_template->NewInstance());
+  v8::Local<v8::Object> global1 = context1->Global();
+  global1->Set(v8_str("object"),
+               obj_template->NewInstance(context1).ToLocalChecked());
   {
     v8::TryCatch try_catch(isolate);
     value = CompileRun("'use strong'; object.x");
     CHECK(try_catch.HasCaught());
     CHECK(access_was_called);
   }
   access_was_called = false;
   {
     v8::TryCatch try_catch(isolate);
     value = CompileRun("'use strong'; object.foo");
@@ skipping 29 matching lines @@
   }
 
   {
     v8::TryCatch try_catch(isolate);
     fun->Call(v8::Undefined(isolate), 0, nullptr);
     CHECK(try_catch.HasCaught());
   }
 
   {
     v8::TryCatch try_catch(isolate);
-    v8::Handle<Value> args[] = {v8_num(42)};
+    v8::Local<Value> args[] = {v8_num(42)};
     fun->Call(v8::Undefined(isolate), arraysize(args), args);
     CHECK(!try_catch.HasCaught());
   }
 
   {
     v8::TryCatch try_catch(isolate);
-    v8::Handle<Value> args[] = {v8_num(42), v8_num(555)};
+    v8::Local<Value> args[] = {v8_num(42), v8_num(555)};
     fun->Call(v8::Undefined(isolate), arraysize(args), args);
     CHECK(!try_catch.HasCaught());
   }
 }
 
 
 TEST(StrongModeArityCallFromApi2) {
   i::FLAG_strong_mode = true;
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
@@ skipping 10 matching lines @@
   }
 
   {
     v8::TryCatch try_catch(isolate);
     fun->Call(v8::Undefined(isolate), 0, nullptr);
     CHECK(try_catch.HasCaught());
   }
 
   {
     v8::TryCatch try_catch(isolate);
-    v8::Handle<Value> args[] = {v8_num(42)};
+    v8::Local<Value> args[] = {v8_num(42)};
     fun->Call(v8::Undefined(isolate), arraysize(args), args);
     CHECK(!try_catch.HasCaught());
   }
 
   {
     v8::TryCatch try_catch(isolate);
-    v8::Handle<Value> args[] = {v8_num(42), v8_num(555)};
+    v8::Local<Value> args[] = {v8_num(42), v8_num(555)};
     fun->Call(v8::Undefined(isolate), arraysize(args), args);
     CHECK(!try_catch.HasCaught());
   }
 }
 
 
 TEST(StrongObjectDelete) {
   i::FLAG_strong_mode = true;
   LocalContext env;
   v8::Isolate* isolate = env->GetIsolate();
@@ skipping 10 matching lines @@
   obj->ForceSet(v8_str("2"), v8_num(1), v8::None);
   CHECK(obj->HasOwnProperty(v8_str("foo")));
   CHECK(obj->HasOwnProperty(v8_str("2")));
   CHECK(!obj->Delete(v8_str("foo")));
   CHECK(!obj->Delete(2));
 }
 
 
 static void ExtrasBindingTestRuntimeFunction(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
-  CHECK_EQ(3, args[0]->Int32Value());
+  CHECK_EQ(
+      3,
+      args[0]->Int32Value(args.GetIsolate()->GetCurrentContext()).FromJust());
   args.GetReturnValue().Set(v8_num(7));
 }
 
 
 TEST(ExtrasBindingObject) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   LocalContext env;
 
   // standalone.gypi ensures we include the test-extra.js file, which should
   // export the tested functions.
   v8::Local<v8::Object> binding = env->GetExtrasBindingObject();
 
   auto func =
       binding->Get(v8_str("testExtraShouldReturnFive")).As<v8::Function>();
   auto undefined = v8::Undefined(isolate);
   auto result = func->Call(undefined, 0, {}).As<v8::Number>();
-  CHECK_EQ(5, result->Int32Value());
+  CHECK_EQ(5, result->Int32Value(env.local()).FromJust());
 
-  v8::Handle<v8::FunctionTemplate> runtimeFunction =
+  v8::Local<v8::FunctionTemplate> runtimeFunction =
       v8::FunctionTemplate::New(isolate, ExtrasBindingTestRuntimeFunction);
-  binding->Set(v8_str("runtime"), runtimeFunction->GetFunction());
+  binding->Set(v8_str("runtime"),
+               runtimeFunction->GetFunction(env.local()).ToLocalChecked());
   func =
       binding->Get(v8_str("testExtraShouldCallToRuntime")).As<v8::Function>();
   result = func->Call(undefined, 0, {}).As<v8::Number>();
-  CHECK_EQ(7, result->Int32Value());
+  CHECK_EQ(7, result->Int32Value(env.local()).FromJust());
 }
 
 
 TEST(ExperimentalExtras) {
   i::FLAG_experimental_extras = true;
 
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   LocalContext env;
 
   // standalone.gypi ensures we include the test-experimental-extra.js file,
   // which should export the tested functions.
   v8::Local<v8::Object> binding = env->GetExtrasBindingObject();
 
   auto func = binding->Get(v8_str("testExperimentalExtraShouldReturnTen"))
                   .As<v8::Function>();
   auto undefined = v8::Undefined(isolate);
   auto result = func->Call(undefined, 0, {}).As<v8::Number>();
-  CHECK_EQ(10, result->Int32Value());
+  CHECK_EQ(10, result->Int32Value(env.local()).FromJust());
 
-  v8::Handle<v8::FunctionTemplate> runtimeFunction =
+  v8::Local<v8::FunctionTemplate> runtimeFunction =
       v8::FunctionTemplate::New(isolate, ExtrasBindingTestRuntimeFunction);
-  binding->Set(v8_str("runtime"), runtimeFunction->GetFunction());
+  binding->Set(v8_str("runtime"),
+               runtimeFunction->GetFunction(env.local()).ToLocalChecked());
   func = binding->Get(v8_str("testExperimentalExtraShouldCallToRuntime"))
              .As<v8::Function>();
   result = func->Call(undefined, 0, {}).As<v8::Number>();
-  CHECK_EQ(7, result->Int32Value());
+  CHECK_EQ(7, result->Int32Value(env.local()).FromJust());
 }
 
 
 TEST(ExtrasUtilsObject) {
   LocalContext context;
   v8::Isolate* isolate = context->GetIsolate();
   v8::HandleScope handle_scope(isolate);
 
   LocalContext env;
   v8::Local<v8::Object> binding = env->GetExtrasBindingObject();
 
   auto func = binding->Get(v8_str("testExtraCanUseUtils")).As<v8::Function>();
   auto undefined = v8::Undefined(isolate);
   auto result = func->Call(undefined, 0, {}).As<v8::Object>();
 
   auto private_symbol = result->Get(v8_str("privateSymbol")).As<v8::Symbol>();
   i::Handle<i::Symbol> ips = v8::Utils::OpenHandle(*private_symbol);
   CHECK_EQ(true, ips->IsPrivate());
 
   CompileRun("var result = 0; function store(x) { result = x; }");
   auto store = CompileRun("store").As<v8::Function>();
 
   auto fulfilled_promise =
       result->Get(v8_str("fulfilledPromise")).As<v8::Promise>();
   fulfilled_promise->Then(store);
   isolate->RunMicrotasks();
-  CHECK_EQ(1, CompileRun("result")->Int32Value());
+  CHECK_EQ(1, CompileRun("result")->Int32Value(env.local()).FromJust());
 
   auto fulfilled_promise_2 =
       result->Get(v8_str("fulfilledPromise2")).As<v8::Promise>();
   fulfilled_promise_2->Then(store);
   isolate->RunMicrotasks();
-  CHECK_EQ(2, CompileRun("result")->Int32Value());
+  CHECK_EQ(2, CompileRun("result")->Int32Value(env.local()).FromJust());
 
   auto rejected_promise =
       result->Get(v8_str("rejectedPromise")).As<v8::Promise>();
   rejected_promise->Catch(store);
   isolate->RunMicrotasks();
-  CHECK_EQ(3, CompileRun("result")->Int32Value());
+  CHECK_EQ(3, CompileRun("result")->Int32Value(env.local()).FromJust());
 }
 
 
 TEST(Map) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
   LocalContext env;
 
   v8::Local<v8::Map> map = v8::Map::New(isolate);
   CHECK(map->IsObject());
@@ skipping 16 matching lines @@
   CHECK_EQ(2U, map->Size());
 
   CHECK(map->Has(env.local(), v8::Integer::New(isolate, 1)).FromJust());
   CHECK(map->Has(env.local(), v8::Integer::New(isolate, 3)).FromJust());
 
   CHECK(!map->Has(env.local(), v8::Integer::New(isolate, 2)).FromJust());
   CHECK(!map->Has(env.local(), map).FromJust());
 
   CHECK_EQ(2, map->Get(env.local(), v8::Integer::New(isolate, 1))
                   .ToLocalChecked()
-                  ->Int32Value());
+                  ->Int32Value(env.local())
+                  .FromJust());
   CHECK_EQ(4, map->Get(env.local(), v8::Integer::New(isolate, 3))
                   .ToLocalChecked()
-                  ->Int32Value());
+                  ->Int32Value(env.local())
+                  .FromJust());
 
   CHECK(map->Get(env.local(), v8::Integer::New(isolate, 42))
             .ToLocalChecked()
             ->IsUndefined());
 
   CHECK(!map->Set(env.local(), map, map).IsEmpty());
   CHECK_EQ(3U, map->Size());
   CHECK(map->Has(env.local(), map).FromJust());
 
   CHECK(map->Delete(env.local(), map).FromJust());
@@ skipping 53 matching lines @@
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   v8::Local<v8::FunctionTemplate> parent = FunctionTemplate::New(isolate);
   v8::Local<v8::Signature> signature = v8::Signature::New(isolate, parent);
   auto returns_42 =
       v8::FunctionTemplate::New(isolate, Returns42, Local<Value>(), signature);
   parent->PrototypeTemplate()->SetAccessorProperty(v8_str("age"), returns_42);
   v8::Local<v8::FunctionTemplate> child = v8::FunctionTemplate::New(isolate);
   child->Inherit(parent);
   LocalContext env;
-  env->Global()->Set(v8_str("Child"), child->GetFunction());
+  CHECK(env->Global()
+            ->Set(env.local(), v8_str("Child"),
+                  child->GetFunction(env.local()).ToLocalChecked())
+            .FromJust());
 
   // Make sure there's a compiled stub for "Child.prototype.age" in the cache.
   CompileRun(
       "var real = new Child();\n"
       "for (var i = 0; i < 3; ++i) {\n"
       "  real.age;\n"
       "}\n");
 
   // Check that the cached stub is never used.
   ExpectInt32(
@@ skipping 62 matching lines @@
 
 bool NoAbortOnUncaughtException(v8::Isolate* isolate) {
   ++nb_uncaught_exception_callback_calls;
   return false;
 }
 
 
 TEST(AbortOnUncaughtExceptionNoAbort) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope handle_scope(isolate);
-  v8::Handle<v8::ObjectTemplate> global_template =
+  v8::Local<v8::ObjectTemplate> global_template =
       v8::ObjectTemplate::New(isolate);
   LocalContext env(NULL, global_template);
 
   i::FLAG_abort_on_uncaught_exception = true;
   isolate->SetAbortOnUncaughtExceptionCallback(NoAbortOnUncaughtException);
 
   CompileRun("function boom() { throw new Error(\"boom\") }");
 
   v8::Local<v8::Object> global_object = env->Global();
   v8::Local<v8::Function> foo =
       v8::Local<v8::Function>::Cast(global_object->Get(v8_str("boom")));
 
   foo->Call(global_object, 0, NULL);
 
   CHECK_EQ(1, nb_uncaught_exception_callback_calls);
 }
 
 
 TEST(AccessCheckedIsConcatSpreadable) {
   i::FLAG_harmony_concat_spreadable = true;
   v8::Isolate* isolate = CcTest::isolate();
   HandleScope scope(isolate);
   LocalContext env;
 
   // Object with access check
   Local<ObjectTemplate> spreadable_template = v8::ObjectTemplate::New(isolate);
   spreadable_template->SetAccessCheckCallback(AccessBlocker);
   spreadable_template->Set(v8::Symbol::GetIsConcatSpreadable(isolate),
                            v8::Boolean::New(isolate, true));
-  Local<Object> object = spreadable_template->NewInstance();
+  Local<Object> object =
+      spreadable_template->NewInstance(env.local()).ToLocalChecked();
 
   allowed_access = true;
-  env->Global()->Set(v8_str("object"), object);
+  CHECK(env->Global()->Set(env.local(), v8_str("object"), object).FromJust());
   object->Set(v8_str("length"), v8_num(2));
   object->Set(0U, v8_str("a"));
   object->Set(1U, v8_str("b"));
 
   // Access check is allowed, and the object is spread
   CompileRun("var result = [].concat(object)");
   ExpectTrue("Array.isArray(result)");
   ExpectString("result[0]", "a");
   ExpectString("result[1]", "b");
   ExpectTrue("result.length === 2");
@@ skipping 48 matching lines @@
 
 
 TEST(ObjectTemplateIntrinsics) {
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   LocalContext env;
 
   Local<ObjectTemplate> object_template = v8::ObjectTemplate::New(isolate);
   object_template->SetIntrinsicDataProperty(v8_str("values"),
                                             v8::kArrayProto_values);
-  Local<Object> object = object_template->NewInstance();
+  Local<Object> object =
+      object_template->NewInstance(env.local()).ToLocalChecked();
 
-  env->Global()->Set(v8_str("obj1"), object);
+  CHECK(env->Global()->Set(env.local(), v8_str("obj1"), object).FromJust());
   ExpectString("typeof obj1.values", "function");
 
   auto values = Local<Function>::Cast(object->Get(v8_str("values")));
   auto fn = i::Handle<i::JSFunction>::cast(v8::Utils::OpenHandle(*values));
   auto ctx = v8::Utils::OpenHandle(*env.local());
   CHECK_EQ(fn->GetCreationContext(), *ctx);
 
   {
     LocalContext env2;
-    Local<Object> object2 = object_template->NewInstance();
-    env2->Global()->Set(v8_str("obj2"), object2);
+    Local<Object> object2 =
+        object_template->NewInstance(env2.local()).ToLocalChecked();
+    CHECK(
+        env2->Global()->Set(env2.local(), v8_str("obj2"), object2).FromJust());
     ExpectString("typeof obj2.values", "function");
     CHECK_NE(*object->Get(v8_str("values")), *object2->Get(v8_str("values")));
 
     auto values2 = Local<Function>::Cast(object2->Get(v8_str("values")));
     auto fn2 = i::Handle<i::JSFunction>::cast(v8::Utils::OpenHandle(*values2));
     auto ctx2 = v8::Utils::OpenHandle(*env2.local());
     CHECK_EQ(fn2->GetCreationContext(), *ctx2);
   }
 }