convert compile functions to use maybe

src/api.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/api.h"
 
 #include <string.h>  // For memcpy, strlen.
 #ifdef V8_USE_ADDRESS_SANITIZER
 #include <sanitizer/asan_interface.h>
 #endif  // V8_USE_ADDRESS_SANITIZER
@@ skipping 78 matching lines @@
 
 #define EXCEPTION_BAILOUT_CHECK_DO_CALLBACK(isolate, value)                    \
   EXCEPTION_BAILOUT_CHECK_GENERIC(                                             \
       isolate, value, isolate->FireCallCompletedCallback();)
 
 
 #define EXCEPTION_BAILOUT_CHECK(isolate, value)                                \
   EXCEPTION_BAILOUT_CHECK_GENERIC(isolate, value, ;)
 
 
-#define PREPARE_FOR_EXECUTION_GENERIC(context, function_name, bailout_value, \
-                                      HandleScopeClass, do_callback)         \
+#define PREPARE_FOR_EXECUTION_GENERIC(isolate, context, function_name, \
+                                      bailout_value, HandleScopeClass, \
+                                      do_callback)                     \
+  if (IsExecutionTerminatingCheck(isolate)) {                          \
+    return bailout_value;                                              \
+  }                                                                    \
+  HandleScopeClass handle_scope(isolate);                              \
+  CallDepthScope call_depth_scope(isolate, context, do_callback);      \
+  LOG_API(isolate, function_name);                                     \
+  ENTER_V8(isolate);                                                   \
+  bool has_pending_exception = false
+
+
+#define PREPARE_FOR_EXECUTION_WITH_CONTEXT(                                  \
+    context, function_name, bailout_value, HandleScopeClass, do_callback)    \
   auto isolate = context.IsEmpty()                                           \
                      ? i::Isolate::Current()                                 \
                      : reinterpret_cast<i::Isolate*>(context->GetIsolate()); \
-  if (IsExecutionTerminatingCheck(isolate)) {                                \
-    return bailout_value;                                                    \
-  }                                                                          \
-  HandleScopeClass handle_scope(isolate);                                    \
-  CallDepthScope call_depth_scope(isolate, context, do_callback);            \
-  LOG_API(isolate, function_name);                                           \
-  ENTER_V8(isolate);                                                         \
-  bool has_pending_exception = false
+  PREPARE_FOR_EXECUTION_GENERIC(isolate, context, function_name,             \
+                                bailout_value, HandleScopeClass, do_callback);
 
 
-#define PREPARE_FOR_EXECUTION(context, function_name, T)                 \
-  PREPARE_FOR_EXECUTION_GENERIC(context, function_name, MaybeLocal<T>(), \
-                                InternalEscapableScope, false)
+#define PREPARE_FOR_EXECUTION_WITH_ISOLATE(isolate, function_name, T)     \
+  PREPARE_FOR_EXECUTION_GENERIC(isolate, Local<Context>(), function_name, \
+                                MaybeLocal<T>(), InternalEscapableScope,  \
+                                false);
 
 
-#define PREPARE_FOR_EXECUTION_WITH_CALLBACK(context, function_name, T)   \
-  PREPARE_FOR_EXECUTION_GENERIC(context, function_name, MaybeLocal<T>(), \
-                                InternalEscapableScope, true)
+#define PREPARE_FOR_EXECUTION(context, function_name, T)                      \
+  PREPARE_FOR_EXECUTION_WITH_CONTEXT(context, function_name, MaybeLocal<T>(), \
+                                     InternalEscapableScope, false)
 
 
-#define PREPARE_FOR_EXECUTION_PRIMITIVE(context, function_name, T)    \
-  PREPARE_FOR_EXECUTION_GENERIC(context, function_name, Nothing<T>(), \
-                                i::HandleScope, false)
+#define PREPARE_FOR_EXECUTION_WITH_CALLBACK(context, function_name, T)        \
+  PREPARE_FOR_EXECUTION_WITH_CONTEXT(context, function_name, MaybeLocal<T>(), \
+                                     InternalEscapableScope, true)
+
+
+#define PREPARE_FOR_EXECUTION_PRIMITIVE(context, function_name, T)         \
+  PREPARE_FOR_EXECUTION_WITH_CONTEXT(context, function_name, Nothing<T>(), \
+                                     i::HandleScope, false)
 
 
 #define EXCEPTION_BAILOUT_CHECK_SCOPED(isolate, value) \
   do {                                                 \
     if (has_pending_exception) {                       \
       call_depth_scope.Escape();                       \
       return value;                                    \
     }                                                  \
   } while (false)
 
