electron/shell/common/node_util.cc

// Copyright (c) 2019 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.

#include "shell/common/node_util.h"

#include "base/compiler_specific.h"
#include "base/containers/to_value_list.h"
#include "base/json/json_writer.h"
#include "base/logging.h"
#include "base/no_destructor.h"
#include "base/strings/strcat.h"
#include "base/strings/string_number_conversions.h"
#include "base/threading/thread_local.h"
#include "base/values.h"
#include "gin/converter.h"
#include "shell/common/gin_converters/callback_converter.h"
#include "shell/common/node_includes.h"
#include "shell/common/node_natives_code_cache.h"
#include "shell/common/process_util.h"
#include "third_party/electron_node/src/node_process-inl.h"

namespace electron::util {

v8::MaybeLocal<v8::Function> CompileBundle(
    v8::Local<v8::Context> context,
    const char* id,
    v8::LocalVector<v8::String>* parameters) {
  static base::NoDestructor<
      base::ThreadLocalOwnedPointer<node::builtins::BuiltinLoader>>
      builtin_loader;
  if (!builtin_loader->Get()) {
    auto loader = std::make_unique<node::builtins::BuiltinLoader>();
    // Feed the build-time js2c code cache so the framework bundles are
    // consumed instead of compiled from source. Must run before the first
    // LookupAndCompileFunction; empty on builds without a generated cache.
    const bool has_node_env = node::Environment::GetCurrent(context) != nullptr;
    const auto& cache =
        GetNativesCodeCache(CurrentProcessJs2cCacheFlavor(has_node_env));
    if (!cache.empty())
      loader->RefreshCodeCache(cache);
    builtin_loader->Set(std::move(loader));
  }
  v8::MaybeLocal<v8::Function> compiled =
      builtin_loader->Get()->LookupAndCompileFunction(
          context, id, parameters, node::Realm::GetCurrent(context));
  // TODO(samuelmaddock): how can we get the compilation error message?
  if (compiled.IsEmpty())
    LOG(ERROR) << "Failed to compile electron script (" << id << ")";
  return compiled;
}

v8::MaybeLocal<v8::Value> CompileAndCall(
    v8::Isolate* const isolate,
    v8::Local<v8::Context> context,
    const char* id,
    v8::LocalVector<v8::String>* parameters,
    v8::LocalVector<v8::Value>* arguments) {
  v8::TryCatch try_catch{isolate};
  v8::Local<v8::Function> fn;
  if (!CompileBundle(context, id, parameters).ToLocal(&fn))
    return {};
  v8::MaybeLocal<v8::Value> ret = fn->Call(
      context, v8::Null(isolate), arguments->size(), arguments->data());

  // This will only be caught when something has gone terrible wrong as all
  // electron scripts are wrapped in a try {} catch {} by
  // build/bundle/bundle.mjs
  if (try_catch.HasCaught()) {
    std::string msg = "no error message";
    if (!try_catch.Message().IsEmpty()) {
      gin::ConvertFromV8(isolate, try_catch.Message()->Get(), &msg);
    } else if (try_catch.HasTerminated()) {
      msg = "script execution has been terminated";
    }
    LOG(ERROR) << "CompileAndCall failed to evaluate electron script (" << id
               << "): " << msg;
  }
  return ret;
}

void FeedEnvironmentCodeCache(node::Environment* env) {
  const auto& cache = GetNativesCodeCache(CurrentProcessJs2cCacheFlavor());
  if (!cache.empty())
    env->builtin_loader()->RefreshCodeCache(cache);
}

void InstallProcessCodeCache() {
  static const bool installed = [] {
    const auto& cache = GetNativesCodeCache(CurrentProcessJs2cCacheFlavor());
    if (!cache.empty())
      node::builtins::BuiltinLoader::SetProcessDefaultCodeCache(&cache);
    return true;
  }();
  (void)installed;
}

void EmitWarning(const std::string_view warning_msg,
                 const std::string_view warning_type) {
  // Reachable from renderers, where there is no JavascriptEnvironment.
  EmitWarning(v8::Isolate::TryGetCurrent(), warning_msg, warning_type);
}

void EmitWarning(v8::Isolate* isolate,
                 const std::string_view warning_msg,
                 const std::string_view warning_type) {
  node::Environment* env =
      isolate ? node::Environment::GetCurrent(isolate) : nullptr;
  if (!env) {
    // No Node.js environment available, fall back to console logging.
    LOG(WARNING) << "[" << warning_type << "] " << warning_msg;
    return;
  }
  node::ProcessEmitWarningGeneric(env, warning_msg, warning_type);
}

void EmitDeprecationWarning(const std::string_view warning_msg,
                            const std::string_view deprecation_code) {
  EmitDeprecationWarning(v8::Isolate::TryGetCurrent(), warning_msg,
                         deprecation_code);
}

void EmitDeprecationWarning(v8::Isolate* isolate,
                            const std::string_view warning_msg,
                            const std::string_view deprecation_code) {
  node::Environment* env =
      isolate ? node::Environment::GetCurrent(isolate) : nullptr;
  if (!env) {
    // No Node.js environment available, fall back to console logging.
    LOG(WARNING) << "[DeprecationWarning] " << warning_msg
                 << " (code: " << deprecation_code << ")";
    return;
  }
  node::ProcessEmitWarningGeneric(env, warning_msg, "DeprecationWarning",
                                  deprecation_code);
}

node::Environment* CreateEnvironment(v8::Isolate* isolate,
                                     node::IsolateData* isolate_data,
                                     v8::Local<v8::Context> context,
                                     const std::vector<std::string>& args,
                                     const std::vector<std::string>& exec_args,
                                     node::EnvironmentFlags::Flags env_flags,
                                     std::string_view process_type) {
  v8::TryCatch try_catch{isolate};
  node::Environment* env = node::CreateEnvironment(isolate_data, context, args,
                                                   exec_args, env_flags);
  if (auto message = try_catch.Message(); !message.IsEmpty()) {
    base::DictValue dict;

    if (std::string str; gin::ConvertFromV8(isolate, message->Get(), &str))
      dict.Set("message", std::move(str));

    if (std::string str; gin::ConvertFromV8(
            isolate, message->GetScriptOrigin().ResourceName(), &str)) {
      const auto line_num = message->GetLineNumber(context).FromJust();
      const auto line_str = base::NumberToString(line_num);
      dict.Set("location", base::StrCat({", at ", str, ":", line_str}));
    }

    if (std::string str; gin::ConvertFromV8(
            isolate, message->GetSourceLine(context).ToLocalChecked(), &str))
      dict.Set("source_line", std::move(str));

    if (!std::empty(process_type))
      dict.Set("process_type", process_type);

    if (auto list = base::ToValueList(args); !std::empty(list))
      dict.Set("args", std::move(list));

    if (auto list = base::ToValueList(exec_args); !std::empty(list))
      dict.Set("exec_args", std::move(list));

    std::string errstr = "Failed to initialize Node.js.";
    if (std::optional<std::string> jsonstr = base::WriteJsonWithOptions(
            dict, base::JsonOptions::OPTIONS_PRETTY_PRINT))
      errstr += base::StrCat({" ", *jsonstr});

    LOG(ERROR) << errstr;
  }

  return env;
}

v8::Local<v8::Object> CreateAbortController(v8::Isolate* isolate) {
  auto context = isolate->GetCurrentContext();
  auto global_object = context->Global();

  auto value =
      global_object->Get(context, gin::StringToV8(isolate, "AbortController"))
          .ToLocalChecked();
  DCHECK(!value.IsEmpty() && value->IsObject());

  DCHECK(value->IsFunction());
  auto constructor = value.As<v8::Function>();
  auto instance =
      constructor->NewInstance(context, 0, nullptr).ToLocalChecked();
  return instance;
}

ExplicitMicrotasksScope::ExplicitMicrotasksScope(v8::MicrotaskQueue* queue)
    : microtask_queue_(queue), original_policy_(queue->GetMicrotasksPolicy()) {
  // Browser-like processes already run with kExplicit, nested run loops
  // included. Renderers can get here from inside script (a frame's environment
  // freed by element.remove()); explicit checkpoints are then no-ops until the
  // enclosing scope unwinds.
  if (electron::IsBrowserProcess() || electron::IsUtilityProcess())
    DCHECK_EQ(original_policy_, v8::MicrotasksPolicy::kExplicit);

  microtask_queue_->SetMicrotasksPolicy(v8::MicrotasksPolicy::kExplicit);
}

ExplicitMicrotasksScope::~ExplicitMicrotasksScope() {
  microtask_queue_->SetMicrotasksPolicy(original_policy_);
}

}  // namespace electron::util

namespace electron::Buffer {

// SAFETY: There is no node::Buffer API that passes the UNSAFE_BUFFER_USAGE
// test, so let's isolate the unsafe API use into this function. Instead of
// calling `Buffer::Data()` and `Buffer::Length()` directly, the rest of our
// code should prefer to use spans returned by this function.
base::span<uint8_t> as_byte_span(v8::Local<v8::Value> node_buffer) {
  auto* data = reinterpret_cast<uint8_t*>(node::Buffer::Data(node_buffer));
  const auto size = node::Buffer::Length(node_buffer);
  return UNSAFE_BUFFERS(base::span{data, size});
}

v8::MaybeLocal<v8::Object> Copy(v8::Isolate* isolate,
                                const base::span<const char> data) {
  // SAFETY: span-friendly version of node::Buffer::Copy()
  return UNSAFE_BUFFERS(node::Buffer::Copy(isolate, data.data(), data.size()));
}

v8::MaybeLocal<v8::Object> Copy(v8::Isolate* isolate,
                                const base::span<const uint8_t> data) {
  return Copy(isolate, base::as_chars(data));
}

}  // namespace electron::Buffer