OLD | NEW |
1 // Copyright 2011 The Chromium Authors. All rights reserved. | 1 // Copyright 2011 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 "cc/scheduler/begin_frame_source.h" | 5 #include "cc/scheduler/begin_frame_source.h" |
6 | 6 |
7 #include <stdint.h> | 7 #include <stdint.h> |
8 | 8 |
9 #include "base/memory/ptr_util.h" | 9 #include "base/memory/ptr_util.h" |
10 #include "base/test/test_simple_task_runner.h" | 10 #include "base/test/test_simple_task_runner.h" |
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
66 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 66 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
67 source_->AddObserver(obs_.get()); | 67 source_->AddObserver(obs_.get()); |
68 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 68 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
69 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 69 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
70 1000 + kDeadline, kInterval); | 70 1000 + kDeadline, kInterval); |
71 task_runner_->RunPendingTasks(); | 71 task_runner_->RunPendingTasks(); |
72 | 72 |
73 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, | 73 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, |
74 1100 + kDeadline, kInterval); | 74 1100 + kDeadline, kInterval); |
75 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 75 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
76 source_->DidFinishFrame(obs_.get(), | 76 source_->DidFinishFrame(obs_.get()); |
77 BeginFrameAck(source_->source_id(), 1, 1, true)); | |
78 task_runner_->RunPendingTasks(); | 77 task_runner_->RunPendingTasks(); |
79 } | 78 } |
80 | 79 |
81 TEST_F(BackToBackBeginFrameSourceTest, | 80 TEST_F(BackToBackBeginFrameSourceTest, |
82 RemoveObserverThenDidFinishFrameProducesNoFrame) { | 81 RemoveObserverThenDidFinishFrameProducesNoFrame) { |
83 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 82 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
84 source_->AddObserver(obs_.get()); | 83 source_->AddObserver(obs_.get()); |
85 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 84 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
86 1000 + kDeadline, kInterval); | 85 1000 + kDeadline, kInterval); |
87 task_runner_->RunPendingTasks(); | 86 task_runner_->RunPendingTasks(); |
88 | 87 |
89 source_->RemoveObserver(obs_.get()); | 88 source_->RemoveObserver(obs_.get()); |
90 source_->DidFinishFrame(obs_.get(), | 89 source_->DidFinishFrame(obs_.get()); |
91 BeginFrameAck(source_->source_id(), 1, 1, true)); | |
92 | 90 |
93 // Verify no BeginFrame is sent to |obs_|. There is a pending task in the | 91 // Verify no BeginFrame is sent to |obs_|. There is a pending task in the |
94 // task_runner_ as a BeginFrame was posted, but it gets aborted since |obs_| | 92 // task_runner_ as a BeginFrame was posted, but it gets aborted since |obs_| |
95 // is removed. | 93 // is removed. |
96 task_runner_->RunPendingTasks(); | 94 task_runner_->RunPendingTasks(); |
97 EXPECT_FALSE(task_runner_->HasPendingTasks()); | 95 EXPECT_FALSE(task_runner_->HasPendingTasks()); |
98 } | 96 } |
99 | 97 |
100 TEST_F(BackToBackBeginFrameSourceTest, | 98 TEST_F(BackToBackBeginFrameSourceTest, |
101 DidFinishFrameThenRemoveObserverProducesNoFrame) { | 99 DidFinishFrameThenRemoveObserverProducesNoFrame) { |
102 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 100 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
103 source_->AddObserver(obs_.get()); | 101 source_->AddObserver(obs_.get()); |
104 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 102 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
105 1000 + kDeadline, kInterval); | 103 1000 + kDeadline, kInterval); |
106 task_runner_->RunPendingTasks(); | 104 task_runner_->RunPendingTasks(); |
107 | 105 |
108 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 106 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
109 source_->DidFinishFrame(obs_.get(), | 107 source_->DidFinishFrame(obs_.get()); |
110 BeginFrameAck(source_->source_id(), 1, 1, true)); | |
111 source_->RemoveObserver(obs_.get()); | 108 source_->RemoveObserver(obs_.get()); |
112 | 109 |
113 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 110 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
114 task_runner_->RunPendingTasks(); | 111 task_runner_->RunPendingTasks(); |
115 } | 112 } |
116 | 113 |
117 TEST_F(BackToBackBeginFrameSourceTest, | 114 TEST_F(BackToBackBeginFrameSourceTest, |
118 TogglingObserverThenDidFinishFrameProducesCorrectFrame) { | 115 TogglingObserverThenDidFinishFrameProducesCorrectFrame) { |
119 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 116 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
120 source_->AddObserver(obs_.get()); | 117 source_->AddObserver(obs_.get()); |
121 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 118 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
122 1000 + kDeadline, kInterval); | 119 1000 + kDeadline, kInterval); |
123 task_runner_->RunPendingTasks(); | 120 task_runner_->RunPendingTasks(); |
124 | 121 |
125 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 122 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
126 source_->RemoveObserver(obs_.get()); | 123 source_->RemoveObserver(obs_.get()); |
127 | 124 |
128 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 125 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
129 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 126 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
130 source_->AddObserver(obs_.get()); | 127 source_->AddObserver(obs_.get()); |
131 | 128 |
132 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 129 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
133 source_->DidFinishFrame(obs_.get(), | 130 source_->DidFinishFrame(obs_.get()); |
134 BeginFrameAck(source_->source_id(), 1, 1, true)); | |
135 | 131 |
136 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 132 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
137 // The begin frame is posted at the time when the observer was added, | 133 // The begin frame is posted at the time when the observer was added, |
138 // so it ignores changes to "now" afterward. | 134 // so it ignores changes to "now" afterward. |
139 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1110, | 135 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1110, |
140 1110 + kDeadline, kInterval); | 136 1110 + kDeadline, kInterval); |
141 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 137 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
142 task_runner_->RunPendingTasks(); | 138 task_runner_->RunPendingTasks(); |
143 } | 139 } |
144 | 140 |
145 TEST_F(BackToBackBeginFrameSourceTest, | 141 TEST_F(BackToBackBeginFrameSourceTest, |
146 DidFinishFrameThenTogglingObserverProducesCorrectFrame) { | 142 DidFinishFrameThenTogglingObserverProducesCorrectFrame) { |
147 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 143 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
148 source_->AddObserver(obs_.get()); | 144 source_->AddObserver(obs_.get()); |
149 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 145 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
150 1000 + kDeadline, kInterval); | 146 1000 + kDeadline, kInterval); |
151 task_runner_->RunPendingTasks(); | 147 task_runner_->RunPendingTasks(); |
152 | 148 |
153 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 149 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
154 source_->DidFinishFrame(obs_.get(), | 150 source_->DidFinishFrame(obs_.get()); |
155 BeginFrameAck(source_->source_id(), 1, 1, true)); | |
156 | 151 |
157 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 152 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
158 source_->RemoveObserver(obs_.get()); | 153 source_->RemoveObserver(obs_.get()); |
159 | 154 |
160 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 155 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
161 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 156 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
162 source_->AddObserver(obs_.get()); | 157 source_->AddObserver(obs_.get()); |
163 | 158 |
164 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 159 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
165 // Ticks at the time at which the observer was added, ignoring the | 160 // Ticks at the time at which the observer was added, ignoring the |
166 // last change to "now". | 161 // last change to "now". |
167 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1120, | 162 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1120, |
168 1120 + kDeadline, kInterval); | 163 1120 + kDeadline, kInterval); |
169 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 164 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
170 task_runner_->RunPendingTasks(); | 165 task_runner_->RunPendingTasks(); |
171 } | 166 } |
172 | 167 |
173 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameNoObserver) { | 168 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameNoObserver) { |
174 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 169 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
175 source_->AddObserver(obs_.get()); | 170 source_->AddObserver(obs_.get()); |
176 source_->RemoveObserver(obs_.get()); | 171 source_->RemoveObserver(obs_.get()); |
177 source_->DidFinishFrame(obs_.get(), | 172 source_->DidFinishFrame(obs_.get()); |
178 BeginFrameAck(source_->source_id(), 1, 1, true)); | |
179 EXPECT_FALSE(task_runner_->RunPendingTasks()); | 173 EXPECT_FALSE(task_runner_->RunPendingTasks()); |
180 } | 174 } |
181 | 175 |
182 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameMultipleCallsIdempotent) { | 176 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameMultipleCallsIdempotent) { |
183 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 177 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
184 source_->AddObserver(obs_.get()); | 178 source_->AddObserver(obs_.get()); |
185 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 179 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
186 1000 + kDeadline, kInterval); | 180 1000 + kDeadline, kInterval); |
187 task_runner_->RunPendingTasks(); | 181 task_runner_->RunPendingTasks(); |
188 | 182 |
189 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 183 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
190 source_->DidFinishFrame(obs_.get(), | 184 source_->DidFinishFrame(obs_.get()); |
191 BeginFrameAck(source_->source_id(), 1, 1, true)); | 185 source_->DidFinishFrame(obs_.get()); |
192 source_->DidFinishFrame(obs_.get(), | 186 source_->DidFinishFrame(obs_.get()); |
193 BeginFrameAck(source_->source_id(), 1, 1, true)); | |
194 source_->DidFinishFrame(obs_.get(), | |
195 BeginFrameAck(source_->source_id(), 1, 1, true)); | |
196 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, | 187 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, |
197 1100 + kDeadline, kInterval); | 188 1100 + kDeadline, kInterval); |
198 task_runner_->RunPendingTasks(); | 189 task_runner_->RunPendingTasks(); |
199 | 190 |
200 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 191 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
201 source_->DidFinishFrame(obs_.get(), | 192 source_->DidFinishFrame(obs_.get()); |
202 BeginFrameAck(source_->source_id(), 2, 2, true)); | 193 source_->DidFinishFrame(obs_.get()); |
203 source_->DidFinishFrame(obs_.get(), | 194 source_->DidFinishFrame(obs_.get()); |
204 BeginFrameAck(source_->source_id(), 2, 2, true)); | |
205 source_->DidFinishFrame(obs_.get(), | |
206 BeginFrameAck(source_->source_id(), 2, 2, true)); | |
207 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 3, 1200, | 195 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 3, 1200, |
208 1200 + kDeadline, kInterval); | 196 1200 + kDeadline, kInterval); |
209 task_runner_->RunPendingTasks(); | 197 task_runner_->RunPendingTasks(); |
210 } | 198 } |
211 | 199 |
212 TEST_F(BackToBackBeginFrameSourceTest, DelayInPostedTaskProducesCorrectFrame) { | 200 TEST_F(BackToBackBeginFrameSourceTest, DelayInPostedTaskProducesCorrectFrame) { |
213 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 201 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
214 source_->AddObserver(obs_.get()); | 202 source_->AddObserver(obs_.get()); |
215 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 203 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
216 1000 + kDeadline, kInterval); | 204 1000 + kDeadline, kInterval); |
217 task_runner_->RunPendingTasks(); | 205 task_runner_->RunPendingTasks(); |
218 | 206 |
219 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 207 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
220 source_->DidFinishFrame(obs_.get(), | 208 source_->DidFinishFrame(obs_.get()); |
221 BeginFrameAck(source_->source_id(), 1, 1, true)); | |
222 now_src_->Advance(base::TimeDelta::FromMicroseconds(50)); | 209 now_src_->Advance(base::TimeDelta::FromMicroseconds(50)); |
223 // Ticks at the time the last frame finished, so ignores the last change to | 210 // Ticks at the time the last frame finished, so ignores the last change to |
224 // "now". | 211 // "now". |
225 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, | 212 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, |
226 1100 + kDeadline, kInterval); | 213 1100 + kDeadline, kInterval); |
227 | 214 |
228 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 215 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
229 task_runner_->RunPendingTasks(); | 216 task_runner_->RunPendingTasks(); |
230 } | 217 } |
231 | 218 |
232 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversSynchronized) { | 219 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversSynchronized) { |
233 StrictMock<MockBeginFrameObserver> obs1, obs2; | 220 StrictMock<MockBeginFrameObserver> obs1, obs2; |
234 | 221 |
235 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); | 222 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); |
236 source_->AddObserver(&obs1); | 223 source_->AddObserver(&obs1); |
237 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); | 224 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); |
238 source_->AddObserver(&obs2); | 225 source_->AddObserver(&obs2); |
239 | 226 |
240 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, | 227 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, |
241 kInterval); | 228 kInterval); |
242 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline, | 229 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline, |
243 kInterval); | 230 kInterval); |
244 task_runner_->RunPendingTasks(); | 231 task_runner_->RunPendingTasks(); |
245 | 232 |
246 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 233 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
247 source_->DidFinishFrame(&obs1, | 234 source_->DidFinishFrame(&obs1); |
248 BeginFrameAck(source_->source_id(), 1, 1, true)); | 235 source_->DidFinishFrame(&obs2); |
249 source_->DidFinishFrame(&obs2, | |
250 BeginFrameAck(source_->source_id(), 1, 1, true)); | |
251 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 1100, 1100 + kDeadline, | 236 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 1100, 1100 + kDeadline, |
252 kInterval); | 237 kInterval); |
253 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, | 238 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, |
254 kInterval); | 239 kInterval); |
255 task_runner_->RunPendingTasks(); | 240 task_runner_->RunPendingTasks(); |
256 | 241 |
257 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 242 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
258 source_->DidFinishFrame(&obs1, | 243 source_->DidFinishFrame(&obs1); |
259 BeginFrameAck(source_->source_id(), 2, 2, true)); | 244 source_->DidFinishFrame(&obs2); |
260 source_->DidFinishFrame(&obs2, | |
261 BeginFrameAck(source_->source_id(), 2, 2, true)); | |
262 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 245 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
263 source_->RemoveObserver(&obs1); | 246 source_->RemoveObserver(&obs1); |
264 source_->RemoveObserver(&obs2); | 247 source_->RemoveObserver(&obs2); |
265 task_runner_->RunPendingTasks(); | 248 task_runner_->RunPendingTasks(); |
266 } | 249 } |
267 | 250 |
268 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversInterleaved) { | 251 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversInterleaved) { |
269 StrictMock<MockBeginFrameObserver> obs1, obs2; | 252 StrictMock<MockBeginFrameObserver> obs1, obs2; |
270 | 253 |
271 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); | 254 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); |
272 source_->AddObserver(&obs1); | 255 source_->AddObserver(&obs1); |
273 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, | 256 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, |
274 kInterval); | 257 kInterval); |
275 task_runner_->RunPendingTasks(); | 258 task_runner_->RunPendingTasks(); |
276 | 259 |
277 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 260 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
278 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); | 261 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); |
279 source_->AddObserver(&obs2); | 262 source_->AddObserver(&obs2); |
280 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, | 263 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, |
281 kInterval); | 264 kInterval); |
282 task_runner_->RunPendingTasks(); | 265 task_runner_->RunPendingTasks(); |
283 | 266 |
284 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 267 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
285 source_->DidFinishFrame(&obs1, | 268 source_->DidFinishFrame(&obs1); |
286 BeginFrameAck(source_->source_id(), 1, 1, true)); | |
287 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 3, 1200, 1200 + kDeadline, | 269 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 3, 1200, 1200 + kDeadline, |
288 kInterval); | 270 kInterval); |
289 task_runner_->RunPendingTasks(); | 271 task_runner_->RunPendingTasks(); |
290 | 272 |
291 source_->DidFinishFrame(&obs1, | 273 source_->DidFinishFrame(&obs1); |
292 BeginFrameAck(source_->source_id(), 3, 3, true)); | |
293 source_->RemoveObserver(&obs1); | 274 source_->RemoveObserver(&obs1); |
294 // Removing all finished observers should disable the time source. | 275 // Removing all finished observers should disable the time source. |
295 EXPECT_FALSE(delay_based_time_source_->Active()); | 276 EXPECT_FALSE(delay_based_time_source_->Active()); |
296 // Finishing the frame for |obs1| posts a begin frame task, which will be | 277 // Finishing the frame for |obs1| posts a begin frame task, which will be |
297 // aborted since |obs1| is removed. Clear that from the task runner. | 278 // aborted since |obs1| is removed. Clear that from the task runner. |
298 task_runner_->RunPendingTasks(); | 279 task_runner_->RunPendingTasks(); |
299 | 280 |
300 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 281 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
301 source_->DidFinishFrame(&obs2, | 282 source_->DidFinishFrame(&obs2); |
302 BeginFrameAck(source_->source_id(), 2, 2, true)); | |
303 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 4, 1300, 1300 + kDeadline, | 283 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 4, 1300, 1300 + kDeadline, |
304 kInterval); | 284 kInterval); |
305 task_runner_->RunPendingTasks(); | 285 task_runner_->RunPendingTasks(); |
306 | 286 |
307 source_->DidFinishFrame(&obs2, | 287 source_->DidFinishFrame(&obs2); |
308 BeginFrameAck(source_->source_id(), 4, 4, true)); | |
309 source_->RemoveObserver(&obs2); | 288 source_->RemoveObserver(&obs2); |
310 } | 289 } |
311 | 290 |
312 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversAtOnce) { | 291 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversAtOnce) { |
313 StrictMock<MockBeginFrameObserver> obs1, obs2; | 292 StrictMock<MockBeginFrameObserver> obs1, obs2; |
314 | 293 |
315 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); | 294 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); |
316 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); | 295 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); |
317 source_->AddObserver(&obs1); | 296 source_->AddObserver(&obs1); |
318 source_->AddObserver(&obs2); | 297 source_->AddObserver(&obs2); |
319 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, | 298 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, |
320 kInterval); | 299 kInterval); |
321 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline, | 300 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline, |
322 kInterval); | 301 kInterval); |
323 task_runner_->RunPendingTasks(); | 302 task_runner_->RunPendingTasks(); |
324 | 303 |
325 // |obs1| finishes first. | 304 // |obs1| finishes first. |
326 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 305 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
327 source_->DidFinishFrame(&obs1, | 306 source_->DidFinishFrame(&obs1); |
328 BeginFrameAck(source_->source_id(), 1, 1, true)); | |
329 | 307 |
330 // |obs2| finishes also, before getting to the newly posted begin frame. | 308 // |obs2| finishes also, before getting to the newly posted begin frame. |
331 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 309 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
332 source_->DidFinishFrame(&obs2, | 310 source_->DidFinishFrame(&obs2); |
333 BeginFrameAck(source_->source_id(), 1, 1, true)); | |
334 | 311 |
335 // Because the begin frame source already ticked when |obs1| finished, | 312 // Because the begin frame source already ticked when |obs1| finished, |
336 // we see it as the frame time for both observers. | 313 // we see it as the frame time for both observers. |
337 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 1100, 1100 + kDeadline, | 314 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 1100, 1100 + kDeadline, |
338 kInterval); | 315 kInterval); |
339 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, | 316 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, |
340 kInterval); | 317 kInterval); |
341 task_runner_->RunPendingTasks(); | 318 task_runner_->RunPendingTasks(); |
342 | 319 |
343 source_->DidFinishFrame(&obs1, | 320 source_->DidFinishFrame(&obs1); |
344 BeginFrameAck(source_->source_id(), 2, 2, true)); | |
345 source_->RemoveObserver(&obs1); | 321 source_->RemoveObserver(&obs1); |
346 source_->DidFinishFrame(&obs2, | 322 source_->DidFinishFrame(&obs2); |
347 BeginFrameAck(source_->source_id(), 2, 2, true)); | |
348 source_->RemoveObserver(&obs2); | 323 source_->RemoveObserver(&obs2); |
349 } | 324 } |
350 | 325 |
351 // DelayBasedBeginFrameSource testing ------------------------------------------ | 326 // DelayBasedBeginFrameSource testing ------------------------------------------ |
352 class DelayBasedBeginFrameSourceTest : public ::testing::Test { | 327 class DelayBasedBeginFrameSourceTest : public ::testing::Test { |
353 public: | 328 public: |
354 std::unique_ptr<base::SimpleTestTickClock> now_src_; | 329 std::unique_ptr<base::SimpleTestTickClock> now_src_; |
355 scoped_refptr<OrderedSimpleTaskRunner> task_runner_; | 330 scoped_refptr<OrderedSimpleTaskRunner> task_runner_; |
356 std::unique_ptr<DelayBasedBeginFrameSource> source_; | 331 std::unique_ptr<DelayBasedBeginFrameSource> source_; |
357 std::unique_ptr<MockBeginFrameObserver> obs_; | 332 std::unique_ptr<MockBeginFrameObserver> obs_; |
(...skipping 235 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
593 // not notify observer. | 568 // not notify observer. |
594 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 569 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
595 EXPECT_CALL((*client_), OnNeedsBeginFrames(true)).Times(1); | 570 EXPECT_CALL((*client_), OnNeedsBeginFrames(true)).Times(1); |
596 ExternalBeginFrameSource source2(client_.get()); | 571 ExternalBeginFrameSource source2(client_.get()); |
597 source2.AddObserver(obs_.get()); | 572 source2.AddObserver(obs_.get()); |
598 source2.OnBeginFrame(args); | 573 source2.OnBeginFrame(args); |
599 } | 574 } |
600 | 575 |
601 } // namespace | 576 } // namespace |
602 } // namespace cc | 577 } // namespace cc |
OLD | NEW |