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.
|
|
|
|
|
2014-03-16 00:30:26 +00:00
|
|
|
#include "atom/common/node_bindings.h"
|
2013-04-13 10:39:09 +00:00
|
|
|
|
2018-01-22 22:49:30 +00:00
|
|
|
#include <algorithm>
|
2018-09-13 00:25:56 +00:00
|
|
|
#include <memory>
|
2014-03-16 01:13:06 +00:00
|
|
|
#include <string>
|
2018-10-18 23:57:28 +00:00
|
|
|
#include <utility>
|
2014-03-16 01:13:06 +00:00
|
|
|
#include <vector>
|
|
|
|
|
2015-08-07 11:34:00 +00:00
|
|
|
#include "atom/common/api/event_emitter_caller.h"
|
|
|
|
#include "atom/common/api/locker.h"
|
2015-06-19 15:11:53 +00:00
|
|
|
#include "atom/common/atom_command_line.h"
|
2015-02-13 05:32:58 +00:00
|
|
|
#include "atom/common/native_mate_converters/file_path_converter.h"
|
2019-03-12 00:13:43 +00:00
|
|
|
#include "atom/common/node_includes.h"
|
2013-12-11 15:59:03 +00:00
|
|
|
#include "base/base_paths.h"
|
2016-08-26 22:30:02 +00:00
|
|
|
#include "base/command_line.h"
|
2015-11-06 10:51:34 +00:00
|
|
|
#include "base/environment.h"
|
2013-12-11 15:59:03 +00:00
|
|
|
#include "base/path_service.h"
|
2016-11-30 07:30:03 +00:00
|
|
|
#include "base/run_loop.h"
|
2018-10-18 23:57:28 +00:00
|
|
|
#include "base/strings/string_split.h"
|
2018-01-22 22:49:30 +00:00
|
|
|
#include "base/strings/utf_string_conversions.h"
|
2016-11-30 07:30:03 +00:00
|
|
|
#include "base/threading/thread_task_runner_handle.h"
|
2016-12-07 11:22:08 +00:00
|
|
|
#include "base/trace_event/trace_event.h"
|
2013-07-22 06:58:25 +00:00
|
|
|
#include "content/public/browser/browser_thread.h"
|
2015-04-14 06:05:30 +00:00
|
|
|
#include "content/public/common/content_paths.h"
|
2018-10-01 20:00:53 +00:00
|
|
|
#include "electron/buildflags/buildflags.h"
|
2015-02-13 05:32:58 +00:00
|
|
|
#include "native_mate/dictionary.h"
|
2013-04-13 10:39:09 +00:00
|
|
|
|
2018-01-06 15:58:24 +00:00
|
|
|
#define ELECTRON_BUILTIN_MODULES(V) \
|
|
|
|
V(atom_browser_app) \
|
|
|
|
V(atom_browser_auto_updater) \
|
|
|
|
V(atom_browser_browser_view) \
|
|
|
|
V(atom_browser_content_tracing) \
|
|
|
|
V(atom_browser_debugger) \
|
|
|
|
V(atom_browser_dialog) \
|
|
|
|
V(atom_browser_download_item) \
|
2018-10-18 03:36:45 +00:00
|
|
|
V(atom_browser_event) \
|
2018-01-06 15:58:24 +00:00
|
|
|
V(atom_browser_global_shortcut) \
|
|
|
|
V(atom_browser_in_app_purchase) \
|
|
|
|
V(atom_browser_menu) \
|
|
|
|
V(atom_browser_net) \
|
|
|
|
V(atom_browser_power_monitor) \
|
|
|
|
V(atom_browser_power_save_blocker) \
|
|
|
|
V(atom_browser_protocol) \
|
|
|
|
V(atom_browser_render_process_preferences) \
|
|
|
|
V(atom_browser_session) \
|
|
|
|
V(atom_browser_system_preferences) \
|
2018-04-14 02:04:23 +00:00
|
|
|
V(atom_browser_top_level_window) \
|
2018-01-06 15:58:24 +00:00
|
|
|
V(atom_browser_tray) \
|
|
|
|
V(atom_browser_web_contents) \
|
2018-05-07 07:04:33 +00:00
|
|
|
V(atom_browser_web_contents_view) \
|
2018-05-07 05:52:25 +00:00
|
|
|
V(atom_browser_view) \
|
2018-01-06 15:58:24 +00:00
|
|
|
V(atom_browser_web_view_manager) \
|
|
|
|
V(atom_browser_window) \
|
|
|
|
V(atom_common_asar) \
|
|
|
|
V(atom_common_clipboard) \
|
2019-01-03 16:22:34 +00:00
|
|
|
V(atom_common_command_line) \
|
2018-01-06 15:58:24 +00:00
|
|
|
V(atom_common_crash_reporter) \
|
2018-03-15 13:56:25 +00:00
|
|
|
V(atom_common_features) \
|
2018-01-06 15:58:24 +00:00
|
|
|
V(atom_common_native_image) \
|
|
|
|
V(atom_common_notification) \
|
|
|
|
V(atom_common_screen) \
|
|
|
|
V(atom_common_shell) \
|
|
|
|
V(atom_common_v8_util) \
|
|
|
|
V(atom_renderer_ipc) \
|
|
|
|
V(atom_renderer_web_frame)
|
|
|
|
|
2018-05-24 06:35:50 +00:00
|
|
|
#define ELECTRON_VIEW_MODULES(V) \
|
|
|
|
V(atom_browser_box_layout) \
|
2018-05-24 07:56:02 +00:00
|
|
|
V(atom_browser_button) \
|
2018-05-24 08:11:08 +00:00
|
|
|
V(atom_browser_label_button) \
|
2018-05-24 07:26:17 +00:00
|
|
|
V(atom_browser_layout_manager) \
|
2018-10-23 14:57:13 +00:00
|
|
|
V(atom_browser_md_text_button) \
|
2018-11-21 13:39:59 +00:00
|
|
|
V(atom_browser_resize_area) \
|
2018-05-24 07:26:17 +00:00
|
|
|
V(atom_browser_text_field)
|
2018-05-24 06:35:50 +00:00
|
|
|
|
2018-06-13 16:15:34 +00:00
|
|
|
#define ELECTRON_DESKTOP_CAPTURER_MODULE(V) V(atom_browser_desktop_capturer)
|
|
|
|
|
2018-01-06 15:58:24 +00:00
|
|
|
// This is used to load built-in modules. Instead of using
|
|
|
|
// __attribute__((constructor)), we call the _register_<modname>
|
|
|
|
// function for each built-in modules explicitly. This is only
|
|
|
|
// forward declaration. The definitions are in each module's
|
2019-03-08 18:29:52 +00:00
|
|
|
// implementation when calling the NODE_LINKED_MODULE_CONTEXT_AWARE.
|
2018-01-06 15:58:24 +00:00
|
|
|
#define V(modname) void _register_##modname();
|
|
|
|
ELECTRON_BUILTIN_MODULES(V)
|
2018-10-01 20:00:53 +00:00
|
|
|
#if BUILDFLAG(ENABLE_VIEW_API)
|
2018-05-24 06:35:50 +00:00
|
|
|
ELECTRON_VIEW_MODULES(V)
|
|
|
|
#endif
|
2018-10-01 20:00:53 +00:00
|
|
|
#if BUILDFLAG(ENABLE_DESKTOP_CAPTURER)
|
2018-06-13 16:15:34 +00:00
|
|
|
ELECTRON_DESKTOP_CAPTURER_MODULE(V)
|
|
|
|
#endif
|
2018-01-06 15:58:24 +00:00
|
|
|
#undef V
|
2014-06-29 10:12:46 +00:00
|
|
|
|
2018-01-04 19:16:06 +00:00
|
|
|
namespace {
|
|
|
|
|
|
|
|
void stop_and_close_uv_loop(uv_loop_t* loop) {
|
|
|
|
// Close any active handles
|
|
|
|
uv_stop(loop);
|
2018-04-18 01:55:30 +00:00
|
|
|
uv_walk(loop,
|
|
|
|
[](uv_handle_t* handle, void*) {
|
|
|
|
if (!uv_is_closing(handle)) {
|
|
|
|
uv_close(handle, nullptr);
|
|
|
|
}
|
|
|
|
},
|
|
|
|
nullptr);
|
2018-01-04 19:16:06 +00:00
|
|
|
|
|
|
|
// Run the loop to let it finish all the closing handles
|
|
|
|
// NB: after uv_stop(), uv_run(UV_RUN_DEFAULT) returns 0 when that's done
|
|
|
|
for (;;)
|
|
|
|
if (!uv_run(loop, UV_RUN_DEFAULT))
|
|
|
|
break;
|
|
|
|
|
|
|
|
DCHECK(!uv_loop_alive(loop));
|
|
|
|
uv_loop_close(loop);
|
|
|
|
}
|
|
|
|
|
2018-06-13 07:38:31 +00:00
|
|
|
bool g_is_initialized = false;
|
|
|
|
|
2018-01-04 19:16:06 +00:00
|
|
|
} // namespace
|
|
|
|
|
2013-04-13 10:39:09 +00:00
|
|
|
namespace atom {
|
|
|
|
|
2013-07-22 06:58:25 +00:00
|
|
|
namespace {
|
|
|
|
|
2015-03-29 11:53:47 +00:00
|
|
|
// Convert the given vector to an array of C-strings. The strings in the
|
|
|
|
// returned vector are only guaranteed valid so long as the vector of strings
|
|
|
|
// is not modified.
|
2018-04-18 01:55:30 +00:00
|
|
|
std::unique_ptr<const char* []> StringVectorToArgArray(
|
2015-03-29 11:53:47 +00:00
|
|
|
const std::vector<std::string>& vector) {
|
2019-04-30 20:59:47 +00:00
|
|
|
std::unique_ptr<const char*[]> array(new const char*[vector.size()]);
|
2015-03-29 11:53:47 +00:00
|
|
|
for (size_t i = 0; i < vector.size(); ++i) {
|
|
|
|
array[i] = vector[i].c_str();
|
|
|
|
}
|
2016-03-08 14:28:53 +00:00
|
|
|
return array;
|
2015-03-29 11:53:47 +00:00
|
|
|
}
|
|
|
|
|
2015-03-29 11:59:16 +00:00
|
|
|
base::FilePath GetResourcesPath(bool is_browser) {
|
2018-04-17 22:41:47 +00:00
|
|
|
auto* command_line = base::CommandLine::ForCurrentProcess();
|
2015-03-29 11:59:16 +00:00
|
|
|
base::FilePath exec_path(command_line->GetProgram());
|
2018-09-15 00:09:42 +00:00
|
|
|
base::PathService::Get(base::FILE_EXE, &exec_path);
|
2015-03-29 11:59:16 +00:00
|
|
|
|
2015-02-13 05:32:58 +00:00
|
|
|
base::FilePath resources_path =
|
|
|
|
#if defined(OS_MACOSX)
|
2018-04-18 01:55:30 +00:00
|
|
|
is_browser
|
|
|
|
? exec_path.DirName().DirName().Append("Resources")
|
|
|
|
: exec_path.DirName().DirName().DirName().DirName().DirName().Append(
|
|
|
|
"Resources");
|
2015-02-13 05:32:58 +00:00
|
|
|
#else
|
|
|
|
exec_path.DirName().Append(FILE_PATH_LITERAL("resources"));
|
|
|
|
#endif
|
|
|
|
return resources_path;
|
|
|
|
}
|
|
|
|
|
2013-07-22 06:58:25 +00:00
|
|
|
} // namespace
|
|
|
|
|
2017-03-08 08:33:44 +00:00
|
|
|
NodeBindings::NodeBindings(BrowserEnvironment browser_env)
|
2018-05-21 22:18:38 +00:00
|
|
|
: browser_env_(browser_env), weak_factory_(this) {
|
2019-05-03 18:11:41 +00:00
|
|
|
if (browser_env == BrowserEnvironment::WORKER) {
|
2018-01-04 19:16:06 +00:00
|
|
|
uv_loop_init(&worker_loop_);
|
|
|
|
uv_loop_ = &worker_loop_;
|
|
|
|
} else {
|
|
|
|
uv_loop_ = uv_default_loop();
|
|
|
|
}
|
2013-04-13 10:39:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
NodeBindings::~NodeBindings() {
|
2013-11-11 08:57:40 +00:00
|
|
|
// Quit the embed thread.
|
2013-07-22 06:58:25 +00:00
|
|
|
embed_closed_ = true;
|
2013-11-11 08:57:40 +00:00
|
|
|
uv_sem_post(&embed_sem_);
|
2013-07-23 08:55:09 +00:00
|
|
|
WakeupEmbedThread();
|
2013-11-11 08:57:40 +00:00
|
|
|
|
|
|
|
// Wait for everything to be done.
|
2013-07-22 06:58:25 +00:00
|
|
|
uv_thread_join(&embed_thread_);
|
2013-11-11 08:57:40 +00:00
|
|
|
|
|
|
|
// Clear uv.
|
2013-07-22 06:58:25 +00:00
|
|
|
uv_sem_destroy(&embed_sem_);
|
2017-02-28 01:58:52 +00:00
|
|
|
uv_close(reinterpret_cast<uv_handle_t*>(&dummy_uv_handle_), nullptr);
|
2017-03-10 08:07:51 +00:00
|
|
|
|
2018-01-04 19:16:06 +00:00
|
|
|
// Clean up worker loop
|
|
|
|
if (uv_loop_ == &worker_loop_)
|
|
|
|
stop_and_close_uv_loop(uv_loop_);
|
2013-04-13 10:39:09 +00:00
|
|
|
}
|
|
|
|
|
2018-01-06 15:58:24 +00:00
|
|
|
void NodeBindings::RegisterBuiltinModules() {
|
|
|
|
#define V(modname) _register_##modname();
|
|
|
|
ELECTRON_BUILTIN_MODULES(V)
|
2018-10-01 20:00:53 +00:00
|
|
|
#if BUILDFLAG(ENABLE_VIEW_API)
|
2018-05-24 06:35:50 +00:00
|
|
|
ELECTRON_VIEW_MODULES(V)
|
|
|
|
#endif
|
2018-10-01 20:00:53 +00:00
|
|
|
#if BUILDFLAG(ENABLE_DESKTOP_CAPTURER)
|
2018-06-13 16:15:34 +00:00
|
|
|
ELECTRON_DESKTOP_CAPTURER_MODULE(V)
|
|
|
|
#endif
|
2018-01-06 15:58:24 +00:00
|
|
|
#undef V
|
|
|
|
}
|
|
|
|
|
2018-06-13 07:38:31 +00:00
|
|
|
bool NodeBindings::IsInitialized() {
|
|
|
|
return g_is_initialized;
|
|
|
|
}
|
|
|
|
|
2018-08-21 18:05:45 +00:00
|
|
|
base::FilePath::StringType NodeBindings::GetHelperResourcesPath() {
|
|
|
|
return GetResourcesPath(false).value();
|
|
|
|
}
|
|
|
|
|
2013-04-13 10:39:09 +00:00
|
|
|
void NodeBindings::Initialize() {
|
2019-04-29 22:28:30 +00:00
|
|
|
TRACE_EVENT0("electron", "NodeBindings::Initialize");
|
2013-12-15 06:20:28 +00:00
|
|
|
// Open node's error reporting system for browser process.
|
2019-05-03 18:11:41 +00:00
|
|
|
node::g_standalone_mode = browser_env_ == BrowserEnvironment::BROWSER;
|
2013-12-15 06:20:28 +00:00
|
|
|
node::g_upstream_node_mode = false;
|
2013-07-01 13:44:25 +00:00
|
|
|
|
2015-06-19 14:56:10 +00:00
|
|
|
#if defined(OS_LINUX)
|
|
|
|
// Get real command line in renderer process forked by zygote.
|
2019-05-03 18:11:41 +00:00
|
|
|
if (browser_env_ != BrowserEnvironment::BROWSER)
|
2015-06-19 14:56:10 +00:00
|
|
|
AtomCommandLine::InitializeFromCommandLine();
|
|
|
|
#endif
|
|
|
|
|
2018-01-06 15:58:24 +00:00
|
|
|
// Explicitly register electron's builtin modules.
|
|
|
|
RegisterBuiltinModules();
|
|
|
|
|
2018-10-18 23:57:28 +00:00
|
|
|
// pass non-null program name to argv so it doesn't crash
|
|
|
|
// trying to index into a nullptr
|
|
|
|
int argc = 1;
|
2018-09-18 00:48:10 +00:00
|
|
|
int exec_argc = 0;
|
2018-10-18 23:57:28 +00:00
|
|
|
const char* prog_name = "electron";
|
|
|
|
const char** argv = &prog_name;
|
2018-09-18 00:48:10 +00:00
|
|
|
const char** exec_argv = nullptr;
|
2018-10-18 23:57:28 +00:00
|
|
|
|
|
|
|
std::unique_ptr<base::Environment> env(base::Environment::Create());
|
|
|
|
if (env->HasVar("NODE_OPTIONS")) {
|
|
|
|
base::FilePath exe_path;
|
|
|
|
base::PathService::Get(base::FILE_EXE, &exe_path);
|
2018-10-19 02:11:43 +00:00
|
|
|
#if defined(OS_WIN)
|
|
|
|
std::string path = base::UTF16ToUTF8(exe_path.value());
|
|
|
|
#else
|
2018-10-18 23:57:28 +00:00
|
|
|
std::string path = exe_path.value();
|
2018-10-19 02:11:43 +00:00
|
|
|
#endif
|
2018-10-18 23:57:28 +00:00
|
|
|
std::transform(path.begin(), path.end(), path.begin(), ::tolower);
|
|
|
|
|
|
|
|
#if defined(OS_WIN)
|
|
|
|
const bool is_packaged_app = path == "electron.exe";
|
|
|
|
#else
|
|
|
|
const bool is_packaged_app = path == "electron";
|
|
|
|
#endif
|
|
|
|
|
|
|
|
// explicitly disallow NODE_OPTIONS in packaged apps
|
|
|
|
if (is_packaged_app) {
|
|
|
|
LOG(WARNING) << "NODE_OPTIONs are not supported in packaged apps";
|
|
|
|
env->SetVar("NODE_OPTIONS", "");
|
|
|
|
} else {
|
|
|
|
const std::vector<std::string> disallowed = {
|
|
|
|
"--openssl-config", "--use-bundled-ca", "--use-openssl-ca",
|
|
|
|
"--force-fips", "--enable-fips"};
|
|
|
|
|
|
|
|
std::string options;
|
|
|
|
env->GetVar("NODE_OPTIONS", &options);
|
|
|
|
std::vector<std::string> parts = base::SplitString(
|
|
|
|
options, " ", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
|
|
|
|
|
|
|
|
// parse passed options for unsupported options
|
|
|
|
// and remove them from the options list
|
|
|
|
std::string new_options = options;
|
|
|
|
for (const auto& disallow : disallowed) {
|
|
|
|
for (const auto& part : parts) {
|
|
|
|
if (part.find(disallow) != std::string::npos) {
|
|
|
|
LOG(WARNING) << "The NODE_OPTION" << disallow
|
|
|
|
<< "is not supported in Electron";
|
|
|
|
new_options.erase(new_options.find(part), part.length());
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// overwrite new NODE_OPTIONS without unsupported variables
|
|
|
|
if (new_options != options)
|
|
|
|
env->SetVar("NODE_OPTIONS", new_options);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// TODO(codebytere): this is going to be deprecated in the near future
|
|
|
|
// in favor of Init(std::vector<std::string>* argv,
|
|
|
|
// std::vector<std::string>* exec_argv)
|
2018-09-18 00:48:10 +00:00
|
|
|
node::Init(&argc, argv, &exec_argc, &exec_argv);
|
2015-11-06 10:51:34 +00:00
|
|
|
|
|
|
|
#if defined(OS_WIN)
|
|
|
|
// uv_init overrides error mode to suppress the default crash dialog, bring
|
|
|
|
// it back if user wants to show it.
|
2019-05-03 18:11:41 +00:00
|
|
|
if (browser_env_ == BrowserEnvironment::BROWSER ||
|
|
|
|
env->HasVar("ELECTRON_DEFAULT_ERROR_MODE"))
|
2016-09-16 21:01:33 +00:00
|
|
|
SetErrorMode(GetErrorMode() & ~SEM_NOGPFAULTERRORBOX);
|
2015-11-06 10:51:34 +00:00
|
|
|
#endif
|
2018-06-13 07:38:31 +00:00
|
|
|
|
|
|
|
g_is_initialized = true;
|
2013-12-15 06:20:28 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
node::Environment* NodeBindings::CreateEnvironment(
|
2018-01-31 07:09:13 +00:00
|
|
|
v8::Handle<v8::Context> context,
|
|
|
|
node::MultiIsolatePlatform* platform) {
|
2018-01-22 22:49:30 +00:00
|
|
|
#if defined(OS_WIN)
|
|
|
|
auto& atom_args = AtomCommandLine::argv();
|
|
|
|
std::vector<std::string> args(atom_args.size());
|
|
|
|
std::transform(atom_args.cbegin(), atom_args.cend(), args.begin(),
|
|
|
|
[](auto& a) { return base::WideToUTF8(a); });
|
|
|
|
#else
|
2015-03-17 12:55:53 +00:00
|
|
|
auto args = AtomCommandLine::argv();
|
2018-01-22 22:49:30 +00:00
|
|
|
#endif
|
2013-04-13 10:39:09 +00:00
|
|
|
|
2013-12-11 15:59:03 +00:00
|
|
|
// Feed node the path to initialization script.
|
2019-06-04 00:03:59 +00:00
|
|
|
std::string process_type;
|
2017-03-08 08:33:44 +00:00
|
|
|
switch (browser_env_) {
|
2019-05-03 18:11:41 +00:00
|
|
|
case BrowserEnvironment::BROWSER:
|
2019-06-04 00:03:59 +00:00
|
|
|
process_type = "browser";
|
2017-03-08 08:33:44 +00:00
|
|
|
break;
|
2019-05-03 18:11:41 +00:00
|
|
|
case BrowserEnvironment::RENDERER:
|
2019-06-04 00:03:59 +00:00
|
|
|
process_type = "renderer";
|
2017-03-08 08:33:44 +00:00
|
|
|
break;
|
2019-05-03 18:11:41 +00:00
|
|
|
case BrowserEnvironment::WORKER:
|
2019-06-04 00:03:59 +00:00
|
|
|
process_type = "worker";
|
2017-03-08 08:33:44 +00:00
|
|
|
break;
|
|
|
|
}
|
2019-05-03 18:11:41 +00:00
|
|
|
base::FilePath resources_path =
|
|
|
|
GetResourcesPath(browser_env_ == BrowserEnvironment::BROWSER);
|
2019-06-04 00:03:59 +00:00
|
|
|
std::string init_script = "electron/js2c/" + process_type + "_init";
|
|
|
|
|
|
|
|
args.insert(args.begin() + 1, init_script);
|
2013-12-11 15:59:03 +00:00
|
|
|
|
2019-04-30 20:59:47 +00:00
|
|
|
std::unique_ptr<const char*[]> c_argv = StringVectorToArgArray(args);
|
2015-03-29 11:59:16 +00:00
|
|
|
node::Environment* env = node::CreateEnvironment(
|
2018-01-06 15:58:24 +00:00
|
|
|
node::CreateIsolateData(context->GetIsolate(), uv_loop_, platform),
|
|
|
|
context, args.size(), c_argv.get(), 0, nullptr);
|
2015-02-13 05:32:58 +00:00
|
|
|
|
2019-05-03 18:11:41 +00:00
|
|
|
if (browser_env_ == BrowserEnvironment::BROWSER) {
|
2017-01-25 17:24:24 +00:00
|
|
|
// SetAutorunMicrotasks is no longer called in node::CreateEnvironment
|
|
|
|
// so instead call it here to match expected node behavior
|
|
|
|
context->GetIsolate()->SetMicrotasksPolicy(v8::MicrotasksPolicy::kExplicit);
|
|
|
|
} else {
|
|
|
|
// Node uses the deprecated SetAutorunMicrotasks(false) mode, we should
|
|
|
|
// switch to use the scoped policy to match blink's behavior.
|
2016-08-22 10:34:59 +00:00
|
|
|
context->GetIsolate()->SetMicrotasksPolicy(v8::MicrotasksPolicy::kScoped);
|
|
|
|
}
|
2016-08-03 08:57:10 +00:00
|
|
|
|
2015-02-13 05:32:58 +00:00
|
|
|
mate::Dictionary process(context->GetIsolate(), env->process_object());
|
2018-11-08 14:28:06 +00:00
|
|
|
process.SetReadOnly("type", process_type);
|
2015-02-13 05:32:58 +00:00
|
|
|
process.Set("resourcesPath", resources_path);
|
2016-04-03 06:05:47 +00:00
|
|
|
// Do not set DOM globals for renderer process.
|
2019-05-03 18:11:41 +00:00
|
|
|
if (browser_env_ != BrowserEnvironment::BROWSER)
|
2019-06-04 00:03:59 +00:00
|
|
|
process.Set("_noBrowserGlobals", true);
|
2015-04-14 06:05:30 +00:00
|
|
|
// The path to helper app.
|
|
|
|
base::FilePath helper_exec_path;
|
2018-09-15 00:09:42 +00:00
|
|
|
base::PathService::Get(content::CHILD_PROCESS_EXE, &helper_exec_path);
|
2015-04-14 06:05:30 +00:00
|
|
|
process.Set("helperExecPath", helper_exec_path);
|
2016-08-26 19:06:15 +00:00
|
|
|
|
2015-02-13 05:32:58 +00:00
|
|
|
return env;
|
2013-04-20 03:13:06 +00:00
|
|
|
}
|
|
|
|
|
2015-01-21 22:00:19 +00:00
|
|
|
void NodeBindings::LoadEnvironment(node::Environment* env) {
|
|
|
|
node::LoadEnvironment(env);
|
2015-06-23 12:14:03 +00:00
|
|
|
mate::EmitEvent(env->isolate(), env->process_object(), "loaded");
|
2015-01-21 22:00:19 +00:00
|
|
|
}
|
|
|
|
|
2013-07-22 06:58:25 +00:00
|
|
|
void NodeBindings::PrepareMessageLoop() {
|
|
|
|
// Add dummy handle for libuv, otherwise libuv would quit when there is
|
|
|
|
// nothing to do.
|
2016-08-03 11:48:41 +00:00
|
|
|
uv_async_init(uv_loop_, &dummy_uv_handle_, nullptr);
|
2013-07-22 06:58:25 +00:00
|
|
|
|
|
|
|
// Start worker that will interrupt main loop when having uv events.
|
|
|
|
uv_sem_init(&embed_sem_, 0);
|
|
|
|
uv_thread_create(&embed_thread_, EmbedThreadRunner, this);
|
|
|
|
}
|
|
|
|
|
|
|
|
void NodeBindings::RunMessageLoop() {
|
|
|
|
// The MessageLoop should have been created, remember the one in main thread.
|
2016-11-30 07:30:03 +00:00
|
|
|
task_runner_ = base::ThreadTaskRunnerHandle::Get();
|
2013-07-22 06:58:25 +00:00
|
|
|
|
|
|
|
// Run uv loop for once to give the uv__io_poll a chance to add all events.
|
|
|
|
UvRunOnce();
|
|
|
|
}
|
|
|
|
|
|
|
|
void NodeBindings::UvRunOnce() {
|
2016-03-27 10:21:12 +00:00
|
|
|
node::Environment* env = uv_env();
|
2014-01-27 07:14:11 +00:00
|
|
|
|
2017-03-28 08:19:14 +00:00
|
|
|
// When doing navigation without restarting renderer process, it may happen
|
|
|
|
// that the node environment is destroyed but the message loop is still there.
|
|
|
|
// In this case we should not run uv loop.
|
|
|
|
if (!env)
|
|
|
|
return;
|
|
|
|
|
2014-06-28 14:33:00 +00:00
|
|
|
// Use Locker in browser process.
|
2014-08-10 11:14:20 +00:00
|
|
|
mate::Locker locker(env->isolate());
|
2014-06-28 14:33:00 +00:00
|
|
|
v8::HandleScope handle_scope(env->isolate());
|
2014-01-09 13:35:29 +00:00
|
|
|
|
2014-06-28 14:33:00 +00:00
|
|
|
// Enter node context while dealing with uv events.
|
2014-01-09 13:35:29 +00:00
|
|
|
v8::Context::Scope context_scope(env->context());
|
2013-07-22 06:58:25 +00:00
|
|
|
|
2015-08-07 07:10:14 +00:00
|
|
|
// Perform microtask checkpoint after running JavaScript.
|
2016-06-24 05:45:31 +00:00
|
|
|
v8::MicrotasksScope script_scope(env->isolate(),
|
|
|
|
v8::MicrotasksScope::kRunMicrotasks);
|
2015-08-07 07:10:14 +00:00
|
|
|
|
2019-05-03 18:11:41 +00:00
|
|
|
if (browser_env_ != BrowserEnvironment::BROWSER)
|
2016-12-12 21:49:58 +00:00
|
|
|
TRACE_EVENT_BEGIN0("devtools.timeline", "FunctionCall");
|
2016-12-07 11:22:08 +00:00
|
|
|
|
2013-07-22 06:58:25 +00:00
|
|
|
// Deal with uv events.
|
2015-01-13 00:17:44 +00:00
|
|
|
int r = uv_run(uv_loop_, UV_RUN_NOWAIT);
|
2016-12-07 11:22:08 +00:00
|
|
|
|
2019-05-03 18:11:41 +00:00
|
|
|
if (browser_env_ != BrowserEnvironment::BROWSER)
|
2016-12-07 11:22:08 +00:00
|
|
|
TRACE_EVENT_END0("devtools.timeline", "FunctionCall");
|
|
|
|
|
2016-08-03 11:52:17 +00:00
|
|
|
if (r == 0)
|
2016-11-30 07:30:03 +00:00
|
|
|
base::RunLoop().QuitWhenIdle(); // Quit from uv.
|
2013-07-22 06:58:25 +00:00
|
|
|
|
|
|
|
// Tell the worker thread to continue polling.
|
|
|
|
uv_sem_post(&embed_sem_);
|
|
|
|
}
|
|
|
|
|
|
|
|
void NodeBindings::WakeupMainThread() {
|
2016-11-30 07:30:03 +00:00
|
|
|
DCHECK(task_runner_);
|
2018-04-20 10:55:05 +00:00
|
|
|
task_runner_->PostTask(FROM_HERE, base::BindOnce(&NodeBindings::UvRunOnce,
|
|
|
|
weak_factory_.GetWeakPtr()));
|
2013-07-22 06:58:25 +00:00
|
|
|
}
|
|
|
|
|
2013-07-23 05:08:40 +00:00
|
|
|
void NodeBindings::WakeupEmbedThread() {
|
|
|
|
uv_async_send(&dummy_uv_handle_);
|
|
|
|
}
|
|
|
|
|
2013-07-22 06:58:25 +00:00
|
|
|
// static
|
2018-04-18 01:55:30 +00:00
|
|
|
void NodeBindings::EmbedThreadRunner(void* arg) {
|
2013-07-22 06:58:25 +00:00
|
|
|
NodeBindings* self = static_cast<NodeBindings*>(arg);
|
|
|
|
|
2014-01-08 02:30:30 +00:00
|
|
|
while (true) {
|
2013-07-22 06:58:25 +00:00
|
|
|
// Wait for the main loop to deal with events.
|
|
|
|
uv_sem_wait(&self->embed_sem_);
|
2014-01-08 02:30:30 +00:00
|
|
|
if (self->embed_closed_)
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Wait for something to happen in uv loop.
|
|
|
|
// Note that the PollEvents() is implemented by derived classes, so when
|
|
|
|
// this class is being destructed the PollEvents() would not be available
|
|
|
|
// anymore. Because of it we must make sure we only invoke PollEvents()
|
|
|
|
// when this class is alive.
|
2013-07-22 06:58:25 +00:00
|
|
|
self->PollEvents();
|
2014-01-08 02:30:30 +00:00
|
|
|
if (self->embed_closed_)
|
|
|
|
break;
|
2013-07-22 06:58:25 +00:00
|
|
|
|
|
|
|
// Deal with event in main thread.
|
|
|
|
self->WakeupMainThread();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-04-13 13:10:41 +00:00
|
|
|
} // namespace atom
|