The Tor Browser: ipc/chromium/src/base/message_loop.cc@6474c204b198 (annotated)

ipc/chromium/src/base/message_loop.cc@6474c204b198 (annotated)

ipc/chromium/src/base/message_loop.cc

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 // 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

The Tor Browser / annotate

ipc/chromium/src/base/message_loop.cc@6474c204b198 (annotated)

ipc/chromium/src/base/message_loop.cc