2014-10-31 18:17:05 +00:00
|
|
|
// Copyright (c) 2013 GitHub, Inc.
|
2014-04-25 09:49:37 +00:00
|
|
|
// Use of this source code is governed by the MIT license that can be
|
2013-04-13 10:39:09 +00:00
|
|
|
// found in the LICENSE file.
|
|
|
|
|
2021-11-22 07:34:31 +00:00
|
|
|
#ifndef ELECTRON_SHELL_COMMON_NODE_BINDINGS_H_
|
|
|
|
#define ELECTRON_SHELL_COMMON_NODE_BINDINGS_H_
|
2013-04-13 10:39:09 +00:00
|
|
|
|
2022-10-20 05:49:49 +00:00
|
|
|
#include <string>
|
2020-09-14 00:53:50 +00:00
|
|
|
#include <type_traits>
|
2022-10-20 05:49:49 +00:00
|
|
|
#include <vector>
|
2020-09-14 00:53:50 +00:00
|
|
|
|
2018-08-21 18:05:45 +00:00
|
|
|
#include "base/files/file_path.h"
|
2014-01-08 03:55:54 +00:00
|
|
|
#include "base/memory/weak_ptr.h"
|
2020-04-24 19:57:41 +00:00
|
|
|
#include "uv.h" // NOLINT(build/include_directory)
|
2013-12-15 06:20:28 +00:00
|
|
|
#include "v8/include/v8.h"
|
2013-04-13 10:39:09 +00:00
|
|
|
|
2013-07-22 06:58:25 +00:00
|
|
|
namespace base {
|
2021-07-02 00:51:37 +00:00
|
|
|
class SingleThreadTaskRunner;
|
2013-07-22 06:58:25 +00:00
|
|
|
}
|
|
|
|
|
2013-12-15 06:20:28 +00:00
|
|
|
namespace node {
|
|
|
|
class Environment;
|
2018-01-06 15:58:24 +00:00
|
|
|
class MultiIsolatePlatform;
|
2019-11-02 22:14:11 +00:00
|
|
|
class IsolateData;
|
2018-04-18 01:44:10 +00:00
|
|
|
} // namespace node
|
2013-12-15 06:20:28 +00:00
|
|
|
|
2019-06-19 21:23:04 +00:00
|
|
|
namespace electron {
|
2013-04-13 10:39:09 +00:00
|
|
|
|
2020-09-14 00:53:50 +00:00
|
|
|
// A helper class to manage uv_handle_t types, e.g. uv_async_t.
|
|
|
|
//
|
|
|
|
// As per the uv docs: "uv_close() MUST be called on each handle before
|
|
|
|
// memory is released. Moreover, the memory can only be released in
|
|
|
|
// close_cb or after it has returned." This class encapsulates the work
|
|
|
|
// needed to follow those requirements.
|
|
|
|
template <typename T,
|
|
|
|
typename std::enable_if<
|
|
|
|
// these are the C-style 'subclasses' of uv_handle_t
|
|
|
|
std::is_same<T, uv_async_t>::value ||
|
|
|
|
std::is_same<T, uv_check_t>::value ||
|
|
|
|
std::is_same<T, uv_fs_event_t>::value ||
|
|
|
|
std::is_same<T, uv_fs_poll_t>::value ||
|
|
|
|
std::is_same<T, uv_idle_t>::value ||
|
|
|
|
std::is_same<T, uv_pipe_t>::value ||
|
|
|
|
std::is_same<T, uv_poll_t>::value ||
|
|
|
|
std::is_same<T, uv_prepare_t>::value ||
|
|
|
|
std::is_same<T, uv_process_t>::value ||
|
|
|
|
std::is_same<T, uv_signal_t>::value ||
|
|
|
|
std::is_same<T, uv_stream_t>::value ||
|
|
|
|
std::is_same<T, uv_tcp_t>::value ||
|
|
|
|
std::is_same<T, uv_timer_t>::value ||
|
|
|
|
std::is_same<T, uv_tty_t>::value ||
|
|
|
|
std::is_same<T, uv_udp_t>::value>::type* = nullptr>
|
|
|
|
class UvHandle {
|
|
|
|
public:
|
|
|
|
UvHandle() : t_(new T) {}
|
|
|
|
~UvHandle() { reset(); }
|
|
|
|
T* get() { return t_; }
|
|
|
|
uv_handle_t* handle() { return reinterpret_cast<uv_handle_t*>(t_); }
|
|
|
|
|
|
|
|
void reset() {
|
|
|
|
auto* h = handle();
|
|
|
|
if (h != nullptr) {
|
|
|
|
DCHECK_EQ(0, uv_is_closing(h));
|
|
|
|
uv_close(h, OnClosed);
|
|
|
|
t_ = nullptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
static void OnClosed(uv_handle_t* handle) {
|
|
|
|
delete reinterpret_cast<T*>(handle);
|
|
|
|
}
|
|
|
|
|
|
|
|
T* t_ = {};
|
|
|
|
};
|
|
|
|
|
2013-04-13 10:39:09 +00:00
|
|
|
class NodeBindings {
|
|
|
|
public:
|
2022-10-20 05:49:49 +00:00
|
|
|
enum class BrowserEnvironment { kBrowser, kRenderer, kUtility, kWorker };
|
2017-03-08 08:33:44 +00:00
|
|
|
|
|
|
|
static NodeBindings* Create(BrowserEnvironment browser_env);
|
2023-02-09 01:31:38 +00:00
|
|
|
static void RegisterBuiltinBindings();
|
2018-06-13 07:38:31 +00:00
|
|
|
static bool IsInitialized();
|
2013-04-13 15:05:13 +00:00
|
|
|
|
2013-04-13 10:39:09 +00:00
|
|
|
virtual ~NodeBindings();
|
|
|
|
|
2013-12-15 06:20:28 +00:00
|
|
|
// Setup V8, libuv.
|
2023-02-22 09:03:46 +00:00
|
|
|
void Initialize(v8::Local<v8::Context> context);
|
2013-04-13 15:05:13 +00:00
|
|
|
|
2022-11-10 21:31:20 +00:00
|
|
|
void SetNodeCliFlags();
|
|
|
|
|
2013-12-15 06:20:28 +00:00
|
|
|
// Create the environment and load node.js.
|
2022-10-20 05:49:49 +00:00
|
|
|
node::Environment* CreateEnvironment(v8::Handle<v8::Context> context,
|
|
|
|
node::MultiIsolatePlatform* platform,
|
|
|
|
std::vector<std::string> args,
|
|
|
|
std::vector<std::string> exec_args);
|
2019-07-18 23:54:23 +00:00
|
|
|
node::Environment* CreateEnvironment(v8::Handle<v8::Context> context,
|
2020-02-25 16:46:08 +00:00
|
|
|
node::MultiIsolatePlatform* platform);
|
2013-04-20 03:13:06 +00:00
|
|
|
|
2015-01-21 22:00:19 +00:00
|
|
|
// Load node.js in the environment.
|
|
|
|
void LoadEnvironment(node::Environment* env);
|
|
|
|
|
2022-03-30 03:09:42 +00:00
|
|
|
// Prepare embed thread for message loop integration.
|
|
|
|
void PrepareEmbedThread();
|
2013-04-13 15:05:13 +00:00
|
|
|
|
2022-03-30 03:09:42 +00:00
|
|
|
// Notify embed thread to start polling after environment is loaded.
|
|
|
|
void StartPolling();
|
2013-04-13 15:05:13 +00:00
|
|
|
|
2022-03-21 07:42:22 +00:00
|
|
|
// Gets/sets the per isolate data.
|
|
|
|
void set_isolate_data(node::IsolateData* isolate_data) {
|
|
|
|
isolate_data_ = isolate_data;
|
|
|
|
}
|
2019-11-02 22:14:11 +00:00
|
|
|
node::IsolateData* isolate_data() const { return isolate_data_; }
|
|
|
|
|
2014-01-09 13:35:29 +00:00
|
|
|
// Gets/sets the environment to wrap uv loop.
|
|
|
|
void set_uv_env(node::Environment* env) { uv_env_ = env; }
|
2014-01-10 08:29:38 +00:00
|
|
|
node::Environment* uv_env() const { return uv_env_; }
|
2014-01-09 13:35:29 +00:00
|
|
|
|
2017-03-10 08:07:51 +00:00
|
|
|
uv_loop_t* uv_loop() const { return uv_loop_; }
|
|
|
|
|
2020-07-08 18:00:43 +00:00
|
|
|
bool in_worker_loop() const { return uv_loop_ == &worker_loop_; }
|
|
|
|
|
2021-11-03 11:41:45 +00:00
|
|
|
// disable copy
|
|
|
|
NodeBindings(const NodeBindings&) = delete;
|
|
|
|
NodeBindings& operator=(const NodeBindings&) = delete;
|
|
|
|
|
2013-04-13 15:05:13 +00:00
|
|
|
protected:
|
2017-03-08 08:33:44 +00:00
|
|
|
explicit NodeBindings(BrowserEnvironment browser_env);
|
2013-04-13 10:39:09 +00:00
|
|
|
|
2013-07-22 06:58:25 +00:00
|
|
|
// Called to poll events in new thread.
|
|
|
|
virtual void PollEvents() = 0;
|
|
|
|
|
|
|
|
// Run the libuv loop for once.
|
|
|
|
void UvRunOnce();
|
|
|
|
|
|
|
|
// Make the main thread run libuv loop.
|
|
|
|
void WakeupMainThread();
|
|
|
|
|
2013-07-23 05:08:40 +00:00
|
|
|
// Interrupt the PollEvents.
|
|
|
|
void WakeupEmbedThread();
|
|
|
|
|
2017-03-08 08:33:44 +00:00
|
|
|
// Which environment we are running.
|
2019-05-03 18:11:41 +00:00
|
|
|
const BrowserEnvironment browser_env_;
|
2013-04-13 13:10:41 +00:00
|
|
|
|
2017-03-10 08:07:51 +00:00
|
|
|
// Current thread's MessageLoop.
|
2016-11-30 07:30:03 +00:00
|
|
|
scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
|
2013-07-22 06:58:25 +00:00
|
|
|
|
2017-03-10 08:07:51 +00:00
|
|
|
// Current thread's libuv loop.
|
2013-07-22 06:58:25 +00:00
|
|
|
uv_loop_t* uv_loop_;
|
|
|
|
|
2013-07-22 07:25:39 +00:00
|
|
|
private:
|
|
|
|
// Thread to poll uv events.
|
2018-04-18 01:44:10 +00:00
|
|
|
static void EmbedThreadRunner(void* arg);
|
2013-07-22 07:25:39 +00:00
|
|
|
|
2022-03-30 03:09:42 +00:00
|
|
|
// Indicates whether polling thread has been created.
|
|
|
|
bool initialized_ = false;
|
|
|
|
|
2013-07-22 07:25:39 +00:00
|
|
|
// Whether the libuv loop has ended.
|
2018-05-21 22:18:38 +00:00
|
|
|
bool embed_closed_ = false;
|
2013-07-22 07:25:39 +00:00
|
|
|
|
2018-01-04 19:16:06 +00:00
|
|
|
// Loop used when constructed in WORKER mode
|
|
|
|
uv_loop_t worker_loop_;
|
|
|
|
|
2013-07-22 06:58:25 +00:00
|
|
|
// Dummy handle to make uv's loop not quit.
|
2020-09-14 00:53:50 +00:00
|
|
|
UvHandle<uv_async_t> dummy_uv_handle_;
|
2013-07-22 06:58:25 +00:00
|
|
|
|
|
|
|
// Thread for polling events.
|
|
|
|
uv_thread_t embed_thread_;
|
|
|
|
|
|
|
|
// Semaphore to wait for main loop in the embed thread.
|
|
|
|
uv_sem_t embed_sem_;
|
|
|
|
|
2014-01-09 13:35:29 +00:00
|
|
|
// Environment that to wrap the uv loop.
|
2018-05-21 22:18:38 +00:00
|
|
|
node::Environment* uv_env_ = nullptr;
|
2014-01-09 13:35:29 +00:00
|
|
|
|
2019-11-02 22:14:11 +00:00
|
|
|
// Isolate data used in creating the environment
|
|
|
|
node::IsolateData* isolate_data_ = nullptr;
|
|
|
|
|
2021-01-26 18:16:21 +00:00
|
|
|
base::WeakPtrFactory<NodeBindings> weak_factory_{this};
|
2013-04-13 10:39:09 +00:00
|
|
|
};
|
|
|
|
|
2019-06-19 21:23:04 +00:00
|
|
|
} // namespace electron
|
2013-04-13 10:39:09 +00:00
|
|
|
|
2021-11-22 07:34:31 +00:00
|
|
|
#endif // ELECTRON_SHELL_COMMON_NODE_BINDINGS_H_
|