public:

IsolateData(v8::Isolate* isolate, uv_loop_t* event_loop,

MultiIsolatePlatform* platform = nullptr,

uint32_t* zero_fill_field = nullptr);

~IsolateData();

inline uv_loop_t* event_loop() const;

inline uint32_t* zero_fill_field() const;

inline MultiIsolatePlatform* platform() const;

#define VP(PropertyName, StringValue) V(v8::Private, PropertyName)

#define VS(PropertyName, StringValue) V(v8::String, PropertyName)

#define V(TypeName, PropertyName) \

inline v8::Local<TypeName> PropertyName(v8::Isolate* isolate) const;

PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(VP)

PER_ISOLATE_STRING_PROPERTIES(VS)

#undef V

#undef VS

#undef VP

std::unordered_map<nghttp2_rcbuf*, v8::Eternal<v8::String>> http2_static_strs;

inline v8::Isolate* isolate() const;

private:

#define VP(PropertyName, StringValue) V(v8::Private, PropertyName)

#define VS(PropertyName, StringValue) V(v8::String, PropertyName)

#define V(TypeName, PropertyName) \

v8::Eternal<TypeName> PropertyName ## _;

PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(VP)

PER_ISOLATE_STRING_PROPERTIES(VS)

#undef V

#undef VS

#undef VP

v8::Isolate* const isolate_;

uv_loop_t* const event_loop_;

uint32_t* const zero_fill_field_;

MultiIsolatePlatform* platform_;

DISALLOW_COPY_AND_ASSIGN(IsolateData);

explicit ContextInfo(const std::string& name) : name(name) {}

const std::string name;

std::string origin;

bool is_default = false;

public:

class AsyncHooks {

public:

// Reason for both UidFields and Fields are that one is stored as a double*

// and the other as a uint32_t*.

enum Fields {

kInit,

kBefore,

kAfter,

kDestroy,

kPromiseResolve,

kTotals,

kCheck,

kStackLength,

kFieldsCount,

};

enum UidFields {

kExecutionAsyncId,

kTriggerAsyncId,

kAsyncIdCounter,

kDefaultTriggerAsyncId,

kUidFieldsCount,

};

inline AliasedBuffer<uint32_t, v8::Uint32Array>& fields();

inline AliasedBuffer<double, v8::Float64Array>& async_id_fields();

inline AliasedBuffer<double, v8::Float64Array>& async_ids_stack();

inline v8::Local<v8::String> provider_string(int idx);

inline void no_force_checks();

inline Environment* env();

inline void push_async_ids(double async_id, double trigger_async_id);

inline bool pop_async_id(double async_id);

inline void clear_async_id_stack(); // Used in fatal exceptions.

// Used to set the kDefaultTriggerAsyncId in a scope. This is instead of

// passing the trigger_async_id along with other constructor arguments.

class DefaultTriggerAsyncIdScope {

public:

DefaultTriggerAsyncIdScope() = delete;

explicit DefaultTriggerAsyncIdScope(Environment* env,

double init_trigger_async_id);

~DefaultTriggerAsyncIdScope();

private:

AliasedBuffer<double, v8::Float64Array> async_id_fields_ref_;

double old_default_trigger_async_id_;

DISALLOW_COPY_AND_ASSIGN(DefaultTriggerAsyncIdScope);

};

private:

friend class Environment; // So we can call the constructor.

inline AsyncHooks();

// Keep a list of all Persistent strings used for Provider types.

v8::Eternal<v8::String> providers_[AsyncWrap::PROVIDERS_LENGTH];

// Keep track of the environment copy itself.

Environment* env_;

// Stores the ids of the current execution context stack.

AliasedBuffer<double, v8::Float64Array> async_ids_stack_;

// Attached to a Uint32Array that tracks the number of active hooks for

// each type.

AliasedBuffer<uint32_t, v8::Uint32Array> fields_;

// Attached to a Float64Array that tracks the state of async resources.

AliasedBuffer<double, v8::Float64Array> async_id_fields_;

void grow_async_ids_stack();

DISALLOW_COPY_AND_ASSIGN(AsyncHooks);

};

