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/location.h" 15 #include "base/memory/ref_counted.h" 16 #include "base/memory/scoped_ptr.h" 17 #include "base/message_loop/incoming_task_queue.h" 18 #include "base/message_loop/message_loop_proxy.h" 19 #include "base/message_loop/message_loop_proxy_impl.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 MessagePumpObserver; 42 class RunLoop; 43 class ThreadTaskRunnerHandle; 44 class 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 // 77 class 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 scoped_refptr<MessageLoopProxy> message_loop_proxy() { 299 return message_loop_proxy_; 300 } 301 302 // Enables or disables the recursive task processing. This happens in the case 303 // of recursive message loops. Some unwanted message loop may occurs when 304 // using common controls or printer functions. By default, recursive task 305 // processing is disabled. 306 // 307 // Please utilize |ScopedNestableTaskAllower| instead of calling these methods 308 // directly. In general nestable message loops are to be avoided. They are 309 // dangerous and difficult to get right, so please use with extreme caution. 310 // 311 // The specific case where tasks get queued is: 312 // - The thread is running a message loop. 313 // - It receives a task #1 and execute it. 314 // - The task #1 implicitly start a message loop, like a MessageBox in the 315 // unit test. This can also be StartDoc or GetSaveFileName. 316 // - The thread receives a task #2 before or while in this second message 317 // loop. 318 // - With NestableTasksAllowed set to true, the task #2 will run right away. 319 // Otherwise, it will get executed right after task #1 completes at "thread 320 // message loop level". 321 void SetNestableTasksAllowed(bool allowed); 322 bool NestableTasksAllowed() const; 323 324 // Enables nestable tasks on |loop| while in scope. 325 class ScopedNestableTaskAllower { 326 public: 327 explicit ScopedNestableTaskAllower(MessageLoop* loop) 328 : loop_(loop), 329 old_state_(loop_->NestableTasksAllowed()) { 330 loop_->SetNestableTasksAllowed(true); 331 } 332 ~ScopedNestableTaskAllower() { 333 loop_->SetNestableTasksAllowed(old_state_); 334 } 335 336 private: 337 MessageLoop* loop_; 338 bool old_state_; 339 }; 340 341 // Returns true if we are currently running a nested message loop. 342 bool IsNested(); 343 344 // A TaskObserver is an object that receives task notifications from the 345 // MessageLoop. 346 // 347 // NOTE: A TaskObserver implementation should be extremely fast! 348 class BASE_EXPORT TaskObserver { 349 public: 350 TaskObserver(); 351 352 // This method is called before processing a task. 353 virtual void WillProcessTask(const PendingTask& pending_task) = 0; 354 355 // This method is called after processing a task. 356 virtual void DidProcessTask(const PendingTask& pending_task) = 0; 357 358 protected: 359 virtual ~TaskObserver(); 360 }; 361 362 // These functions can only be called on the same thread that |this| is 363 // running on. 364 void AddTaskObserver(TaskObserver* task_observer); 365 void RemoveTaskObserver(TaskObserver* task_observer); 366 367 // When we go into high resolution timer mode, we will stay in hi-res mode 368 // for at least 1s. 369 static const int kHighResolutionTimerModeLeaseTimeMs = 1000; 370 371 #if defined(OS_WIN) 372 void set_os_modal_loop(bool os_modal_loop) { 373 os_modal_loop_ = os_modal_loop; 374 } 375 376 bool os_modal_loop() const { 377 return os_modal_loop_; 378 } 379 #endif // OS_WIN 380 381 // Can only be called from the thread that owns the MessageLoop. 382 bool is_running() const; 383 384 // Returns true if the message loop has high resolution timers enabled. 385 // Provided for testing. 386 bool IsHighResolutionTimerEnabledForTesting(); 387 388 // Returns true if the message loop is "idle". Provided for testing. 389 bool IsIdleForTesting(); 390 391 //---------------------------------------------------------------------------- 392 protected: 393 scoped_ptr<MessagePump> pump_; 394 395 private: 396 friend class internal::IncomingTaskQueue; 397 friend class RunLoop; 398 399 // Configures various members for the two constructors. 400 void Init(); 401 402 // Invokes the actual run loop using the message pump. 403 void RunHandler(); 404 405 // Called to process any delayed non-nestable tasks. 406 bool ProcessNextDelayedNonNestableTask(); 407 408 // Runs the specified PendingTask. 409 void RunTask(const PendingTask& pending_task); 410 411 // Calls RunTask or queues the pending_task on the deferred task list if it 412 // cannot be run right now. Returns true if the task was run. 413 bool DeferOrRunPendingTask(const PendingTask& pending_task); 414 415 // Adds the pending task to delayed_work_queue_. 416 void AddToDelayedWorkQueue(const PendingTask& pending_task); 417 418 // Delete tasks that haven't run yet without running them. Used in the 419 // destructor to make sure all the task's destructors get called. Returns 420 // true if some work was done. 421 bool DeletePendingTasks(); 422 423 // Creates a process-wide unique ID to represent this task in trace events. 424 // This will be mangled with a Process ID hash to reduce the likelyhood of 425 // colliding with MessageLoop pointers on other processes. 426 uint64 GetTaskTraceID(const PendingTask& task); 427 428 // Loads tasks from the incoming queue to |work_queue_| if the latter is 429 // empty. 430 void ReloadWorkQueue(); 431 432 // Wakes up the message pump. Can be called on any thread. The caller is 433 // responsible for synchronizing ScheduleWork() calls. 434 void ScheduleWork(bool was_empty); 435 436 // Start recording histogram info about events and action IF it was enabled 437 // and IF the statistics recorder can accept a registration of our histogram. 438 void StartHistogrammer(); 439 440 // Add occurrence of event to our histogram, so that we can see what is being 441 // done in a specific MessageLoop instance (i.e., specific thread). 442 // If message_histogram_ is NULL, this is a no-op. 443 void HistogramEvent(int event); 444 445 // MessagePump::Delegate methods: 446 virtual bool DoWork() OVERRIDE; 447 virtual bool DoDelayedWork(TimeTicks* next_delayed_work_time) OVERRIDE; 448 virtual bool DoIdleWork() OVERRIDE; 449 virtual void GetQueueingInformation(size_t* queue_size, 450 TimeDelta* queueing_delay) OVERRIDE; 451 452 const Type type_; 453 454 // A list of tasks that need to be processed by this instance. Note that 455 // this queue is only accessed (push/pop) by our current thread. 456 TaskQueue work_queue_; 457 458 // Contains delayed tasks, sorted by their 'delayed_run_time' property. 459 DelayedTaskQueue delayed_work_queue_; 460 461 // A recent snapshot of Time::Now(), used to check delayed_work_queue_. 462 TimeTicks recent_time_; 463 464 // A queue of non-nestable tasks that we had to defer because when it came 465 // time to execute them we were in a nested message loop. They will execute 466 // once we're out of nested message loops. 467 TaskQueue deferred_non_nestable_work_queue_; 468 469 ObserverList<DestructionObserver> destruction_observers_; 470 471 // A recursion block that prevents accidentally running additional tasks when 472 // insider a (accidentally induced?) nested message pump. 473 bool nestable_tasks_allowed_; 474 475 #if defined(OS_WIN) 476 // Should be set to true before calling Windows APIs like TrackPopupMenu, etc 477 // which enter a modal message loop. 478 bool os_modal_loop_; 479 #endif 480 481 std::string thread_name_; 482 // A profiling histogram showing the counts of various messages and events. 483 HistogramBase* message_histogram_; 484 485 RunLoop* run_loop_; 486 487 ObserverList<TaskObserver> task_observers_; 488 489 scoped_refptr<internal::IncomingTaskQueue> incoming_task_queue_; 490 491 // The message loop proxy associated with this message loop. 492 scoped_refptr<internal::MessageLoopProxyImpl> message_loop_proxy_; 493 scoped_ptr<ThreadTaskRunnerHandle> thread_task_runner_handle_; 494 495 template <class T, class R> friend class base::subtle::DeleteHelperInternal; 496 template <class T, class R> friend class base::subtle::ReleaseHelperInternal; 497 498 void DeleteSoonInternal(const tracked_objects::Location& from_here, 499 void(*deleter)(const void*), 500 const void* object); 501 void ReleaseSoonInternal(const tracked_objects::Location& from_here, 502 void(*releaser)(const void*), 503 const void* object); 504 505 DISALLOW_COPY_AND_ASSIGN(MessageLoop); 506 }; 507 508 #if !defined(OS_NACL) 509 510 //----------------------------------------------------------------------------- 511 // MessageLoopForUI extends MessageLoop with methods that are particular to a 512 // MessageLoop instantiated with TYPE_UI. 513 // 514 // This class is typically used like so: 515 // MessageLoopForUI::current()->...call some method... 516 // 517 class BASE_EXPORT MessageLoopForUI : public MessageLoop { 518 public: 519 MessageLoopForUI() : MessageLoop(TYPE_UI) { 520 } 521 522 // Returns the MessageLoopForUI of the current thread. 523 static MessageLoopForUI* current() { 524 MessageLoop* loop = MessageLoop::current(); 525 DCHECK(loop); 526 DCHECK_EQ(MessageLoop::TYPE_UI, loop->type()); 527 return static_cast<MessageLoopForUI*>(loop); 528 } 529 530 static bool IsCurrent() { 531 MessageLoop* loop = MessageLoop::current(); 532 return loop && loop->type() == MessageLoop::TYPE_UI; 533 } 534 535 #if defined(OS_IOS) 536 // On iOS, the main message loop cannot be Run(). Instead call Attach(), 537 // which connects this MessageLoop to the UI thread's CFRunLoop and allows 538 // PostTask() to work. 539 void Attach(); 540 #endif 541 542 #if defined(OS_ANDROID) 543 // On Android, the UI message loop is handled by Java side. So Run() should 544 // never be called. Instead use Start(), which will forward all the native UI 545 // events to the Java message loop. 546 void Start(); 547 #endif 548 549 #if defined(OS_WIN) 550 typedef MessagePumpObserver Observer; 551 552 // Please see message_pump_win for definitions of these methods. 553 void AddObserver(Observer* observer); 554 void RemoveObserver(Observer* observer); 555 #endif 556 557 #if defined(USE_OZONE) || (defined(OS_CHROMEOS) && !defined(USE_GLIB)) 558 // Please see MessagePumpLibevent for definition. 559 bool WatchFileDescriptor( 560 int fd, 561 bool persistent, 562 MessagePumpLibevent::Mode mode, 563 MessagePumpLibevent::FileDescriptorWatcher* controller, 564 MessagePumpLibevent::Watcher* delegate); 565 #endif 566 }; 567 568 // Do not add any member variables to MessageLoopForUI! This is important b/c 569 // MessageLoopForUI is often allocated via MessageLoop(TYPE_UI). Any extra 570 // data that you need should be stored on the MessageLoop's pump_ instance. 571 COMPILE_ASSERT(sizeof(MessageLoop) == sizeof(MessageLoopForUI), 572 MessageLoopForUI_should_not_have_extra_member_variables); 573 574 #endif // !defined(OS_NACL) 575 576 //----------------------------------------------------------------------------- 577 // MessageLoopForIO extends MessageLoop with methods that are particular to a 578 // MessageLoop instantiated with TYPE_IO. 579 // 580 // This class is typically used like so: 581 // MessageLoopForIO::current()->...call some method... 582 // 583 class BASE_EXPORT MessageLoopForIO : public MessageLoop { 584 public: 585 MessageLoopForIO() : MessageLoop(TYPE_IO) { 586 } 587 588 // Returns the MessageLoopForIO of the current thread. 589 static MessageLoopForIO* current() { 590 MessageLoop* loop = MessageLoop::current(); 591 DCHECK_EQ(MessageLoop::TYPE_IO, loop->type()); 592 return static_cast<MessageLoopForIO*>(loop); 593 } 594 595 static bool IsCurrent() { 596 MessageLoop* loop = MessageLoop::current(); 597 return loop && loop->type() == MessageLoop::TYPE_IO; 598 } 599 600 #if !defined(OS_NACL) 601 602 #if defined(OS_WIN) 603 typedef MessagePumpForIO::IOHandler IOHandler; 604 typedef MessagePumpForIO::IOContext IOContext; 605 typedef MessagePumpForIO::IOObserver IOObserver; 606 #elif defined(OS_IOS) 607 typedef MessagePumpIOSForIO::Watcher Watcher; 608 typedef MessagePumpIOSForIO::FileDescriptorWatcher 609 FileDescriptorWatcher; 610 typedef MessagePumpIOSForIO::IOObserver IOObserver; 611 612 enum Mode { 613 WATCH_READ = MessagePumpIOSForIO::WATCH_READ, 614 WATCH_WRITE = MessagePumpIOSForIO::WATCH_WRITE, 615 WATCH_READ_WRITE = MessagePumpIOSForIO::WATCH_READ_WRITE 616 }; 617 #elif defined(OS_POSIX) 618 typedef MessagePumpLibevent::Watcher Watcher; 619 typedef MessagePumpLibevent::FileDescriptorWatcher 620 FileDescriptorWatcher; 621 typedef MessagePumpLibevent::IOObserver IOObserver; 622 623 enum Mode { 624 WATCH_READ = MessagePumpLibevent::WATCH_READ, 625 WATCH_WRITE = MessagePumpLibevent::WATCH_WRITE, 626 WATCH_READ_WRITE = MessagePumpLibevent::WATCH_READ_WRITE 627 }; 628 #endif 629 630 void AddIOObserver(IOObserver* io_observer); 631 void RemoveIOObserver(IOObserver* io_observer); 632 633 #if defined(OS_WIN) 634 // Please see MessagePumpWin for definitions of these methods. 635 void RegisterIOHandler(HANDLE file, IOHandler* handler); 636 bool RegisterJobObject(HANDLE job, IOHandler* handler); 637 bool WaitForIOCompletion(DWORD timeout, IOHandler* filter); 638 #elif defined(OS_POSIX) 639 // Please see MessagePumpIOSForIO/MessagePumpLibevent for definition. 640 bool WatchFileDescriptor(int fd, 641 bool persistent, 642 Mode mode, 643 FileDescriptorWatcher *controller, 644 Watcher *delegate); 645 #endif // defined(OS_IOS) || defined(OS_POSIX) 646 #endif // !defined(OS_NACL) 647 }; 648 649 // Do not add any member variables to MessageLoopForIO! This is important b/c 650 // MessageLoopForIO is often allocated via MessageLoop(TYPE_IO). Any extra 651 // data that you need should be stored on the MessageLoop's pump_ instance. 652 COMPILE_ASSERT(sizeof(MessageLoop) == sizeof(MessageLoopForIO), 653 MessageLoopForIO_should_not_have_extra_member_variables); 654 655 } // namespace base 656 657 #endif // BASE_MESSAGE_LOOP_MESSAGE_LOOP_H_ 658