Separate the create and start phases in DelayedTaskManager.

base/task_scheduler/delayed_task_manager.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_DELAYED_TASK_MANAGER_H_
 #define BASE_TASK_SCHEDULER_DELAYED_TASK_MANAGER_H_
 
 #include <memory>
+#include <utility>
+#include <vector>
 
 #include "base/base_export.h"
-#include "base/callback_forward.h"
+#include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/task_scheduler/scheduler_lock.h"
 
 namespace base {
 
 class TaskRunner;
 
 namespace internal {
 
 struct Task;
 
-// The DelayedTaskManager forwards tasks to various scheduler components when
-// they become ripe for execution. This class is thread-safe.
+// The DelayedTaskManager forwards tasks to post task callbacks when they become
+// ripe for execution. Tasks are not forwarded before Start() is called. This
+// class is thread-safe.
 class BASE_EXPORT DelayedTaskManager {
  public:
   // Posts |task| for execution immediately.
-  using PostTaskNowCallback = Callback<void(std::unique_ptr<Task> task)>;
+  using PostTaskNowCallback = OnceCallback<void(std::unique_ptr<Task> task)>;
 
+  DelayedTaskManager();
+  ~DelayedTaskManager();
+
+  // Starts the delayed task manager, allowing past and future tasks to be
+  // forwarded to their callbacks as they become ripe for execution.
   // |service_thread_task_runner| posts tasks to the TaskScheduler service
   // thread.
-  explicit DelayedTaskManager(
-      scoped_refptr<TaskRunner> service_thread_task_runner);
-  ~DelayedTaskManager();
+  void Start(scoped_refptr<TaskRunner> service_thread_task_runner);
 
   // Calls |post_task_now_callback| with |task| when |task| is ripe for
   // execution.
   void AddDelayedTask(std::unique_ptr<Task> task,
-                      const PostTaskNowCallback& post_task_now_callback);
+                      PostTaskNowCallback post_task_now_callback);
 
  private:
-  const scoped_refptr<TaskRunner> service_thread_task_runner_;
+  // Synchronizes access to all members.
+  SchedulerLock lock_;

[gab, 2017/04/12 19:15:51]

The lock is irrelevant after threads have all "seen" Start()'s effect, right?

Should we add an AtomicFlag and only use the lock when it's not set? i.e. if
(IsSet()) tr->PostTask; else { lock + if tr post /else queue }

[fdoray, 2017/04/19 15:37:55]

Done.

+
+  scoped_refptr<TaskRunner> service_thread_task_runner_;
+  std::vector<std::pair<std::unique_ptr<Task>, PostTaskNowCallback>>
+      tasks_added_before_start_;
 
   DISALLOW_COPY_AND_ASSIGN(DelayedTaskManager);
 };
 
 }  // namespace internal
 }  // namespace base
 
 #endif  // BASE_TASK_SCHEDULER_DELAYED_TASK_MANAGER_H_