blob: 0f4fa57ae42d16dfa55357decc6e0c5c0064e88a (
plain)
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
|
// Copyright (c) 2012 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/child/child_process.h"
#include <string.h>
#include "base/bind.h"
#include "base/lazy_instance.h"
#include "base/message_loop/message_pump_type.h"
#include "base/process/process_handle.h"
#include "base/single_thread_task_runner.h"
#include "base/task/thread_pool/thread_pool_instance.h"
#include "base/threading/thread.h"
#include "base/threading/thread_local.h"
#include "build/build_config.h"
#include "content/child/child_thread_impl.h"
#include "content/common/android/cpu_time_metrics.h"
#include "content/common/mojo_core_library_support.h"
#include "mojo/public/cpp/system/dynamic_library_support.h"
#include "services/service_manager/sandbox/sandbox_type.h"
#include "services/tracing/public/cpp/trace_startup.h"
#include "third_party/blink/public/common/features.h"
namespace content {
namespace {
base::LazyInstance<base::ThreadLocalPointer<ChildProcess>>::DestructorAtExit
g_lazy_child_process_tls = LAZY_INSTANCE_INITIALIZER;
}
ChildProcess::ChildProcess(base::ThreadPriority io_thread_priority,
const std::string& thread_pool_name,
std::unique_ptr<base::ThreadPoolInstance::InitParams>
thread_pool_init_params)
: ref_count_(0),
shutdown_event_(base::WaitableEvent::ResetPolicy::MANUAL,
base::WaitableEvent::InitialState::NOT_SIGNALED),
io_thread_("Chrome_ChildIOThread") {
DCHECK(!g_lazy_child_process_tls.Pointer()->Get());
g_lazy_child_process_tls.Pointer()->Set(this);
#if defined(OS_LINUX)
const base::CommandLine& command_line =
*base::CommandLine::ForCurrentProcess();
if (IsMojoCoreSharedLibraryEnabled()) {
// If we're in a child process on Linux and dynamic Mojo Core is in use, we
// expect early process startup code (see ContentMainRunnerImpl::Run()) to
// have already loaded the library via |mojo::LoadCoreLibrary()|, rendering
// this call safe even from within a strict sandbox.
MojoInitializeFlags flags = MOJO_INITIALIZE_FLAG_NONE;
if (service_manager::IsUnsandboxedSandboxType(
service_manager::SandboxTypeFromCommandLine(command_line))) {
flags |= MOJO_INITIALIZE_FLAG_FORCE_DIRECT_SHARED_MEMORY_ALLOCATION;
}
CHECK_EQ(MOJO_RESULT_OK, mojo::InitializeCoreLibrary(flags));
}
#endif
// Initialize ThreadPoolInstance if not already done. A ThreadPoolInstance may
// already exist when ChildProcess is instantiated in the browser process or
// in a test process.
if (!base::ThreadPoolInstance::Get()) {
if (thread_pool_init_params) {
base::ThreadPoolInstance::Create(thread_pool_name);
base::ThreadPoolInstance::Get()->Start(*thread_pool_init_params.get());
} else {
base::ThreadPoolInstance::CreateAndStartWithDefaultParams(
thread_pool_name);
}
DCHECK(base::ThreadPoolInstance::Get());
initialized_thread_pool_ = true;
}
tracing::InitTracingPostThreadPoolStartAndFeatureList();
#if defined(OS_ANDROID)
SetupCpuTimeMetrics();
#endif
// We can't recover from failing to start the IO thread.
base::Thread::Options thread_options(base::MessagePumpType::IO, 0);
thread_options.priority = io_thread_priority;
#if defined(OS_ANDROID)
// TODO(reveman): Remove this in favor of setting it explicitly for each type
// of process.
if (base::FeatureList::IsEnabled(
blink::features::kBlinkCompositorUseDisplayThreadPriority)) {
thread_options.priority = base::ThreadPriority::DISPLAY;
}
#endif
CHECK(io_thread_.StartWithOptions(thread_options));
}
ChildProcess::~ChildProcess() {
DCHECK(g_lazy_child_process_tls.Pointer()->Get() == this);
// Signal this event before destroying the child process. That way all
// background threads can cleanup.
// For example, in the renderer the RenderThread instances will be able to
// notice shutdown before the render process begins waiting for them to exit.
shutdown_event_.Signal();
if (main_thread_) { // null in unittests.
main_thread_->Shutdown();
if (main_thread_->ShouldBeDestroyed()) {
main_thread_.reset();
} else {
// Leak the main_thread_. See a comment in
// RenderThreadImpl::ShouldBeDestroyed.
main_thread_.release();
}
}
g_lazy_child_process_tls.Pointer()->Set(nullptr);
io_thread_.Stop();
if (initialized_thread_pool_) {
DCHECK(base::ThreadPoolInstance::Get());
base::ThreadPoolInstance::Get()->Shutdown();
}
}
ChildThreadImpl* ChildProcess::main_thread() {
return main_thread_.get();
}
void ChildProcess::set_main_thread(ChildThreadImpl* thread) {
main_thread_.reset(thread);
}
void ChildProcess::AddRefProcess() {
DCHECK(!main_thread_.get() || // null in unittests.
main_thread_->main_thread_runner()->BelongsToCurrentThread());
ref_count_++;
}
void ChildProcess::ReleaseProcess() {
DCHECK(!main_thread_.get() || // null in unittests.
main_thread_->main_thread_runner()->BelongsToCurrentThread());
DCHECK(ref_count_);
if (--ref_count_)
return;
if (main_thread_) // null in unittests.
main_thread_->OnProcessFinalRelease();
}
ChildProcess* ChildProcess::current() {
return g_lazy_child_process_tls.Pointer()->Get();
}
base::WaitableEvent* ChildProcess::GetShutDownEvent() {
return &shutdown_event_;
}
} // namespace content
|
