[test] Move away from deprecated API for heap-related tests.

test/cctest/test-heap.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
 //       with the distribution.
 //     * Neither the name of Google Inc. nor the names of its
 //       contributors may be used to endorse or promote products derived
 //       from this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+// TODO(jochen): Remove this after the setting is turned on globally.
+#define V8_IMMINENT_DEPRECATION_WARNINGS
+
 #include <stdlib.h>
 #include <utility>
 
 #include "src/compilation-cache.h"
 #include "src/context-measure.h"
 #include "src/deoptimizer.h"
 #include "src/execution.h"
 #include "src/factory.h"
 #include "src/global-handles.h"
 #include "src/heap/gc-tracer.h"
 #include "src/heap/memory-reducer.h"
 #include "src/ic/ic.h"
 #include "src/macro-assembler.h"
 #include "src/snapshot/snapshot.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/heap-tester.h"
 #include "test/cctest/test-feedback-vector.h"
 
-using v8::Just;
 
 namespace v8 {
 namespace internal {
 
 static void CheckMap(Map* map, int type, int instance_size) {
   CHECK(map->IsHeapObject());
 #ifdef DEBUG
   CHECK(CcTest::heap()->Contains(map));
 #endif
   CHECK_EQ(CcTest::heap()->meta_map(), map->map());
@@ skipping 1584 matching lines @@
     count++;
     object = Context::cast(object)->get(Context::NEXT_CONTEXT_LINK);
   }
   // Subtract one to compensate for the code stub context that is always present
   return count - 1;
 }
 
 
 // Count the number of user functions in the weak list of optimized
 // functions attached to a native context.
-static int CountOptimizedUserFunctions(v8::Handle<v8::Context> context) {
+static int CountOptimizedUserFunctions(v8::Local<v8::Context> context) {
   int count = 0;
   Handle<Context> icontext = v8::Utils::OpenHandle(*context);
   Object* object = icontext->get(Context::OPTIMIZED_FUNCTIONS_LIST);
   while (object->IsJSFunction() &&
          !JSFunction::cast(object)->shared()->IsBuiltin()) {
     count++;
     object = JSFunction::cast(object)->next_function_link();
   }
   return count;
 }
 
 
 TEST(TestInternalWeakLists) {
   FLAG_always_opt = false;
   FLAG_allow_natives_syntax = true;
   v8::V8::Initialize();
 
   // Some flags turn Scavenge collections into Mark-sweep collections
   // and hence are incompatible with this test case.
   if (FLAG_gc_global || FLAG_stress_compaction) return;
   FLAG_retain_maps_for_n_gc = 0;
 
   static const int kNumTestContexts = 10;
 
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
   HandleScope scope(isolate);
-  v8::Handle<v8::Context> ctx[kNumTestContexts];
+  v8::Local<v8::Context> ctx[kNumTestContexts];
   if (!isolate->use_crankshaft()) return;
 
   CHECK_EQ(0, CountNativeContexts());
 
   // Create a number of global contests which gets linked together.
   for (int i = 0; i < kNumTestContexts; i++) {
     ctx[i] = v8::Context::New(CcTest::isolate());
 
     // Collect garbage that might have been created by one of the
     // installed extensions.
@@ skipping 92 matching lines @@
                        isolate);
   }
   // Subtract one to compensate for the code stub context that is always present
   return count - 1;
 }
 
 
 // Count the number of user functions in the weak list of optimized
 // functions attached to a native context causing a GC after the
 // specified number of elements.
-static int CountOptimizedUserFunctionsWithGC(v8::Handle<v8::Context> context,
+static int CountOptimizedUserFunctionsWithGC(v8::Local<v8::Context> context,
                                              int n) {
   int count = 0;
   Handle<Context> icontext = v8::Utils::OpenHandle(*context);
   Isolate* isolate = icontext->GetIsolate();
   Handle<Object> object(icontext->get(Context::OPTIMIZED_FUNCTIONS_LIST),
                         isolate);
   while (object->IsJSFunction() &&
          !Handle<JSFunction>::cast(object)->shared()->IsBuiltin()) {
     count++;
     if (count == n) isolate->heap()->CollectAllGarbage();
     object = Handle<Object>(
         Object::cast(JSFunction::cast(*object)->next_function_link()),
         isolate);
   }
   return count;
 }
 
 
 TEST(TestInternalWeakListsTraverseWithGC) {
   FLAG_always_opt = false;
   FLAG_allow_natives_syntax = true;
   v8::V8::Initialize();
 
   static const int kNumTestContexts = 10;
 
   Isolate* isolate = CcTest::i_isolate();
   HandleScope scope(isolate);
-  v8::Handle<v8::Context> ctx[kNumTestContexts];
+  v8::Local<v8::Context> ctx[kNumTestContexts];
   if (!isolate->use_crankshaft()) return;
 
   CHECK_EQ(0, CountNativeContexts());
 
   // Create an number of contexts and check the length of the weak list both
   // with and without GCs while iterating the list.
   for (int i = 0; i < kNumTestContexts; i++) {
     ctx[i] = v8::Context::New(CcTest::isolate());
     CHECK_EQ(i + 1, CountNativeContexts());
     CHECK_EQ(i + 1, CountNativeContextsWithGC(isolate, i / 2 + 1));
@@ skipping 551 matching lines @@
   }
 
   CcTest::heap()->CollectAllAvailableGarbage();
   CHECK_EQ(4, NumberOfGlobalObjects());
 
   {
     v8::HandleScope inner_scope(isolate);
     CompileRun("var v = {x: 42}");
     v8::Local<v8::Context> ctx1 = v8::Local<v8::Context>::New(isolate, ctx1p);
     v8::Local<v8::Context> ctx2 = v8::Local<v8::Context>::New(isolate, ctx2p);
-    v8::Local<v8::Value> v = ctx1->Global()->Get(v8_str("v"));
+    v8::Local<v8::Value> v =
+        ctx1->Global()->Get(ctx1, v8_str("v")).ToLocalChecked();
     ctx2->Enter();
-    ctx2->Global()->Set(v8_str("o"), v);
+    CHECK(ctx2->Global()->Set(ctx2, v8_str("o"), v).FromJust());
     v8::Local<v8::Value> res = CompileRun(
         "function f() { return o.x; }"
         "for (var i = 0; i < 10; ++i) f();"
         "%OptimizeFunctionOnNextCall(f);"
         "f();");
-    CHECK_EQ(42, res->Int32Value());
-    ctx2->Global()->Set(v8_str("o"), v8::Int32::New(isolate, 0));
+    CHECK_EQ(42, res->Int32Value(ctx2).FromJust());
+    CHECK(ctx2->Global()
+              ->Set(ctx2, v8_str("o"), v8::Int32::New(isolate, 0))
+              .FromJust());
     ctx2->Exit();
     v8::Local<v8::Context>::New(isolate, ctx1)->Exit();
     ctx1p.Reset();
     isolate->ContextDisposedNotification();
   }
   CcTest::heap()->CollectAllAvailableGarbage();
   CHECK_EQ(2, NumberOfGlobalObjects());
   ctx2p.Reset();
   CcTest::heap()->CollectAllAvailableGarbage();
   CHECK_EQ(0, NumberOfGlobalObjects());
@@ skipping 16 matching lines @@
   }
 
   CcTest::heap()->CollectAllAvailableGarbage();
   CHECK_EQ(4, NumberOfGlobalObjects());
 
   {
     v8::HandleScope inner_scope(isolate);
     CompileRun("var v = function() { return 42; }");
     v8::Local<v8::Context> ctx1 = v8::Local<v8::Context>::New(isolate, ctx1p);
     v8::Local<v8::Context> ctx2 = v8::Local<v8::Context>::New(isolate, ctx2p);
-    v8::Local<v8::Value> v = ctx1->Global()->Get(v8_str("v"));
+    v8::Local<v8::Value> v =
+        ctx1->Global()->Get(ctx1, v8_str("v")).ToLocalChecked();
     ctx2->Enter();
-    ctx2->Global()->Set(v8_str("o"), v);
+    CHECK(ctx2->Global()->Set(ctx2, v8_str("o"), v).FromJust());
     v8::Local<v8::Value> res = CompileRun(
         "function f(x) { return x(); }"
         "for (var i = 0; i < 10; ++i) f(o);"
         "%OptimizeFunctionOnNextCall(f);"
         "f(o);");
-    CHECK_EQ(42, res->Int32Value());
-    ctx2->Global()->Set(v8_str("o"), v8::Int32::New(isolate, 0));
+    CHECK_EQ(42, res->Int32Value(ctx2).FromJust());
+    CHECK(ctx2->Global()
+              ->Set(ctx2, v8_str("o"), v8::Int32::New(isolate, 0))
+              .FromJust());
     ctx2->Exit();
     ctx1->Exit();
     ctx1p.Reset();
     isolate->ContextDisposedNotification();
   }
   CcTest::heap()->CollectAllAvailableGarbage();
   CHECK_EQ(2, NumberOfGlobalObjects());
   ctx2p.Reset();
   CcTest::heap()->CollectAllAvailableGarbage();
   CHECK_EQ(0, NumberOfGlobalObjects());
@@ skipping 14 matching lines @@
   }
 
   CcTest::heap()->CollectAllAvailableGarbage();
   CHECK_EQ(4, NumberOfGlobalObjects());
 
   {
     v8::HandleScope inner_scope(isolate);
     CompileRun("var v = [42, 43]");
     v8::Local<v8::Context> ctx1 = v8::Local<v8::Context>::New(isolate, ctx1p);
     v8::Local<v8::Context> ctx2 = v8::Local<v8::Context>::New(isolate, ctx2p);
-    v8::Local<v8::Value> v = ctx1->Global()->Get(v8_str("v"));
+    v8::Local<v8::Value> v =
+        ctx1->Global()->Get(ctx1, v8_str("v")).ToLocalChecked();
     ctx2->Enter();
-    ctx2->Global()->Set(v8_str("o"), v);
+    CHECK(ctx2->Global()->Set(ctx2, v8_str("o"), v).FromJust());
     v8::Local<v8::Value> res = CompileRun(
         "function f() { return o[0]; }"
         "for (var i = 0; i < 10; ++i) f();"
         "%OptimizeFunctionOnNextCall(f);"
         "f();");
-    CHECK_EQ(42, res->Int32Value());
-    ctx2->Global()->Set(v8_str("o"), v8::Int32::New(isolate, 0));
+    CHECK_EQ(42, res->Int32Value(ctx2).FromJust());
+    CHECK(ctx2->Global()
+              ->Set(ctx2, v8_str("o"), v8::Int32::New(isolate, 0))
+              .FromJust());
     ctx2->Exit();
     ctx1->Exit();
     ctx1p.Reset();
     isolate->ContextDisposedNotification();
   }
   CcTest::heap()->CollectAllAvailableGarbage();
   CHECK_EQ(2, NumberOfGlobalObjects());
   ctx2p.Reset();
   CcTest::heap()->CollectAllAvailableGarbage();
   CHECK_EQ(0, NumberOfGlobalObjects());
@@ skipping 14 matching lines @@
   }
 
   CcTest::heap()->CollectAllAvailableGarbage();
   CHECK_EQ(4, NumberOfGlobalObjects());
 
   {
     v8::HandleScope inner_scope(isolate);
     CompileRun("var v = { y: 42}");
     v8::Local<v8::Context> ctx1 = v8::Local<v8::Context>::New(isolate, ctx1p);
     v8::Local<v8::Context> ctx2 = v8::Local<v8::Context>::New(isolate, ctx2p);
-    v8::Local<v8::Value> v = ctx1->Global()->Get(v8_str("v"));
+    v8::Local<v8::Value> v =
+        ctx1->Global()->Get(ctx1, v8_str("v")).ToLocalChecked();
     ctx2->Enter();
-    ctx2->Global()->Set(v8_str("o"), v);
+    CHECK(ctx2->Global()->Set(ctx2, v8_str("o"), v).FromJust());
     v8::Local<v8::Value> res = CompileRun(
         "function f() {"
         "  var p = {x: 42};"
         "  p.__proto__ = o;"
         "  return p.x;"
         "}"
         "for (var i = 0; i < 10; ++i) f();"
         "%OptimizeFunctionOnNextCall(f);"
         "f();");
-    CHECK_EQ(42, res->Int32Value());
-    ctx2->Global()->Set(v8_str("o"), v8::Int32::New(isolate, 0));
+    CHECK_EQ(42, res->Int32Value(ctx2).FromJust());
+    CHECK(ctx2->Global()
+              ->Set(ctx2, v8_str("o"), v8::Int32::New(isolate, 0))
+              .FromJust());
     ctx2->Exit();
     ctx1->Exit();
     ctx1p.Reset();
     isolate->ContextDisposedNotification();
   }
   CcTest::heap()->CollectAllAvailableGarbage();
   CHECK_EQ(2, NumberOfGlobalObjects());
   ctx2p.Reset();
   CcTest::heap()->CollectAllAvailableGarbage();
   CHECK_EQ(0, NumberOfGlobalObjects());
 }
 
 
 TEST(InstanceOfStubWriteBarrier) {
   i::FLAG_allow_natives_syntax = true;
 #ifdef VERIFY_HEAP
   i::FLAG_verify_heap = true;
 #endif
 
   CcTest::InitializeVM();
   if (!CcTest::i_isolate()->use_crankshaft()) return;
   if (i::FLAG_force_marking_deque_overflows) return;
   v8::HandleScope outer_scope(CcTest::isolate());
+  v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
 
   {
     v8::HandleScope scope(CcTest::isolate());
     CompileRun(
         "function foo () { }"
         "function mkbar () { return new (new Function(\"\")) (); }"
         "function f (x) { return (x instanceof foo); }"
         "function g () { f(mkbar()); }"
         "f(new foo()); f(new foo());"
         "%OptimizeFunctionOnNextCall(f);"
         "f(new foo()); g();");
   }
 
   IncrementalMarking* marking = CcTest::heap()->incremental_marking();
   marking->Stop();
   CcTest::heap()->StartIncrementalMarking();
 
-  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+  i::Handle<JSFunction> f = i::Handle<JSFunction>::cast(
+      v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+          CcTest::global()->Get(ctx, v8_str("f")).ToLocalChecked())));
 
   CHECK(f->IsOptimized());
 
   while (!Marking::IsBlack(Marking::MarkBitFrom(f->code())) &&
          !marking->IsStopped()) {
     // Discard any pending GC requests otherwise we will get GC when we enter
     // code below.
     marking->Step(MB, IncrementalMarking::NO_GC_VIA_STACK_GUARD);
   }
 
   CHECK(marking->IsMarking());
 
   {
     v8::HandleScope scope(CcTest::isolate());
-    v8::Handle<v8::Object> global = CcTest::global();
-    v8::Handle<v8::Function> g =
-        v8::Handle<v8::Function>::Cast(global->Get(v8_str("g")));
-    g->Call(global, 0, NULL);
+    v8::Local<v8::Object> global = CcTest::global();
+    v8::Local<v8::Function> g = v8::Local<v8::Function>::Cast(
+        global->Get(ctx, v8_str("g")).ToLocalChecked());
+    g->Call(ctx, global, 0, nullptr).ToLocalChecked();
   }
 
   CcTest::heap()->incremental_marking()->set_should_hurry(true);
   CcTest::heap()->CollectGarbage(OLD_SPACE);
 }
 
 
 static int NumberOfProtoTransitions(Map* map) {
   return TransitionArray::NumberOfPrototypeTransitions(
       TransitionArray::GetPrototypeTransitions(map));
 }
 
 
 TEST(PrototypeTransitionClearing) {
   if (FLAG_never_compact) return;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   v8::HandleScope scope(CcTest::isolate());
+  v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
 
   CompileRun("var base = {};");
-  Handle<JSObject> baseObject =
-      v8::Utils::OpenHandle(
-          *v8::Handle<v8::Object>::Cast(
-              CcTest::global()->Get(v8_str("base"))));
+  i::Handle<JSObject> baseObject =
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(
+          CcTest::global()->Get(ctx, v8_str("base")).ToLocalChecked()));
+
   int initialTransitions = NumberOfProtoTransitions(baseObject->map());
 
   CompileRun(
       "var live = [];"
       "for (var i = 0; i < 10; i++) {"
       "  var object = {};"
       "  var prototype = {};"
       "  object.__proto__ = prototype;"
       "  if (i >= 3) live.push(object, prototype);"
       "}");
