electron::ProcessIntegrityLevel value) {

switch (value) {

case electron::ProcessIntegrityLevel::Untrusted:

return mate::StringToV8(isolate, "untrusted");

case electron::ProcessIntegrityLevel::Low:

return mate::StringToV8(isolate, "low");

case electron::ProcessIntegrityLevel::Medium:

return mate::StringToV8(isolate, "medium");

case electron::ProcessIntegrityLevel::High:

return mate::StringToV8(isolate, "high");

default:

return mate::StringToV8(isolate, "unknown");

}

v8::Local<v8::Value> val,

Browser::UserTask* out) {

mate::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::TASK;

else if (item_type == "separator")

*out = JumpListItem::Type::SEPARATOR;

else if (item_type == "file")

*out = JumpListItem::Type::FILE;

else

return false;

return true;

JumpListItem::Type val) {

std::string item_type;

switch (val) {

case JumpListItem::Type::TASK:

item_type = "task";

break;

case JumpListItem::Type::SEPARATOR:

item_type = "separator";

break;

case JumpListItem::Type::FILE:

item_type = "file";

break;

}

return mate::ConvertToV8(isolate, item_type);

v8::Local<v8::Value> val,

JumpListItem* out) {

mate::Dictionary dict;

if (!ConvertFromV8(isolate, val, &dict))

return false;

if (!dict.Get("type", &(out->type)))

return false;

switch (out->type) {

case JumpListItem::Type::TASK:

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::SEPARATOR:

return true;

case JumpListItem::Type::FILE:

return dict.Get("path", &(out->path));

}

assert(false);

return false;

const JumpListItem& val) {

mate::Dictionary dict = mate::Dictionary::CreateEmpty(isolate);

dict.Set("type", val.type);

switch (val.type) {

case JumpListItem::Type::TASK:

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::SEPARATOR:

break;

case JumpListItem::Type::FILE:

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::TASKS;

else if (category_type == "frequent")

*out = JumpListCategory::Type::FREQUENT;

else if (category_type == "recent")

*out = JumpListCategory::Type::RECENT;

else if (category_type == "custom")

*out = JumpListCategory::Type::CUSTOM;

else

return false;

return true;

JumpListCategory::Type val) {

std::string category_type;

switch (val) {

case JumpListCategory::Type::TASKS:

category_type = "tasks";

break;

case JumpListCategory::Type::FREQUENT:

category_type = "frequent";

break;

case JumpListCategory::Type::RECENT:

category_type = "recent";

break;

case JumpListCategory::Type::CUSTOM:

category_type = "custom";

break;

}

return mate::ConvertToV8(isolate, category_type);

v8::Local<v8::Value> val,

JumpListCategory* out) {

mate::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::TASKS;

else

out->type = JumpListCategory::Type::CUSTOM;

}

if ((out->type == JumpListCategory::Type::TASKS) ||

(out->type == JumpListCategory::Type::CUSTOM)) {

if (!dict.Get("items", &(out->items)))

return false;

}

return true;

std::string result_code;

switch (val) {

case JumpListResult::SUCCESS:

result_code = "ok";

break;

case JumpListResult::ARGUMENT_ERROR:

result_code = "argumentError";

break;

case JumpListResult::GENERIC_ERROR:

result_code = "error";

break;

case JumpListResult::CUSTOM_CATEGORY_SEPARATOR_ERROR:

result_code = "invalidSeparatorError";

break;

case JumpListResult::MISSING_FILE_TYPE_REGISTRATION_ERROR:

result_code = "fileTypeRegistrationError";

break;

case JumpListResult::CUSTOM_CATEGORY_ACCESS_DENIED_ERROR:

result_code = "customCategoryAccessDeniedError";

break;

}

return ConvertToV8(isolate, result_code);

v8::Local<v8::Value> val,

Browser::LoginItemSettings* out) {

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

return true;

Browser::LoginItemSettings val) {

mate::Dictionary dict = mate::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);

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

return true;

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

else if (name == "cache")

return DIR_CACHE;

else if (name == "userCache")

return DIR_USER_CACHE;

else if (name == "logs")

return DIR_APP_LOGS;

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;

else if (name == "pepperFlashSystemPlugin")

return chrome::FILE_PEPPER_FLASH_SYSTEM_PLUGIN;

else

return -1;