@@ skipping 1438 matching lines @@
 }
 
 
 Local<UnboundScript> Script::GetUnboundScript() {
   i::Handle<i::Object> obj = Utils::OpenHandle(this);
   return ToApiHandle<UnboundScript>(
       i::Handle<i::SharedFunctionInfo>(i::JSFunction::cast(*obj)->shared()));
 }
 
 
-Local<UnboundScript> ScriptCompiler::CompileUnboundInternal(
+MaybeLocal<UnboundScript> ScriptCompiler::CompileUnboundInternal(
     Isolate* v8_isolate, Source* source, CompileOptions options,
     bool is_module) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
-  ON_BAILOUT(isolate, "v8::ScriptCompiler::CompileUnbound()",
-             return Local<UnboundScript>());
+  PREPARE_FOR_EXECUTION_WITH_ISOLATE(
+      isolate, "v8::ScriptCompiler::CompileUnbound()", UnboundScript);
 
   // Support the old API for a transition period:
   // - kProduceToCache -> kProduceParserCache
   // - kNoCompileOptions + cached_data != NULL -> kConsumeParserCache
   if (options == kProduceDataToCache) {
     options = kProduceParserCache;
   } else if (options == kNoCompileOptions && source->cached_data) {
     options = kConsumeParserCache;
   }
 
   // Don't try to produce any kind of cache when the debugger is loaded.
   if (isolate->debug()->is_loaded() &&
       (options == kProduceParserCache || options == kProduceCodeCache)) {
     options = kNoCompileOptions;
   }
 
   i::ScriptData* script_data = NULL;
   if (options == kConsumeParserCache || options == kConsumeCodeCache) {
     DCHECK(source->cached_data);
     // ScriptData takes care of pointer-aligning the data.
     script_data = new i::ScriptData(source->cached_data->data,
                                     source->cached_data->length);
   }
 
   i::Handle<i::String> str = Utils::OpenHandle(*(source->source_string));
-  LOG_API(isolate, "ScriptCompiler::CompileUnbound");
-  ENTER_V8(isolate);
   i::SharedFunctionInfo* raw_result = NULL;
   { i::HandleScope scope(isolate);
     i::HistogramTimerScope total(isolate->counters()->compile_script(), true);
     i::Handle<i::Object> name_obj;
     int line_offset = 0;
     int column_offset = 0;
     bool is_embedder_debug_script = false;
     bool is_shared_cross_origin = false;
     if (!source->resource_name.IsEmpty()) {
       name_obj = Utils::OpenHandle(*(source->resource_name));
     }
     if (!source->resource_line_offset.IsEmpty()) {
       line_offset = static_cast<int>(source->resource_line_offset->Value());
     }
     if (!source->resource_column_offset.IsEmpty()) {
       column_offset =
           static_cast<int>(source->resource_column_offset->Value());
     }
     if (!source->resource_is_shared_cross_origin.IsEmpty()) {
       is_shared_cross_origin =
           source->resource_is_shared_cross_origin->IsTrue();
     }
     if (!source->resource_is_embedder_debug_script.IsEmpty()) {
       is_embedder_debug_script =
           source->resource_is_embedder_debug_script->IsTrue();
     }
-    EXCEPTION_PREAMBLE(isolate);
     i::Handle<i::SharedFunctionInfo> result = i::Compiler::CompileScript(
         str, name_obj, line_offset, column_offset, is_embedder_debug_script,
         is_shared_cross_origin, isolate->native_context(), NULL, &script_data,
         options, i::NOT_NATIVES_CODE, is_module);
     has_pending_exception = result.is_null();
     if (has_pending_exception && script_data != NULL) {
       // This case won't happen during normal operation; we have compiled
       // successfully and produced cached data, and but the second compilation
       // of the same source code fails.
       delete script_data;
       script_data = NULL;
     }
-    EXCEPTION_BAILOUT_CHECK(isolate, Local<UnboundScript>());
+    RETURN_ON_FAILED_EXECUTION(UnboundScript);
     raw_result = *result;
 
     if ((options == kProduceParserCache || options == kProduceCodeCache) &&
         script_data != NULL) {
       // script_data now contains the data that was generated. source will
       // take the ownership.
       source->cached_data = new CachedData(
           script_data->data(), script_data->length(), CachedData::BufferOwned);
       script_data->ReleaseDataOwnership();
     } else if (options == kConsumeParserCache || options == kConsumeCodeCache) {
       source->cached_data->rejected = script_data->rejected();
     }
     delete script_data;
   }
   i::Handle<i::SharedFunctionInfo> result(raw_result, isolate);
-  return ToApiHandle<UnboundScript>(result);
+  RETURN_ESCAPED(ToApiHandle<UnboundScript>(result));
+}
+
+
+MaybeLocal<UnboundScript> ScriptCompiler::CompileUnboundScript(
+    Isolate* v8_isolate, Source* source, CompileOptions options) {
+  return CompileUnboundInternal(v8_isolate, source, options, false);
 }
 
 
 Local<UnboundScript> ScriptCompiler::CompileUnbound(Isolate* v8_isolate,
                                                     Source* source,
                                                     CompileOptions options) {
-  return CompileUnboundInternal(v8_isolate, source, options, false);
+  RETURN_TO_LOCAL_UNCHECKED(
+      CompileUnboundInternal(v8_isolate, source, options, false),
+      UnboundScript);
 }
 
 
