bool MiniLoop::DoWork() { for (;;) { ReloadWorkQueue(); if (work_job_.empty()) { break; } do { PendingJob pending_job = work_job_.front(); work_job_.pop(); if (pending_job.delay_run_ticks > 0) { AddToDelayedWorkQueue(pending_job); if (delayed_job_.top().job == pending_job.job) { pump_->ScheduleDelayedWork(pending_job.delay_run_ticks); } } else{ if (DeferOrRunPendingJob(pending_job)) return true; } } while (!work_job_.empty()); } return false; }
bool MessageLoop::DoWork() { //TODO(tangjie): add nestable task process. for (; ;) { ReloadWorkQueue(); if (work_queue_.empty()) { break; } do { PendingTask task = work_queue_.front(); work_queue_.pop(); if (!task.delayed_run_time_.IsNull()) { AddToDelayedQueue(task); // if task is the first one which was pushed into queue. need to schedule delay work. if (delayed_work_queue_.top().sequence_num_ == task.sequence_num_) { pump_->ScheduleDelayWork(task.delayed_run_time_); } }else { if (DeferOrRunPendingTask(task)) { return true; } } }while(!work_queue_.empty()); } return false; }
MessageLoop::~MessageLoop() { assert(this == current()); // 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; } FOR_EACH_OBSERVER(DestructionObserver, destruction_observers_, PreDestroyCurrentMessageLoop()); internal::LocalStorage<MessageLoop>::GetInstance()->Set(nullptr); }