forked from chromium/chromium
-
Notifications
You must be signed in to change notification settings - Fork 0
/
browser_thread_unittest.cc
241 lines (205 loc) · 8.32 KB
/
browser_thread_unittest.cc
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
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
// 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 <memory>
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/callback.h"
#include "base/location.h"
#include "base/message_loop/message_loop.h"
#include "base/run_loop.h"
#include "base/sequenced_task_runner_helpers.h"
#include "base/single_thread_task_runner.h"
#include "base/task/post_task.h"
#include "base/test/scoped_task_environment.h"
#include "base/threading/thread_task_runner_handle.h"
#include "build/build_config.h"
#include "content/browser/browser_process_sub_thread.h"
#include "content/browser/browser_thread_impl.h"
#include "content/browser/scheduler/browser_task_executor.h"
#include "content/public/browser/browser_task_traits.h"
#include "content/public/test/test_browser_thread.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "testing/platform_test.h"
namespace content {
class BrowserThreadTest : public testing::Test {
public:
void Release() const {
EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI));
EXPECT_TRUE(on_release_);
std::move(on_release_).Run();
}
void StopUIThread() { ui_thread_->Stop(); }
protected:
void SetUp() override {
BrowserTaskExecutor::Create();
ui_thread_ = std::make_unique<BrowserProcessSubThread>(BrowserThread::UI);
ui_thread_->Start();
io_thread_ = std::make_unique<BrowserProcessSubThread>(BrowserThread::IO);
base::Thread::Options io_options;
io_options.message_loop_type = base::MessageLoop::TYPE_IO;
io_thread_->StartWithOptions(io_options);
ui_thread_->RegisterAsBrowserThread();
io_thread_->RegisterAsBrowserThread();
}
void TearDown() override {
io_thread_.reset();
ui_thread_.reset();
BrowserThreadImpl::ResetGlobalsForTesting(BrowserThread::UI);
BrowserThreadImpl::ResetGlobalsForTesting(BrowserThread::IO);
BrowserTaskExecutor::ResetForTesting();
}
// Prepares this BrowserThreadTest for Release() to be invoked. |on_release|
// will be invoked when this occurs.
void ExpectRelease(base::OnceClosure on_release) {
on_release_ = std::move(on_release);
}
static void BasicFunction(base::OnceClosure continuation,
BrowserThread::ID target) {
EXPECT_TRUE(BrowserThread::CurrentlyOn(target));
std::move(continuation).Run();
}
class DeletedOnIO
: public base::RefCountedThreadSafe<DeletedOnIO,
BrowserThread::DeleteOnIOThread> {
public:
explicit DeletedOnIO(base::OnceClosure on_deletion)
: on_deletion_(std::move(on_deletion)) {}
private:
friend struct BrowserThread::DeleteOnThread<BrowserThread::IO>;
friend class base::DeleteHelper<DeletedOnIO>;
~DeletedOnIO() {
EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::IO));
std::move(on_deletion_).Run();
}
base::OnceClosure on_deletion_;
};
private:
std::unique_ptr<BrowserProcessSubThread> ui_thread_;
std::unique_ptr<BrowserProcessSubThread> io_thread_;
base::test::ScopedTaskEnvironment scoped_task_environment_;
// Must be set before Release() to verify the deletion is intentional. Will be
// run from the next call to Release(). mutable so it can be consumed from
// Release().
mutable base::OnceClosure on_release_;
};
class UIThreadDestructionObserver
: public base::MessageLoopCurrent::DestructionObserver {
public:
explicit UIThreadDestructionObserver(bool* did_shutdown,
const base::Closure& callback)
: callback_task_runner_(base::ThreadTaskRunnerHandle::Get()),
callback_(callback),
ui_task_runner_(
base::CreateSingleThreadTaskRunnerWithTraits({BrowserThread::UI})),
did_shutdown_(did_shutdown) {
ui_task_runner_->PostTask(FROM_HERE, base::BindOnce(&Watch, this));
}
private:
static void Watch(UIThreadDestructionObserver* observer) {
base::MessageLoopCurrent::Get()->AddDestructionObserver(observer);
}
// base::MessageLoopCurrent::DestructionObserver:
void WillDestroyCurrentMessageLoop() override {
// Ensure that even during MessageLoop teardown the BrowserThread ID is
// correctly associated with this thread and the BrowserThreadTaskRunner
// knows it's on the right thread.
EXPECT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI));
EXPECT_TRUE(ui_task_runner_->BelongsToCurrentThread());
base::MessageLoopCurrent::Get()->RemoveDestructionObserver(this);
*did_shutdown_ = true;
callback_task_runner_->PostTask(FROM_HERE, callback_);
}
const scoped_refptr<base::SingleThreadTaskRunner> callback_task_runner_;
const base::Closure callback_;
const scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
bool* did_shutdown_;
};
TEST_F(BrowserThreadTest, PostTaskWithTraits) {
base::RunLoop run_loop;
EXPECT_TRUE(base::PostTaskWithTraits(
FROM_HERE, {BrowserThread::IO, NonNestable()},
base::BindOnce(&BasicFunction, run_loop.QuitWhenIdleClosure(),
BrowserThread::IO)));
run_loop.Run();
}
TEST_F(BrowserThreadTest, Release) {
base::RunLoop run_loop;
ExpectRelease(run_loop.QuitWhenIdleClosure());
BrowserThread::ReleaseSoon(BrowserThread::UI, FROM_HERE, this);
run_loop.Run();
}
TEST_F(BrowserThreadTest, ReleasedOnCorrectThread) {
base::RunLoop run_loop;
{
scoped_refptr<DeletedOnIO> test(
new DeletedOnIO(run_loop.QuitWhenIdleClosure()));
}
run_loop.Run();
}
TEST_F(BrowserThreadTest, PostTaskViaTaskRunnerWithTraits) {
scoped_refptr<base::TaskRunner> task_runner =
base::CreateTaskRunnerWithTraits({BrowserThread::IO});
base::RunLoop run_loop;
EXPECT_TRUE(task_runner->PostTask(
FROM_HERE, base::BindOnce(&BasicFunction, run_loop.QuitWhenIdleClosure(),
BrowserThread::IO)));
run_loop.Run();
}
TEST_F(BrowserThreadTest, PostTaskViaSequencedTaskRunnerWithTraits) {
scoped_refptr<base::SequencedTaskRunner> task_runner =
base::CreateSequencedTaskRunnerWithTraits({BrowserThread::IO});
base::RunLoop run_loop;
EXPECT_TRUE(task_runner->PostTask(
FROM_HERE, base::BindOnce(&BasicFunction, run_loop.QuitWhenIdleClosure(),
BrowserThread::IO)));
run_loop.Run();
}
TEST_F(BrowserThreadTest, PostTaskViaSingleThreadTaskRunnerWithTraits) {
scoped_refptr<base::SingleThreadTaskRunner> task_runner =
base::CreateSingleThreadTaskRunnerWithTraits({BrowserThread::IO});
base::RunLoop run_loop;
EXPECT_TRUE(task_runner->PostTask(
FROM_HERE, base::BindOnce(&BasicFunction, run_loop.QuitWhenIdleClosure(),
BrowserThread::IO)));
run_loop.Run();
}
#if defined(OS_WIN)
TEST_F(BrowserThreadTest, PostTaskViaCOMSTATaskRunnerWithTraits) {
scoped_refptr<base::SingleThreadTaskRunner> task_runner =
base::CreateCOMSTATaskRunnerWithTraits({BrowserThread::UI});
base::RunLoop run_loop;
EXPECT_TRUE(task_runner->PostTask(
FROM_HERE, base::BindOnce(&BasicFunction, run_loop.QuitWhenIdleClosure(),
BrowserThread::UI)));
run_loop.Run();
}
#endif // defined(OS_WIN)
TEST_F(BrowserThreadTest, ReleaseViaTaskRunnerWithTraits) {
scoped_refptr<base::SingleThreadTaskRunner> task_runner =
base::CreateSingleThreadTaskRunnerWithTraits({BrowserThread::UI});
base::RunLoop run_loop;
ExpectRelease(run_loop.QuitWhenIdleClosure());
task_runner->ReleaseSoon(FROM_HERE, this);
run_loop.Run();
}
TEST_F(BrowserThreadTest, PostTaskAndReplyWithTraits) {
// Most of the heavy testing for PostTaskAndReply() is done inside the
// task runner test. This just makes sure we get piped through at all.
base::RunLoop run_loop;
ASSERT_TRUE(base::PostTaskWithTraitsAndReply(FROM_HERE, {BrowserThread::IO},
base::DoNothing(),
run_loop.QuitWhenIdleClosure()));
run_loop.Run();
}
TEST_F(BrowserThreadTest, RunsTasksInCurrentSequencedDuringShutdown) {
bool did_shutdown = false;
base::RunLoop loop;
UIThreadDestructionObserver observer(&did_shutdown, loop.QuitClosure());
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE,
base::BindOnce(&BrowserThreadTest::StopUIThread, base::Unretained(this)));
loop.Run();
EXPECT_TRUE(did_shutdown);
}
} // namespace content