Remove SingleThreadTaskRunner Support from SchedulerWorkerPoolImpl

base/task_scheduler/scheduler_worker_pool_impl.h

 // 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.
 
 #ifndef BASE_TASK_SCHEDULER_SCHEDULER_WORKER_POOL_IMPL_H_
 #define BASE_TASK_SCHEDULER_SCHEDULER_WORKER_POOL_IMPL_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 49 matching lines @@
       const SchedulerWorkerPoolParams& params,
       const ReEnqueueSequenceCallback& re_enqueue_sequence_callback,
       TaskTracker* task_tracker,
       DelayedTaskManager* delayed_task_manager);
 
   // SchedulerWorkerPool:
   scoped_refptr<TaskRunner> CreateTaskRunnerWithTraits(
       const TaskTraits& traits) override;
   scoped_refptr<SequencedTaskRunner> CreateSequencedTaskRunnerWithTraits(
       const TaskTraits& traits) override;
-  scoped_refptr<SingleThreadTaskRunner> CreateSingleThreadTaskRunnerWithTraits(
-      const TaskTraits& traits) override;
   void ReEnqueueSequence(scoped_refptr<Sequence> sequence,
                          const SequenceSortKey& sequence_sort_key) override;
   bool PostTaskWithSequence(std::unique_ptr<Task> task,
-                            scoped_refptr<Sequence> sequence,
-                            SchedulerWorker* worker) override;
+                            scoped_refptr<Sequence> sequence) override;
   void PostTaskWithSequenceNow(std::unique_ptr<Task> task,
-                               scoped_refptr<Sequence> sequence,
-                               SchedulerWorker* worker) override;
+                               scoped_refptr<Sequence> sequence) override;
 
   const HistogramBase* num_tasks_before_detach_histogram() const {
     return num_tasks_before_detach_histogram_;
   }
 
   const HistogramBase* num_tasks_between_waits_histogram() const {
     return num_tasks_between_waits_histogram_;
   }
 
   void GetHistograms(std::vector<const HistogramBase*>* histograms) const;
@@ skipping 14 matching lines @@
   // TimeDelta::Max(), the test must call this before JoinForTesting() to reduce
   // the chance of thread detachment during the process of joining all of the
   // threads, and as a result, threads running after JoinForTesting().
   void DisallowWorkerDetachmentForTesting();
 
   // Returns the number of workers alive in this worker pool. The value may
   // change if workers are woken up or detached during this call.
   size_t NumberOfAliveWorkersForTesting();
 
  private:
-  class SchedulerSingleThreadTaskRunner;
   class SchedulerWorkerDelegateImpl;
 
   SchedulerWorkerPoolImpl(const SchedulerWorkerPoolParams& params,
                           TaskTracker* task_tracker,
                           DelayedTaskManager* delayed_task_manager);
 
   bool Initialize(
       const SchedulerWorkerPoolParams& params,
       const ReEnqueueSequenceCallback& re_enqueue_sequence_callback);
 
-  // Wakes up |worker|.
-  void WakeUpWorker(SchedulerWorker* worker);
-
   // Wakes up the last worker from this worker pool to go idle, if any.
   void WakeUpOneWorker();
 
   // Adds |worker| to |idle_workers_stack_|.
   void AddToIdleWorkersStack(SchedulerWorker* worker);
 
   // Peeks from |idle_workers_stack_|.
   const SchedulerWorker* PeekAtIdleWorkersStack() const;
 
   // Removes |worker| from |idle_workers_stack_|.
   void RemoveFromIdleWorkersStack(SchedulerWorker* worker);
 
   // Returns true if worker thread detachment is permitted.
   bool CanWorkerDetachForTesting();
 
   // The name of this worker pool, used to label its worker threads.
   const std::string name_;
 
   // All worker owned by this worker pool. Only modified during initialization
   // of the worker pool.
   std::vector<scoped_refptr<SchedulerWorker>> workers_;
 
-  // Synchronizes access to |next_worker_index_|.
-  SchedulerLock next_worker_index_lock_;
-
-  // Index of the worker that will be assigned to the next single-threaded
-  // TaskRunner returned by this pool.
-  size_t next_worker_index_ = 0;
-
   // PriorityQueue from which all threads of this worker pool get work.
   PriorityQueue shared_priority_queue_;
 
   // Suggested reclaim time for workers.
   const TimeDelta suggested_reclaim_time_;
 
   // Synchronizes access to |idle_workers_stack_| and
   // |idle_workers_stack_cv_for_testing_|. Has |shared_priority_queue_|'s
   // lock as its predecessor so that a worker can be pushed to
   // |idle_workers_stack_| within the scope of a Transaction (more
@@ skipping 37 matching lines @@
   TaskTracker* const task_tracker_;
   DelayedTaskManager* const delayed_task_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(SchedulerWorkerPoolImpl);
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_TASK_SCHEDULER_SCHEDULER_WORKER_POOL_IMPL_H_