| OLD | NEW |
|---|
| (Empty) |
| 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" | |
| 14 #include "base/debug/task_annotator.h" | |
| 15 #include "base/location.h" | |
| 16 #include "base/memory/ref_counted.h" | |
| 17 #include "base/memory/scoped_ptr.h" | |
| 18 #include "base/message_loop/incoming_task_queue.h" | |
| 19 #include "base/message_loop/message_loop_task_runner.h" | |
| 20 #include "base/message_loop/message_pump.h" | |
| 21 #include "base/message_loop/timer_slack.h" | |
| 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" | |
| 26 #include "base/time/time.h" | |
| 27 #include "base/tracking_info.h" | |
| 28 | |
| 29 // TODO(sky): these includes should not be necessary. Nuke them. | |
| 30 #if defined(OS_WIN) | |
| 31 #include "base/message_loop/message_pump_win.h" | |
| 32 #elif defined(OS_IOS) | |
| 33 #include "base/message_loop/message_pump_io_ios.h" | |
| 34 #elif defined(OS_POSIX) | |
| 35 #include "base/message_loop/message_pump_libevent.h" | |
| 36 #endif | |
| 37 | |
| 38 namespace base { | |
| 39 | |
| 40 class HistogramBase; | |
| 41 class RunLoop; | |
| 42 class ThreadTaskRunnerHandle; | |
| 43 class WaitableEvent; | |
| 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 // | |
| 76 class BASE_EXPORT MessageLoop : public MessagePump::Delegate { | |
| 77 public: | |
| 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 // | |
| 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 // | |
| 98 // TYPE_CUSTOM | |
| 99 // MessagePump was supplied to constructor. | |
| 100 // | |
| 101 enum Type { | |
| 102 TYPE_DEFAULT, | |
| 103 TYPE_UI, | |
| 104 TYPE_CUSTOM, | |
| 105 TYPE_IO, | |
| 106 #if defined(OS_ANDROID) | |
| 107 TYPE_JAVA, | |
| 108 #endif // defined(OS_ANDROID) | |
| 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); | |
| 114 // Creates a TYPE_CUSTOM MessageLoop with the supplied MessagePump, which must | |
| 115 // be non-NULL. | |
| 116 explicit MessageLoop(scoped_ptr<MessagePump> pump); | |
| 117 | |
| 118 ~MessageLoop() override; | |
| 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 | |
| 125 typedef scoped_ptr<MessagePump> (MessagePumpFactory)(); | |
| 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 | |
| 131 // Creates the default MessagePump based on |type|. Caller owns return | |
| 132 // value. | |
| 133 static scoped_ptr<MessagePump> CreateMessagePumpForType(Type type); | |
| 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 | |
| 158 // NOTE: Deprecated; prefer task_runner() and the TaskRunner interfaces. | |
| 159 // TODO(skyostil): Remove these functions (crbug.com/465354). | |
| 160 // | |
| 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 // | |
| 178 // NOTE: These methods may be called on any thread. The Task will be invoked | |
| 179 // on the thread that executes MessageLoop::Run(). | |
| 180 void PostTask(const tracked_objects::Location& from_here, | |
| 181 const Closure& task); | |
| 182 | |
| 183 void PostDelayedTask(const tracked_objects::Location& from_here, | |
| 184 const Closure& task, | |
| 185 TimeDelta delay); | |
| 186 | |
| 187 void PostNonNestableTask(const tracked_objects::Location& from_here, | |
| 188 const Closure& task); | |
| 189 | |
| 190 void PostNonNestableDelayedTask(const tracked_objects::Location& from_here, | |
| 191 const Closure& task, | |
| 192 TimeDelta delay); | |
| 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 | |
| 200 // on the thread that executes MessageLoop::Run(). | |
| 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 // | |
| 212 // A common pattern is to manually increment the object's reference count | |
| 213 // (AddRef), clear the pointer, then issue a ReleaseSoon. The reference count | |
| 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 = ... | |
| 219 // foo->AddRef(); | |
| 220 // Foo* raw_foo = foo.get(); | |
| 221 // foo = NULL; | |
| 222 // message_loop->ReleaseSoon(raw_foo); | |
| 223 // | |
| 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 | |
| 227 // ReleaseSoon(FROM_HERE, ), then T MUST inherit from | |
| 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(). | |
| 272 static Closure QuitClosure() { return QuitWhenIdleClosure(); } | |
| 273 | |
| 274 // Deprecated: use RunLoop instead. | |
| 275 // Construct a Closure that will call QuitWhenIdle(). Useful to schedule an | |
| 276 // arbitrary MessageLoop to QuitWhenIdle. | |
| 277 static Closure QuitWhenIdleClosure(); | |
| 278 | |
| 279 // Set the timer slack for this message loop. | |
| 280 void SetTimerSlack(TimerSlack timer_slack) { | |
| 281 pump_->SetTimerSlack(timer_slack); | |
| 282 } | |
| 283 | |
| 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 | |
| 298 // Gets the TaskRunner associated with this message loop. | |
| 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); | |
| 309 | |
| 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 | |
| 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. | |
| 361 virtual void WillProcessTask(const PendingTask& pending_task) = 0; | |
| 362 | |
| 363 // This method is called after processing a task. | |
| 364 virtual void DidProcessTask(const PendingTask& pending_task) = 0; | |
| 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 | |
| 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 | |
| 388 // Returns true if the message loop has high resolution timers enabled. | |
| 389 // Provided for testing. | |
| 390 bool HasHighResolutionTasks(); | |
| 391 | |
| 392 // Returns true if the message loop is "idle". Provided for testing. | |
| 393 bool IsIdleForTesting(); | |
| 394 | |
| 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 | |
| 402 //---------------------------------------------------------------------------- | |
| 403 protected: | |
| 404 scoped_ptr<MessagePump> pump_; | |
| 405 | |
| 406 private: | |
| 407 friend class RunLoop; | |
| 408 friend class internal::IncomingTaskQueue; | |
| 409 friend class ScheduleWorkTest; | |
| 410 friend class Thread; | |
| 411 | |
| 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. | |
| 425 static scoped_ptr<MessageLoop> CreateUnbound( | |
| 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(); | |
| 435 | |
| 436 // Sets the ThreadTaskRunnerHandle for the current thread to point to the | |
| 437 // task runner for this message loop. | |
| 438 void SetThreadTaskRunnerHandle(); | |
| 439 | |
| 440 // Invokes the actual run loop using the message pump. | |
| 441 void RunHandler(); | |
| 442 | |
| 443 // Called to process any delayed non-nestable tasks. | |
| 444 bool ProcessNextDelayedNonNestableTask(); | |
| 445 | |
| 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. | |
| 448 bool DeferOrRunPendingTask(const PendingTask& pending_task); | |
| 449 | |
| 450 // Adds the pending task to delayed_work_queue_. | |
| 451 void AddToDelayedWorkQueue(const PendingTask& pending_task); | |
| 452 | |
| 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 | |
| 458 // Loads tasks from the incoming queue to |work_queue_| if the latter is | |
| 459 // empty. | |
| 460 void ReloadWorkQueue(); | |
| 461 | |
| 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 | |
| 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 | |
| 475 // MessagePump::Delegate methods: | |
| 476 bool DoWork() override; | |
| 477 bool DoDelayedWork(TimeTicks* next_delayed_work_time) override; | |
| 478 bool DoIdleWork() override; | |
| 479 | |
| 480 const Type type_; | |
| 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. | |
| 484 TaskQueue work_queue_; | |
| 485 | |
| 486 #if defined(OS_WIN) | |
| 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_; | |
| 494 #endif | |
| 495 | |
| 496 // Contains delayed tasks, sorted by their 'delayed_run_time' property. | |
| 497 DelayedTaskQueue delayed_work_queue_; | |
| 498 | |
| 499 // A recent snapshot of Time::Now(), used to check delayed_work_queue_. | |
| 500 TimeTicks recent_time_; | |
| 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. | |
| 505 TaskQueue deferred_non_nestable_work_queue_; | |
| 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 | |
| 513 #if defined(OS_WIN) | |
| 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 | |
| 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 | |
| 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_; | |
| 528 | |
| 529 ObserverList<TaskObserver> task_observers_; | |
| 530 | |
| 531 debug::TaskAnnotator task_annotator_; | |
| 532 | |
| 533 scoped_refptr<internal::IncomingTaskQueue> incoming_task_queue_; | |
| 534 | |
| 535 // A task runner which we haven't bound to a thread yet. | |
| 536 scoped_refptr<internal::MessageLoopTaskRunner> unbound_task_runner_; | |
| 537 | |
| 538 // The task runner associated with this message loop. | |
| 539 scoped_refptr<SingleThreadTaskRunner> task_runner_; | |
| 540 scoped_ptr<ThreadTaskRunnerHandle> thread_task_runner_handle_; | |
| 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 | |
| 555 #if !defined(OS_NACL) | |
| 556 | |
| 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: | |
| 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 | |
| 577 static bool IsCurrent() { | |
| 578 MessageLoop* loop = MessageLoop::current(); | |
| 579 return loop && loop->type() == MessageLoop::TYPE_UI; | |
| 580 } | |
| 581 | |
| 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(); | |
| 594 #endif | |
| 595 | |
| 596 #if defined(USE_OZONE) || (defined(USE_X11) && !defined(USE_GLIB)) | |
| 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 | |
| 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 | |
| 613 #endif // !defined(OS_NACL) | |
| 614 | |
| 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: | |
| 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 | |
| 639 #if !defined(OS_NACL_SFI) | |
| 640 | |
| 641 #if defined(OS_WIN) | |
| 642 typedef MessagePumpForIO::IOHandler IOHandler; | |
| 643 typedef MessagePumpForIO::IOContext IOContext; | |
| 644 typedef MessagePumpForIO::IOObserver IOObserver; | |
| 645 #elif defined(OS_IOS) | |
| 646 typedef MessagePumpIOSForIO::Watcher Watcher; | |
| 647 typedef MessagePumpIOSForIO::FileDescriptorWatcher | |
| 648 FileDescriptorWatcher; | |
| 649 typedef MessagePumpIOSForIO::IOObserver IOObserver; | |
| 650 | |
| 651 enum Mode { | |
| 652 WATCH_READ = MessagePumpIOSForIO::WATCH_READ, | |
| 653 WATCH_WRITE = MessagePumpIOSForIO::WATCH_WRITE, | |
| 654 WATCH_READ_WRITE = MessagePumpIOSForIO::WATCH_READ_WRITE | |
| 655 }; | |
| 656 #elif defined(OS_POSIX) | |
| 657 typedef MessagePumpLibevent::Watcher Watcher; | |
| 658 typedef MessagePumpLibevent::FileDescriptorWatcher | |
| 659 FileDescriptorWatcher; | |
| 660 typedef MessagePumpLibevent::IOObserver IOObserver; | |
| 661 | |
| 662 enum Mode { | |
| 663 WATCH_READ = MessagePumpLibevent::WATCH_READ, | |
| 664 WATCH_WRITE = MessagePumpLibevent::WATCH_WRITE, | |
| 665 WATCH_READ_WRITE = MessagePumpLibevent::WATCH_READ_WRITE | |
| 666 }; | |
| 667 #endif | |
| 668 | |
| 669 void AddIOObserver(IOObserver* io_observer); | |
| 670 void RemoveIOObserver(IOObserver* io_observer); | |
| 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); | |
| 677 #elif defined(OS_POSIX) | |
| 678 // Please see MessagePumpIOSForIO/MessagePumpLibevent for definition. | |
| 679 bool WatchFileDescriptor(int fd, | |
| 680 bool persistent, | |
| 681 Mode mode, | |
| 682 FileDescriptorWatcher* controller, | |
| 683 Watcher* delegate); | |
| 684 #endif // defined(OS_IOS) || defined(OS_POSIX) | |
| 685 #endif // !defined(OS_NACL_SFI) | |
| 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_ | |
| OLD | NEW |
|---|
Chromium Code Reviews