+MaybeLocal<Script> ScriptCompiler::Compile(Local<Context> context,
+                                           Source* source,
+                                           CompileOptions options) {
+  auto isolate = context->GetIsolate();
+  auto maybe = CompileUnboundInternal(isolate, source, options, false);
+  Local<UnboundScript> result;
+  if (!maybe.ToLocal(&result)) return MaybeLocal<Script>();
+  v8::Context::Scope scope(context);
+  return result->BindToCurrentContext();
+}
+
+
 Local<Script> ScriptCompiler::Compile(
     Isolate* v8_isolate,
     Source* source,
     CompileOptions options) {
-  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
-  ON_BAILOUT(isolate, "v8::ScriptCompiler::Compile()", return Local<Script>());
-  LOG_API(isolate, "ScriptCompiler::CompileBound()");
-  ENTER_V8(isolate);
-  Local<UnboundScript> generic = CompileUnbound(v8_isolate, source, options);
-  if (generic.IsEmpty()) return Local<Script>();
+  auto context = v8_isolate->GetCurrentContext();
+  RETURN_TO_LOCAL_UNCHECKED(Compile(context, source, options), Script);
+}
+
+
+MaybeLocal<Script> ScriptCompiler::CompileModule(Local<Context> context,
+                                                 Source* source,
+                                                 CompileOptions options) {
+  CHECK(i::FLAG_harmony_modules);
+  auto isolate = context->GetIsolate();
+  auto maybe = CompileUnboundInternal(isolate, source, options, true);
+  Local<UnboundScript> generic;
+  if (!maybe.ToLocal(&generic)) return MaybeLocal<Script>();
+  v8::Context::Scope scope(context);
   return generic->BindToCurrentContext();
 }
 
 
 Local<Script> ScriptCompiler::CompileModule(Isolate* v8_isolate, Source* source,
                                             CompileOptions options) {
-  CHECK(i::FLAG_harmony_modules);
-  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
-  ON_BAILOUT(isolate, "v8::ScriptCompiler::CompileModule()",
-             return Local<Script>());
-  LOG_API(isolate, "ScriptCompiler::CompileModule()");
-  ENTER_V8(isolate);
-  Local<UnboundScript> generic =
-      CompileUnboundInternal(v8_isolate, source, options, true);
-  if (generic.IsEmpty()) return Local<Script>();
-  return generic->BindToCurrentContext();
+  auto context = v8_isolate->GetCurrentContext();
+  RETURN_TO_LOCAL_UNCHECKED(CompileModule(context, source, options), Script);
 }
 
 
 class IsIdentifierHelper {
  public:
   IsIdentifierHelper() : is_identifier_(false), first_char_(true) {}
 
   bool Check(i::String* string) {
     i::ConsString* cons_string = i::String::VisitFlat(this, string, 0);
     if (cons_string == NULL) return is_identifier_;
@@ skipping 22 matching lines @@
   }
 
  private:
   bool is_identifier_;
   bool first_char_;
   i::UnicodeCache unicode_cache_;
   DISALLOW_COPY_AND_ASSIGN(IsIdentifierHelper);
 };
 
 
