Continuing removing deprecated function from cctest

test/cctest/test-serialize.cc

 // Copyright 2007-2010 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(mythria): Remove this define after this flag is turned on globally
+#define V8_IMMINENT_DEPRECATION_WARNINGS
+
 #include <signal.h>
 
 #include <sys/stat.h>
 
 #include "src/v8.h"
 
 #include "src/bootstrapper.h"
 #include "src/compilation-cache.h"
 #include "src/debug/debug.h"
 #include "src/heap/spaces.h"
@@ skipping 199 matching lines @@
   v8::Isolate* isolate = Deserialize();
   {
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
 
 
     v8::Local<v8::Context> env = v8::Context::New(isolate);
     env->Enter();
 
     const char* c_source = "\"1234\".length";
-    v8::Local<v8::String> source = v8::String::NewFromUtf8(isolate, c_source);
-    v8::Local<v8::Script> script = v8::Script::Compile(source);
-    CHECK_EQ(4, script->Run()->Int32Value());
+    v8::Local<v8::Script> script = v8_compile(c_source);
+    v8::Maybe<int32_t> result = script->Run(isolate->GetCurrentContext())
+                                    .ToLocalChecked()
+                                    ->Int32Value(isolate->GetCurrentContext());
+    CHECK_EQ(4, result.FromJust());
   }
   isolate->Dispose();
 }
 
 
 UNINITIALIZED_DEPENDENT_TEST(DeserializeFromSecondSerializationAndRunScript2,
                              SerializeTwice) {
   DisableTurbofan();
   if (DefaultSnapshotAvailable()) return;
   v8::Isolate* isolate = Deserialize();
   {
     v8::Isolate::Scope isolate_scope(isolate);
     v8::HandleScope handle_scope(isolate);
 
     v8::Local<v8::Context> env = v8::Context::New(isolate);
     env->Enter();
 
     const char* c_source = "\"1234\".length";
-    v8::Local<v8::String> source = v8::String::NewFromUtf8(isolate, c_source);
-    v8::Local<v8::Script> script = v8::Script::Compile(source);
-    CHECK_EQ(4, script->Run()->Int32Value());
+    v8::Local<v8::Script> script = v8_compile(c_source);
+    v8::Maybe<int32_t> result = script->Run(isolate->GetCurrentContext())
+                                    .ToLocalChecked()
+                                    ->Int32Value(isolate->GetCurrentContext());
+    CHECK_EQ(4, result.FromJust());
   }
   isolate->Dispose();
 }
 
 
 UNINITIALIZED_TEST(PartialSerialization) {
   DisableTurbofan();
   if (DefaultSnapshotAvailable()) return;
   v8::Isolate* v8_isolate = TestIsolate::NewInitialized(true);
   Isolate* isolate = reinterpret_cast<Isolate*>(v8_isolate);
@@ skipping 17 matching lines @@
       for (int i = 0; i < Natives::GetBuiltinsCount(); i++) {
         isolate->bootstrapper()->SourceLookup<Natives>(i);
       }
     }
     heap->CollectAllGarbage();
     heap->CollectAllGarbage();
 
     Object* raw_foo;
     {
       v8::HandleScope handle_scope(v8_isolate);
-      v8::Local<v8::String> foo = v8::String::NewFromUtf8(v8_isolate, "foo");
+      v8::Local<v8::String> foo = v8_str("foo");
       DCHECK(!foo.IsEmpty());
       raw_foo = *(v8::Utils::OpenHandle(*foo));
     }
 
     int file_name_length = StrLength(FLAG_testing_serialization_file) + 10;
     Vector<char> startup_name = Vector<char>::New(file_name_length + 1);
     SNPrintF(startup_name, "%s.startup", FLAG_testing_serialization_file);
 
     {
       v8::HandleScope handle_scope(v8_isolate);
@@ skipping 218 matching lines @@
           "})();"
           "var o = this;"
           "var r = Math.random() + Math.cos(0);"
           "var f = (function(a, b) { return a + b; }).bind(1, 2, 3);"
           "var s = parseInt('12345');");
 
       Vector<const uint8_t> source = ConstructSource(
           STATIC_CHAR_VECTOR("function g() { return [,"),
           STATIC_CHAR_VECTOR("1,"),
           STATIC_CHAR_VECTOR("];} a = g(); b = g(); b.push(1);"), 100000);