@@ skipping 38 matching lines @@
 TEST(ResetSharedFunctionInfoCountersDuringIncrementalMarking) {
   i::FLAG_stress_compaction = false;
   i::FLAG_allow_natives_syntax = true;
 #ifdef VERIFY_HEAP
   i::FLAG_verify_heap = true;
 #endif
 
   CcTest::InitializeVM();
   if (!CcTest::i_isolate()->use_crankshaft()) return;
   v8::HandleScope outer_scope(CcTest::isolate());
+  v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
 
   {
     v8::HandleScope scope(CcTest::isolate());
     CompileRun(
         "function f () {"
         "  var s = 0;"
         "  for (var i = 0; i < 100; i++)  s += i;"
         "  return s;"
         "}"
         "f(); f();"
         "%OptimizeFunctionOnNextCall(f);"
         "f();");
   }
-  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+  i::Handle<JSFunction> f = i::Handle<JSFunction>::cast(
+      v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+          CcTest::global()->Get(ctx, v8_str("f")).ToLocalChecked())));
   CHECK(f->IsOptimized());
 
   IncrementalMarking* marking = CcTest::heap()->incremental_marking();
   marking->Stop();
   CcTest::heap()->StartIncrementalMarking();
   // The following calls will increment CcTest::heap()->global_ic_age().
   CcTest::isolate()->ContextDisposedNotification();
   SimulateIncrementalMarking(CcTest::heap());
   CcTest::heap()->CollectAllGarbage();
   CHECK_EQ(CcTest::heap()->global_ic_age(), f->shared()->ic_age());
   CHECK_EQ(0, f->shared()->opt_count());
   CHECK_EQ(0, f->shared()->code()->profiler_ticks());
 }
 
 
 TEST(ResetSharedFunctionInfoCountersDuringMarkSweep) {
   i::FLAG_stress_compaction = false;
   i::FLAG_allow_natives_syntax = true;
 #ifdef VERIFY_HEAP
   i::FLAG_verify_heap = true;
 #endif
 
   CcTest::InitializeVM();
   if (!CcTest::i_isolate()->use_crankshaft()) return;
   v8::HandleScope outer_scope(CcTest::isolate());
+  v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
 
   {
     v8::HandleScope scope(CcTest::isolate());
     CompileRun(
         "function f () {"
         "  var s = 0;"
         "  for (var i = 0; i < 100; i++)  s += i;"
         "  return s;"
         "}"
         "f(); f();"
         "%OptimizeFunctionOnNextCall(f);"
         "f();");
   }
-  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+  i::Handle<JSFunction> f = i::Handle<JSFunction>::cast(
+      v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+          CcTest::global()->Get(ctx, v8_str("f")).ToLocalChecked())));
+
   CHECK(f->IsOptimized());
 
   CcTest::heap()->incremental_marking()->Stop();
 
   // The following two calls will increment CcTest::heap()->global_ic_age().
   CcTest::isolate()->ContextDisposedNotification();
   CcTest::heap()->CollectAllGarbage();
 
   CHECK_EQ(CcTest::heap()->global_ic_age(), f->shared()->ic_age());
   CHECK_EQ(0, f->shared()->opt_count());
@@ skipping 79 matching lines @@
 }
 
 
 // Test that HAllocateObject will always return an object in new-space.
 TEST(OptimizedAllocationAlwaysInNewSpace) {
   i::FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   if (!CcTest::i_isolate()->use_crankshaft() || i::FLAG_always_opt) return;
   if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
   v8::HandleScope scope(CcTest::isolate());
-
+  v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   SimulateFullSpace(CcTest::heap()->new_space());
   AlwaysAllocateScope always_allocate(CcTest::i_isolate());
   v8::Local<v8::Value> res = CompileRun(
       "function c(x) {"
       "  this.x = x;"
       "  for (var i = 0; i < 32; i++) {"
       "    this['x' + i] = x;"
       "  }"
       "}"
       "function f(x) { return new c(x); };"
       "f(1); f(2); f(3);"
       "%OptimizeFunctionOnNextCall(f);"
       "f(4);");
-  CHECK_EQ(
-      4, res.As<v8::Object>()->GetRealNamedProperty(v8_str("x"))->Int32Value());
 
-  Handle<JSObject> o =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
+  CHECK_EQ(4, res.As<v8::Object>()
+                  ->GetRealNamedProperty(ctx, v8_str("x"))
+                  .ToLocalChecked()
+                  ->Int32Value(ctx)
+                  .FromJust());
+
+  i::Handle<JSObject> o =
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(res));
 
   CHECK(CcTest::heap()->InNewSpace(*o));
 }
 
 
 TEST(OptimizedPretenuringAllocationFolding) {
   i::FLAG_allow_natives_syntax = true;
   i::FLAG_expose_gc = true;
   CcTest::InitializeVM();
   if (!CcTest::i_isolate()->use_crankshaft() || i::FLAG_always_opt) return;
   if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
   v8::HandleScope scope(CcTest::isolate());
-
+  v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   // Grow new space unitl maximum capacity reached.
   while (!CcTest::heap()->new_space()->IsAtMaximumCapacity()) {
     CcTest::heap()->new_space()->Grow();
   }
 
   i::ScopedVector<char> source(1024);
   i::SNPrintF(
       source,
       "var number_elements = %d;"
       "var elements = new Array();"
       "function f() {"
       "  for (var i = 0; i < number_elements; i++) {"
       "    elements[i] = [[{}], [1.1]];"
       "  }"
       "  return elements[number_elements-1]"
       "};"
       "f(); gc();"
       "f(); f();"
       "%%OptimizeFunctionOnNextCall(f);"
       "f();",
       AllocationSite::kPretenureMinimumCreated);
 
   v8::Local<v8::Value> res = CompileRun(source.start());
 
-  v8::Local<v8::Value> int_array = v8::Object::Cast(*res)->Get(v8_str("0"));
-  Handle<JSObject> int_array_handle =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(int_array));
-  v8::Local<v8::Value> double_array = v8::Object::Cast(*res)->Get(v8_str("1"));
-  Handle<JSObject> double_array_handle =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(double_array));
+  v8::Local<v8::Value> int_array =
+      v8::Object::Cast(*res)->Get(ctx, v8_str("0")).ToLocalChecked();
+  i::Handle<JSObject> int_array_handle =
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(int_array));
+  v8::Local<v8::Value> double_array =
+      v8::Object::Cast(*res)->Get(ctx, v8_str("1")).ToLocalChecked();
+  i::Handle<JSObject> double_array_handle =
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(double_array));
 
