a9ef68f126
* refactor: change defined(MAS_BUILD) to IS_MAS_BUILD() This is missing-definition safe and thus allows us to move the definition of this macro away from "all compilation targets" to "just the compilation targets that depend on this macro". In turn this makes the rebuild time changing from mas <-> darwin only 80 seconds on my machine, instead of the 12-15 minutes it used to take. This will also allow us in the future to build both MAS and darwin on the same CI machine. Costing us ~2 minutes on one machine but saving us anywhere from 30 minutes to an hour of CI time on other parts of the matrix. * build: always define IS_MAS_BUILD even on non-mac builds * build: use extra_configs
1867 lines
62 KiB
C++
1867 lines
62 KiB
C++
// Copyright (c) 2013 GitHub, Inc.
|
|
// Use of this source code is governed by the MIT license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "shell/browser/api/electron_api_app.h"
|
|
|
|
#include <memory>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "base/callback_helpers.h"
|
|
#include "base/command_line.h"
|
|
#include "base/containers/span.h"
|
|
#include "base/environment.h"
|
|
#include "base/files/file_path.h"
|
|
#include "base/files/file_util.h"
|
|
#include "base/path_service.h"
|
|
#include "base/system/sys_info.h"
|
|
#include "base/values.h"
|
|
#include "chrome/browser/browser_process.h"
|
|
#include "chrome/browser/icon_manager.h"
|
|
#include "chrome/common/chrome_features.h"
|
|
#include "chrome/common/chrome_paths.h"
|
|
#include "content/browser/gpu/compositor_util.h" // nogncheck
|
|
#include "content/browser/gpu/gpu_data_manager_impl.h" // nogncheck
|
|
#include "content/public/browser/browser_accessibility_state.h"
|
|
#include "content/public/browser/browser_child_process_host.h"
|
|
#include "content/public/browser/child_process_data.h"
|
|
#include "content/public/browser/client_certificate_delegate.h"
|
|
#include "content/public/browser/gpu_data_manager.h"
|
|
#include "content/public/browser/network_service_instance.h"
|
|
#include "content/public/browser/render_frame_host.h"
|
|
#include "content/public/common/content_switches.h"
|
|
#include "crypto/crypto_buildflags.h"
|
|
#include "media/audio/audio_manager.h"
|
|
#include "net/dns/public/dns_over_https_config.h"
|
|
#include "net/dns/public/dns_over_https_server_config.h"
|
|
#include "net/dns/public/util.h"
|
|
#include "net/ssl/client_cert_identity.h"
|
|
#include "net/ssl/ssl_cert_request_info.h"
|
|
#include "net/ssl/ssl_private_key.h"
|
|
#include "sandbox/policy/switches.h"
|
|
#include "services/network/network_service.h"
|
|
#include "shell/app/command_line_args.h"
|
|
#include "shell/browser/api/electron_api_menu.h"
|
|
#include "shell/browser/api/electron_api_session.h"
|
|
#include "shell/browser/api/electron_api_utility_process.h"
|
|
#include "shell/browser/api/electron_api_web_contents.h"
|
|
#include "shell/browser/api/gpuinfo_manager.h"
|
|
#include "shell/browser/browser_process_impl.h"
|
|
#include "shell/browser/electron_browser_context.h"
|
|
#include "shell/browser/electron_browser_main_parts.h"
|
|
#include "shell/browser/javascript_environment.h"
|
|
#include "shell/browser/login_handler.h"
|
|
#include "shell/browser/relauncher.h"
|
|
#include "shell/common/application_info.h"
|
|
#include "shell/common/electron_command_line.h"
|
|
#include "shell/common/electron_paths.h"
|
|
#include "shell/common/gin_converters/base_converter.h"
|
|
#include "shell/common/gin_converters/blink_converter.h"
|
|
#include "shell/common/gin_converters/callback_converter.h"
|
|
#include "shell/common/gin_converters/file_path_converter.h"
|
|
#include "shell/common/gin_converters/gurl_converter.h"
|
|
#include "shell/common/gin_converters/image_converter.h"
|
|
#include "shell/common/gin_converters/net_converter.h"
|
|
#include "shell/common/gin_converters/value_converter.h"
|
|
#include "shell/common/gin_helper/dictionary.h"
|
|
#include "shell/common/gin_helper/object_template_builder.h"
|
|
#include "shell/common/language_util.h"
|
|
#include "shell/common/node_includes.h"
|
|
#include "shell/common/options_switches.h"
|
|
#include "shell/common/platform_util.h"
|
|
#include "shell/common/v8_value_serializer.h"
|
|
#include "third_party/abseil-cpp/absl/types/optional.h"
|
|
#include "ui/gfx/image/image.h"
|
|
|
|
#if BUILDFLAG(IS_WIN)
|
|
#include "base/strings/utf_string_conversions.h"
|
|
#include "shell/browser/ui/win/jump_list.h"
|
|
#endif
|
|
|
|
#if BUILDFLAG(IS_MAC)
|
|
#include <CoreFoundation/CoreFoundation.h>
|
|
#include "shell/browser/ui/cocoa/electron_bundle_mover.h"
|
|
#endif
|
|
|
|
using electron::Browser;
|
|
|
|
namespace gin {
|
|
|
|
#if BUILDFLAG(IS_WIN)
|
|
template <>
|
|
struct Converter<electron::ProcessIntegrityLevel> {
|
|
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
|
|
electron::ProcessIntegrityLevel value) {
|
|
switch (value) {
|
|
case electron::ProcessIntegrityLevel::kUntrusted:
|
|
return StringToV8(isolate, "untrusted");
|
|
case electron::ProcessIntegrityLevel::kLow:
|
|
return StringToV8(isolate, "low");
|
|
case electron::ProcessIntegrityLevel::kMedium:
|
|
return StringToV8(isolate, "medium");
|
|
case electron::ProcessIntegrityLevel::kHigh:
|
|
return StringToV8(isolate, "high");
|
|
default:
|
|
return StringToV8(isolate, "unknown");
|
|
}
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct Converter<Browser::UserTask> {
|
|
static bool FromV8(v8::Isolate* isolate,
|
|
v8::Local<v8::Value> val,
|
|
Browser::UserTask* out) {
|
|
gin_helper::Dictionary dict;
|
|
if (!ConvertFromV8(isolate, val, &dict))
|
|
return false;
|
|
if (!dict.Get("program", &(out->program)) ||
|
|
!dict.Get("title", &(out->title)))
|
|
return false;
|
|
if (dict.Get("iconPath", &(out->icon_path)) &&
|
|
!dict.Get("iconIndex", &(out->icon_index)))
|
|
return false;
|
|
dict.Get("arguments", &(out->arguments));
|
|
dict.Get("description", &(out->description));
|
|
dict.Get("workingDirectory", &(out->working_dir));
|
|
return true;
|
|
}
|
|
};
|
|
|
|
using electron::JumpListCategory;
|
|
using electron::JumpListItem;
|
|
using electron::JumpListResult;
|
|
|
|
template <>
|
|
struct Converter<JumpListItem::Type> {
|
|
static bool FromV8(v8::Isolate* isolate,
|
|
v8::Local<v8::Value> val,
|
|
JumpListItem::Type* out) {
|
|
std::string item_type;
|
|
if (!ConvertFromV8(isolate, val, &item_type))
|
|
return false;
|
|
|
|
if (item_type == "task")
|
|
*out = JumpListItem::Type::kTask;
|
|
else if (item_type == "separator")
|
|
*out = JumpListItem::Type::kSeparator;
|
|
else if (item_type == "file")
|
|
*out = JumpListItem::Type::kFile;
|
|
else
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
|
|
JumpListItem::Type val) {
|
|
std::string item_type;
|
|
switch (val) {
|
|
case JumpListItem::Type::kTask:
|
|
item_type = "task";
|
|
break;
|
|
|
|
case JumpListItem::Type::kSeparator:
|
|
item_type = "separator";
|
|
break;
|
|
|
|
case JumpListItem::Type::kFile:
|
|
item_type = "file";
|
|
break;
|
|
}
|
|
return gin::ConvertToV8(isolate, item_type);
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct Converter<JumpListItem> {
|
|
static bool FromV8(v8::Isolate* isolate,
|
|
v8::Local<v8::Value> val,
|
|
JumpListItem* out) {
|
|
gin_helper::Dictionary dict;
|
|
if (!ConvertFromV8(isolate, val, &dict))
|
|
return false;
|
|
|
|
if (!dict.Get("type", &(out->type)))
|
|
return false;
|
|
|
|
switch (out->type) {
|
|
case JumpListItem::Type::kTask:
|
|
if (!dict.Get("program", &(out->path)) ||
|
|
!dict.Get("title", &(out->title)))
|
|
return false;
|
|
|
|
if (dict.Get("iconPath", &(out->icon_path)) &&
|
|
!dict.Get("iconIndex", &(out->icon_index)))
|
|
return false;
|
|
|
|
dict.Get("args", &(out->arguments));
|
|
dict.Get("description", &(out->description));
|
|
dict.Get("workingDirectory", &(out->working_dir));
|
|
return true;
|
|
|
|
case JumpListItem::Type::kSeparator:
|
|
return true;
|
|
|
|
case JumpListItem::Type::kFile:
|
|
return dict.Get("path", &(out->path));
|
|
}
|
|
|
|
assert(false);
|
|
return false;
|
|
}
|
|
|
|
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
|
|
const JumpListItem& val) {
|
|
gin_helper::Dictionary dict = gin::Dictionary::CreateEmpty(isolate);
|
|
dict.Set("type", val.type);
|
|
|
|
switch (val.type) {
|
|
case JumpListItem::Type::kTask:
|
|
dict.Set("program", val.path);
|
|
dict.Set("args", val.arguments);
|
|
dict.Set("title", val.title);
|
|
dict.Set("iconPath", val.icon_path);
|
|
dict.Set("iconIndex", val.icon_index);
|
|
dict.Set("description", val.description);
|
|
dict.Set("workingDirectory", val.working_dir);
|
|
break;
|
|
|
|
case JumpListItem::Type::kSeparator:
|
|
break;
|
|
|
|
case JumpListItem::Type::kFile:
|
|
dict.Set("path", val.path);
|
|
break;
|
|
}
|
|
return dict.GetHandle();
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct Converter<JumpListCategory::Type> {
|
|
static bool FromV8(v8::Isolate* isolate,
|
|
v8::Local<v8::Value> val,
|
|
JumpListCategory::Type* out) {
|
|
std::string category_type;
|
|
if (!ConvertFromV8(isolate, val, &category_type))
|
|
return false;
|
|
|
|
if (category_type == "tasks")
|
|
*out = JumpListCategory::Type::kTasks;
|
|
else if (category_type == "frequent")
|
|
*out = JumpListCategory::Type::kFrequent;
|
|
else if (category_type == "recent")
|
|
*out = JumpListCategory::Type::kRecent;
|
|
else if (category_type == "custom")
|
|
*out = JumpListCategory::Type::kCustom;
|
|
else
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
|
|
JumpListCategory::Type val) {
|
|
std::string category_type;
|
|
switch (val) {
|
|
case JumpListCategory::Type::kTasks:
|
|
category_type = "tasks";
|
|
break;
|
|
|
|
case JumpListCategory::Type::kFrequent:
|
|
category_type = "frequent";
|
|
break;
|
|
|
|
case JumpListCategory::Type::kRecent:
|
|
category_type = "recent";
|
|
break;
|
|
|
|
case JumpListCategory::Type::kCustom:
|
|
category_type = "custom";
|
|
break;
|
|
}
|
|
return gin::ConvertToV8(isolate, category_type);
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct Converter<JumpListCategory> {
|
|
static bool FromV8(v8::Isolate* isolate,
|
|
v8::Local<v8::Value> val,
|
|
JumpListCategory* out) {
|
|
gin_helper::Dictionary dict;
|
|
if (!ConvertFromV8(isolate, val, &dict))
|
|
return false;
|
|
|
|
if (dict.Get("name", &(out->name)) && out->name.empty())
|
|
return false;
|
|
|
|
if (!dict.Get("type", &(out->type))) {
|
|
if (out->name.empty())
|
|
out->type = JumpListCategory::Type::kTasks;
|
|
else
|
|
out->type = JumpListCategory::Type::kCustom;
|
|
}
|
|
|
|
if ((out->type == JumpListCategory::Type::kTasks) ||
|
|
(out->type == JumpListCategory::Type::kCustom)) {
|
|
if (!dict.Get("items", &(out->items)))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
// static
|
|
template <>
|
|
struct Converter<JumpListResult> {
|
|
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate, JumpListResult val) {
|
|
std::string result_code;
|
|
switch (val) {
|
|
case JumpListResult::kSuccess:
|
|
result_code = "ok";
|
|
break;
|
|
|
|
case JumpListResult::kArgumentError:
|
|
result_code = "argumentError";
|
|
break;
|
|
|
|
case JumpListResult::kGenericError:
|
|
result_code = "error";
|
|
break;
|
|
|
|
case JumpListResult::kCustomCategorySeparatorError:
|
|
result_code = "invalidSeparatorError";
|
|
break;
|
|
|
|
case JumpListResult::kMissingFileTypeRegistrationError:
|
|
result_code = "fileTypeRegistrationError";
|
|
break;
|
|
|
|
case JumpListResult::kCustomCategoryAccessDeniedError:
|
|
result_code = "customCategoryAccessDeniedError";
|
|
break;
|
|
}
|
|
return ConvertToV8(isolate, result_code);
|
|
}
|
|
};
|
|
#endif
|
|
|
|
#if BUILDFLAG(IS_WIN)
|
|
template <>
|
|
struct Converter<Browser::LaunchItem> {
|
|
static bool FromV8(v8::Isolate* isolate,
|
|
v8::Local<v8::Value> val,
|
|
Browser::LaunchItem* out) {
|
|
gin_helper::Dictionary dict;
|
|
if (!ConvertFromV8(isolate, val, &dict))
|
|
return false;
|
|
|
|
dict.Get("name", &(out->name));
|
|
dict.Get("path", &(out->path));
|
|
dict.Get("args", &(out->args));
|
|
dict.Get("scope", &(out->scope));
|
|
dict.Get("enabled", &(out->enabled));
|
|
return true;
|
|
}
|
|
|
|
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
|
|
Browser::LaunchItem val) {
|
|
gin_helper::Dictionary dict = gin::Dictionary::CreateEmpty(isolate);
|
|
dict.Set("name", val.name);
|
|
dict.Set("path", val.path);
|
|
dict.Set("args", val.args);
|
|
dict.Set("scope", val.scope);
|
|
dict.Set("enabled", val.enabled);
|
|
return dict.GetHandle();
|
|
}
|
|
};
|
|
#endif
|
|
|
|
template <>
|
|
struct Converter<Browser::LoginItemSettings> {
|
|
static bool FromV8(v8::Isolate* isolate,
|
|
v8::Local<v8::Value> val,
|
|
Browser::LoginItemSettings* out) {
|
|
gin_helper::Dictionary dict;
|
|
if (!ConvertFromV8(isolate, val, &dict))
|
|
return false;
|
|
|
|
dict.Get("openAtLogin", &(out->open_at_login));
|
|
dict.Get("openAsHidden", &(out->open_as_hidden));
|
|
dict.Get("path", &(out->path));
|
|
dict.Get("args", &(out->args));
|
|
#if BUILDFLAG(IS_WIN)
|
|
dict.Get("enabled", &(out->enabled));
|
|
dict.Get("name", &(out->name));
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
|
|
Browser::LoginItemSettings val) {
|
|
gin_helper::Dictionary dict = gin::Dictionary::CreateEmpty(isolate);
|
|
dict.Set("openAtLogin", val.open_at_login);
|
|
dict.Set("openAsHidden", val.open_as_hidden);
|
|
dict.Set("restoreState", val.restore_state);
|
|
dict.Set("wasOpenedAtLogin", val.opened_at_login);
|
|
dict.Set("wasOpenedAsHidden", val.opened_as_hidden);
|
|
#if BUILDFLAG(IS_WIN)
|
|
dict.Set("launchItems", val.launch_items);
|
|
dict.Set("executableWillLaunchAtLogin",
|
|
val.executable_will_launch_at_login);
|
|
#endif
|
|
return dict.GetHandle();
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct Converter<content::CertificateRequestResultType> {
|
|
static bool FromV8(v8::Isolate* isolate,
|
|
v8::Local<v8::Value> val,
|
|
content::CertificateRequestResultType* out) {
|
|
bool b;
|
|
if (!ConvertFromV8(isolate, val, &b))
|
|
return false;
|
|
*out = b ? content::CERTIFICATE_REQUEST_RESULT_TYPE_CONTINUE
|
|
: content::CERTIFICATE_REQUEST_RESULT_TYPE_DENY;
|
|
return true;
|
|
}
|
|
};
|
|
|
|
template <>
|
|
struct Converter<net::SecureDnsMode> {
|
|
static bool FromV8(v8::Isolate* isolate,
|
|
v8::Local<v8::Value> val,
|
|
net::SecureDnsMode* out) {
|
|
std::string s;
|
|
if (!ConvertFromV8(isolate, val, &s))
|
|
return false;
|
|
if (s == "off") {
|
|
*out = net::SecureDnsMode::kOff;
|
|
return true;
|
|
} else if (s == "automatic") {
|
|
*out = net::SecureDnsMode::kAutomatic;
|
|
return true;
|
|
} else if (s == "secure") {
|
|
*out = net::SecureDnsMode::kSecure;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
};
|
|
} // namespace gin
|
|
|
|
namespace electron::api {
|
|
|
|
gin::WrapperInfo App::kWrapperInfo = {gin::kEmbedderNativeGin};
|
|
|
|
namespace {
|
|
|
|
IconLoader::IconSize GetIconSizeByString(const std::string& size) {
|
|
if (size == "small") {
|
|
return IconLoader::IconSize::SMALL;
|
|
} else if (size == "large") {
|
|
return IconLoader::IconSize::LARGE;
|
|
}
|
|
return IconLoader::IconSize::NORMAL;
|
|
}
|
|
|
|
// Return the path constant from string.
|
|
int GetPathConstant(const std::string& name) {
|
|
if (name == "appData")
|
|
return DIR_APP_DATA;
|
|
else if (name == "sessionData")
|
|
return DIR_SESSION_DATA;
|
|
else if (name == "userData")
|
|
return chrome::DIR_USER_DATA;
|
|
else if (name == "cache")
|
|
#if BUILDFLAG(IS_POSIX)
|
|
return base::DIR_CACHE;
|
|
#else
|
|
return base::DIR_ROAMING_APP_DATA;
|
|
#endif
|
|
else if (name == "userCache")
|
|
return DIR_USER_CACHE;
|
|
else if (name == "logs")
|
|
return DIR_APP_LOGS;
|
|
else if (name == "crashDumps")
|
|
return DIR_CRASH_DUMPS;
|
|
else if (name == "home")
|
|
return base::DIR_HOME;
|
|
else if (name == "temp")
|
|
return base::DIR_TEMP;
|
|
else if (name == "userDesktop" || name == "desktop")
|
|
return base::DIR_USER_DESKTOP;
|
|
else if (name == "exe")
|
|
return base::FILE_EXE;
|
|
else if (name == "module")
|
|
return base::FILE_MODULE;
|
|
else if (name == "documents")
|
|
return chrome::DIR_USER_DOCUMENTS;
|
|
else if (name == "downloads")
|
|
return chrome::DIR_DEFAULT_DOWNLOADS;
|
|
else if (name == "music")
|
|
return chrome::DIR_USER_MUSIC;
|
|
else if (name == "pictures")
|
|
return chrome::DIR_USER_PICTURES;
|
|
else if (name == "videos")
|
|
return chrome::DIR_USER_VIDEOS;
|
|
#if BUILDFLAG(IS_WIN)
|
|
else if (name == "recent")
|
|
return electron::DIR_RECENT;
|
|
#endif
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
bool NotificationCallbackWrapper(
|
|
const base::RepeatingCallback<
|
|
void(const base::CommandLine& command_line,
|
|
const base::FilePath& current_directory,
|
|
const std::vector<const uint8_t> additional_data)>& callback,
|
|
const base::CommandLine& cmd,
|
|
const base::FilePath& cwd,
|
|
const std::vector<const uint8_t> additional_data) {
|
|
// Make sure the callback is called after app gets ready.
|
|
if (Browser::Get()->is_ready()) {
|
|
callback.Run(cmd, cwd, std::move(additional_data));
|
|
} else {
|
|
scoped_refptr<base::SingleThreadTaskRunner> task_runner(
|
|
base::ThreadTaskRunnerHandle::Get());
|
|
|
|
// Make a copy of the span so that the data isn't lost.
|
|
task_runner->PostTask(FROM_HERE,
|
|
base::BindOnce(base::IgnoreResult(callback), cmd, cwd,
|
|
std::move(additional_data)));
|
|
}
|
|
// ProcessSingleton needs to know whether current process is quiting.
|
|
return !Browser::Get()->is_shutting_down();
|
|
}
|
|
|
|
void GotPrivateKey(std::shared_ptr<content::ClientCertificateDelegate> delegate,
|
|
scoped_refptr<net::X509Certificate> cert,
|
|
scoped_refptr<net::SSLPrivateKey> private_key) {
|
|
delegate->ContinueWithCertificate(cert, private_key);
|
|
}
|
|
|
|
void OnClientCertificateSelected(
|
|
v8::Isolate* isolate,
|
|
std::shared_ptr<content::ClientCertificateDelegate> delegate,
|
|
std::shared_ptr<net::ClientCertIdentityList> identities,
|
|
gin::Arguments* args) {
|
|
if (args->Length() == 2) {
|
|
delegate->ContinueWithCertificate(nullptr, nullptr);
|
|
return;
|
|
}
|
|
|
|
v8::Local<v8::Value> val;
|
|
args->GetNext(&val);
|
|
if (val->IsNull()) {
|
|
delegate->ContinueWithCertificate(nullptr, nullptr);
|
|
return;
|
|
}
|
|
|
|
gin_helper::Dictionary cert_data;
|
|
if (!gin::ConvertFromV8(isolate, val, &cert_data)) {
|
|
gin_helper::ErrorThrower(isolate).ThrowError(
|
|
"Must pass valid certificate object.");
|
|
return;
|
|
}
|
|
|
|
std::string data;
|
|
if (!cert_data.Get("data", &data))
|
|
return;
|
|
|
|
auto certs = net::X509Certificate::CreateCertificateListFromBytes(
|
|
base::as_bytes(base::make_span(data.c_str(), data.size())),
|
|
net::X509Certificate::FORMAT_AUTO);
|
|
if (!certs.empty()) {
|
|
scoped_refptr<net::X509Certificate> cert(certs[0].get());
|
|
for (auto& identity : *identities) {
|
|
scoped_refptr<net::X509Certificate> identity_cert =
|
|
identity->certificate();
|
|
// Since |cert| was recreated from |data|, it won't include any
|
|
// intermediates. That's fine for checking equality, but once a match is
|
|
// found then |identity_cert| should be used since it will include the
|
|
// intermediates which would otherwise be lost.
|
|
if (cert->EqualsExcludingChain(identity_cert.get())) {
|
|
net::ClientCertIdentity::SelfOwningAcquirePrivateKey(
|
|
std::move(identity), base::BindRepeating(&GotPrivateKey, delegate,
|
|
std::move(identity_cert)));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#if BUILDFLAG(USE_NSS_CERTS)
|
|
int ImportIntoCertStore(CertificateManagerModel* model, base::Value options) {
|
|
std::string file_data, cert_path;
|
|
std::u16string password;
|
|
net::ScopedCERTCertificateList imported_certs;
|
|
int rv = -1;
|
|
|
|
std::string* cert_path_ptr = options.FindStringKey("certificate");
|
|
if (cert_path_ptr)
|
|
cert_path = *cert_path_ptr;
|
|
|
|
std::string* pwd = options.FindStringKey("password");
|
|
if (pwd)
|
|
password = base::UTF8ToUTF16(*pwd);
|
|
|
|
if (!cert_path.empty()) {
|
|
if (base::ReadFileToString(base::FilePath(cert_path), &file_data)) {
|
|
auto module = model->cert_db()->GetPrivateSlot();
|
|
rv = model->ImportFromPKCS12(module.get(), file_data, password, true,
|
|
&imported_certs);
|
|
if (imported_certs.size() > 1) {
|
|
auto it = imported_certs.begin();
|
|
++it; // skip first which would be the client certificate.
|
|
for (; it != imported_certs.end(); ++it)
|
|
rv &= model->SetCertTrust(it->get(), net::CA_CERT,
|
|
net::NSSCertDatabase::TRUSTED_SSL);
|
|
}
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
#endif
|
|
|
|
void OnIconDataAvailable(gin_helper::Promise<gfx::Image> promise,
|
|
gfx::Image icon) {
|
|
if (!icon.IsEmpty()) {
|
|
promise.Resolve(icon);
|
|
} else {
|
|
promise.RejectWithErrorMessage("Failed to get file icon.");
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
App::App() {
|
|
static_cast<ElectronBrowserClient*>(ElectronBrowserClient::Get())
|
|
->set_delegate(this);
|
|
Browser::Get()->AddObserver(this);
|
|
|
|
auto pid = content::ChildProcessHost::kInvalidUniqueID;
|
|
auto process_metric = std::make_unique<electron::ProcessMetric>(
|
|
content::PROCESS_TYPE_BROWSER, base::GetCurrentProcessHandle(),
|
|
base::ProcessMetrics::CreateCurrentProcessMetrics());
|
|
app_metrics_[pid] = std::move(process_metric);
|
|
}
|
|
|
|
App::~App() {
|
|
static_cast<ElectronBrowserClient*>(ElectronBrowserClient::Get())
|
|
->set_delegate(nullptr);
|
|
Browser::Get()->RemoveObserver(this);
|
|
content::GpuDataManager::GetInstance()->RemoveObserver(this);
|
|
content::BrowserChildProcessObserver::Remove(this);
|
|
}
|
|
|
|
void App::OnBeforeQuit(bool* prevent_default) {
|
|
if (Emit("before-quit")) {
|
|
*prevent_default = true;
|
|
}
|
|
}
|
|
|
|
void App::OnWillQuit(bool* prevent_default) {
|
|
if (Emit("will-quit")) {
|
|
*prevent_default = true;
|
|
}
|
|
}
|
|
|
|
void App::OnWindowAllClosed() {
|
|
Emit("window-all-closed");
|
|
}
|
|
|
|
void App::OnQuit() {
|
|
const int exitCode = ElectronBrowserMainParts::Get()->GetExitCode();
|
|
Emit("quit", exitCode);
|
|
|
|
if (process_singleton_) {
|
|
process_singleton_->Cleanup();
|
|
process_singleton_.reset();
|
|
}
|
|
}
|
|
|
|
void App::OnOpenFile(bool* prevent_default, const std::string& file_path) {
|
|
if (Emit("open-file", file_path)) {
|
|
*prevent_default = true;
|
|
}
|
|
}
|
|
|
|
void App::OnOpenURL(const std::string& url) {
|
|
Emit("open-url", url);
|
|
}
|
|
|
|
void App::OnActivate(bool has_visible_windows) {
|
|
Emit("activate", has_visible_windows);
|
|
}
|
|
|
|
void App::OnWillFinishLaunching() {
|
|
Emit("will-finish-launching");
|
|
}
|
|
|
|
void App::OnFinishLaunching(base::Value::Dict launch_info) {
|
|
#if BUILDFLAG(IS_LINUX)
|
|
// Set the application name for audio streams shown in external
|
|
// applications. Only affects pulseaudio currently.
|
|
media::AudioManager::SetGlobalAppName(Browser::Get()->GetName());
|
|
#endif
|
|
Emit("ready", base::Value(std::move(launch_info)));
|
|
}
|
|
|
|
void App::OnPreMainMessageLoopRun() {
|
|
content::BrowserChildProcessObserver::Add(this);
|
|
if (process_singleton_ && watch_singleton_socket_on_ready_) {
|
|
process_singleton_->StartWatching();
|
|
watch_singleton_socket_on_ready_ = false;
|
|
}
|
|
}
|
|
|
|
void App::OnPreCreateThreads() {
|
|
DCHECK(!content::GpuDataManager::Initialized());
|
|
content::GpuDataManager* manager = content::GpuDataManager::GetInstance();
|
|
manager->AddObserver(this);
|
|
|
|
if (disable_hw_acceleration_) {
|
|
manager->DisableHardwareAcceleration();
|
|
}
|
|
|
|
if (disable_domain_blocking_for_3DAPIs_) {
|
|
content::GpuDataManagerImpl::GetInstance()
|
|
->DisableDomainBlockingFor3DAPIsForTesting();
|
|
}
|
|
}
|
|
|
|
void App::OnAccessibilitySupportChanged() {
|
|
Emit("accessibility-support-changed", IsAccessibilitySupportEnabled());
|
|
}
|
|
|
|
#if BUILDFLAG(IS_MAC)
|
|
void App::OnWillContinueUserActivity(bool* prevent_default,
|
|
const std::string& type) {
|
|
if (Emit("will-continue-activity", type)) {
|
|
*prevent_default = true;
|
|
}
|
|
}
|
|
|
|
void App::OnDidFailToContinueUserActivity(const std::string& type,
|
|
const std::string& error) {
|
|
Emit("continue-activity-error", type, error);
|
|
}
|
|
|
|
void App::OnContinueUserActivity(bool* prevent_default,
|
|
const std::string& type,
|
|
base::Value::Dict user_info,
|
|
base::Value::Dict details) {
|
|
if (Emit("continue-activity", type, base::Value(std::move(user_info)),
|
|
base::Value(std::move(details)))) {
|
|
*prevent_default = true;
|
|
}
|
|
}
|
|
|
|
void App::OnUserActivityWasContinued(const std::string& type,
|
|
base::Value::Dict user_info) {
|
|
Emit("activity-was-continued", type, base::Value(std::move(user_info)));
|
|
}
|
|
|
|
void App::OnUpdateUserActivityState(bool* prevent_default,
|
|
const std::string& type,
|
|
base::Value::Dict user_info) {
|
|
if (Emit("update-activity-state", type, base::Value(std::move(user_info)))) {
|
|
*prevent_default = true;
|
|
}
|
|
}
|
|
|
|
void App::OnNewWindowForTab() {
|
|
Emit("new-window-for-tab");
|
|
}
|
|
|
|
void App::OnDidBecomeActive() {
|
|
Emit("did-become-active");
|
|
}
|
|
#endif
|
|
|
|
bool App::CanCreateWindow(
|
|
content::RenderFrameHost* opener,
|
|
const GURL& opener_url,
|
|
const GURL& opener_top_level_frame_url,
|
|
const url::Origin& source_origin,
|
|
content::mojom::WindowContainerType container_type,
|
|
const GURL& target_url,
|
|
const content::Referrer& referrer,
|
|
const std::string& frame_name,
|
|
WindowOpenDisposition disposition,
|
|
const blink::mojom::WindowFeatures& features,
|
|
const std::string& raw_features,
|
|
const scoped_refptr<network::ResourceRequestBody>& body,
|
|
bool user_gesture,
|
|
bool opener_suppressed,
|
|
bool* no_javascript_access) {
|
|
v8::Isolate* isolate = JavascriptEnvironment::GetIsolate();
|
|
v8::HandleScope handle_scope(isolate);
|
|
content::WebContents* web_contents =
|
|
content::WebContents::FromRenderFrameHost(opener);
|
|
if (web_contents) {
|
|
WebContents* api_web_contents = WebContents::From(web_contents);
|
|
// No need to emit any event if the WebContents is not available in JS.
|
|
if (api_web_contents) {
|
|
api_web_contents->OnCreateWindow(target_url, referrer, frame_name,
|
|
disposition, raw_features, body);
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void App::AllowCertificateError(
|
|
content::WebContents* web_contents,
|
|
int cert_error,
|
|
const net::SSLInfo& ssl_info,
|
|
const GURL& request_url,
|
|
bool is_main_frame_request,
|
|
bool strict_enforcement,
|
|
base::OnceCallback<void(content::CertificateRequestResultType)> callback) {
|
|
auto adapted_callback = base::AdaptCallbackForRepeating(std::move(callback));
|
|
v8::Isolate* isolate = JavascriptEnvironment::GetIsolate();
|
|
v8::HandleScope handle_scope(isolate);
|
|
bool prevent_default = Emit(
|
|
"certificate-error", WebContents::FromOrCreate(isolate, web_contents),
|
|
request_url, net::ErrorToString(cert_error), ssl_info.cert,
|
|
adapted_callback, is_main_frame_request);
|
|
|
|
// Deny the certificate by default.
|
|
if (!prevent_default)
|
|
adapted_callback.Run(content::CERTIFICATE_REQUEST_RESULT_TYPE_DENY);
|
|
}
|
|
|
|
base::OnceClosure App::SelectClientCertificate(
|
|
content::WebContents* web_contents,
|
|
net::SSLCertRequestInfo* cert_request_info,
|
|
net::ClientCertIdentityList identities,
|
|
std::unique_ptr<content::ClientCertificateDelegate> delegate) {
|
|
std::shared_ptr<content::ClientCertificateDelegate> shared_delegate(
|
|
delegate.release());
|
|
|
|
// Convert the ClientCertIdentityList to a CertificateList
|
|
// to avoid changes in the API.
|
|
auto client_certs = net::CertificateList();
|
|
for (const std::unique_ptr<net::ClientCertIdentity>& identity : identities)
|
|
client_certs.emplace_back(identity->certificate());
|
|
|
|
auto shared_identities =
|
|
std::make_shared<net::ClientCertIdentityList>(std::move(identities));
|
|
|
|
v8::Isolate* isolate = JavascriptEnvironment::GetIsolate();
|
|
v8::HandleScope handle_scope(isolate);
|
|
bool prevent_default =
|
|
Emit("select-client-certificate",
|
|
WebContents::FromOrCreate(isolate, web_contents),
|
|
cert_request_info->host_and_port.ToString(), std::move(client_certs),
|
|
base::BindOnce(&OnClientCertificateSelected, isolate,
|
|
shared_delegate, shared_identities));
|
|
|
|
// Default to first certificate from the platform store.
|
|
if (!prevent_default) {
|
|
scoped_refptr<net::X509Certificate> cert =
|
|
(*shared_identities)[0]->certificate();
|
|
net::ClientCertIdentity::SelfOwningAcquirePrivateKey(
|
|
std::move((*shared_identities)[0]),
|
|
base::BindRepeating(&GotPrivateKey, shared_delegate, std::move(cert)));
|
|
}
|
|
return base::OnceClosure();
|
|
}
|
|
|
|
void App::OnGpuInfoUpdate() {
|
|
Emit("gpu-info-update");
|
|
}
|
|
|
|
void App::OnGpuProcessCrashed() {
|
|
Emit("gpu-process-crashed", true);
|
|
}
|
|
|
|
void App::BrowserChildProcessLaunchedAndConnected(
|
|
const content::ChildProcessData& data) {
|
|
ChildProcessLaunched(data.process_type, data.id, data.GetProcess().Handle(),
|
|
data.metrics_name, base::UTF16ToUTF8(data.name));
|
|
}
|
|
|
|
void App::BrowserChildProcessHostDisconnected(
|
|
const content::ChildProcessData& data) {
|
|
ChildProcessDisconnected(data.id);
|
|
}
|
|
|
|
void App::BrowserChildProcessCrashed(
|
|
const content::ChildProcessData& data,
|
|
const content::ChildProcessTerminationInfo& info) {
|
|
ChildProcessDisconnected(data.id);
|
|
BrowserChildProcessCrashedOrKilled(data, info);
|
|
}
|
|
|
|
void App::BrowserChildProcessKilled(
|
|
const content::ChildProcessData& data,
|
|
const content::ChildProcessTerminationInfo& info) {
|
|
ChildProcessDisconnected(data.id);
|
|
BrowserChildProcessCrashedOrKilled(data, info);
|
|
}
|
|
|
|
void App::BrowserChildProcessCrashedOrKilled(
|
|
const content::ChildProcessData& data,
|
|
const content::ChildProcessTerminationInfo& info) {
|
|
v8::Isolate* isolate = JavascriptEnvironment::GetIsolate();
|
|
v8::HandleScope handle_scope(isolate);
|
|
auto details = gin_helper::Dictionary::CreateEmpty(isolate);
|
|
details.Set("type", content::GetProcessTypeNameInEnglish(data.process_type));
|
|
details.Set("reason", info.status);
|
|
details.Set("exitCode", info.exit_code);
|
|
details.Set("serviceName", data.metrics_name);
|
|
if (!data.name.empty()) {
|
|
details.Set("name", data.name);
|
|
}
|
|
if (data.process_type == content::PROCESS_TYPE_UTILITY) {
|
|
base::ProcessId pid = data.GetProcess().Pid();
|
|
auto utility_process_wrapper = UtilityProcessWrapper::FromProcessId(pid);
|
|
if (utility_process_wrapper)
|
|
utility_process_wrapper->Shutdown(info.exit_code);
|
|
}
|
|
Emit("child-process-gone", details);
|
|
}
|
|
|
|
void App::RenderProcessReady(content::RenderProcessHost* host) {
|
|
ChildProcessLaunched(content::PROCESS_TYPE_RENDERER, host->GetID(),
|
|
host->GetProcess().Handle());
|
|
}
|
|
|
|
void App::RenderProcessExited(content::RenderProcessHost* host) {
|
|
ChildProcessDisconnected(host->GetID());
|
|
}
|
|
|
|
void App::ChildProcessLaunched(int process_type,
|
|
int pid,
|
|
base::ProcessHandle handle,
|
|
const std::string& service_name,
|
|
const std::string& name) {
|
|
#if BUILDFLAG(IS_MAC)
|
|
auto metrics = base::ProcessMetrics::CreateProcessMetrics(
|
|
handle, content::BrowserChildProcessHost::GetPortProvider());
|
|
#else
|
|
auto metrics = base::ProcessMetrics::CreateProcessMetrics(handle);
|
|
#endif
|
|
app_metrics_[pid] = std::make_unique<electron::ProcessMetric>(
|
|
process_type, handle, std::move(metrics), service_name, name);
|
|
}
|
|
|
|
void App::ChildProcessDisconnected(int pid) {
|
|
app_metrics_.erase(pid);
|
|
}
|
|
|
|
base::FilePath App::GetAppPath() const {
|
|
return app_path_;
|
|
}
|
|
|
|
void App::SetAppPath(const base::FilePath& app_path) {
|
|
app_path_ = app_path;
|
|
}
|
|
|
|
#if !BUILDFLAG(IS_MAC)
|
|
void App::SetAppLogsPath(gin_helper::ErrorThrower thrower,
|
|
absl::optional<base::FilePath> custom_path) {
|
|
if (custom_path.has_value()) {
|
|
if (!custom_path->IsAbsolute()) {
|
|
thrower.ThrowError("Path must be absolute");
|
|
return;
|
|
}
|
|
{
|
|
base::ThreadRestrictions::ScopedAllowIO allow_io;
|
|
base::PathService::Override(DIR_APP_LOGS, custom_path.value());
|
|
}
|
|
} else {
|
|
base::FilePath path;
|
|
if (base::PathService::Get(chrome::DIR_USER_DATA, &path)) {
|
|
path = path.Append(base::FilePath::FromUTF8Unsafe("logs"));
|
|
{
|
|
base::ThreadRestrictions::ScopedAllowIO allow_io;
|
|
base::PathService::Override(DIR_APP_LOGS, path);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// static
|
|
bool App::IsPackaged() {
|
|
auto env = base::Environment::Create();
|
|
if (env->HasVar("ELECTRON_FORCE_IS_PACKAGED"))
|
|
return true;
|
|
|
|
base::FilePath exe_path;
|
|
base::PathService::Get(base::FILE_EXE, &exe_path);
|
|
base::FilePath::StringType base_name =
|
|
base::ToLowerASCII(exe_path.BaseName().value());
|
|
|
|
#if BUILDFLAG(IS_WIN)
|
|
return base_name != FILE_PATH_LITERAL("electron.exe");
|
|
#else
|
|
return base_name != FILE_PATH_LITERAL("electron");
|
|
#endif
|
|
}
|
|
|
|
base::FilePath App::GetPath(gin_helper::ErrorThrower thrower,
|
|
const std::string& name) {
|
|
base::FilePath path;
|
|
|
|
int key = GetPathConstant(name);
|
|
if (key < 0 || !base::PathService::Get(key, &path))
|
|
thrower.ThrowError("Failed to get '" + name + "' path");
|
|
|
|
return path;
|
|
}
|
|
|
|
void App::SetPath(gin_helper::ErrorThrower thrower,
|
|
const std::string& name,
|
|
const base::FilePath& path) {
|
|
if (!path.IsAbsolute()) {
|
|
thrower.ThrowError("Path must be absolute");
|
|
return;
|
|
}
|
|
|
|
int key = GetPathConstant(name);
|
|
if (key < 0 || !base::PathService::OverrideAndCreateIfNeeded(
|
|
key, path, /* is_absolute = */ true, /* create = */ false))
|
|
thrower.ThrowError("Failed to set path");
|
|
}
|
|
|
|
void App::SetDesktopName(const std::string& desktop_name) {
|
|
#if BUILDFLAG(IS_LINUX)
|
|
auto env = base::Environment::Create();
|
|
env->SetVar("CHROME_DESKTOP", desktop_name);
|
|
#endif
|
|
}
|
|
|
|
std::string App::GetLocale() {
|
|
return g_browser_process->GetApplicationLocale();
|
|
}
|
|
|
|
std::string App::GetSystemLocale(gin_helper::ErrorThrower thrower) const {
|
|
if (!Browser::Get()->is_ready()) {
|
|
thrower.ThrowError(
|
|
"app.getSystemLocale() can only be called "
|
|
"after app is ready");
|
|
return std::string();
|
|
}
|
|
return static_cast<BrowserProcessImpl*>(g_browser_process)->GetSystemLocale();
|
|
}
|
|
|
|
std::string App::GetLocaleCountryCode() {
|
|
std::string region;
|
|
#if BUILDFLAG(IS_WIN)
|
|
WCHAR locale_name[LOCALE_NAME_MAX_LENGTH] = {0};
|
|
|
|
if (GetLocaleInfoEx(LOCALE_NAME_USER_DEFAULT, LOCALE_SISO3166CTRYNAME,
|
|
(LPWSTR)&locale_name,
|
|
sizeof(locale_name) / sizeof(WCHAR)) ||
|
|
GetLocaleInfoEx(LOCALE_NAME_SYSTEM_DEFAULT, LOCALE_SISO3166CTRYNAME,
|
|
(LPWSTR)&locale_name,
|
|
sizeof(locale_name) / sizeof(WCHAR))) {
|
|
base::WideToUTF8(locale_name, wcslen(locale_name), ®ion);
|
|
}
|
|
#elif BUILDFLAG(IS_MAC)
|
|
CFLocaleRef locale = CFLocaleCopyCurrent();
|
|
CFStringRef value = CFStringRef(
|
|
static_cast<CFTypeRef>(CFLocaleGetValue(locale, kCFLocaleCountryCode)));
|
|
if (value != nil) {
|
|
char temporaryCString[3];
|
|
const CFIndex kCStringSize = sizeof(temporaryCString);
|
|
if (CFStringGetCString(value, temporaryCString, kCStringSize,
|
|
kCFStringEncodingUTF8)) {
|
|
region = temporaryCString;
|
|
}
|
|
}
|
|
#else
|
|
const char* locale_ptr = setlocale(LC_TIME, nullptr);
|
|
if (!locale_ptr)
|
|
locale_ptr = setlocale(LC_NUMERIC, nullptr);
|
|
if (locale_ptr) {
|
|
std::string locale = locale_ptr;
|
|
std::string::size_type rpos = locale.find('.');
|
|
if (rpos != std::string::npos)
|
|
locale = locale.substr(0, rpos);
|
|
rpos = locale.find('_');
|
|
if (rpos != std::string::npos && rpos + 1 < locale.size())
|
|
region = locale.substr(rpos + 1);
|
|
}
|
|
#endif
|
|
return region.size() == 2 ? region : std::string();
|
|
}
|
|
|
|
void App::OnSecondInstance(const base::CommandLine& cmd,
|
|
const base::FilePath& cwd,
|
|
const std::vector<const uint8_t> additional_data) {
|
|
v8::Isolate* isolate = JavascriptEnvironment::GetIsolate();
|
|
v8::HandleScope handle_scope(isolate);
|
|
v8::Local<v8::Value> data_value =
|
|
DeserializeV8Value(isolate, std::move(additional_data));
|
|
Emit("second-instance", cmd.argv(), cwd, data_value);
|
|
}
|
|
|
|
bool App::HasSingleInstanceLock() const {
|
|
if (process_singleton_)
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
bool App::RequestSingleInstanceLock(gin::Arguments* args) {
|
|
if (HasSingleInstanceLock())
|
|
return true;
|
|
|
|
std::string program_name = electron::Browser::Get()->GetName();
|
|
|
|
base::FilePath user_dir;
|
|
base::PathService::Get(chrome::DIR_USER_DATA, &user_dir);
|
|
// The user_dir may not have been created yet.
|
|
base::CreateDirectoryAndGetError(user_dir, nullptr);
|
|
|
|
auto cb = base::BindRepeating(&App::OnSecondInstance, base::Unretained(this));
|
|
|
|
blink::CloneableMessage additional_data_message;
|
|
args->GetNext(&additional_data_message);
|
|
#if BUILDFLAG(IS_WIN)
|
|
bool app_is_sandboxed =
|
|
IsSandboxEnabled(base::CommandLine::ForCurrentProcess());
|
|
process_singleton_ = std::make_unique<ProcessSingleton>(
|
|
program_name, user_dir, additional_data_message.encoded_message,
|
|
app_is_sandboxed, base::BindRepeating(NotificationCallbackWrapper, cb));
|
|
#else
|
|
process_singleton_ = std::make_unique<ProcessSingleton>(
|
|
user_dir, additional_data_message.encoded_message,
|
|
base::BindRepeating(NotificationCallbackWrapper, cb));
|
|
#endif
|
|
|
|
switch (process_singleton_->NotifyOtherProcessOrCreate()) {
|
|
case ProcessSingleton::NotifyResult::PROCESS_NONE:
|
|
if (content::BrowserThread::IsThreadInitialized(
|
|
content::BrowserThread::IO)) {
|
|
process_singleton_->StartWatching();
|
|
} else {
|
|
watch_singleton_socket_on_ready_ = true;
|
|
}
|
|
return true;
|
|
case ProcessSingleton::NotifyResult::LOCK_ERROR:
|
|
case ProcessSingleton::NotifyResult::PROFILE_IN_USE:
|
|
case ProcessSingleton::NotifyResult::PROCESS_NOTIFIED: {
|
|
process_singleton_.reset();
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
void App::ReleaseSingleInstanceLock() {
|
|
if (process_singleton_) {
|
|
process_singleton_->Cleanup();
|
|
process_singleton_.reset();
|
|
}
|
|
}
|
|
|
|
bool App::Relaunch(gin::Arguments* js_args) {
|
|
// Parse parameters.
|
|
bool override_argv = false;
|
|
base::FilePath exec_path;
|
|
relauncher::StringVector args;
|
|
|
|
gin_helper::Dictionary options;
|
|
if (js_args->GetNext(&options)) {
|
|
bool has_exec_path = options.Get("execPath", &exec_path);
|
|
bool has_args = options.Get("args", &args);
|
|
if (has_exec_path || has_args)
|
|
override_argv = true;
|
|
}
|
|
|
|
if (!override_argv) {
|
|
const relauncher::StringVector& argv =
|
|
electron::ElectronCommandLine::argv();
|
|
return relauncher::RelaunchApp(argv);
|
|
}
|
|
|
|
relauncher::StringVector argv;
|
|
argv.reserve(1 + args.size());
|
|
|
|
if (exec_path.empty()) {
|
|
base::FilePath current_exe_path;
|
|
base::PathService::Get(base::FILE_EXE, ¤t_exe_path);
|
|
argv.push_back(current_exe_path.value());
|
|
} else {
|
|
argv.push_back(exec_path.value());
|
|
}
|
|
|
|
argv.insert(argv.end(), args.begin(), args.end());
|
|
|
|
return relauncher::RelaunchApp(argv);
|
|
}
|
|
|
|
void App::DisableHardwareAcceleration(gin_helper::ErrorThrower thrower) {
|
|
if (Browser::Get()->is_ready()) {
|
|
thrower.ThrowError(
|
|
"app.disableHardwareAcceleration() can only be called "
|
|
"before app is ready");
|
|
return;
|
|
}
|
|
if (content::GpuDataManager::Initialized()) {
|
|
content::GpuDataManager::GetInstance()->DisableHardwareAcceleration();
|
|
} else {
|
|
disable_hw_acceleration_ = true;
|
|
}
|
|
}
|
|
|
|
void App::DisableDomainBlockingFor3DAPIs(gin_helper::ErrorThrower thrower) {
|
|
if (Browser::Get()->is_ready()) {
|
|
thrower.ThrowError(
|
|
"app.disableDomainBlockingFor3DAPIs() can only be called "
|
|
"before app is ready");
|
|
return;
|
|
}
|
|
if (content::GpuDataManager::Initialized()) {
|
|
content::GpuDataManagerImpl::GetInstance()
|
|
->DisableDomainBlockingFor3DAPIsForTesting();
|
|
} else {
|
|
disable_domain_blocking_for_3DAPIs_ = true;
|
|
}
|
|
}
|
|
|
|
bool App::IsAccessibilitySupportEnabled() {
|
|
auto* ax_state = content::BrowserAccessibilityState::GetInstance();
|
|
return ax_state->IsAccessibleBrowser();
|
|
}
|
|
|
|
void App::SetAccessibilitySupportEnabled(gin_helper::ErrorThrower thrower,
|
|
bool enabled) {
|
|
if (!Browser::Get()->is_ready()) {
|
|
thrower.ThrowError(
|
|
"app.setAccessibilitySupportEnabled() can only be called "
|
|
"after app is ready");
|
|
return;
|
|
}
|
|
|
|
auto* ax_state = content::BrowserAccessibilityState::GetInstance();
|
|
if (enabled) {
|
|
ax_state->OnScreenReaderDetected();
|
|
} else {
|
|
ax_state->DisableAccessibility();
|
|
}
|
|
Browser::Get()->OnAccessibilitySupportChanged();
|
|
}
|
|
|
|
Browser::LoginItemSettings App::GetLoginItemSettings(gin::Arguments* args) {
|
|
Browser::LoginItemSettings options;
|
|
args->GetNext(&options);
|
|
return Browser::Get()->GetLoginItemSettings(options);
|
|
}
|
|
|
|
#if BUILDFLAG(USE_NSS_CERTS)
|
|
void App::ImportCertificate(gin_helper::ErrorThrower thrower,
|
|
base::Value options,
|
|
net::CompletionOnceCallback callback) {
|
|
if (!options.is_dict()) {
|
|
thrower.ThrowTypeError("Expected options to be an object");
|
|
return;
|
|
}
|
|
|
|
auto* browser_context = ElectronBrowserContext::From("", false);
|
|
if (!certificate_manager_model_) {
|
|
CertificateManagerModel::Create(
|
|
browser_context,
|
|
base::BindOnce(&App::OnCertificateManagerModelCreated,
|
|
base::Unretained(this), std::move(options),
|
|
std::move(callback)));
|
|
return;
|
|
}
|
|
|
|
int rv =
|
|
ImportIntoCertStore(certificate_manager_model_.get(), std::move(options));
|
|
std::move(callback).Run(rv);
|
|
}
|
|
|
|
void App::OnCertificateManagerModelCreated(
|
|
base::Value options,
|
|
net::CompletionOnceCallback callback,
|
|
std::unique_ptr<CertificateManagerModel> model) {
|
|
certificate_manager_model_ = std::move(model);
|
|
int rv =
|
|
ImportIntoCertStore(certificate_manager_model_.get(), std::move(options));
|
|
std::move(callback).Run(rv);
|
|
}
|
|
#endif
|
|
|
|
#if BUILDFLAG(IS_WIN)
|
|
v8::Local<v8::Value> App::GetJumpListSettings() {
|
|
JumpList jump_list(Browser::Get()->GetAppUserModelID());
|
|
|
|
int min_items = 10;
|
|
std::vector<JumpListItem> removed_items;
|
|
if (jump_list.Begin(&min_items, &removed_items)) {
|
|
// We don't actually want to change anything, so abort the transaction.
|
|
jump_list.Abort();
|
|
} else {
|
|
LOG(ERROR) << "Failed to begin Jump List transaction.";
|
|
}
|
|
|
|
v8::Isolate* isolate = JavascriptEnvironment::GetIsolate();
|
|
gin_helper::Dictionary dict = gin::Dictionary::CreateEmpty(isolate);
|
|
dict.Set("minItems", min_items);
|
|
dict.Set("removedItems", gin::ConvertToV8(isolate, removed_items));
|
|
return dict.GetHandle();
|
|
}
|
|
|
|
JumpListResult App::SetJumpList(v8::Local<v8::Value> val,
|
|
gin::Arguments* args) {
|
|
std::vector<JumpListCategory> categories;
|
|
bool delete_jump_list = val->IsNull();
|
|
if (!delete_jump_list &&
|
|
!gin::ConvertFromV8(args->isolate(), val, &categories)) {
|
|
gin_helper::ErrorThrower(args->isolate())
|
|
.ThrowError("Argument must be null or an array of categories");
|
|
return JumpListResult::kArgumentError;
|
|
}
|
|
|
|
JumpList jump_list(Browser::Get()->GetAppUserModelID());
|
|
|
|
if (delete_jump_list) {
|
|
return jump_list.Delete() ? JumpListResult::kSuccess
|
|
: JumpListResult::kGenericError;
|
|
}
|
|
|
|
// Start a transaction that updates the JumpList of this application.
|
|
if (!jump_list.Begin())
|
|
return JumpListResult::kGenericError;
|
|
|
|
JumpListResult result = jump_list.AppendCategories(categories);
|
|
// AppendCategories may have failed to add some categories, but it's better
|
|
// to have something than nothing so try to commit the changes anyway.
|
|
if (!jump_list.Commit()) {
|
|
LOG(ERROR) << "Failed to commit changes to custom Jump List.";
|
|
// It's more useful to return the earlier error code that might give
|
|
// some indication as to why the transaction actually failed, so don't
|
|
// overwrite it with a "generic error" code here.
|
|
if (result == JumpListResult::kSuccess)
|
|
result = JumpListResult::kGenericError;
|
|
}
|
|
|
|
return result;
|
|
}
|
|
#endif // BUILDFLAG(IS_WIN)
|
|
|
|
v8::Local<v8::Promise> App::GetFileIcon(const base::FilePath& path,
|
|
gin::Arguments* args) {
|
|
v8::Isolate* isolate = JavascriptEnvironment::GetIsolate();
|
|
gin_helper::Promise<gfx::Image> promise(isolate);
|
|
v8::Local<v8::Promise> handle = promise.GetHandle();
|
|
base::FilePath normalized_path = path.NormalizePathSeparators();
|
|
|
|
IconLoader::IconSize icon_size;
|
|
gin_helper::Dictionary options;
|
|
if (!args->GetNext(&options)) {
|
|
icon_size = IconLoader::IconSize::NORMAL;
|
|
} else {
|
|
std::string icon_size_string;
|
|
options.Get("size", &icon_size_string);
|
|
icon_size = GetIconSizeByString(icon_size_string);
|
|
}
|
|
|
|
auto* icon_manager = ElectronBrowserMainParts::Get()->GetIconManager();
|
|
gfx::Image* icon =
|
|
icon_manager->LookupIconFromFilepath(normalized_path, icon_size, 1.0f);
|
|
if (icon) {
|
|
promise.Resolve(*icon);
|
|
} else {
|
|
icon_manager->LoadIcon(
|
|
normalized_path, icon_size, 1.0f,
|
|
base::BindOnce(&OnIconDataAvailable, std::move(promise)),
|
|
&cancelable_task_tracker_);
|
|
}
|
|
return handle;
|
|
}
|
|
|
|
std::vector<gin_helper::Dictionary> App::GetAppMetrics(v8::Isolate* isolate) {
|
|
std::vector<gin_helper::Dictionary> result;
|
|
result.reserve(app_metrics_.size());
|
|
int processor_count = base::SysInfo::NumberOfProcessors();
|
|
|
|
for (const auto& process_metric : app_metrics_) {
|
|
gin_helper::Dictionary pid_dict = gin::Dictionary::CreateEmpty(isolate);
|
|
gin_helper::Dictionary cpu_dict = gin::Dictionary::CreateEmpty(isolate);
|
|
|
|
pid_dict.SetHidden("simple", true);
|
|
cpu_dict.SetHidden("simple", true);
|
|
cpu_dict.Set(
|
|
"percentCPUUsage",
|
|
process_metric.second->metrics->GetPlatformIndependentCPUUsage() /
|
|
processor_count);
|
|
|
|
#if !BUILDFLAG(IS_WIN)
|
|
cpu_dict.Set("idleWakeupsPerSecond",
|
|
process_metric.second->metrics->GetIdleWakeupsPerSecond());
|
|
#else
|
|
// Chrome's underlying process_metrics.cc will throw a non-fatal warning
|
|
// that this method isn't implemented on Windows, so set it to 0 instead
|
|
// of calling it
|
|
cpu_dict.Set("idleWakeupsPerSecond", 0);
|
|
#endif
|
|
|
|
pid_dict.Set("cpu", cpu_dict);
|
|
pid_dict.Set("pid", process_metric.second->process.Pid());
|
|
pid_dict.Set("type", content::GetProcessTypeNameInEnglish(
|
|
process_metric.second->type));
|
|
pid_dict.Set("creationTime",
|
|
process_metric.second->process.CreationTime().ToJsTime());
|
|
|
|
if (!process_metric.second->service_name.empty()) {
|
|
pid_dict.Set("serviceName", process_metric.second->service_name);
|
|
}
|
|
|
|
if (!process_metric.second->name.empty()) {
|
|
pid_dict.Set("name", process_metric.second->name);
|
|
}
|
|
|
|
#if !BUILDFLAG(IS_LINUX)
|
|
auto memory_info = process_metric.second->GetMemoryInfo();
|
|
|
|
gin_helper::Dictionary memory_dict = gin::Dictionary::CreateEmpty(isolate);
|
|
memory_dict.SetHidden("simple", true);
|
|
memory_dict.Set("workingSetSize",
|
|
static_cast<double>(memory_info.working_set_size >> 10));
|
|
memory_dict.Set(
|
|
"peakWorkingSetSize",
|
|
static_cast<double>(memory_info.peak_working_set_size >> 10));
|
|
|
|
#if BUILDFLAG(IS_WIN)
|
|
memory_dict.Set("privateBytes",
|
|
static_cast<double>(memory_info.private_bytes >> 10));
|
|
#endif
|
|
|
|
pid_dict.Set("memory", memory_dict);
|
|
#endif
|
|
|
|
#if BUILDFLAG(IS_MAC)
|
|
pid_dict.Set("sandboxed", process_metric.second->IsSandboxed());
|
|
#elif BUILDFLAG(IS_WIN)
|
|
auto integrity_level = process_metric.second->GetIntegrityLevel();
|
|
auto sandboxed = ProcessMetric::IsSandboxed(integrity_level);
|
|
pid_dict.Set("integrityLevel", integrity_level);
|
|
pid_dict.Set("sandboxed", sandboxed);
|
|
#endif
|
|
|
|
result.push_back(pid_dict);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
v8::Local<v8::Value> App::GetGPUFeatureStatus(v8::Isolate* isolate) {
|
|
return gin::ConvertToV8(isolate, content::GetFeatureStatus());
|
|
}
|
|
|
|
v8::Local<v8::Promise> App::GetGPUInfo(v8::Isolate* isolate,
|
|
const std::string& info_type) {
|
|
auto* const gpu_data_manager = content::GpuDataManagerImpl::GetInstance();
|
|
gin_helper::Promise<base::Value> promise(isolate);
|
|
v8::Local<v8::Promise> handle = promise.GetHandle();
|
|
if (info_type != "basic" && info_type != "complete") {
|
|
promise.RejectWithErrorMessage(
|
|
"Invalid info type. Use 'basic' or 'complete'");
|
|
return handle;
|
|
}
|
|
std::string reason;
|
|
if (!gpu_data_manager->GpuAccessAllowed(&reason)) {
|
|
promise.RejectWithErrorMessage("GPU access not allowed. Reason: " + reason);
|
|
return handle;
|
|
}
|
|
|
|
auto* const info_mgr = GPUInfoManager::GetInstance();
|
|
if (info_type == "complete") {
|
|
#if BUILDFLAG(IS_WIN) || BUILDFLAG(IS_MAC)
|
|
info_mgr->FetchCompleteInfo(std::move(promise));
|
|
#else
|
|
info_mgr->FetchBasicInfo(std::move(promise));
|
|
#endif
|
|
} else /* (info_type == "basic") */ {
|
|
info_mgr->FetchBasicInfo(std::move(promise));
|
|
}
|
|
return handle;
|
|
}
|
|
|
|
static void RemoveNoSandboxSwitch(base::CommandLine* command_line) {
|
|
if (command_line->HasSwitch(sandbox::policy::switches::kNoSandbox)) {
|
|
const base::CommandLine::CharType* noSandboxArg =
|
|
FILE_PATH_LITERAL("--no-sandbox");
|
|
base::CommandLine::StringVector modified_command_line;
|
|
for (auto& arg : command_line->argv()) {
|
|
if (arg.compare(noSandboxArg) != 0) {
|
|
modified_command_line.push_back(arg);
|
|
}
|
|
}
|
|
command_line->InitFromArgv(modified_command_line);
|
|
}
|
|
}
|
|
|
|
void App::EnableSandbox(gin_helper::ErrorThrower thrower) {
|
|
if (Browser::Get()->is_ready()) {
|
|
thrower.ThrowError(
|
|
"app.enableSandbox() can only be called "
|
|
"before app is ready");
|
|
return;
|
|
}
|
|
|
|
auto* command_line = base::CommandLine::ForCurrentProcess();
|
|
RemoveNoSandboxSwitch(command_line);
|
|
command_line->AppendSwitch(switches::kEnableSandbox);
|
|
}
|
|
|
|
void App::SetUserAgentFallback(const std::string& user_agent) {
|
|
ElectronBrowserClient::Get()->SetUserAgent(user_agent);
|
|
}
|
|
|
|
#if BUILDFLAG(IS_WIN)
|
|
|
|
bool App::IsRunningUnderARM64Translation() const {
|
|
USHORT processMachine = 0;
|
|
USHORT nativeMachine = 0;
|
|
|
|
auto IsWow64Process2 = reinterpret_cast<decltype(&::IsWow64Process2)>(
|
|
GetProcAddress(GetModuleHandle(L"kernel32.dll"), "IsWow64Process2"));
|
|
|
|
if (IsWow64Process2 == nullptr) {
|
|
return false;
|
|
}
|
|
|
|
if (!IsWow64Process2(GetCurrentProcess(), &processMachine, &nativeMachine)) {
|
|
return false;
|
|
}
|
|
|
|
return nativeMachine == IMAGE_FILE_MACHINE_ARM64;
|
|
}
|
|
#endif
|
|
|
|
std::string App::GetUserAgentFallback() {
|
|
return ElectronBrowserClient::Get()->GetUserAgent();
|
|
}
|
|
|
|
#if BUILDFLAG(IS_MAC)
|
|
bool App::MoveToApplicationsFolder(gin_helper::ErrorThrower thrower,
|
|
gin::Arguments* args) {
|
|
return ElectronBundleMover::Move(thrower, args);
|
|
}
|
|
|
|
bool App::IsInApplicationsFolder() {
|
|
return ElectronBundleMover::IsCurrentAppInApplicationsFolder();
|
|
}
|
|
|
|
int DockBounce(gin::Arguments* args) {
|
|
int request_id = -1;
|
|
std::string type = "informational";
|
|
args->GetNext(&type);
|
|
|
|
if (type == "critical")
|
|
request_id = Browser::Get()->DockBounce(Browser::BounceType::kCritical);
|
|
else if (type == "informational")
|
|
request_id =
|
|
Browser::Get()->DockBounce(Browser::BounceType::kInformational);
|
|
return request_id;
|
|
}
|
|
|
|
void DockSetMenu(electron::api::Menu* menu) {
|
|
Browser::Get()->DockSetMenu(menu->model());
|
|
}
|
|
|
|
v8::Local<v8::Value> App::GetDockAPI(v8::Isolate* isolate) {
|
|
if (dock_.IsEmpty()) {
|
|
// Initialize the Dock API, the methods are bound to "dock" which exists
|
|
// for the lifetime of "app"
|
|
auto browser = base::Unretained(Browser::Get());
|
|
gin_helper::Dictionary dock_obj = gin::Dictionary::CreateEmpty(isolate);
|
|
dock_obj.SetMethod("bounce", &DockBounce);
|
|
dock_obj.SetMethod(
|
|
"cancelBounce",
|
|
base::BindRepeating(&Browser::DockCancelBounce, browser));
|
|
dock_obj.SetMethod(
|
|
"downloadFinished",
|
|
base::BindRepeating(&Browser::DockDownloadFinished, browser));
|
|
dock_obj.SetMethod(
|
|
"setBadge", base::BindRepeating(&Browser::DockSetBadgeText, browser));
|
|
dock_obj.SetMethod(
|
|
"getBadge", base::BindRepeating(&Browser::DockGetBadgeText, browser));
|
|
dock_obj.SetMethod("hide",
|
|
base::BindRepeating(&Browser::DockHide, browser));
|
|
dock_obj.SetMethod("show",
|
|
base::BindRepeating(&Browser::DockShow, browser));
|
|
dock_obj.SetMethod("isVisible",
|
|
base::BindRepeating(&Browser::DockIsVisible, browser));
|
|
dock_obj.SetMethod("setMenu", &DockSetMenu);
|
|
dock_obj.SetMethod("setIcon",
|
|
base::BindRepeating(&Browser::DockSetIcon, browser));
|
|
|
|
dock_.Reset(isolate, dock_obj.GetHandle());
|
|
}
|
|
return v8::Local<v8::Value>::New(isolate, dock_);
|
|
}
|
|
#endif
|
|
|
|
void ConfigureHostResolver(v8::Isolate* isolate,
|
|
const gin_helper::Dictionary& opts) {
|
|
gin_helper::ErrorThrower thrower(isolate);
|
|
if (!Browser::Get()->is_ready()) {
|
|
thrower.ThrowError(
|
|
"configureHostResolver cannot be called before the app is ready");
|
|
return;
|
|
}
|
|
net::SecureDnsMode secure_dns_mode = net::SecureDnsMode::kOff;
|
|
std::string default_doh_templates;
|
|
if (base::FeatureList::IsEnabled(features::kDnsOverHttps)) {
|
|
if (features::kDnsOverHttpsFallbackParam.Get()) {
|
|
secure_dns_mode = net::SecureDnsMode::kAutomatic;
|
|
} else {
|
|
secure_dns_mode = net::SecureDnsMode::kSecure;
|
|
}
|
|
default_doh_templates = features::kDnsOverHttpsTemplatesParam.Get();
|
|
}
|
|
|
|
net::DnsOverHttpsConfig doh_config;
|
|
if (!default_doh_templates.empty() &&
|
|
secure_dns_mode != net::SecureDnsMode::kOff) {
|
|
auto maybe_doh_config =
|
|
net::DnsOverHttpsConfig::FromString(default_doh_templates);
|
|
if (maybe_doh_config.has_value())
|
|
doh_config = maybe_doh_config.value();
|
|
}
|
|
|
|
bool enable_built_in_resolver =
|
|
base::FeatureList::IsEnabled(features::kAsyncDns);
|
|
bool additional_dns_query_types_enabled = true;
|
|
|
|
if (opts.Has("enableBuiltInResolver") &&
|
|
!opts.Get("enableBuiltInResolver", &enable_built_in_resolver)) {
|
|
thrower.ThrowTypeError("enableBuiltInResolver must be a boolean");
|
|
return;
|
|
}
|
|
|
|
if (opts.Has("secureDnsMode") &&
|
|
!opts.Get("secureDnsMode", &secure_dns_mode)) {
|
|
thrower.ThrowTypeError(
|
|
"secureDnsMode must be one of: off, automatic, secure");
|
|
return;
|
|
}
|
|
|
|
std::vector<std::string> secure_dns_server_strings;
|
|
if (opts.Has("secureDnsServers")) {
|
|
if (!opts.Get("secureDnsServers", &secure_dns_server_strings)) {
|
|
thrower.ThrowTypeError("secureDnsServers must be an array of strings");
|
|
return;
|
|
}
|
|
|
|
// Validate individual server templates prior to batch-assigning to
|
|
// doh_config.
|
|
std::vector<net::DnsOverHttpsServerConfig> servers;
|
|
for (const std::string& server_template : secure_dns_server_strings) {
|
|
absl::optional<net::DnsOverHttpsServerConfig> server_config =
|
|
net::DnsOverHttpsServerConfig::FromString(server_template);
|
|
if (!server_config.has_value()) {
|
|
thrower.ThrowTypeError(std::string("not a valid DoH template: ") +
|
|
server_template);
|
|
return;
|
|
}
|
|
servers.push_back(*server_config);
|
|
}
|
|
doh_config = net::DnsOverHttpsConfig(std::move(servers));
|
|
}
|
|
|
|
if (opts.Has("enableAdditionalDnsQueryTypes") &&
|
|
!opts.Get("enableAdditionalDnsQueryTypes",
|
|
&additional_dns_query_types_enabled)) {
|
|
thrower.ThrowTypeError("enableAdditionalDnsQueryTypes must be a boolean");
|
|
return;
|
|
}
|
|
|
|
// Configure the stub resolver. This must be done after the system
|
|
// NetworkContext is created, but before anything has the chance to use it.
|
|
content::GetNetworkService()->ConfigureStubHostResolver(
|
|
enable_built_in_resolver, secure_dns_mode, doh_config,
|
|
additional_dns_query_types_enabled);
|
|
}
|
|
|
|
// static
|
|
App* App::Get() {
|
|
static base::NoDestructor<App> app;
|
|
return app.get();
|
|
}
|
|
|
|
// static
|
|
gin::Handle<App> App::Create(v8::Isolate* isolate) {
|
|
return gin::CreateHandle(isolate, Get());
|
|
}
|
|
|
|
gin::ObjectTemplateBuilder App::GetObjectTemplateBuilder(v8::Isolate* isolate) {
|
|
auto browser = base::Unretained(Browser::Get());
|
|
return gin_helper::EventEmitterMixin<App>::GetObjectTemplateBuilder(isolate)
|
|
.SetMethod("quit", base::BindRepeating(&Browser::Quit, browser))
|
|
.SetMethod("exit", base::BindRepeating(&Browser::Exit, browser))
|
|
.SetMethod("focus", base::BindRepeating(&Browser::Focus, browser))
|
|
.SetMethod("getVersion",
|
|
base::BindRepeating(&Browser::GetVersion, browser))
|
|
.SetMethod("setVersion",
|
|
base::BindRepeating(&Browser::SetVersion, browser))
|
|
.SetMethod("getName", base::BindRepeating(&Browser::GetName, browser))
|
|
.SetMethod("setName", base::BindRepeating(&Browser::SetName, browser))
|
|
.SetMethod("isReady", base::BindRepeating(&Browser::is_ready, browser))
|
|
.SetMethod("whenReady", base::BindRepeating(&Browser::WhenReady, browser))
|
|
.SetMethod("addRecentDocument",
|
|
base::BindRepeating(&Browser::AddRecentDocument, browser))
|
|
.SetMethod("clearRecentDocuments",
|
|
base::BindRepeating(&Browser::ClearRecentDocuments, browser))
|
|
#if BUILDFLAG(IS_WIN)
|
|
.SetMethod("setAppUserModelId",
|
|
base::BindRepeating(&Browser::SetAppUserModelID, browser))
|
|
#endif
|
|
.SetMethod(
|
|
"isDefaultProtocolClient",
|
|
base::BindRepeating(&Browser::IsDefaultProtocolClient, browser))
|
|
.SetMethod(
|
|
"setAsDefaultProtocolClient",
|
|
base::BindRepeating(&Browser::SetAsDefaultProtocolClient, browser))
|
|
.SetMethod(
|
|
"removeAsDefaultProtocolClient",
|
|
base::BindRepeating(&Browser::RemoveAsDefaultProtocolClient, browser))
|
|
#if !BUILDFLAG(IS_LINUX)
|
|
.SetMethod(
|
|
"getApplicationInfoForProtocol",
|
|
base::BindRepeating(&Browser::GetApplicationInfoForProtocol, browser))
|
|
#endif
|
|
.SetMethod(
|
|
"getApplicationNameForProtocol",
|
|
base::BindRepeating(&Browser::GetApplicationNameForProtocol, browser))
|
|
.SetMethod("setBadgeCount",
|
|
base::BindRepeating(&Browser::SetBadgeCount, browser))
|
|
.SetMethod("getBadgeCount",
|
|
base::BindRepeating(&Browser::GetBadgeCount, browser))
|
|
.SetMethod("getLoginItemSettings", &App::GetLoginItemSettings)
|
|
.SetMethod("setLoginItemSettings",
|
|
base::BindRepeating(&Browser::SetLoginItemSettings, browser))
|
|
.SetMethod("isEmojiPanelSupported",
|
|
base::BindRepeating(&Browser::IsEmojiPanelSupported, browser))
|
|
#if BUILDFLAG(IS_MAC)
|
|
.SetMethod("hide", base::BindRepeating(&Browser::Hide, browser))
|
|
.SetMethod("isHidden", base::BindRepeating(&Browser::IsHidden, browser))
|
|
.SetMethod("show", base::BindRepeating(&Browser::Show, browser))
|
|
.SetMethod("setUserActivity",
|
|
base::BindRepeating(&Browser::SetUserActivity, browser))
|
|
.SetMethod("getCurrentActivityType",
|
|
base::BindRepeating(&Browser::GetCurrentActivityType, browser))
|
|
.SetMethod(
|
|
"invalidateCurrentActivity",
|
|
base::BindRepeating(&Browser::InvalidateCurrentActivity, browser))
|
|
.SetMethod("resignCurrentActivity",
|
|
base::BindRepeating(&Browser::ResignCurrentActivity, browser))
|
|
.SetMethod("updateCurrentActivity",
|
|
base::BindRepeating(&Browser::UpdateCurrentActivity, browser))
|
|
.SetMethod("moveToApplicationsFolder", &App::MoveToApplicationsFolder)
|
|
.SetMethod("isInApplicationsFolder", &App::IsInApplicationsFolder)
|
|
.SetMethod("setActivationPolicy", &App::SetActivationPolicy)
|
|
#endif
|
|
.SetMethod("setAboutPanelOptions",
|
|
base::BindRepeating(&Browser::SetAboutPanelOptions, browser))
|
|
.SetMethod("showAboutPanel",
|
|
base::BindRepeating(&Browser::ShowAboutPanel, browser))
|
|
#if BUILDFLAG(IS_MAC)
|
|
.SetMethod(
|
|
"isSecureKeyboardEntryEnabled",
|
|
base::BindRepeating(&Browser::IsSecureKeyboardEntryEnabled, browser))
|
|
.SetMethod(
|
|
"setSecureKeyboardEntryEnabled",
|
|
base::BindRepeating(&Browser::SetSecureKeyboardEntryEnabled, browser))
|
|
#endif
|
|
#if BUILDFLAG(IS_MAC) || BUILDFLAG(IS_WIN)
|
|
.SetMethod("showEmojiPanel",
|
|
base::BindRepeating(&Browser::ShowEmojiPanel, browser))
|
|
#endif
|
|
#if BUILDFLAG(IS_WIN)
|
|
.SetMethod("setUserTasks",
|
|
base::BindRepeating(&Browser::SetUserTasks, browser))
|
|
.SetMethod("getJumpListSettings", &App::GetJumpListSettings)
|
|
.SetMethod("setJumpList", &App::SetJumpList)
|
|
#endif
|
|
#if BUILDFLAG(IS_LINUX)
|
|
.SetMethod("isUnityRunning",
|
|
base::BindRepeating(&Browser::IsUnityRunning, browser))
|
|
#endif
|
|
.SetProperty("isPackaged", &App::IsPackaged)
|
|
.SetMethod("setAppPath", &App::SetAppPath)
|
|
.SetMethod("getAppPath", &App::GetAppPath)
|
|
.SetMethod("setPath", &App::SetPath)
|
|
.SetMethod("getPath", &App::GetPath)
|
|
.SetMethod("setAppLogsPath", &App::SetAppLogsPath)
|
|
.SetMethod("setDesktopName", &App::SetDesktopName)
|
|
.SetMethod("getLocale", &App::GetLocale)
|
|
.SetMethod("getPreferredSystemLanguages", &GetPreferredLanguages)
|
|
.SetMethod("getSystemLocale", &App::GetSystemLocale)
|
|
.SetMethod("getLocaleCountryCode", &App::GetLocaleCountryCode)
|
|
#if BUILDFLAG(USE_NSS_CERTS)
|
|
.SetMethod("importCertificate", &App::ImportCertificate)
|
|
#endif
|
|
.SetMethod("hasSingleInstanceLock", &App::HasSingleInstanceLock)
|
|
.SetMethod("requestSingleInstanceLock", &App::RequestSingleInstanceLock)
|
|
.SetMethod("releaseSingleInstanceLock", &App::ReleaseSingleInstanceLock)
|
|
.SetMethod("relaunch", &App::Relaunch)
|
|
.SetMethod("isAccessibilitySupportEnabled",
|
|
&App::IsAccessibilitySupportEnabled)
|
|
.SetMethod("setAccessibilitySupportEnabled",
|
|
&App::SetAccessibilitySupportEnabled)
|
|
.SetMethod("disableHardwareAcceleration",
|
|
&App::DisableHardwareAcceleration)
|
|
.SetMethod("disableDomainBlockingFor3DAPIs",
|
|
&App::DisableDomainBlockingFor3DAPIs)
|
|
.SetMethod("getFileIcon", &App::GetFileIcon)
|
|
.SetMethod("getAppMetrics", &App::GetAppMetrics)
|
|
.SetMethod("getGPUFeatureStatus", &App::GetGPUFeatureStatus)
|
|
.SetMethod("getGPUInfo", &App::GetGPUInfo)
|
|
#if IS_MAS_BUILD()
|
|
.SetMethod("startAccessingSecurityScopedResource",
|
|
&App::StartAccessingSecurityScopedResource)
|
|
#endif
|
|
#if BUILDFLAG(IS_MAC)
|
|
.SetProperty("dock", &App::GetDockAPI)
|
|
.SetProperty("runningUnderRosettaTranslation",
|
|
&App::IsRunningUnderRosettaTranslation)
|
|
#endif
|
|
#if BUILDFLAG(IS_MAC) || BUILDFLAG(IS_WIN)
|
|
.SetProperty("runningUnderARM64Translation",
|
|
&App::IsRunningUnderARM64Translation)
|
|
#endif
|
|
.SetProperty("userAgentFallback", &App::GetUserAgentFallback,
|
|
&App::SetUserAgentFallback)
|
|
.SetMethod("configureHostResolver", &ConfigureHostResolver)
|
|
.SetMethod("enableSandbox", &App::EnableSandbox);
|
|
}
|
|
|
|
const char* App::GetTypeName() {
|
|
return "App";
|
|
}
|
|
|
|
} // namespace electron::api
|
|
|
|
namespace {
|
|
|
|
void Initialize(v8::Local<v8::Object> exports,
|
|
v8::Local<v8::Value> unused,
|
|
v8::Local<v8::Context> context,
|
|
void* priv) {
|
|
v8::Isolate* isolate = context->GetIsolate();
|
|
gin_helper::Dictionary dict(isolate, exports);
|
|
dict.Set("app", electron::api::App::Create(isolate));
|
|
}
|
|
|
|
} // namespace
|
|
|
|
NODE_LINKED_MODULE_CONTEXT_AWARE(electron_browser_app, Initialize)
|