class AsyncCallbackScope {

public:

AsyncCallbackScope() = delete;

explicit AsyncCallbackScope(Environment* env);

~AsyncCallbackScope();

inline bool in_makecallback() const;

private:

Environment* env_;

DISALLOW_COPY_AND_ASSIGN(AsyncCallbackScope);

};

class ImmediateInfo {

public:

inline AliasedBuffer<uint32_t, v8::Uint32Array>& fields();

inline uint32_t count() const;

inline bool has_outstanding() const;

inline void count_inc(uint32_t increment);

inline void count_dec(uint32_t decrement);

private:

friend class Environment; // So we can call the constructor.

inline explicit ImmediateInfo(v8::Isolate* isolate);

enum Fields {

kCount,

kHasOutstanding,

kFieldsCount

};

AliasedBuffer<uint32_t, v8::Uint32Array> fields_;

DISALLOW_COPY_AND_ASSIGN(ImmediateInfo);

};

class TickInfo {

public:

inline AliasedBuffer<uint8_t, v8::Uint8Array>& fields();

inline bool has_scheduled() const;

private:

friend class Environment; // So we can call the constructor.

inline explicit TickInfo(v8::Isolate* isolate);

enum Fields {

kHasScheduled,

kFieldsCount

};

AliasedBuffer<uint8_t, v8::Uint8Array> fields_;

DISALLOW_COPY_AND_ASSIGN(TickInfo);

};

typedef void (*HandleCleanupCb)(Environment* env,

uv_handle_t* handle,

void* arg);

class HandleCleanup {

private:

friend class Environment;

HandleCleanup(uv_handle_t* handle, HandleCleanupCb cb, void* arg)

: handle_(handle),

cb_(cb),

arg_(arg) {

}

uv_handle_t* handle_;

HandleCleanupCb cb_;

void* arg_;

ListNode<HandleCleanup> handle_cleanup_queue_;

};

static inline Environment* GetCurrent(v8::Isolate* isolate);

static inline Environment* GetCurrent(v8::Local<v8::Context> context);

static inline Environment* GetCurrent(

const v8::FunctionCallbackInfo<v8::Value>& info);

template <typename T>

static inline Environment* GetCurrent(

const v8::PropertyCallbackInfo<T>& info);

inline Environment(IsolateData* isolate_data, v8::Local<v8::Context> context);

inline ~Environment();

void Start(int argc,

const char* const* argv,

int exec_argc,

const char* const* exec_argv,

bool start_profiler_idle_notifier);

void CleanupHandles();

inline void AssignToContext(v8::Local<v8::Context> context,

const ContextInfo& info);

void StartProfilerIdleNotifier();

void StopProfilerIdleNotifier();

inline v8::Isolate* isolate() const;

inline uv_loop_t* event_loop() const;

inline uint32_t watched_providers() const;

static inline Environment* from_immediate_check_handle(uv_check_t* handle);

inline uv_check_t* immediate_check_handle();

inline uv_idle_t* immediate_idle_handle();

// Register clean-up cb to be called on environment destruction.

inline void RegisterHandleCleanup(uv_handle_t* handle,

HandleCleanupCb cb,

void *arg);

inline void FinishHandleCleanup(uv_handle_t* handle);

inline AsyncHooks* async_hooks();

inline ImmediateInfo* immediate_info();

inline TickInfo* tick_info();

inline uint64_t timer_base() const;

inline IsolateData* isolate_data() const;

inline bool using_domains() const;

inline void set_using_domains(bool value);

inline bool printed_error() const;

inline void set_printed_error(bool value);

void PrintSyncTrace() const;

inline void set_trace_sync_io(bool value);

// This stores whether the --abort-on-uncaught-exception flag was passed

// to Node.

inline bool abort_on_uncaught_exception() const;

inline void set_abort_on_uncaught_exception(bool value);

