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