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 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 class 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