-      v8::Handle<v8::String> source_str = v8::String::NewFromOneByte(
-          v8_isolate, source.start(), v8::String::kNormalString,
+      v8::MaybeLocal<v8::String> source_str = v8::String::NewFromOneByte(
+          v8_isolate, source.start(), v8::NewStringType::kNormal,
           source.length());
-      CompileRun(source_str);
+      CompileRun(source_str.ToLocalChecked());
       source.Dispose();
     }
     // Make sure all builtin scripts are cached.
     {
       HandleScope scope(isolate);
       for (int i = 0; i < Natives::GetBuiltinsCount(); i++) {
         isolate->bootstrapper()->SourceLookup<Natives>(i);
       }
     }
     // If we don't do this then we end up with a stray root pointing at the
@@ skipping 73 matching lines @@
         CHECK_EQ(3, outdated_contexts->length());
       }
       CHECK(root->IsContext());
       Handle<Context> context = Handle<Context>::cast(root);
       CHECK(context->global_proxy() == *global_proxy);
       Handle<String> o = isolate->factory()->NewStringFromAsciiChecked("o");
       Handle<JSObject> global_object(context->global_object(), isolate);
       Handle<Object> property = JSReceiver::GetDataProperty(global_object, o);
       CHECK(property.is_identical_to(global_proxy));
 
-      v8::Handle<v8::Context> v8_context = v8::Utils::ToLocal(context);
+      v8::Local<v8::Context> v8_context = v8::Utils::ToLocal(context);
       v8::Context::Scope context_scope(v8_context);
-      double r = CompileRun("r")->ToNumber(v8_isolate)->Value();
+      double r = CompileRun("r")
+                     ->ToNumber(v8_isolate->GetCurrentContext())
+                     .ToLocalChecked()
+                     ->Value();
       CHECK(r >= 1 && r <= 2);
-      int f = CompileRun("f()")->ToNumber(v8_isolate)->Int32Value();
+      int f = CompileRun("f()")
+                  ->ToNumber(v8_isolate->GetCurrentContext())
+                  .ToLocalChecked()
+                  ->Int32Value(v8_isolate->GetCurrentContext())
+                  .FromJust();
       CHECK_EQ(5, f);
-      f = CompileRun("e('f()')")->ToNumber(v8_isolate)->Int32Value();
+      f = CompileRun("e('f()')")
+              ->ToNumber(v8_isolate->GetCurrentContext())
+              .ToLocalChecked()
+              ->Int32Value(v8_isolate->GetCurrentContext())
+              .FromJust();
       CHECK_EQ(5, f);
-      v8::Handle<v8::String> s = CompileRun("s")->ToString(v8_isolate);
-      CHECK(s->Equals(v8_str("12345")));
-      int a = CompileRun("a.length")->ToNumber(v8_isolate)->Int32Value();
+      v8::Local<v8::String> s = CompileRun("s")
+                                    ->ToString(v8_isolate->GetCurrentContext())
+                                    .ToLocalChecked();
+      CHECK(s->Equals(v8_isolate->GetCurrentContext(), v8_str("12345"))
+                .FromJust());
+      int a = CompileRun("a.length")
+                  ->ToNumber(v8_isolate->GetCurrentContext())
+                  .ToLocalChecked()
+                  ->Int32Value(v8_isolate->GetCurrentContext())
+                  .FromJust();
       CHECK_EQ(100001, a);