// This is a pseudo-boolean that keeps track of whether an uncaught exception

// should abort the process or not if --abort-on-uncaught-exception was

// passed to Node. If the flag was not passed, it is ignored.

inline AliasedBuffer<uint32_t, v8::Uint32Array>&

should_abort_on_uncaught_toggle();

// The necessary API for async_hooks.

inline double new_async_id();

inline double execution_async_id();

inline double trigger_async_id();

inline double get_default_trigger_async_id();

// List of id's that have been destroyed and need the destroy() cb called.

inline std::vector<double>* destroy_async_id_list();

std::unordered_multimap<int, loader::ModuleWrap*> module_map;

inline double* heap_statistics_buffer() const;

inline void set_heap_statistics_buffer(double* pointer);

inline double* heap_space_statistics_buffer() const;

inline void set_heap_space_statistics_buffer(double* pointer);

inline char* http_parser_buffer() const;

inline void set_http_parser_buffer(char* buffer);

inline http2::http2_state* http2_state() const;

inline void set_http2_state(std::unique_ptr<http2::http2_state> state);

inline double* fs_stats_field_array() const;

inline void set_fs_stats_field_array(double* fields);

inline performance::performance_state* performance_state();

inline std::map<std::string, uint64_t>* performance_marks();

void CollectExceptionInfo(v8::Local<v8::Value> context,

int errorno,

const char* syscall = nullptr,

const char* message = nullptr,

const char* path = nullptr);

void CollectUVExceptionInfo(v8::Local<v8::Value> context,

int errorno,

const char* syscall = nullptr,

const char* message = nullptr,

const char* path = nullptr,

const char* dest = nullptr);

inline void ThrowError(const char* errmsg);

inline void ThrowTypeError(const char* errmsg);

inline void ThrowRangeError(const char* errmsg);

inline void ThrowErrnoException(int errorno,

const char* syscall = nullptr,

const char* message = nullptr,

const char* path = nullptr);

inline void ThrowUVException(int errorno,

const char* syscall = nullptr,

const char* message = nullptr,

const char* path = nullptr,

const char* dest = nullptr);

inline v8::Local<v8::FunctionTemplate>

NewFunctionTemplate(v8::FunctionCallback callback,

v8::Local<v8::Signature> signature =

v8::Local<v8::Signature>());

// Convenience methods for NewFunctionTemplate().

inline void SetMethod(v8::Local<v8::Object> that,

const char* name,

v8::FunctionCallback callback);

inline void SetProtoMethod(v8::Local<v8::FunctionTemplate> that,

const char* name,

v8::FunctionCallback callback);

inline void SetTemplateMethod(v8::Local<v8::FunctionTemplate> that,

const char* name,

v8::FunctionCallback callback);

void AtExit(void (*cb)(void* arg), void* arg);

void RunAtExitCallbacks();

// Strings and private symbols are shared across shared contexts

// The getters simply proxy to the per-isolate primitive.

#define VP(PropertyName, StringValue) V(v8::Private, PropertyName)

#define VS(PropertyName, StringValue) V(v8::String, PropertyName)

#define V(TypeName, PropertyName) \

inline v8::Local<TypeName> PropertyName() const;

PER_ISOLATE_PRIVATE_SYMBOL_PROPERTIES(VP)

PER_ISOLATE_STRING_PROPERTIES(VS)

#undef V

#undef VS

#undef VP

#define V(PropertyName, TypeName) \

inline v8::Local<TypeName> PropertyName() const; \

inline void set_ ## PropertyName(v8::Local<TypeName> value);

ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V)

#undef V

#if HAVE_INSPECTOR

inline inspector::Agent* inspector_agent() const {

return inspector_agent_.get();

}

#endif

typedef ListHead<HandleWrap, &HandleWrap::handle_wrap_queue_> HandleWrapQueue;

typedef ListHead<ReqWrap<uv_req_t>, &ReqWrap<uv_req_t>::req_wrap_queue_>

ReqWrapQueue;