-  Handle<JSObject> o =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
+  i::Handle<JSObject> o =
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(res));
   CHECK(CcTest::heap()->InOldSpace(*o));
   CHECK(CcTest::heap()->InOldSpace(*int_array_handle));
   CHECK(CcTest::heap()->InOldSpace(int_array_handle->elements()));
   CHECK(CcTest::heap()->InOldSpace(*double_array_handle));
   CHECK(CcTest::heap()->InOldSpace(double_array_handle->elements()));
 }
 
 
 TEST(OptimizedPretenuringObjectArrayLiterals) {
   i::FLAG_allow_natives_syntax = true;
@@ skipping 20 matching lines @@
       "  return elements[number_elements - 1];"
       "};"
       "f(); gc();"
       "f(); f();"
       "%%OptimizeFunctionOnNextCall(f);"
       "f();",
       AllocationSite::kPretenureMinimumCreated);
 
   v8::Local<v8::Value> res = CompileRun(source.start());
 
-  Handle<JSObject> o =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
+  i::Handle<JSObject> o =
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(res));
 
   CHECK(CcTest::heap()->InOldSpace(o->elements()));
   CHECK(CcTest::heap()->InOldSpace(*o));
 }
 
 
 TEST(OptimizedPretenuringMixedInObjectProperties) {
   i::FLAG_allow_natives_syntax = true;
   i::FLAG_expose_gc = true;
   CcTest::InitializeVM();
@@ skipping 19 matching lines @@
       "  return elements[number_elements - 1];"
       "};"
       "f(); gc();"
       "f(); f();"
       "%%OptimizeFunctionOnNextCall(f);"
       "f();",
       AllocationSite::kPretenureMinimumCreated);
 
   v8::Local<v8::Value> res = CompileRun(source.start());
 
-  Handle<JSObject> o =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
+  i::Handle<JSObject> o =
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(res));
 
   CHECK(CcTest::heap()->InOldSpace(*o));
   FieldIndex idx1 = FieldIndex::ForPropertyIndex(o->map(), 0);
   FieldIndex idx2 = FieldIndex::ForPropertyIndex(o->map(), 1);
   CHECK(CcTest::heap()->InOldSpace(o->RawFastPropertyAt(idx1)));
   if (!o->IsUnboxedDoubleField(idx2)) {
     CHECK(CcTest::heap()->InOldSpace(o->RawFastPropertyAt(idx2)));
   } else {
     CHECK_EQ(1.1, o->RawFastDoublePropertyAt(idx2));
   }
@@ skipping 35 matching lines @@
       "  return elements[i - 1];"
       "};"
       "f(); gc();"
       "f(); f();"
       "%%OptimizeFunctionOnNextCall(f);"
       "f();",
       AllocationSite::kPretenureMinimumCreated);
 
   v8::Local<v8::Value> res = CompileRun(source.start());
 
-  Handle<JSObject> o =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
+  i::Handle<JSObject> o =
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(res));
 
   CHECK(CcTest::heap()->InOldSpace(*o));
   CHECK(CcTest::heap()->InOldSpace(o->properties()));
 }
 
 
 TEST(OptimizedPretenuringdoubleArrayLiterals) {
   i::FLAG_allow_natives_syntax = true;
   i::FLAG_expose_gc = true;
   CcTest::InitializeVM();
@@ skipping 18 matching lines @@
       "  return elements[number_elements - 1];"
       "};"
       "f(); gc();"
       "f(); f();"
       "%%OptimizeFunctionOnNextCall(f);"
       "f();",
       AllocationSite::kPretenureMinimumCreated);
 
   v8::Local<v8::Value> res = CompileRun(source.start());
 
-  Handle<JSObject> o =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
+  i::Handle<JSObject> o =
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(res));
 
   CHECK(CcTest::heap()->InOldSpace(o->elements()));
   CHECK(CcTest::heap()->InOldSpace(*o));
 }
 
 
 TEST(OptimizedPretenuringNestedMixedArrayLiterals) {
   i::FLAG_allow_natives_syntax = true;
   i::FLAG_expose_gc = true;
   CcTest::InitializeVM();
   if (!CcTest::i_isolate()->use_crankshaft() || i::FLAG_always_opt) return;
   if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
   v8::HandleScope scope(CcTest::isolate());
-
+  v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   // Grow new space unitl maximum capacity reached.
   while (!CcTest::heap()->new_space()->IsAtMaximumCapacity()) {
     CcTest::heap()->new_space()->Grow();
   }
 
   i::ScopedVector<char> source(1024);
   i::SNPrintF(
       source,
       "var number_elements = 100;"
       "var elements = new Array(number_elements);"
       "function f() {"
       "  for (var i = 0; i < number_elements; i++) {"
       "    elements[i] = [[{}, {}, {}], [1.1, 2.2, 3.3]];"
       "  }"
       "  return elements[number_elements - 1];"
       "};"
       "f(); gc();"
       "f(); f();"
       "%%OptimizeFunctionOnNextCall(f);"
       "f();");
 
   v8::Local<v8::Value> res = CompileRun(source.start());
 
-  v8::Local<v8::Value> int_array = v8::Object::Cast(*res)->Get(v8_str("0"));
-  Handle<JSObject> int_array_handle =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(int_array));
-  v8::Local<v8::Value> double_array = v8::Object::Cast(*res)->Get(v8_str("1"));
-  Handle<JSObject> double_array_handle =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(double_array));
+  v8::Local<v8::Value> int_array =
+      v8::Object::Cast(*res)->Get(ctx, v8_str("0")).ToLocalChecked();
+  i::Handle<JSObject> int_array_handle =
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(int_array));
+  v8::Local<v8::Value> double_array =
+      v8::Object::Cast(*res)->Get(ctx, v8_str("1")).ToLocalChecked();
+  i::Handle<JSObject> double_array_handle =
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(double_array));
 
-  Handle<JSObject> o =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
+  Handle<JSObject> o = v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(res));
   CHECK(CcTest::heap()->InOldSpace(*o));
   CHECK(CcTest::heap()->InOldSpace(*int_array_handle));
   CHECK(CcTest::heap()->InOldSpace(int_array_handle->elements()));
   CHECK(CcTest::heap()->InOldSpace(*double_array_handle));
   CHECK(CcTest::heap()->InOldSpace(double_array_handle->elements()));
 }
 
 
 TEST(OptimizedPretenuringNestedObjectLiterals) {
   i::FLAG_allow_natives_syntax = true;
   i::FLAG_expose_gc = true;
   CcTest::InitializeVM();
   if (!CcTest::i_isolate()->use_crankshaft() || i::FLAG_always_opt) return;
   if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
   v8::HandleScope scope(CcTest::isolate());
-
+  v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   // Grow new space unitl maximum capacity reached.
   while (!CcTest::heap()->new_space()->IsAtMaximumCapacity()) {
     CcTest::heap()->new_space()->Grow();
   }
 
   i::ScopedVector<char> source(1024);
   i::SNPrintF(
       source,
       "var number_elements = %d;"
       "var elements = new Array(number_elements);"
       "function f() {"
       "  for (var i = 0; i < number_elements; i++) {"
       "    elements[i] = [[{}, {}, {}],[{}, {}, {}]];"
       "  }"
       "  return elements[number_elements - 1];"
       "};"
       "f(); gc();"
       "f(); f();"
       "%%OptimizeFunctionOnNextCall(f);"
       "f();",
       AllocationSite::kPretenureMinimumCreated);
 
   v8::Local<v8::Value> res = CompileRun(source.start());
 
-  v8::Local<v8::Value> int_array_1 = v8::Object::Cast(*res)->Get(v8_str("0"));
+  v8::Local<v8::Value> int_array_1 =
+      v8::Object::Cast(*res)->Get(ctx, v8_str("0")).ToLocalChecked();
   Handle<JSObject> int_array_handle_1 =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(int_array_1));
-  v8::Local<v8::Value> int_array_2 = v8::Object::Cast(*res)->Get(v8_str("1"));
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(int_array_1));
+  v8::Local<v8::Value> int_array_2 =
+      v8::Object::Cast(*res)->Get(ctx, v8_str("1")).ToLocalChecked();
   Handle<JSObject> int_array_handle_2 =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(int_array_2));
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(int_array_2));
 
-  Handle<JSObject> o =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
+  Handle<JSObject> o = v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(res));
   CHECK(CcTest::heap()->InOldSpace(*o));
   CHECK(CcTest::heap()->InOldSpace(*int_array_handle_1));
   CHECK(CcTest::heap()->InOldSpace(int_array_handle_1->elements()));
   CHECK(CcTest::heap()->InOldSpace(*int_array_handle_2));
   CHECK(CcTest::heap()->InOldSpace(int_array_handle_2->elements()));
 }
 
 
 TEST(OptimizedPretenuringNestedDoubleLiterals) {
   i::FLAG_allow_natives_syntax = true;
   i::FLAG_expose_gc = true;
   CcTest::InitializeVM();
   if (!CcTest::i_isolate()->use_crankshaft() || i::FLAG_always_opt) return;
   if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
   v8::HandleScope scope(CcTest::isolate());
-
+  v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   // Grow new space unitl maximum capacity reached.
   while (!CcTest::heap()->new_space()->IsAtMaximumCapacity()) {
     CcTest::heap()->new_space()->Grow();
   }
 
   i::ScopedVector<char> source(1024);
   i::SNPrintF(
       source,
       "var number_elements = %d;"
       "var elements = new Array(number_elements);"
       "function f() {"
       "  for (var i = 0; i < number_elements; i++) {"
       "    elements[i] = [[1.1, 1.2, 1.3],[2.1, 2.2, 2.3]];"
       "  }"
       "  return elements[number_elements - 1];"
       "};"
       "f(); gc();"
       "f(); f();"
       "%%OptimizeFunctionOnNextCall(f);"
       "f();",
       AllocationSite::kPretenureMinimumCreated);
 
   v8::Local<v8::Value> res = CompileRun(source.start());
 
   v8::Local<v8::Value> double_array_1 =
-      v8::Object::Cast(*res)->Get(v8_str("0"));
-  Handle<JSObject> double_array_handle_1 =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(double_array_1));
+      v8::Object::Cast(*res)->Get(ctx, v8_str("0")).ToLocalChecked();
+  i::Handle<JSObject> double_array_handle_1 =
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(double_array_1));
   v8::Local<v8::Value> double_array_2 =
-      v8::Object::Cast(*res)->Get(v8_str("1"));
-  Handle<JSObject> double_array_handle_2 =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(double_array_2));
+      v8::Object::Cast(*res)->Get(ctx, v8_str("1")).ToLocalChecked();
+  i::Handle<JSObject> double_array_handle_2 =
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(double_array_2));
 
