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");

}

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;

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;

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);

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;

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();

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;

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);

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;

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);

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;

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();

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;

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();

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;

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;

if (size == "small") {

return IconLoader::IconSize::SMALL;

} else if (size == "large") {

return IconLoader::IconSize::LARGE;

}

return IconLoader::IconSize::NORMAL;

if (name == "appData")

return DIR_APP_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;

const base::RepeatingCallback<

void(const base::CommandLine& command_line,

const base::FilePath& current_directory,

const std::vector<uint8_t> additional_data,

const ProcessSingleton::NotificationAckCallback& ack_callback)>&

callback,

const base::CommandLine& cmd,

const base::FilePath& cwd,

const std::vector<uint8_t> additional_data,

const ProcessSingleton::NotificationAckCallback& ack_callback) {

// Make sure the callback is called after app gets ready.

if (Browser::Get()->is_ready()) {

callback.Run(cmd, cwd, std::move(additional_data), ack_callback);

} 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), ack_callback));

}

// ProcessSingleton needs to know whether current process is quiting.

return !Browser::Get()->is_shutting_down();

scoped_refptr<net::X509Certificate> cert,

scoped_refptr<net::SSLPrivateKey> private_key) {

delegate->ContinueWithCertificate(cert, private_key);

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;

}

}

}

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;

gfx::Image icon) {

if (!icon.IsEmpty()) {

promise.Resolve(icon);

} else {

promise.RejectWithErrorMessage("Failed to get file icon.");

}

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);

if (Emit("before-quit")) {

*prevent_default = true;

}

if (Emit("will-quit")) {

*prevent_default = true;

}

const int exitCode = ElectronBrowserMainParts::Get()->GetExitCode();

Emit("quit", exitCode);

if (process_singleton_) {

process_singleton_->Cleanup();

process_singleton_.reset();

}

if (Emit("open-file", file_path)) {

*prevent_default = true;

}

#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", launch_info);

content::BrowserChildProcessObserver::Add(this);

if (process_singleton_) {

process_singleton_->OnBrowserReady();

}

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();

}

const std::string& type) {

if (Emit("will-continue-activity", type)) {

*prevent_default = true;

}

const std::string& type,

const base::DictionaryValue& user_info,

const base::DictionaryValue& details) {

if (Emit("continue-activity", type, user_info, details)) {

*prevent_default = true;

}

const std::string& type,

const base::DictionaryValue& user_info) {

if (Emit("update-activity-state", type, user_info)) {

*prevent_default = true;

}

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::Locker locker(isolate);

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;

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::Locker locker(isolate);

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);

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();

const content::ChildProcessData& data) {

ChildProcessLaunched(data.process_type, data.id, data.GetProcess().Handle(),

data.metrics_name, base::UTF16ToUTF8(data.name));

const content::ChildProcessData& data,

const content::ChildProcessTerminationInfo& info) {

ChildProcessDisconnected(data.id);

BrowserChildProcessCrashedOrKilled(data, info);

const content::ChildProcessData& data,

const content::ChildProcessTerminationInfo& info) {

ChildProcessDisconnected(data.id);

BrowserChildProcessCrashedOrKilled(data, info);

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);

}

Emit("child-process-gone", details);

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);

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);

}

}

}

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());