TaskScheduler [11] Support ExecutionMode::SINGLE_THREADED.

base/task_scheduler/scheduler_thread_pool.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_
 
 #include <memory>
 
 #include "base/base_export.h"
 #include "base/memory/ref_counted.h"
 #include "base/task_runner.h"
 #include "base/task_scheduler/sequence.h"
 #include "base/task_scheduler/task.h"
 #include "base/task_scheduler/task_traits.h"
 
 namespace base {
 namespace internal {
 
+class SchedulerWorkerThread;
 struct SequenceSortKey;
 
 // Interface for a thread pool.
 class BASE_EXPORT SchedulerThreadPool {
  public:
   virtual ~SchedulerThreadPool() = default;
 
   // Returns a TaskRunner whose PostTask invocations will result in scheduling
   // Tasks with |traits| and |execution_mode| in this thread pool.
   virtual scoped_refptr<TaskRunner> CreateTaskRunnerWithTraits(
       const TaskTraits& traits,
       ExecutionMode execution_mode) = 0;
 
   // 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.
   virtual void ReEnqueueSequence(scoped_refptr<Sequence> sequence,
                                  const SequenceSortKey& sequence_sort_key) = 0;
 
-  // Posts |task| to be executed as part of |sequence|.  Returns true if |task|
-  // is posted.
+  // Posts |task| to be executed as part of |sequence|. |task| will run on
+  // |worker_thread| if specified.  Returns true if |task| is posted.
   virtual bool PostTaskWithSequence(std::unique_ptr<Task> task,

[robliao, 2016/04/25 21:42:38]

Similarly, should we instead have PostSingleThreadedTaskWithSequence?

[fdoray, 2016/04/25 22:34:44]

danakj@: What is your take on this? I think that you like having a single post
task flow.

I'd like to avoid duplicating the code in PostTaskWithSequence. That means that
if we add PostSingleThreadedTaskWithSequence, we need an helper function which
will make it hard to understand the post task flow.

If we add PostSingleThreadedTaskWithSequence, we probably also need to add
PostSingleThreadedTaskWithSequenceNow.

[gab, 2016/04/26 11:46:27]

+1 to single post task flow.

-                                    scoped_refptr<Sequence> sequence) = 0;
+                                    scoped_refptr<Sequence> sequence,
+                                    SchedulerWorkerThread* worker_thread) = 0;
 
-  // Posts |task| to be executed by this thread pool as part of |sequence|. The
-  // scheduler's TaskTracker must have allowed |task| to be posted before this
-  // is called. This must only be called after |task|'s delayed run time.
-  virtual void PostTaskWithSequenceNow(std::unique_ptr<Task> task,
-                                       scoped_refptr<Sequence> sequence) = 0;
+  // Posts |task| to be executed by this thread pool as part of |sequence|.
+  // |task| will run on |worker_thread| if specified. The scheduler's

[gab, 2016/04/25 21:00:20]

Add a note that SchedulerThreadPool has to be the owner of SchedulerWorkerThread
(and then DCHECK that this is true in the impl)?

[fdoray, 2016/04/25 22:34:44]

Done.

+  // TaskTracker must have allowed |task| to be posted before this is called.
+  // This must only be called after |task|'s delayed run time.
+  virtual void PostTaskWithSequenceNow(
+      std::unique_ptr<Task> task,
+      scoped_refptr<Sequence> sequence,
+      SchedulerWorkerThread* worker_thread) = 0;
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_TASK_SCHEDULER_SCHEDULER_THREAD_POOL_H_