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_TASKRUNNER_H_
6#define BASE_DEFERRED_SEQUENCED_TASKRUNNER_H_
7
8#include <vector>
9
10#include "base/base_export.h"
11#include "base/basictypes.h"
12#include "base/callback.h"
13#include "base/compiler_specific.h"
14#include "base/memory/ref_counted.h"
15#include "base/sequenced_task_runner.h"
16#include "base/synchronization/lock.h"
17#include "base/time/time.h"
18#include "base/tracked_objects.h"
19
20namespace base {
21
22// A DeferredSequencedTaskRunner is a subclass of SequencedTaskRunner that
23// queues up all requests until the first call to Start() is issued.
24class BASE_EXPORT DeferredSequencedTaskRunner : public SequencedTaskRunner {
25 public:
26  explicit DeferredSequencedTaskRunner(
27      const scoped_refptr<SequencedTaskRunner>& target_runner);
28
29  // TaskRunner implementation
30  virtual bool PostDelayedTask(const tracked_objects::Location& from_here,
31                               const Closure& task,
32                               TimeDelta delay) OVERRIDE;
33  virtual bool RunsTasksOnCurrentThread() const OVERRIDE;
34
35  // SequencedTaskRunner implementation
36  virtual bool PostNonNestableDelayedTask(
37      const tracked_objects::Location& from_here,
38      const Closure& task,
39      TimeDelta delay) OVERRIDE;
40
41  // Start the execution - posts all queued tasks to the target executor. The
42  // deferred tasks are posted with their initial delay, meaning that the task
43  // execution delay is actually measured from Start.
44  // Fails when called a second time.
45  void Start();
46
47 private:
48  struct DeferredTask  {
49    DeferredTask();
50    ~DeferredTask();
51
52    tracked_objects::Location posted_from;
53    Closure task;
54    // The delay this task was initially posted with.
55    TimeDelta delay;
56    bool is_non_nestable;
57  };
58
59  virtual ~DeferredSequencedTaskRunner();
60
61  // Creates a |Task| object and adds it to |deferred_tasks_queue_|.
62  void QueueDeferredTask(const tracked_objects::Location& from_here,
63                         const Closure& task,
64                         TimeDelta delay,
65                         bool is_non_nestable);
66
67  // // Protects |started_| and |deferred_tasks_queue_|.
68  mutable Lock lock_;
69
70  bool started_;
71  const scoped_refptr<SequencedTaskRunner> target_task_runner_;
72  std::vector<DeferredTask> deferred_tasks_queue_;
73
74  DISALLOW_COPY_AND_ASSIGN(DeferredSequencedTaskRunner);
75};
76
77}  // namespace base
78
79#endif  // BASE_DEFERRED_SEQUENCED_TASKRUNNER_H_
80