blob: 077d097ba9a2a35c6ec51d017f588b9f195e48c0 (
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
|
// 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.
#ifndef BASE_RUN_LOOP_H_
#define BASE_RUN_LOOP_H_
#include "base/base_export.h"
#include "base/callback.h"
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "base/message_loop/message_loop.h"
#include "base/threading/thread_checker.h"
#include "build/build_config.h"
namespace base {
#if defined(OS_ANDROID)
class MessagePumpForUI;
#endif
#if defined(OS_IOS)
class MessagePumpUIApplication;
#endif
// Helper class to Run a nested MessageLoop. Please do not use nested
// MessageLoops in production code! If you must, use this class instead of
// calling MessageLoop::Run/Quit directly. RunLoop::Run can only be called once
// per RunLoop lifetime. Create a RunLoop on the stack and call Run/Quit to run
// a nested MessageLoop.
class BASE_EXPORT RunLoop {
public:
RunLoop();
~RunLoop();
// Run the current MessageLoop. This blocks until Quit is called. Before
// calling Run, be sure to grab the QuitClosure in order to stop the
// MessageLoop asynchronously. MessageLoop::QuitWhenIdle and QuitNow will also
// trigger a return from Run, but those are deprecated.
void Run();
// Run the current MessageLoop until it doesn't find any tasks or messages in
// the queue (it goes idle). WARNING: This may never return! Only use this
// when repeating tasks such as animated web pages have been shut down.
void RunUntilIdle();
bool running() const { return running_; }
// Quit() quits an earlier call to Run() immediately. QuitWhenIdle() quits an
// earlier call to Run() when there aren't any tasks or messages in the queue.
//
// There can be other nested RunLoops servicing the same task queue
// (MessageLoop); Quitting one RunLoop has no bearing on the others. Quit()
// and QuitWhenIdle() can be called before, during or after Run(). If called
// before Run(), Run() will return immediately when called. Calling Quit() or
// QuitWhenIdle() after the RunLoop has already finished running has no
// effect.
//
// WARNING: You must NEVER assume that a call to Quit() or QuitWhenIdle() will
// terminate the targetted message loop. If a nested message loop continues
// running, the target may NEVER terminate. It is very easy to livelock (run
// forever) in such a case.
void Quit();
void QuitWhenIdle();
// Convenience methods to get a closure that safely calls Quit() or
// QuitWhenIdle() (has no effect if the RunLoop instance is gone).
//
// Example:
// RunLoop run_loop;
// PostTask(run_loop.QuitClosure());
// run_loop.Run();
base::Closure QuitClosure();
base::Closure QuitWhenIdleClosure();
private:
friend class MessageLoop;
#if defined(OS_ANDROID)
// Android doesn't support the blocking MessageLoop::Run, so it calls
// BeforeRun and AfterRun directly.
friend class base::MessagePumpForUI;
#endif
#if defined(OS_IOS)
// iOS doesn't support the blocking MessageLoop::Run, so it calls
// BeforeRun directly.
friend class base::MessagePumpUIApplication;
#endif
// Return false to abort the Run.
bool BeforeRun();
void AfterRun();
MessageLoop* loop_;
// Parent RunLoop or NULL if this is the top-most RunLoop.
RunLoop* previous_run_loop_;
// Used to count how many nested Run() invocations are on the stack.
int run_depth_;
bool run_called_;
bool quit_called_;
bool running_;
// Used to record that QuitWhenIdle() was called on the MessageLoop, meaning
// that we should quit Run once it becomes idle.
bool quit_when_idle_received_;
base::ThreadChecker thread_checker_;
// WeakPtrFactory for QuitClosure safety.
base::WeakPtrFactory<RunLoop> weak_factory_;
DISALLOW_COPY_AND_ASSIGN(RunLoop);
};
} // namespace base
#endif // BASE_RUN_LOOP_H_
|
