TaskScheduler: Remove base/task_scheduler/utils.h/.cc

base/task_scheduler/scheduler_thread_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_THREAD_POOL_H_
-#define BASE_TASK_SCHEDULER_SCHEDULER_THREAD_POOL_H_
+#ifndef BASE_TASK_SCHEDULER_SCHEDULER_THREAD_POOL_IMPL_H_
+#define BASE_TASK_SCHEDULER_SCHEDULER_THREAD_POOL_IMPL_H_
 
 #include <stddef.h>
 
 #include <memory>
 #include <vector>
 
 #include "base/base_export.h"
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/condition_variable.h"
 #include "base/task_runner.h"
 #include "base/task_scheduler/priority_queue.h"
 #include "base/task_scheduler/scheduler_lock.h"
-#include "base/task_scheduler/scheduler_task_executor.h"
+#include "base/task_scheduler/scheduler_thread_pool.h"
 #include "base/task_scheduler/scheduler_worker_thread.h"
 #include "base/task_scheduler/scheduler_worker_thread_stack.h"
 #include "base/task_scheduler/sequence.h"
 #include "base/task_scheduler/task.h"
 #include "base/task_scheduler/task_traits.h"
 #include "base/threading/platform_thread.h"
 
 namespace base {
 namespace internal {
 
 class DelayedTaskManager;
 struct SequenceSortKey;
 class TaskTracker;
 
 // A pool of threads that run Tasks. This class is thread-safe.
-class BASE_EXPORT SchedulerThreadPool : public SchedulerTaskExecutor {
+class BASE_EXPORT SchedulerThreadPoolImpl : public SchedulerThreadPool {
  public:
   // Callback invoked when a Sequence isn't empty after a worker thread pops a
   // Task from it.
   using EnqueueSequenceCallback = Callback<void(scoped_refptr<Sequence>)>;
 
   // Destroying a SchedulerThreadPool returned by CreateThreadPool() is not
   // allowed in production; it is always leaked. In tests, it can only be
   // destroyed after JoinForTesting() has returned.
-  ~SchedulerThreadPool() override;
+  ~SchedulerThreadPoolImpl() override;
 
   // Creates a SchedulerThreadPool with up to |max_threads| threads of priority
   // |thread_priority|. |enqueue_sequence_callback| will be invoked after a
   // thread of this thread pool tries to run a Task. |task_tracker| is used to
   // handle shutdown behavior of Tasks. |delayed_task_manager| handles Tasks
   // posted with a delay. Returns nullptr on failure to create a thread pool
   // with at least one thread.
-  static std::unique_ptr<SchedulerThreadPool> CreateThreadPool(
+  static std::unique_ptr<SchedulerThreadPoolImpl> CreateThreadPool(
       ThreadPriority thread_priority,
       size_t max_threads,
       const EnqueueSequenceCallback& enqueue_sequence_callback,
       TaskTracker* task_tracker,
       DelayedTaskManager* delayed_task_manager);
 
-  // Returns a TaskRunner whose PostTask invocations will result in scheduling
-  // Tasks with |traits| and |execution_mode| in this thread pool.
-  scoped_refptr<TaskRunner> CreateTaskRunnerWithTraits(
-      const TaskTraits& traits,
-      ExecutionMode execution_mode);
-
-  // Inserts |sequence| into this thread pool's shared priority queue with
-  // |sequence_sort_key|. Must only be called from a worker thread to put
-  // |sequence| back into a PriorityQueue after running a Task from it. The
-  // worker thread doesn't have to belong to this thread pool.
-  void EnqueueSequence(scoped_refptr<Sequence> sequence,
-                       const SequenceSortKey& sequence_sort_key);
-
   // Waits until all threads are idle.
   void WaitForAllWorkerThreadsIdleForTesting();
 
   // Joins all threads of this thread pool. Tasks that are already running are
   // allowed to complete their execution. This can only be called once.
   void JoinForTesting();
 
-  // SchedulerTaskExecutor:
-  void PostTaskWithSequence(std::unique_ptr<Task> task,
+  // SchedulerThreadPool:
+  scoped_refptr<TaskRunner> CreateTaskRunnerWithTraits(

[robliao, 2016/04/22 22:56:41]

Can these be made private or do we have callers that will need both sets of
methods from SchedulerThreadPoolImpl and SchedulerThreadPool?

[fdoray, 2016/04/25 15:19:12]

Relevant discussions:

tl;dr Overrides are public except when the base class clearly states in which
context they should be called (e.g. methods that override MyClassDelegate can be
private because it's clear that they shouldn't be called outside of MyClass).

https://codereview.chromium.org/1708773002/diff/610001/base/task_scheduler/sc...
https://codereview.chromium.org/1708773002/diff/470001/base/task_scheduler/sc...

[robliao, 2016/04/25 20:08:09]

The chromium-dev discussion on the topic is here:
https://groups.google.com/a/chromium.org/d/topic/chromium-dev/CwzjcWd9cYM/dis...

The main benefit to making overridden methods private is it helps enforce that
callers to use the interface form of the class rather than the implementation
form of the class.

I don't have a really strong opinion in this case here since there are good
arguments to both sides. I'm fine with it being public, just wanted to make sure
we're doing this deliberately.

+      const TaskTraits& traits,
+      ExecutionMode execution_mode) override;
+  void EnqueueSequence(scoped_refptr<Sequence> sequence,
+                       const SequenceSortKey& sequence_sort_key) override;
+  bool PostTaskWithSequence(std::unique_ptr<Task> task,
                             scoped_refptr<Sequence> sequence) override;
+  void PostTaskWithSequenceNow(std::unique_ptr<Task> task,
+                               scoped_refptr<Sequence> sequence) override;
 
  private:
   class SchedulerWorkerThreadDelegateImpl;
 
-  SchedulerThreadPool(const EnqueueSequenceCallback& enqueue_sequence_callback,
-                      TaskTracker* task_tracker,
-                      DelayedTaskManager* delayed_task_manager);
+  SchedulerThreadPoolImpl(
+      const EnqueueSequenceCallback& enqueue_sequence_callback,
+      TaskTracker* task_tracker,
+      DelayedTaskManager* delayed_task_manager);
 
   bool Initialize(ThreadPriority thread_priority, size_t max_threads);
 
   // Wakes up the last thread from this thread pool to go idle, if any.
   void WakeUpOneThread();
 
   // Adds |worker_thread| to |idle_worker_threads_stack_|.
   void AddToIdleWorkerThreadsStack(SchedulerWorkerThread* worker_thread);
 
   // PriorityQueue from which all threads of this thread pool get work.
@@ skipping 18 matching lines @@
 
   // Signaled once JoinForTesting() has returned.
   WaitableEvent join_for_testing_returned_;
 
   // Delegate for all worker threads in this pool.
   std::unique_ptr<SchedulerWorkerThread::Delegate> worker_thread_delegate_;
 
   TaskTracker* const task_tracker_;
   DelayedTaskManager* const delayed_task_manager_;
 
-  DISALLOW_COPY_AND_ASSIGN(SchedulerThreadPool);
+  DISALLOW_COPY_AND_ASSIGN(SchedulerThreadPoolImpl);
 };
 
 }  // namespace internal
 }  // namespace base
 
-#endif  // BASE_TASK_SCHEDULER_SCHEDULER_THREAD_POOL_H_
+#endif  // BASE_TASK_SCHEDULER_SCHEDULER_THREAD_POOL_IMPL_H_