The Tor Browser / file revision

 // Copyright (c) 2009 The Chromium Authors. All rights reserved.

 // Use of this source code is governed by a BSD-style license that can be

 // found in the LICENSE file.

 #include "base/message_loop.h"

 #include <algorithm>

 #include "mozilla/Atomics.h"

 #include "base/compiler_specific.h"

 #include "base/lazy_instance.h"

 #include "base/logging.h"

 #include "base/message_pump_default.h"

 #include "base/string_util.h"

 #include "base/thread_local.h"

 #if defined(OS_MACOSX)

 #include "base/message_pump_mac.h"

 #endif

 #if defined(OS_POSIX)

 #include "base/message_pump_libevent.h"

 #endif

 #if defined(OS_LINUX) || defined(OS_BSD)

 #if defined(MOZ_WIDGET_GTK)

 #include "base/message_pump_glib.h"

 #endif

 #ifdef MOZ_WIDGET_QT

 #include "base/message_pump_qt.h"

 #endif

 #endif

 #ifdef ANDROID

 #include "base/message_pump_android.h"

 #endif

 #ifdef MOZ_TASK_TRACER

 #include "GeckoTaskTracer.h"

 #endif

 #include "MessagePump.h"

 using base::Time;

 using base::TimeDelta;

 using base::TimeTicks;

 // A lazily created thread local storage for quick access to a thread's message

 // loop, if one exists.  This should be safe and free of static constructors.

 static base::LazyInstance<base::ThreadLocalPointer<MessageLoop> > lazy_tls_ptr(

     base::LINKER_INITIALIZED);

 //------------------------------------------------------------------------------

 // Logical events for Histogram profiling. Run with -message-loop-histogrammer

 // to get an accounting of messages and actions taken on each thread.

 static const int kTaskRunEvent = 0x1;

 static const int kTimerEvent = 0x2;

 // Provide range of message IDs for use in histogramming and debug display.

 static const int kLeastNonZeroMessageId = 1;

 static const int kMaxMessageId = 1099;

 static const int kNumberOfDistinctMessagesDisplayed = 1100;

 //------------------------------------------------------------------------------

 #if defined(OS_WIN)

 // Upon a SEH exception in this thread, it restores the original unhandled

 // exception filter.

 static int SEHFilter(LPTOP_LEVEL_EXCEPTION_FILTER old_filter) {

   ::SetUnhandledExceptionFilter(old_filter);

   return EXCEPTION_CONTINUE_SEARCH;

 }

 // Retrieves a pointer to the current unhandled exception filter. There

 // is no standalone getter method.

 static LPTOP_LEVEL_EXCEPTION_FILTER GetTopSEHFilter() {

   LPTOP_LEVEL_EXCEPTION_FILTER top_filter = NULL;

   top_filter = ::SetUnhandledExceptionFilter(0);

   ::SetUnhandledExceptionFilter(top_filter);

   return top_filter;

 }

 #endif  // defined(OS_WIN)

 //------------------------------------------------------------------------------

 // static

 MessageLoop* MessageLoop::current() {

   // TODO(darin): sadly, we cannot enable this yet since people call us even

   // when they have no intention of using us.

   //DCHECK(loop) << "Ouch, did you forget to initialize me?";

   return lazy_tls_ptr.Pointer()->Get();

 }

 static mozilla::Atomic<int32_t> message_loop_id_seq(0);

 MessageLoop::MessageLoop(Type type)

     : type_(type),

       id_(++message_loop_id_seq),

       nestable_tasks_allowed_(true),

       exception_restoration_(false),

       state_(NULL),

       run_depth_base_(1),

 #ifdef OS_WIN

       os_modal_loop_(false),

 #endif  // OS_WIN

       transient_hang_timeout_(0),

       permanent_hang_timeout_(0),

       next_sequence_num_(0) {

   DCHECK(!current()) << "should only have one message loop per thread";

   lazy_tls_ptr.Pointer()->Set(this);

   if (type_ == TYPE_MOZILLA_UI) {

     pump_ = new mozilla::ipc::MessagePump();

     return;

   }

   if (type_ == TYPE_MOZILLA_CHILD) {

     pump_ = new mozilla::ipc::MessagePumpForChildProcess();

     // There is a MessageLoop Run call from XRE_InitChildProcess

     // and another one from MessagePumpForChildProcess. The one

     // from MessagePumpForChildProcess becomes the base, so we need

     // to set run_depth_base_ to 2 or we'll never be able to process

     // Idle tasks.

     run_depth_base_ = 2;

     return;

   }

   if (type_ == TYPE_MOZILLA_NONMAINTHREAD) {

     pump_ = new mozilla::ipc::MessagePumpForNonMainThreads();

     return;

   }

 #if defined(OS_WIN)

   // TODO(rvargas): Get rid of the OS guards.

   if (type_ == TYPE_DEFAULT) {

     pump_ = new base::MessagePumpDefault();

   } else if (type_ == TYPE_IO) {

     pump_ = new base::MessagePumpForIO();

   } else {

     DCHECK(type_ == TYPE_UI);

     pump_ = new base::MessagePumpForUI();

   }

 #elif defined(OS_POSIX)

   if (type_ == TYPE_UI) {

 #if defined(OS_MACOSX)

     pump_ = base::MessagePumpMac::Create();

 #elif defined(OS_LINUX) || defined(OS_BSD)

     pump_ = new base::MessagePumpForUI();

 #endif  // OS_LINUX

   } else if (type_ == TYPE_IO) {

     pump_ = new base::MessagePumpLibevent();

   } else {

     pump_ = new base::MessagePumpDefault();

   }

 #endif  // OS_POSIX

 }

 MessageLoop::~MessageLoop() {

   DCHECK(this == current());

   // Let interested parties have one last shot at accessing this.

   FOR_EACH_OBSERVER(DestructionObserver, destruction_observers_,

                     WillDestroyCurrentMessageLoop());

   DCHECK(!state_);

   // Clean up any unprocessed tasks, but take care: deleting a task could

   // result in the addition of more tasks (e.g., via DeleteSoon).  We set a

   // limit on the number of times we will allow a deleted task to generate more

   // tasks.  Normally, we should only pass through this loop once or twice.  If

   // we end up hitting the loop limit, then it is probably due to one task that

   // is being stubborn.  Inspect the queues to see who is left.

   bool did_work;

   for (int i = 0; i < 100; ++i) {

     DeletePendingTasks();

     ReloadWorkQueue();

     // If we end up with empty queues, then break out of the loop.

     did_work = DeletePendingTasks();

     if (!did_work)

       break;

   }

   DCHECK(!did_work);

   // OK, now make it so that no one can find us.

   lazy_tls_ptr.Pointer()->Set(NULL);

 }

 void MessageLoop::AddDestructionObserver(DestructionObserver *obs) {

   DCHECK(this == current());

   destruction_observers_.AddObserver(obs);

 }

 void MessageLoop::RemoveDestructionObserver(DestructionObserver *obs) {

   DCHECK(this == current());

   destruction_observers_.RemoveObserver(obs);

 }

 void MessageLoop::Run() {

   AutoRunState save_state(this);

   RunHandler();

 }

 void MessageLoop::RunAllPending() {

   AutoRunState save_state(this);

   state_->quit_received = true;  // Means run until we would otherwise block.

   RunHandler();

 }

 // Runs the loop in two different SEH modes:

 // enable_SEH_restoration_ = false : any unhandled exception goes to the last

 // one that calls SetUnhandledExceptionFilter().

 // enable_SEH_restoration_ = true : any unhandled exception goes to the filter

 // that was existed before the loop was run.

 void MessageLoop::RunHandler() {

 #if defined(OS_WIN)

   if (exception_restoration_) {

     LPTOP_LEVEL_EXCEPTION_FILTER current_filter = GetTopSEHFilter();

     MOZ_SEH_TRY {

       RunInternal();

     } MOZ_SEH_EXCEPT(SEHFilter(current_filter)) {

     }

     return;

   }

 #endif

   RunInternal();

 }

 //------------------------------------------------------------------------------

 void MessageLoop::RunInternal() {

   DCHECK(this == current());

   pump_->Run(this);

 }

 //------------------------------------------------------------------------------

 // Wrapper functions for use in above message loop framework.

 bool MessageLoop::ProcessNextDelayedNonNestableTask() {

   if (state_->run_depth > run_depth_base_)

     return false;

   if (deferred_non_nestable_work_queue_.empty())

     return false;

   Task* task = deferred_non_nestable_work_queue_.front().task;

   deferred_non_nestable_work_queue_.pop();

   RunTask(task);

   return true;

 }

 //------------------------------------------------------------------------------

 void MessageLoop::Quit() {

   DCHECK(current() == this);

   if (state_) {

     state_->quit_received = true;

   } else {

     NOTREACHED() << "Must be inside Run to call Quit";

   }

 }

 void MessageLoop::PostTask(

     const tracked_objects::Location& from_here, Task* task) {

   PostTask_Helper(from_here, task, 0, true);

 }

 void MessageLoop::PostDelayedTask(

     const tracked_objects::Location& from_here, Task* task, int delay_ms) {

   PostTask_Helper(from_here, task, delay_ms, true);

 }

 void MessageLoop::PostNonNestableTask(

     const tracked_objects::Location& from_here, Task* task) {

   PostTask_Helper(from_here, task, 0, false);

 }

 void MessageLoop::PostNonNestableDelayedTask(

     const tracked_objects::Location& from_here, Task* task, int delay_ms) {

   PostTask_Helper(from_here, task, delay_ms, false);

 }

 void MessageLoop::PostIdleTask(

     const tracked_objects::Location& from_here, Task* task) {

   DCHECK(current() == this);

 #ifdef MOZ_TASK_TRACER

   task = mozilla::tasktracer::CreateTracedTask(task);

 #endif

   task->SetBirthPlace(from_here);

   PendingTask pending_task(task, false);

   deferred_non_nestable_work_queue_.push(pending_task);

 }

 // Possibly called on a background thread!

 void MessageLoop::PostTask_Helper(

     const tracked_objects::Location& from_here, Task* task, int delay_ms,

     bool nestable) {

 #ifdef MOZ_TASK_TRACER

   task = mozilla::tasktracer::CreateTracedTask(task);

 #endif

   task->SetBirthPlace(from_here);

   PendingTask pending_task(task, nestable);

   if (delay_ms > 0) {

     pending_task.delayed_run_time =

         TimeTicks::Now() + TimeDelta::FromMilliseconds(delay_ms);

   } else {

     DCHECK(delay_ms == 0) << "delay should not be negative";

   }

   // Warning: Don't try to short-circuit, and handle this thread's tasks more

   // directly, as it could starve handling of foreign threads.  Put every task

   // into this queue.

   scoped_refptr<base::MessagePump> pump;

   {

     AutoLock locked(incoming_queue_lock_);

     incoming_queue_.push(pending_task);

     pump = pump_;

   }

   // Since the incoming_queue_ may contain a task that destroys this message

   // loop, we cannot exit incoming_queue_lock_ until we are done with |this|.

   // We use a stack-based reference to the message pump so that we can call

   // ScheduleWork outside of incoming_queue_lock_.

   pump->ScheduleWork();

 }

 void MessageLoop::SetNestableTasksAllowed(bool allowed) {

   if (nestable_tasks_allowed_ != allowed) {

     nestable_tasks_allowed_ = allowed;

     if (!nestable_tasks_allowed_)

       return;

     // Start the native pump if we are not already pumping.

     pump_->ScheduleWorkForNestedLoop();

   }

 }

 void MessageLoop::ScheduleWork() {

   // Start the native pump if we are not already pumping.

   pump_->ScheduleWork();

 }

 bool MessageLoop::NestableTasksAllowed() const {

   return nestable_tasks_allowed_;

 }

 //------------------------------------------------------------------------------

 void MessageLoop::RunTask(Task* task) {

   DCHECK(nestable_tasks_allowed_);

   // Execute the task and assume the worst: It is probably not reentrant.

   nestable_tasks_allowed_ = false;

   task->Run();

   delete task;

   nestable_tasks_allowed_ = true;

 }

 bool MessageLoop::DeferOrRunPendingTask(const PendingTask& pending_task) {

   if (pending_task.nestable || state_->run_depth <= run_depth_base_) {

     RunTask(pending_task.task);

     // Show that we ran a task (Note: a new one might arrive as a

     // consequence!).

     return true;

   }

   // We couldn't run the task now because we're in a nested message loop

   // and the task isn't nestable.

   deferred_non_nestable_work_queue_.push(pending_task);

   return false;

 }

 void MessageLoop::AddToDelayedWorkQueue(const PendingTask& pending_task) {

   // Move to the delayed work queue.  Initialize the sequence number

   // before inserting into the delayed_work_queue_.  The sequence number

   // is used to faciliate FIFO sorting when two tasks have the same

   // delayed_run_time value.

   PendingTask new_pending_task(pending_task);

   new_pending_task.sequence_num = next_sequence_num_++;

   delayed_work_queue_.push(new_pending_task);

 }

 void MessageLoop::ReloadWorkQueue() {

   // We can improve performance of our loading tasks from incoming_queue_ to

   // work_queue_ by waiting until the last minute (work_queue_ is empty) to

   // load.  That reduces the number of locks-per-task significantly when our

   // queues get large.

   if (!work_queue_.empty())

     return;  // Wait till we *really* need to lock and load.

   // Acquire all we can from the inter-thread queue with one lock acquisition.

   {

     AutoLock lock(incoming_queue_lock_);

     if (incoming_queue_.empty())

       return;

     std::swap(incoming_queue_, work_queue_);

     DCHECK(incoming_queue_.empty());

   }

 }

 bool MessageLoop::DeletePendingTasks() {

   MOZ_ASSERT(work_queue_.empty());

   bool did_work = !deferred_non_nestable_work_queue_.empty();

   while (!deferred_non_nestable_work_queue_.empty()) {

     Task* task = deferred_non_nestable_work_queue_.front().task;

     deferred_non_nestable_work_queue_.pop();

     delete task;

   }

   did_work |= !delayed_work_queue_.empty();

   while (!delayed_work_queue_.empty()) {

     Task* task = delayed_work_queue_.top().task;

     delayed_work_queue_.pop();

     delete task;

   }

   return did_work;

 }

 bool MessageLoop::DoWork() {

   if (!nestable_tasks_allowed_) {

     // Task can't be executed right now.

     return false;

   }

   for (;;) {

     ReloadWorkQueue();

     if (work_queue_.empty())

       break;

     // Execute oldest task.

     do {

       PendingTask pending_task = work_queue_.front();

       work_queue_.pop();

       if (!pending_task.delayed_run_time.is_null()) {

         AddToDelayedWorkQueue(pending_task);

         // If we changed the topmost task, then it is time to re-schedule.

         if (delayed_work_queue_.top().task == pending_task.task)

           pump_->ScheduleDelayedWork(pending_task.delayed_run_time);

       } else {

         if (DeferOrRunPendingTask(pending_task))

           return true;

       }

     } while (!work_queue_.empty());

   }

   // Nothing happened.

   return false;

 }

 bool MessageLoop::DoDelayedWork(TimeTicks* next_delayed_work_time) {

   if (!nestable_tasks_allowed_ || delayed_work_queue_.empty()) {

     *next_delayed_work_time = TimeTicks();

     return false;

   }

   if (delayed_work_queue_.top().delayed_run_time > TimeTicks::Now()) {

     *next_delayed_work_time = delayed_work_queue_.top().delayed_run_time;

     return false;

   }

   PendingTask pending_task = delayed_work_queue_.top();

   delayed_work_queue_.pop();

   if (!delayed_work_queue_.empty())

     *next_delayed_work_time = delayed_work_queue_.top().delayed_run_time;

   return DeferOrRunPendingTask(pending_task);

 }

 bool MessageLoop::DoIdleWork() {

   if (ProcessNextDelayedNonNestableTask())

     return true;

   if (state_->quit_received)

     pump_->Quit();

   return false;

 }

 //------------------------------------------------------------------------------

 // MessageLoop::AutoRunState

 MessageLoop::AutoRunState::AutoRunState(MessageLoop* loop) : loop_(loop) {

   // Make the loop reference us.

   previous_state_ = loop_->state_;

   if (previous_state_) {

     run_depth = previous_state_->run_depth + 1;

   } else {

     run_depth = 1;

   }

   loop_->state_ = this;

   // Initialize the other fields:

   quit_received = false;

 #if defined(OS_WIN)

   dispatcher = NULL;

 #endif

 }

 MessageLoop::AutoRunState::~AutoRunState() {

   loop_->state_ = previous_state_;

 }

 //------------------------------------------------------------------------------

 // MessageLoop::PendingTask

 bool MessageLoop::PendingTask::operator<(const PendingTask& other) const {

   // Since the top of a priority queue is defined as the "greatest" element, we

   // need to invert the comparison here.  We want the smaller time to be at the

   // top of the heap.

   if (delayed_run_time < other.delayed_run_time)

     return false;

   if (delayed_run_time > other.delayed_run_time)

     return true;

   // If the times happen to match, then we use the sequence number to decide.

   // Compare the difference to support integer roll-over.

   return (sequence_num - other.sequence_num) > 0;

 }

 //------------------------------------------------------------------------------

 // MessageLoopForUI

 #if defined(OS_WIN)

 void MessageLoopForUI::Run(Dispatcher* dispatcher) {

   AutoRunState save_state(this);

   state_->dispatcher = dispatcher;

   RunHandler();

 }

 void MessageLoopForUI::AddObserver(Observer* observer) {

   pump_win()->AddObserver(observer);

 }

 void MessageLoopForUI::RemoveObserver(Observer* observer) {

   pump_win()->RemoveObserver(observer);

 }

 void MessageLoopForUI::WillProcessMessage(const MSG& message) {

   pump_win()->WillProcessMessage(message);

 }

 void MessageLoopForUI::DidProcessMessage(const MSG& message) {

   pump_win()->DidProcessMessage(message);

 }

 void MessageLoopForUI::PumpOutPendingPaintMessages() {

   pump_ui()->PumpOutPendingPaintMessages();

 }

 #endif  // defined(OS_WIN)

 //------------------------------------------------------------------------------

 // MessageLoopForIO

 #if defined(OS_WIN)

 void MessageLoopForIO::RegisterIOHandler(HANDLE file, IOHandler* handler) {

   pump_io()->RegisterIOHandler(file, handler);

 }

 bool MessageLoopForIO::WaitForIOCompletion(DWORD timeout, IOHandler* filter) {

   return pump_io()->WaitForIOCompletion(timeout, filter);

 }

 #elif defined(OS_POSIX)

 bool MessageLoopForIO::WatchFileDescriptor(int fd,

                                            bool persistent,

                                            Mode mode,

                                            FileDescriptorWatcher *controller,

                                            Watcher *delegate) {

   return pump_libevent()->WatchFileDescriptor(

       fd,

       persistent,

       static_cast<base::MessagePumpLibevent::Mode>(mode),

       controller,

       delegate);

 }

 bool

 MessageLoopForIO::CatchSignal(int sig,

                               SignalEvent* sigevent,

                               SignalWatcher* delegate)

 {

   return pump_libevent()->CatchSignal(sig, sigevent, delegate);

 }

 #endif