inline HandleWrapQueue* handle_wrap_queue() { return &handle_wrap_queue_; }

inline ReqWrapQueue* req_wrap_queue() { return &req_wrap_queue_; }

static const int kContextEmbedderDataIndex = NODE_CONTEXT_EMBEDDER_DATA_INDEX;

void AddPromiseHook(promise_hook_func fn, void* arg);

bool RemovePromiseHook(promise_hook_func fn, void* arg);

bool EmitNapiWarning();

typedef void (*native_immediate_callback)(Environment* env, void* data);

// cb will be called as cb(env, data) on the next event loop iteration.

// obj will be kept alive between now and after the callback has run.

inline void SetImmediate(native_immediate_callback cb,

void* data,

v8::Local<v8::Object> obj = v8::Local<v8::Object>());

// This needs to be available for the JS-land setImmediate().

void ActivateImmediateCheck();

class ShouldNotAbortOnUncaughtScope {

public:

explicit inline ShouldNotAbortOnUncaughtScope(Environment* env);

inline void Close();

inline ~ShouldNotAbortOnUncaughtScope();

private:

Environment* env_;

};

inline bool inside_should_not_abort_on_uncaught_scope() const;

static inline Environment* ForAsyncHooks(AsyncHooks* hooks);

private:

inline void ThrowError(v8::Local<v8::Value> (*fun)(v8::Local<v8::String>),

const char* errmsg);

v8::Isolate* const isolate_;

IsolateData* const isolate_data_;

uv_check_t immediate_check_handle_;

uv_idle_t immediate_idle_handle_;

uv_prepare_t idle_prepare_handle_;

uv_check_t idle_check_handle_;

AsyncHooks async_hooks_;

ImmediateInfo immediate_info_;

TickInfo tick_info_;

const uint64_t timer_base_;

bool using_domains_;

bool printed_error_;

bool trace_sync_io_;

bool abort_on_uncaught_exception_;

bool emit_napi_warning_;

size_t makecallback_cntr_;

std::vector<double> destroy_async_id_list_;

AliasedBuffer<uint32_t, v8::Uint32Array> should_abort_on_uncaught_toggle_;

int should_not_abort_scope_counter_ = 0;

performance::performance_state* performance_state_ = nullptr;

std::map<std::string, uint64_t> performance_marks_;

#if HAVE_INSPECTOR

std::unique_ptr<inspector::Agent> inspector_agent_;

#endif

HandleWrapQueue handle_wrap_queue_;

ReqWrapQueue req_wrap_queue_;

ListHead<HandleCleanup,

&HandleCleanup::handle_cleanup_queue_> handle_cleanup_queue_;

int handle_cleanup_waiting_;

double* heap_statistics_buffer_ = nullptr;

double* heap_space_statistics_buffer_ = nullptr;

char* http_parser_buffer_;

std::unique_ptr<http2::http2_state> http2_state_;

double* fs_stats_field_array_;

struct AtExitCallback {

void (*cb_)(void* arg);

void* arg_;

};

std::list<AtExitCallback> at_exit_functions_;

struct PromiseHookCallback {

promise_hook_func cb_;

void* arg_;

size_t enable_count_;

};

std::vector<PromiseHookCallback> promise_hooks_;

struct NativeImmediateCallback {

native_immediate_callback cb_;

void* data_;

std::unique_ptr<v8::Persistent<v8::Object>> keep_alive_;

};

std::vector<NativeImmediateCallback> native_immediate_callbacks_;

void RunAndClearNativeImmediates();

static void CheckImmediate(uv_check_t* handle);

static void EnvPromiseHook(v8::PromiseHookType type,

v8::Local<v8::Promise> promise,

v8::Local<v8::Value> parent);

#define V(PropertyName, TypeName) \

v8::Persistent<TypeName> PropertyName ## _;

ENVIRONMENT_STRONG_PERSISTENT_PROPERTIES(V)

#undef V

DISALLOW_COPY_AND_ASSIGN(Environment);