1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #ifndef BASE_DEFERRED_SEQUENCED_TASK_RUNNER_H_
6 #define BASE_DEFERRED_SEQUENCED_TASK_RUNNER_H_
7 
8 #include <vector>
9 
10 #include "base/base_export.h"
11 #include "base/callback.h"
12 #include "base/compiler_specific.h"
13 #include "base/macros.h"
14 #include "base/memory/ref_counted.h"
15 #include "base/sequenced_task_runner.h"
16 #include "base/synchronization/lock.h"
17 #include "base/threading/platform_thread.h"
18 #include "base/time/time.h"
19 
20 namespace base {
21 
22 // A DeferredSequencedTaskRunner is a subclass of SequencedTaskRunner that
23 // queues up all requests until the first call to Start() is issued.
24 // DeferredSequencedTaskRunner may be created in two ways:
25 // . with an explicit SequencedTaskRunner that the events are flushed to
26 // . without a SequencedTaskRunner. In this configuration the
27 //   SequencedTaskRunner is supplied in StartWithTaskRunner().
28 class BASE_EXPORT DeferredSequencedTaskRunner : public SequencedTaskRunner {
29  public:
30   explicit DeferredSequencedTaskRunner(
31       scoped_refptr<SequencedTaskRunner> target_runner);
32 
33   // Use this constructor when you don't have the target SequencedTaskRunner.
34   // When using this call StartWithTaskRunner().
35   DeferredSequencedTaskRunner();
36 
37   // TaskRunner implementation
38   bool PostDelayedTask(const Location& from_here,
39                        OnceClosure task,
40                        TimeDelta delay) override;
41   bool RunsTasksInCurrentSequence() const override;
42 
43   // SequencedTaskRunner implementation
44   bool PostNonNestableDelayedTask(const Location& from_here,
45                                   OnceClosure task,
46                                   TimeDelta delay) override;
47 
48   // Start the execution - posts all queued tasks to the target executor. The
49   // deferred tasks are posted with their initial delay, meaning that the task
50   // execution delay is actually measured from Start.
51   // Fails when called a second time.
52   void Start();
53 
54   // Same as Start(), but must be used with the no-arg constructor.
55   void StartWithTaskRunner(
56       scoped_refptr<SequencedTaskRunner> target_task_runner);
57 
58  private:
59   struct DeferredTask  {
60     DeferredTask();
61     DeferredTask(DeferredTask&& other);
62     ~DeferredTask();
63     DeferredTask& operator=(DeferredTask&& other);
64 
65     Location posted_from;
66     OnceClosure task;
67     // The delay this task was initially posted with.
68     TimeDelta delay;
69     bool is_non_nestable;
70   };
71 
72   ~DeferredSequencedTaskRunner() override;
73 
74   // Both variants of Start() call into this.
75   void StartImpl();
76 
77   // Creates a |Task| object and adds it to |deferred_tasks_queue_|.
78   void QueueDeferredTask(const Location& from_here,
79                          OnceClosure task,
80                          TimeDelta delay,
81                          bool is_non_nestable);
82 
83   // // Protects |started_| and |deferred_tasks_queue_|.
84   mutable Lock lock_;
85 
86   const PlatformThreadId created_thread_id_;
87 
88   bool started_ = false;
89   scoped_refptr<SequencedTaskRunner> target_task_runner_;
90   std::vector<DeferredTask> deferred_tasks_queue_;
91 
92   DISALLOW_COPY_AND_ASSIGN(DeferredSequencedTaskRunner);
93 };
94 
95 }  // namespace base
96 
97 #endif  // BASE_DEFERRED_SEQUENCED_TASK_RUNNER_H_
98