-  Handle<JSObject> o =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
+  i::Handle<JSObject> o =
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(res));
   CHECK(CcTest::heap()->InOldSpace(*o));
   CHECK(CcTest::heap()->InOldSpace(*double_array_handle_1));
   CHECK(CcTest::heap()->InOldSpace(double_array_handle_1->elements()));
   CHECK(CcTest::heap()->InOldSpace(*double_array_handle_2));
   CHECK(CcTest::heap()->InOldSpace(double_array_handle_2->elements()));
 }
 
 
 // Test regular array literals allocation.
 TEST(OptimizedAllocationArrayLiterals) {
   i::FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   if (!CcTest::i_isolate()->use_crankshaft() || i::FLAG_always_opt) return;
   if (i::FLAG_gc_global || i::FLAG_stress_compaction) return;
   v8::HandleScope scope(CcTest::isolate());
-
+  v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   v8::Local<v8::Value> res = CompileRun(
       "function f() {"
       "  var numbers = new Array(1, 2, 3);"
       "  numbers[0] = 3.14;"
       "  return numbers;"
       "};"
       "f(); f(); f();"
       "%OptimizeFunctionOnNextCall(f);"
       "f();");
-  CHECK_EQ(static_cast<int>(3.14),
-           v8::Object::Cast(*res)->Get(v8_str("0"))->Int32Value());
+  CHECK_EQ(static_cast<int>(3.14), v8::Object::Cast(*res)
+                                       ->Get(ctx, v8_str("0"))
+                                       .ToLocalChecked()
+                                       ->Int32Value(ctx)
+                                       .FromJust());
 
-  Handle<JSObject> o =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
+  i::Handle<JSObject> o =
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(res));
 
   CHECK(CcTest::heap()->InNewSpace(o->elements()));
 }
 
 
 static int CountMapTransitions(Map* map) {
   return TransitionArray::NumberOfTransitions(map->raw_transitions());
 }
 
 
 // Test that map transitions are cleared and maps are collected with
 // incremental marking as well.
 TEST(Regress1465) {
   i::FLAG_stress_compaction = false;
   i::FLAG_allow_natives_syntax = true;
   i::FLAG_trace_incremental_marking = true;
   i::FLAG_retain_maps_for_n_gc = 0;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
+  v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   static const int transitions_count = 256;
 
   CompileRun("function F() {}");
   {
     AlwaysAllocateScope always_allocate(CcTest::i_isolate());
     for (int i = 0; i < transitions_count; i++) {
       EmbeddedVector<char, 64> buffer;
       SNPrintF(buffer, "var o = new F; o.prop%d = %d;", i, i);
       CompileRun(buffer.start());
     }
     CompileRun("var root = new F;");
   }
 
-  Handle<JSObject> root =
-      v8::Utils::OpenHandle(
-          *v8::Handle<v8::Object>::Cast(
-              CcTest::global()->Get(v8_str("root"))));
+  i::Handle<JSObject> root = v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(
+      CcTest::global()->Get(ctx, v8_str("root")).ToLocalChecked()));
 
   // Count number of live transitions before marking.
   int transitions_before = CountMapTransitions(root->map());
   CompileRun("%DebugPrint(root);");
   CHECK_EQ(transitions_count, transitions_before);
 
   SimulateIncrementalMarking(CcTest::heap());
   CcTest::heap()->CollectAllGarbage();
 
   // Count number of live transitions after marking.  Note that one transition
   // is left, because 'o' still holds an instance of one transition target.
   int transitions_after = CountMapTransitions(root->map());
   CompileRun("%DebugPrint(root);");
   CHECK_EQ(1, transitions_after);
 }
 
 
 #ifdef DEBUG
 static void AddTransitions(int transitions_count) {
   AlwaysAllocateScope always_allocate(CcTest::i_isolate());
   for (int i = 0; i < transitions_count; i++) {
     EmbeddedVector<char, 64> buffer;
     SNPrintF(buffer, "var o = new F; o.prop%d = %d;", i, i);
     CompileRun(buffer.start());
   }
 }
 
 
-static Handle<JSObject> GetByName(const char* name) {
-  return v8::Utils::OpenHandle(
-      *v8::Handle<v8::Object>::Cast(
-          CcTest::global()->Get(v8_str(name))));
+static i::Handle<JSObject> GetByName(const char* name) {
+  return v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(
+      CcTest::global()
+          ->Get(CcTest::isolate()->GetCurrentContext(), v8_str(name))
+          .ToLocalChecked()));
 }
 
 
 static void AddPropertyTo(
     int gc_count, Handle<JSObject> object, const char* property_name) {
   Isolate* isolate = CcTest::i_isolate();
   Factory* factory = isolate->factory();
   Handle<String> prop_name = factory->InternalizeUtf8String(property_name);
   Handle<Smi> twenty_three(Smi::FromInt(23), isolate);
   i::FLAG_gc_interval = gc_count;
@@ skipping 139 matching lines @@
              "}"
              "f(new Object);"
              "f(root);");
 
   // This bug only triggers with aggressive IC clearing.
   CcTest::heap()->AgeInlineCaches();
 
   // Explicitly request GC to perform final marking step and sweeping.
   CcTest::heap()->CollectAllGarbage();
 
-  Handle<JSObject> root =
-      v8::Utils::OpenHandle(
-          *v8::Handle<v8::Object>::Cast(
-              CcTest::global()->Get(v8_str("root"))));
+  Handle<JSObject> root = v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(
+      CcTest::global()
+          ->Get(CcTest::isolate()->GetCurrentContext(), v8_str("root"))
+          .ToLocalChecked()));
 
   // The root object should be in a sane state.
   CHECK(root->IsJSObject());
   CHECK(root->map()->IsMap());
 }
 
 
 TEST(Regress2143b) {
   i::FLAG_incremental_marking = true;
   i::FLAG_allow_natives_syntax = true;
@@ skipping 19 matching lines @@
              "%OptimizeFunctionOnNextCall(f);"
              "f(root);"
              "%DeoptimizeFunction(f);");
 
   // This bug only triggers with aggressive IC clearing.
   CcTest::heap()->AgeInlineCaches();
 
   // Explicitly request GC to perform final marking step and sweeping.
   CcTest::heap()->CollectAllGarbage();
 
-  Handle<JSObject> root =
-      v8::Utils::OpenHandle(
-          *v8::Handle<v8::Object>::Cast(
-              CcTest::global()->Get(v8_str("root"))));
+  Handle<JSObject> root = v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(
+      CcTest::global()
+          ->Get(CcTest::isolate()->GetCurrentContext(), v8_str("root"))
+          .ToLocalChecked()));
 
   // The root object should be in a sane state.
   CHECK(root->IsJSObject());
   CHECK(root->map()->IsMap());
 }
 
 
 TEST(ReleaseOverReservedPages) {
   if (FLAG_never_compact) return;
   i::FLAG_trace_gc = true;
@@ skipping 66 matching lines @@
   const char* source = "gc();";
   CompileRun(source);
   CHECK_GT(forced_gc_counter, 0);
 }
 
 
 #ifdef OBJECT_PRINT
 TEST(PrintSharedFunctionInfo) {
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
+  v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   const char* source = "f = function() { return 987654321; }\n"
                        "g = function() { return 123456789; }\n";
   CompileRun(source);
-  Handle<JSFunction> g = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("g")))));
+  i::Handle<JSFunction> g = i::Handle<JSFunction>::cast(
+      v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+          CcTest::global()->Get(ctx, v8_str("g")).ToLocalChecked())));
 
   OFStream os(stdout);
   g->shared()->Print(os);
   os << std::endl;
 }
 #endif  // OBJECT_PRINT
 
 
 TEST(IncrementalMarkingPreservesMonomorphicCallIC) {
   if (i::FLAG_always_opt) return;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::Value> fun1, fun2;
-
+  v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   {
     LocalContext env;
     CompileRun("function fun() {};");
-    fun1 = env->Global()->Get(v8_str("fun"));
+    fun1 = env->Global()->Get(env.local(), v8_str("fun")).ToLocalChecked();
   }
 
   {
     LocalContext env;
     CompileRun("function fun() {};");
-    fun2 = env->Global()->Get(v8_str("fun"));
+    fun2 = env->Global()->Get(env.local(), v8_str("fun")).ToLocalChecked();
   }
 
   // Prepare function f that contains type feedback for closures
   // originating from two different native contexts.
-  CcTest::global()->Set(v8_str("fun1"), fun1);
-  CcTest::global()->Set(v8_str("fun2"), fun2);
+  CHECK(CcTest::global()->Set(ctx, v8_str("fun1"), fun1).FromJust());
+  CHECK(CcTest::global()->Set(ctx, v8_str("fun2"), fun2).FromJust());
   CompileRun("function f(a, b) { a(); b(); } f(fun1, fun2);");
 
-  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+  Handle<JSFunction> f = Handle<JSFunction>::cast(
+      v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+          CcTest::global()->Get(ctx, v8_str("f")).ToLocalChecked())));
 
   Handle<TypeFeedbackVector> feedback_vector(f->shared()->feedback_vector());
   FeedbackVectorHelper feedback_helper(feedback_vector);
 
   int expected_slots = 2;
   CHECK_EQ(expected_slots, feedback_helper.slot_count());
   int slot1 = 0;
   int slot2 = 1;
   CHECK(feedback_vector->Get(feedback_helper.slot(slot1))->IsWeakCell());
   CHECK(feedback_vector->Get(feedback_helper.slot(slot2))->IsWeakCell());
