apply review comments

Author: hs0225

deps/node/lib/internal/lwnode/setup.js

@@ -95,13 +95,13 @@ function wrapLWNodeMethods(binding) {
         return binding.hasSystemInfo.apply(null, args);
       }
     },
-    binding: (message) => {
+    sendMessageSync: (message) => {
       if (typeof message !== "string") {
         throw new TypeError("The message argument must be a string");
       }
 
-      if (binding.binding) {
-        return binding.binding(message);
+      if (binding.sendMessageSync) {
+        return binding.sendMessageSync(message);
       }
     }
   };

deps/node/src/lwnode/lwnode-public.cc

@@ -29,8 +29,8 @@ using namespace node;
 namespace lwnode {
 
 struct Runtime::Configuration::Internal {
-  Runtime::BindingCallback binding_callback{nullptr};
-  void* binding_callback_data{nullptr};
+  Runtime::SendMessageSyncCallback send_message_sync_callback{nullptr};
+  void* send_message_sync_callback_data{nullptr};
 };
 
 class Runtime::Internal {
@@ -40,15 +40,17 @@ class Runtime::Internal {
   std::pair<bool, int> Init(int argc, char** argv) {
     is_initialized = true;
 
-    // Set binding callback to isolate context embedder data.
-    runner_.SetOnCreatedContextCallback([this](v8::Local<v8::Context> context) {
-      context->SetAlignedPointerInEmbedderData(
-          LWNode::ContextEmbedderIndex::kBindingCallback,
-          reinterpret_cast<void*>(config_.internal_->binding_callback));
-      context->SetAlignedPointerInEmbedderData(
-          LWNode::ContextEmbedderIndex::kBindingCallbackData,
-          config_.internal_->binding_callback_data);
-    });
+    // Set sendMessageSync callback to isolate context embedder data.
+    runner_.SetOnMainEnvCreationCallback(
+        [this](v8::Local<v8::Context> context) {
+          context->SetAlignedPointerInEmbedderData(
+              LWNode::ContextEmbedderIndex::kSendMessageSyncCallback,
+              reinterpret_cast<void*>(
+                  config_.internal_->send_message_sync_callback));
+          context->SetAlignedPointerInEmbedderData(
+              LWNode::ContextEmbedderIndex::kSendMessageSyncCallbackData,
+              config_.internal_->send_message_sync_callback_data);
+        });
 
     return InitializeNode(argc, argv, &instance_);
   }
@@ -126,10 +128,10 @@ Runtime::Configuration& Runtime::Configuration::operator=(
   return *this;
 }
 
-void Runtime::Configuration::SetBindingCallback(
-    Runtime::BindingCallback callback, void* user_data) {
-  internal_->binding_callback = callback;
-  internal_->binding_callback_data = user_data;
+void Runtime::Configuration::OnSendMessageSync(
+    Runtime::SendMessageSyncCallback callback, void* user_data) {
+  internal_->send_message_sync_callback = callback;
+  internal_->send_message_sync_callback_data = user_data;
 }
 
 /**************************************************************************

deps/node/src/node_main_lw_runner-inl.h

@@ -127,8 +127,8 @@ class LWNodeMainRunner {
 
     Context::Scope context_scope(env_->context());
 
-    if (on_context_created_callback_) {
-      on_context_created_callback_(env_->context());
+    if (on_main_env_creation_callback_) {
+      on_main_env_creation_callback_(env_->context());
     }
 
     if (exit_code == 0) {
@@ -197,16 +197,16 @@ class LWNodeMainRunner {
     promise_ = std::move(promise);
   }
 
-  void SetOnCreatedContextCallback(
+  void SetOnMainEnvCreationCallback(
       const std::function<void(v8::Local<v8::Context>)>& callback) {
-    on_context_created_callback_ = callback;
+    on_main_env_creation_callback_ = callback;
   }
 
  private:
   std::unique_ptr<node::ArrayBufferAllocator> array_buffer_allocator_;
   Environment* environment_ = nullptr;
   std::promise<void> promise_;
-  std::function<void(v8::Local<v8::Context>)> on_context_created_callback_{
+  std::function<void(v8::Local<v8::Context>)> on_main_env_creation_callback_{
       nullptr};
 };
 

include/lwnode/lwnode-public.h

@@ -49,7 +49,8 @@ LWNODE_EXPORT void SetDlogID(const std::string& appId);
 
 class LWNODE_EXPORT Runtime {
  public:
-  using BindingCallback = std::string (*)(const std::string&, void* user_data);
+  using SendMessageSyncCallback = std::string (*)(const std::string&,
+                                                  void* user_data);
 
   class Configuration {
    public:
@@ -62,7 +63,7 @@ class LWNODE_EXPORT Runtime {
     Configuration& operator=(const Configuration& t) = delete;
     Configuration& operator=(Configuration&&);
 
-    void SetBindingCallback(BindingCallback callback, void* user_data);
+    void OnSendMessageSync(SendMessageSyncCallback callback, void* user_data);
 
    private:
     struct Internal;

include/lwnode/lwnode.h

@@ -40,8 +40,8 @@ enum ContextEmbedderIndex {
   // Others are listed in deps/node/src/node_context_data.h.
   kMainMessagePort = 90,
   kLoopHolder = 91,
-  kBindingCallback = 92,
-  kBindingCallbackData = 93,
+  kSendMessageSyncCallback = 92,
+  kSendMessageSyncCallbackData = 93,
 };
 
 void InitializeProcessMethods(v8::Local<v8::Object> target,

src/lwnode/lwnode.cc

@@ -241,28 +241,29 @@ static ValueRef* Unref(ExecutionStateRef* state,
   return ValueRef::create(loop_holder->ref_count());
 }
 
-static ValueRef* Binding(ExecutionStateRef* state,
-                         ValueRef* this_value,
-                         size_t argc,
-                         ValueRef** argv,
-                         bool isConstructCall) {
+static ValueRef* SendMessageSync(ExecutionStateRef* state,
+                                 ValueRef* this_value,
+                                 size_t argc,
+                                 ValueRef** argv,
+                                 bool isConstructCall) {
   std::string message;
   if (argc > 0 && argv[0]->isString()) {
     message = argv[0]->asString()->toStdUTF8String();
   }
 
   ContextWrap* lwContext = ContextWrap::fromEscargot(state->context());
-  lwnode::Runtime::BindingCallback callback =
-      reinterpret_cast<lwnode::Runtime::BindingCallback>(
-          lwContext->GetAlignedPointerFromEmbedderData(kBindingCallback));
+  lwnode::Runtime::SendMessageSyncCallback callback =
+      reinterpret_cast<lwnode::Runtime::SendMessageSyncCallback>(
+          lwContext->GetAlignedPointerFromEmbedderData(
+              kSendMessageSyncCallback));
+  if (!callback) {
+    return ValueRef::createUndefined();
+  }
 
-  void* data =
-      lwContext->GetAlignedPointerFromEmbedderData(kBindingCallbackData);
+  void* data = lwContext->GetAlignedPointerFromEmbedderData(
+      kSendMessageSyncCallbackData);
 
-  std::string response;
-  if (callback) {
-    response = callback(message, data);
-  }
+  std::string response = callback(message, data);
 
   return StringRef::createFromUTF8(response.c_str(), response.length());
 }
@@ -305,7 +306,7 @@ void InitializeProcessMethods(Local<Object> target, Local<Context> context) {
   SetMethod(esContext, esTarget, "ref", Ref);
   SetMethod(esContext, esTarget, "unref", Unref);
 
-  SetMethod(esContext, esTarget, "binding", Binding);
+  SetMethod(esContext, esTarget, "sendMessageSync", SendMessageSync);
 
   ModuleMessagePortInit(esContext, esTarget);
 }

test/embedding/CMakeLists.txt

@@ -15,4 +15,4 @@ endif()
 
 add_executable(embedtest.x embedtest.cc)
 add_executable(example.x example.cc)
-add_executable(binding.x binding.cc)
+add_executable(send-message-sync.x send-message-sync.cc)

test/embedding/binding.cc renamed to test/embedding/send-message-sync.cc

@@ -1,10 +1,10 @@
+#include <lwnode-public.h>
+#include <message-port.h>
 #include <filesystem>
 #include <future>
 #include <iostream>
-#include <thread>
 #include <memory>
-#include <lwnode-public.h>
-#include <message-port.h>
+#include <thread>
 
 #define COUNT_OF(array) (sizeof(array) / sizeof((array)[0]))
 
@@ -27,16 +27,13 @@ int main(int argc, char* argv[]) {
   std::shared_ptr<Info> info = std::make_shared<Info>("John", "30", "male");
 
   lwnode::Runtime::Configuration configuration;
-  configuration.SetBindingCallback(
+  configuration.OnSendMessageSync(
       [](const std::string& message, void* user_data) -> std::string {
         Info* info = static_cast<Info*>(user_data);
-        
-        if (message == "name")
-          return info->GetName();
-        if (message == "age")
-          return info->GetAge();
-        if (message == "gender")
-          return info->GetGender();
+
+        if (message == "name") return info->GetName();
+        if (message == "age") return info->GetAge();
+        if (message == "gender") return info->GetGender();
 
         return "";
       },
@@ -46,7 +43,7 @@ int main(int argc, char* argv[]) {
 
   std::promise<void> promise;
   std::future<void> init_future = promise.get_future();
-  const char* script = "test/embedding/test-10-binding-basic.js";
+  const char* script = "test/embedding/test-10-send-message-sync-basic.js";
   std::string path = (std::filesystem::current_path() / script).string();
   char* args[] = {const_cast<char*>(""), const_cast<char*>(path.c_str())};
 

test/embedding/test-10-binding-basic.js renamed to test/embedding/test-10-send-message-sync-basic.js

@@ -1,25 +1,22 @@
 const lwnode = process.lwnode;
 const port = process.lwnode.port;
 
-lwnode.ref();
-
 port.onmessage = (event) => {
     console.log(`${event.data}`);
     if (event.data == "ping") {
         port.postMessage("pong");
-        lwnode.unref();
     }
 };
 
 function printMessage() {
     console.log("printMessage called--------------------------------------------");
-    const name = lwnode.binding('name');
+    const name = lwnode.sendMessageSync('name');
     console.log(`Hello, ${name}!`);
 
-    const age = lwnode.binding('age');
+    const age = lwnode.sendMessageSync('age');
     console.log(`I am ${age} years old.`);
 
-    const gender = lwnode.binding('gender');
+    const gender = lwnode.sendMessageSync('gender');
     console.log(`My gender is ${gender}.`);
 }