Implement Shared SingleThreadTaskRunners in the Task Scheduler

base/task_scheduler/scheduler_single_thread_task_runner_manager.h

Index: base/task_scheduler/scheduler_single_thread_task_runner_manager.h
diff --git a/base/task_scheduler/scheduler_single_thread_task_runner_manager.h b/base/task_scheduler/scheduler_single_thread_task_runner_manager.h
index c6d9d692b22e6e2b521cfc3890ddd8b3ea135b10..556f56ad7f1b323a0f7d429360d0b02d08634167 100644
--- a/base/task_scheduler/scheduler_single_thread_task_runner_manager.h
+++ b/base/task_scheduler/scheduler_single_thread_task_runner_manager.h
@@ -14,7 +14,9 @@
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/task_scheduler/environment_config.h"
 #include "base/task_scheduler/scheduler_lock.h"
+#include "base/task_scheduler/single_thread_task_runner_thread_mode.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 
@@ -35,8 +37,14 @@ class SchedulerWorkerDelegate;
 
 }  // namespace
 
-// Manages a pool of threads which are each associated with one
-// SingleThreadTaskRunner.
+// Manages a pool of threads which are each associated with one or more
+// SingleThreadTaskRunners.
+//
+// SingleThreadTaskRunners are shared by reusing a single dedicated
+// SingleThreadTaskRunners for each COM+Trait combination. These

[fdoray, 2017/05/24 13:25:45]

SingleThreadTaskRunnerThreadMode::SHARED (make it clear that this doesn't apply
to DEDICATED) SingleThreadTaskRunners with the same *task environment* (not
traits) and COM state run their tasks on the same thread. These shared threads
(the threads are joined, not the SingleThreadTaskRunners) are only reclaimed
during JoinForTesting(), even if all external references to the
SingleThreadTaskRunners are released before that.

[robliao, 2017/05/24 18:28:32]

Went with 
// SingleThreadTaskRunners using SingleThreadTaskRunnerThreadMode::SHARED, are
// backed by shared SchedulerWorkers for each COM+task environment combination.
// These workers are only reclaimed during JoinForTesting().

+// SingleThreadTaskRunners are only reclaimed during JoinForTesting().
+// Otherwise, no resources are freed even if the shared SingleThreadTaskRunner
+// reference count goes to 1.
 //
 // No threads are created (and hence no tasks can run) before Start() is called.
 //
@@ -52,24 +60,32 @@ class BASE_EXPORT SchedulerSingleThreadTaskRunnerManager final {
   // be started when SingleThreadTaskRunners are created in the future.
   void Start();
 
-  // Creates a SingleThreadTaskRunner which runs tasks with |traits| on a
-  // dedicated thread named "TaskSchedulerSingleThread" + |name| +  index.
-  // |priority_hint| is the preferred thread priority; the actual thread
-  // priority depends on shutdown state and platform capabilities.
+  // Creates a SingleThreadTaskRunner which runs tasks with |traits| on a thread
+  // named "TaskSchedulerSingleThread[Shared]" + |name| +  index. "Shared" will
+  // be in the thread name when |thread_mode| is SHARED. |priority_hint| is the
+  // preferred thread priority. The actual thread priority depends on shutdown
+  // state and platform capabilities. If |thread_mode| is DEDICATED, a thread
+  // will be dedicated to the returned task runner, otherwise it could be shared
+  // with other SingleThreadTaskRunners.
   scoped_refptr<SingleThreadTaskRunner> CreateSingleThreadTaskRunnerWithTraits(
       const std::string& name,
       ThreadPriority priority_hint,
-      const TaskTraits& traits);
+      const TaskTraits& traits,
+      SingleThreadTaskRunnerThreadMode thread_mode);
 
 #if defined(OS_WIN)
-  // Creates a SingleThreadTaskRunner which runs tasks with |traits| on a
-  // dedicated COM STA thread named "TaskSchedulerSingleThreadCOMSTA" + |name| +
-  // index. |priority_hint| is the preferred thread priority; the actual thread
-  // priority depends on shutdown state and platform capabilities.
+  // Creates a SingleThreadTaskRunner which runs tasks with |traits| on a COM
+  // STA thread named "TaskSchedulerSingleThreadCOMSTA[Shared]" + |name| +
+  // index. "Shared" will be in the thread name when |thread_mode| is SHARED.
+  // |priority_hint| is the preferred thread priority. The actual thread
+  // priority depends on shutdown state and platform capabilities. If
+  // |thread_mode| is DEDICATED, a thread will be dedicated to the returned task
+  // runner, otherwise it could be shared with other SingleThreadTaskRunners.
   scoped_refptr<SingleThreadTaskRunner> CreateCOMSTATaskRunnerWithTraits(
       const std::string& name,
       ThreadPriority priority_hint,
-      const TaskTraits& traits);
+      const TaskTraits& traits,
+      SingleThreadTaskRunnerThreadMode thread_mode);
 #endif  // defined(OS_WIN)
 
   void JoinForTesting();
@@ -78,7 +94,14 @@ class BASE_EXPORT SchedulerSingleThreadTaskRunnerManager final {
   class SchedulerSingleThreadTaskRunner;
 
   template <typename DelegateType>
-  scoped_refptr<SingleThreadTaskRunner>
+  scoped_refptr<SchedulerSingleThreadTaskRunner> CreateTaskRunnerWithTraitsImpl(
+      const std::string& name,
+      ThreadPriority priority_hint,
+      const TaskTraits& traits,
+      SingleThreadTaskRunnerThreadMode thread_mode);
+
+  template <typename DelegateType>
+  scoped_refptr<SchedulerSingleThreadTaskRunner>
   CreateSingleThreadTaskRunnerWithDelegate(const std::string& name,
                                            ThreadPriority priority_hint,
                                            const TaskTraits& traits);
@@ -93,23 +116,35 @@ class BASE_EXPORT SchedulerSingleThreadTaskRunnerManager final {
       const std::string& name,
       ThreadPriority priority_hint);
 
+  template <typename DelegateType>
+  scoped_refptr<SchedulerSingleThreadTaskRunner>& GetSharedTaskRunnerForTraits(
+      const TaskTraits& traits);
+
   void UnregisterSchedulerWorker(SchedulerWorker* worker);
 
+  void ReleaseSharedTaskRunners();
+
   TaskTracker* const task_tracker_;
   DelayedTaskManager* const delayed_task_manager_;
 
-  // Synchronizes access to |workers_|, |next_worker_id_| and |started_|.
+#if DCHECK_IS_ON()
+  subtle::Atomic32 workers_unregistered_during_join_ = 0;
+#endif
+
+  // Synchronizes access to all members below.
   SchedulerLock lock_;
   std::vector<scoped_refptr<SchedulerWorker>> workers_;
   int next_worker_id_ = 0;
 
+  scoped_refptr<SchedulerSingleThreadTaskRunner> shared_task_runners_[4];
+
+#if defined(OS_WIN)
+  scoped_refptr<SchedulerSingleThreadTaskRunner> shared_com_task_runners_[4];
+#endif  // defined(OS_WIN)
+
   // Set to true when Start() is called.
   bool started_ = false;
 
-#if DCHECK_IS_ON()
-  subtle::Atomic32 workers_unregistered_during_join_ = 0;
-#endif
-
   DISALLOW_COPY_AND_ASSIGN(SchedulerSingleThreadTaskRunnerManager);
 };