@@ skipping 51 matching lines @@
 
 TEST(ICInBuiltInIsClearedAppropriately) {
   if (i::FLAG_always_opt) return;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
 
   Handle<JSFunction> apply;
   {
     LocalContext env;
     v8::Local<v8::Value> res = CompileRun("Function.apply");
-    Handle<JSObject> maybe_apply =
-        v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(res));
-    apply = Handle<JSFunction>::cast(maybe_apply);
-    Handle<TypeFeedbackVector> vector(apply->shared()->feedback_vector());
+    i::Handle<JSObject> maybe_apply =
+        v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(res));
+    apply = i::Handle<JSFunction>::cast(maybe_apply);
+    i::Handle<TypeFeedbackVector> vector(apply->shared()->feedback_vector());
     FeedbackVectorHelper feedback_helper(vector);
     CHECK_EQ(1, feedback_helper.slot_count());
     CheckVectorIC(apply, 0, UNINITIALIZED);
     CompileRun(
         "function b(a1, a2, a3) { return a1 + a2 + a3; }"
         "function fun(bar) { bar.apply({}, [1, 2, 3]); };"
         "fun(b); fun(b)");
     CheckVectorIC(apply, 0, MONOMORPHIC);
   }
 
   // Fire context dispose notification.
   CcTest::isolate()->ContextDisposedNotification();
   SimulateIncrementalMarking(CcTest::heap());
   CcTest::heap()->CollectAllGarbage();
 
   // The IC in apply has been cleared, ready to learn again.
   CheckVectorIC(apply, 0, PREMONOMORPHIC);
 }
 
 
 TEST(IncrementalMarkingPreservesMonomorphicConstructor) {
   if (i::FLAG_always_opt) return;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
-
+  v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   // Prepare function f that contains a monomorphic IC for object
   // originating from the same native context.
   CompileRun(
       "function fun() { this.x = 1; };"
       "function f(o) { return new o(); } f(fun); f(fun);");
-  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
-
+  Handle<JSFunction> f = Handle<JSFunction>::cast(
+      v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+          CcTest::global()->Get(ctx, v8_str("f")).ToLocalChecked())));
 
   Handle<TypeFeedbackVector> vector(f->shared()->feedback_vector());
   CHECK(vector->Get(FeedbackVectorSlot(0))->IsWeakCell());
 
   SimulateIncrementalMarking(CcTest::heap());
   CcTest::heap()->CollectAllGarbage();
 
   CHECK(vector->Get(FeedbackVectorSlot(0))->IsWeakCell());
 }
 
 
 TEST(IncrementalMarkingClearsMonomorphicConstructor) {
   if (i::FLAG_always_opt) return;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::Value> fun1;
+  v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
 
   {
     LocalContext env;
     CompileRun("function fun() { this.x = 1; };");
-    fun1 = env->Global()->Get(v8_str("fun"));
+    fun1 = env->Global()->Get(env.local(), v8_str("fun")).ToLocalChecked();
   }
 
   // Prepare function f that contains a monomorphic constructor for object
   // originating from a different native context.
-  CcTest::global()->Set(v8_str("fun1"), fun1);
+  CHECK(CcTest::global()->Set(ctx, v8_str("fun1"), fun1).FromJust());
   CompileRun(
       "function fun() { this.x = 1; };"
       "function f(o) { return new o(); } f(fun1); f(fun1);");
-  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+  Handle<JSFunction> f = Handle<JSFunction>::cast(
+      v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+          CcTest::global()->Get(ctx, v8_str("f")).ToLocalChecked())));
 
 
   Handle<TypeFeedbackVector> vector(f->shared()->feedback_vector());
   CHECK(vector->Get(FeedbackVectorSlot(0))->IsWeakCell());
 
   // Fire context dispose notification.
   CcTest::isolate()->ContextDisposedNotification();
   SimulateIncrementalMarking(CcTest::heap());
   CcTest::heap()->CollectAllGarbage();
 
   CHECK_EQ(*TypeFeedbackVector::UninitializedSentinel(isolate),
            vector->Get(FeedbackVectorSlot(0)));
 }
 
 
 TEST(IncrementalMarkingPreservesMonomorphicIC) {
   if (i::FLAG_always_opt) return;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
-
+  v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
   // Prepare function f that contains a monomorphic IC for object
   // originating from the same native context.
   CompileRun("function fun() { this.x = 1; }; var obj = new fun();"
              "function f(o) { return o.x; } f(obj); f(obj);");
-  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+  Handle<JSFunction> f = Handle<JSFunction>::cast(
+      v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+          CcTest::global()->Get(ctx, v8_str("f")).ToLocalChecked())));
 
   CheckVectorIC(f, 0, MONOMORPHIC);
 
   SimulateIncrementalMarking(CcTest::heap());
   CcTest::heap()->CollectAllGarbage();
 
   CheckVectorIC(f, 0, MONOMORPHIC);
 }
 
 
 TEST(IncrementalMarkingClearsMonomorphicIC) {
   if (i::FLAG_always_opt) return;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::Value> obj1;
+  v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
 
   {
     LocalContext env;
     CompileRun("function fun() { this.x = 1; }; var obj = new fun();");
-    obj1 = env->Global()->Get(v8_str("obj"));
+    obj1 = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
   }
 
   // Prepare function f that contains a monomorphic IC for object
   // originating from a different native context.
-  CcTest::global()->Set(v8_str("obj1"), obj1);
+  CHECK(CcTest::global()->Set(ctx, v8_str("obj1"), obj1).FromJust());
   CompileRun("function f(o) { return o.x; } f(obj1); f(obj1);");
-  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+  Handle<JSFunction> f = Handle<JSFunction>::cast(
+      v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+          CcTest::global()->Get(ctx, v8_str("f")).ToLocalChecked())));
 
   CheckVectorIC(f, 0, MONOMORPHIC);
 
   // Fire context dispose notification.
   CcTest::isolate()->ContextDisposedNotification();
   SimulateIncrementalMarking(CcTest::heap());
   CcTest::heap()->CollectAllGarbage();
 
   CheckVectorICCleared(f, 0);
 }
 
 
 TEST(IncrementalMarkingPreservesPolymorphicIC) {
   if (i::FLAG_always_opt) return;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::Value> obj1, obj2;
+  v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
 
   {
     LocalContext env;
     CompileRun("function fun() { this.x = 1; }; var obj = new fun();");
-    obj1 = env->Global()->Get(v8_str("obj"));
+    obj1 = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
   }
 
   {
     LocalContext env;
     CompileRun("function fun() { this.x = 2; }; var obj = new fun();");
-    obj2 = env->Global()->Get(v8_str("obj"));
+    obj2 = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
   }
 
   // Prepare function f that contains a polymorphic IC for objects
   // originating from two different native contexts.
-  CcTest::global()->Set(v8_str("obj1"), obj1);
-  CcTest::global()->Set(v8_str("obj2"), obj2);
+  CHECK(CcTest::global()->Set(ctx, v8_str("obj1"), obj1).FromJust());
+  CHECK(CcTest::global()->Set(ctx, v8_str("obj2"), obj2).FromJust());
   CompileRun("function f(o) { return o.x; } f(obj1); f(obj1); f(obj2);");
-  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+  Handle<JSFunction> f = Handle<JSFunction>::cast(
+      v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+          CcTest::global()->Get(ctx, v8_str("f")).ToLocalChecked())));
 
   CheckVectorIC(f, 0, POLYMORPHIC);
 
   // Fire context dispose notification.
   SimulateIncrementalMarking(CcTest::heap());
   CcTest::heap()->CollectAllGarbage();
 
   CheckVectorIC(f, 0, POLYMORPHIC);
 }
 
 
 TEST(IncrementalMarkingClearsPolymorphicIC) {
   if (i::FLAG_always_opt) return;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
   v8::Local<v8::Value> obj1, obj2;
+  v8::Local<v8::Context> ctx = CcTest::isolate()->GetCurrentContext();
 
   {
     LocalContext env;
     CompileRun("function fun() { this.x = 1; }; var obj = new fun();");
-    obj1 = env->Global()->Get(v8_str("obj"));
+    obj1 = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
   }
 
   {
     LocalContext env;
     CompileRun("function fun() { this.x = 2; }; var obj = new fun();");
-    obj2 = env->Global()->Get(v8_str("obj"));
+    obj2 = env->Global()->Get(env.local(), v8_str("obj")).ToLocalChecked();
   }
 
   // Prepare function f that contains a polymorphic IC for objects
   // originating from two different native contexts.
-  CcTest::global()->Set(v8_str("obj1"), obj1);
-  CcTest::global()->Set(v8_str("obj2"), obj2);
+  CHECK(CcTest::global()->Set(ctx, v8_str("obj1"), obj1).FromJust());
+  CHECK(CcTest::global()->Set(ctx, v8_str("obj2"), obj2).FromJust());
   CompileRun("function f(o) { return o.x; } f(obj1); f(obj1); f(obj2);");
-  Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+  Handle<JSFunction> f = Handle<JSFunction>::cast(
+      v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+          CcTest::global()->Get(ctx, v8_str("f")).ToLocalChecked())));
 
   CheckVectorIC(f, 0, POLYMORPHIC);
 
   // Fire context dispose notification.
   CcTest::isolate()->ContextDisposedNotification();
   SimulateIncrementalMarking(CcTest::heap());
   CcTest::heap()->CollectAllGarbage();
 
   CheckVectorICCleared(f, 0);
 }
@@ skipping 25 matching lines @@
                                const char* accessor) {
   // Test that the data retained by the Error.stack accessor is released
   // after the first time the accessor is fired.  We use external string
   // to check whether the data is being released since the external string
   // resource's callback is fired when the external string is GC'ed.
   i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
   v8::HandleScope scope(isolate);
   SourceResource* resource = new SourceResource(i::StrDup(source));
   {
     v8::HandleScope scope(isolate);
-    v8::Handle<v8::String> source_string =
-        v8::String::NewExternal(isolate, resource);
+    v8::Local<v8::Context> ctx = isolate->GetCurrentContext();
+    v8::Local<v8::String> source_string =
+        v8::String::NewExternalOneByte(isolate, resource).ToLocalChecked();
     i_isolate->heap()->CollectAllAvailableGarbage();
-    v8::Script::Compile(source_string)->Run();
+    v8::Script::Compile(ctx, source_string)
+        .ToLocalChecked()
+        ->Run(ctx)
+        .ToLocalChecked();
     CHECK(!resource->IsDisposed());
   }
   // i_isolate->heap()->CollectAllAvailableGarbage();
   CHECK(!resource->IsDisposed());
 
   CompileRun(accessor);
   i_isolate->heap()->CollectAllAvailableGarbage();
 
   // External source has been released.
   CHECK(resource->IsDisposed());
@@ skipping 57 matching lines @@
     ReleaseStackTraceDataTest(isolate, source4, getter);
   }
   isolate->Dispose();
 }
 
 
 TEST(Regress159140) {
   i::FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
+  LocalContext env;
   Heap* heap = isolate->heap();
   HandleScope scope(isolate);
 
   // Perform one initial GC to enable code flushing.
   heap->CollectAllGarbage();
 
   // Prepare several closures that are all eligible for code flushing
   // because all reachable ones are not optimized. Make sure that the
   // optimized code object is directly reachable through a handle so
   // that it is marked black during incremental marking.
   Handle<Code> code;
   {
     HandleScope inner_scope(isolate);
     CompileRun("function h(x) {}"
                "function mkClosure() {"
                "  return function(x) { return x + 1; };"
                "}"
                "var f = mkClosure();"
                "var g = mkClosure();"
                "f(1); f(2);"
                "g(1); g(2);"
                "h(1); h(2);"
                "%OptimizeFunctionOnNextCall(f); f(3);"
                "%OptimizeFunctionOnNextCall(h); h(3);");
 
-    Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+    Handle<JSFunction> f = Handle<JSFunction>::cast(
+        v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+            CcTest::global()->Get(env.local(), v8_str("f")).ToLocalChecked())));
     CHECK(f->is_compiled());
     CompileRun("f = null;");
 
-    Handle<JSFunction> g = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("g")))));
+    Handle<JSFunction> g = Handle<JSFunction>::cast(
+        v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+            CcTest::global()->Get(env.local(), v8_str("g")).ToLocalChecked())));
     CHECK(g->is_compiled());
     const int kAgingThreshold = 6;
     for (int i = 0; i < kAgingThreshold; i++) {
       g->code()->MakeOlder(static_cast<MarkingParity>(i % 2));
     }
 
     code = inner_scope.CloseAndEscape(Handle<Code>(f->code()));
   }
 
   // Simulate incremental marking so that the functions are enqueued as
