ajwong@chromium.org | 22a8a0d | 2012-01-04 09:57:39 +0900 | [diff] [blame] | 1 | // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
| 4 | |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 5 | #include "base/message_loop/message_pump_glib.h" |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 6 | |
erg@chromium.org | b09a889 | 2012-06-29 04:57:26 +0900 | [diff] [blame] | 7 | #include <glib.h> |
agl@chromium.org | 927bd07 | 2009-06-16 04:53:08 +0900 | [diff] [blame] | 8 | #include <math.h> |
| 9 | |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 10 | #include <algorithm> |
| 11 | #include <vector> |
agl@chromium.org | 927bd07 | 2009-06-16 04:53:08 +0900 | [diff] [blame] | 12 | |
jhawkins@chromium.org | 598ca1c | 2012-01-01 11:14:47 +0900 | [diff] [blame] | 13 | #include "base/bind.h" |
| 14 | #include "base/bind_helpers.h" |
dcheng@chromium.org | 7029710 | 2011-12-10 08:06:02 +0900 | [diff] [blame] | 15 | #include "base/callback.h" |
avi | a6a6a68 | 2015-12-27 07:15:14 +0900 | [diff] [blame] | 16 | #include "base/macros.h" |
levin@chromium.org | 5c52868 | 2011-03-28 10:54:15 +0900 | [diff] [blame] | 17 | #include "base/memory/ref_counted.h" |
avi@chromium.org | a043a86 | 2013-07-18 17:12:40 +0900 | [diff] [blame] | 18 | #include "base/message_loop/message_loop.h" |
tfarina@chromium.org | 7d4a0ec | 2013-02-07 01:56:19 +0900 | [diff] [blame] | 19 | #include "base/run_loop.h" |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 20 | #include "base/single_thread_task_runner.h" |
brettw@chromium.org | 5b5f5e0 | 2011-01-01 10:01:06 +0900 | [diff] [blame] | 21 | #include "base/threading/thread.h" |
fdoray | 96ab655 | 2016-07-19 08:47:16 +0900 | [diff] [blame] | 22 | #include "base/threading/thread_task_runner_handle.h" |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 23 | #include "testing/gtest/include/gtest/gtest.h" |
| 24 | |
tfarina@chromium.org | 7d4a0ec | 2013-02-07 01:56:19 +0900 | [diff] [blame] | 25 | namespace base { |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 26 | namespace { |
| 27 | |
| 28 | // This class injects dummy "events" into the GLib loop. When "handled" these |
| 29 | // events can run tasks. This is intended to mock gtk events (the corresponding |
| 30 | // GLib source runs at the same priority). |
| 31 | class EventInjector { |
| 32 | public: |
| 33 | EventInjector() : processed_events_(0) { |
| 34 | source_ = static_cast<Source*>(g_source_new(&SourceFuncs, sizeof(Source))); |
| 35 | source_->injector = this; |
Ivan Kotenkov | e88f346 | 2017-11-08 21:37:33 +0900 | [diff] [blame] | 36 | g_source_attach(source_, nullptr); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 37 | g_source_set_can_recurse(source_, TRUE); |
| 38 | } |
| 39 | |
| 40 | ~EventInjector() { |
| 41 | g_source_destroy(source_); |
| 42 | g_source_unref(source_); |
| 43 | } |
| 44 | |
| 45 | int HandlePrepare() { |
| 46 | // If the queue is empty, block. |
| 47 | if (events_.empty()) |
| 48 | return -1; |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 49 | TimeDelta delta = events_[0].time - Time::NowFromSystemTime(); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 50 | return std::max(0, static_cast<int>(ceil(delta.InMillisecondsF()))); |
| 51 | } |
| 52 | |
| 53 | bool HandleCheck() { |
| 54 | if (events_.empty()) |
| 55 | return false; |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 56 | return events_[0].time <= Time::NowFromSystemTime(); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 57 | } |
| 58 | |
| 59 | void HandleDispatch() { |
| 60 | if (events_.empty()) |
| 61 | return; |
tzik | c372ed8 | 2017-04-18 16:01:15 +0900 | [diff] [blame] | 62 | Event event = std::move(events_[0]); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 63 | events_.erase(events_.begin()); |
| 64 | ++processed_events_; |
jhawkins@chromium.org | 598ca1c | 2012-01-01 11:14:47 +0900 | [diff] [blame] | 65 | if (!event.callback.is_null()) |
tzik | c372ed8 | 2017-04-18 16:01:15 +0900 | [diff] [blame] | 66 | std::move(event.callback).Run(); |
jhawkins@chromium.org | 598ca1c | 2012-01-01 11:14:47 +0900 | [diff] [blame] | 67 | else if (!event.task.is_null()) |
tzik | c372ed8 | 2017-04-18 16:01:15 +0900 | [diff] [blame] | 68 | std::move(event.task).Run(); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 69 | } |
| 70 | |
dcheng@chromium.org | 7029710 | 2011-12-10 08:06:02 +0900 | [diff] [blame] | 71 | // Adds an event to the queue. When "handled", executes |callback|. |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 72 | // delay_ms is relative to the last event if any, or to Now() otherwise. |
tzik | c372ed8 | 2017-04-18 16:01:15 +0900 | [diff] [blame] | 73 | void AddEvent(int delay_ms, OnceClosure callback) { |
| 74 | AddEventHelper(delay_ms, std::move(callback), OnceClosure()); |
dcheng@chromium.org | 7029710 | 2011-12-10 08:06:02 +0900 | [diff] [blame] | 75 | } |
| 76 | |
| 77 | void AddDummyEvent(int delay_ms) { |
tzik | c372ed8 | 2017-04-18 16:01:15 +0900 | [diff] [blame] | 78 | AddEventHelper(delay_ms, OnceClosure(), OnceClosure()); |
dcheng@chromium.org | 7029710 | 2011-12-10 08:06:02 +0900 | [diff] [blame] | 79 | } |
| 80 | |
tzik | c372ed8 | 2017-04-18 16:01:15 +0900 | [diff] [blame] | 81 | void AddEventAsTask(int delay_ms, OnceClosure task) { |
| 82 | AddEventHelper(delay_ms, OnceClosure(), std::move(task)); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 83 | } |
| 84 | |
| 85 | void Reset() { |
| 86 | processed_events_ = 0; |
| 87 | events_.clear(); |
| 88 | } |
| 89 | |
| 90 | int processed_events() const { return processed_events_; } |
| 91 | |
| 92 | private: |
| 93 | struct Event { |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 94 | Time time; |
tzik | c372ed8 | 2017-04-18 16:01:15 +0900 | [diff] [blame] | 95 | OnceClosure callback; |
| 96 | OnceClosure task; |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 97 | }; |
| 98 | |
| 99 | struct Source : public GSource { |
| 100 | EventInjector* injector; |
| 101 | }; |
| 102 | |
tzik | c372ed8 | 2017-04-18 16:01:15 +0900 | [diff] [blame] | 103 | void AddEventHelper(int delay_ms, OnceClosure callback, OnceClosure task) { |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 104 | Time last_time; |
jhawkins@chromium.org | 598ca1c | 2012-01-01 11:14:47 +0900 | [diff] [blame] | 105 | if (!events_.empty()) |
dcheng@chromium.org | 7029710 | 2011-12-10 08:06:02 +0900 | [diff] [blame] | 106 | last_time = (events_.end()-1)->time; |
jhawkins@chromium.org | 598ca1c | 2012-01-01 11:14:47 +0900 | [diff] [blame] | 107 | else |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 108 | last_time = Time::NowFromSystemTime(); |
jhawkins@chromium.org | 598ca1c | 2012-01-01 11:14:47 +0900 | [diff] [blame] | 109 | |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 110 | Time future = last_time + TimeDelta::FromMilliseconds(delay_ms); |
tzik | c372ed8 | 2017-04-18 16:01:15 +0900 | [diff] [blame] | 111 | EventInjector::Event event = {future, std::move(callback), std::move(task)}; |
| 112 | events_.push_back(std::move(event)); |
dcheng@chromium.org | 7029710 | 2011-12-10 08:06:02 +0900 | [diff] [blame] | 113 | } |
| 114 | |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 115 | static gboolean Prepare(GSource* source, gint* timeout_ms) { |
| 116 | *timeout_ms = static_cast<Source*>(source)->injector->HandlePrepare(); |
| 117 | return FALSE; |
| 118 | } |
| 119 | |
| 120 | static gboolean Check(GSource* source) { |
| 121 | return static_cast<Source*>(source)->injector->HandleCheck(); |
| 122 | } |
| 123 | |
| 124 | static gboolean Dispatch(GSource* source, |
| 125 | GSourceFunc unused_func, |
| 126 | gpointer unused_data) { |
| 127 | static_cast<Source*>(source)->injector->HandleDispatch(); |
| 128 | return TRUE; |
| 129 | } |
| 130 | |
| 131 | Source* source_; |
| 132 | std::vector<Event> events_; |
| 133 | int processed_events_; |
| 134 | static GSourceFuncs SourceFuncs; |
| 135 | DISALLOW_COPY_AND_ASSIGN(EventInjector); |
| 136 | }; |
| 137 | |
Ivan Kotenkov | e88f346 | 2017-11-08 21:37:33 +0900 | [diff] [blame] | 138 | GSourceFuncs EventInjector::SourceFuncs = {EventInjector::Prepare, |
| 139 | EventInjector::Check, |
| 140 | EventInjector::Dispatch, nullptr}; |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 141 | |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 142 | void IncrementInt(int *value) { |
| 143 | ++*value; |
| 144 | } |
| 145 | |
| 146 | // Checks how many events have been processed by the injector. |
| 147 | void ExpectProcessedEvents(EventInjector* injector, int count) { |
| 148 | EXPECT_EQ(injector->processed_events(), count); |
| 149 | } |
| 150 | |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 151 | // Posts a task on the current message loop. |
Brett Wilson | 89388db | 2017-09-12 14:22:16 +0900 | [diff] [blame] | 152 | void PostMessageLoopTask(const Location& from_here, OnceClosure task) { |
tzik | c372ed8 | 2017-04-18 16:01:15 +0900 | [diff] [blame] | 153 | ThreadTaskRunnerHandle::Get()->PostTask(from_here, std::move(task)); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 154 | } |
| 155 | |
| 156 | // Test fixture. |
| 157 | class MessagePumpGLibTest : public testing::Test { |
| 158 | public: |
Ivan Kotenkov | e88f346 | 2017-11-08 21:37:33 +0900 | [diff] [blame] | 159 | MessagePumpGLibTest() : loop_(nullptr), injector_(nullptr) {} |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 160 | |
tfarina@chromium.org | 2852dcb | 2012-07-31 10:38:18 +0900 | [diff] [blame] | 161 | // Overridden from testing::Test: |
dcheng | ca87abb | 2014-12-23 11:56:47 +0900 | [diff] [blame] | 162 | void SetUp() override { |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 163 | loop_ = new MessageLoop(MessageLoop::TYPE_UI); |
| 164 | injector_ = new EventInjector(); |
| 165 | } |
dcheng | ca87abb | 2014-12-23 11:56:47 +0900 | [diff] [blame] | 166 | void TearDown() override { |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 167 | delete injector_; |
Ivan Kotenkov | e88f346 | 2017-11-08 21:37:33 +0900 | [diff] [blame] | 168 | injector_ = nullptr; |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 169 | delete loop_; |
Ivan Kotenkov | e88f346 | 2017-11-08 21:37:33 +0900 | [diff] [blame] | 170 | loop_ = nullptr; |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 171 | } |
| 172 | |
| 173 | MessageLoop* loop() const { return loop_; } |
| 174 | EventInjector* injector() const { return injector_; } |
| 175 | |
| 176 | private: |
| 177 | MessageLoop* loop_; |
| 178 | EventInjector* injector_; |
| 179 | DISALLOW_COPY_AND_ASSIGN(MessagePumpGLibTest); |
| 180 | }; |
| 181 | |
| 182 | } // namespace |
| 183 | |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 184 | TEST_F(MessagePumpGLibTest, TestQuit) { |
| 185 | // Checks that Quit works and that the basic infrastructure is working. |
| 186 | |
| 187 | // Quit from a task |
tfarina@chromium.org | 7d4a0ec | 2013-02-07 01:56:19 +0900 | [diff] [blame] | 188 | RunLoop().RunUntilIdle(); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 189 | EXPECT_EQ(0, injector()->processed_events()); |
| 190 | |
| 191 | injector()->Reset(); |
| 192 | // Quit from an event |
thakis@chromium.org | fc6f929 | 2013-02-05 08:40:00 +0900 | [diff] [blame] | 193 | injector()->AddEvent(0, MessageLoop::QuitWhenIdleClosure()); |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 194 | RunLoop().Run(); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 195 | EXPECT_EQ(1, injector()->processed_events()); |
| 196 | } |
| 197 | |
| 198 | TEST_F(MessagePumpGLibTest, TestEventTaskInterleave) { |
| 199 | // Checks that tasks posted by events are executed before the next event if |
| 200 | // the posted task queue is empty. |
| 201 | // MessageLoop doesn't make strong guarantees that it is the case, but the |
| 202 | // current implementation ensures it and the tests below rely on it. |
| 203 | // If changes cause this test to fail, it is reasonable to change it, but |
| 204 | // TestWorkWhileWaitingForEvents and TestEventsWhileWaitingForWork have to be |
| 205 | // changed accordingly, otherwise they can become flaky. |
Peter Kasting | 24efe5e | 2018-02-24 09:03:01 +0900 | [diff] [blame^] | 206 | injector()->AddEventAsTask(0, DoNothing()); |
tzik | c372ed8 | 2017-04-18 16:01:15 +0900 | [diff] [blame] | 207 | OnceClosure check_task = |
| 208 | BindOnce(&ExpectProcessedEvents, Unretained(injector()), 2); |
| 209 | OnceClosure posted_task = |
| 210 | BindOnce(&PostMessageLoopTask, FROM_HERE, std::move(check_task)); |
| 211 | injector()->AddEventAsTask(0, std::move(posted_task)); |
Peter Kasting | 24efe5e | 2018-02-24 09:03:01 +0900 | [diff] [blame^] | 212 | injector()->AddEventAsTask(0, DoNothing()); |
thakis@chromium.org | fc6f929 | 2013-02-05 08:40:00 +0900 | [diff] [blame] | 213 | injector()->AddEvent(0, MessageLoop::QuitWhenIdleClosure()); |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 214 | RunLoop().Run(); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 215 | EXPECT_EQ(4, injector()->processed_events()); |
| 216 | |
| 217 | injector()->Reset(); |
Peter Kasting | 24efe5e | 2018-02-24 09:03:01 +0900 | [diff] [blame^] | 218 | injector()->AddEventAsTask(0, DoNothing()); |
tzik | c372ed8 | 2017-04-18 16:01:15 +0900 | [diff] [blame] | 219 | check_task = BindOnce(&ExpectProcessedEvents, Unretained(injector()), 2); |
| 220 | posted_task = |
| 221 | BindOnce(&PostMessageLoopTask, FROM_HERE, std::move(check_task)); |
| 222 | injector()->AddEventAsTask(0, std::move(posted_task)); |
Peter Kasting | 24efe5e | 2018-02-24 09:03:01 +0900 | [diff] [blame^] | 223 | injector()->AddEventAsTask(10, DoNothing()); |
thakis@chromium.org | fc6f929 | 2013-02-05 08:40:00 +0900 | [diff] [blame] | 224 | injector()->AddEvent(0, MessageLoop::QuitWhenIdleClosure()); |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 225 | RunLoop().Run(); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 226 | EXPECT_EQ(4, injector()->processed_events()); |
| 227 | } |
| 228 | |
| 229 | TEST_F(MessagePumpGLibTest, TestWorkWhileWaitingForEvents) { |
| 230 | int task_count = 0; |
| 231 | // Tests that we process tasks while waiting for new events. |
| 232 | // The event queue is empty at first. |
| 233 | for (int i = 0; i < 10; ++i) { |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 234 | loop()->task_runner()->PostTask(FROM_HERE, |
tzik | 6bdbeb2 | 2017-04-12 00:00:44 +0900 | [diff] [blame] | 235 | BindOnce(&IncrementInt, &task_count)); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 236 | } |
| 237 | // After all the previous tasks have executed, enqueue an event that will |
| 238 | // quit. |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 239 | loop()->task_runner()->PostTask( |
tzik | 6bdbeb2 | 2017-04-12 00:00:44 +0900 | [diff] [blame] | 240 | FROM_HERE, BindOnce(&EventInjector::AddEvent, Unretained(injector()), 0, |
| 241 | MessageLoop::QuitWhenIdleClosure())); |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 242 | RunLoop().Run(); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 243 | ASSERT_EQ(10, task_count); |
| 244 | EXPECT_EQ(1, injector()->processed_events()); |
| 245 | |
| 246 | // Tests that we process delayed tasks while waiting for new events. |
| 247 | injector()->Reset(); |
| 248 | task_count = 0; |
| 249 | for (int i = 0; i < 10; ++i) { |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 250 | loop()->task_runner()->PostDelayedTask(FROM_HERE, |
tzik | 6bdbeb2 | 2017-04-12 00:00:44 +0900 | [diff] [blame] | 251 | BindOnce(&IncrementInt, &task_count), |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 252 | TimeDelta::FromMilliseconds(10 * i)); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 253 | } |
| 254 | // After all the previous tasks have executed, enqueue an event that will |
| 255 | // quit. |
| 256 | // This relies on the fact that delayed tasks are executed in delay order. |
| 257 | // That is verified in message_loop_unittest.cc. |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 258 | loop()->task_runner()->PostDelayedTask( |
tzik | 6bdbeb2 | 2017-04-12 00:00:44 +0900 | [diff] [blame] | 259 | FROM_HERE, |
| 260 | BindOnce(&EventInjector::AddEvent, Unretained(injector()), 10, |
| 261 | MessageLoop::QuitWhenIdleClosure()), |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 262 | TimeDelta::FromMilliseconds(150)); |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 263 | RunLoop().Run(); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 264 | ASSERT_EQ(10, task_count); |
| 265 | EXPECT_EQ(1, injector()->processed_events()); |
| 266 | } |
| 267 | |
| 268 | TEST_F(MessagePumpGLibTest, TestEventsWhileWaitingForWork) { |
| 269 | // Tests that we process events while waiting for work. |
| 270 | // The event queue is empty at first. |
| 271 | for (int i = 0; i < 10; ++i) { |
dcheng@chromium.org | 7029710 | 2011-12-10 08:06:02 +0900 | [diff] [blame] | 272 | injector()->AddDummyEvent(0); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 273 | } |
| 274 | // After all the events have been processed, post a task that will check that |
| 275 | // the events have been processed (note: the task executes after the event |
| 276 | // that posted it has been handled, so we expect 11 at that point). |
tzik | c372ed8 | 2017-04-18 16:01:15 +0900 | [diff] [blame] | 277 | OnceClosure check_task = |
| 278 | BindOnce(&ExpectProcessedEvents, Unretained(injector()), 11); |
| 279 | OnceClosure posted_task = |
| 280 | BindOnce(&PostMessageLoopTask, FROM_HERE, std::move(check_task)); |
| 281 | injector()->AddEventAsTask(10, std::move(posted_task)); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 282 | |
| 283 | // And then quit (relies on the condition tested by TestEventTaskInterleave). |
thakis@chromium.org | fc6f929 | 2013-02-05 08:40:00 +0900 | [diff] [blame] | 284 | injector()->AddEvent(10, MessageLoop::QuitWhenIdleClosure()); |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 285 | RunLoop().Run(); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 286 | |
| 287 | EXPECT_EQ(12, injector()->processed_events()); |
| 288 | } |
| 289 | |
| 290 | namespace { |
| 291 | |
| 292 | // This class is a helper for the concurrent events / posted tasks test below. |
| 293 | // It will quit the main loop once enough tasks and events have been processed, |
| 294 | // while making sure there is always work to do and events in the queue. |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 295 | class ConcurrentHelper : public RefCounted<ConcurrentHelper> { |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 296 | public: |
erg@google.com | bf6ce9f | 2010-01-27 08:08:02 +0900 | [diff] [blame] | 297 | explicit ConcurrentHelper(EventInjector* injector) |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 298 | : injector_(injector), |
| 299 | event_count_(kStartingEventCount), |
| 300 | task_count_(kStartingTaskCount) { |
| 301 | } |
| 302 | |
| 303 | void FromTask() { |
| 304 | if (task_count_ > 0) { |
| 305 | --task_count_; |
| 306 | } |
| 307 | if (task_count_ == 0 && event_count_ == 0) { |
Gabriel Charette | 274bec8 | 2017-07-26 21:36:23 +0900 | [diff] [blame] | 308 | RunLoop::QuitCurrentWhenIdleDeprecated(); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 309 | } else { |
fdoray | 96ab655 | 2016-07-19 08:47:16 +0900 | [diff] [blame] | 310 | ThreadTaskRunnerHandle::Get()->PostTask( |
tzik | 6bdbeb2 | 2017-04-12 00:00:44 +0900 | [diff] [blame] | 311 | FROM_HERE, BindOnce(&ConcurrentHelper::FromTask, this)); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 312 | } |
| 313 | } |
| 314 | |
| 315 | void FromEvent() { |
| 316 | if (event_count_ > 0) { |
| 317 | --event_count_; |
| 318 | } |
| 319 | if (task_count_ == 0 && event_count_ == 0) { |
Gabriel Charette | 274bec8 | 2017-07-26 21:36:23 +0900 | [diff] [blame] | 320 | RunLoop::QuitCurrentWhenIdleDeprecated(); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 321 | } else { |
tzik | c372ed8 | 2017-04-18 16:01:15 +0900 | [diff] [blame] | 322 | injector_->AddEventAsTask(0, |
| 323 | BindOnce(&ConcurrentHelper::FromEvent, this)); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 324 | } |
| 325 | } |
| 326 | |
| 327 | int event_count() const { return event_count_; } |
| 328 | int task_count() const { return task_count_; } |
| 329 | |
| 330 | private: |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 331 | friend class RefCounted<ConcurrentHelper>; |
jam@chromium.org | b1f47b2 | 2009-11-06 06:53:08 +0900 | [diff] [blame] | 332 | |
| 333 | ~ConcurrentHelper() {} |
| 334 | |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 335 | static const int kStartingEventCount = 20; |
| 336 | static const int kStartingTaskCount = 20; |
| 337 | |
| 338 | EventInjector* injector_; |
| 339 | int event_count_; |
| 340 | int task_count_; |
| 341 | }; |
| 342 | |
| 343 | } // namespace |
| 344 | |
| 345 | TEST_F(MessagePumpGLibTest, TestConcurrentEventPostedTask) { |
| 346 | // Tests that posted tasks don't starve events, nor the opposite. |
| 347 | // We use the helper class above. We keep both event and posted task queues |
| 348 | // full, the helper verifies that both tasks and events get processed. |
| 349 | // If that is not the case, either event_count_ or task_count_ will not get |
tfarina@chromium.org | 3b5d147 | 2013-01-10 23:56:17 +0900 | [diff] [blame] | 350 | // to 0, and MessageLoop::QuitWhenIdle() will never be called. |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 351 | scoped_refptr<ConcurrentHelper> helper = new ConcurrentHelper(injector()); |
| 352 | |
| 353 | // Add 2 events to the queue to make sure it is always full (when we remove |
| 354 | // the event before processing it). |
tzik | c372ed8 | 2017-04-18 16:01:15 +0900 | [diff] [blame] | 355 | injector()->AddEventAsTask(0, BindOnce(&ConcurrentHelper::FromEvent, helper)); |
| 356 | injector()->AddEventAsTask(0, BindOnce(&ConcurrentHelper::FromEvent, helper)); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 357 | |
| 358 | // Similarly post 2 tasks. |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 359 | loop()->task_runner()->PostTask( |
tzik | 6bdbeb2 | 2017-04-12 00:00:44 +0900 | [diff] [blame] | 360 | FROM_HERE, BindOnce(&ConcurrentHelper::FromTask, helper)); |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 361 | loop()->task_runner()->PostTask( |
tzik | 6bdbeb2 | 2017-04-12 00:00:44 +0900 | [diff] [blame] | 362 | FROM_HERE, BindOnce(&ConcurrentHelper::FromTask, helper)); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 363 | |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 364 | RunLoop().Run(); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 365 | EXPECT_EQ(0, helper->event_count()); |
| 366 | EXPECT_EQ(0, helper->task_count()); |
| 367 | } |
| 368 | |
| 369 | namespace { |
| 370 | |
| 371 | void AddEventsAndDrainGLib(EventInjector* injector) { |
| 372 | // Add a couple of dummy events |
dcheng@chromium.org | 7029710 | 2011-12-10 08:06:02 +0900 | [diff] [blame] | 373 | injector->AddDummyEvent(0); |
| 374 | injector->AddDummyEvent(0); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 375 | // Then add an event that will quit the main loop. |
thakis@chromium.org | fc6f929 | 2013-02-05 08:40:00 +0900 | [diff] [blame] | 376 | injector->AddEvent(0, MessageLoop::QuitWhenIdleClosure()); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 377 | |
| 378 | // Post a couple of dummy tasks |
Peter Kasting | 24efe5e | 2018-02-24 09:03:01 +0900 | [diff] [blame^] | 379 | ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, DoNothing()); |
| 380 | ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, DoNothing()); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 381 | |
| 382 | // Drain the events |
Ivan Kotenkov | e88f346 | 2017-11-08 21:37:33 +0900 | [diff] [blame] | 383 | while (g_main_context_pending(nullptr)) { |
| 384 | g_main_context_iteration(nullptr, FALSE); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 385 | } |
| 386 | } |
| 387 | |
| 388 | } // namespace |
| 389 | |
| 390 | TEST_F(MessagePumpGLibTest, TestDrainingGLib) { |
| 391 | // Tests that draining events using GLib works. |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 392 | loop()->task_runner()->PostTask( |
tzik | 6bdbeb2 | 2017-04-12 00:00:44 +0900 | [diff] [blame] | 393 | FROM_HERE, BindOnce(&AddEventsAndDrainGLib, Unretained(injector()))); |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 394 | RunLoop().Run(); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 395 | |
| 396 | EXPECT_EQ(3, injector()->processed_events()); |
| 397 | } |
| 398 | |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 399 | namespace { |
| 400 | |
| 401 | // Helper class that lets us run the GLib message loop. |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 402 | class GLibLoopRunner : public RefCounted<GLibLoopRunner> { |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 403 | public: |
| 404 | GLibLoopRunner() : quit_(false) { } |
| 405 | |
| 406 | void RunGLib() { |
| 407 | while (!quit_) { |
Ivan Kotenkov | e88f346 | 2017-11-08 21:37:33 +0900 | [diff] [blame] | 408 | g_main_context_iteration(nullptr, TRUE); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 409 | } |
| 410 | } |
| 411 | |
sadrul@chromium.org | 847a572 | 2011-09-21 09:17:19 +0900 | [diff] [blame] | 412 | void RunLoop() { |
sadrul@chromium.org | 847a572 | 2011-09-21 09:17:19 +0900 | [diff] [blame] | 413 | while (!quit_) { |
Ivan Kotenkov | e88f346 | 2017-11-08 21:37:33 +0900 | [diff] [blame] | 414 | g_main_context_iteration(nullptr, TRUE); |
sadrul@chromium.org | 847a572 | 2011-09-21 09:17:19 +0900 | [diff] [blame] | 415 | } |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 416 | } |
| 417 | |
| 418 | void Quit() { |
| 419 | quit_ = true; |
| 420 | } |
| 421 | |
| 422 | void Reset() { |
| 423 | quit_ = false; |
| 424 | } |
| 425 | |
| 426 | private: |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 427 | friend class RefCounted<GLibLoopRunner>; |
jam@chromium.org | b1f47b2 | 2009-11-06 06:53:08 +0900 | [diff] [blame] | 428 | |
| 429 | ~GLibLoopRunner() {} |
| 430 | |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 431 | bool quit_; |
| 432 | }; |
| 433 | |
| 434 | void TestGLibLoopInternal(EventInjector* injector) { |
| 435 | // Allow tasks to be processed from 'native' event loops. |
| 436 | MessageLoop::current()->SetNestableTasksAllowed(true); |
| 437 | scoped_refptr<GLibLoopRunner> runner = new GLibLoopRunner(); |
| 438 | |
| 439 | int task_count = 0; |
| 440 | // Add a couple of dummy events |
dcheng@chromium.org | 7029710 | 2011-12-10 08:06:02 +0900 | [diff] [blame] | 441 | injector->AddDummyEvent(0); |
| 442 | injector->AddDummyEvent(0); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 443 | // Post a couple of dummy tasks |
fdoray | 96ab655 | 2016-07-19 08:47:16 +0900 | [diff] [blame] | 444 | ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
tzik | 6bdbeb2 | 2017-04-12 00:00:44 +0900 | [diff] [blame] | 445 | BindOnce(&IncrementInt, &task_count)); |
fdoray | 96ab655 | 2016-07-19 08:47:16 +0900 | [diff] [blame] | 446 | ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
tzik | 6bdbeb2 | 2017-04-12 00:00:44 +0900 | [diff] [blame] | 447 | BindOnce(&IncrementInt, &task_count)); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 448 | // Delayed events |
dcheng@chromium.org | 7029710 | 2011-12-10 08:06:02 +0900 | [diff] [blame] | 449 | injector->AddDummyEvent(10); |
| 450 | injector->AddDummyEvent(10); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 451 | // Delayed work |
fdoray | 96ab655 | 2016-07-19 08:47:16 +0900 | [diff] [blame] | 452 | ThreadTaskRunnerHandle::Get()->PostDelayedTask( |
tzik | 6bdbeb2 | 2017-04-12 00:00:44 +0900 | [diff] [blame] | 453 | FROM_HERE, BindOnce(&IncrementInt, &task_count), |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 454 | TimeDelta::FromMilliseconds(30)); |
fdoray | 96ab655 | 2016-07-19 08:47:16 +0900 | [diff] [blame] | 455 | ThreadTaskRunnerHandle::Get()->PostDelayedTask( |
tzik | 6bdbeb2 | 2017-04-12 00:00:44 +0900 | [diff] [blame] | 456 | FROM_HERE, BindOnce(&GLibLoopRunner::Quit, runner), |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 457 | TimeDelta::FromMilliseconds(40)); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 458 | |
| 459 | // Run a nested, straight GLib message loop. |
| 460 | runner->RunGLib(); |
| 461 | |
| 462 | ASSERT_EQ(3, task_count); |
| 463 | EXPECT_EQ(4, injector->processed_events()); |
Gabriel Charette | 274bec8 | 2017-07-26 21:36:23 +0900 | [diff] [blame] | 464 | RunLoop::QuitCurrentWhenIdleDeprecated(); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 465 | } |
| 466 | |
| 467 | void TestGtkLoopInternal(EventInjector* injector) { |
| 468 | // Allow tasks to be processed from 'native' event loops. |
| 469 | MessageLoop::current()->SetNestableTasksAllowed(true); |
| 470 | scoped_refptr<GLibLoopRunner> runner = new GLibLoopRunner(); |
| 471 | |
| 472 | int task_count = 0; |
| 473 | // Add a couple of dummy events |
dcheng@chromium.org | 7029710 | 2011-12-10 08:06:02 +0900 | [diff] [blame] | 474 | injector->AddDummyEvent(0); |
| 475 | injector->AddDummyEvent(0); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 476 | // Post a couple of dummy tasks |
fdoray | 96ab655 | 2016-07-19 08:47:16 +0900 | [diff] [blame] | 477 | ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
tzik | 6bdbeb2 | 2017-04-12 00:00:44 +0900 | [diff] [blame] | 478 | BindOnce(&IncrementInt, &task_count)); |
fdoray | 96ab655 | 2016-07-19 08:47:16 +0900 | [diff] [blame] | 479 | ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, |
tzik | 6bdbeb2 | 2017-04-12 00:00:44 +0900 | [diff] [blame] | 480 | BindOnce(&IncrementInt, &task_count)); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 481 | // Delayed events |
dcheng@chromium.org | 7029710 | 2011-12-10 08:06:02 +0900 | [diff] [blame] | 482 | injector->AddDummyEvent(10); |
| 483 | injector->AddDummyEvent(10); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 484 | // Delayed work |
fdoray | 96ab655 | 2016-07-19 08:47:16 +0900 | [diff] [blame] | 485 | ThreadTaskRunnerHandle::Get()->PostDelayedTask( |
tzik | 6bdbeb2 | 2017-04-12 00:00:44 +0900 | [diff] [blame] | 486 | FROM_HERE, BindOnce(&IncrementInt, &task_count), |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 487 | TimeDelta::FromMilliseconds(30)); |
fdoray | 96ab655 | 2016-07-19 08:47:16 +0900 | [diff] [blame] | 488 | ThreadTaskRunnerHandle::Get()->PostDelayedTask( |
tzik | 6bdbeb2 | 2017-04-12 00:00:44 +0900 | [diff] [blame] | 489 | FROM_HERE, BindOnce(&GLibLoopRunner::Quit, runner), |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 490 | TimeDelta::FromMilliseconds(40)); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 491 | |
| 492 | // Run a nested, straight Gtk message loop. |
sadrul@chromium.org | 847a572 | 2011-09-21 09:17:19 +0900 | [diff] [blame] | 493 | runner->RunLoop(); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 494 | |
| 495 | ASSERT_EQ(3, task_count); |
| 496 | EXPECT_EQ(4, injector->processed_events()); |
Gabriel Charette | 274bec8 | 2017-07-26 21:36:23 +0900 | [diff] [blame] | 497 | RunLoop::QuitCurrentWhenIdleDeprecated(); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 498 | } |
| 499 | |
| 500 | } // namespace |
| 501 | |
| 502 | TEST_F(MessagePumpGLibTest, TestGLibLoop) { |
jhawkins@chromium.org | 598ca1c | 2012-01-01 11:14:47 +0900 | [diff] [blame] | 503 | // Tests that events and posted tasks are correctly executed if the message |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 504 | // loop is not run by MessageLoop::Run() but by a straight GLib loop. |
| 505 | // Note that in this case we don't make strong guarantees about niceness |
| 506 | // between events and posted tasks. |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 507 | loop()->task_runner()->PostTask( |
tzik | 6bdbeb2 | 2017-04-12 00:00:44 +0900 | [diff] [blame] | 508 | FROM_HERE, BindOnce(&TestGLibLoopInternal, Unretained(injector()))); |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 509 | RunLoop().Run(); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 510 | } |
| 511 | |
| 512 | TEST_F(MessagePumpGLibTest, TestGtkLoop) { |
jhawkins@chromium.org | 598ca1c | 2012-01-01 11:14:47 +0900 | [diff] [blame] | 513 | // Tests that events and posted tasks are correctly executed if the message |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 514 | // loop is not run by MessageLoop::Run() but by a straight Gtk loop. |
| 515 | // Note that in this case we don't make strong guarantees about niceness |
| 516 | // between events and posted tasks. |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 517 | loop()->task_runner()->PostTask( |
tzik | 6bdbeb2 | 2017-04-12 00:00:44 +0900 | [diff] [blame] | 518 | FROM_HERE, BindOnce(&TestGtkLoopInternal, Unretained(injector()))); |
fdoray | 851719c | 2016-08-26 00:36:37 +0900 | [diff] [blame] | 519 | RunLoop().Run(); |
deanm@chromium.org | bec47f4 | 2009-06-15 19:30:44 +0900 | [diff] [blame] | 520 | } |
tfarina@chromium.org | 7d4a0ec | 2013-02-07 01:56:19 +0900 | [diff] [blame] | 521 | |
| 522 | } // namespace base |