[ESNext] Implement DynamicImportCall

src/d8.h

 // 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.
 
 #ifndef V8_D8_H_
 #define V8_D8_H_
 
 #include <iterator>
 #include <memory>
 #include <string>
@@ skipping 262 matching lines @@
 
   base::Semaphore in_semaphore_;
   base::Semaphore out_semaphore_;
   SerializationDataQueue in_queue_;
   SerializationDataQueue out_queue_;
   base::Thread* thread_;
   char* script_;
   base::Atomic32 running_;
 };
 
+class DynamicImportData {

[adamk, 2017/03/15 21:36:44]

All-public things generally use "struct" instead of "class".

Also, does this have to be in d8.h, or could it be in an anonymous namespace in
d8.cc?

[gsathya, 2017/03/16 00:59:24]

Done.

+ public:
+  explicit DynamicImportData(Isolate* isolate, Local<String> referrer,

[adamk, 2017/03/15 21:36:44]

No need for "explicit" here, since this constructor takes more than one
argument.

[gsathya, 2017/03/16 00:59:24]

Done.

+                             Local<String> specifier, Local<Promise> promise)
+      : isolate_(isolate) {
+    referrer_.Reset(isolate_, referrer);

[adamk, 2017/03/15 21:36:43]

Rather than calling Reset, you should be able to use the initializer list, like:

referrer_(isolate, referrer),
specifier_(isolate, specifier),
...

[gsathya, 2017/03/16 00:59:24]

Nope, globals don't seem to have that constructor.

+    specifier_.Reset(isolate_, specifier);
+    promise_.Reset(isolate_, promise);
+  }
+
+  Isolate* isolate_;

[adamk, 2017/03/15 21:36:43]

Style: public data members should not have a trailing "_".

[gsathya, 2017/03/16 00:59:24]

Done.

+  Global<String> referrer_;
+  Global<String> specifier_;
+  Global<Promise> promise_;
+};
 
 class ShellOptions {
  public:
   ShellOptions()
       : script_executed(false),
         send_idle_notification(false),
         invoke_weak_callbacks(false),
         omit_quit(false),
         stress_opt(false),
         stress_deopt(false),
@@ skipping 140 matching lines @@
   // with the current umask.  Intermediate directories are created if necessary.
   // An exception is not thrown if the directory already exists.  Analogous to
   // the "mkdir -p" command.
   static void System(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void ChangeDirectory(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void SetEnvironment(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void UnsetEnvironment(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void SetUMask(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void MakeDirectory(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void RemoveDirectory(const v8::FunctionCallbackInfo<v8::Value>& args);
-
+  static void HostImportModuleDynamically(Isolate* isolate,
+                                          Local<String> source_url,
+                                          Local<String> specifier,
+                                          Local<Promise> promise);
+  static void DoHostImportModuleDynamically(void* data);
   static void AddOSMethods(v8::Isolate* isolate,
                            Local<ObjectTemplate> os_template);
 
   static const char* kPrompt;
   static ShellOptions options;
   static ArrayBuffer::Allocator* array_buffer_allocator;
 
  private:
   static Global<Context> evaluation_context_;
   static base::OnceType quit_once_;
@@ skipping 21 matching lines @@
   static void RunShell(Isolate* isolate);
   static bool SetOptions(int argc, char* argv[]);
   static Local<ObjectTemplate> CreateGlobalTemplate(Isolate* isolate);
   static MaybeLocal<Context> CreateRealm(
       const v8::FunctionCallbackInfo<v8::Value>& args, int index,
       v8::MaybeLocal<Value> global_object);
   static void DisposeRealm(const v8::FunctionCallbackInfo<v8::Value>& args,
                            int index);
   static MaybeLocal<Module> FetchModuleTree(v8::Local<v8::Context> context,
                                             const std::string& file_name);
+  static MaybeLocal<Module> DynamicFetchModuleTree(
+      v8::Local<v8::Context> context, v8::Local<v8::Promise> promise,
+      const std::string& file_name);
 };
 
 
 }  // namespace v8
 
 
 #endif  // V8_D8_H_