[ESNext] Implement DynamicImportCall

src/isolate.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/isolate.h"
 
 #include <stdlib.h>
 
 #include <fstream>  // NOLINT(readability/streams)
 #include <sstream>
@@ skipping 3323 matching lines @@
   v8::Isolate::SuppressMicrotaskExecutionScope suppress(isolate);
   for (int i = 0; i < call_completed_callbacks_.length(); i++) {
     call_completed_callbacks_.at(i)(isolate);
   }
 }
 
 void Isolate::DebugStateUpdated() {
   promise_hook_or_debug_is_active_ = promise_hook_ || debug()->is_active();
 }
 
+void Isolate::RunHostImportModuleDynamicallyCallback(
+    Handle<String> source_url, Handle<String> specifier,
+    Handle<JSPromise> promise) {
+  if (host_import_module_dynamically_callback_ == nullptr) return;

[neis, 2017/03/17 10:36:32]

I think we talked about this case. Didn't we agree to fail here?

[gsathya, 2017/03/17 21:47:59]

I'm not sure tbh. there could be cases where the embedder doesnt want to
implement this? Also not sure how to sync this change with blink if we fail. I
was going to ask Jochen about this.

[neis, 2017/03/20 09:36:03]

Hmm, I would imagine that if an embedder for some reason doesn't want to support
dynamic imports, they just do that by making the callback always do
FinishDynamicImportFailure. But I would be interested to hear what Jochen and
Adam think.

[gsathya, 2017/03/22 03:08:34]

Jochen --

For dynamic import to work, we require that the embedder register a callback to
load files. 

1) Should the API be something like
isolate->SetHostImportModuleDynamicallyCallback(callback) or have the callback
set up as part of creating the isolate using create_params (which is what I've
implemented here).

2) What if the embedder doesn't implement the API? Should we crash when import
is used (for the former approach using SetHostImportModuleDyanamicallyCallback)
or on isolate creation (for the create_params approach)?

This is part of the syntax defined by the language so should we even allow the
creation of an isolate without this callback?

+
+  host_import_module_dynamically_callback_(
+      reinterpret_cast<v8::Isolate*>(this), v8::Utils::ToLocal(source_url),
+      v8::Utils::ToLocal(specifier), v8::Utils::PromiseToLocal(promise));
+}
+
+void Isolate::SetHostImportModuleDynamicallyCallback(
+    HostImportModuleDynamicallyCallback callback) {
+  host_import_module_dynamically_callback_ = callback;
+}
+
 void Isolate::SetPromiseHook(PromiseHook hook) {
   promise_hook_ = hook;
   DebugStateUpdated();
 }
 
 void Isolate::RunPromiseHook(PromiseHookType type, Handle<JSPromise> promise,
                              Handle<Object> parent) {
   if (debug()->is_active()) debug()->RunPromiseHook(type, promise, parent);
   if (promise_hook_ == nullptr) return;
   promise_hook_(type, v8::Utils::PromiseToLocal(promise),
@@ skipping 385 matching lines @@
   // Then check whether this scope intercepts.
   if ((flag & intercept_mask_)) {
     intercepted_flags_ |= flag;
     return true;
   }
   return false;
 }
 
 }  // namespace internal
 }  // namespace v8