mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 1

fix: crashReporter incompatible with sandbox on Linux (#23265)

Browse source
This commit is contained in:
Jeremy Apthorp 2020-05-07 13:31:26 -07:00 • committed by GitHub
parent fc434f136b
commit 06bf0d08dc
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
77 changed files with 2235 additions and 2404 deletions
Download patch file Download diff file Expand all files Collapse all files

2
shell/common/api/api.mojom
View file

@ -15,8 +15,6 @@ interface ElectronRenderer {
ReceivePostMessage(string channel, blink.mojom.TransferableMessage message);
UpdateCrashpadPipeName(string pipe_name);
// This is an API specific to the "remote" module, and will ultimately be
// replaced by generic IPC once WeakRef is generally available.
[EnableIf=enable_remote_module]

67
shell/common/api/electron_api_crash_reporter.cc
View file

@ -1,67 +0,0 @@
// 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 <map>
#include <string>
#include "base/bind.h"
#include "gin/data_object_builder.h"
#include "shell/common/crash_reporter/crash_reporter.h"
#include "shell/common/gin_converters/callback_converter.h"
#include "shell/common/gin_converters/file_path_converter.h"
#include "shell/common/gin_helper/dictionary.h"
#include "shell/common/node_includes.h"
using crash_reporter::CrashReporter;
namespace gin {
template <>
struct Converter<CrashReporter::UploadReportResult> {
static v8::Local<v8::Value> ToV8(
v8::Isolate* isolate,
const CrashReporter::UploadReportResult& reports) {
return gin::DataObjectBuilder(isolate)
.Set("date",
v8::Date::New(isolate->GetCurrentContext(), reports.first * 1000.0)
.ToLocalChecked())
.Set("id", reports.second)
.Build();
}
};
} // namespace gin
namespace {
void Initialize(v8::Local<v8::Object> exports,
v8::Local<v8::Value> unused,
v8::Local<v8::Context> context,
void* priv) {
auto reporter = base::Unretained(CrashReporter::GetInstance());
gin_helper::Dictionary dict(context->GetIsolate(), exports);
dict.SetMethod("start", base::BindRepeating(&CrashReporter::Start, reporter));
dict.SetMethod(
"addExtraParameter",
base::BindRepeating(&CrashReporter::AddExtraParameter, reporter));
dict.SetMethod(
"removeExtraParameter",
base::BindRepeating(&CrashReporter::RemoveExtraParameter, reporter));
dict.SetMethod("getParameters",
base::BindRepeating(&CrashReporter::GetParameters, reporter));
dict.SetMethod(
"getUploadedReports",
base::BindRepeating(&CrashReporter::GetUploadedReports, reporter));
dict.SetMethod(
"setUploadToServer",
base::BindRepeating(&CrashReporter::SetUploadToServer, reporter));
dict.SetMethod(
"getUploadToServer",
base::BindRepeating(&CrashReporter::GetUploadToServer, reporter));
}
} // namespace
NODE_LINKED_MODULE_CONTEXT_AWARE(electron_common_crash_reporter, Initialize)

144
shell/common/crash_keys.cc Normal file
View file

@ -0,0 +1,144 @@
// Copyright (c) 2020 Slack Technologies, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "shell/common/crash_keys.h"
#include <deque>
#include <utility>
#include <vector>
#include "base/command_line.h"
#include "base/environment.h"
#include "base/no_destructor.h"
#include "base/strings/string_split.h"
#include "components/crash/core/common/crash_key.h"
#include "content/public/common/content_switches.h"
#include "shell/common/electron_constants.h"
#include "shell/common/options_switches.h"
#include "third_party/crashpad/crashpad/client/annotation.h"
namespace electron {
namespace crash_keys {
namespace {
using ExtraCrashKeys = std::deque<crash_reporter::CrashKeyString<127>>;
ExtraCrashKeys& GetExtraCrashKeys() {
static base::NoDestructor<ExtraCrashKeys> extra_keys;
return *extra_keys;
}
std::deque<std::string>& GetExtraCrashKeyNames() {
static base::NoDestructor<std::deque<std::string>> crash_key_names;
return *crash_key_names;
}
} // namespace
constexpr uint32_t kMaxCrashKeyNameLength = 40;
#if defined(OS_LINUX)
static_assert(kMaxCrashKeyNameLength <=
crash_reporter::internal::kCrashKeyStorageKeySize,
"max crash key name length above what breakpad supports");
#else
static_assert(kMaxCrashKeyNameLength <= crashpad::Annotation::kNameMaxLength,
"max crash key name length above what crashpad supports");
#endif
void SetCrashKey(const std::string& key, const std::string& value) {
// Chrome DCHECK()s if we try to set an annotation with a name longer than
// the max.
// TODO(nornagon): warn the developer (via console.warn) when this happens.
if (key.size() >= kMaxCrashKeyNameLength)
return;
auto& crash_key_names = GetExtraCrashKeyNames();
auto iter = std::find(crash_key_names.begin(), crash_key_names.end(), key);
if (iter == crash_key_names.end()) {
crash_key_names.emplace_back(key);
GetExtraCrashKeys().emplace_back(crash_key_names.back().c_str());
iter = crash_key_names.end() - 1;
}
GetExtraCrashKeys()[iter - crash_key_names.begin()].Set(value);
}
void ClearCrashKey(const std::string& key) {
const auto& crash_key_names = GetExtraCrashKeyNames();
auto iter = std::find(crash_key_names.begin(), crash_key_names.end(), key);
if (iter != crash_key_names.end()) {
GetExtraCrashKeys()[iter - crash_key_names.begin()].Clear();
}
}
void GetCrashKeys(std::map<std::string, std::string>* keys) {
const auto& crash_key_names = GetExtraCrashKeyNames();
const auto& crash_keys = GetExtraCrashKeys();
int i = 0;
for (const auto& key : crash_key_names) {
const auto& value = crash_keys[i++];
if (value.is_set()) {
keys->emplace(key, value.value());
}
}
}
namespace {
bool IsRunningAsNode() {
#if BUILDFLAG(ENABLE_RUN_AS_NODE)
return base::Environment::Create()->HasVar(electron::kRunAsNode);
#else
return false;
#endif
}
} // namespace
void SetCrashKeysFromCommandLine(const base::CommandLine& command_line) {
#if defined(OS_LINUX)
if (command_line.HasSwitch(switches::kGlobalCrashKeys)) {
std::vector<std::pair<std::string, std::string>> global_crash_keys;
base::SplitStringIntoKeyValuePairs(
command_line.GetSwitchValueASCII(switches::kGlobalCrashKeys), '=', ',',
&global_crash_keys);
for (const auto& pair : global_crash_keys) {
SetCrashKey(pair.first, pair.second);
}
}
#endif
// NB. this is redundant with the 'ptype' key that //components/crash
// reports; it's present for backwards compatibility.
static crash_reporter::CrashKeyString<16> process_type_key("process_type");
if (IsRunningAsNode()) {
process_type_key.Set("node");
} else {
std::string process_type =
command_line.GetSwitchValueASCII(::switches::kProcessType);
if (process_type.empty()) {
process_type_key.Set("browser");
} else {
process_type_key.Set(process_type);
}
}
}
void SetPlatformCrashKey() {
// TODO(nornagon): this is redundant with the 'plat' key that
// //components/crash already includes. Remove it.
static crash_reporter::CrashKeyString<8> platform_key("platform");
#if defined(OS_WIN)
platform_key.Set("win32");
#elif defined(OS_MACOSX)
platform_key.Set("darwin");
#elif defined(OS_LINUX)
platform_key.Set("linux");
#else
platform_key.Set("unknown");
#endif
}
} // namespace crash_keys
} // namespace electron

30
shell/common/crash_keys.h Normal file
View file

@ -0,0 +1,30 @@
// Copyright (c) 2020 Slack Technologies, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef SHELL_COMMON_CRASH_KEYS_H_
#define SHELL_COMMON_CRASH_KEYS_H_
#include <map>
#include <string>
namespace base {
class CommandLine;
}
namespace electron {
namespace crash_keys {
void SetCrashKey(const std::string& key, const std::string& value);
void ClearCrashKey(const std::string& key);
void GetCrashKeys(std::map<std::string, std::string>* keys);
void SetCrashKeysFromCommandLine(const base::CommandLine& command_line);
void SetPlatformCrashKey();
} // namespace crash_keys
} // namespace electron
#endif // SHELL_COMMON_CRASH_KEYS_H_

159
shell/common/crash_reporter/crash_reporter.cc
View file

@ -1,159 +0,0 @@
// 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/common/crash_reporter/crash_reporter.h"
#include <memory>
#include "base/command_line.h"
#include "base/environment.h"
#include "base/files/file_util.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_split.h"
#include "base/threading/thread_restrictions.h"
#include "content/public/common/content_switches.h"
#include "electron/electron_version.h"
#include "shell/browser/browser.h"
#include "shell/common/electron_constants.h"
#include "shell/common/gin_converters/file_path_converter.h"
#include "shell/common/gin_helper/dictionary.h"
namespace crash_reporter {
const char kCrashpadProcess[] = "crash-handler";
const char kCrashesDirectoryKey[] = "crashes-directory";
CrashReporter::CrashReporter() {
#if BUILDFLAG(ENABLE_RUN_AS_NODE)
bool run_as_node = base::Environment::Create()->HasVar(electron::kRunAsNode);
#else
bool run_as_node = false;
#endif
if (run_as_node) {
process_type_ = "node";
} else {
auto* cmd = base::CommandLine::ForCurrentProcess();
process_type_ = cmd->GetSwitchValueASCII(switches::kProcessType);
}
// process_type_ will be empty for browser process
}
CrashReporter::~CrashReporter() = default;
bool CrashReporter::IsInitialized() {
return is_initialized_;
}
void CrashReporter::Start(const std::string& submit_url,
const base::FilePath& crashes_dir,
bool upload_to_server,
bool skip_system_crash_handler,
bool rate_limit,
bool compress,
const StringMap& extra_parameters) {
is_initialized_ = true;
SetUploadParameters(extra_parameters);
Init(submit_url, crashes_dir, upload_to_server, skip_system_crash_handler,
rate_limit, compress);
}
void CrashReporter::SetUploadParameters(const StringMap& parameters) {
upload_parameters_ = parameters;
upload_parameters_["process_type"] =
process_type_.empty() ? "browser" : process_type_;
upload_parameters_["prod"] = ELECTRON_PRODUCT_NAME;
upload_parameters_["ver"] = ELECTRON_VERSION_STRING;
// Setting platform dependent parameters.
SetUploadParameters();
}
std::vector<CrashReporter::UploadReportResult>
CrashReporter::GetUploadedReports(const base::FilePath& crashes_dir) {
base::ThreadRestrictions::ScopedAllowIO allow_io;
std::string file_content;
std::vector<CrashReporter::UploadReportResult> result;
base::FilePath uploads_path =
crashes_dir.Append(FILE_PATH_LITERAL("uploads.log"));
if (base::ReadFileToString(uploads_path, &file_content)) {
std::vector<std::string> reports = base::SplitString(
file_content, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
for (const std::string& report : reports) {
std::vector<std::string> report_item = base::SplitString(
report, ",", base::TRIM_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
int report_time = 0;
if (report_item.size() >= 2 &&
base::StringToInt(report_item[0], &report_time)) {
result.emplace_back(report_time, report_item[1]);
}
}
}
return result;
}
std::map<std::string, std::string> CrashReporter::GetParameters() const {
return upload_parameters_;
}
#if defined(OS_MACOSX) && defined(MAS_BUILD)
class DummyCrashReporter : public CrashReporter {
public:
~DummyCrashReporter() override {}
void SetUploadToServer(bool upload_to_server) override {}
bool GetUploadToServer() override { return false; }
void AddExtraParameter(const std::string& key,
const std::string& value) override {}
void RemoveExtraParameter(const std::string& key) override {}
void Init(const std::string& submit_url,
const base::FilePath& crashes_dir,
bool upload_to_server,
bool skip_system_crash_handler,
bool rate_limit,
bool compress) override {}
void SetUploadParameters() override {}
};
// static
CrashReporter* CrashReporter::GetInstance() {
static DummyCrashReporter crash_reporter;
return &crash_reporter;
}
#endif
void CrashReporter::StartInstance(const gin_helper::Dictionary& options) {
auto* reporter = GetInstance();
if (!reporter)
return;
std::string product_name;
options.Get("productName", &product_name);
std::string company_name;
options.Get("companyName", &company_name);
std::string submit_url;
options.Get("submitURL", &submit_url);
base::FilePath crashes_dir;
options.Get("crashesDirectory", &crashes_dir);
StringMap extra_parameters;
options.Get("extra", &extra_parameters);
bool rate_limit = false;
options.Get("rateLimit", &rate_limit);
bool compress = false;
options.Get("compress", &compress);
extra_parameters["_productName"] = product_name;
extra_parameters["_companyName"] = company_name;
bool upload_to_server = true;
bool skip_system_crash_handler = false;
reporter->Start(submit_url, crashes_dir, upload_to_server,
skip_system_crash_handler, rate_limit, compress,
extra_parameters);
}
} // namespace crash_reporter

79
shell/common/crash_reporter/crash_reporter.h
View file

@ -1,79 +0,0 @@
// Copyright (c) 2013 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef SHELL_COMMON_CRASH_REPORTER_CRASH_REPORTER_H_
#define SHELL_COMMON_CRASH_REPORTER_CRASH_REPORTER_H_
#include <map>
#include <string>
#include <utility>
#include <vector>
#include "base/files/file_path.h"
#include "base/macros.h"
namespace gin_helper {
class Dictionary;
}
namespace crash_reporter {
extern const char kCrashpadProcess[];
extern const char kCrashesDirectoryKey[];
class CrashReporter {
public:
typedef std::map<std::string, std::string> StringMap;
typedef std::pair<int, std::string> UploadReportResult; // upload-date, id
static CrashReporter* GetInstance();
// FIXME(zcbenz): We should not do V8 in this file, this method should only
// accept C++ struct as parameter, and atom_api_crash_reporter.cc is
// responsible for parsing the parameter from JavaScript.
static void StartInstance(const gin_helper::Dictionary& options);
bool IsInitialized();
void Start(const std::string& submit_url,
const base::FilePath& crashes_dir,
bool upload_to_server,
bool skip_system_crash_handler,
bool rate_limit,
bool compress,
const StringMap& extra_parameters);
virtual std::vector<CrashReporter::UploadReportResult> GetUploadedReports(
const base::FilePath& crashes_dir);
virtual void SetUploadToServer(bool upload_to_server) = 0;
virtual bool GetUploadToServer() = 0;
virtual void AddExtraParameter(const std::string& key,
const std::string& value) = 0;
virtual void RemoveExtraParameter(const std::string& key) = 0;
virtual std::map<std::string, std::string> GetParameters() const;
protected:
CrashReporter();
virtual ~CrashReporter();
virtual void Init(const std::string& submit_url,
const base::FilePath& crashes_dir,
bool upload_to_server,
bool skip_system_crash_handler,
bool rate_limit,
bool compress) = 0;
virtual void SetUploadParameters() = 0;
StringMap upload_parameters_;
std::string process_type_;
private:
bool is_initialized_ = false;
void SetUploadParameters(const StringMap& parameters);
DISALLOW_COPY_AND_ASSIGN(CrashReporter);
};
} // namespace crash_reporter
#endif // SHELL_COMMON_CRASH_REPORTER_CRASH_REPORTER_H_

118
shell/common/crash_reporter/crash_reporter_crashpad.cc
View file

@ -1,118 +0,0 @@
// Copyright (c) 2019 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "shell/common/crash_reporter/crash_reporter_crashpad.h"
#include <algorithm>
#include <memory>
#include "base/files/file_util.h"
#include "base/strings/string_piece.h"
#include "base/strings/stringprintf.h"
#include "base/strings/sys_string_conversions.h"
#include "base/threading/thread_restrictions.h"
#include "third_party/crashpad/crashpad/client/settings.h"
namespace crash_reporter {
CrashReporterCrashpad::CrashReporterCrashpad() {}
CrashReporterCrashpad::~CrashReporterCrashpad() {}
bool CrashReporterCrashpad::GetUploadToServer() {
bool enabled = true;
if (database_) {
database_->GetSettings()->GetUploadsEnabled(&enabled);
}
return enabled;
}
void CrashReporterCrashpad::SetUploadToServer(const bool upload_to_server) {
if (database_) {
database_->GetSettings()->SetUploadsEnabled(upload_to_server);
}
}
void CrashReporterCrashpad::SetCrashKeyValue(base::StringPiece key,
base::StringPiece value) {
simple_string_dictionary_->SetKeyValue(key.data(), value.data());
}
void CrashReporterCrashpad::SetInitialCrashKeyValues() {
for (const auto& upload_parameter : upload_parameters_)
SetCrashKeyValue(upload_parameter.first, upload_parameter.second);
}
void CrashReporterCrashpad::AddExtraParameter(const std::string& key,
const std::string& value) {
if (simple_string_dictionary_) {
SetCrashKeyValue(key, value);
} else {
upload_parameters_[key] = value;
}
}
void CrashReporterCrashpad::RemoveExtraParameter(const std::string& key) {
if (simple_string_dictionary_)
simple_string_dictionary_->RemoveKey(key.data());
else
upload_parameters_.erase(key);
}
std::map<std::string, std::string> CrashReporterCrashpad::GetParameters()
const {
if (simple_string_dictionary_) {
std::map<std::string, std::string> ret;
crashpad::SimpleStringDictionary::Iterator iter(*simple_string_dictionary_);
for (;;) {
auto* const entry = iter.Next();
if (!entry)
break;
ret[entry->key] = entry->value;
}
return ret;
}
return upload_parameters_;
}
std::vector<CrashReporter::UploadReportResult>
CrashReporterCrashpad::GetUploadedReports(const base::FilePath& crashes_dir) {
std::vector<CrashReporter::UploadReportResult> uploaded_reports;
{
base::ThreadRestrictions::ScopedAllowIO allow_io;
if (!base::PathExists(crashes_dir)) {
return uploaded_reports;
}
}
// Load crashpad database.
std::unique_ptr<crashpad::CrashReportDatabase> database =
crashpad::CrashReportDatabase::Initialize(crashes_dir);
DCHECK(database);
std::vector<crashpad::CrashReportDatabase::Report> completed_reports;
crashpad::CrashReportDatabase::OperationStatus status =
database->GetCompletedReports(&completed_reports);
if (status != crashpad::CrashReportDatabase::kNoError) {
return uploaded_reports;
}
for (const crashpad::CrashReportDatabase::Report& completed_report :
completed_reports) {
if (completed_report.uploaded) {
uploaded_reports.push_back(
UploadReportResult(static_cast<int>(completed_report.creation_time),
completed_report.id));
}
}
auto sort_by_time = [](const UploadReportResult& a,
const UploadReportResult& b) {
return a.first > b.first;
};
std::sort(uploaded_reports.begin(), uploaded_reports.end(), sort_by_time);
return uploaded_reports;
}
} // namespace crash_reporter

49
shell/common/crash_reporter/crash_reporter_crashpad.h
View file

@ -1,49 +0,0 @@
// Copyright (c) 2013 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef SHELL_COMMON_CRASH_REPORTER_CRASH_REPORTER_CRASHPAD_H_
#define SHELL_COMMON_CRASH_REPORTER_CRASH_REPORTER_CRASHPAD_H_
#include <map>
#include <memory>
#include <string>
#include <vector>
#include "base/compiler_specific.h"
#include "base/strings/string_piece.h"
#include "shell/common/crash_reporter/crash_reporter.h"
#include "third_party/crashpad/crashpad/client/crash_report_database.h"
#include "third_party/crashpad/crashpad/client/simple_string_dictionary.h"
namespace crash_reporter {
class CrashReporterCrashpad : public CrashReporter {
public:
void SetUploadToServer(bool upload_to_server) override;
bool GetUploadToServer() override;
void AddExtraParameter(const std::string& key,
const std::string& value) override;
void RemoveExtraParameter(const std::string& key) override;
std::map<std::string, std::string> GetParameters() const override;
protected:
CrashReporterCrashpad();
~CrashReporterCrashpad() override;
void SetUploadsEnabled(bool enable_uploads);
void SetCrashKeyValue(base::StringPiece key, base::StringPiece value);
void SetInitialCrashKeyValues();
std::vector<UploadReportResult> GetUploadedReports(
const base::FilePath& crashes_dir) override;
std::unique_ptr<crashpad::SimpleStringDictionary> simple_string_dictionary_;
std::unique_ptr<crashpad::CrashReportDatabase> database_;
DISALLOW_COPY_AND_ASSIGN(CrashReporterCrashpad);
};
} // namespace crash_reporter
#endif // SHELL_COMMON_CRASH_REPORTER_CRASH_REPORTER_CRASHPAD_H_

150
shell/common/crash_reporter/crash_reporter_linux.cc
View file

@ -1,150 +0,0 @@
// Copyright (c) 2014 GitHub, Inc.
// Copyright (c) 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "shell/common/crash_reporter/crash_reporter_linux.h"
#include <sys/time.h>
#include <unistd.h>
#include <memory>
#include <string>
#include "base/debug/crash_logging.h"
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/linux_util.h"
#include "base/logging.h"
#include "base/memory/singleton.h"
#include "base/process/memory.h"
#include "base/threading/thread_restrictions.h"
#include "breakpad/src/client/linux/handler/exception_handler.h"
#include "breakpad/src/common/linux/linux_libc_support.h"
using google_breakpad::ExceptionHandler;
using google_breakpad::MinidumpDescriptor;
namespace crash_reporter {
namespace {
// Define a preferred limit on minidump sizes, because Crash Server currently
// throws away any larger than 1.2MB (1.2 * 1024 * 1024). A value of -1 means
// no limit.
static const off_t kMaxMinidumpFileSize = 1258291;
} // namespace
CrashReporterLinux::CrashReporterLinux() : pid_(getpid()) {
// Set the base process start time value.
struct timeval tv;
if (!gettimeofday(&tv, nullptr)) {
uint64_t ret = tv.tv_sec;
ret *= 1000;
ret += tv.tv_usec / 1000;
process_start_time_ = ret;
}
{
base::ThreadRestrictions::ScopedAllowIO allow_io;
// Make base::g_linux_distro work.
base::SetLinuxDistro(base::GetLinuxDistro());
}
}
CrashReporterLinux::~CrashReporterLinux() = default;
void CrashReporterLinux::Init(const std::string& submit_url,
const base::FilePath& crashes_dir,
bool upload_to_server,
bool skip_system_crash_handler,
bool rate_limit,
bool compress) {
EnableCrashDumping(crashes_dir);
upload_url_ = submit_url;
upload_to_server_ = upload_to_server;
crash_keys_ = std::make_unique<CrashKeyStorage>();
for (StringMap::const_iterator iter = upload_parameters_.begin();
iter != upload_parameters_.end(); ++iter)
crash_keys_->SetKeyValue(iter->first.c_str(), iter->second.c_str());
}
void CrashReporterLinux::SetUploadParameters() {
upload_parameters_["platform"] = "linux";
}
void CrashReporterLinux::SetUploadToServer(const bool upload_to_server) {
upload_to_server_ = upload_to_server;
}
bool CrashReporterLinux::GetUploadToServer() {
return upload_to_server_;
}
void CrashReporterLinux::AddExtraParameter(const std::string& key,
const std::string& value) {}
void CrashReporterLinux::RemoveExtraParameter(const std::string& key) {}
void CrashReporterLinux::EnableCrashDumping(const base::FilePath& crashes_dir) {
{
base::ThreadRestrictions::ScopedAllowIO allow_io;
base::CreateDirectory(crashes_dir);
}
std::string log_file = crashes_dir.Append("uploads.log").value();
strncpy(g_crash_log_path, log_file.c_str(), sizeof(g_crash_log_path));
MinidumpDescriptor minidump_descriptor(crashes_dir.value());
minidump_descriptor.set_size_limit(kMaxMinidumpFileSize);
breakpad_ = std::make_unique<ExceptionHandler>(minidump_descriptor, nullptr,
CrashDone, this,
true, // Install handlers.
-1);
}
bool CrashReporterLinux::CrashDone(const MinidumpDescriptor& minidump,
void* context,
const bool succeeded) {
CrashReporterLinux* self = static_cast<CrashReporterLinux*>(context);
// WARNING: this code runs in a compromised context. It may not call into
// libc nor allocate memory normally.
if (!succeeded) {
const char msg[] = "Failed to generate minidump.";
WriteLog(msg, sizeof(msg) - 1);
return false;
}
DCHECK(!minidump.IsFD());
BreakpadInfo info = {0};
info.filename = minidump.path();
info.fd = minidump.fd();
info.distro = base::g_linux_distro;
info.distro_length = my_strlen(base::g_linux_distro);
info.upload = self->upload_to_server_;
info.process_start_time = self->process_start_time_;
info.oom_size = base::g_oom_size;
info.pid = self->pid_;
info.upload_url = self->upload_url_.c_str();
info.crash_keys = self->crash_keys_.get();
HandleCrashDump(info);
return true;
}
// static
CrashReporterLinux* CrashReporterLinux::GetInstance() {
return base::Singleton<CrashReporterLinux>::get();
}
// static
CrashReporter* CrashReporter::GetInstance() {
return CrashReporterLinux::GetInstance();
}
} // namespace crash_reporter

68
shell/common/crash_reporter/crash_reporter_linux.h
View file

@ -1,68 +0,0 @@
// Copyright (c) 2014 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef SHELL_COMMON_CRASH_REPORTER_CRASH_REPORTER_LINUX_H_
#define SHELL_COMMON_CRASH_REPORTER_CRASH_REPORTER_LINUX_H_
#include <memory>
#include <string>
#include "base/compiler_specific.h"
#include "shell/common/crash_reporter/crash_reporter.h"
#include "shell/common/crash_reporter/linux/crash_dump_handler.h"
namespace base {
template <typename T>
struct DefaultSingletonTraits;
}
namespace google_breakpad {
class ExceptionHandler;
class MinidumpDescriptor;
} // namespace google_breakpad
namespace crash_reporter {
class CrashReporterLinux : public CrashReporter {
public:
static CrashReporterLinux* GetInstance();
void Init(const std::string& submit_url,
const base::FilePath& crashes_dir,
bool upload_to_server,
bool skip_system_crash_handler,
bool rate_limit,
bool compress) override;
void SetUploadToServer(bool upload_to_server) override;
void SetUploadParameters() override;
bool GetUploadToServer() override;
void AddExtraParameter(const std::string& key,
const std::string& value) override;
void RemoveExtraParameter(const std::string& key) override;
private:
friend struct base::DefaultSingletonTraits<CrashReporterLinux>;
CrashReporterLinux();
~CrashReporterLinux() override;
void EnableCrashDumping(const base::FilePath& crashes_dir);
static bool CrashDone(const google_breakpad::MinidumpDescriptor& minidump,
void* context,
const bool succeeded);
std::unique_ptr<google_breakpad::ExceptionHandler> breakpad_;
std::unique_ptr<CrashKeyStorage> crash_keys_;
uint64_t process_start_time_ = 0;
pid_t pid_ = 0;
std::string upload_url_;
bool upload_to_server_ = true;
DISALLOW_COPY_AND_ASSIGN(CrashReporterLinux);
};
} // namespace crash_reporter
#endif // SHELL_COMMON_CRASH_REPORTER_CRASH_REPORTER_LINUX_H_

43
shell/common/crash_reporter/crash_reporter_mac.h
View file

@ -1,43 +0,0 @@
// Copyright (c) 2013 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef SHELL_COMMON_CRASH_REPORTER_CRASH_REPORTER_MAC_H_
#define SHELL_COMMON_CRASH_REPORTER_CRASH_REPORTER_MAC_H_
#include <memory>
#include <string>
#include "shell/common/crash_reporter/crash_reporter_crashpad.h"
namespace base {
template <typename T>
struct DefaultSingletonTraits;
}
namespace crash_reporter {
class CrashReporterMac : public CrashReporterCrashpad {
public:
static CrashReporterMac* GetInstance();
void Init(const std::string& submit_url,
const base::FilePath& crashes_dir,
bool upload_to_server,
bool skip_system_crash_handler,
bool rate_limit,
bool compress) override;
void SetUploadParameters() override;
private:
friend struct base::DefaultSingletonTraits<CrashReporterMac>;
CrashReporterMac();
~CrashReporterMac() override;
DISALLOW_COPY_AND_ASSIGN(CrashReporterMac);
};
} // namespace crash_reporter
#endif // SHELL_COMMON_CRASH_REPORTER_CRASH_REPORTER_MAC_H_

85
shell/common/crash_reporter/crash_reporter_mac.mm
View file

@ -1,85 +0,0 @@
// 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/common/crash_reporter/crash_reporter_mac.h"
#include <algorithm>
#include <map>
#include <memory>
#include <string>
#include <vector>
#include "base/mac/bundle_locations.h"
#include "base/mac/mac_util.h"
#include "base/memory/singleton.h"
#include "third_party/crashpad/crashpad/client/crashpad_client.h"
#include "third_party/crashpad/crashpad/client/crashpad_info.h"
namespace crash_reporter {
CrashReporterMac::CrashReporterMac() {}
CrashReporterMac::~CrashReporterMac() {}
void CrashReporterMac::Init(const std::string& submit_url,
const base::FilePath& crashes_dir,
bool upload_to_server,
bool skip_system_crash_handler,
bool rate_limit,
bool compress) {
// check whether crashpad has been initialized.
// Only need to initialize once.
if (simple_string_dictionary_)
return;
if (process_type_.empty()) { // browser process
@autoreleasepool {
base::FilePath framework_bundle_path = base::mac::FrameworkBundlePath();
base::FilePath handler_path =
framework_bundle_path.Append("Resources").Append("crashpad_handler");
std::vector<std::string> args;
if (!rate_limit)
args.emplace_back("--no-rate-limit");
if (!compress)
args.emplace_back("--no-upload-gzip");
crashpad::CrashpadClient crashpad_client;
crashpad_client.StartHandler(handler_path, crashes_dir, crashes_dir,
submit_url, StringMap(), args, true, false);
} // @autoreleasepool
}
crashpad::CrashpadInfo* crashpad_info =
crashpad::CrashpadInfo::GetCrashpadInfo();
if (skip_system_crash_handler) {
crashpad_info->set_system_crash_reporter_forwarding(
crashpad::TriState::kDisabled);
}
simple_string_dictionary_.reset(new crashpad::SimpleStringDictionary());
crashpad_info->set_simple_annotations(simple_string_dictionary_.get());
SetInitialCrashKeyValues();
if (process_type_.empty()) { // browser process
database_ = crashpad::CrashReportDatabase::Initialize(crashes_dir);
SetUploadToServer(upload_to_server);
}
}
void CrashReporterMac::SetUploadParameters() {
upload_parameters_["platform"] = "darwin";
}
// static
CrashReporterMac* CrashReporterMac::GetInstance() {
return base::Singleton<CrashReporterMac>::get();
}
// static
CrashReporter* CrashReporter::GetInstance() {
return CrashReporterMac::GetInstance();
}
} // namespace crash_reporter

151
shell/common/crash_reporter/crash_reporter_win.cc
View file

@ -1,151 +0,0 @@
// 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/common/crash_reporter/crash_reporter_win.h"
#include <memory>
#include <vector>
#include "base/environment.h"
#include "base/memory/singleton.h"
#include "base/path_service.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "electron/shell/common/api/api.mojom.h"
#include "mojo/public/cpp/bindings/associated_remote.h"
#include "shell/browser/ui/inspectable_web_contents_impl.h"
#include "shell/common/electron_constants.h"
#include "third_party/blink/public/common/associated_interfaces/associated_interface_provider.h"
#include "third_party/crashpad/crashpad/client/crashpad_client.h"
#include "third_party/crashpad/crashpad/client/crashpad_info.h"
#if defined(_WIN64)
#include "gin/public/debug.h"
#endif
namespace {
#if defined(_WIN64)
int CrashForException(EXCEPTION_POINTERS* info) {
auto* reporter = crash_reporter::CrashReporterWin::GetInstance();
if (reporter->IsInitialized()) {
reporter->GetCrashpadClient().DumpAndCrash(info);
return EXCEPTION_CONTINUE_SEARCH;
}
// When there is exception and we do not have crashReporter set up, we just
// let the execution continue and crash, which is the default behavior.
//
// We must not return EXCEPTION_CONTINUE_SEARCH here, as it would end up with
// busy loop when there is no exception handler in the program.
return EXCEPTION_CONTINUE_EXECUTION;
}
#endif
} // namespace
namespace crash_reporter {
CrashReporterWin::CrashReporterWin() {}
CrashReporterWin::~CrashReporterWin() {}
#if defined(_WIN64)
void CrashReporterWin::SetUnhandledExceptionFilter() {
gin::Debug::SetUnhandledExceptionCallback(&CrashForException);
}
#endif
void CrashReporterWin::Init(const std::string& submit_url,
const base::FilePath& crashes_dir,
bool upload_to_server,
bool skip_system_crash_handler,
bool rate_limit,
bool compress) {
// check whether crashpad has been initialized.
// Only need to initialize once.
if (simple_string_dictionary_)
return;
if (process_type_.empty()) { // browser process
base::FilePath handler_path;
base::PathService::Get(base::FILE_EXE, &handler_path);
std::vector<std::string> args;
if (!rate_limit)
args.emplace_back("--no-rate-limit");
if (!compress)
args.emplace_back("--no-upload-gzip");
args.push_back(base::StringPrintf("--type=%s", kCrashpadProcess));
args.push_back(
base::StringPrintf("--%s=%s", kCrashesDirectoryKey,
base::UTF16ToUTF8(crashes_dir.value()).c_str()));
crashpad_client_.StartHandler(handler_path, crashes_dir, crashes_dir,
submit_url, StringMap(), args, true, false);
UpdatePipeName();
} else {
std::unique_ptr<base::Environment> env(base::Environment::Create());
std::string pipe_name_utf8;
if (env->GetVar(electron::kCrashpadPipeName, &pipe_name_utf8)) {
base::string16 pipe_name = base::UTF8ToUTF16(pipe_name_utf8);
if (!crashpad_client_.SetHandlerIPCPipe(pipe_name))
LOG(ERROR) << "Failed to set handler IPC pipe name: " << pipe_name;
} else {
LOG(ERROR) << "Unable to get pipe name for crashpad";
}
}
crashpad::CrashpadInfo* crashpad_info =
crashpad::CrashpadInfo::GetCrashpadInfo();
if (skip_system_crash_handler) {
crashpad_info->set_system_crash_reporter_forwarding(
crashpad::TriState::kDisabled);
}
simple_string_dictionary_.reset(new crashpad::SimpleStringDictionary());
crashpad_info->set_simple_annotations(simple_string_dictionary_.get());
SetInitialCrashKeyValues();
if (process_type_.empty()) { // browser process
database_ = crashpad::CrashReportDatabase::Initialize(crashes_dir);
SetUploadToServer(upload_to_server);
}
}
void CrashReporterWin::SetUploadParameters() {
upload_parameters_["platform"] = "win32";
}
crashpad::CrashpadClient& CrashReporterWin::GetCrashpadClient() {
return crashpad_client_;
}
void CrashReporterWin::UpdatePipeName() {
std::string pipe_name =
base::UTF16ToUTF8(crashpad_client_.GetHandlerIPCPipe());
std::unique_ptr<base::Environment> env(base::Environment::Create());
env->SetVar(electron::kCrashpadPipeName, pipe_name);
// Notify all WebContents of the pipe name.
const auto& pages = electron::InspectableWebContentsImpl::GetAll();
for (auto* page : pages) {
auto* frame_host = page->GetWebContents()->GetMainFrame();
if (!frame_host)
continue;
mojo::AssociatedRemote<electron::mojom::ElectronRenderer> electron_renderer;
frame_host->GetRemoteAssociatedInterfaces()->GetInterface(
&electron_renderer);
electron_renderer->UpdateCrashpadPipeName(pipe_name);
}
}
// static
CrashReporterWin* CrashReporterWin::GetInstance() {
return base::Singleton<CrashReporterWin>::get();
}
// static
CrashReporter* CrashReporter::GetInstance() {
return CrashReporterWin::GetInstance();
}
} // namespace crash_reporter

52
shell/common/crash_reporter/crash_reporter_win.h
View file

@ -1,52 +0,0 @@
// Copyright (c) 2013 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef SHELL_COMMON_CRASH_REPORTER_CRASH_REPORTER_WIN_H_
#define SHELL_COMMON_CRASH_REPORTER_CRASH_REPORTER_WIN_H_
#include <memory>
#include <string>
#include "shell/common/crash_reporter/crash_reporter_crashpad.h"
#include "third_party/crashpad/crashpad/client/crashpad_client.h"
namespace base {
template <typename T>
struct DefaultSingletonTraits;
}
namespace crash_reporter {
class CrashReporterWin : public CrashReporterCrashpad {
public:
static CrashReporterWin* GetInstance();
#if defined(_WIN64)
static void SetUnhandledExceptionFilter();
#endif
void Init(const std::string& submit_url,
const base::FilePath& crashes_dir,
bool upload_to_server,
bool skip_system_crash_handler,
bool rate_limit,
bool compress) override;
void SetUploadParameters() override;
crashpad::CrashpadClient& GetCrashpadClient();
private:
friend struct base::DefaultSingletonTraits<CrashReporterWin>;
CrashReporterWin();
~CrashReporterWin() override;
void UpdatePipeName();
crashpad::CrashpadClient crashpad_client_;
DISALLOW_COPY_AND_ASSIGN(CrashReporterWin);
};
} // namespace crash_reporter
#endif // SHELL_COMMON_CRASH_REPORTER_CRASH_REPORTER_WIN_H_

753
shell/common/crash_reporter/linux/crash_dump_handler.cc
View file

@ -1,753 +0,0 @@
// Copyright (c) 2014 GitHub, Inc.
// Copyright (c) 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
// For linux_syscall_support.h. This makes it safe to call embedded system
// calls when in seccomp mode.
#include "shell/common/crash_reporter/linux/crash_dump_handler.h"
#include <poll.h>
#include <algorithm>
#include "base/posix/eintr_wrapper.h"
#include "breakpad/src/client/linux/minidump_writer/directory_reader.h"
#include "breakpad/src/common/linux/linux_libc_support.h"
#include "breakpad/src/common/memory_allocator.h"
#include "third_party/lss/linux_syscall_support.h"
// Some versions of gcc are prone to warn about unused return values. In cases
// where we either a) know the call cannot fail, or b) there is nothing we
// can do when a call fails, we mark the return code as ignored. This avoids
// spurious compiler warnings.
#define IGNORE_RET(x) \
do { \
if (x) \
; \
} while (0)
namespace crash_reporter {
namespace {
// String buffer size to use to convert a uint64_t to string.
const size_t kUint64StringSize = 21;
// Writes the value |v| as 16 hex characters to the memory pointed at by
// |output|.
void write_uint64_hex(char* output, uint64_t v) {
static const char hextable[] = "0123456789abcdef";
for (int i = 15; i >= 0; --i) {
output[i] = hextable[v & 15];
v >>= 4;
}
}
// uint64_t version of my_int_len() from
// breakpad/src/common/linux/linux_libc_support.h. Return the length of the
// given, non-negative integer when expressed in base 10.
unsigned my_uint64_len(uint64_t i) {
if (!i)
return 1;
unsigned len = 0;
while (i) {
len++;
i /= 10;
}
return len;
}
// uint64_t version of my_uitos() from
// breakpad/src/common/linux/linux_libc_support.h. Convert a non-negative
// integer to a string (not null-terminated).
void my_uint64tos(char* output, uint64_t i, unsigned i_len) {
for (unsigned index = i_len; index; --index, i /= 10)
output[index - 1] = '0' + (i % 10);
}
// Converts a struct timeval to milliseconds.
uint64_t kernel_timeval_to_ms(struct kernel_timeval* tv) {
uint64_t ret = tv->tv_sec; // Avoid overflow by explicitly using a uint64_t.
ret *= 1000;
ret += tv->tv_usec / 1000;
return ret;
}
bool my_isxdigit(char c) {
return (c >= '0' && c <= '9') || ((c | 0x20) >= 'a' && (c | 0x20) <= 'f');
}
size_t LengthWithoutTrailingSpaces(const char* str, size_t len) {
while (len > 0 && str[len - 1] == ' ') {
len--;
}
return len;
}
// MIME substrings.
const char g_rn[] = "\r\n";
const char g_form_data_msg[] = "Content-Disposition: form-data; name=\"";
const char g_quote_msg[] = "\"";
const char g_dashdash_msg[] = "--";
const char g_dump_msg[] = "upload_file_minidump\"; filename=\"dump\"";
const char g_content_type_msg[] = "Content-Type: application/octet-stream";
// MimeWriter manages an iovec for writing MIMEs to a file.
class MimeWriter {
public:
static const int kIovCapacity = 30;
static const size_t kMaxCrashChunkSize = 64;
MimeWriter(int fd, const char* const mime_boundary);
~MimeWriter();
// Append boundary.
virtual void AddBoundary();
// Append end of file boundary.
virtual void AddEnd();
// Append key/value pair with specified sizes.
virtual void AddPairData(const char* msg_type,
size_t msg_type_size,
const char* msg_data,
size_t msg_data_size);
// Append key/value pair.
void AddPairString(const char* msg_type, const char* msg_data) {
AddPairData(msg_type, my_strlen(msg_type), msg_data, my_strlen(msg_data));
}
// Append key/value pair, splitting value into chunks no larger than
// |chunk_size|. |chunk_size| cannot be greater than |kMaxCrashChunkSize|.
// The msg_type string will have a counter suffix to distinguish each chunk.
virtual void AddPairDataInChunks(const char* msg_type,
size_t msg_type_size,
const char* msg_data,
size_t msg_data_size,
size_t chunk_size,
bool strip_trailing_spaces);
// Add binary file contents to be uploaded with the specified filename.
virtual void AddFileContents(const char* filename_msg,
uint8_t* file_data,
size_t file_size);
// Flush any pending iovecs to the output file.
void Flush() {
IGNORE_RET(sys_writev(fd_, iov_, iov_index_));
iov_index_ = 0;
}
protected:
void AddItem(const void* base, size_t size);
// Minor performance trade-off for easier-to-maintain code.
void AddString(const char* str) { AddItem(str, my_strlen(str)); }
void AddItemWithoutTrailingSpaces(const void* base, size_t size);
struct kernel_iovec iov_[kIovCapacity];
int iov_index_ = 0;
// Output file descriptor.
int fd_ = -1;
const char* const mime_boundary_;
private:
DISALLOW_COPY_AND_ASSIGN(MimeWriter);
};
MimeWriter::MimeWriter(int fd, const char* const mime_boundary)
: fd_(fd), mime_boundary_(mime_boundary) {}
MimeWriter::~MimeWriter() = default;
void MimeWriter::AddBoundary() {
AddString(mime_boundary_);
AddString(g_rn);
}
void MimeWriter::AddEnd() {
AddString(mime_boundary_);
AddString(g_dashdash_msg);
AddString(g_rn);
}
void MimeWriter::AddPairData(const char* msg_type,
size_t msg_type_size,
const char* msg_data,
size_t msg_data_size) {
AddString(g_form_data_msg);
AddItem(msg_type, msg_type_size);
AddString(g_quote_msg);
AddString(g_rn);
AddString(g_rn);
AddItem(msg_data, msg_data_size);
AddString(g_rn);
}
void MimeWriter::AddPairDataInChunks(const char* msg_type,
size_t msg_type_size,
const char* msg_data,
size_t msg_data_size,
size_t chunk_size,
bool strip_trailing_spaces) {
if (chunk_size > kMaxCrashChunkSize)
return;
unsigned i = 0;
size_t done = 0, msg_length = msg_data_size;
while (msg_length) {
char num[kUint64StringSize];
const unsigned num_len = my_uint_len(++i);
my_uitos(num, i, num_len);
size_t chunk_len = std::min(chunk_size, msg_length);
AddString(g_form_data_msg);
AddItem(msg_type, msg_type_size);
AddItem(num, num_len);
AddString(g_quote_msg);
AddString(g_rn);
AddString(g_rn);
if (strip_trailing_spaces) {
AddItemWithoutTrailingSpaces(msg_data + done, chunk_len);
} else {
AddItem(msg_data + done, chunk_len);
}
AddString(g_rn);
AddBoundary();
Flush();
done += chunk_len;
msg_length -= chunk_len;
}
}
void MimeWriter::AddFileContents(const char* filename_msg,
uint8_t* file_data,
size_t file_size) {
AddString(g_form_data_msg);
AddString(filename_msg);
AddString(g_rn);
AddString(g_content_type_msg);
AddString(g_rn);
AddString(g_rn);
AddItem(file_data, file_size);
AddString(g_rn);
}
void MimeWriter::AddItem(const void* base, size_t size) {
// Check if the iovec is full and needs to be flushed to output file.
if (iov_index_ == kIovCapacity) {
Flush();
}
iov_[iov_index_].iov_base = const_cast<void*>(base);
iov_[iov_index_].iov_len = size;
++iov_index_;
}
void MimeWriter::AddItemWithoutTrailingSpaces(const void* base, size_t size) {
AddItem(base,
LengthWithoutTrailingSpaces(static_cast<const char*>(base), size));
}
void LoadDataFromFD(google_breakpad::PageAllocator* allocator,
int fd,
bool close_fd,
uint8_t** file_data,
size_t* size) {
struct kernel_stat st;
if (sys_fstat(fd, &st) != 0) {
static const char msg[] = "Cannot upload crash dump: stat failed\n";
WriteLog(msg, sizeof(msg) - 1);
if (close_fd)
IGNORE_RET(sys_close(fd));
return;
}
*file_data = reinterpret_cast<uint8_t*>(allocator->Alloc(st.st_size));
if (!(*file_data)) {
static const char msg[] = "Cannot upload crash dump: cannot alloc\n";
WriteLog(msg, sizeof(msg) - 1);
if (close_fd)
IGNORE_RET(sys_close(fd));
return;
}
my_memset(*file_data, 0xf, st.st_size);
*size = st.st_size;
int byte_read = sys_read(fd, *file_data, *size);
if (byte_read == -1) {
static const char msg[] = "Cannot upload crash dump: read failed\n";
WriteLog(msg, sizeof(msg) - 1);
if (close_fd)
IGNORE_RET(sys_close(fd));
return;
}
if (close_fd)
IGNORE_RET(sys_close(fd));
}
void LoadDataFromFile(google_breakpad::PageAllocator* allocator,
const char* filename,
int* fd,
uint8_t** file_data,
size_t* size) {
// WARNING: this code runs in a compromised context. It may not call into
// libc nor allocate memory normally.
*fd = sys_open(filename, O_RDONLY, 0);
*size = 0;
if (*fd < 0) {
static const char msg[] = "Cannot upload crash dump: failed to open\n";
WriteLog(msg, sizeof(msg) - 1);
return;
}
LoadDataFromFD(allocator, *fd, true, file_data, size);
}
// Spawn the appropriate upload process for the current OS:
// - generic Linux invokes wget.
// - ChromeOS invokes crash_reporter.
// |dumpfile| is the path to the dump data file.
// |mime_boundary| is only used on Linux.
// |exe_buf| is only used on CrOS and is the crashing process' name.
void ExecUploadProcessOrTerminate(const BreakpadInfo& info,
const char* dumpfile,
const char* mime_boundary,
const char* exe_buf,
google_breakpad::PageAllocator* allocator) {
// The --header argument to wget looks like:
// --header=Content-Type: multipart/form-data; boundary=XYZ
// where the boundary has two fewer leading '-' chars
static const char header_msg[] =
"--header=Content-Type: multipart/form-data; boundary=";
char* const header = reinterpret_cast<char*>(
allocator->Alloc(sizeof(header_msg) - 1 + strlen(mime_boundary) - 2 + 1));
memcpy(header, header_msg, sizeof(header_msg) - 1);
memcpy(header + sizeof(header_msg) - 1, mime_boundary + 2,
strlen(mime_boundary) - 2);
// We grab the NUL byte from the end of |mime_boundary|.
// The --post-file argument to wget looks like:
// --post-file=/tmp/...
static const char post_file_msg[] = "--post-file=";
char* const post_file = reinterpret_cast<char*>(
allocator->Alloc(sizeof(post_file_msg) - 1 + strlen(dumpfile) + 1));
memcpy(post_file, post_file_msg, sizeof(post_file_msg) - 1);
memcpy(post_file + sizeof(post_file_msg) - 1, dumpfile, strlen(dumpfile));
static const char kWgetBinary[] = "/usr/bin/wget";
const char* args[] = {
kWgetBinary, header, post_file, info.upload_url,
"--timeout=60", // Set a timeout so we don't hang forever.
"--tries=1", // Don't retry if the upload fails.
"--quiet", // Be silent.
"-O", // output reply to /dev/null.
"/dev/fd/3", nullptr,
};
static const char msg[] =
"Cannot upload crash dump: cannot exec "
"/usr/bin/wget\n";
execve(args[0], const_cast<char**>(args), environ);
WriteLog(msg, sizeof(msg) - 1);
sys__exit(1);
}
// Runs in the helper process to wait for the upload process running
// ExecUploadProcessOrTerminate() to finish. Returns the number of bytes written
// to |fd| and save the written contents to |buf|.
// |buf| needs to be big enough to hold |bytes_to_read| + 1 characters.
size_t WaitForCrashReportUploadProcess(int fd,
size_t bytes_to_read,
char* buf) {
size_t bytes_read = 0;
// Upload should finish in about 10 seconds. Add a few more 500 ms
// internals to account for process startup time.
for (size_t wait_count = 0; wait_count < 24; ++wait_count) {
struct kernel_pollfd poll_fd;
poll_fd.fd = fd;
poll_fd.events = POLLIN | POLLPRI | POLLERR;
int ret = sys_poll(&poll_fd, 1, 500);
if (ret < 0) {
// Error
break;
} else if (ret > 0) {
// There is data to read.
ssize_t len = HANDLE_EINTR(
sys_read(fd, buf + bytes_read, bytes_to_read - bytes_read));
if (len < 0)
break;
bytes_read += len;
if (bytes_read == bytes_to_read)
break;
}
// |ret| == 0 -> timed out, continue waiting.
// or |bytes_read| < |bytes_to_read| still, keep reading.
}
buf[bytes_to_read] = 0; // Always NUL terminate the buffer.
return bytes_read;
}
// |buf| should be |expected_len| + 1 characters in size and NULL terminated.
bool IsValidCrashReportId(const char* buf,
size_t bytes_read,
size_t expected_len) {
if (bytes_read != expected_len)
return false;
for (size_t i = 0; i < bytes_read; ++i) {
if (!my_isxdigit(buf[i]) && buf[i] != '-')
return false;
}
return true;
}
// |buf| should be |expected_len| + 1 characters in size and NULL terminated.
void HandleCrashReportId(const char* buf,
size_t bytes_read,
size_t expected_len) {
if (!IsValidCrashReportId(buf, bytes_read, expected_len)) {
static const char msg[] = "Failed to get crash dump id.";
WriteLog(msg, sizeof(msg) - 1);
WriteNewline();
static const char id_msg[] = "Report Id: ";
WriteLog(id_msg, sizeof(id_msg) - 1);
WriteLog(buf, bytes_read);
WriteNewline();
return;
}
// Write crash dump id to stderr.
static const char msg[] = "Crash dump id: ";
WriteLog(msg, sizeof(msg) - 1);
WriteLog(buf, my_strlen(buf));
WriteNewline();
// Write crash dump id to crash log as: seconds_since_epoch,crash_id
struct kernel_timeval tv;
if (!sys_gettimeofday(&tv, nullptr)) {
uint64_t time = kernel_timeval_to_ms(&tv) / 1000;
char time_str[kUint64StringSize];
const unsigned time_len = my_uint64_len(time);
my_uint64tos(time_str, time, time_len);
const int kLogOpenFlags = O_CREAT | O_WRONLY | O_APPEND | O_CLOEXEC;
int log_fd = sys_open(g_crash_log_path, kLogOpenFlags, 0600);
if (log_fd > 0) {
sys_write(log_fd, time_str, time_len);
sys_write(log_fd, ",", 1);
sys_write(log_fd, buf, my_strlen(buf));
sys_write(log_fd, "\n", 1);
IGNORE_RET(sys_close(log_fd));
}
}
}
} // namespace
char g_crash_log_path[256];
void HandleCrashDump(const BreakpadInfo& info) {
int dumpfd;
bool keep_fd = false;
size_t dump_size;
uint8_t* dump_data;
google_breakpad::PageAllocator allocator;
const char* exe_buf = nullptr;
if (info.fd != -1) {
// Dump is provided with an open FD.
keep_fd = true;
dumpfd = info.fd;
// The FD is pointing to the end of the file.
// Rewind, we'll read the data next.
if (lseek(dumpfd, 0, SEEK_SET) == -1) {
static const char msg[] =
"Cannot upload crash dump: failed to "
"reposition minidump FD\n";
WriteLog(msg, sizeof(msg) - 1);
IGNORE_RET(sys_close(dumpfd));
return;
}
LoadDataFromFD(&allocator, info.fd, false, &dump_data, &dump_size);
} else {
// Dump is provided with a path.
keep_fd = false;
LoadDataFromFile(&allocator, info.filename, &dumpfd, &dump_data,
&dump_size);
}
// We need to build a MIME block for uploading to the server. Since we are
// going to fork and run wget, it needs to be written to a temp file.
const int ufd = sys_open("/dev/urandom", O_RDONLY, 0);
if (ufd < 0) {
static const char msg[] =
"Cannot upload crash dump because /dev/urandom"
" is missing\n";
WriteLog(msg, sizeof(msg) - 1);
return;
}
static const char temp_file_template[] =
"/tmp/chromium-upload-XXXXXXXXXXXXXXXX";
char temp_file[sizeof(temp_file_template)];
int temp_file_fd = -1;
if (keep_fd) {
temp_file_fd = dumpfd;
// Rewind the destination, we are going to overwrite it.
if (lseek(dumpfd, 0, SEEK_SET) == -1) {
static const char msg[] =
"Cannot upload crash dump: failed to "
"reposition minidump FD (2)\n";
WriteLog(msg, sizeof(msg) - 1);
IGNORE_RET(sys_close(dumpfd));
return;
}
} else {
if (info.upload) {
memcpy(temp_file, temp_file_template, sizeof(temp_file_template));
for (unsigned i = 0; i < 10; ++i) {
uint64_t t;
sys_read(ufd, &t, sizeof(t));
write_uint64_hex(temp_file + sizeof(temp_file) - (16 + 1), t);
temp_file_fd = sys_open(temp_file, O_WRONLY | O_CREAT | O_EXCL, 0600);
if (temp_file_fd >= 0)
break;
}
if (temp_file_fd < 0) {
static const char msg[] =
"Failed to create temporary file in /tmp: "
"cannot upload crash dump\n";
WriteLog(msg, sizeof(msg) - 1);
IGNORE_RET(sys_close(ufd));
return;
}
} else {
temp_file_fd = sys_open(info.filename, O_WRONLY, 0600);
if (temp_file_fd < 0) {
static const char msg[] = "Failed to save crash dump: failed to open\n";
WriteLog(msg, sizeof(msg) - 1);
IGNORE_RET(sys_close(ufd));
return;
}
}
}
// The MIME boundary is 28 hyphens, followed by a 64-bit nonce and a NUL.
char mime_boundary[28 + 16 + 1];
my_memset(mime_boundary, '-', 28);
uint64_t boundary_rand;
sys_read(ufd, &boundary_rand, sizeof(boundary_rand));
write_uint64_hex(mime_boundary + 28, boundary_rand);
mime_boundary[28 + 16] = 0;
IGNORE_RET(sys_close(ufd));
// The MIME block looks like this:
// BOUNDARY \r\n
// Content-Disposition: form-data; name="prod" \r\n \r\n
// Chrome_Linux \r\n
// BOUNDARY \r\n
// Content-Disposition: form-data; name="ver" \r\n \r\n
// 1.2.3.4 \r\n
// BOUNDARY \r\n
//
// zero or one:
// Content-Disposition: form-data; name="ptime" \r\n \r\n
// abcdef \r\n
// BOUNDARY \r\n
//
// zero or one:
// Content-Disposition: form-data; name="ptype" \r\n \r\n
// abcdef \r\n
// BOUNDARY \r\n
//
// zero or one:
// Content-Disposition: form-data; name="lsb-release" \r\n \r\n
// abcdef \r\n
// BOUNDARY \r\n
//
// zero or one:
// Content-Disposition: form-data; name="oom-size" \r\n \r\n
// 1234567890 \r\n
// BOUNDARY \r\n
//
// zero or more (up to CrashKeyStorage::num_entries = 64):
// Content-Disposition: form-data; name=crash-key-name \r\n
// crash-key-value \r\n
// BOUNDARY \r\n
//
// Content-Disposition: form-data; name="dump"; filename="dump" \r\n
// Content-Type: application/octet-stream \r\n \r\n
// <dump contents>
// \r\n BOUNDARY -- \r\n
MimeWriter writer(temp_file_fd, mime_boundary);
{
writer.AddBoundary();
if (info.pid > 0) {
char pid_value_buf[kUint64StringSize];
uint64_t pid_value_len = my_uint64_len(info.pid);
my_uint64tos(pid_value_buf, info.pid, pid_value_len);
static const char pid_key_name[] = "pid";
writer.AddPairData(pid_key_name, sizeof(pid_key_name) - 1, pid_value_buf,
pid_value_len);
writer.AddBoundary();
}
writer.Flush();
}
if (info.process_start_time > 0) {
struct kernel_timeval tv;
if (!sys_gettimeofday(&tv, nullptr)) {
uint64_t time = kernel_timeval_to_ms(&tv);
if (time > info.process_start_time) {
time -= info.process_start_time;
char time_str[kUint64StringSize];
const unsigned time_len = my_uint64_len(time);
my_uint64tos(time_str, time, time_len);
static const char process_time_msg[] = "ptime";
writer.AddPairData(process_time_msg, sizeof(process_time_msg) - 1,
time_str, time_len);
writer.AddBoundary();
writer.Flush();
}
}
}
if (info.distro_length) {
static const char distro_msg[] = "lsb-release";
writer.AddPairString(distro_msg, info.distro);
writer.AddBoundary();
writer.Flush();
}
if (info.oom_size) {
char oom_size_str[kUint64StringSize];
const unsigned oom_size_len = my_uint64_len(info.oom_size);
my_uint64tos(oom_size_str, info.oom_size, oom_size_len);
static const char oom_size_msg[] = "oom-size";
writer.AddPairData(oom_size_msg, sizeof(oom_size_msg) - 1, oom_size_str,
oom_size_len);
writer.AddBoundary();
writer.Flush();
}
if (info.crash_keys) {
CrashKeyStorage::Iterator crash_key_iterator(*info.crash_keys);
const CrashKeyStorage::Entry* entry;
while ((entry = crash_key_iterator.Next())) {
writer.AddPairString(entry->key, entry->value);
writer.AddBoundary();
writer.Flush();
}
}
writer.AddFileContents(g_dump_msg, dump_data, dump_size);
writer.AddEnd();
writer.Flush();
IGNORE_RET(sys_close(temp_file_fd));
if (!info.upload)
return;
const pid_t child = sys_fork();
if (!child) {
// Spawned helper process.
//
// This code is called both when a browser is crashing (in which case,
// nothing really matters any more) and when a renderer/plugin crashes, in
// which case we need to continue.
//
// Since we are a multithreaded app, if we were just to fork(), we might
// grab file descriptors which have just been created in another thread and
// hold them open for too long.
//
// Thus, we have to loop and try and close everything.
const int fd = sys_open("/proc/self/fd", O_DIRECTORY | O_RDONLY, 0);
if (fd < 0) {
for (unsigned i = 3; i < 8192; ++i)
IGNORE_RET(sys_close(i));
} else {
google_breakpad::DirectoryReader reader(fd);
const char* name;
while (reader.GetNextEntry(&name)) {
int i;
if (my_strtoui(&i, name) && i > 2 && i != fd)
IGNORE_RET(sys_close(i));
reader.PopEntry();
}
IGNORE_RET(sys_close(fd));
}
IGNORE_RET(sys_setsid());
// Leave one end of a pipe in the upload process and watch for it getting
// closed by the upload process exiting.
int fds[2];
if (sys_pipe(fds) >= 0) {
const pid_t upload_child = sys_fork();
if (!upload_child) {
// Upload process.
IGNORE_RET(sys_close(fds[0]));
IGNORE_RET(sys_dup2(fds[1], 3));
ExecUploadProcessOrTerminate(info, temp_file, mime_boundary, exe_buf,
&allocator);
}
// Helper process.
if (upload_child > 0) {
IGNORE_RET(sys_close(fds[1]));
const size_t kCrashIdLength = 36;
char id_buf[kCrashIdLength + 1];
size_t bytes_read =
WaitForCrashReportUploadProcess(fds[0], kCrashIdLength, id_buf);
HandleCrashReportId(id_buf, bytes_read, kCrashIdLength);
if (sys_waitpid(upload_child, nullptr, WNOHANG) == 0) {
// Upload process is still around, kill it.
sys_kill(upload_child, SIGKILL);
}
}
}
// Helper process.
IGNORE_RET(sys_unlink(info.filename));
IGNORE_RET(sys_unlink(temp_file));
sys__exit(0);
}
// Main browser process.
if (child <= 0)
return;
(void)HANDLE_EINTR(sys_waitpid(child, nullptr, 0));
}
size_t WriteLog(const char* buf, size_t nbytes) {
return sys_write(2, buf, nbytes);
}
size_t WriteNewline() {
return WriteLog("\n", 1);
}
} // namespace crash_reporter

46
shell/common/crash_reporter/linux/crash_dump_handler.h
View file

@ -1,46 +0,0 @@
// Copyright (c) 2014 GitHub, Inc.
// Copyright (c) 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef SHELL_COMMON_CRASH_REPORTER_LINUX_CRASH_DUMP_HANDLER_H_
#define SHELL_COMMON_CRASH_REPORTER_LINUX_CRASH_DUMP_HANDLER_H_
#include <stddef.h>
#include <stdint.h>
#include <sys/types.h>
#include "base/macros.h"
#include "breakpad/src/common/simple_string_dictionary.h"
namespace crash_reporter {
typedef google_breakpad::NonAllocatingMap<256, 256, 64> CrashKeyStorage;
// BreakpadInfo describes a crash report.
// The minidump information can either be contained in a file descriptor (fd) or
// in a file (whose path is in filename).
struct BreakpadInfo {
int fd; // File descriptor to the Breakpad dump data.
const char* filename; // Path to the Breakpad dump data.
const char* distro; // Linux distro string.
unsigned distro_length; // Length of |distro|.
bool upload; // Whether to upload or save crash dump.
uint64_t process_start_time; // Uptime of the crashing process.
size_t oom_size; // Amount of memory requested if OOM.
uint64_t pid; // PID where applicable.
const char* upload_url; // URL to upload the minidump.
CrashKeyStorage* crash_keys;
};
void HandleCrashDump(const BreakpadInfo& info);
size_t WriteLog(const char* buf, size_t nbytes);
size_t WriteNewline();
// Global variable storing the path of upload log.
extern char g_crash_log_path[256];
} // namespace crash_reporter
#endif // SHELL_COMMON_CRASH_REPORTER_LINUX_CRASH_DUMP_HANDLER_H_

80
shell/common/crash_reporter/win/crash_service_main.cc
View file

@ -1,80 +0,0 @@
// 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/common/crash_reporter/win/crash_service_main.h"
#include <string>
#include "base/at_exit.h"
#include "base/command_line.h"
#include "base/files/file_util.h"
#include "base/logging.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "shell/common/crash_reporter/crash_reporter.h"
#include "third_party/crashpad/crashpad/handler/handler_main.h"
namespace crash_service {
namespace {
const wchar_t kStandardLogFile[] = L"operation_log.txt";
void InvalidParameterHandler(const wchar_t*,
const wchar_t*,
const wchar_t*,
unsigned int,
uintptr_t) {
// noop.
}
bool CreateCrashServiceDirectory(const base::FilePath& temp_dir) {
if (!base::PathExists(temp_dir)) {
if (!base::CreateDirectory(temp_dir))
return false;
}
return true;
}
void RemoveArgs(std::vector<char*>* args) {
args->erase(
std::remove_if(args->begin(), args->end(), [](const std::string& str) {
return base::StartsWith(str, "--type", base::CompareCase::SENSITIVE) ||
base::StartsWith(
str,
std::string("--") + crash_reporter::kCrashesDirectoryKey,
base::CompareCase::INSENSITIVE_ASCII);
}));
}
} // namespace.
int Main(std::vector<char*>* args) {
// Ignore invalid parameter errors.
_set_invalid_parameter_handler(InvalidParameterHandler);
// Initialize all Chromium things.
base::AtExitManager exit_manager;
base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
// We use/create a directory under the user's temp folder, for logging.
base::FilePath operating_dir(
cmd_line->GetSwitchValueNative(crash_reporter::kCrashesDirectoryKey));
CreateCrashServiceDirectory(operating_dir);
base::FilePath log_file_path = operating_dir.Append(kStandardLogFile);
// Logging to stderr (to help with debugging failures on the
// buildbots) and to a file.
logging::LoggingSettings settings;
settings.logging_dest = logging::LOG_TO_ALL;
settings.log_file_path = log_file_path.value().c_str();
logging::InitLogging(settings);
// Logging with pid, tid and timestamp.
logging::SetLogItems(true, true, true, false);
// Crashpad cannot handle unknown arguments, so we need to remove it
RemoveArgs(args);
return crashpad::HandlerMain(args->size(), args->data(), nullptr);
}
} // namespace crash_service

17
shell/common/crash_reporter/win/crash_service_main.h
View file

@ -1,17 +0,0 @@
// Copyright (c) 2013 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef SHELL_COMMON_CRASH_REPORTER_WIN_CRASH_SERVICE_MAIN_H_
#define SHELL_COMMON_CRASH_REPORTER_WIN_CRASH_SERVICE_MAIN_H_
#include <vector>
namespace crash_service {
// Program entry, should be called by main();
int Main(std::vector<char*>* args);
} // namespace crash_service
#endif // SHELL_COMMON_CRASH_REPORTER_WIN_CRASH_SERVICE_MAIN_H_

4
shell/common/electron_constants.cc
View file

@ -25,10 +25,6 @@ const char kSecureProtocolDescription[] =
"The connection to this site is using a strong protocol version "
"and cipher suite.";
#if defined(OS_WIN)
const char kCrashpadPipeName[] = "ELECTRON_CRASHPAD_PIPE_NAME";
#endif
#if BUILDFLAG(ENABLE_RUN_AS_NODE)
const char kRunAsNode[] = "ELECTRON_RUN_AS_NODE";
#endif

5
shell/common/electron_constants.h
View file

@ -25,11 +25,6 @@ extern const char kValidCertificateDescription[];
extern const char kSecureProtocol[];
extern const char kSecureProtocolDescription[];
#if defined(OS_WIN)
// Crashpad pipe name.
extern const char kCrashpadPipeName[];
#endif
#if BUILDFLAG(ENABLE_RUN_AS_NODE)
extern const char kRunAsNode[];
#endif

52
shell/common/electron_paths.h Normal file
View file

@ -0,0 +1,52 @@
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef SHELL_COMMON_ELECTRON_PATHS_H_
#define SHELL_COMMON_ELECTRON_PATHS_H_
#include "base/base_paths.h"
#if defined(OS_WIN)
#include "base/base_paths_win.h"
#elif defined(OS_MACOSX)
#include "base/base_paths_mac.h"
#endif
#if defined(OS_POSIX)
#include "base/base_paths_posix.h"
#endif
namespace electron {
enum {
PATH_START = 11000,
DIR_USER_DATA = PATH_START, // Directory where user data can be written.
DIR_USER_CACHE, // Directory where user cache can be written.
DIR_APP_LOGS, // Directory where app logs live
#if defined(OS_LINUX)
DIR_APP_DATA, // Application Data directory under the user profile.
#endif
DIR_CRASH_DUMPS, // c.f. chrome::DIR_CRASH_DUMPS
PATH_END, // End of new paths. Those that follow redirect to base::DIR_*
#if !defined(OS_LINUX)
DIR_APP_DATA = base::DIR_APP_DATA,
#endif
#if defined(OS_POSIX)
DIR_CACHE = base::DIR_CACHE // Directory where to put cache data.
#else
DIR_CACHE = base::DIR_APP_DATA
#endif
};
static_assert(PATH_START < PATH_END, "invalid PATH boundaries");
} // namespace electron
#endif // SHELL_COMMON_ELECTRON_PATHS_H_

21
shell/common/gin_converters/time_converter.cc Normal file
View file

@ -0,0 +1,21 @@
// Copyright (c) 2020 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#include "shell/common/gin_converters/time_converter.h"
#include "base/time/time.h"
namespace gin {
v8::Local<v8::Value> Converter<base::Time>::ToV8(v8::Isolate* isolate,
const base::Time& val) {
v8::Local<v8::Value> date;
if (v8::Date::New(isolate->GetCurrentContext(), val.ToJsTime())
.ToLocal(&date))
return date;
else
return v8::Null(isolate);
}
} // namespace gin

25
shell/common/gin_converters/time_converter.h Normal file
View file

@ -0,0 +1,25 @@
// Copyright (c) 2020 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.
#ifndef SHELL_COMMON_GIN_CONVERTERS_TIME_CONVERTER_H_
#define SHELL_COMMON_GIN_CONVERTERS_TIME_CONVERTER_H_
#include <utility>
#include "gin/converter.h"
namespace base {
class Time;
}
namespace gin {
template <>
struct Converter<base::Time> {
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate, const base::Time& val);
};
} // namespace gin
#endif // SHELL_COMMON_GIN_CONVERTERS_TIME_CONVERTER_H_

5
shell/common/node_bindings.cc
View file

@ -37,6 +37,7 @@
V(electron_browser_auto_updater) \
V(electron_browser_browser_view) \
V(electron_browser_content_tracing) \
V(electron_browser_crash_reporter) \
V(electron_browser_dialog) \
V(electron_browser_event) \
V(electron_browser_event_emitter) \
@ -52,15 +53,14 @@
V(electron_browser_system_preferences) \
V(electron_browser_top_level_window) \
V(electron_browser_tray) \
V(electron_browser_view) \
V(electron_browser_web_contents) \
V(electron_browser_web_contents_view) \
V(electron_browser_view) \
V(electron_browser_web_view_manager) \
V(electron_browser_window) \
V(electron_common_asar) \
V(electron_common_clipboard) \
V(electron_common_command_line) \
V(electron_common_crash_reporter) \
V(electron_common_features) \
V(electron_common_native_image) \
V(electron_common_native_theme) \
@ -69,6 +69,7 @@
V(electron_common_shell) \
V(electron_common_v8_util) \
V(electron_renderer_context_bridge) \
V(electron_renderer_crash_reporter) \
V(electron_renderer_ipc) \
V(electron_renderer_web_frame)

2
shell/common/options_switches.cc
View file

@ -286,6 +286,8 @@ const char kEnableSpellcheck[] = "enable-spellcheck";
const char kEnableRemoteModule[] = "enable-remote-module";
#endif
const char kGlobalCrashKeys[] = "global-crash-keys";
} // namespace switches
} // namespace electron

2
shell/common/options_switches.h
View file

@ -149,6 +149,8 @@ extern const char kEnableSpellcheck[];
extern const char kEnableRemoteModule[];
#endif
extern const char kGlobalCrashKeys[];
} // namespace switches
} // namespace electron