const base::RepeatingCallback<

void(const base::CommandLine::StringVector& command_line,

const base::FilePath& current_directory)>& callback,

const base::CommandLine::StringVector& cmd,

const base::FilePath& cwd) {

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

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

callback.Run(cmd, cwd);

} else {

scoped_refptr<base::SingleThreadTaskRunner> task_runner(

base::ThreadTaskRunnerHandle::Get());

task_runner->PostTask(

FROM_HERE, base::BindOnce(base::IgnoreResult(callback), cmd, cwd));

}

// 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,

mate::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;

}

mate::Dictionary cert_data;

if (!mate::ConvertFromV8(isolate, val, &cert_data)) {

args->ThrowError("Must pass valid certificate object.");

return;

}

std::string data;

if (!cert_data.Get("data", &data))

return;

auto certs = net::X509Certificate::CreateCertificateListFromBytes(

data.c_str(), data.length(), net::X509Certificate::FORMAT_AUTO);

if (!certs.empty()) {

scoped_refptr<net::X509Certificate> cert(certs[0].get());

for (size_t i = 0; i < identities->size(); ++i) {

if (cert->EqualsExcludingChain((*identities)[i]->certificate())) {

net::ClientCertIdentity::SelfOwningAcquirePrivateKey(

std::move((*identities)[i]),

base::BindRepeating(&GotPrivateKey, delegate, std::move(cert)));

break;

}

}

}

const base::DictionaryValue& options) {

std::string file_data, cert_path;

base::string16 password;

net::ScopedCERTCertificateList imported_certs;

int rv = -1;

options.GetString("certificate", &cert_path);

options.GetString("password", &password);

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;

if (!icon.IsEmpty()) {

promise.Resolve(icon);

} else {

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

}

static_cast<AtomBrowserClient*>(AtomBrowserClient::Get())->set_delegate(this);

Browser::Get()->AddObserver(this);

content::GpuDataManager::GetInstance()->AddObserver(this);

base::ProcessId pid = base::GetCurrentProcId();

auto process_metric = std::make_unique<electron::ProcessMetric>(

content::PROCESS_TYPE_BROWSER, base::GetCurrentProcessHandle(),

base::ProcessMetrics::CreateCurrentProcessMetrics());

app_metrics_[pid] = std::move(process_metric);

Init(isolate);

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

*prevent_default = true;

}

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

*prevent_default = true;

}

int exitCode = AtomBrowserMainParts::Get()->GetExitCode();

Emit("quit", exitCode);

if (process_singleton_) {

process_singleton_->Cleanup();

process_singleton_.reset();

}

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

*prevent_default = true;

}

#if defined(OS_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();

}

const std::string& type) {

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

*prevent_default = true;

}

const std::string& type,

