brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 1 | // Copyright 2013 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 | #ifndef BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_ |
| 6 | #define BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_ |
| 7 | |
| 8 | #include <queue> |
| 9 | #include <string> |
| 10 | |
| 11 | #include "base/base_export.h" |
| 12 | #include "base/basictypes.h" |
| 13 | #include "base/callback_forward.h" |
skyostil@chromium.org | 2ca1bf3 | 2014-08-14 23:26:09 +0900 | [diff] [blame] | 14 | #include "base/debug/task_annotator.h" |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 15 | #include "base/location.h" |
| 16 | #include "base/memory/ref_counted.h" |
alexeypa@chromium.org | 4018323 | 2013-07-23 07:24:13 +0900 | [diff] [blame] | 17 | #include "base/memory/scoped_ptr.h" |
| 18 | #include "base/message_loop/incoming_task_queue.h" |
skyostil | 9368ac0 | 2015-06-20 02:22:54 +0900 | [diff] [blame] | 19 | #include "base/message_loop/message_loop_task_runner.h" |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 20 | #include "base/message_loop/message_pump.h" |
jeremy@chromium.org | 4d5a6b2 | 2014-06-06 04:36:20 +0900 | [diff] [blame] | 21 | #include "base/message_loop/timer_slack.h" |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 22 | #include "base/observer_list.h" |
| 23 | #include "base/pending_task.h" |
| 24 | #include "base/sequenced_task_runner_helpers.h" |
| 25 | #include "base/synchronization/lock.h" |
avi@chromium.org | b039e8b | 2013-06-28 09:49:07 +0900 | [diff] [blame] | 26 | #include "base/time/time.h" |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 27 | #include "base/tracking_info.h" |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 28 | |
sky@chromium.org | 66a00b3 | 2014-01-17 09:10:29 +0900 | [diff] [blame] | 29 | // TODO(sky): these includes should not be necessary. Nuke them. |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 30 | #if defined(OS_WIN) |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 31 | #include "base/message_loop/message_pump_win.h" |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 32 | #elif defined(OS_IOS) |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 33 | #include "base/message_loop/message_pump_io_ios.h" |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 34 | #elif defined(OS_POSIX) |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 35 | #include "base/message_loop/message_pump_libevent.h" |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 36 | #endif |
| 37 | |
| 38 | namespace base { |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 39 | |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 40 | class HistogramBase; |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 41 | class RunLoop; |
| 42 | class ThreadTaskRunnerHandle; |
alexeypa@chromium.org | 4018323 | 2013-07-23 07:24:13 +0900 | [diff] [blame] | 43 | class WaitableEvent; |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 44 | |
| 45 | // A MessageLoop is used to process events for a particular thread. There is |
| 46 | // at most one MessageLoop instance per thread. |
| 47 | // |
| 48 | // Events include at a minimum Task instances submitted to PostTask and its |
| 49 | // variants. Depending on the type of message pump used by the MessageLoop |
| 50 | // other events such as UI messages may be processed. On Windows APC calls (as |
| 51 | // time permits) and signals sent to a registered set of HANDLEs may also be |
| 52 | // processed. |
| 53 | // |
| 54 | // NOTE: Unless otherwise specified, a MessageLoop's methods may only be called |
| 55 | // on the thread where the MessageLoop's Run method executes. |
| 56 | // |
| 57 | // NOTE: MessageLoop has task reentrancy protection. This means that if a |
| 58 | // task is being processed, a second task cannot start until the first task is |
| 59 | // finished. Reentrancy can happen when processing a task, and an inner |
| 60 | // message pump is created. That inner pump then processes native messages |
| 61 | // which could implicitly start an inner task. Inner message pumps are created |
| 62 | // with dialogs (DialogBox), common dialogs (GetOpenFileName), OLE functions |
| 63 | // (DoDragDrop), printer functions (StartDoc) and *many* others. |
| 64 | // |
| 65 | // Sample workaround when inner task processing is needed: |
| 66 | // HRESULT hr; |
| 67 | // { |
| 68 | // MessageLoop::ScopedNestableTaskAllower allow(MessageLoop::current()); |
| 69 | // hr = DoDragDrop(...); // Implicitly runs a modal message loop. |
| 70 | // } |
| 71 | // // Process |hr| (the result returned by DoDragDrop()). |
| 72 | // |
| 73 | // Please be SURE your task is reentrant (nestable) and all global variables |
| 74 | // are stable and accessible before calling SetNestableTasksAllowed(true). |
| 75 | // |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 76 | class BASE_EXPORT MessageLoop : public MessagePump::Delegate { |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 77 | public: |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 78 | // A MessageLoop has a particular type, which indicates the set of |
| 79 | // asynchronous events it may process in addition to tasks and timers. |
| 80 | // |
| 81 | // TYPE_DEFAULT |
| 82 | // This type of ML only supports tasks and timers. |
| 83 | // |
| 84 | // TYPE_UI |
| 85 | // This type of ML also supports native UI events (e.g., Windows messages). |
| 86 | // See also MessageLoopForUI. |
| 87 | // |
| 88 | // TYPE_IO |
| 89 | // This type of ML also supports asynchronous IO. See also |
| 90 | // MessageLoopForIO. |
| 91 | // |
kristianm@chromium.org | a78bfa9 | 2013-08-08 10:31:52 +0900 | [diff] [blame] | 92 | // TYPE_JAVA |
| 93 | // This type of ML is backed by a Java message handler which is responsible |
| 94 | // for running the tasks added to the ML. This is only for use on Android. |
| 95 | // TYPE_JAVA behaves in essence like TYPE_UI, except during construction |
| 96 | // where it does not use the main thread specific pump factory. |
| 97 | // |
sky@chromium.org | ab45280 | 2013-11-08 15:16:53 +0900 | [diff] [blame] | 98 | // TYPE_CUSTOM |
| 99 | // MessagePump was supplied to constructor. |
| 100 | // |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 101 | enum Type { |
| 102 | TYPE_DEFAULT, |
| 103 | TYPE_UI, |
sky@chromium.org | ab45280 | 2013-11-08 15:16:53 +0900 | [diff] [blame] | 104 | TYPE_CUSTOM, |
kristianm@chromium.org | a78bfa9 | 2013-08-08 10:31:52 +0900 | [diff] [blame] | 105 | TYPE_IO, |
| 106 | #if defined(OS_ANDROID) |
| 107 | TYPE_JAVA, |
thestig | fa24e5b | 2015-01-22 16:09:45 +0900 | [diff] [blame] | 108 | #endif // defined(OS_ANDROID) |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 109 | }; |
| 110 | |
| 111 | // Normally, it is not necessary to instantiate a MessageLoop. Instead, it |
| 112 | // is typical to make use of the current thread's MessageLoop instance. |
| 113 | explicit MessageLoop(Type type = TYPE_DEFAULT); |
sky@chromium.org | ab45280 | 2013-11-08 15:16:53 +0900 | [diff] [blame] | 114 | // Creates a TYPE_CUSTOM MessageLoop with the supplied MessagePump, which must |
| 115 | // be non-NULL. |
kinuko | f25405c | 2015-05-23 20:38:37 +0900 | [diff] [blame] | 116 | explicit MessageLoop(scoped_ptr<MessagePump> pump); |
| 117 | |
dcheng | 7dc8df5 | 2014-10-21 19:54:51 +0900 | [diff] [blame] | 118 | ~MessageLoop() override; |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 119 | |
| 120 | // Returns the MessageLoop object for the current thread, or null if none. |
| 121 | static MessageLoop* current(); |
| 122 | |
| 123 | static void EnableHistogrammer(bool enable_histogrammer); |
| 124 | |
suyash.s@samsung.com | b5f1fc9 | 2014-03-08 02:03:54 +0900 | [diff] [blame] | 125 | typedef scoped_ptr<MessagePump> (MessagePumpFactory)(); |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 126 | // Uses the given base::MessagePumpForUIFactory to override the default |
| 127 | // MessagePump implementation for 'TYPE_UI'. Returns true if the factory |
| 128 | // was successfully registered. |
| 129 | static bool InitMessagePumpForUIFactory(MessagePumpFactory* factory); |
| 130 | |
sky@chromium.org | 4f42682 | 2013-11-13 01:35:02 +0900 | [diff] [blame] | 131 | // Creates the default MessagePump based on |type|. Caller owns return |
| 132 | // value. |
suyash.s@samsung.com | b5f1fc9 | 2014-03-08 02:03:54 +0900 | [diff] [blame] | 133 | static scoped_ptr<MessagePump> CreateMessagePumpForType(Type type); |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 134 | // A DestructionObserver is notified when the current MessageLoop is being |
| 135 | // destroyed. These observers are notified prior to MessageLoop::current() |
| 136 | // being changed to return NULL. This gives interested parties the chance to |
| 137 | // do final cleanup that depends on the MessageLoop. |
| 138 | // |
| 139 | // NOTE: Any tasks posted to the MessageLoop during this notification will |
| 140 | // not be run. Instead, they will be deleted. |
| 141 | // |
| 142 | class BASE_EXPORT DestructionObserver { |
| 143 | public: |
| 144 | virtual void WillDestroyCurrentMessageLoop() = 0; |
| 145 | |
| 146 | protected: |
| 147 | virtual ~DestructionObserver(); |
| 148 | }; |
| 149 | |
| 150 | // Add a DestructionObserver, which will start receiving notifications |
| 151 | // immediately. |
| 152 | void AddDestructionObserver(DestructionObserver* destruction_observer); |
| 153 | |
| 154 | // Remove a DestructionObserver. It is safe to call this method while a |
| 155 | // DestructionObserver is receiving a notification callback. |
| 156 | void RemoveDestructionObserver(DestructionObserver* destruction_observer); |
| 157 | |
skyostil | dd4cb91 | 2015-03-21 09:56:51 +0900 | [diff] [blame] | 158 | // NOTE: Deprecated; prefer task_runner() and the TaskRunner interfaces. |
| 159 | // TODO(skyostil): Remove these functions (crbug.com/465354). |
| 160 | // |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 161 | // The "PostTask" family of methods call the task's Run method asynchronously |
| 162 | // from within a message loop at some point in the future. |
| 163 | // |
| 164 | // With the PostTask variant, tasks are invoked in FIFO order, inter-mixed |
| 165 | // with normal UI or IO event processing. With the PostDelayedTask variant, |
| 166 | // tasks are called after at least approximately 'delay_ms' have elapsed. |
| 167 | // |
| 168 | // The NonNestable variants work similarly except that they promise never to |
| 169 | // dispatch the task from a nested invocation of MessageLoop::Run. Instead, |
| 170 | // such tasks get deferred until the top-most MessageLoop::Run is executing. |
| 171 | // |
| 172 | // The MessageLoop takes ownership of the Task, and deletes it after it has |
| 173 | // been Run(). |
| 174 | // |
| 175 | // PostTask(from_here, task) is equivalent to |
| 176 | // PostDelayedTask(from_here, task, 0). |
| 177 | // |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 178 | // NOTE: These methods may be called on any thread. The Task will be invoked |
| 179 | // on the thread that executes MessageLoop::Run(). |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 180 | void PostTask(const tracked_objects::Location& from_here, |
| 181 | const Closure& task); |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 182 | |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 183 | void PostDelayedTask(const tracked_objects::Location& from_here, |
| 184 | const Closure& task, |
| 185 | TimeDelta delay); |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 186 | |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 187 | void PostNonNestableTask(const tracked_objects::Location& from_here, |
| 188 | const Closure& task); |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 189 | |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 190 | void PostNonNestableDelayedTask(const tracked_objects::Location& from_here, |
| 191 | const Closure& task, |
| 192 | TimeDelta delay); |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 193 | |
| 194 | // A variant on PostTask that deletes the given object. This is useful |
| 195 | // if the object needs to live until the next run of the MessageLoop (for |
| 196 | // example, deleting a RenderProcessHost from within an IPC callback is not |
| 197 | // good). |
| 198 | // |
| 199 | // NOTE: This method may be called on any thread. The object will be deleted |
maniscalco | cba1be9 | 2014-10-03 03:35:33 +0900 | [diff] [blame] | 200 | // on the thread that executes MessageLoop::Run(). |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 201 | template <class T> |
| 202 | void DeleteSoon(const tracked_objects::Location& from_here, const T* object) { |
| 203 | base::subtle::DeleteHelperInternal<T, void>::DeleteViaSequencedTaskRunner( |
| 204 | this, from_here, object); |
| 205 | } |
| 206 | |
| 207 | // A variant on PostTask that releases the given reference counted object |
| 208 | // (by calling its Release method). This is useful if the object needs to |
| 209 | // live until the next run of the MessageLoop, or if the object needs to be |
| 210 | // released on a particular thread. |
| 211 | // |
maniscalco@chromium.org | 26ea8ac | 2014-05-28 07:37:50 +0900 | [diff] [blame] | 212 | // A common pattern is to manually increment the object's reference count |
vkuzkokov@chromium.org | 49e37bd | 2014-05-31 03:07:17 +0900 | [diff] [blame] | 213 | // (AddRef), clear the pointer, then issue a ReleaseSoon. The reference count |
maniscalco@chromium.org | 26ea8ac | 2014-05-28 07:37:50 +0900 | [diff] [blame] | 214 | // is incremented manually to ensure clearing the pointer does not trigger a |
| 215 | // delete and to account for the upcoming decrement (ReleaseSoon). For |
| 216 | // example: |
| 217 | // |
| 218 | // scoped_refptr<Foo> foo = ... |
vkuzkokov@chromium.org | 49e37bd | 2014-05-31 03:07:17 +0900 | [diff] [blame] | 219 | // foo->AddRef(); |
| 220 | // Foo* raw_foo = foo.get(); |
maniscalco@chromium.org | 26ea8ac | 2014-05-28 07:37:50 +0900 | [diff] [blame] | 221 | // foo = NULL; |
vkuzkokov@chromium.org | 49e37bd | 2014-05-31 03:07:17 +0900 | [diff] [blame] | 222 | // message_loop->ReleaseSoon(raw_foo); |
maniscalco@chromium.org | 26ea8ac | 2014-05-28 07:37:50 +0900 | [diff] [blame] | 223 | // |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 224 | // NOTE: This method may be called on any thread. The object will be |
| 225 | // released (and thus possibly deleted) on the thread that executes |
| 226 | // MessageLoop::Run(). If this is not the same as the thread that calls |
maniscalco | cba1be9 | 2014-10-03 03:35:33 +0900 | [diff] [blame] | 227 | // ReleaseSoon(FROM_HERE, ), then T MUST inherit from |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 228 | // RefCountedThreadSafe<T>! |
| 229 | template <class T> |
| 230 | void ReleaseSoon(const tracked_objects::Location& from_here, |
| 231 | const T* object) { |
| 232 | base::subtle::ReleaseHelperInternal<T, void>::ReleaseViaSequencedTaskRunner( |
| 233 | this, from_here, object); |
| 234 | } |
| 235 | |
| 236 | // Deprecated: use RunLoop instead. |
| 237 | // Run the message loop. |
| 238 | void Run(); |
| 239 | |
| 240 | // Deprecated: use RunLoop instead. |
| 241 | // Process all pending tasks, windows messages, etc., but don't wait/sleep. |
| 242 | // Return as soon as all items that can be run are taken care of. |
| 243 | void RunUntilIdle(); |
| 244 | |
| 245 | // TODO(jbates) remove this. crbug.com/131220. See QuitWhenIdle(). |
| 246 | void Quit() { QuitWhenIdle(); } |
| 247 | |
| 248 | // Deprecated: use RunLoop instead. |
| 249 | // |
| 250 | // Signals the Run method to return when it becomes idle. It will continue to |
| 251 | // process pending messages and future messages as long as they are enqueued. |
| 252 | // Warning: if the MessageLoop remains busy, it may never quit. Only use this |
| 253 | // Quit method when looping procedures (such as web pages) have been shut |
| 254 | // down. |
| 255 | // |
| 256 | // This method may only be called on the same thread that called Run, and Run |
| 257 | // must still be on the call stack. |
| 258 | // |
| 259 | // Use QuitClosure variants if you need to Quit another thread's MessageLoop, |
| 260 | // but note that doing so is fairly dangerous if the target thread makes |
| 261 | // nested calls to MessageLoop::Run. The problem being that you won't know |
| 262 | // which nested run loop you are quitting, so be careful! |
| 263 | void QuitWhenIdle(); |
| 264 | |
| 265 | // Deprecated: use RunLoop instead. |
| 266 | // |
| 267 | // This method is a variant of Quit, that does not wait for pending messages |
| 268 | // to be processed before returning from Run. |
| 269 | void QuitNow(); |
| 270 | |
| 271 | // TODO(jbates) remove this. crbug.com/131220. See QuitWhenIdleClosure(). |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 272 | static Closure QuitClosure() { return QuitWhenIdleClosure(); } |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 273 | |
| 274 | // Deprecated: use RunLoop instead. |
| 275 | // Construct a Closure that will call QuitWhenIdle(). Useful to schedule an |
| 276 | // arbitrary MessageLoop to QuitWhenIdle. |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 277 | static Closure QuitWhenIdleClosure(); |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 278 | |
jeremy@chromium.org | 4d5a6b2 | 2014-06-06 04:36:20 +0900 | [diff] [blame] | 279 | // Set the timer slack for this message loop. |
| 280 | void SetTimerSlack(TimerSlack timer_slack) { |
| 281 | pump_->SetTimerSlack(timer_slack); |
| 282 | } |
| 283 | |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 284 | // Returns true if this loop is |type|. This allows subclasses (especially |
| 285 | // those in tests) to specialize how they are identified. |
| 286 | virtual bool IsType(Type type) const; |
| 287 | |
| 288 | // Returns the type passed to the constructor. |
| 289 | Type type() const { return type_; } |
| 290 | |
| 291 | // Optional call to connect the thread name with this loop. |
| 292 | void set_thread_name(const std::string& thread_name) { |
| 293 | DCHECK(thread_name_.empty()) << "Should not rename this thread!"; |
| 294 | thread_name_ = thread_name; |
| 295 | } |
| 296 | const std::string& thread_name() const { return thread_name_; } |
| 297 | |
rsleevi@chromium.org | c9ff378 | 2014-07-12 10:10:52 +0900 | [diff] [blame] | 298 | // Gets the TaskRunner associated with this message loop. |
skyostil | d1abbc1 | 2015-07-14 06:41:17 +0900 | [diff] [blame] | 299 | const scoped_refptr<SingleThreadTaskRunner>& task_runner() { |
| 300 | return task_runner_; |
| 301 | } |
| 302 | |
| 303 | // Sets a new TaskRunner for this message loop. The message loop must already |
| 304 | // have been bound to a thread prior to this call, and the task runner must |
| 305 | // belong to that thread. Note that changing the task runner will also affect |
| 306 | // the ThreadTaskRunnerHandle for the target thread. Must be called on the |
| 307 | // thread to which the message loop is bound. |
| 308 | void SetTaskRunner(scoped_refptr<SingleThreadTaskRunner> task_runner); |
rsleevi@chromium.org | c9ff378 | 2014-07-12 10:10:52 +0900 | [diff] [blame] | 309 | |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 310 | // Enables or disables the recursive task processing. This happens in the case |
| 311 | // of recursive message loops. Some unwanted message loop may occurs when |
| 312 | // using common controls or printer functions. By default, recursive task |
| 313 | // processing is disabled. |
| 314 | // |
| 315 | // Please utilize |ScopedNestableTaskAllower| instead of calling these methods |
| 316 | // directly. In general nestable message loops are to be avoided. They are |
| 317 | // dangerous and difficult to get right, so please use with extreme caution. |
| 318 | // |
| 319 | // The specific case where tasks get queued is: |
| 320 | // - The thread is running a message loop. |
| 321 | // - It receives a task #1 and execute it. |
| 322 | // - The task #1 implicitly start a message loop, like a MessageBox in the |
| 323 | // unit test. This can also be StartDoc or GetSaveFileName. |
| 324 | // - The thread receives a task #2 before or while in this second message |
| 325 | // loop. |
| 326 | // - With NestableTasksAllowed set to true, the task #2 will run right away. |
| 327 | // Otherwise, it will get executed right after task #1 completes at "thread |
| 328 | // message loop level". |
| 329 | void SetNestableTasksAllowed(bool allowed); |
| 330 | bool NestableTasksAllowed() const; |
| 331 | |
| 332 | // Enables nestable tasks on |loop| while in scope. |
| 333 | class ScopedNestableTaskAllower { |
| 334 | public: |
| 335 | explicit ScopedNestableTaskAllower(MessageLoop* loop) |
| 336 | : loop_(loop), |
| 337 | old_state_(loop_->NestableTasksAllowed()) { |
| 338 | loop_->SetNestableTasksAllowed(true); |
| 339 | } |
| 340 | ~ScopedNestableTaskAllower() { |
| 341 | loop_->SetNestableTasksAllowed(old_state_); |
| 342 | } |
| 343 | |
| 344 | private: |
| 345 | MessageLoop* loop_; |
| 346 | bool old_state_; |
| 347 | }; |
| 348 | |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 349 | // Returns true if we are currently running a nested message loop. |
| 350 | bool IsNested(); |
| 351 | |
| 352 | // A TaskObserver is an object that receives task notifications from the |
| 353 | // MessageLoop. |
| 354 | // |
| 355 | // NOTE: A TaskObserver implementation should be extremely fast! |
| 356 | class BASE_EXPORT TaskObserver { |
| 357 | public: |
| 358 | TaskObserver(); |
| 359 | |
| 360 | // This method is called before processing a task. |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 361 | virtual void WillProcessTask(const PendingTask& pending_task) = 0; |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 362 | |
| 363 | // This method is called after processing a task. |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 364 | virtual void DidProcessTask(const PendingTask& pending_task) = 0; |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 365 | |
| 366 | protected: |
| 367 | virtual ~TaskObserver(); |
| 368 | }; |
| 369 | |
| 370 | // These functions can only be called on the same thread that |this| is |
| 371 | // running on. |
| 372 | void AddTaskObserver(TaskObserver* task_observer); |
| 373 | void RemoveTaskObserver(TaskObserver* task_observer); |
| 374 | |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 375 | #if defined(OS_WIN) |
| 376 | void set_os_modal_loop(bool os_modal_loop) { |
| 377 | os_modal_loop_ = os_modal_loop; |
| 378 | } |
| 379 | |
| 380 | bool os_modal_loop() const { |
| 381 | return os_modal_loop_; |
| 382 | } |
| 383 | #endif // OS_WIN |
| 384 | |
| 385 | // Can only be called from the thread that owns the MessageLoop. |
| 386 | bool is_running() const; |
| 387 | |
alexeypa@chromium.org | 4018323 | 2013-07-23 07:24:13 +0900 | [diff] [blame] | 388 | // Returns true if the message loop has high resolution timers enabled. |
| 389 | // Provided for testing. |
cpu | 410a98e | 2014-08-29 08:25:37 +0900 | [diff] [blame] | 390 | bool HasHighResolutionTasks(); |
alexeypa@chromium.org | 4018323 | 2013-07-23 07:24:13 +0900 | [diff] [blame] | 391 | |
| 392 | // Returns true if the message loop is "idle". Provided for testing. |
| 393 | bool IsIdleForTesting(); |
| 394 | |
jamesr | 8d73106 | 2014-09-30 06:12:44 +0900 | [diff] [blame] | 395 | // Returns the TaskAnnotator which is used to add debug information to posted |
| 396 | // tasks. |
| 397 | debug::TaskAnnotator* task_annotator() { return &task_annotator_; } |
| 398 | |
| 399 | // Runs the specified PendingTask. |
| 400 | void RunTask(const PendingTask& pending_task); |
| 401 | |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 402 | //---------------------------------------------------------------------------- |
| 403 | protected: |
alexeypa@chromium.org | 4018323 | 2013-07-23 07:24:13 +0900 | [diff] [blame] | 404 | scoped_ptr<MessagePump> pump_; |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 405 | |
| 406 | private: |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 407 | friend class RunLoop; |
kinuko | f25405c | 2015-05-23 20:38:37 +0900 | [diff] [blame] | 408 | friend class internal::IncomingTaskQueue; |
| 409 | friend class ScheduleWorkTest; |
| 410 | friend class Thread; |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 411 | |
kinuko | f25405c | 2015-05-23 20:38:37 +0900 | [diff] [blame] | 412 | using MessagePumpFactoryCallback = Callback<scoped_ptr<MessagePump>()>; |
| 413 | |
| 414 | // Creates a MessageLoop without binding to a thread. |
| 415 | // If |type| is TYPE_CUSTOM non-null |pump_factory| must be also given |
| 416 | // to create a message pump for this message loop. Otherwise a default |
| 417 | // message pump for the |type| is created. |
| 418 | // |
| 419 | // It is valid to call this to create a new message loop on one thread, |
| 420 | // and then pass it to the thread where the message loop actually runs. |
| 421 | // The message loop's BindToCurrentThread() method must be called on the |
| 422 | // thread the message loop runs on, before calling Run(). |
| 423 | // Before BindToCurrentThread() is called only Post*Task() functions can |
| 424 | // be called on the message loop. |
kinuko | 9adf8ab | 2015-06-30 10:31:54 +0900 | [diff] [blame] | 425 | static scoped_ptr<MessageLoop> CreateUnbound( |
kinuko | f25405c | 2015-05-23 20:38:37 +0900 | [diff] [blame] | 426 | Type type, |
| 427 | MessagePumpFactoryCallback pump_factory); |
| 428 | |
| 429 | // Common private constructor. Other constructors delegate the initialization |
| 430 | // to this constructor. |
| 431 | MessageLoop(Type type, MessagePumpFactoryCallback pump_factory); |
| 432 | |
| 433 | // Configure various members and bind this message loop to the current thread. |
| 434 | void BindToCurrentThread(); |
sky@chromium.org | ab45280 | 2013-11-08 15:16:53 +0900 | [diff] [blame] | 435 | |
skyostil | d1abbc1 | 2015-07-14 06:41:17 +0900 | [diff] [blame] | 436 | // Sets the ThreadTaskRunnerHandle for the current thread to point to the |
| 437 | // task runner for this message loop. |
| 438 | void SetThreadTaskRunnerHandle(); |
| 439 | |
cpu@chromium.org | 33353ba | 2014-01-04 06:25:26 +0900 | [diff] [blame] | 440 | // Invokes the actual run loop using the message pump. |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 441 | void RunHandler(); |
| 442 | |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 443 | // Called to process any delayed non-nestable tasks. |
| 444 | bool ProcessNextDelayedNonNestableTask(); |
| 445 | |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 446 | // Calls RunTask or queues the pending_task on the deferred task list if it |
| 447 | // cannot be run right now. Returns true if the task was run. |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 448 | bool DeferOrRunPendingTask(const PendingTask& pending_task); |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 449 | |
| 450 | // Adds the pending task to delayed_work_queue_. |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 451 | void AddToDelayedWorkQueue(const PendingTask& pending_task); |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 452 | |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 453 | // Delete tasks that haven't run yet without running them. Used in the |
| 454 | // destructor to make sure all the task's destructors get called. Returns |
| 455 | // true if some work was done. |
| 456 | bool DeletePendingTasks(); |
| 457 | |
alexeypa@chromium.org | 4018323 | 2013-07-23 07:24:13 +0900 | [diff] [blame] | 458 | // Loads tasks from the incoming queue to |work_queue_| if the latter is |
| 459 | // empty. |
| 460 | void ReloadWorkQueue(); |
| 461 | |
kinuko | f25405c | 2015-05-23 20:38:37 +0900 | [diff] [blame] | 462 | // Wakes up the message pump. Can be called on any thread. The caller is |
| 463 | // responsible for synchronizing ScheduleWork() calls. |
| 464 | void ScheduleWork(); |
| 465 | |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 466 | // Start recording histogram info about events and action IF it was enabled |
| 467 | // and IF the statistics recorder can accept a registration of our histogram. |
| 468 | void StartHistogrammer(); |
| 469 | |
| 470 | // Add occurrence of event to our histogram, so that we can see what is being |
| 471 | // done in a specific MessageLoop instance (i.e., specific thread). |
| 472 | // If message_histogram_ is NULL, this is a no-op. |
| 473 | void HistogramEvent(int event); |
| 474 | |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 475 | // MessagePump::Delegate methods: |
dcheng | 7dc8df5 | 2014-10-21 19:54:51 +0900 | [diff] [blame] | 476 | bool DoWork() override; |
| 477 | bool DoDelayedWork(TimeTicks* next_delayed_work_time) override; |
| 478 | bool DoIdleWork() override; |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 479 | |
sky@chromium.org | ab45280 | 2013-11-08 15:16:53 +0900 | [diff] [blame] | 480 | const Type type_; |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 481 | |
| 482 | // A list of tasks that need to be processed by this instance. Note that |
| 483 | // this queue is only accessed (push/pop) by our current thread. |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 484 | TaskQueue work_queue_; |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 485 | |
thestig | fa24e5b | 2015-01-22 16:09:45 +0900 | [diff] [blame] | 486 | #if defined(OS_WIN) |
cpu | 410a98e | 2014-08-29 08:25:37 +0900 | [diff] [blame] | 487 | // How many high resolution tasks are in the pending task queue. This value |
| 488 | // increases by N every time we call ReloadWorkQueue() and decreases by 1 |
| 489 | // every time we call RunTask() if the task needs a high resolution timer. |
| 490 | int pending_high_res_tasks_; |
| 491 | // Tracks if we have requested high resolution timers. Its only use is to |
| 492 | // turn off the high resolution timer upon loop destruction. |
| 493 | bool in_high_res_mode_; |
thestig | fa24e5b | 2015-01-22 16:09:45 +0900 | [diff] [blame] | 494 | #endif |
cpu | 410a98e | 2014-08-29 08:25:37 +0900 | [diff] [blame] | 495 | |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 496 | // Contains delayed tasks, sorted by their 'delayed_run_time' property. |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 497 | DelayedTaskQueue delayed_work_queue_; |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 498 | |
| 499 | // A recent snapshot of Time::Now(), used to check delayed_work_queue_. |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 500 | TimeTicks recent_time_; |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 501 | |
| 502 | // A queue of non-nestable tasks that we had to defer because when it came |
| 503 | // time to execute them we were in a nested message loop. They will execute |
| 504 | // once we're out of nested message loops. |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 505 | TaskQueue deferred_non_nestable_work_queue_; |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 506 | |
| 507 | ObserverList<DestructionObserver> destruction_observers_; |
| 508 | |
| 509 | // A recursion block that prevents accidentally running additional tasks when |
| 510 | // insider a (accidentally induced?) nested message pump. |
| 511 | bool nestable_tasks_allowed_; |
| 512 | |
alexeypa@google.com | bb819d6 | 2013-07-23 05:06:56 +0900 | [diff] [blame] | 513 | #if defined(OS_WIN) |
alexeypa@google.com | bb819d6 | 2013-07-23 05:06:56 +0900 | [diff] [blame] | 514 | // Should be set to true before calling Windows APIs like TrackPopupMenu, etc |
| 515 | // which enter a modal message loop. |
| 516 | bool os_modal_loop_; |
| 517 | #endif |
| 518 | |
kinuko | f25405c | 2015-05-23 20:38:37 +0900 | [diff] [blame] | 519 | // pump_factory_.Run() is called to create a message pump for this loop |
| 520 | // if type_ is TYPE_CUSTOM and pump_ is null. |
| 521 | MessagePumpFactoryCallback pump_factory_; |
| 522 | |
alexeypa@chromium.org | 4018323 | 2013-07-23 07:24:13 +0900 | [diff] [blame] | 523 | std::string thread_name_; |
| 524 | // A profiling histogram showing the counts of various messages and events. |
| 525 | HistogramBase* message_histogram_; |
| 526 | |
| 527 | RunLoop* run_loop_; |
alexeypa@google.com | bb819d6 | 2013-07-23 05:06:56 +0900 | [diff] [blame] | 528 | |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 529 | ObserverList<TaskObserver> task_observers_; |
| 530 | |
skyostil@chromium.org | 2ca1bf3 | 2014-08-14 23:26:09 +0900 | [diff] [blame] | 531 | debug::TaskAnnotator task_annotator_; |
| 532 | |
alexeypa@chromium.org | 4018323 | 2013-07-23 07:24:13 +0900 | [diff] [blame] | 533 | scoped_refptr<internal::IncomingTaskQueue> incoming_task_queue_; |
| 534 | |
skyostil | d1abbc1 | 2015-07-14 06:41:17 +0900 | [diff] [blame] | 535 | // A task runner which we haven't bound to a thread yet. |
| 536 | scoped_refptr<internal::MessageLoopTaskRunner> unbound_task_runner_; |
| 537 | |
skyostil | 9368ac0 | 2015-06-20 02:22:54 +0900 | [diff] [blame] | 538 | // The task runner associated with this message loop. |
skyostil | d1abbc1 | 2015-07-14 06:41:17 +0900 | [diff] [blame] | 539 | scoped_refptr<SingleThreadTaskRunner> task_runner_; |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 540 | scoped_ptr<ThreadTaskRunnerHandle> thread_task_runner_handle_; |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 541 | |
| 542 | template <class T, class R> friend class base::subtle::DeleteHelperInternal; |
| 543 | template <class T, class R> friend class base::subtle::ReleaseHelperInternal; |
| 544 | |
| 545 | void DeleteSoonInternal(const tracked_objects::Location& from_here, |
| 546 | void(*deleter)(const void*), |
| 547 | const void* object); |
| 548 | void ReleaseSoonInternal(const tracked_objects::Location& from_here, |
| 549 | void(*releaser)(const void*), |
| 550 | const void* object); |
| 551 | |
| 552 | DISALLOW_COPY_AND_ASSIGN(MessageLoop); |
| 553 | }; |
| 554 | |
sadrul@chromium.org | b169e22 | 2014-04-23 09:55:07 +0900 | [diff] [blame] | 555 | #if !defined(OS_NACL) |
| 556 | |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 557 | //----------------------------------------------------------------------------- |
| 558 | // MessageLoopForUI extends MessageLoop with methods that are particular to a |
| 559 | // MessageLoop instantiated with TYPE_UI. |
| 560 | // |
| 561 | // This class is typically used like so: |
| 562 | // MessageLoopForUI::current()->...call some method... |
| 563 | // |
| 564 | class BASE_EXPORT MessageLoopForUI : public MessageLoop { |
| 565 | public: |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 566 | MessageLoopForUI() : MessageLoop(TYPE_UI) { |
| 567 | } |
| 568 | |
| 569 | // Returns the MessageLoopForUI of the current thread. |
| 570 | static MessageLoopForUI* current() { |
| 571 | MessageLoop* loop = MessageLoop::current(); |
| 572 | DCHECK(loop); |
| 573 | DCHECK_EQ(MessageLoop::TYPE_UI, loop->type()); |
| 574 | return static_cast<MessageLoopForUI*>(loop); |
| 575 | } |
| 576 | |
sky@chromium.org | 8a7aae7 | 2014-01-20 17:59:52 +0900 | [diff] [blame] | 577 | static bool IsCurrent() { |
| 578 | MessageLoop* loop = MessageLoop::current(); |
| 579 | return loop && loop->type() == MessageLoop::TYPE_UI; |
| 580 | } |
| 581 | |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 582 | #if defined(OS_IOS) |
| 583 | // On iOS, the main message loop cannot be Run(). Instead call Attach(), |
| 584 | // which connects this MessageLoop to the UI thread's CFRunLoop and allows |
| 585 | // PostTask() to work. |
| 586 | void Attach(); |
| 587 | #endif |
| 588 | |
| 589 | #if defined(OS_ANDROID) |
| 590 | // On Android, the UI message loop is handled by Java side. So Run() should |
| 591 | // never be called. Instead use Start(), which will forward all the native UI |
| 592 | // events to the Java message loop. |
| 593 | void Start(); |
sky@chromium.org | f0ef6b6 | 2014-01-12 08:12:06 +0900 | [diff] [blame] | 594 | #endif |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 595 | |
zhaoze.zhou@partner.samsung.com | 0137aa8 | 2014-07-17 04:12:40 +0900 | [diff] [blame] | 596 | #if defined(USE_OZONE) || (defined(USE_X11) && !defined(USE_GLIB)) |
sadrul@chromium.org | 7aff5f6 | 2014-04-11 02:19:38 +0900 | [diff] [blame] | 597 | // Please see MessagePumpLibevent for definition. |
| 598 | bool WatchFileDescriptor( |
| 599 | int fd, |
| 600 | bool persistent, |
| 601 | MessagePumpLibevent::Mode mode, |
| 602 | MessagePumpLibevent::FileDescriptorWatcher* controller, |
| 603 | MessagePumpLibevent::Watcher* delegate); |
| 604 | #endif |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 605 | }; |
| 606 | |
| 607 | // Do not add any member variables to MessageLoopForUI! This is important b/c |
| 608 | // MessageLoopForUI is often allocated via MessageLoop(TYPE_UI). Any extra |
| 609 | // data that you need should be stored on the MessageLoop's pump_ instance. |
| 610 | COMPILE_ASSERT(sizeof(MessageLoop) == sizeof(MessageLoopForUI), |
| 611 | MessageLoopForUI_should_not_have_extra_member_variables); |
| 612 | |
sadrul@chromium.org | b169e22 | 2014-04-23 09:55:07 +0900 | [diff] [blame] | 613 | #endif // !defined(OS_NACL) |
| 614 | |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 615 | //----------------------------------------------------------------------------- |
| 616 | // MessageLoopForIO extends MessageLoop with methods that are particular to a |
| 617 | // MessageLoop instantiated with TYPE_IO. |
| 618 | // |
| 619 | // This class is typically used like so: |
| 620 | // MessageLoopForIO::current()->...call some method... |
| 621 | // |
| 622 | class BASE_EXPORT MessageLoopForIO : public MessageLoop { |
| 623 | public: |
sadrul@chromium.org | b169e22 | 2014-04-23 09:55:07 +0900 | [diff] [blame] | 624 | MessageLoopForIO() : MessageLoop(TYPE_IO) { |
| 625 | } |
| 626 | |
| 627 | // Returns the MessageLoopForIO of the current thread. |
| 628 | static MessageLoopForIO* current() { |
| 629 | MessageLoop* loop = MessageLoop::current(); |
| 630 | DCHECK_EQ(MessageLoop::TYPE_IO, loop->type()); |
| 631 | return static_cast<MessageLoopForIO*>(loop); |
| 632 | } |
| 633 | |
| 634 | static bool IsCurrent() { |
| 635 | MessageLoop* loop = MessageLoop::current(); |
| 636 | return loop && loop->type() == MessageLoop::TYPE_IO; |
| 637 | } |
| 638 | |
hidehiko | 58e1907 | 2014-11-06 08:51:52 +0900 | [diff] [blame] | 639 | #if !defined(OS_NACL_SFI) |
sadrul@chromium.org | b169e22 | 2014-04-23 09:55:07 +0900 | [diff] [blame] | 640 | |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 641 | #if defined(OS_WIN) |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 642 | typedef MessagePumpForIO::IOHandler IOHandler; |
| 643 | typedef MessagePumpForIO::IOContext IOContext; |
| 644 | typedef MessagePumpForIO::IOObserver IOObserver; |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 645 | #elif defined(OS_IOS) |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 646 | typedef MessagePumpIOSForIO::Watcher Watcher; |
| 647 | typedef MessagePumpIOSForIO::FileDescriptorWatcher |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 648 | FileDescriptorWatcher; |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 649 | typedef MessagePumpIOSForIO::IOObserver IOObserver; |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 650 | |
| 651 | enum Mode { |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 652 | WATCH_READ = MessagePumpIOSForIO::WATCH_READ, |
| 653 | WATCH_WRITE = MessagePumpIOSForIO::WATCH_WRITE, |
| 654 | WATCH_READ_WRITE = MessagePumpIOSForIO::WATCH_READ_WRITE |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 655 | }; |
| 656 | #elif defined(OS_POSIX) |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 657 | typedef MessagePumpLibevent::Watcher Watcher; |
| 658 | typedef MessagePumpLibevent::FileDescriptorWatcher |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 659 | FileDescriptorWatcher; |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 660 | typedef MessagePumpLibevent::IOObserver IOObserver; |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 661 | |
| 662 | enum Mode { |
brettw@chromium.org | 710ecb9 | 2013-06-19 05:27:52 +0900 | [diff] [blame] | 663 | WATCH_READ = MessagePumpLibevent::WATCH_READ, |
| 664 | WATCH_WRITE = MessagePumpLibevent::WATCH_WRITE, |
| 665 | WATCH_READ_WRITE = MessagePumpLibevent::WATCH_READ_WRITE |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 666 | }; |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 667 | #endif |
| 668 | |
sadrul@chromium.org | b169e22 | 2014-04-23 09:55:07 +0900 | [diff] [blame] | 669 | void AddIOObserver(IOObserver* io_observer); |
| 670 | void RemoveIOObserver(IOObserver* io_observer); |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 671 | |
| 672 | #if defined(OS_WIN) |
| 673 | // Please see MessagePumpWin for definitions of these methods. |
| 674 | void RegisterIOHandler(HANDLE file, IOHandler* handler); |
| 675 | bool RegisterJobObject(HANDLE job, IOHandler* handler); |
| 676 | bool WaitForIOCompletion(DWORD timeout, IOHandler* filter); |
sadrul@chromium.org | b169e22 | 2014-04-23 09:55:07 +0900 | [diff] [blame] | 677 | #elif defined(OS_POSIX) |
| 678 | // Please see MessagePumpIOSForIO/MessagePumpLibevent for definition. |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 679 | bool WatchFileDescriptor(int fd, |
| 680 | bool persistent, |
| 681 | Mode mode, |
thestig | fa24e5b | 2015-01-22 16:09:45 +0900 | [diff] [blame] | 682 | FileDescriptorWatcher* controller, |
| 683 | Watcher* delegate); |
sadrul@chromium.org | b169e22 | 2014-04-23 09:55:07 +0900 | [diff] [blame] | 684 | #endif // defined(OS_IOS) || defined(OS_POSIX) |
hidehiko | 58e1907 | 2014-11-06 08:51:52 +0900 | [diff] [blame] | 685 | #endif // !defined(OS_NACL_SFI) |
brettw@chromium.org | 6318b39 | 2013-06-14 12:27:49 +0900 | [diff] [blame] | 686 | }; |
| 687 | |
| 688 | // Do not add any member variables to MessageLoopForIO! This is important b/c |
| 689 | // MessageLoopForIO is often allocated via MessageLoop(TYPE_IO). Any extra |
| 690 | // data that you need should be stored on the MessageLoop's pump_ instance. |
| 691 | COMPILE_ASSERT(sizeof(MessageLoop) == sizeof(MessageLoopForIO), |
| 692 | MessageLoopForIO_should_not_have_extra_member_variables); |
| 693 | |
| 694 | } // namespace base |
| 695 | |
| 696 | #endif // BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_ |