-      int b = CompileRun("b.length")->ToNumber(v8_isolate)->Int32Value();
+      int b = CompileRun("b.length")
+                  ->ToNumber(v8_isolate->GetCurrentContext())
+                  .ToLocalChecked()
+                  ->Int32Value(v8_isolate->GetCurrentContext())
+                  .FromJust();
       CHECK_EQ(100002, b);
     }
     DeleteArray(snapshot);
   }
   v8_isolate->Dispose();
 }
 
 
 TEST(PerIsolateSnapshotBlobs) {
   DisableTurbofan();
@@ skipping 10 matching lines @@
   params1.snapshot_blob = &data1;
   params1.array_buffer_allocator = CcTest::array_buffer_allocator();
 
   v8::Isolate* isolate1 = v8::Isolate::New(params1);
   {
     v8::Isolate::Scope i_scope(isolate1);
     v8::HandleScope h_scope(isolate1);
     v8::Local<v8::Context> context = v8::Context::New(isolate1);
     delete[] data1.data;  // We can dispose of the snapshot blob now.
     v8::Context::Scope c_scope(context);
-    CHECK_EQ(42, CompileRun("f()")->ToInt32(isolate1)->Int32Value());
+    v8::Maybe<int32_t> result =
+        CompileRun("f()")->Int32Value(isolate1->GetCurrentContext());
+    CHECK_EQ(42, result.FromJust());
     CHECK(CompileRun("this.g")->IsUndefined());
   }
   isolate1->Dispose();
 
   v8::Isolate::CreateParams params2;
   params2.snapshot_blob = &data2;
   params2.array_buffer_allocator = CcTest::array_buffer_allocator();
   v8::Isolate* isolate2 = v8::Isolate::New(params2);
   {
     v8::Isolate::Scope i_scope(isolate2);
     v8::HandleScope h_scope(isolate2);
     v8::Local<v8::Context> context = v8::Context::New(isolate2);
     delete[] data2.data;  // We can dispose of the snapshot blob now.
     v8::Context::Scope c_scope(context);
-    CHECK_EQ(86, CompileRun("f()")->ToInt32(isolate2)->Int32Value());
-    CHECK_EQ(43, CompileRun("g()")->ToInt32(isolate2)->Int32Value());
+    v8::Maybe<int32_t> result =
+        CompileRun("f()")->Int32Value(isolate2->GetCurrentContext());
+    CHECK_EQ(86, result.FromJust());
+    result = CompileRun("g()")->Int32Value(isolate2->GetCurrentContext());
+    CHECK_EQ(43, result.FromJust());
   }
   isolate2->Dispose();
 }
 
 
 static void SerializationFunctionTemplate(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   args.GetReturnValue().Set(args[0]);
 }
 
@@ skipping 30 matching lines @@
     v8::Local<v8::ObjectTemplate> property = v8::ObjectTemplate::New(isolate);
     v8::Local<v8::FunctionTemplate> function =
         v8::FunctionTemplate::New(isolate, SerializationFunctionTemplate);
     property->Set(isolate, "bar", function);
     global->Set(isolate, "foo", property);
 
     v8::Local<v8::Context> context = v8::Context::New(isolate, NULL, global);
     delete[] data.data;  // We can dispose of the snapshot blob now.
     v8::Context::Scope c_scope(context);
     v8::Local<v8::Value> result = CompileRun(source2);
