Remove SchedulerWorkerPoolImpl::ReEnqueueSequenceCallback.

base/task_scheduler/scheduler_worker_pool_impl.cc

 // Copyright 2016 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/task_scheduler/scheduler_worker_pool_impl.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 125 matching lines @@
                            return i.get() == worker;
                          });
   return it != workers.end();
 }
 
 }  // namespace
 
 class SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl
     : public SchedulerWorker::Delegate {
  public:
-  // |outer| owns the worker for which this delegate is constructed.
-  // |re_enqueue_sequence_callback| is invoked when ReEnqueueSequence() is
-  // called. |index| will be appended to the pool name to label the underlying
-  // worker threads.
+  // |outer| owns the worker for which this delegate is constructed. |index|
+  // will be appended to the pool name to label the underlying worker threads.
   SchedulerWorkerDelegateImpl(
       SchedulerWorkerPoolImpl* outer,
-      const ReEnqueueSequenceCallback& re_enqueue_sequence_callback,
       int index);
   ~SchedulerWorkerDelegateImpl() override;
 
   // SchedulerWorker::Delegate:
   void OnMainEntry(SchedulerWorker* worker) override;
   scoped_refptr<Sequence> GetWork(SchedulerWorker* worker) override;
   void DidRunTask() override;
   void ReEnqueueSequence(scoped_refptr<Sequence> sequence) override;
   TimeDelta GetSleepTimeout() override;
   bool CanDetach(SchedulerWorker* worker) override;
   void OnDetach() override;
 
  private:
   SchedulerWorkerPoolImpl* outer_;
-  const ReEnqueueSequenceCallback re_enqueue_sequence_callback_;
 
   // Time of the last detach.
   TimeTicks last_detach_time_;
 
   // Time when GetWork() first returned nullptr.
   TimeTicks idle_start_time_;
 
   // Indicates whether the last call to GetWork() returned nullptr.
   bool last_get_work_returned_nullptr_ = false;
 
@@ skipping 10 matching lines @@
   size_t num_tasks_since_last_detach_ = 0;
 
   const int index_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulerWorkerDelegateImpl);
 };
 
 SchedulerWorkerPoolImpl::SchedulerWorkerPoolImpl(
     const std::string& name,
     ThreadPriority priority_hint,
-    ReEnqueueSequenceCallback re_enqueue_sequence_callback,
     TaskTracker* task_tracker,
     DelayedTaskManager* delayed_task_manager)
     : name_(name),
       priority_hint_(priority_hint),
-      re_enqueue_sequence_callback_(std::move(re_enqueue_sequence_callback)),
       idle_workers_stack_lock_(shared_priority_queue_.container_lock()),
       idle_workers_stack_cv_for_testing_(
           idle_workers_stack_lock_.CreateConditionVariable()),
       join_for_testing_returned_(WaitableEvent::ResetPolicy::MANUAL,
                                  WaitableEvent::InitialState::NOT_SIGNALED),
       // Mimics the UMA_HISTOGRAM_LONG_TIMES macro.
       detach_duration_histogram_(Histogram::FactoryTimeGet(
           kDetachDurationHistogramPrefix + name_ + kPoolNameSuffix,
           TimeDelta::FromMilliseconds(1),
           TimeDelta::FromHours(1),
@@ skipping 33 matching lines @@
 #if DCHECK_IS_ON()
     DCHECK(!workers_created_.IsSet());
 #endif
 
     DCHECK(workers_.empty());
     workers_.resize(params.max_threads());
 
     // Create workers in reverse order of index so that the worker with the
     // highest index is at the bottom of the idle stack.
     for (int index = params.max_threads() - 1; index >= 0; --index) {
-      workers_[index] = make_scoped_refptr(
-          new SchedulerWorker(priority_hint_,
-                              MakeUnique<SchedulerWorkerDelegateImpl>(
-                                  this, re_enqueue_sequence_callback_, index),
-                              task_tracker_, params.backward_compatibility()));
-
+      workers_[index] = make_scoped_refptr(new SchedulerWorker(
+          priority_hint_, MakeUnique<SchedulerWorkerDelegateImpl>(this, index),
+          task_tracker_, params.backward_compatibility()));
       if (index >= num_wake_ups_before_start_)
         idle_workers_stack_.Push(workers_[index].get());
     }
 
 #if DCHECK_IS_ON()
     workers_created_.Set();
 #endif
   }
 
   // The number of workers created alive is |num_wake_ups_before_start_|, plus
@@ skipping 26 matching lines @@
     const TaskTraits& traits) {
   return make_scoped_refptr(new SchedulerParallelTaskRunner(traits, this));
 }
 
 scoped_refptr<SequencedTaskRunner>
 SchedulerWorkerPoolImpl::CreateSequencedTaskRunnerWithTraits(
     const TaskTraits& traits) {
   return make_scoped_refptr(new SchedulerSequencedTaskRunner(traits, this));
 }
 
