OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/threading/worker_pool.h" | 5 #include "base/threading/worker_pool.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/compiler_specific.h" | 8 #include "base/compiler_specific.h" |
9 #include "base/debug/leak_annotations.h" | 9 #include "base/debug/leak_annotations.h" |
10 #include "base/lazy_instance.h" | 10 #include "base/lazy_instance.h" |
11 #include "base/macros.h" | 11 #include "base/macros.h" |
12 #include "base/task_runner.h" | 12 #include "base/task_runner.h" |
13 #include "base/threading/post_task_and_reply_impl.h" | 13 #include "base/threading/post_task_and_reply_impl.h" |
14 #include "base/tracked_objects.h" | 14 #include "base/tracked_objects.h" |
15 | 15 |
16 namespace base { | 16 namespace base { |
17 | 17 |
18 namespace { | 18 namespace { |
19 | 19 |
20 class PostTaskAndReplyWorkerPool : public internal::PostTaskAndReplyImpl { | 20 class PostTaskAndReplyWorkerPool : public internal::PostTaskAndReplyImpl { |
21 public: | 21 public: |
22 explicit PostTaskAndReplyWorkerPool(bool task_is_slow) | 22 explicit PostTaskAndReplyWorkerPool(bool task_is_slow) |
23 : task_is_slow_(task_is_slow) { | 23 : task_is_slow_(task_is_slow) { |
24 } | 24 } |
25 ~PostTaskAndReplyWorkerPool() override = default; | 25 ~PostTaskAndReplyWorkerPool() override = default; |
26 | 26 |
27 private: | 27 private: |
28 bool PostTask(const tracked_objects::Location& from_here, | 28 bool PostTask(const tracked_objects::Location& from_here, |
29 const Closure& task) override { | 29 OnceClosure task) override { |
30 return WorkerPool::PostTask(from_here, task, task_is_slow_); | 30 return WorkerPool::PostTask(from_here, std::move(task), task_is_slow_); |
31 } | 31 } |
32 | 32 |
33 bool task_is_slow_; | 33 bool task_is_slow_; |
34 }; | 34 }; |
35 | 35 |
36 // WorkerPoolTaskRunner --------------------------------------------- | 36 // WorkerPoolTaskRunner --------------------------------------------- |
37 // A TaskRunner which posts tasks to a WorkerPool with a | 37 // A TaskRunner which posts tasks to a WorkerPool with a |
38 // fixed ShutdownBehavior. | 38 // fixed ShutdownBehavior. |
39 // | 39 // |
40 // Note that this class is RefCountedThreadSafe (inherited from TaskRunner). | 40 // Note that this class is RefCountedThreadSafe (inherited from TaskRunner). |
41 class WorkerPoolTaskRunner : public TaskRunner { | 41 class WorkerPoolTaskRunner : public TaskRunner { |
42 public: | 42 public: |
43 explicit WorkerPoolTaskRunner(bool tasks_are_slow); | 43 explicit WorkerPoolTaskRunner(bool tasks_are_slow); |
44 | 44 |
45 // TaskRunner implementation | 45 // TaskRunner implementation |
46 bool PostDelayedTask(const tracked_objects::Location& from_here, | 46 bool PostDelayedTask(const tracked_objects::Location& from_here, |
47 const Closure& task, | 47 OnceClosure task, |
48 TimeDelta delay) override; | 48 TimeDelta delay) override; |
49 bool RunsTasksOnCurrentThread() const override; | 49 bool RunsTasksOnCurrentThread() const override; |
50 | 50 |
51 private: | 51 private: |
52 ~WorkerPoolTaskRunner() override; | 52 ~WorkerPoolTaskRunner() override; |
53 | 53 |
54 // Helper function for posting a delayed task. Asserts that the delay is | 54 // Helper function for posting a delayed task. Asserts that the delay is |
55 // zero because non-zero delays are not supported. | 55 // zero because non-zero delays are not supported. |
56 bool PostDelayedTaskAssertZeroDelay( | 56 bool PostDelayedTaskAssertZeroDelay( |
57 const tracked_objects::Location& from_here, | 57 const tracked_objects::Location& from_here, |
58 const Closure& task, | 58 OnceClosure task, |
59 base::TimeDelta delay); | 59 base::TimeDelta delay); |
60 | 60 |
61 const bool tasks_are_slow_; | 61 const bool tasks_are_slow_; |
62 | 62 |
63 DISALLOW_COPY_AND_ASSIGN(WorkerPoolTaskRunner); | 63 DISALLOW_COPY_AND_ASSIGN(WorkerPoolTaskRunner); |
64 }; | 64 }; |
65 | 65 |
66 WorkerPoolTaskRunner::WorkerPoolTaskRunner(bool tasks_are_slow) | 66 WorkerPoolTaskRunner::WorkerPoolTaskRunner(bool tasks_are_slow) |
67 : tasks_are_slow_(tasks_are_slow) { | 67 : tasks_are_slow_(tasks_are_slow) { |
68 } | 68 } |
69 | 69 |
70 WorkerPoolTaskRunner::~WorkerPoolTaskRunner() { | 70 WorkerPoolTaskRunner::~WorkerPoolTaskRunner() { |
71 } | 71 } |
72 | 72 |
73 bool WorkerPoolTaskRunner::PostDelayedTask( | 73 bool WorkerPoolTaskRunner::PostDelayedTask( |
74 const tracked_objects::Location& from_here, | 74 const tracked_objects::Location& from_here, |
75 const Closure& task, | 75 OnceClosure task, |
76 TimeDelta delay) { | 76 TimeDelta delay) { |
77 return PostDelayedTaskAssertZeroDelay(from_here, task, delay); | 77 return PostDelayedTaskAssertZeroDelay(from_here, std::move(task), delay); |
78 } | 78 } |
79 | 79 |
80 bool WorkerPoolTaskRunner::RunsTasksOnCurrentThread() const { | 80 bool WorkerPoolTaskRunner::RunsTasksOnCurrentThread() const { |
81 return WorkerPool::RunsTasksOnCurrentThread(); | 81 return WorkerPool::RunsTasksOnCurrentThread(); |
82 } | 82 } |
83 | 83 |
84 bool WorkerPoolTaskRunner::PostDelayedTaskAssertZeroDelay( | 84 bool WorkerPoolTaskRunner::PostDelayedTaskAssertZeroDelay( |
85 const tracked_objects::Location& from_here, | 85 const tracked_objects::Location& from_here, |
86 const Closure& task, | 86 OnceClosure task, |
87 base::TimeDelta delay) { | 87 base::TimeDelta delay) { |
88 DCHECK_EQ(delay.InMillisecondsRoundedUp(), 0) | 88 DCHECK_EQ(delay.InMillisecondsRoundedUp(), 0) |
89 << "WorkerPoolTaskRunner does not support non-zero delays"; | 89 << "WorkerPoolTaskRunner does not support non-zero delays"; |
90 return WorkerPool::PostTask(from_here, task, tasks_are_slow_); | 90 return WorkerPool::PostTask(from_here, std::move(task), tasks_are_slow_); |
91 } | 91 } |
92 | 92 |
93 struct TaskRunnerHolder { | 93 struct TaskRunnerHolder { |
94 TaskRunnerHolder() { | 94 TaskRunnerHolder() { |
95 taskrunners_[0] = new WorkerPoolTaskRunner(false); | 95 taskrunners_[0] = new WorkerPoolTaskRunner(false); |
96 taskrunners_[1] = new WorkerPoolTaskRunner(true); | 96 taskrunners_[1] = new WorkerPoolTaskRunner(true); |
97 } | 97 } |
98 scoped_refptr<TaskRunner> taskrunners_[2]; | 98 scoped_refptr<TaskRunner> taskrunners_[2]; |
99 }; | 99 }; |
100 | 100 |
101 base::LazyInstance<TaskRunnerHolder>::Leaky | 101 base::LazyInstance<TaskRunnerHolder>::Leaky |
102 g_taskrunners = LAZY_INSTANCE_INITIALIZER; | 102 g_taskrunners = LAZY_INSTANCE_INITIALIZER; |
103 | 103 |
104 } // namespace | 104 } // namespace |
105 | 105 |
106 bool WorkerPool::PostTaskAndReply(const tracked_objects::Location& from_here, | 106 bool WorkerPool::PostTaskAndReply(const tracked_objects::Location& from_here, |
107 const Closure& task, | 107 OnceClosure task, |
108 const Closure& reply, | 108 OnceClosure reply, |
109 bool task_is_slow) { | 109 bool task_is_slow) { |
110 // Do not report PostTaskAndReplyRelay leaks in tests. There's nothing we can | 110 // Do not report PostTaskAndReplyRelay leaks in tests. There's nothing we can |
111 // do about them because WorkerPool doesn't have a flushing API. | 111 // do about them because WorkerPool doesn't have a flushing API. |
112 // http://crbug.com/248513 | 112 // http://crbug.com/248513 |
113 // http://crbug.com/290897 | 113 // http://crbug.com/290897 |
114 // Note: this annotation does not cover tasks posted through a TaskRunner. | 114 // Note: this annotation does not cover tasks posted through a TaskRunner. |
115 ANNOTATE_SCOPED_MEMORY_LEAK; | 115 ANNOTATE_SCOPED_MEMORY_LEAK; |
116 return PostTaskAndReplyWorkerPool(task_is_slow).PostTaskAndReply( | 116 return PostTaskAndReplyWorkerPool(task_is_slow) |
117 from_here, task, reply); | 117 .PostTaskAndReply(from_here, std::move(task), std::move(reply)); |
118 } | 118 } |
119 | 119 |
120 // static | 120 // static |
121 const scoped_refptr<TaskRunner>& | 121 const scoped_refptr<TaskRunner>& |
122 WorkerPool::GetTaskRunner(bool tasks_are_slow) { | 122 WorkerPool::GetTaskRunner(bool tasks_are_slow) { |
123 return g_taskrunners.Get().taskrunners_[tasks_are_slow]; | 123 return g_taskrunners.Get().taskrunners_[tasks_are_slow]; |
124 } | 124 } |
125 | 125 |
126 } // namespace base | 126 } // namespace base |
OLD | NEW |