-    CHECK(v8_str("42")->Equals(result));
+    v8::Maybe<bool> compare = v8_str("42")->Equals(
+        v8::Isolate::GetCurrent()->GetCurrentContext(), result);
+    CHECK(compare.FromJust());
   }
   isolate->Dispose();
 }
 
 
 TEST(PerIsolateSnapshotBlobsWithLocker) {
   DisableTurbofan();
   v8::Isolate::CreateParams create_params;
   create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
   v8::Isolate* isolate0 = v8::Isolate::New(create_params);
   {
     v8::Locker locker(isolate0);
     v8::Isolate::Scope i_scope(isolate0);
     v8::HandleScope h_scope(isolate0);
     v8::Local<v8::Context> context = v8::Context::New(isolate0);
     v8::Context::Scope c_scope(context);
-    CHECK_EQ(1, CompileRun("Math.cos(0)")->ToInt32(isolate0)->Int32Value());
+    v8::Maybe<int32_t> result =
+        CompileRun("Math.cos(0)")->Int32Value(isolate0->GetCurrentContext());
+    CHECK_EQ(1, result.FromJust());
   }
   isolate0->Dispose();
 
   const char* source1 = "function f() { return 42; }";
 
   v8::StartupData data1 = v8::V8::CreateSnapshotDataBlob(source1);
 
   v8::Isolate::CreateParams params1;
   params1.snapshot_blob = &data1;
   params1.array_buffer_allocator = CcTest::array_buffer_allocator();
   v8::Isolate* isolate1 = v8::Isolate::New(params1);
   {
     v8::Locker locker(isolate1);
     v8::Isolate::Scope i_scope(isolate1);
     v8::HandleScope h_scope(isolate1);
     v8::Local<v8::Context> context = v8::Context::New(isolate1);
     delete[] data1.data;  // We can dispose of the snapshot blob now.
     v8::Context::Scope c_scope(context);
-    CHECK_EQ(42, CompileRun("f()")->ToInt32(isolate1)->Int32Value());
+    v8::Maybe<int32_t> result = CompileRun("f()")->Int32Value(context);
+    CHECK_EQ(42, result.FromJust());
   }
   isolate1->Dispose();
 }
 
 
 TEST(SnapshotBlobsStackOverflow) {
   DisableTurbofan();
   const char* source =
       "var a = [0];"
       "var b = a;"
@@ skipping 17 matching lines @@
     v8::Local<v8::Context> context = v8::Context::New(isolate);
     delete[] data.data;  // We can dispose of the snapshot blob now.
     v8::Context::Scope c_scope(context);
     const char* test =
         "var sum = 0;"
         "while (a) {"
         "  sum += a[0];"
         "  a = a[1];"
         "}"
         "sum";
-    CHECK_EQ(9999 * 5000, CompileRun(test)->ToInt32(isolate)->Int32Value());
+    v8::Maybe<int32_t> result =
+        CompileRun(test)->Int32Value(isolate->GetCurrentContext());
+    CHECK_EQ(9999 * 5000, result.FromJust());
   }
   isolate->Dispose();
 }
 
 
 TEST(TestThatAlwaysSucceeds) {
 }
 
 
 TEST(TestThatAlwaysFails) {
@@ skipping 324 matching lines @@
                          v8::ScriptCompiler::kConsumeCodeCache);
   }
   CHECK_NE(*orig, *copy);
 
   Handle<JSFunction> copy_fun =
       isolate->factory()->NewFunctionFromSharedFunctionInfo(
           copy, isolate->native_context());
 
   USE(Execution::Call(isolate, copy_fun, global, 0, NULL));
 
-  CHECK_EQ(600000 + 700000, CompileRun("(a + b).length")->Int32Value());
-  CHECK_EQ(500000 + 600000, CompileRun("(b + c).length")->Int32Value());
+  v8::Maybe<int32_t> result =
+      CompileRun("(a + b).length")
+          ->Int32Value(v8::Isolate::GetCurrent()->GetCurrentContext());
+  CHECK_EQ(600000 + 700000, result.FromJust());
+  result = CompileRun("(b + c).length")
+               ->Int32Value(v8::Isolate::GetCurrent()->GetCurrentContext());
+  CHECK_EQ(500000 + 600000, result.FromJust());
   Heap* heap = isolate->heap();