@@ skipping 16 matching lines @@
   HandleScope scope(isolate);
 
   // Perform one initial GC to enable code flushing.
   heap->CollectAllGarbage();
 
   // Prepare an optimized closure that the optimized code map will get
   // populated. Then age the unoptimized code to trigger code flushing
   // but make sure the optimized code is unreachable.
   {
     HandleScope inner_scope(isolate);
+    LocalContext env;
     CompileRun("function mkClosure() {"
                "  return function(x) { return x + 1; };"
                "}"
                "var f = mkClosure();"
                "f(1); f(2);"
                "%OptimizeFunctionOnNextCall(f); f(3);");
 
-    Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+    Handle<JSFunction> f = Handle<JSFunction>::cast(
+        v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+            CcTest::global()->Get(env.local(), v8_str("f")).ToLocalChecked())));
     CHECK(f->is_compiled());
     const int kAgingThreshold = 6;
     for (int i = 0; i < kAgingThreshold; i++) {
       f->shared()->code()->MakeOlder(static_cast<MarkingParity>(i % 2));
     }
 
     CompileRun("f = null;");
   }
 
   // Simulate incremental marking so that unoptimized code is flushed
@@ skipping 17 matching lines @@
   HandleScope scope(isolate);
 
   // Perform one initial GC to enable code flushing.
   heap->CollectAllGarbage();
 
   // Prepare a shared function info eligible for code flushing for which
   // the unoptimized code will be replaced during optimization.
   Handle<SharedFunctionInfo> shared1;
   {
     HandleScope inner_scope(isolate);
+    LocalContext env;
     CompileRun("function f() { return 'foobar'; }"
                "function g(x) { if (x) f(); }"
                "f();"
                "g(false);"
                "g(false);");
 
-    Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+    Handle<JSFunction> f = Handle<JSFunction>::cast(
+        v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+            CcTest::global()->Get(env.local(), v8_str("f")).ToLocalChecked())));
     CHECK(f->is_compiled());
     const int kAgingThreshold = 6;
     for (int i = 0; i < kAgingThreshold; i++) {
       f->shared()->code()->MakeOlder(static_cast<MarkingParity>(i % 2));
     }
 
     shared1 = inner_scope.CloseAndEscape(handle(f->shared(), isolate));
   }
 
   // Prepare a shared function info eligible for code flushing that will
   // represent the dangling tail of the candidate list.
   Handle<SharedFunctionInfo> shared2;
   {
     HandleScope inner_scope(isolate);
+    LocalContext env;
     CompileRun("function flushMe() { return 0; }"
                "flushMe(1);");
 
-    Handle<JSFunction> f = Handle<JSFunction>::cast(
-        v8::Utils::OpenHandle(*v8::Handle<v8::Function>::Cast(
-            CcTest::global()->Get(v8_str("flushMe")))));
+    Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
+        *v8::Local<v8::Function>::Cast(CcTest::global()
+                                           ->Get(env.local(), v8_str("flushMe"))
+                                           .ToLocalChecked())));
     CHECK(f->is_compiled());
     const int kAgingThreshold = 6;
     for (int i = 0; i < kAgingThreshold; i++) {
       f->shared()->code()->MakeOlder(static_cast<MarkingParity>(i % 2));
     }
 
     shared2 = inner_scope.CloseAndEscape(handle(f->shared(), isolate));
   }
 
   // Simulate incremental marking and collect code flushing candidates.
@@ skipping 11 matching lines @@
   heap->CollectAllGarbage();
   CHECK(shared1->code()->gc_metadata() == NULL);
 }
 
 
 TEST(Regress169928) {
   i::FLAG_allow_natives_syntax = true;
   i::FLAG_crankshaft = false;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
+  LocalContext env;
   Factory* factory = isolate->factory();
   v8::HandleScope scope(CcTest::isolate());
 
   // Some flags turn Scavenge collections into Mark-sweep collections
   // and hence are incompatible with this test case.
   if (FLAG_gc_global || FLAG_stress_compaction) return;
 
   // Prepare the environment
   CompileRun("function fastliteralcase(literal, value) {"
              "    literal[0] = value;"
              "    return literal;"
              "}"
              "function get_standard_literal() {"
              "    var literal = [1, 2, 3];"
              "    return literal;"
              "}"
              "obj = fastliteralcase(get_standard_literal(), 1);"
              "obj = fastliteralcase(get_standard_literal(), 1.5);"
              "obj = fastliteralcase(get_standard_literal(), 2);");
 
   // prepare the heap
   v8::Local<v8::String> mote_code_string =
       v8_str("fastliteralcase(mote, 2.5);");
 
   v8::Local<v8::String> array_name = v8_str("mote");
-  CcTest::global()->Set(array_name, v8::Int32::New(CcTest::isolate(), 0));
+  CHECK(CcTest::global()
+            ->Set(env.local(), array_name, v8::Int32::New(CcTest::isolate(), 0))
+            .FromJust());
 
   // First make sure we flip spaces
   CcTest::heap()->CollectGarbage(NEW_SPACE);
 
   // Allocate the object.
   Handle<FixedArray> array_data = factory->NewFixedArray(2, NOT_TENURED);
   array_data->set(0, Smi::FromInt(1));
   array_data->set(1, Smi::FromInt(2));
 
   AllocateAllButNBytes(CcTest::heap()->new_space(),
@@ skipping 11 matching lines @@
   HeapObject* obj = NULL;
   AllocationResult allocation =
       CcTest::heap()->new_space()->AllocateRawUnaligned(
           AllocationMemento::kSize + kPointerSize);
   CHECK(allocation.To(&obj));
   Address addr_obj = obj->address();
   CcTest::heap()->CreateFillerObjectAt(
       addr_obj, AllocationMemento::kSize + kPointerSize);
 
   // Give the array a name, making sure not to allocate strings.
-  v8::Handle<v8::Object> array_obj = v8::Utils::ToLocal(array);
-  CcTest::global()->Set(array_name, array_obj);
+  v8::Local<v8::Object> array_obj = v8::Utils::ToLocal(array);
+  CHECK(CcTest::global()->Set(env.local(), array_name, array_obj).FromJust());
 
   // This should crash with a protection violation if we are running a build
   // with the bug.
   AlwaysAllocateScope aa_scope(isolate);
-  v8::Script::Compile(mote_code_string)->Run();
+  v8::Script::Compile(env.local(), mote_code_string)
+      .ToLocalChecked()
+      ->Run(env.local())
+      .ToLocalChecked();
 }
 
 
 #ifdef DEBUG
 TEST(Regress513507) {
   i::FLAG_flush_optimized_code_cache = false;
   i::FLAG_allow_natives_syntax = true;
   i::FLAG_gc_global = true;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
+  LocalContext env;
   Heap* heap = isolate->heap();
   HandleScope scope(isolate);
 
   // Prepare function whose optimized code map we can use.
   Handle<SharedFunctionInfo> shared;
   {
     HandleScope inner_scope(isolate);
     CompileRun("function f() { return 1 }"
                "f(); %OptimizeFunctionOnNextCall(f); f();");
 
-    Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+    Handle<JSFunction> f = Handle<JSFunction>::cast(
+        v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+            CcTest::global()->Get(env.local(), v8_str("f")).ToLocalChecked())));
     shared = inner_scope.CloseAndEscape(handle(f->shared(), isolate));
     CompileRun("f = null");
   }
 
   // Prepare optimized code that we can use.
   Handle<Code> code;
   {
     HandleScope inner_scope(isolate);
     CompileRun("function g() { return 2 }"
                "g(); %OptimizeFunctionOnNextCall(g); g();");
 
-    Handle<JSFunction> g = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("g")))));
+    Handle<JSFunction> g = Handle<JSFunction>::cast(
+        v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+            CcTest::global()->Get(env.local(), v8_str("g")).ToLocalChecked())));
     code = inner_scope.CloseAndEscape(handle(g->code(), isolate));
     if (!code->is_optimized_code()) return;
   }
 
   Handle<TypeFeedbackVector> vector = handle(shared->feedback_vector());
   Handle<LiteralsArray> lit =
       LiteralsArray::New(isolate, vector, shared->num_literals(), TENURED);
   Handle<Context> context(isolate->context());
 
   // Add the new code several times to the optimized code map and also set an
   // allocation timeout so that expanding the code map will trigger a GC.
   heap->set_allocation_timeout(5);
   FLAG_gc_interval = 1000;
   for (int i = 0; i < 10; ++i) {
     BailoutId id = BailoutId(i);
     SharedFunctionInfo::AddToOptimizedCodeMap(shared, context, code, lit, id);
   }
 }
 #endif  // DEBUG
 
 
 TEST(Regress514122) {
   i::FLAG_flush_optimized_code_cache = false;
   i::FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
+  LocalContext env;
   Heap* heap = isolate->heap();
   HandleScope scope(isolate);
 
   // Perfrom one initial GC to enable code flushing.
   CcTest::heap()->CollectAllGarbage();
 
   // Prepare function whose optimized code map we can use.
   Handle<SharedFunctionInfo> shared;
   {
     HandleScope inner_scope(isolate);
     CompileRun("function f() { return 1 }"
                "f(); %OptimizeFunctionOnNextCall(f); f();");
 
-    Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+    Handle<JSFunction> f = Handle<JSFunction>::cast(
+        v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+            CcTest::global()->Get(env.local(), v8_str("f")).ToLocalChecked())));
     shared = inner_scope.CloseAndEscape(handle(f->shared(), isolate));
     CompileRun("f = null");
   }
 
   // Prepare optimized code that we can use.
   Handle<Code> code;
   {
     HandleScope inner_scope(isolate);
     CompileRun("function g() { return 2 }"
                "g(); %OptimizeFunctionOnNextCall(g); g();");
 
-    Handle<JSFunction> g = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("g")))));
+    Handle<JSFunction> g = Handle<JSFunction>::cast(
+        v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+            CcTest::global()->Get(env.local(), v8_str("g")).ToLocalChecked())));
     code = inner_scope.CloseAndEscape(handle(g->code(), isolate));
     if (!code->is_optimized_code()) return;
   }
 
   Handle<TypeFeedbackVector> vector = handle(shared->feedback_vector());
   Handle<LiteralsArray> lit =
       LiteralsArray::New(isolate, vector, shared->num_literals(), TENURED);
   Handle<Context> context(isolate->context());
 
   // Add the code several times to the optimized code map.
@@ skipping 53 matching lines @@
   HandleScope scope(isolate);
 
   // Perfrom one initial GC to enable code flushing.
   CcTest::heap()->CollectAllGarbage();
 
   // Prepare an optimized closure with containing an inlined function. Then age
   // the inlined unoptimized code to trigger code flushing but make sure the
   // outer optimized code is kept in the optimized code map.
   Handle<SharedFunctionInfo> shared;
   {
+    LocalContext context;
     HandleScope inner_scope(isolate);
     CompileRun(
         "function g(x) { return x + 1 }"
         "function mkClosure() {"
         "  return function(x) { return g(x); };"
         "}"
         "var f = mkClosure();"
         "f(1); f(2);"
         "%OptimizeFunctionOnNextCall(f); f(3);");
 
     Handle<JSFunction> g = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("g")))));
