Remove after wakeup logic and replace PumpTask with Fences

third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc

Index: third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc b/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
index a68a4af5b4889e90167140c59ff298f5f6e7d8c2..d57f38f2a5bfa7967b401f7efec7f58c47312d35 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
@@ -50,17 +50,13 @@ TaskQueueImpl::TaskQueueImpl(
     const char* disabled_by_default_tracing_category,
     const char* disabled_by_default_verbose_tracing_category)
     : thread_id_(base::PlatformThread::CurrentId()),
-      any_thread_(task_queue_manager, spec.pump_policy, time_domain),
+      any_thread_(task_queue_manager, time_domain),
       name_(spec.name),
       disabled_by_default_tracing_category_(
           disabled_by_default_tracing_category),
       disabled_by_default_verbose_tracing_category_(
           disabled_by_default_verbose_tracing_category),
-      main_thread_only_(task_queue_manager,
-                        spec.pump_policy,
-                        this,
-                        time_domain),
-      wakeup_policy_(spec.wakeup_policy),
+      main_thread_only_(task_queue_manager, this, time_domain),
       should_monitor_quiescence_(spec.should_monitor_quiescence),
       should_notify_observers_(spec.should_notify_observers),
       should_report_when_execution_blocked_(
@@ -171,10 +167,8 @@ bool TaskQueueImpl::Task::DelayedRunTimeComparatorFn(const Task& a,
 }
 
 TaskQueueImpl::AnyThread::AnyThread(TaskQueueManager* task_queue_manager,
-                                    PumpPolicy pump_policy,
                                     TimeDomain* time_domain)
     : task_queue_manager(task_queue_manager),
-      pump_policy(pump_policy),
       time_domain(time_domain),
       immediate_incoming_queue(&TaskQueueImpl::Task::EnqueueOrderComparatorFn) {
 }
@@ -183,11 +177,9 @@ TaskQueueImpl::AnyThread::~AnyThread() {}
 
 TaskQueueImpl::MainThreadOnly::MainThreadOnly(
     TaskQueueManager* task_queue_manager,
-    PumpPolicy pump_policy,
     TaskQueueImpl* task_queue,
     TimeDomain* time_domain)
     : task_queue_manager(task_queue_manager),
-      pump_policy(pump_policy),
       time_domain(time_domain),
       delayed_work_queue(
           new WorkQueue(task_queue,
@@ -449,8 +441,7 @@ void TaskQueueImpl::PushOntoDelayedIncomingQueueLocked(Task pending_task) {
 void TaskQueueImpl::PushOntoImmediateIncomingQueueLocked(Task pending_task) {
   if (any_thread().immediate_incoming_queue.empty())
     any_thread().time_domain->RegisterAsUpdatableTaskQueue(this);
-  if (any_thread().pump_policy == PumpPolicy::AUTO &&
-      any_thread().immediate_incoming_queue.empty()) {
+  if (any_thread().immediate_incoming_queue.empty()) {

[Sami, 2016/08/25 15:54:12]

I was trying to work out if we get extra DoWorks because of this -- probably
not?

nit: Could remove the braces too.

[alex clarke (OOO till 29th), 2016/08/26 13:29:08]

As discussed offline we can avoid posting DoWorks for disabled queues.

     any_thread().task_queue_manager->MaybeScheduleImmediateWork(FROM_HERE);
   }
   any_thread().task_queue_manager->DidQueueTask(pending_task);
@@ -511,86 +502,23 @@ bool TaskQueueImpl::IsEmpty() const {
 }
 
 bool TaskQueueImpl::HasPendingImmediateWork() const {
+  // Any work queue tasks count as immediate work.
   if (!main_thread_only().delayed_work_queue->Empty() ||
       !main_thread_only().immediate_work_queue->Empty()) {
     return true;
   }
 
-  return NeedsPumping();
-}
-
-bool TaskQueueImpl::NeedsPumping() const {
-  if (!main_thread_only().immediate_work_queue->Empty())
-    return false;
-
-  base::AutoLock lock(any_thread_lock_);
-  if (!any_thread().immediate_incoming_queue.empty())
-    return true;
-
-  // If there's no immediate Incoming work then we only need pumping if there
-  // is a delayed task that should be running now.
-  if (main_thread_only().delayed_incoming_queue.empty())
-    return false;
-
-  return main_thread_only().delayed_incoming_queue.begin()->delayed_run_time <=
-         main_thread_only().time_domain->CreateLazyNow().Now();
-}
-
-bool TaskQueueImpl::TaskIsOlderThanQueuedImmediateTasksLocked(
-    const Task* task) {
-  // A null task is passed when UpdateQueue is called before any task is run.
-  // In this case we don't want to pump an after_wakeup queue, so return true
-  // here.
-  if (!task)
+  // Tasks on |delayed_incoming_queue| that could run now, count as
+  // immediate work.
+  if (!main_thread_only().delayed_incoming_queue.empty() &&
+      main_thread_only().delayed_incoming_queue.begin()->delayed_run_time <=
+          main_thread_only().time_domain->CreateLazyNow().Now()) {
     return true;
-
-  // Return false if task is newer than the oldest immediate task.
-  if (!any_thread().immediate_incoming_queue.empty() &&
-      task->enqueue_order() >
-          any_thread().immediate_incoming_queue.begin()->enqueue_order()) {
-    return false;
   }
-  return true;
-}
-
-bool TaskQueueImpl::TaskIsOlderThanQueuedDelayedTasks(const Task* task) {
-  DCHECK(main_thread_checker_.CalledOnValidThread());
-  // A null task is passed when UpdateQueue is called before any task is run.
-  // In this case we don't want to pump an after_wakeup queue, so return true
-  // here.
-  if (!task)
-    return true;
 
-  EnqueueOrder enqueue_order;
-  if (!main_thread_only().delayed_work_queue->GetFrontTaskEnqueueOrder(
-          &enqueue_order)) {
-    return true;
-  }
-
-  return task->enqueue_order() < enqueue_order;
-}
-
-bool TaskQueueImpl::ShouldAutoPumpImmediateQueueLocked(
-    bool should_trigger_wakeup,
-    const Task* previous_task) {
-  if (main_thread_only().pump_policy == PumpPolicy::MANUAL)
-    return false;
-  if (main_thread_only().pump_policy == PumpPolicy::AFTER_WAKEUP &&
-      (!should_trigger_wakeup ||
-       TaskIsOlderThanQueuedImmediateTasksLocked(previous_task)))
-    return false;
-  return true;
-}
-
-bool TaskQueueImpl::ShouldAutoPumpDelayedQueue(bool should_trigger_wakeup,
-                                               const Task* previous_task) {
-  if (main_thread_only().pump_policy == PumpPolicy::MANUAL)
-    return false;
-  if (main_thread_only().pump_policy == PumpPolicy::AFTER_WAKEUP &&
-      (!should_trigger_wakeup ||
-       TaskIsOlderThanQueuedDelayedTasks(previous_task)))
-    return false;
-  return true;
+  // Finally tasks on |immediate_incoming_queue| count as immediate work.
+  base::AutoLock lock(any_thread_lock_);
+  return !any_thread().immediate_incoming_queue.empty();
 }
 
 void TaskQueueImpl::MoveReadyDelayedTasksToDelayedWorkQueue(LazyNow* lazy_now) {
@@ -609,25 +537,18 @@ void TaskQueueImpl::MoveReadyDelayedTasksToDelayedWorkQueue(LazyNow* lazy_now) {
   }
 }
 
-void TaskQueueImpl::UpdateDelayedWorkQueue(LazyNow* lazy_now,
-                                           bool should_trigger_wakeup,
-                                           const Task* previous_task) {
+void TaskQueueImpl::UpdateDelayedWorkQueue(LazyNow* lazy_now) {
   if (!main_thread_only().task_queue_manager)
     return;
-  if (!ShouldAutoPumpDelayedQueue(should_trigger_wakeup, previous_task))
-    return;
   MoveReadyDelayedTasksToDelayedWorkQueue(lazy_now);
   TraceQueueSize(false);
 }
 
-void TaskQueueImpl::UpdateImmediateWorkQueue(bool should_trigger_wakeup,
-                                             const Task* previous_task) {
+void TaskQueueImpl::UpdateImmediateWorkQueue() {
   DCHECK(main_thread_only().immediate_work_queue->Empty());
   base::AutoLock lock(any_thread_lock_);
   if (!main_thread_only().task_queue_manager)
     return;
-  if (!ShouldAutoPumpImmediateQueueLocked(should_trigger_wakeup, previous_task))
-    return;
 
   main_thread_only().immediate_work_queue->SwapLocked(
       any_thread().immediate_incoming_queue);
@@ -663,56 +584,6 @@ void TaskQueueImpl::TraceQueueSize(bool is_locked) const {
     any_thread_lock_.Release();
 }
 
-void TaskQueueImpl::SetPumpPolicy(PumpPolicy pump_policy) {
-  base::AutoLock lock(any_thread_lock_);
-  if (pump_policy == PumpPolicy::AUTO &&
-      any_thread().pump_policy != PumpPolicy::AUTO) {
-    LazyNow lazy_now(main_thread_only().time_domain->CreateLazyNow());
-    PumpQueueLocked(&lazy_now, true);
-  }
-  any_thread().pump_policy = pump_policy;
-  main_thread_only().pump_policy = pump_policy;
-}
-
-TaskQueue::PumpPolicy TaskQueueImpl::GetPumpPolicy() const {
-  return main_thread_only().pump_policy;
-}
-
-void TaskQueueImpl::PumpQueueLocked(LazyNow* lazy_now, bool may_post_dowork) {
-  TRACE_EVENT1(disabled_by_default_tracing_category_,
-               "TaskQueueImpl::PumpQueueLocked", "queue", name_);
-  TaskQueueManager* task_queue_manager = any_thread().task_queue_manager;
-  if (!task_queue_manager)
-    return;
-
-  MoveReadyDelayedTasksToDelayedWorkQueue(lazy_now);
-
-  while (!any_thread().immediate_incoming_queue.empty()) {
-    ComparatorQueue::iterator it =
-        any_thread().immediate_incoming_queue.begin();
-    main_thread_only().immediate_work_queue->Push(
-        std::move(const_cast<Task&>(*it)));
-    any_thread().immediate_incoming_queue.erase(it);
-  }
-
-  // |immediate_incoming_queue| is now empty so TimeDomain::UpdateQueues no
-  // longer needs to consider this queue for reloading.
-  main_thread_only().time_domain->UnregisterAsUpdatableTaskQueue(this);
-
-  if (main_thread_only().immediate_work_queue->Empty() &&
-      main_thread_only().delayed_work_queue->Empty()) {
-    return;
-  }
-
-  if (may_post_dowork)
-    task_queue_manager->MaybeScheduleImmediateWork(FROM_HERE);
-}
-
-void TaskQueueImpl::PumpQueue(LazyNow* lazy_now, bool may_post_dowork) {
-  base::AutoLock lock(any_thread_lock_);
-  PumpQueueLocked(lazy_now, may_post_dowork);
-}
-
 const char* TaskQueueImpl::GetName() const {
   return name_;
 }
@@ -731,36 +602,6 @@ TaskQueueImpl::QueuePriority TaskQueueImpl::GetQueuePriority() const {
 }
 
 // static
-const char* TaskQueueImpl::PumpPolicyToString(
-    TaskQueue::PumpPolicy pump_policy) {
-  switch (pump_policy) {
-    case TaskQueue::PumpPolicy::AUTO:
-      return "auto";
-    case TaskQueue::PumpPolicy::AFTER_WAKEUP:
-      return "after_wakeup";
-    case TaskQueue::PumpPolicy::MANUAL:
-      return "manual";
-    default:
-      NOTREACHED();
-      return nullptr;
-  }
-}
-
-// static
-const char* TaskQueueImpl::WakeupPolicyToString(
-    TaskQueue::WakeupPolicy wakeup_policy) {
-  switch (wakeup_policy) {
-    case TaskQueue::WakeupPolicy::CAN_WAKE_OTHER_QUEUES:
-      return "can_wake_other_queues";
-    case TaskQueue::WakeupPolicy::DONT_WAKE_OTHER_QUEUES:
-      return "dont_wake_other_queues";
-    default:
-      NOTREACHED();
-      return nullptr;
-  }
-}
-
-// static
 const char* TaskQueueImpl::PriorityToString(QueuePriority priority) {
   switch (priority) {
     case CONTROL_PRIORITY:
@@ -784,8 +625,6 @@ void TaskQueueImpl::AsValueInto(base::trace_event::TracedValue* state) const {
   state->SetBoolean("enabled", main_thread_only().is_enabled);
   state->SetString("time_domain_name",
                    main_thread_only().time_domain->GetName());
-  state->SetString("pump_policy", PumpPolicyToString(any_thread().pump_policy));
-  state->SetString("wakeup_policy", WakeupPolicyToString(wakeup_policy_));
   bool verbose_tracing_enabled = false;
   TRACE_EVENT_CATEGORY_GROUP_ENABLED(
       disabled_by_default_verbose_tracing_category_, &verbose_tracing_enabled);