-  CHECK(heap->InSpace(
-      *v8::Utils::OpenHandle(*CompileRun("a")->ToString(CcTest::isolate())),
-      OLD_SPACE));
-  CHECK(heap->InSpace(
-      *v8::Utils::OpenHandle(*CompileRun("b")->ToString(CcTest::isolate())),
-      OLD_SPACE));
-  CHECK(heap->InSpace(
-      *v8::Utils::OpenHandle(*CompileRun("c")->ToString(CcTest::isolate())),
-      OLD_SPACE));
+  v8::Local<v8::String> result_str =
+      CompileRun("a")
+          ->ToString(CcTest::isolate()->GetCurrentContext())
+          .ToLocalChecked();
+  CHECK(heap->InSpace(*v8::Utils::OpenHandle(*result_str), OLD_SPACE));
+  result_str = CompileRun("b")
+                   ->ToString(CcTest::isolate()->GetCurrentContext())
+                   .ToLocalChecked();
+  CHECK(heap->InSpace(*v8::Utils::OpenHandle(*result_str), OLD_SPACE));
+  result_str = CompileRun("c")
+                   ->ToString(CcTest::isolate()->GetCurrentContext())
+                   .ToLocalChecked();
+  CHECK(heap->InSpace(*v8::Utils::OpenHandle(*result_str), OLD_SPACE));
 
   delete cache;
   source_a.Dispose();
   source_b.Dispose();
   source_c.Dispose();
 }
 
 
 class SerializerOneByteResource
     : public v8::String::ExternalOneByteStringResource {
@@ skipping 214 matching lines @@
   v8::Isolate* isolate1 = v8::Isolate::New(create_params);
   {
     v8::Isolate::Scope iscope(isolate1);
     v8::HandleScope scope(isolate1);
     v8::Local<v8::Context> context = v8::Context::New(isolate1);
     v8::Context::Scope context_scope(context);
 
     v8::Local<v8::String> source_str = v8_str(source);
     v8::ScriptOrigin origin(v8_str("test"));
     v8::ScriptCompiler::Source source(source_str, origin);
-    v8::Local<v8::UnboundScript> script = v8::ScriptCompiler::CompileUnbound(
-        isolate1, &source, v8::ScriptCompiler::kProduceCodeCache);
+    v8::Local<v8::UnboundScript> script =
+        v8::ScriptCompiler::CompileUnboundScript(
+            isolate1, &source, v8::ScriptCompiler::kProduceCodeCache)
+            .ToLocalChecked();
     const v8::ScriptCompiler::CachedData* data = source.GetCachedData();
     CHECK(data);
     // Persist cached data.
     uint8_t* buffer = NewArray<uint8_t>(data->length);
     MemCopy(buffer, data->data, data->length);
     cache = new v8::ScriptCompiler::CachedData(
         buffer, data->length, v8::ScriptCompiler::CachedData::BufferOwned);
 
-    v8::Local<v8::Value> result = script->BindToCurrentContext()->Run();
-    CHECK(result->ToString(isolate1)->Equals(v8_str("abcdef")));
+    v8::Local<v8::Value> result = script->BindToCurrentContext()
+                                      ->Run(isolate1->GetCurrentContext())
+                                      .ToLocalChecked();
+    v8::Local<v8::String> result_string =
+        result->ToString(isolate1->GetCurrentContext()).ToLocalChecked();
+    CHECK(result_string->Equals(isolate1->GetCurrentContext(), v8_str("abcdef"))
+              .FromJust());
   }
   isolate1->Dispose();
   return cache;
 }
 
 
 TEST(SerializeToplevelIsolates) {
   FLAG_serialize_toplevel = true;
 
   const char* source = "function f() { return 'abc'; }; f() + 'def'";
@@ skipping 10 matching lines @@
     v8::HandleScope scope(isolate2);
     v8::Local<v8::Context> context = v8::Context::New(isolate2);
     v8::Context::Scope context_scope(context);
 
     v8::Local<v8::String> source_str = v8_str(source);
     v8::ScriptOrigin origin(v8_str("test"));
     v8::ScriptCompiler::Source source(source_str, origin, cache);
     v8::Local<v8::UnboundScript> script;
     {
       DisallowCompilation no_compile(reinterpret_cast<Isolate*>(isolate2));
-      script = v8::ScriptCompiler::CompileUnbound(
-          isolate2, &source, v8::ScriptCompiler::kConsumeCodeCache);
+      script = v8::ScriptCompiler::CompileUnboundScript(
+                   isolate2, &source, v8::ScriptCompiler::kConsumeCodeCache)
+                   .ToLocalChecked();
     }
     CHECK(!cache->rejected);
-    v8::Local<v8::Value> result = script->BindToCurrentContext()->Run();
-    CHECK(result->ToString(isolate2)->Equals(v8_str("abcdef")));
+    v8::Local<v8::Value> result = script->BindToCurrentContext()
+                                      ->Run(isolate2->GetCurrentContext())
+                                      .ToLocalChecked();
+    CHECK(result->ToString(isolate2->GetCurrentContext())
+              .ToLocalChecked()
+              ->Equals(isolate2->GetCurrentContext(), v8_str("abcdef"))
+              .FromJust());
   }
   DCHECK(toplevel_test_code_event_found);
   isolate2->Dispose();
 }
 
 
 TEST(SerializeToplevelFlagChange) {
   FLAG_serialize_toplevel = true;
 
   const char* source = "function f() { return 'abc'; }; f() + 'def'";
   v8::ScriptCompiler::CachedData* cache = ProduceCache(source);
 
   v8::Isolate::CreateParams create_params;
   create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
   v8::Isolate* isolate2 = v8::Isolate::New(create_params);
 
   FLAG_allow_natives_syntax = true;  // Flag change should trigger cache reject.
   FlagList::EnforceFlagImplications();
   {
     v8::Isolate::Scope iscope(isolate2);
     v8::HandleScope scope(isolate2);
     v8::Local<v8::Context> context = v8::Context::New(isolate2);
     v8::Context::Scope context_scope(context);
 
     v8::Local<v8::String> source_str = v8_str(source);
     v8::ScriptOrigin origin(v8_str("test"));
     v8::ScriptCompiler::Source source(source_str, origin, cache);
-    v8::ScriptCompiler::CompileUnbound(isolate2, &source,
-                                       v8::ScriptCompiler::kConsumeCodeCache);
+    v8::ScriptCompiler::CompileUnboundScript(
+        isolate2, &source, v8::ScriptCompiler::kConsumeCodeCache)
+        .ToLocalChecked();
     CHECK(cache->rejected);
   }
   isolate2->Dispose();
 }
 
 
 TEST(SerializeToplevelBitFlip) {
   FLAG_serialize_toplevel = true;
 
   const char* source = "function f() { return 'abc'; }; f() + 'def'";
   v8::ScriptCompiler::CachedData* cache = ProduceCache(source);
 
   // Random bit flip.
   const_cast<uint8_t*>(cache->data)[337] ^= 0x40;
 
   v8::Isolate::CreateParams create_params;
   create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
   v8::Isolate* isolate2 = v8::Isolate::New(create_params);
   {
     v8::Isolate::Scope iscope(isolate2);
     v8::HandleScope scope(isolate2);
     v8::Local<v8::Context> context = v8::Context::New(isolate2);
     v8::Context::Scope context_scope(context);
 
     v8::Local<v8::String> source_str = v8_str(source);
     v8::ScriptOrigin origin(v8_str("test"));
     v8::ScriptCompiler::Source source(source_str, origin, cache);
-    v8::ScriptCompiler::CompileUnbound(isolate2, &source,
-                                       v8::ScriptCompiler::kConsumeCodeCache);
+    v8::ScriptCompiler::CompileUnboundScript(
+        isolate2, &source, v8::ScriptCompiler::kConsumeCodeCache)
+        .ToLocalChecked();
     CHECK(cache->rejected);
   }
   isolate2->Dispose();
 }
 
 
 TEST(SerializeWithHarmonyScoping) {
   FLAG_serialize_toplevel = true;
 
   const char* source1 = "'use strict'; let x = 'X'";
@@ skipping 10 matching lines @@
     v8::HandleScope scope(isolate1);
     v8::Local<v8::Context> context = v8::Context::New(isolate1);
     v8::Context::Scope context_scope(context);
 
     CompileRun(source1);
     CompileRun(source2);
 
     v8::Local<v8::String> source_str = v8_str(source3);
     v8::ScriptOrigin origin(v8_str("test"));
     v8::ScriptCompiler::Source source(source_str, origin);
-    v8::Local<v8::UnboundScript> script = v8::ScriptCompiler::CompileUnbound(
-        isolate1, &source, v8::ScriptCompiler::kProduceCodeCache);
+    v8::Local<v8::UnboundScript> script =
+        v8::ScriptCompiler::CompileUnboundScript(
+            isolate1, &source, v8::ScriptCompiler::kProduceCodeCache)
+            .ToLocalChecked();
     const v8::ScriptCompiler::CachedData* data = source.GetCachedData();
     CHECK(data);
     // Persist cached data.
     uint8_t* buffer = NewArray<uint8_t>(data->length);
     MemCopy(buffer, data->data, data->length);
     cache = new v8::ScriptCompiler::CachedData(
         buffer, data->length, v8::ScriptCompiler::CachedData::BufferOwned);
 
-    v8::Local<v8::Value> result = script->BindToCurrentContext()->Run();
-    CHECK(result->ToString(isolate1)->Equals(v8_str("XY")));
+    v8::Local<v8::Value> result = script->BindToCurrentContext()
+                                      ->Run(isolate1->GetCurrentContext())
+                                      .ToLocalChecked();
+    v8::Local<v8::String> result_str =
+        result->ToString(isolate1->GetCurrentContext()).ToLocalChecked();
+    CHECK(result_str->Equals(isolate1->GetCurrentContext(), v8_str("XY"))
+              .FromJust());
   }
   isolate1->Dispose();
 
   v8::Isolate* isolate2 = v8::Isolate::New(create_params);
   {
     v8::Isolate::Scope iscope(isolate2);
     v8::HandleScope scope(isolate2);
     v8::Local<v8::Context> context = v8::Context::New(isolate2);
     v8::Context::Scope context_scope(context);
 
     // Reverse order of prior running scripts.
     CompileRun(source2);
     CompileRun(source1);
 
     v8::Local<v8::String> source_str = v8_str(source3);
     v8::ScriptOrigin origin(v8_str("test"));
     v8::ScriptCompiler::Source source(source_str, origin, cache);
     v8::Local<v8::UnboundScript> script;
     {
       DisallowCompilation no_compile(reinterpret_cast<Isolate*>(isolate2));
-      script = v8::ScriptCompiler::CompileUnbound(
-          isolate2, &source, v8::ScriptCompiler::kConsumeCodeCache);
+      script = v8::ScriptCompiler::CompileUnboundScript(
+                   isolate2, &source, v8::ScriptCompiler::kConsumeCodeCache)
+                   .ToLocalChecked();
     }
-    v8::Local<v8::Value> result = script->BindToCurrentContext()->Run();
-    CHECK(result->ToString(isolate2)->Equals(v8_str("XY")));
+    v8::Local<v8::Value> result = script->BindToCurrentContext()
+                                      ->Run(isolate2->GetCurrentContext())
+                                      .ToLocalChecked();
+    v8::Local<v8::String> result_str =
+        result->ToString(isolate2->GetCurrentContext()).ToLocalChecked();
+    CHECK(result_str->Equals(isolate2->GetCurrentContext(), v8_str("XY"))
+              .FromJust());
   }
   isolate2->Dispose();
 }
 
 
 TEST(SerializeInternalReference) {
 #if V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_ARM64
   return;
 #endif
   // Disable experimental natives that are loaded after deserialization.
@@ skipping 28 matching lines @@
   v8::Isolate::CreateParams params;
   params.snapshot_blob = &data;
   params.array_buffer_allocator = CcTest::array_buffer_allocator();
   v8::Isolate* isolate = v8::Isolate::New(params);
   {
     v8::Isolate::Scope i_scope(isolate);
     v8::HandleScope h_scope(isolate);
     v8::Local<v8::Context> context = v8::Context::New(isolate);
     delete[] data.data;  // We can dispose of the snapshot blob now.
     v8::Context::Scope c_scope(context);
-    v8::Handle<v8::Function> foo =
-        v8::Handle<v8::Function>::Cast(CompileRun("foo"));
+    v8::Local<v8::Function> foo =
+        v8::Local<v8::Function>::Cast(CompileRun("foo"));
 
     // There are at least 6 internal references.
     int mask = RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE) |
                RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE_ENCODED);
     RelocIterator it(v8::Utils::OpenHandle(*foo)->code(), mask);
     for (int i = 0; i < 6; ++i) {
       CHECK(!it.done());
       it.next();
     }
 
     CHECK(v8::Utils::OpenHandle(*foo)->code()->is_turbofanned());
