fixup! vm: make ContextifyContext a BaseObject

This reverts commit b9042c87b60184a37d9c8674ec8c8b29b2a8ab5e.

Author: joyeecheung

src/node_contextify.cc

@@ -131,81 +131,7 @@ BaseObjectPtr<ContextifyContext> ContextifyContext::New(
  // Allocation failure, maximum call stack size reached, termination, etc.
  return BaseObjectPtr<ContextifyContext>();
  }
-
- // This only initializes part of the context. The primordials are
- // only initilaized when needed because even deserializing them slows
- // things down significantly and they are only needed in rare occasions
- // in the vm contexts.
- if (InitializeContextRuntime(v8_context).IsNothing()) {
- return BaseObjectPtr<ContextifyContext>();
- }
-
- Local<Context> main_context = env->context();
- Local<Object> new_context_global = v8_context->Global();
- v8_context->SetSecurityToken(main_context->GetSecurityToken());
-
- // We need to tie the lifetime of the sandbox object with the lifetime of
- // newly created context. We do this by making them hold references to each
- // other. The context can directly hold a reference to the sandbox as an
- // embedder data field. The sandbox uses a private symbol to hold a reference
- // to the ContextifyContext wrapper which in turn internally references
- // the context from its constructor.
- v8_context->SetEmbedderData(ContextEmbedderIndex::kSandboxObject,
- sandbox_obj);
-
- // Delegate the code generation validation to
- // node::ModifyCodeGenerationFromStrings.
- v8_context->AllowCodeGenerationFromStrings(false);
- v8_context->SetEmbedderData(
- ContextEmbedderIndex::kAllowCodeGenerationFromStrings,
- options.allow_code_gen_strings);
- v8_context->SetEmbedderData(ContextEmbedderIndex::kAllowWasmCodeGeneration,
- options.allow_code_gen_wasm);
-
- Utf8Value name_val(env->isolate(), options.name);
- ContextInfo info(*name_val);
- if (!options.origin.IsEmpty()) {
- Utf8Value origin_val(env->isolate(), options.origin);
- info.origin = *origin_val;
- }
-
- BaseObjectPtr<ContextifyContext> result;
- Local<Object> wrapper;
- {
- Context::Scope context_scope(v8_context);
- Local<String> ctor_name = sandbox_obj->GetConstructorName();
- if (!ctor_name->Equals(v8_context, env->object_string()).FromMaybe(false) &&
- new_context_global
- ->DefineOwnProperty(
- v8_context,
- v8::Symbol::GetToStringTag(env->isolate()),
- ctor_name,
- static_cast<v8::PropertyAttribute>(v8::DontEnum))
- .IsNothing()) {
- return BaseObjectPtr<ContextifyContext>();
- }
- env->AssignToContext(v8_context, nullptr, info);
-
- if (!env->contextify_wrapper_template()
- ->NewInstance(v8_context)
- .ToLocal(&wrapper)) {
- return BaseObjectPtr<ContextifyContext>();
- }
-
- result =
- MakeBaseObject<ContextifyContext>(env, wrapper, v8_context, options);
- // The only strong reference to the wrapper will come from the sandbox.
- result->MakeWeak();
- }
-
- if (sandbox_obj
- ->SetPrivate(
- v8_context, env->contextify_context_private_symbol(), wrapper)
- .IsNothing()) {
- return BaseObjectPtr<ContextifyContext>();
- }
-
- return result;
+ return New(v8_context, env, sandbox_obj, options);
 }
 
 void ContextifyContext::MemoryInfo(MemoryTracker* tracker) const {
@@ -316,6 +242,89 @@ MaybeLocal<Context> ContextifyContext::CreateV8Context(
  return scope.Escape(ctx);
 }
 
+
+BaseObjectPtr<ContextifyContext> ContextifyContext::New(
+ Local<Context> v8_context,
+ Environment* env,
+ Local<Object> sandbox_obj,
+ const ContextOptions& options) {
+ HandleScope scope(env->isolate());
+ // This only initializes part of the context. The primordials are
+ // only initilaized when needed because even deserializing them slows
+ // things down significantly and they are only needed in rare occasions
+ // in the vm contexts.
+ if (InitializeContextRuntime(v8_context).IsNothing()) {
+ return BaseObjectPtr<ContextifyContext>();
+ }
+
+ Local<Context> main_context = env->context();
+ Local<Object> new_context_global = v8_context->Global();
+ v8_context->SetSecurityToken(main_context->GetSecurityToken());
+
+ // We need to tie the lifetime of the sandbox object with the lifetime of
+ // newly created context. We do this by making them hold references to each
+ // other. The context can directly hold a reference to the sandbox as an
+ // embedder data field. The sandbox uses a private symbol to hold a reference
+ // to the ContextifyContext wrapper which in turn internally references
+ // the context from its constructor.
+ v8_context->SetEmbedderData(ContextEmbedderIndex::kSandboxObject,
+ sandbox_obj);
+
+ // Delegate the code generation validation to
+ // node::ModifyCodeGenerationFromStrings.
+ v8_context->AllowCodeGenerationFromStrings(false);
+ v8_context->SetEmbedderData(
+ ContextEmbedderIndex::kAllowCodeGenerationFromStrings,
+ options.allow_code_gen_strings);
+ v8_context->SetEmbedderData(ContextEmbedderIndex::kAllowWasmCodeGeneration,
+ options.allow_code_gen_wasm);
+
+ Utf8Value name_val(env->isolate(), options.name);
+ ContextInfo info(*name_val);
+ if (!options.origin.IsEmpty()) {
+ Utf8Value origin_val(env->isolate(), options.origin);
+ info.origin = *origin_val;
+ }
+
+ BaseObjectPtr<ContextifyContext> result;
+ Local<Object> wrapper;
+ {
+ Context::Scope context_scope(v8_context);
+ Local<String> ctor_name = sandbox_obj->GetConstructorName();
+ if (!ctor_name->Equals(v8_context, env->object_string()).FromMaybe(false) &&
+ new_context_global
+ ->DefineOwnProperty(
+ v8_context,
+ v8::Symbol::GetToStringTag(env->isolate()),
+ ctor_name,
+ static_cast<v8::PropertyAttribute>(v8::DontEnum))
+ .IsNothing()) {
+ return BaseObjectPtr<ContextifyContext>();
+ }
+ env->AssignToContext(v8_context, nullptr, info);
+
+ if (!env->contextify_wrapper_template()
+ ->NewInstance(v8_context)
+ .ToLocal(&wrapper)) {
+ return BaseObjectPtr<ContextifyContext>();
+ }
+
+ result =
+ MakeBaseObject<ContextifyContext>(env, wrapper, v8_context, options);
+ // The only strong reference to the wrapper will come from the sandbox.
+ result->MakeWeak();
+ }
+
+ if (sandbox_obj
+ ->SetPrivate(
+ v8_context, env->contextify_context_private_symbol(), wrapper)
+ .IsNothing()) {
+ return BaseObjectPtr<ContextifyContext>();
+ }
+
+ return result;
+}
+
 void ContextifyContext::Init(Environment* env, Local<Object> target) {
  Local<Context> context = env->context();
  SetMethod(context, target, "makeContext", MakeContext);
@@ -387,12 +396,6 @@ void ContextifyContext::MakeContext(const FunctionCallbackInfo<Value>& args) {
  try_catch.ReThrow();
  return;
  }
-
- if (context_ptr.get() == nullptr) {
- return;
- }
- Local<Context> new_context = context_ptr->context();
- if (new_context.IsEmpty()) return;
 }
 
 

src/node_contextify.h

@@ -53,18 +53,11 @@ class ContextifyContext : public BaseObject {
  SET_MEMORY_INFO_NAME(ContextifyContext)
  SET_SELF_SIZE(ContextifyContext)
 
- static BaseObjectPtr<ContextifyContext> New(Environment* env,
- v8::Local<v8::Object> sandbox_obj,
- const ContextOptions& options);
  static v8::MaybeLocal<v8::Context> CreateV8Context(
  v8::Isolate* isolate,
  v8::Local<v8::ObjectTemplate> object_template,
  const SnapshotData* snapshot_data,
  v8::MicrotaskQueue* queue);
- static bool InitializeContext(v8::Local<v8::Context> ctx,
- Environment* env,
- v8::Local<v8::Object> sandbox_obj,
- const ContextOptions& options);
  static void Init(Environment* env, v8::Local<v8::Object> target);
  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
 
@@ -97,6 +90,15 @@ class ContextifyContext : public BaseObject {
  static void InitializeGlobalTemplates(IsolateData* isolate_data);
 
  private:
+ static BaseObjectPtr<ContextifyContext> New(Environment* env,
+ v8::Local<v8::Object> sandbox_obj,
+ const ContextOptions& options);
+ // Initialize a context created from CreateV8Context()
+ static BaseObjectPtr<ContextifyContext> New(v8::Local<v8::Context> ctx,
+ Environment* env,
+ v8::Local<v8::Object> sandbox_obj,
+ const ContextOptions& options);
+
  static bool IsStillInitializing(const ContextifyContext* ctx);
  static void MakeContext(const v8::FunctionCallbackInfo<v8::Value>& args);
  static void IsContext(const v8::FunctionCallbackInfo<v8::Value>& args);