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#include "base/message_loop/message_loop.h" 6 7#include <algorithm> 8 9#include "base/bind.h" 10#include "base/compiler_specific.h" 11#include "base/debug/alias.h" 12#include "base/debug/trace_event.h" 13#include "base/lazy_instance.h" 14#include "base/logging.h" 15#include "base/memory/scoped_ptr.h" 16#include "base/message_loop/message_pump_default.h" 17#include "base/metrics/histogram.h" 18#include "base/metrics/statistics_recorder.h" 19#include "base/run_loop.h" 20#include "base/third_party/dynamic_annotations/dynamic_annotations.h" 21#include "base/thread_task_runner_handle.h" 22#include "base/threading/thread_local.h" 23#include "base/time/time.h" 24#include "base/tracked_objects.h" 25 26#if defined(OS_MACOSX) 27#include "base/message_loop/message_pump_mac.h" 28#endif 29#if defined(OS_POSIX) && !defined(OS_IOS) 30#include "base/message_loop/message_pump_libevent.h" 31#endif 32#if defined(OS_ANDROID) 33#include "base/message_loop/message_pump_android.h" 34#endif 35#if defined(USE_GLIB) 36#include "base/message_loop/message_pump_glib.h" 37#endif 38 39namespace base { 40 41namespace { 42 43// A lazily created thread local storage for quick access to a thread's message 44// loop, if one exists. This should be safe and free of static constructors. 45LazyInstance<base::ThreadLocalPointer<MessageLoop> >::Leaky lazy_tls_ptr = 46 LAZY_INSTANCE_INITIALIZER; 47 48// Logical events for Histogram profiling. Run with -message-loop-histogrammer 49// to get an accounting of messages and actions taken on each thread. 50const int kTaskRunEvent = 0x1; 51#if !defined(OS_NACL) 52const int kTimerEvent = 0x2; 53 54// Provide range of message IDs for use in histogramming and debug display. 55const int kLeastNonZeroMessageId = 1; 56const int kMaxMessageId = 1099; 57const int kNumberOfDistinctMessagesDisplayed = 1100; 58 59// Provide a macro that takes an expression (such as a constant, or macro 60// constant) and creates a pair to initalize an array of pairs. In this case, 61// our pair consists of the expressions value, and the "stringized" version 62// of the expression (i.e., the exrpression put in quotes). For example, if 63// we have: 64// #define FOO 2 65// #define BAR 5 66// then the following: 67// VALUE_TO_NUMBER_AND_NAME(FOO + BAR) 68// will expand to: 69// {7, "FOO + BAR"} 70// We use the resulting array as an argument to our histogram, which reads the 71// number as a bucket identifier, and proceeds to use the corresponding name 72// in the pair (i.e., the quoted string) when printing out a histogram. 73#define VALUE_TO_NUMBER_AND_NAME(name) {name, #name}, 74 75const LinearHistogram::DescriptionPair event_descriptions_[] = { 76 // Provide some pretty print capability in our histogram for our internal 77 // messages. 78 79 // A few events we handle (kindred to messages), and used to profile actions. 80 VALUE_TO_NUMBER_AND_NAME(kTaskRunEvent) 81 VALUE_TO_NUMBER_AND_NAME(kTimerEvent) 82 83 {-1, NULL} // The list must be null terminated, per API to histogram. 84}; 85#endif // !defined(OS_NACL) 86 87bool enable_histogrammer_ = false; 88 89MessageLoop::MessagePumpFactory* message_pump_for_ui_factory_ = NULL; 90 91// Returns true if MessagePump::ScheduleWork() must be called one 92// time for every task that is added to the MessageLoop incoming queue. 93bool AlwaysNotifyPump(MessageLoop::Type type) { 94#if defined(OS_ANDROID) 95 return type == MessageLoop::TYPE_UI || type == MessageLoop::TYPE_JAVA; 96#else 97 return false; 98#endif 99} 100 101#if defined(OS_IOS) 102typedef MessagePumpIOSForIO MessagePumpForIO; 103#elif defined(OS_NACL) 104typedef MessagePumpDefault MessagePumpForIO; 105#elif defined(OS_POSIX) 106typedef MessagePumpLibevent MessagePumpForIO; 107#endif 108 109MessagePumpForIO* ToPumpIO(MessagePump* pump) { 110 return static_cast<MessagePumpForIO*>(pump); 111} 112 113} // namespace 114 115//------------------------------------------------------------------------------ 116 117MessageLoop::TaskObserver::TaskObserver() { 118} 119 120MessageLoop::TaskObserver::~TaskObserver() { 121} 122 123MessageLoop::DestructionObserver::~DestructionObserver() { 124} 125 126//------------------------------------------------------------------------------ 127 128MessageLoop::MessageLoop(Type type) 129 : type_(type), 130 nestable_tasks_allowed_(true), 131#if defined(OS_WIN) 132 os_modal_loop_(false), 133#endif // OS_WIN 134 message_histogram_(NULL), 135 run_loop_(NULL) { 136 Init(); 137 138 pump_ = CreateMessagePumpForType(type).Pass(); 139} 140 141MessageLoop::MessageLoop(scoped_ptr<MessagePump> pump) 142 : pump_(pump.Pass()), 143 type_(TYPE_CUSTOM), 144 nestable_tasks_allowed_(true), 145#if defined(OS_WIN) 146 os_modal_loop_(false), 147#endif // OS_WIN 148 message_histogram_(NULL), 149 run_loop_(NULL) { 150 DCHECK(pump_.get()); 151 Init(); 152} 153 154MessageLoop::~MessageLoop() { 155 DCHECK_EQ(this, current()); 156 157 DCHECK(!run_loop_); 158 159 // Clean up any unprocessed tasks, but take care: deleting a task could 160 // result in the addition of more tasks (e.g., via DeleteSoon). We set a 161 // limit on the number of times we will allow a deleted task to generate more 162 // tasks. Normally, we should only pass through this loop once or twice. If 163 // we end up hitting the loop limit, then it is probably due to one task that 164 // is being stubborn. Inspect the queues to see who is left. 165 bool did_work; 166 for (int i = 0; i < 100; ++i) { 167 DeletePendingTasks(); 168 ReloadWorkQueue(); 169 // If we end up with empty queues, then break out of the loop. 170 did_work = DeletePendingTasks(); 171 if (!did_work) 172 break; 173 } 174 DCHECK(!did_work); 175 176 // Let interested parties have one last shot at accessing this. 177 FOR_EACH_OBSERVER(DestructionObserver, destruction_observers_, 178 WillDestroyCurrentMessageLoop()); 179 180 thread_task_runner_handle_.reset(); 181 182 // Tell the incoming queue that we are dying. 183 incoming_task_queue_->WillDestroyCurrentMessageLoop(); 184 incoming_task_queue_ = NULL; 185 message_loop_proxy_ = NULL; 186 187 // OK, now make it so that no one can find us. 188 lazy_tls_ptr.Pointer()->Set(NULL); 189} 190 191// static 192MessageLoop* MessageLoop::current() { 193 // TODO(darin): sadly, we cannot enable this yet since people call us even 194 // when they have no intention of using us. 195 // DCHECK(loop) << "Ouch, did you forget to initialize me?"; 196 return lazy_tls_ptr.Pointer()->Get(); 197} 198 199// static 200void MessageLoop::EnableHistogrammer(bool enable) { 201 enable_histogrammer_ = enable; 202} 203 204// static 205bool MessageLoop::InitMessagePumpForUIFactory(MessagePumpFactory* factory) { 206 if (message_pump_for_ui_factory_) 207 return false; 208 209 message_pump_for_ui_factory_ = factory; 210 return true; 211} 212 213// static 214scoped_ptr<MessagePump> MessageLoop::CreateMessagePumpForType(Type type) { 215// TODO(rvargas): Get rid of the OS guards. 216#if defined(USE_GLIB) && !defined(OS_NACL) 217 typedef MessagePumpGlib MessagePumpForUI; 218#elif defined(OS_LINUX) && !defined(OS_NACL) 219 typedef MessagePumpLibevent MessagePumpForUI; 220#endif 221 222#if defined(OS_IOS) || defined(OS_MACOSX) 223#define MESSAGE_PUMP_UI scoped_ptr<MessagePump>(MessagePumpMac::Create()) 224#elif defined(OS_NACL) 225// Currently NaCl doesn't have a UI MessageLoop. 226// TODO(abarth): Figure out if we need this. 227#define MESSAGE_PUMP_UI scoped_ptr<MessagePump>() 228#else 229#define MESSAGE_PUMP_UI scoped_ptr<MessagePump>(new MessagePumpForUI()) 230#endif 231 232 if (type == MessageLoop::TYPE_UI) { 233 if (message_pump_for_ui_factory_) 234 return message_pump_for_ui_factory_(); 235 return MESSAGE_PUMP_UI; 236 } 237 if (type == MessageLoop::TYPE_IO) 238 return scoped_ptr<MessagePump>(new MessagePumpForIO()); 239 240#if defined(OS_ANDROID) 241 if (type == MessageLoop::TYPE_JAVA) 242 return scoped_ptr<MessagePump>(new MessagePumpForUI()); 243#endif 244 245 DCHECK_EQ(MessageLoop::TYPE_DEFAULT, type); 246 return scoped_ptr<MessagePump>(new MessagePumpDefault()); 247} 248 249void MessageLoop::AddDestructionObserver( 250 DestructionObserver* destruction_observer) { 251 DCHECK_EQ(this, current()); 252 destruction_observers_.AddObserver(destruction_observer); 253} 254 255void MessageLoop::RemoveDestructionObserver( 256 DestructionObserver* destruction_observer) { 257 DCHECK_EQ(this, current()); 258 destruction_observers_.RemoveObserver(destruction_observer); 259} 260 261void MessageLoop::PostTask( 262 const tracked_objects::Location& from_here, 263 const Closure& task) { 264 DCHECK(!task.is_null()) << from_here.ToString(); 265 incoming_task_queue_->AddToIncomingQueue(from_here, task, TimeDelta(), true); 266} 267 268void MessageLoop::PostDelayedTask( 269 const tracked_objects::Location& from_here, 270 const Closure& task, 271 TimeDelta delay) { 272 DCHECK(!task.is_null()) << from_here.ToString(); 273 incoming_task_queue_->AddToIncomingQueue(from_here, task, delay, true); 274} 275 276void MessageLoop::PostNonNestableTask( 277 const tracked_objects::Location& from_here, 278 const Closure& task) { 279 DCHECK(!task.is_null()) << from_here.ToString(); 280 incoming_task_queue_->AddToIncomingQueue(from_here, task, TimeDelta(), false); 281} 282 283void MessageLoop::PostNonNestableDelayedTask( 284 const tracked_objects::Location& from_here, 285 const Closure& task, 286 TimeDelta delay) { 287 DCHECK(!task.is_null()) << from_here.ToString(); 288 incoming_task_queue_->AddToIncomingQueue(from_here, task, delay, false); 289} 290 291void MessageLoop::Run() { 292 RunLoop run_loop; 293 run_loop.Run(); 294} 295 296void MessageLoop::RunUntilIdle() { 297 RunLoop run_loop; 298 run_loop.RunUntilIdle(); 299} 300 301void MessageLoop::QuitWhenIdle() { 302 DCHECK_EQ(this, current()); 303 if (run_loop_) { 304 run_loop_->quit_when_idle_received_ = true; 305 } else { 306 NOTREACHED() << "Must be inside Run to call Quit"; 307 } 308} 309 310void MessageLoop::QuitNow() { 311 DCHECK_EQ(this, current()); 312 if (run_loop_) { 313 pump_->Quit(); 314 } else { 315 NOTREACHED() << "Must be inside Run to call Quit"; 316 } 317} 318 319bool MessageLoop::IsType(Type type) const { 320 return type_ == type; 321} 322 323static void QuitCurrentWhenIdle() { 324 MessageLoop::current()->QuitWhenIdle(); 325} 326 327// static 328Closure MessageLoop::QuitWhenIdleClosure() { 329 return Bind(&QuitCurrentWhenIdle); 330} 331 332void MessageLoop::SetNestableTasksAllowed(bool allowed) { 333 if (allowed) { 334 // Kick the native pump just in case we enter a OS-driven nested message 335 // loop. 336 pump_->ScheduleWork(); 337 } 338 nestable_tasks_allowed_ = allowed; 339} 340 341bool MessageLoop::NestableTasksAllowed() const { 342 return nestable_tasks_allowed_; 343} 344 345bool MessageLoop::IsNested() { 346 return run_loop_->run_depth_ > 1; 347} 348 349void MessageLoop::AddTaskObserver(TaskObserver* task_observer) { 350 DCHECK_EQ(this, current()); 351 task_observers_.AddObserver(task_observer); 352} 353 354void MessageLoop::RemoveTaskObserver(TaskObserver* task_observer) { 355 DCHECK_EQ(this, current()); 356 task_observers_.RemoveObserver(task_observer); 357} 358 359bool MessageLoop::is_running() const { 360 DCHECK_EQ(this, current()); 361 return run_loop_ != NULL; 362} 363 364bool MessageLoop::IsHighResolutionTimerEnabledForTesting() { 365 return incoming_task_queue_->IsHighResolutionTimerEnabledForTesting(); 366} 367 368bool MessageLoop::IsIdleForTesting() { 369 // We only check the imcoming queue|, since we don't want to lock the work 370 // queue. 371 return incoming_task_queue_->IsIdleForTesting(); 372} 373 374//------------------------------------------------------------------------------ 375 376void MessageLoop::Init() { 377 DCHECK(!current()) << "should only have one message loop per thread"; 378 lazy_tls_ptr.Pointer()->Set(this); 379 380 incoming_task_queue_ = new internal::IncomingTaskQueue(this); 381 message_loop_proxy_ = 382 new internal::MessageLoopProxyImpl(incoming_task_queue_); 383 thread_task_runner_handle_.reset( 384 new ThreadTaskRunnerHandle(message_loop_proxy_)); 385} 386 387void MessageLoop::RunHandler() { 388 DCHECK_EQ(this, current()); 389 390 StartHistogrammer(); 391 392#if defined(OS_WIN) 393 if (run_loop_->dispatcher_ && type() == TYPE_UI) { 394 static_cast<MessagePumpForUI*>(pump_.get())-> 395 RunWithDispatcher(this, run_loop_->dispatcher_); 396 return; 397 } 398#endif 399 400 pump_->Run(this); 401} 402 403bool MessageLoop::ProcessNextDelayedNonNestableTask() { 404 if (run_loop_->run_depth_ != 1) 405 return false; 406 407 if (deferred_non_nestable_work_queue_.empty()) 408 return false; 409 410 PendingTask pending_task = deferred_non_nestable_work_queue_.front(); 411 deferred_non_nestable_work_queue_.pop(); 412 413 RunTask(pending_task); 414 return true; 415} 416 417void MessageLoop::RunTask(const PendingTask& pending_task) { 418 tracked_objects::TrackedTime start_time = 419 tracked_objects::ThreadData::NowForStartOfRun(pending_task.birth_tally); 420 421 TRACE_EVENT_FLOW_END1(TRACE_DISABLED_BY_DEFAULT("toplevel.flow"), 422 "MessageLoop::PostTask", TRACE_ID_MANGLE(GetTaskTraceID(pending_task)), 423 "queue_duration", 424 (start_time - pending_task.EffectiveTimePosted()).InMilliseconds()); 425 // When tracing memory for posted tasks it's more valuable to attribute the 426 // memory allocations to the source function than generically to "RunTask". 427 TRACE_EVENT_WITH_MEMORY_TAG2( 428 "toplevel", "MessageLoop::RunTask", 429 pending_task.posted_from.function_name(), // Name for memory tracking. 430 "src_file", pending_task.posted_from.file_name(), 431 "src_func", pending_task.posted_from.function_name()); 432 433 DCHECK(nestable_tasks_allowed_); 434 // Execute the task and assume the worst: It is probably not reentrant. 435 nestable_tasks_allowed_ = false; 436 437 // Before running the task, store the program counter where it was posted 438 // and deliberately alias it to ensure it is on the stack if the task 439 // crashes. Be careful not to assume that the variable itself will have the 440 // expected value when displayed by the optimizer in an optimized build. 441 // Look at a memory dump of the stack. 442 const void* program_counter = 443 pending_task.posted_from.program_counter(); 444 debug::Alias(&program_counter); 445 446 HistogramEvent(kTaskRunEvent); 447 448 FOR_EACH_OBSERVER(TaskObserver, task_observers_, 449 WillProcessTask(pending_task)); 450 pending_task.task.Run(); 451 FOR_EACH_OBSERVER(TaskObserver, task_observers_, 452 DidProcessTask(pending_task)); 453 454 tracked_objects::ThreadData::TallyRunOnNamedThreadIfTracking(pending_task, 455 start_time, tracked_objects::ThreadData::NowForEndOfRun()); 456 457 nestable_tasks_allowed_ = true; 458} 459 460bool MessageLoop::DeferOrRunPendingTask(const PendingTask& pending_task) { 461 if (pending_task.nestable || run_loop_->run_depth_ == 1) { 462 RunTask(pending_task); 463 // Show that we ran a task (Note: a new one might arrive as a 464 // consequence!). 465 return true; 466 } 467 468 // We couldn't run the task now because we're in a nested message loop 469 // and the task isn't nestable. 470 deferred_non_nestable_work_queue_.push(pending_task); 471 return false; 472} 473 474void MessageLoop::AddToDelayedWorkQueue(const PendingTask& pending_task) { 475 // Move to the delayed work queue. 476 delayed_work_queue_.push(pending_task); 477} 478 479bool MessageLoop::DeletePendingTasks() { 480 bool did_work = !work_queue_.empty(); 481 while (!work_queue_.empty()) { 482 PendingTask pending_task = work_queue_.front(); 483 work_queue_.pop(); 484 if (!pending_task.delayed_run_time.is_null()) { 485 // We want to delete delayed tasks in the same order in which they would 486 // normally be deleted in case of any funny dependencies between delayed 487 // tasks. 488 AddToDelayedWorkQueue(pending_task); 489 } 490 } 491 did_work |= !deferred_non_nestable_work_queue_.empty(); 492 while (!deferred_non_nestable_work_queue_.empty()) { 493 deferred_non_nestable_work_queue_.pop(); 494 } 495 did_work |= !delayed_work_queue_.empty(); 496 497 // Historically, we always delete the task regardless of valgrind status. It's 498 // not completely clear why we want to leak them in the loops above. This 499 // code is replicating legacy behavior, and should not be considered 500 // absolutely "correct" behavior. See TODO above about deleting all tasks 501 // when it's safe. 502 while (!delayed_work_queue_.empty()) { 503 delayed_work_queue_.pop(); 504 } 505 return did_work; 506} 507 508uint64 MessageLoop::GetTaskTraceID(const PendingTask& task) { 509 return (static_cast<uint64>(task.sequence_num) << 32) | 510 ((static_cast<uint64>(reinterpret_cast<intptr_t>(this)) << 32) >> 32); 511} 512 513void MessageLoop::ReloadWorkQueue() { 514 // We can improve performance of our loading tasks from the incoming queue to 515 // |*work_queue| by waiting until the last minute (|*work_queue| is empty) to 516 // load. That reduces the number of locks-per-task significantly when our 517 // queues get large. 518 if (work_queue_.empty()) 519 incoming_task_queue_->ReloadWorkQueue(&work_queue_); 520} 521 522void MessageLoop::ScheduleWork(bool was_empty) { 523 // The Android UI message loop needs to get notified each time 524 // a task is added to the incoming queue. 525 if (was_empty || AlwaysNotifyPump(type_)) 526 pump_->ScheduleWork(); 527} 528 529//------------------------------------------------------------------------------ 530// Method and data for histogramming events and actions taken by each instance 531// on each thread. 532 533void MessageLoop::StartHistogrammer() { 534#if !defined(OS_NACL) // NaCl build has no metrics code. 535 if (enable_histogrammer_ && !message_histogram_ 536 && StatisticsRecorder::IsActive()) { 537 DCHECK(!thread_name_.empty()); 538 message_histogram_ = LinearHistogram::FactoryGetWithRangeDescription( 539 "MsgLoop:" + thread_name_, 540 kLeastNonZeroMessageId, kMaxMessageId, 541 kNumberOfDistinctMessagesDisplayed, 542 message_histogram_->kHexRangePrintingFlag, 543 event_descriptions_); 544 } 545#endif 546} 547 548void MessageLoop::HistogramEvent(int event) { 549#if !defined(OS_NACL) 550 if (message_histogram_) 551 message_histogram_->Add(event); 552#endif 553} 554 555bool MessageLoop::DoWork() { 556 if (!nestable_tasks_allowed_) { 557 // Task can't be executed right now. 558 return false; 559 } 560 561 for (;;) { 562 ReloadWorkQueue(); 563 if (work_queue_.empty()) 564 break; 565 566 // Execute oldest task. 567 do { 568 PendingTask pending_task = work_queue_.front(); 569 work_queue_.pop(); 570 if (!pending_task.delayed_run_time.is_null()) { 571 AddToDelayedWorkQueue(pending_task); 572 // If we changed the topmost task, then it is time to reschedule. 573 if (delayed_work_queue_.top().task.Equals(pending_task.task)) 574 pump_->ScheduleDelayedWork(pending_task.delayed_run_time); 575 } else { 576 if (DeferOrRunPendingTask(pending_task)) 577 return true; 578 } 579 } while (!work_queue_.empty()); 580 } 581 582 // Nothing happened. 583 return false; 584} 585 586bool MessageLoop::DoDelayedWork(TimeTicks* next_delayed_work_time) { 587 if (!nestable_tasks_allowed_ || delayed_work_queue_.empty()) { 588 recent_time_ = *next_delayed_work_time = TimeTicks(); 589 return false; 590 } 591 592 // When we "fall behind," there will be a lot of tasks in the delayed work 593 // queue that are ready to run. To increase efficiency when we fall behind, 594 // we will only call Time::Now() intermittently, and then process all tasks 595 // that are ready to run before calling it again. As a result, the more we 596 // fall behind (and have a lot of ready-to-run delayed tasks), the more 597 // efficient we'll be at handling the tasks. 598 599 TimeTicks next_run_time = delayed_work_queue_.top().delayed_run_time; 600 if (next_run_time > recent_time_) { 601 recent_time_ = TimeTicks::Now(); // Get a better view of Now(); 602 if (next_run_time > recent_time_) { 603 *next_delayed_work_time = next_run_time; 604 return false; 605 } 606 } 607 608 PendingTask pending_task = delayed_work_queue_.top(); 609 delayed_work_queue_.pop(); 610 611 if (!delayed_work_queue_.empty()) 612 *next_delayed_work_time = delayed_work_queue_.top().delayed_run_time; 613 614 return DeferOrRunPendingTask(pending_task); 615} 616 617bool MessageLoop::DoIdleWork() { 618 if (ProcessNextDelayedNonNestableTask()) 619 return true; 620 621 if (run_loop_->quit_when_idle_received_) 622 pump_->Quit(); 623 624 return false; 625} 626 627void MessageLoop::GetQueueingInformation(size_t* queue_size, 628 TimeDelta* queueing_delay) { 629 *queue_size = work_queue_.size(); 630 if (*queue_size == 0) { 631 *queueing_delay = TimeDelta(); 632 return; 633 } 634 635 const PendingTask& next_to_run = work_queue_.front(); 636 tracked_objects::Duration duration = 637 tracked_objects::TrackedTime::Now() - next_to_run.EffectiveTimePosted(); 638 *queueing_delay = TimeDelta::FromMilliseconds(duration.InMilliseconds()); 639} 640 641void MessageLoop::DeleteSoonInternal(const tracked_objects::Location& from_here, 642 void(*deleter)(const void*), 643 const void* object) { 644 PostNonNestableTask(from_here, Bind(deleter, object)); 645} 646 647void MessageLoop::ReleaseSoonInternal( 648 const tracked_objects::Location& from_here, 649 void(*releaser)(const void*), 650 const void* object) { 651 PostNonNestableTask(from_here, Bind(releaser, object)); 652} 653 654#if !defined(OS_NACL) 655//------------------------------------------------------------------------------ 656// MessageLoopForUI 657 658#if defined(OS_ANDROID) 659void MessageLoopForUI::Start() { 660 // No Histogram support for UI message loop as it is managed by Java side 661 static_cast<MessagePumpForUI*>(pump_.get())->Start(this); 662} 663#endif 664 665#if defined(OS_IOS) 666void MessageLoopForUI::Attach() { 667 static_cast<MessagePumpUIApplication*>(pump_.get())->Attach(this); 668} 669#endif 670 671#if defined(OS_WIN) 672void MessageLoopForUI::AddObserver(Observer* observer) { 673 static_cast<MessagePumpWin*>(pump_.get())->AddObserver(observer); 674} 675 676void MessageLoopForUI::RemoveObserver(Observer* observer) { 677 static_cast<MessagePumpWin*>(pump_.get())->RemoveObserver(observer); 678} 679#endif // defined(OS_WIN) 680 681#if defined(USE_OZONE) || (defined(OS_CHROMEOS) && !defined(USE_GLIB)) 682bool MessageLoopForUI::WatchFileDescriptor( 683 int fd, 684 bool persistent, 685 MessagePumpLibevent::Mode mode, 686 MessagePumpLibevent::FileDescriptorWatcher *controller, 687 MessagePumpLibevent::Watcher *delegate) { 688 return static_cast<MessagePumpLibevent*>(pump_.get())->WatchFileDescriptor( 689 fd, 690 persistent, 691 mode, 692 controller, 693 delegate); 694} 695#endif 696 697#endif // !defined(OS_NACL) 698 699//------------------------------------------------------------------------------ 700// MessageLoopForIO 701 702#if !defined(OS_NACL) 703void MessageLoopForIO::AddIOObserver( 704 MessageLoopForIO::IOObserver* io_observer) { 705 ToPumpIO(pump_.get())->AddIOObserver(io_observer); 706} 707 708void MessageLoopForIO::RemoveIOObserver( 709 MessageLoopForIO::IOObserver* io_observer) { 710 ToPumpIO(pump_.get())->RemoveIOObserver(io_observer); 711} 712 713#if defined(OS_WIN) 714void MessageLoopForIO::RegisterIOHandler(HANDLE file, IOHandler* handler) { 715 ToPumpIO(pump_.get())->RegisterIOHandler(file, handler); 716} 717 718bool MessageLoopForIO::RegisterJobObject(HANDLE job, IOHandler* handler) { 719 return ToPumpIO(pump_.get())->RegisterJobObject(job, handler); 720} 721 722bool MessageLoopForIO::WaitForIOCompletion(DWORD timeout, IOHandler* filter) { 723 return ToPumpIO(pump_.get())->WaitForIOCompletion(timeout, filter); 724} 725#elif defined(OS_POSIX) 726bool MessageLoopForIO::WatchFileDescriptor(int fd, 727 bool persistent, 728 Mode mode, 729 FileDescriptorWatcher *controller, 730 Watcher *delegate) { 731 return ToPumpIO(pump_.get())->WatchFileDescriptor( 732 fd, 733 persistent, 734 mode, 735 controller, 736 delegate); 737} 738#endif 739 740#endif // !defined(OS_NACL) 741 742} // namespace base 743