+        *v8::Local<v8::Function>::Cast(CcTest::global()
+                                           ->Get(context.local(), v8_str("g"))
+                                           .ToLocalChecked())));
     CHECK(g->shared()->is_compiled());
     const int kAgingThreshold = 6;
     for (int i = 0; i < kAgingThreshold; i++) {
       g->shared()->code()->MakeOlder(static_cast<MarkingParity>(i % 2));
     }
 
     Handle<JSFunction> f = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("f")))));
+        *v8::Local<v8::Function>::Cast(CcTest::global()
+                                           ->Get(context.local(), v8_str("f"))
+                                           .ToLocalChecked())));
     CHECK(f->is_compiled());
     shared = inner_scope.CloseAndEscape(handle(f->shared(), isolate));
     CompileRun("f = null");
   }
 
   // Lookup the optimized code and keep it alive.
   CodeAndLiterals result = shared->SearchOptimizedCodeMap(
       isolate->context()->native_context(), BailoutId::None());
   Handle<Code> optimized_code(result.code, isolate);
 
@@ skipping 167 matching lines @@
 
     CompileRun("%OptimizeFunctionOnNextCall(bar); bar();");
 
     DependentCode::GroupStartIndexes starts(site->dependent_code());
     CHECK_GE(starts.number_of_entries(), 1);
     int index = starts.at(DependentCode::kAllocationSiteTransitionChangedGroup);
     CHECK(site->dependent_code()->object_at(index)->IsWeakCell());
     Code* function_bar = Code::cast(
         WeakCell::cast(site->dependent_code()->object_at(index))->value());
     Handle<JSFunction> bar_handle = Handle<JSFunction>::cast(
-        v8::Utils::OpenHandle(*v8::Handle<v8::Function>::Cast(
-            CcTest::global()->Get(v8_str("bar")))));
+        v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+            CcTest::global()
+                ->Get(context.local(), v8_str("bar"))
+                .ToLocalChecked())));
     CHECK_EQ(bar_handle->code(), function_bar);
   }
 
   // Now make sure that a gc should get rid of the function, even though we
   // still have the allocation site alive.
   for (int i = 0; i < 4; i++) {
     heap->CollectAllGarbage();
   }
 
   // The site still exists because of our global handle, but the code is no
@@ skipping 26 matching lines @@
                "  };"
                "  var foo = function(x) { with (x) { return 1 + x; } };"
                "  bar(foo);"
                "  bar(foo);"
                "  bar(foo);"
                "  %OptimizeFunctionOnNextCall(bar);"
                "  bar(foo);"
                "  return bar;})();");
 
     Handle<JSFunction> bar = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("bar")))));
+        *v8::Local<v8::Function>::Cast(CcTest::global()
+                                           ->Get(context.local(), v8_str("bar"))
+                                           .ToLocalChecked())));
     code = scope.CloseAndEscape(Handle<Code>(bar->code()));
   }
 
   // Now make sure that a gc should get rid of the function
   for (int i = 0; i < 4; i++) {
     heap->CollectAllGarbage();
   }
 
   DCHECK(code->marked_for_deoptimization());
 }
@@ skipping 18 matching lines @@
                "  return foo(1);"
                "};"
                "function foo(x) { with (x) { return 1 + x; } };"
                "bar();"
                "bar();"
                "bar();"
                "%OptimizeFunctionOnNextCall(bar);"
                "bar();");
 
     Handle<JSFunction> bar = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-        *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str("bar")))));
+        *v8::Local<v8::Function>::Cast(CcTest::global()
+                                           ->Get(context.local(), v8_str("bar"))
+                                           .ToLocalChecked())));
     code = scope.CloseAndEscape(Handle<Code>(bar->code()));
   }
 
   // Now make sure that a gc should get rid of the function
   for (int i = 0; i < 4; i++) {
     heap->CollectAllGarbage();
   }
 
   DCHECK(code->marked_for_deoptimization());
 }
@@ skipping 43 matching lines @@
   }
   int elements = 0;
   if (heap->weak_object_to_code_table()->IsHashTable()) {
     WeakHashTable* t = WeakHashTable::cast(heap->weak_object_to_code_table());
     elements = t->NumberOfElements();
   }
   CHECK_EQ(0, elements);
 }
 
 
-static Handle<JSFunction> OptimizeDummyFunction(const char* name) {
+static Handle<JSFunction> OptimizeDummyFunction(v8::Isolate* isolate,
+                                                const char* name) {
   EmbeddedVector<char, 256> source;
   SNPrintF(source,
           "function %s() { return 0; }"
           "%s(); %s();"
           "%%OptimizeFunctionOnNextCall(%s);"
           "%s();", name, name, name, name, name);
   CompileRun(source.start());
-  Handle<JSFunction> fun = Handle<JSFunction>::cast(v8::Utils::OpenHandle(
-      *v8::Handle<v8::Function>::Cast(CcTest::global()->Get(v8_str(name)))));
+  i::Handle<JSFunction> fun = Handle<JSFunction>::cast(
+      v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+          CcTest::global()
+              ->Get(isolate->GetCurrentContext(), v8_str(name))
+              .ToLocalChecked())));
   return fun;
 }
 
 
 static int GetCodeChainLength(Code* code) {
   int result = 0;
   while (code->next_code_link()->IsCode()) {
     result++;
     code = Code::cast(code->next_code_link());
   }
   return result;
 }
 
 
 TEST(NextCodeLinkIsWeak) {
   i::FLAG_always_opt = false;
   i::FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   v8::internal::Heap* heap = CcTest::heap();
 
   if (!isolate->use_crankshaft()) return;
   HandleScope outer_scope(heap->isolate());
   Handle<Code> code;
   heap->CollectAllAvailableGarbage();
   int code_chain_length_before, code_chain_length_after;
   {
     HandleScope scope(heap->isolate());
-    Handle<JSFunction> mortal = OptimizeDummyFunction("mortal");
-    Handle<JSFunction> immortal = OptimizeDummyFunction("immortal");
+    Handle<JSFunction> mortal =
+        OptimizeDummyFunction(CcTest::isolate(), "mortal");
+    Handle<JSFunction> immortal =
+        OptimizeDummyFunction(CcTest::isolate(), "immortal");
     CHECK_EQ(immortal->code()->next_code_link(), mortal->code());
     code_chain_length_before = GetCodeChainLength(immortal->code());
     // Keep the immortal code and let the mortal code die.
     code = scope.CloseAndEscape(Handle<Code>(immortal->code()));
     CompileRun("mortal = null; immortal = null;");
   }
   heap->CollectAllAvailableGarbage();
   // Now mortal code should be dead.
   code_chain_length_after = GetCodeChainLength(*code);
   CHECK_EQ(code_chain_length_before - 1, code_chain_length_after);
@@ skipping 50 matching lines @@
   weak_ic_cleared = true;
   data.GetParameter()->Reset();
 }
 
 
 TEST(WeakFunctionInConstructor) {
   if (i::FLAG_always_opt) return;
   i::FLAG_stress_compaction = false;
   CcTest::InitializeVM();
   v8::Isolate* isolate = CcTest::isolate();
+  LocalContext env;
   v8::HandleScope scope(isolate);
   CompileRun(
       "function createObj(obj) {"
       "  return new obj();"
       "}");
-  Handle<JSFunction> createObj = Handle<JSFunction>::cast(
-      v8::Utils::OpenHandle(*v8::Handle<v8::Function>::Cast(
-          CcTest::global()->Get(v8_str("createObj")))));
+  i::Handle<JSFunction> createObj = Handle<JSFunction>::cast(
+      v8::Utils::OpenHandle(*v8::Local<v8::Function>::Cast(
+          CcTest::global()
+              ->Get(env.local(), v8_str("createObj"))
+              .ToLocalChecked())));
 
   v8::Persistent<v8::Object> garbage;
   {
     v8::HandleScope scope(isolate);
     const char* source =
         " (function() {"
         "   function hat() { this.x = 5; }"
         "   createObj(hat);"
         "   createObj(hat);"
         "   return hat;"
         " })();";
-    garbage.Reset(isolate, CompileRun(source)->ToObject(isolate));
+    garbage.Reset(isolate, CompileRun(env.local(), source)
+                               .ToLocalChecked()
+                               ->ToObject(env.local())
+                               .ToLocalChecked());
   }
   weak_ic_cleared = false;
   garbage.SetWeak(&garbage, &ClearWeakIC, v8::WeakCallbackType::kParameter);
   Heap* heap = CcTest::i_isolate()->heap();
   heap->CollectAllGarbage();
   CHECK(weak_ic_cleared);
 
   // We've determined the constructor in createObj has had it's weak cell
   // cleared. Now, verify that one additional call with a new function
   // allows monomorphicity.
@@ skipping 14 matching lines @@
   slot_value = feedback_vector->Get(FeedbackVectorSlot(0));
   CHECK(slot_value->IsWeakCell() && !WeakCell::cast(slot_value)->cleared());
 }
 
 
 // Checks that the value returned by execution of the source is weak.
 void CheckWeakness(const char* source) {
   i::FLAG_stress_compaction = false;
   CcTest::InitializeVM();
   v8::Isolate* isolate = CcTest::isolate();
+  LocalContext env;
   v8::HandleScope scope(isolate);
   v8::Persistent<v8::Object> garbage;
   {
     v8::HandleScope scope(isolate);
-    garbage.Reset(isolate, CompileRun(source)->ToObject(isolate));
+    garbage.Reset(isolate, CompileRun(env.local(), source)
+                               .ToLocalChecked()
+                               ->ToObject(env.local())
+                               .ToLocalChecked());
   }
   weak_ic_cleared = false;
   garbage.SetWeak(&garbage, &ClearWeakIC, v8::WeakCallbackType::kParameter);
   Heap* heap = CcTest::i_isolate()->heap();
   heap->CollectAllGarbage();
   CHECK(weak_ic_cleared);
 }
 
 
 // Each of the following "weak IC" tests creates an IC that embeds a map with
