Allow passing sourceMapUrl when compiling scripts

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 197 matching lines @@
  private:
   i::Isolate* const isolate_;
   Local<Context> context_;
   bool escaped_;
   bool do_callback_;
 };
 
 }  // namespace
 
 
+static ScriptOrigin GetScriptOriginForScript(i::Isolate* isolate,
+                                             i::Handle<i::Script> script) {
+  i::Handle<i::Object> scriptName(i::Script::GetNameOrSourceURL(script));
+  i::Handle<i::Object> source_map_url(script->source_mapping_url(), isolate);
+  v8::Isolate* v8_isolate =
+      reinterpret_cast<v8::Isolate*>(script->GetIsolate());
+  v8::ScriptOrigin origin(
+      Utils::ToLocal(scriptName),
+      v8::Integer::New(v8_isolate, script->line_offset()->value()),
+      v8::Integer::New(v8_isolate, script->column_offset()->value()),
+      v8::Boolean::New(v8_isolate, script->is_shared_cross_origin()),
+      v8::Integer::New(v8_isolate, script->id()->value()),
+      v8::Boolean::New(v8_isolate, script->is_embedder_debug_script()),
+      Utils::ToLocal(source_map_url));
+  return origin;
+}
+
+
 // --- E x c e p t i o n   B e h a v i o r ---
 
 
 void i::FatalProcessOutOfMemory(const char* location) {
   i::V8::FatalProcessOutOfMemory(location, false);
 }
 
 
 // When V8 cannot allocated memory FatalProcessOutOfMemory is called.
 // The default fatal error handler is called and execution is stopped.
@@ skipping 1395 matching lines @@
     // 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));
   i::SharedFunctionInfo* raw_result = NULL;
   { i::HandleScope scope(isolate);
     i::HistogramTimerScope total(isolate->counters()->compile_script(), true);
     i::Handle<i::Object> name_obj;
+    i::Handle<i::Object> source_map_url;
     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();
     }
+    if (!source->source_map_url.IsEmpty()) {
+      source_map_url = Utils::OpenHandle(*(source->source_map_url));
+    }
     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);
+        is_shared_cross_origin, source_map_url, 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;
     }
     RETURN_ON_FAILED_EXECUTION(UnboundScript);
     raw_result = *result;
@@ skipping 226 matching lines @@
           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());
     }
+    if (!origin.SourceMapUrl().IsEmpty()) {
+      script->set_source_mapping_url(
+          *Utils::OpenHandle(*(origin.SourceMapUrl())));
+    }
+
     source->info->set_script(script);
     source->info->SetContext(isolate->native_context());
 
     // 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() == nullptr);
     source->parser->HandleSourceURLComments(isolate, script);
 
     i::Handle<i::SharedFunctionInfo> result;
@@ skipping 246 matching lines @@
 
 ScriptOrigin Message::GetScriptOrigin() const {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
   i::Handle<i::JSMessageObject> message =
       i::Handle<i::JSMessageObject>::cast(Utils::OpenHandle(this));
   i::Handle<i::Object> script_wraper =
       i::Handle<i::Object>(message->script(), isolate);
   i::Handle<i::JSValue> script_value =
       i::Handle<i::JSValue>::cast(script_wraper);
   i::Handle<i::Script> script(i::Script::cast(script_value->value()));
-  i::Handle<i::Object> scriptName(i::Script::GetNameOrSourceURL(script));
-  v8::Isolate* v8_isolate =
-      reinterpret_cast<v8::Isolate*>(script->GetIsolate());
-  v8::ScriptOrigin origin(
-      Utils::ToLocal(scriptName),
-      v8::Integer::New(v8_isolate, script->line_offset()->value()),
-      v8::Integer::New(v8_isolate, script->column_offset()->value()),
-      v8::Boolean::New(v8_isolate, script->is_shared_cross_origin()),
-      v8::Integer::New(v8_isolate, script->id()->value()),
-      v8::Boolean::New(v8_isolate, script->is_embedder_debug_script()));
-  return origin;
+  return GetScriptOriginForScript(isolate, script);
 }
 
 
 v8::Handle<Value> Message::GetScriptResourceName() const {
   return GetScriptOrigin().ResourceName();
 }
 
 
 v8::Handle<v8::StackTrace> Message::GetStackTrace() const {
   i::Isolate* isolate = Utils::OpenHandle(this)->GetIsolate();
@@ skipping 2277 matching lines @@
   }
 
   return ToApiHandle<Primitive>(isolate->factory()->undefined_value());
 }
 
 
 ScriptOrigin Function::GetScriptOrigin() const {
   i::Handle<i::JSFunction> func = Utils::OpenHandle(this);
   if (func->shared()->script()->IsScript()) {
     i::Handle<i::Script> script(i::Script::cast(func->shared()->script()));
-    i::Handle<i::Object> scriptName = i::Script::GetNameOrSourceURL(script);
-    v8::Isolate* isolate = reinterpret_cast<v8::Isolate*>(func->GetIsolate());
-    v8::ScriptOrigin origin(
-        Utils::ToLocal(scriptName),
-        v8::Integer::New(isolate, script->line_offset()->value()),
-        v8::Integer::New(isolate, script->column_offset()->value()),
-        v8::Boolean::New(isolate, script->is_shared_cross_origin()),
-        v8::Integer::New(isolate, script->id()->value()),
-        v8::Boolean::New(isolate, script->is_embedder_debug_script()));
-    return origin;
+    return GetScriptOriginForScript(func->GetIsolate(), script);
   }
   return v8::ScriptOrigin(Handle<Value>());
 }
 
 
 const int Function::kLineOffsetNotFound = -1;
 
 
 int Function::GetScriptLineNumber() const {
   i::Handle<i::JSFunction> func = Utils::OpenHandle(this);
@@ skipping 3519 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