-void SchedulerWorkerPoolImpl::ReEnqueueSequence(
-    scoped_refptr<Sequence> sequence,
-    const SequenceSortKey& sequence_sort_key) {
-  shared_priority_queue_.BeginTransaction()->Push(std::move(sequence),
-                                                  sequence_sort_key);
-
-  // The thread calling this method just ran a Task from |sequence| and will
-  // soon try to get another Sequence from which to run a Task. If the thread
-  // belongs to this pool, it will get that Sequence from
-  // |shared_priority_queue_|. When that's the case, there is no need to wake up
-  // another worker after |sequence| is inserted in |shared_priority_queue_|. If
-  // we did wake up another worker, we would waste resources by having more
-  // workers trying to get a Sequence from |shared_priority_queue_| than the
-  // number of Sequences in it.
-  if (tls_current_worker_pool.Get().Get() != this)
-    WakeUpOneWorker();
-}
-
 bool SchedulerWorkerPoolImpl::PostTaskWithSequence(
     std::unique_ptr<Task> task,
     scoped_refptr<Sequence> sequence) {
   DCHECK(task);
   DCHECK(sequence);
 
   if (!task_tracker_->WillPostTask(task.get()))
     return false;
 
   if (task->delayed_run_time.is_null()) {
@@ skipping 84 matching lines @@
   for (const auto& worker : workers_) {
     if (worker->ThreadAliveForTesting())
       ++num_alive_workers;
   }
   return num_alive_workers;
 }
 
 SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::
     SchedulerWorkerDelegateImpl(
         SchedulerWorkerPoolImpl* outer,
-        const ReEnqueueSequenceCallback& re_enqueue_sequence_callback,
         int index)
     : outer_(outer),
-      re_enqueue_sequence_callback_(re_enqueue_sequence_callback),
       index_(index) {}
 
 SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::
     ~SchedulerWorkerDelegateImpl() = default;
 
 void SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::OnMainEntry(
     SchedulerWorker* worker) {
 #if DCHECK_IS_ON()
   DCHECK(outer_->workers_created_.IsSet());
   DCHECK(ContainsWorker(outer_->workers_, worker));
@@ skipping 75 matching lines @@
   return sequence;
 }
 
 void SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::DidRunTask() {
   ++num_tasks_since_last_wait_;
   ++num_tasks_since_last_detach_;
 }
 
 void SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::
     ReEnqueueSequence(scoped_refptr<Sequence> sequence) {
-  // |re_enqueue_sequence_callback_| will determine in which PriorityQueue
-  // |sequence| must be enqueued.
-  re_enqueue_sequence_callback_.Run(std::move(sequence));
+  const SequenceSortKey sort_key = sequence->GetSortKey();
+  outer_->shared_priority_queue_.BeginTransaction()->Push(std::move(sequence),
+                                                          sort_key);
+  // No need to wake up a worker. The current worker will soon call GetWork().
 }
 
 TimeDelta SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::
     GetSleepTimeout() {
   return outer_->suggested_reclaim_time_;
 }
 
 bool SchedulerWorkerPoolImpl::SchedulerWorkerDelegateImpl::CanDetach(
     SchedulerWorker* worker) {
   const bool can_detach =
@@ skipping 59 matching lines @@
   AutoSchedulerLock auto_lock(idle_workers_stack_lock_);
   idle_workers_stack_.Remove(worker);
 }
 
 bool SchedulerWorkerPoolImpl::CanWorkerDetachForTesting() {
   return !worker_detachment_disallowed_.IsSet();
 }
 
 }  // namespace internal
 }  // namespace base