MessageLoop mischief

base/message_loop/message_loop.cc

 // Copyright 2013 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/message_loop.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 372 matching lines @@
   DCHECK_EQ(this, current());
   DCHECK(run_loop_);
   CHECK(allow_nesting_ || run_loop_->run_depth_ == 1);
   pump_->Run(this);
 }
 
 bool MessageLoop::ProcessNextDelayedNonNestableTask() {
   if (run_loop_->run_depth_ != 1)
     return false;
 
-  if (deferred_non_nestable_work_queue_.empty())
-    return false;
+  while (!deferred_non_nestable_work_queue_.empty()) {
+    PendingTask pending_task =
+        std::move(deferred_non_nestable_work_queue_.front());
+    deferred_non_nestable_work_queue_.pop();
 
-  PendingTask pending_task =
-      std::move(deferred_non_nestable_work_queue_.front());
-  deferred_non_nestable_work_queue_.pop();
+    if (pending_task.task.IsCancelled()) {
+#if defined(OS_WIN)
+      if (pending_task.is_high_res) {
+        pending_high_res_tasks_--;
+        CHECK_GE(pending_high_res_tasks_, 0);
+      }
+#endif
+      continue;
+    }
 
-  RunTask(&pending_task);
-  return true;
+    RunTask(&pending_task);
+    return true;
+  }
+
+  return false;
 }
 
 void MessageLoop::RunTask(PendingTask* pending_task) {
   DCHECK(nestable_tasks_allowed_);
 
 #if defined(OS_WIN)
   if (pending_task->is_high_res) {
     pending_high_res_tasks_--;
     CHECK_GE(pending_high_res_tasks_, 0);
   }
@@ skipping 25 matching lines @@
   // and the task isn't nestable.
   deferred_non_nestable_work_queue_.push(std::move(pending_task));
   return false;
 }
 
 void MessageLoop::AddToDelayedWorkQueue(PendingTask pending_task) {
   // Move to the delayed work queue.
   delayed_work_queue_.push(std::move(pending_task));
 }
 
+bool MessageLoop::SweepDelayedWorkQueue() {
+  DCHECK(!delayed_work_queue_.empty());
+
+  do {
+    const auto& pending_task = delayed_work_queue_.top();
+    if (pending_task.task.IsCancelled()) {
+#if defined(OS_WIN)
+      if (pending_task.is_high_res) {
+        pending_high_res_tasks_--;
+        CHECK_GE(pending_high_res_tasks_, 0);
+      }
+#endif
+      delayed_work_queue_.pop();
+      continue;
+    } else {
+      return false;
+    }
+  } while (!delayed_work_queue_.empty());
+
+  return true;
+}
+
 bool MessageLoop::DeletePendingTasks() {
   bool did_work = !work_queue_.empty();
   while (!work_queue_.empty()) {
     PendingTask pending_task = std::move(work_queue_.front());
     work_queue_.pop();
     if (!pending_task.delayed_run_time.is_null()) {
       // We want to delete delayed tasks in the same order in which they would
       // normally be deleted in case of any funny dependencies between delayed
       // tasks.
       AddToDelayedWorkQueue(std::move(pending_task));
@@ skipping 48 matching lines @@
 
   for (;;) {
     ReloadWorkQueue();
     if (work_queue_.empty())
       break;
 
     // Execute oldest task.
     do {
       PendingTask pending_task = std::move(work_queue_.front());
       work_queue_.pop();
+
+      if (pending_task.task.IsCancelled()) {
+#if defined(OS_WIN)
+        if (pending_task.is_high_res) {
+          pending_high_res_tasks_--;
+          CHECK_GE(pending_high_res_tasks_, 0);
+        }
+#endif
+        continue;
+      }
+
       if (!pending_task.delayed_run_time.is_null()) {
         int sequence_num = pending_task.sequence_num;
         TimeTicks delayed_run_time = pending_task.delayed_run_time;
         AddToDelayedWorkQueue(std::move(pending_task));
         // If we changed the topmost task, then it is time to reschedule.
         if (delayed_work_queue_.top().sequence_num == sequence_num)
           pump_->ScheduleDelayedWork(delayed_run_time);
       } else {
         if (DeferOrRunPendingTask(std::move(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()) {
+  if (!nestable_tasks_allowed_ || delayed_work_queue_.empty() ||
+      SweepDelayedWorkQueue()) {
     recent_time_ = *next_delayed_work_time = TimeTicks();
     return false;
   }
 
   // When we "fall behind", there will be a lot of tasks in the delayed work
   // queue that are ready to run.  To increase efficiency when we fall behind,
   // we will only call Time::Now() intermittently, and then process all tasks
   // that are ready to run before calling it again.  As a result, the more we
   // fall behind (and have a lot of ready-to-run delayed tasks), the more
   // efficient we'll be at handling the tasks.
 
   TimeTicks next_run_time = delayed_work_queue_.top().delayed_run_time;
   if (next_run_time > recent_time_) {
     recent_time_ = TimeTicks::Now();  // Get a better view of Now();
     if (next_run_time > recent_time_) {
       *next_delayed_work_time = next_run_time;
       return false;
     }
   }
 
   PendingTask pending_task =
       std::move(const_cast<PendingTask&>(delayed_work_queue_.top()));
   delayed_work_queue_.pop();
 
-  if (!delayed_work_queue_.empty())
+  bool did_work = DeferOrRunPendingTask(std::move(pending_task));
+
+  if (!delayed_work_queue_.empty() && !SweepDelayedWorkQueue())
     *next_delayed_work_time = delayed_work_queue_.top().delayed_run_time;
 
-  return DeferOrRunPendingTask(std::move(pending_task));
+  return did_work;
 }
 
 bool MessageLoop::DoIdleWork() {
   if (ProcessNextDelayedNonNestableTask())
     return true;
 
   if (run_loop_->quit_when_idle_received_)
     pump_->Quit();
 
   // When we return we will do a kernel wait for more tasks.
@@ skipping 89 matching lines @@
       persistent,
       mode,
       controller,
       delegate);
 }
 #endif
 
 #endif  // !defined(OS_NACL_SFI)
 
 }  // namespace base