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