-Local<Function> ScriptCompiler::CompileFunctionInContext(
-    Isolate* v8_isolate, Source* source, Local<Context> v8_context,
-    size_t arguments_count, Local<String> arguments[],
-    size_t context_extension_count, Local<Object> context_extensions[]) {
-  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
-  ON_BAILOUT(isolate, "v8::ScriptCompiler::CompileFunctionInContext()",
-             return Local<Function>());
-  LOG_API(isolate, "ScriptCompiler::CompileFunctionInContext()");
-  ENTER_V8(isolate);
-
+MaybeLocal<Function> ScriptCompiler::CompileFunctionInContext(
+    Local<Context> v8_context, Source* source, size_t arguments_count,
+    Local<String> arguments[], size_t context_extension_count,
+    Local<Object> context_extensions[]) {
+  PREPARE_FOR_EXECUTION(
+      v8_context, "v8::ScriptCompiler::CompileFunctionInContext()", Function);
   i::Handle<i::String> source_string;
+  auto factory = isolate->factory();
   if (arguments_count) {
-    source_string =
-        Utils::OpenHandle(*v8::String::NewFromUtf8(v8_isolate, "(function("));
+    source_string = factory->NewStringFromStaticChars("(function(");
     for (size_t i = 0; i < arguments_count; ++i) {
       IsIdentifierHelper helper;
       if (!helper.Check(*Utils::OpenHandle(*arguments[i]))) {
         return Local<Function>();
       }
-      i::MaybeHandle<i::String> maybe_source =
-          isolate->factory()->NewConsString(source_string,
-                                            Utils::OpenHandle(*arguments[i]));
-      if (!maybe_source.ToHandle(&source_string)) {
-        return Local<Function>();
-      }
+      has_pending_exception =
+          !factory->NewConsString(source_string,
+                                  Utils::OpenHandle(*arguments[i]))
+               .ToHandle(&source_string);
+      RETURN_ON_FAILED_EXECUTION(Function);
       if (i + 1 == arguments_count) continue;
-      maybe_source = isolate->factory()->NewConsString(
-          source_string,
-          isolate->factory()->LookupSingleCharacterStringFromCode(','));
-      if (!maybe_source.ToHandle(&source_string)) {
-        return Local<Function>();
-      }
+      has_pending_exception =
+          !factory->NewConsString(source_string,
+                                  factory->LookupSingleCharacterStringFromCode(
+                                      ',')).ToHandle(&source_string);
+      RETURN_ON_FAILED_EXECUTION(Function);
     }
-    i::Handle<i::String> brackets =
-        Utils::OpenHandle(*v8::String::NewFromUtf8(v8_isolate, "){"));
-    i::MaybeHandle<i::String> maybe_source =
-        isolate->factory()->NewConsString(source_string, brackets);
-    if (!maybe_source.ToHandle(&source_string)) {
-      return Local<Function>();
-    }
+    auto brackets = factory->NewStringFromStaticChars("){");
+    has_pending_exception = !factory->NewConsString(source_string, brackets)
+                                 .ToHandle(&source_string);
+    RETURN_ON_FAILED_EXECUTION(Function);
   } else {
-    source_string =
-        Utils::OpenHandle(*v8::String::NewFromUtf8(v8_isolate, "(function(){"));
+    source_string = factory->NewStringFromStaticChars("(function(){");
   }
 
   int scope_position = source_string->length();
-  i::MaybeHandle<i::String> maybe_source = isolate->factory()->NewConsString(
-      source_string, Utils::OpenHandle(*source->source_string));
-  if (!maybe_source.ToHandle(&source_string)) {
-    return Local<Function>();
-  }
+  has_pending_exception =
+      !factory->NewConsString(source_string,
+                              Utils::OpenHandle(*source->source_string))
+           .ToHandle(&source_string);
+  RETURN_ON_FAILED_EXECUTION(Function);
   // Include \n in case the source contains a line end comment.
-  i::Handle<i::String> brackets =
-      Utils::OpenHandle(*v8::String::NewFromUtf8(v8_isolate, "\n})"));
-  maybe_source = isolate->factory()->NewConsString(source_string, brackets);
-  if (!maybe_source.ToHandle(&source_string)) {
-    return Local<Function>();
-  }
+  auto brackets = factory->NewStringFromStaticChars("\n})");
+  has_pending_exception =
+      !factory->NewConsString(source_string, brackets).ToHandle(&source_string);
+  RETURN_ON_FAILED_EXECUTION(Function);
 
   i::Handle<i::Context> context = Utils::OpenHandle(*v8_context);
   i::Handle<i::SharedFunctionInfo> outer_info(context->closure()->shared(),
                                               isolate);
   for (size_t i = 0; i < context_extension_count; ++i) {
     i::Handle<i::JSObject> extension =
         Utils::OpenHandle(*context_extensions[i]);
     i::Handle<i::JSFunction> closure(context->closure(), isolate);
-    context = isolate->factory()->NewWithContext(closure, context, extension);
+    context = factory->NewWithContext(closure, context, extension);
   }
 
-  EXCEPTION_PREAMBLE(isolate);
-  i::MaybeHandle<i::JSFunction> maybe_fun = i::Compiler::GetFunctionFromEval(
-      source_string, outer_info, context, i::SLOPPY,
-      i::ONLY_SINGLE_FUNCTION_LITERAL, scope_position);
   i::Handle<i::JSFunction> fun;
-  has_pending_exception = !maybe_fun.ToHandle(&fun);
-  EXCEPTION_BAILOUT_CHECK(isolate, Local<Function>());
+  has_pending_exception =
+      !i::Compiler::GetFunctionFromEval(
+           source_string, outer_info, context, i::SLOPPY,
+           i::ONLY_SINGLE_FUNCTION_LITERAL, scope_position).ToHandle(&fun);
+  RETURN_ON_FAILED_EXECUTION(Function);
 
-  i::MaybeHandle<i::Object> result = i::Execution::Call(
-      isolate, fun, Utils::OpenHandle(*v8_context->Global()), 0, NULL);
-  i::Handle<i::Object> final_result;
-  has_pending_exception = !result.ToHandle(&final_result);
-  EXCEPTION_BAILOUT_CHECK(isolate, Local<Function>());
-  return Utils::ToLocal(i::Handle<i::JSFunction>::cast(final_result));
+  i::Handle<i::Object> result;
+  has_pending_exception =
+      !i::Execution::Call(isolate, fun,
+                          Utils::OpenHandle(*v8_context->Global()), 0,
+                          nullptr).ToHandle(&result);
+  RETURN_ON_FAILED_EXECUTION(Function);
+  RETURN_ESCAPED(Utils::ToLocal(i::Handle<i::JSFunction>::cast(result)));
 }
 
 
+Local<Function> ScriptCompiler::CompileFunctionInContext(
+    Isolate* v8_isolate, Source* source, Local<Context> v8_context,
+    size_t arguments_count, Local<String> arguments[],
+    size_t context_extension_count, Local<Object> context_extensions[]) {
+  RETURN_TO_LOCAL_UNCHECKED(
+      CompileFunctionInContext(v8_context, source, arguments_count, arguments,
+                               context_extension_count, context_extensions),
+      Function);
+}
+
+
 ScriptCompiler::ScriptStreamingTask* ScriptCompiler::StartStreamingScript(
     Isolate* v8_isolate, StreamedSource* source, CompileOptions options) {
   i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
   return new i::BackgroundParsingTask(source->impl(), options,
                                       i::FLAG_stack_size, isolate);
 }
 
 
-Local<Script> ScriptCompiler::Compile(Isolate* v8_isolate,
-                                      StreamedSource* v8_source,
-                                      Handle<String> full_source_string,
-                                      const ScriptOrigin& origin) {
-  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
+MaybeLocal<Script> ScriptCompiler::Compile(Local<Context> context,
+                                           StreamedSource* v8_source,
+                                           Handle<String> full_source_string,
+                                           const ScriptOrigin& origin) {
+  PREPARE_FOR_EXECUTION(context, "v8::ScriptCompiler::Compile()", Script);
   i::StreamedSource* source = v8_source->impl();
-  ON_BAILOUT(isolate, "v8::ScriptCompiler::Compile()", return Local<Script>());
-  LOG_API(isolate, "ScriptCompiler::Compile()");
-  ENTER_V8(isolate);
-  i::SharedFunctionInfo* raw_result = NULL;
-
+  i::SharedFunctionInfo* raw_result = nullptr;
   {
     i::HandleScope scope(isolate);
     i::Handle<i::String> str = Utils::OpenHandle(*(full_source_string));
     i::Handle<i::Script> script = isolate->factory()->NewScript(str);
     if (!origin.ResourceName().IsEmpty()) {
       script->set_name(*Utils::OpenHandle(*(origin.ResourceName())));
     }
     if (!origin.ResourceLineOffset().IsEmpty()) {
       script->set_line_offset(i::Smi::FromInt(
           static_cast<int>(origin.ResourceLineOffset()->Value())));
     }
     if (!origin.ResourceColumnOffset().IsEmpty()) {
       script->set_column_offset(i::Smi::FromInt(
           static_cast<int>(origin.ResourceColumnOffset()->Value())));
     }
     if (!origin.ResourceIsSharedCrossOrigin().IsEmpty()) {
       script->set_is_shared_cross_origin(
           origin.ResourceIsSharedCrossOrigin()->IsTrue());
     }
     if (!origin.ResourceIsEmbedderDebugScript().IsEmpty()) {
       script->set_is_embedder_debug_script(
           origin.ResourceIsEmbedderDebugScript()->IsTrue());
     }
     source->info->set_script(script);
     source->info->SetContext(isolate->native_context());
 
-    EXCEPTION_PREAMBLE(isolate);
-
     // Do the parsing tasks which need to be done on the main thread. This will
     // also handle parse errors.
     source->parser->Internalize(isolate, script,
-                                source->info->function() == NULL);
+                                source->info->function() == nullptr);
     source->parser->HandleSourceURLComments(isolate, script);
 
-    i::Handle<i::SharedFunctionInfo> result =
-        i::Handle<i::SharedFunctionInfo>::null();
-    if (source->info->function() != NULL) {
+    i::Handle<i::SharedFunctionInfo> result;
+    if (source->info->function() != nullptr) {
       // Parsing has succeeded.
       result =
           i::Compiler::CompileStreamedScript(source->info.get(), str->length());
     }
     has_pending_exception = result.is_null();
     if (has_pending_exception) isolate->ReportPendingMessages();
-    EXCEPTION_BAILOUT_CHECK(isolate, Local<Script>());
+    RETURN_ON_FAILED_EXECUTION(Script);
 
     raw_result = *result;
     // The Handle<Script> will go out of scope soon; make sure CompilationInfo
     // doesn't point to it.
     source->info->set_script(i::Handle<i::Script>());
   }  // HandleScope goes out of scope.
   i::Handle<i::SharedFunctionInfo> result(raw_result, isolate);
   Local<UnboundScript> generic = ToApiHandle<UnboundScript>(result);
-  if (generic.IsEmpty()) {
-    return Local<Script>();
-  }
-  return generic->BindToCurrentContext();
+  if (generic.IsEmpty()) return Local<Script>();
+  RETURN_ESCAPED(generic->BindToCurrentContext());
 }
 
 
+Local<Script> ScriptCompiler::Compile(Isolate* v8_isolate,
+                                      StreamedSource* v8_source,
+                                      Handle<String> full_source_string,
+                                      const ScriptOrigin& origin) {
+  auto context = v8_isolate->GetCurrentContext();
+  RETURN_TO_LOCAL_UNCHECKED(
+      Compile(context, v8_source, full_source_string, origin), Script);
+}
+
+
 uint32_t ScriptCompiler::CachedDataVersionTag() {
   return static_cast<uint32_t>(base::hash_combine(
       internal::Version::Hash(), internal::FlagList::Hash(),
       static_cast<uint32_t>(internal::CpuFeatures::SupportedFeatures())));
 }
 
 
+MaybeLocal<Script> Script::Compile(Local<Context> context,
+                                   Handle<String> source,
+                                   ScriptOrigin* origin) {
+  if (origin) {
+    ScriptCompiler::Source script_source(source, *origin);
+    return ScriptCompiler::Compile(context, &script_source);
+  }
+  ScriptCompiler::Source script_source(source);
+  return ScriptCompiler::Compile(context, &script_source);
+}
+
+
 Local<Script> Script::Compile(v8::Handle<String> source,
                               v8::ScriptOrigin* origin) {
-  i::Handle<i::String> str = Utils::OpenHandle(*source);
-  if (origin) {
-    ScriptCompiler::Source script_source(source, *origin);
-    return ScriptCompiler::Compile(
-        reinterpret_cast<v8::Isolate*>(str->GetIsolate()),
-        &script_source);
-  }
-  ScriptCompiler::Source script_source(source);
-  return ScriptCompiler::Compile(
-      reinterpret_cast<v8::Isolate*>(str->GetIsolate()),
-      &script_source);
+  auto str = Utils::OpenHandle(*source);
+  auto context = ContextFromHeapObject(str);
+  RETURN_TO_LOCAL_UNCHECKED(Compile(context, source, origin), Script);
 }
 
 
 Local<Script> Script::Compile(v8::Handle<String> source,
                               v8::Handle<String> file_name) {
   ScriptOrigin origin(file_name);
   return Compile(source, &origin);
 }
 
 
@@ skipping 6038 matching lines @@
   Isolate* isolate = reinterpret_cast<Isolate*>(info.GetIsolate());
   Address callback_address =
       reinterpret_cast<Address>(reinterpret_cast<intptr_t>(callback));
   VMState<EXTERNAL> state(isolate);
   ExternalCallbackScope call_scope(isolate, callback_address);
   callback(info);
 }
 
 
 } }  // namespace v8::internal