-    CHECK_EQ(11, CompileRun("foo(0)")->ToInt32(isolate)->Int32Value());
-    CHECK_EQ(11, CompileRun("foo(1)")->ToInt32(isolate)->Int32Value());
-    CHECK_EQ(12, CompileRun("foo(2)")->ToInt32(isolate)->Int32Value());
-    CHECK_EQ(12, CompileRun("foo(3)")->ToInt32(isolate)->Int32Value());
-    CHECK_EQ(23, CompileRun("foo(4)")->ToInt32(isolate)->Int32Value());
-    CHECK_EQ(23, CompileRun("foo(5)")->ToInt32(isolate)->Int32Value());
-    CHECK_EQ(10, CompileRun("foo(6)")->ToInt32(isolate)->Int32Value());
+    CHECK_EQ(11, CompileRun("foo(0)")
+                     ->Int32Value(isolate->GetCurrentContext())
+                     .FromJust());
+    CHECK_EQ(11, CompileRun("foo(1)")
+                     ->Int32Value(isolate->GetCurrentContext())
+                     .FromJust());
+    CHECK_EQ(12, CompileRun("foo(2)")
+                     ->Int32Value(isolate->GetCurrentContext())
+                     .FromJust());
+    CHECK_EQ(12, CompileRun("foo(3)")
+                     ->Int32Value(isolate->GetCurrentContext())
+                     .FromJust());
+    CHECK_EQ(23, CompileRun("foo(4)")
+                     ->Int32Value(isolate->GetCurrentContext())
+                     .FromJust());
+    CHECK_EQ(23, CompileRun("foo(5)")
+                     ->Int32Value(isolate->GetCurrentContext())
+                     .FromJust());
+    CHECK_EQ(10, CompileRun("foo(6)")
+                     ->Int32Value(isolate->GetCurrentContext())
+                     .FromJust());
   }
   isolate->Dispose();
 }
 
 
 TEST(Regress503552) {
   // Test that the code serializer can deal with weak cells that form a linked
   // list during incremental marking.
 
   CcTest::InitializeVM();
@@ skipping 16 matching lines @@
   delete script_data;
 }
 
 
 TEST(SerializationMemoryStats) {
   FLAG_profile_deserialization = true;
   FLAG_always_opt = false;
   v8::StartupData blob = v8::V8::CreateSnapshotDataBlob();
   delete[] blob.data;
 }