base/deferred_sequenced_task_runner.h

   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_