Add script streaming API

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
 #include <cmath>  // For isnan.
 #include "include/v8-debug.h"
 #include "include/v8-profiler.h"
 #include "include/v8-testing.h"
 #include "src/assert-scope.h"
+#include "src/background-parser-thread.h"
 #include "src/base/platform/platform.h"
 #include "src/base/platform/time.h"
 #include "src/base/utils/random-number-generator.h"
 #include "src/bootstrapper.h"
 #include "src/code-stubs.h"
 #include "src/compiler.h"
 #include "src/conversions-inl.h"
 #include "src/counters.h"
 #include "src/cpu-profiler.h"
 #include "src/debug.h"
@@ skipping 1542 matching lines @@
     : data(data_), length(length_), buffer_policy(buffer_policy_) {}
 
 
 ScriptCompiler::CachedData::~CachedData() {
   if (buffer_policy == BufferOwned) {
     delete[] data;
   }
 }
 
 
+ScriptCompiler::StreamedSource::~StreamedSource() {
+  delete source_stream;
+  delete cached_data;
+  delete info;
+}
+
+
 Local<Script> UnboundScript::BindToCurrentContext() {
   i::Handle<i::HeapObject> obj =
       i::Handle<i::HeapObject>::cast(Utils::OpenHandle(this));
   i::Handle<i::SharedFunctionInfo>
       function_info(i::SharedFunctionInfo::cast(*obj), obj->GetIsolate());
   i::Handle<i::JSFunction> function =
       obj->GetIsolate()->factory()->NewFunctionFromSharedFunctionInfo(
           function_info, obj->GetIsolate()->global_context());
   return ToApiHandle<Script>(function);
 }
@@ skipping 180 matching lines @@
           script_data->data(), script_data->length(), CachedData::BufferOwned);
       script_data->ReleaseDataOwnership();
     }
     delete script_data;
   }
   i::Handle<i::SharedFunctionInfo> result(raw_result, isolate);
   return ToApiHandle<UnboundScript>(result);
 }
 
 
+bool ScriptCompiler::StartStreamingScript(Isolate* v8_isolate,
+                                          StreamedSource* source,
+                                          StreamingCompleteCallback callback,
+                                          void* callback_data,
+                                          CompileOptions options) {
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
+  if (!isolate->global_context().is_null() &&
+      !isolate->global_context()->IsNativeContext()) {
+    // The context chain is non-trivial, and constructing the corresponding
+    // non-trivial Scope chain outside the V8 heap is not implemented. Don't
+    // stream the script. This will only occur if Harmony scoping is enabled and
+    // a previous script has introduced "let" or "const" variables. TODO(marja):
+    // Implement externalizing ScopeInfos and constructing non-trivial Scope
+    // chains independent of the V8 heap so that we can stream also in this
+    // case.
+    return false;
+  }
+  // At the moment, it's only possible to stream one script per
+  // time. TODO(marja): get rid of this restriction. Since we need one
+  // background thread per a script to be streamed, we need to find a trade-off
+  // between launching new threads and streaming more scripts.
+  if (isolate->background_parser_thread()->HasTask()) return false;
+
+  source->info = new i::CompilationInfoWithZone(source->source_stream, isolate);
+  source->info->MarkAsGlobal();
+  DCHECK(options == kProduceParserCache || options == kProduceCodeCache ||
+         options == kNoCompileOptions);
+  bool allow_lazy = !i::Compiler::DebuggerWantsEagerCompilation(source->info);
+  i::BackgroundParsingTask* task = new i::BackgroundParsingTask(
+      source, callback, callback_data, allow_lazy, isolate);
+  if (options == kProduceParserCache || options == kProduceCodeCache) {
+    source->info->SetCachedData(&(task->script_data_), options);
+  }
+  // We don't set the context to the CompilationInfo yet, because the background
+  // thread cannot do anything with it anyway. We set it just before compilation
+  // on the foreground thread.
+  isolate->background_parser_thread()->SetTask(task);
+  return true;
+}
+
+
+Local<Script> ScriptCompiler::Compile(Isolate* v8_isolate,
+                                      StreamedSource* source,
+                                      Handle<String> full_source_string,
+                                      const ScriptOrigin& origin) {
+  if (source->info->function() == NULL) {
+    // Parsing has failed.
+    return Local<Script>();
+  }
+  i::Isolate* isolate = reinterpret_cast<i::Isolate*>(v8_isolate);
+  source->info->ast_value_factory()->Internalize(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() ==
+                                       v8::True(v8_isolate));
+  }
+  source->info->set_script(script);
+  source->info->SetContext(isolate->global_context());
+
+  ON_BAILOUT(isolate, "v8::ScriptCompiler::Compile()", return Local<Script>());
+  LOG_API(isolate, "ScriptCompiler::Compile()");
+  ENTER_V8(isolate);
+  EXCEPTION_PREAMBLE(isolate);
+  i::Handle<i::SharedFunctionInfo> result =
+      i::Compiler::CompileStreamedScript(source->info, str->length());
+  EXCEPTION_BAILOUT_CHECK(isolate, Local<Script>());
+  Local<UnboundScript> generic = ToApiHandle<UnboundScript>(result);
+  if (generic.IsEmpty()) return Local<Script>();
+  return generic->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::CompiletBound()");
   ENTER_V8(isolate);
   Local<UnboundScript> generic = CompileUnbound(v8_isolate, source, options);
   if (generic.IsEmpty()) return Local<Script>();
@@ skipping 5846 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