1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
|
// Copyright 2017 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.
#include "content/browser/child_process_launcher_helper.h"
#include "base/command_line.h"
#include "base/process/launch.h"
#include "base/strings/stringprintf.h"
#include "content/browser/child_process_launcher.h"
#include "content/public/browser/child_process_launcher_utils.h"
#include "content/public/common/sandboxed_process_launcher_delegate.h"
namespace content {
namespace internal {
namespace {
const char* ProcessNameFromSandboxType(
sandbox::policy::SandboxType sandbox_type) {
switch (sandbox_type) {
case sandbox::policy::SandboxType::kNoSandbox:
return nullptr;
case sandbox::policy::SandboxType::kWebContext:
return "context";
case sandbox::policy::SandboxType::kRenderer:
return "renderer";
case sandbox::policy::SandboxType::kUtility:
return "utility";
case sandbox::policy::SandboxType::kGpu:
return "gpu";
case sandbox::policy::SandboxType::kNetwork:
return "network";
case sandbox::policy::SandboxType::kVideoCapture:
return "video-capture";
default:
NOTREACHED() << "Unknown sandbox_type.";
return nullptr;
}
}
} // namespace
void ChildProcessLauncherHelper::SetProcessPriorityOnLauncherThread(
base::Process process,
const ChildProcessLauncherPriority& priority) {
DCHECK(CurrentlyOnProcessLauncherTaskRunner());
// TODO(https://crbug.com/926583): Fuchsia does not currently support this.
}
ChildProcessTerminationInfo ChildProcessLauncherHelper::GetTerminationInfo(
const ChildProcessLauncherHelper::Process& process,
bool known_dead) {
ChildProcessTerminationInfo info;
info.status =
base::GetTerminationStatus(process.process.Handle(), &info.exit_code);
return info;
}
// static
bool ChildProcessLauncherHelper::TerminateProcess(const base::Process& process,
int exit_code) {
return process.Terminate(exit_code, false);
}
void ChildProcessLauncherHelper::BeforeLaunchOnClientThread() {
DCHECK(client_task_runner_->RunsTasksInCurrentSequence());
sandbox_policy_ = std::make_unique<sandbox::policy::SandboxPolicyFuchsia>(
delegate_->GetSandboxType());
}
std::unique_ptr<FileMappedForLaunch>
ChildProcessLauncherHelper::GetFilesToMap() {
DCHECK(CurrentlyOnProcessLauncherTaskRunner());
return std::unique_ptr<FileMappedForLaunch>();
}
bool ChildProcessLauncherHelper::BeforeLaunchOnLauncherThread(
PosixFileDescriptorInfo& files_to_register,
base::LaunchOptions* options) {
DCHECK(CurrentlyOnProcessLauncherTaskRunner());
mojo_channel_->PrepareToPassRemoteEndpoint(&options->handles_to_transfer,
command_line());
sandbox_policy_->UpdateLaunchOptionsForSandbox(options);
// Set process name suffix to make it easier to identify the process.
const char* process_type =
ProcessNameFromSandboxType(delegate_->GetSandboxType());
if (process_type)
options->process_name_suffix = base::StringPrintf(":%s", process_type);
return true;
}
ChildProcessLauncherHelper::Process
ChildProcessLauncherHelper::LaunchProcessOnLauncherThread(
const base::LaunchOptions& options,
std::unique_ptr<FileMappedForLaunch> files_to_register,
bool* is_synchronous_launch,
int* launch_result) {
DCHECK(CurrentlyOnProcessLauncherTaskRunner());
DCHECK(mojo_channel_);
DCHECK(mojo_channel_->remote_endpoint().is_valid());
Process child_process;
child_process.process = base::LaunchProcess(*command_line(), options);
return child_process;
}
void ChildProcessLauncherHelper::AfterLaunchOnLauncherThread(
const ChildProcessLauncherHelper::Process& process,
const base::LaunchOptions& options) {
}
// static
void ChildProcessLauncherHelper::ForceNormalProcessTerminationSync(
ChildProcessLauncherHelper::Process process) {
DCHECK(CurrentlyOnProcessLauncherTaskRunner());
process.process.Terminate(RESULT_CODE_NORMAL_EXIT, true);
}
} // namespace internal
} // namespace content
|