@@ skipping 322 matching lines @@
 TEST(AddInstructionChangesNewSpacePromotion) {
   i::FLAG_allow_natives_syntax = true;
   i::FLAG_expose_gc = true;
   i::FLAG_stress_compaction = true;
   i::FLAG_gc_interval = 1000;
   CcTest::InitializeVM();
   if (!i::FLAG_allocation_site_pretenuring) return;
   v8::HandleScope scope(CcTest::isolate());
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
-
+  LocalContext env;
   CompileRun(
       "function add(a, b) {"
       "  return a + b;"
       "}"
       "add(1, 2);"
       "add(\"a\", \"b\");"
       "var oldSpaceObject;"
       "gc();"
       "function crash(x) {"
       "  var object = {a: null, b: null};"
       "  var result = add(1.5, x | 0);"
       "  object.a = result;"
       "  oldSpaceObject = object;"
       "  return object;"
       "}"
       "crash(1);"
       "crash(1);"
       "%OptimizeFunctionOnNextCall(crash);"
       "crash(1);");
 
-  v8::Handle<v8::Object> global = CcTest::global();
-    v8::Handle<v8::Function> g =
-        v8::Handle<v8::Function>::Cast(global->Get(v8_str("crash")));
-  v8::Handle<v8::Value> args1[] = { v8_num(1) };
+  v8::Local<v8::Object> global = CcTest::global();
+  v8::Local<v8::Function> g = v8::Local<v8::Function>::Cast(
+      global->Get(env.local(), v8_str("crash")).ToLocalChecked());
+  v8::Local<v8::Value> args1[] = {v8_num(1)};
   heap->DisableInlineAllocation();
   heap->set_allocation_timeout(1);
-  g->Call(global, 1, args1);
+  g->Call(env.local(), global, 1, args1).ToLocalChecked();
   heap->CollectAllGarbage();
 }
 
 
 void OnFatalErrorExpectOOM(const char* location, const char* message) {
   // Exit with 0 if the location matches our expectation.
   exit(strcmp(location, "CALL_AND_RETRY_LAST"));
 }
 
 
 TEST(CEntryStubOOM) {
   i::FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   v8::HandleScope scope(CcTest::isolate());
-  v8::V8::SetFatalErrorHandler(OnFatalErrorExpectOOM);
+  CcTest::isolate()->SetFatalErrorHandler(OnFatalErrorExpectOOM);
 
-  v8::Handle<v8::Value> result = CompileRun(
+  v8::Local<v8::Value> result = CompileRun(
       "%SetFlags('--gc-interval=1');"
       "var a = [];"
       "a.__proto__ = [];"
       "a.unshift(1)");
 
   CHECK(result->IsNumber());
 }
 
 #endif  // DEBUG
 
@@ skipping 35 matching lines @@
   }
   isolate->Exit();
   isolate->Dispose();
 }
 
 
 TEST(Regress357137) {
   CcTest::InitializeVM();
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope hscope(isolate);
-  v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate);
-  global->Set(v8::String::NewFromUtf8(isolate, "interrupt"),
-              v8::FunctionTemplate::New(isolate, RequestInterrupt));
+  v8::Local<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate);
+  global->Set(
+      v8::String::NewFromUtf8(isolate, "interrupt", v8::NewStringType::kNormal)
+          .ToLocalChecked(),
+      v8::FunctionTemplate::New(isolate, RequestInterrupt));
   v8::Local<v8::Context> context = v8::Context::New(isolate, NULL, global);
   DCHECK(!context.IsEmpty());
   v8::Context::Scope cscope(context);
 
   v8::Local<v8::Value> result = CompileRun(
       "var locals = '';"
       "for (var i = 0; i < 512; i++) locals += 'var v' + i + '= 42;';"
       "eval('function f() {' + locals + 'return function() { return v0; }; }');"
       "interrupt();"  // This triggers a fake stack overflow in f.
       "f()()");
-  CHECK_EQ(42.0, result->ToNumber(isolate)->Value());
+  CHECK_EQ(42.0, result->ToNumber(context).ToLocalChecked()->Value());
 }
 
 
 TEST(Regress507979) {
   const int kFixedArrayLen = 10;
   CcTest::InitializeVM();
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
   HandleScope handle_scope(isolate);
 
@@ skipping 25 matching lines @@
   v8::Local<v8::Value> result = CompileRun(
       "var array = new Array(400);"
       "var tmp = new Array(1000);"
       "array[0] = 10;"
       "gc();"
       "gc();"
       "array.shift();"
       "array;");
 
   Handle<JSObject> o =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(result));
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(result));
   CHECK(heap->InOldSpace(o->elements()));
   CHECK(heap->InOldSpace(*o));
   Page* page = Page::FromAddress(o->elements()->address());
   CHECK(page->parallel_sweeping_state().Value() <=
             MemoryChunk::kSweepingFinalize ||
         Marking::IsBlack(Marking::MarkBitFrom(o->elements())));
 }
 
 
 UNINITIALIZED_TEST(PromotionQueue) {
@@ skipping 128 matching lines @@
       "  var key = {'k' : i + 0.1};"
       "  weak_map.set(key, 1);"
       "  future_keys.push({'x' : i + 0.2});"
       "}"
       "weak_map");
   if (marking->IsStopped()) {
     CcTest::heap()->StartIncrementalMarking();
   }
   // Incrementally mark the backing store.
   Handle<JSObject> obj =
-      v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(result));
+      v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(result));
   Handle<JSWeakCollection> weak_map(reinterpret_cast<JSWeakCollection*>(*obj));
   while (!Marking::IsBlack(
              Marking::MarkBitFrom(HeapObject::cast(weak_map->table()))) &&
          !marking->IsStopped()) {
     marking->Step(MB, IncrementalMarking::NO_GC_VIA_STACK_GUARD);
   }
   // Stash the backing store in a handle.
   Handle<Object> save(weak_map->table(), isolate);
   // The following line will update the backing store.
   CompileRun(
@@ skipping 39 matching lines @@
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
   Factory* factory = isolate->factory();
   HandleScope scope(isolate);
   CompileRun("function cls() { this.x = 10; }");
   Handle<WeakCell> weak_prototype;
   {
     HandleScope inner_scope(isolate);
     v8::Local<v8::Value> result = CompileRun("cls.prototype");
     Handle<JSObject> proto =
-        v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(result));
+        v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(result));
     weak_prototype = inner_scope.CloseAndEscape(factory->NewWeakCell(proto));
   }
   CHECK(!weak_prototype->cleared());
   CompileRun(
       "var a = { };"
       "a.x = new cls();"
       "cls.prototype = null;");
   for (int i = 0; i < 4; i++) {
     heap->CollectAllGarbage();
   }
   // The map of a.x keeps prototype alive
   CHECK(!weak_prototype->cleared());
   // Change the map of a.x and make the previous map garbage collectable.
   CompileRun("a.x.__proto__ = {};");
   for (int i = 0; i < 4; i++) {
     heap->CollectAllGarbage();
   }
   CHECK(weak_prototype->cleared());
 }
 
 
 Handle<WeakCell> AddRetainedMap(Isolate* isolate, Heap* heap) {
     HandleScope inner_scope(isolate);
     Handle<Map> map = Map::Create(isolate, 1);
     v8::Local<v8::Value> result =
         CompileRun("(function () { return {x : 10}; })();");
     Handle<JSObject> proto =
-        v8::Utils::OpenHandle(*v8::Handle<v8::Object>::Cast(result));
+        v8::Utils::OpenHandle(*v8::Local<v8::Object>::Cast(result));
     Map::SetPrototype(map, proto);
     heap->AddRetainedMap(map);
     return inner_scope.CloseAndEscape(Map::WeakCellForMap(map));
 }
 
 
 void CheckMapRetainingFor(int n) {
   FLAG_retain_maps_for_n_gc = n;
   Isolate* isolate = CcTest::i_isolate();
   Heap* heap = isolate->heap();
@@ skipping 167 matching lines @@
   data.GetParameter()->Reset();
 }
 
 
 TEST(BootstrappingExports) {
   // Expose utils object and delete it to observe that it is indeed
   // being garbage-collected.
   FLAG_expose_natives_as = "utils";
   CcTest::InitializeVM();
   v8::Isolate* isolate = CcTest::isolate();
+  LocalContext env;
 
   if (Snapshot::HaveASnapshotToStartFrom(CcTest::i_isolate())) return;
 
   utils_has_been_collected = false;
 
   v8::Persistent<v8::Object> utils;
 
   {
     v8::HandleScope scope(isolate);
     v8::Local<v8::String> name = v8_str("utils");
-    utils.Reset(isolate, CcTest::global()->Get(name)->ToObject(isolate));
-    CcTest::global()->Delete(name);
+    utils.Reset(isolate, CcTest::global()
+                             ->Get(env.local(), name)
+                             .ToLocalChecked()
+                             ->ToObject(env.local())
+                             .ToLocalChecked());
+    CHECK(CcTest::global()->Delete(env.local(), name).FromJust());
   }
 
   utils.SetWeak(&utils, UtilsHasBeenCollected,
                 v8::WeakCallbackType::kParameter);
 
   CcTest::heap()->CollectAllAvailableGarbage("fire weak callbacks");
 
   CHECK(utils_has_been_collected);
 }
 
 
 TEST(Regress1878) {
   FLAG_allow_natives_syntax = true;
   CcTest::InitializeVM();
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
   v8::Local<v8::Function> constructor = v8::Utils::CallableToLocal(
       CcTest::i_isolate()->internal_array_function());
-  CcTest::global()->Set(v8_str("InternalArray"), constructor);
+  LocalContext env;
+  CHECK(CcTest::global()
+            ->Set(env.local(), v8_str("InternalArray"), constructor)
+            .FromJust());
 
   v8::TryCatch try_catch(isolate);
 
   CompileRun(
       "var a = Array();"
       "for (var i = 0; i < 1000; i++) {"
       "  var ai = new InternalArray(10000);"
       "  if (%HaveSameMap(ai, a)) throw Error();"
       "  if (!%HasFastObjectElements(ai)) throw Error();"
       "}"
@@ skipping 133 matching lines @@
   Object* message =
       *reinterpret_cast<Object**>(isolate->pending_message_obj_address());
   CHECK(message->IsTheHole());
 }
 
 
 TEST(MessageObjectLeak) {
   CcTest::InitializeVM();
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate);
-  global->Set(v8::String::NewFromUtf8(isolate, "check"),
-              v8::FunctionTemplate::New(isolate, CheckLeak));
+  v8::Local<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate);
+  global->Set(
+      v8::String::NewFromUtf8(isolate, "check", v8::NewStringType::kNormal)
+          .ToLocalChecked(),
+      v8::FunctionTemplate::New(isolate, CheckLeak));
   v8::Local<v8::Context> context = v8::Context::New(isolate, NULL, global);
   v8::Context::Scope cscope(context);
 
   const char* test =
       "try {"
       "  throw 'message 1';"
       "} catch (e) {"
       "}"
       "check();"
       "L: try {"
@@ skipping 30 matching lines @@
   fun->ReplaceCode(*isolate->builtins()->CompileLazy());
   fun->shared()->ReplaceCode(*isolate->builtins()->CompileLazy());
   isolate->heap()->CollectAllAvailableGarbage("remove code and gc");
 }
 
 
 TEST(CanonicalSharedFunctionInfo) {
   CcTest::InitializeVM();
   v8::Isolate* isolate = CcTest::isolate();
   v8::HandleScope scope(isolate);
-  v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate);
+  v8::Local<v8::ObjectTemplate> global = v8::ObjectTemplate::New(isolate);
   global->Set(isolate, "check", v8::FunctionTemplate::New(
                                     isolate, CheckEqualSharedFunctionInfos));
   global->Set(isolate, "remove",
               v8::FunctionTemplate::New(isolate, RemoveCodeAndGC));
   v8::Local<v8::Context> context = v8::Context::New(isolate, NULL, global);
   v8::Context::Scope cscope(context);
   CompileRun(
       "function f() { return function g() {}; }"
       "var g1 = f();"
       "remove(f);"
@@ skipping 190 matching lines @@
   isolate->IncrementJsCallsFromApiCounter();
   isolate->IncrementJsCallsFromApiCounter();
   isolate->IncrementJsCallsFromApiCounter();
   calls_per_ms = memory_reducer->SampleAndGetJsCallsPerMs(4);
   CheckDoubleEquals(2, calls_per_ms);
 }
 
 
 }  // namespace internal
 }  // namespace v8