const base::DictionaryValue& user_info) {

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

*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::vector<std::string>& additional_features,

const scoped_refptr<network::ResourceRequestBody>& body,

bool user_gesture,

bool opener_suppressed,

bool* no_javascript_access) {

v8::Locker locker(isolate());

v8::HandleScope handle_scope(isolate());

content::WebContents* web_contents =

content::WebContents::FromRenderFrameHost(opener);

if (web_contents) {

auto api_web_contents = WebContents::From(isolate(), web_contents);

// No need to emit any event if the WebContents is not available in JS.

if (!api_web_contents.IsEmpty()) {

api_web_contents->OnCreateWindow(target_url, referrer, frame_name,

disposition, additional_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,

const base::RepeatingCallback<void(content::CertificateRequestResultType)>&

callback) {

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

// Deny the certificate by default.

if (!prevent_default)

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.push_back(identity->certificate());

auto shared_identities =

std::make_shared<net::ClientCertIdentityList>(std::move(identities));

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,

const content::ChildProcessTerminationInfo& info) {

ChildProcessDisconnected(base::GetProcId(data.GetProcess().Handle()));

const content::ChildProcessData& data,

const content::ChildProcessTerminationInfo& info) {

ChildProcessDisconnected(base::GetProcId(data.GetProcess().Handle()));

ChildProcessLaunched(content::PROCESS_TYPE_RENDERER,

host->GetProcess().Handle());

// TODO(jeremy): this isn't really the right place to be creating

// `WebContents` instances, but this was implicitly happening before in

// `RenderProcessPreferences`, so this is at least more explicit...

content::WebContents* web_contents =

AtomBrowserClient::Get()->GetWebContentsFromProcessID(host->GetID());

if (web_contents)

WebContents::FromOrCreate(v8::Isolate::GetCurrent(), web_contents);

auto pid = base::GetProcId(handle);

#if defined(OS_MACOSX)

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

mate::Arguments* args) {

if (custom_path.has_value()) {

if (!custom_path->IsAbsolute()) {

args->ThrowError("Path must be absolute");

return;

}

base::PathService::Override(DIR_APP_LOGS, custom_path.value());

} else {

base::FilePath path;

if (base::PathService::Get(DIR_USER_DATA, &path)) {

path = path.Append(base::FilePath::FromUTF8Unsafe(GetApplicationName()));

path = path.Append(base::FilePath::FromUTF8Unsafe("logs"));

base::PathService::Override(DIR_APP_LOGS, path);

}

}

bool succeed = false;

base::FilePath path;

int key = GetPathConstant(name);

if (key >= 0) {

succeed = base::PathService::Get(key, &path);

// If users try to get the logs path before setting a logs path,

// set the path to a sensible default and then try to get it again

if (!succeed && name == "logs") {

base::ThreadRestrictions::ScopedAllowIO allow_io;

SetAppLogsPath(base::Optional<base::FilePath>(), args);

succeed = base::PathService::Get(key, &path);

}

}

if (!succeed)

args->ThrowError("Failed to get '" + name + "' path");

return path;

const std::string& name,

const base::FilePath& path) {

if (!path.IsAbsolute()) {

args->ThrowError("Path must be absolute");

return;

}

bool succeed = false;

int key = GetPathConstant(name);

if (key >= 0)

succeed =

base::PathService::OverrideAndCreateIfNeeded(key, path, true, false);

if (!succeed)

args->ThrowError("Failed to set path");

#if defined(OS_LINUX)

std::unique_ptr<base::Environment> env(base::Environment::Create());

env->SetVar("CHROME_DESKTOP", desktop_name);

#endif

std::string region;

#if defined(OS_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), &region);

}

#elif defined(OS_MACOSX)

CFLocaleRef locale = CFLocaleCopyCurrent();

CFStringRef value = CFStringRef(

static_cast<CFTypeRef>(CFLocaleGetValue(locale, kCFLocaleCountryCode)));

const CFIndex kCStringSize = 128;

char temporaryCString[kCStringSize] = {0};

CFStringGetCString(value, temporaryCString, kCStringSize,

kCFStringEncodingUTF8);

region = temporaryCString;

#else

const char* locale_ptr = setlocale(LC_TIME, NULL);

if (!locale_ptr)

locale_ptr = setlocale(LC_NUMERIC, NULL);

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

if (process_singleton_)

return true;

return false;

if (HasSingleInstanceLock())

return true;

base::FilePath user_dir;

base::PathService::Get(DIR_USER_DATA, &user_dir);

auto cb = base::BindRepeating(&App::OnSecondInstance, base::Unretained(this));

process_singleton_.reset(new ProcessSingleton(

user_dir, base::BindRepeating(NotificationCallbackWrapper, cb)));

switch (process_singleton_->NotifyOtherProcessOrCreate()) {

case ProcessSingleton::NotifyResult::LOCK_ERROR:

case ProcessSingleton::NotifyResult::PROFILE_IN_USE:

case ProcessSingleton::NotifyResult::PROCESS_NOTIFIED: {

process_singleton_.reset();

return false;

}

case ProcessSingleton::NotifyResult::PROCESS_NONE:

default: // Shouldn't be needed, but VS warns if it is not there.

return true;

}

if (process_singleton_) {

process_singleton_->Cleanup();

process_singleton_.reset();

}

// Parse parameters.

bool override_argv = false;

base::FilePath exec_path;

relauncher::StringVector args;

mate::Dictionary options;

if (js_args->GetNext(&options)) {

if (options.Get("execPath", &exec_path) | options.Get("args", &args))

override_argv = true;

}

if (!override_argv) {

const relauncher::StringVector& argv = electron::AtomCommandLine::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, &current_exe_path);

argv.push_back(current_exe_path.value());

} else {

argv.push_back(exec_path.value());

}

argv.insert(argv.end(), args.begin(), args.end());