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(), 0); | 76 source_->DidFinishFrame(obs_.get(), |
| 77 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
77 task_runner_->RunPendingTasks(); | 78 task_runner_->RunPendingTasks(); |
78 } | 79 } |
79 | 80 |
80 TEST_F(BackToBackBeginFrameSourceTest, | 81 TEST_F(BackToBackBeginFrameSourceTest, |
81 RemoveObserverThenDidFinishFrameProducesNoFrame) { | 82 RemoveObserverThenDidFinishFrameProducesNoFrame) { |
82 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 83 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
83 source_->AddObserver(obs_.get()); | 84 source_->AddObserver(obs_.get()); |
84 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 85 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
85 1000 + kDeadline, kInterval); | 86 1000 + kDeadline, kInterval); |
86 task_runner_->RunPendingTasks(); | 87 task_runner_->RunPendingTasks(); |
87 | 88 |
88 source_->RemoveObserver(obs_.get()); | 89 source_->RemoveObserver(obs_.get()); |
89 source_->DidFinishFrame(obs_.get(), 0); | 90 source_->DidFinishFrame(obs_.get(), |
| 91 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
90 | 92 |
91 // Verify no BeginFrame is sent to |obs_|. There is a pending task in the | 93 // Verify no BeginFrame is sent to |obs_|. There is a pending task in the |
92 // task_runner_ as a BeginFrame was posted, but it gets aborted since |obs_| | 94 // task_runner_ as a BeginFrame was posted, but it gets aborted since |obs_| |
93 // is removed. | 95 // is removed. |
94 task_runner_->RunPendingTasks(); | 96 task_runner_->RunPendingTasks(); |
95 EXPECT_FALSE(task_runner_->HasPendingTasks()); | 97 EXPECT_FALSE(task_runner_->HasPendingTasks()); |
96 } | 98 } |
97 | 99 |
98 TEST_F(BackToBackBeginFrameSourceTest, | 100 TEST_F(BackToBackBeginFrameSourceTest, |
99 DidFinishFrameThenRemoveObserverProducesNoFrame) { | 101 DidFinishFrameThenRemoveObserverProducesNoFrame) { |
100 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 102 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
101 source_->AddObserver(obs_.get()); | 103 source_->AddObserver(obs_.get()); |
102 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 104 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
103 1000 + kDeadline, kInterval); | 105 1000 + kDeadline, kInterval); |
104 task_runner_->RunPendingTasks(); | 106 task_runner_->RunPendingTasks(); |
105 | 107 |
106 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 108 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
107 source_->DidFinishFrame(obs_.get(), 0); | 109 source_->DidFinishFrame(obs_.get(), |
| 110 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
108 source_->RemoveObserver(obs_.get()); | 111 source_->RemoveObserver(obs_.get()); |
109 | 112 |
110 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 113 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
111 task_runner_->RunPendingTasks(); | 114 task_runner_->RunPendingTasks(); |
112 } | 115 } |
113 | 116 |
114 TEST_F(BackToBackBeginFrameSourceTest, | 117 TEST_F(BackToBackBeginFrameSourceTest, |
115 TogglingObserverThenDidFinishFrameProducesCorrectFrame) { | 118 TogglingObserverThenDidFinishFrameProducesCorrectFrame) { |
116 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 119 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
117 source_->AddObserver(obs_.get()); | 120 source_->AddObserver(obs_.get()); |
118 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 121 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
119 1000 + kDeadline, kInterval); | 122 1000 + kDeadline, kInterval); |
120 task_runner_->RunPendingTasks(); | 123 task_runner_->RunPendingTasks(); |
121 | 124 |
122 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 125 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
123 source_->RemoveObserver(obs_.get()); | 126 source_->RemoveObserver(obs_.get()); |
124 | 127 |
125 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 128 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
126 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 129 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
127 source_->AddObserver(obs_.get()); | 130 source_->AddObserver(obs_.get()); |
128 | 131 |
129 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 132 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
130 source_->DidFinishFrame(obs_.get(), 0); | 133 source_->DidFinishFrame(obs_.get(), |
| 134 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
131 | 135 |
132 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 136 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
133 // The begin frame is posted at the time when the observer was added, | 137 // The begin frame is posted at the time when the observer was added, |
134 // so it ignores changes to "now" afterward. | 138 // so it ignores changes to "now" afterward. |
135 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1110, | 139 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1110, |
136 1110 + kDeadline, kInterval); | 140 1110 + kDeadline, kInterval); |
137 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 141 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
138 task_runner_->RunPendingTasks(); | 142 task_runner_->RunPendingTasks(); |
139 } | 143 } |
140 | 144 |
141 TEST_F(BackToBackBeginFrameSourceTest, | 145 TEST_F(BackToBackBeginFrameSourceTest, |
142 DidFinishFrameThenTogglingObserverProducesCorrectFrame) { | 146 DidFinishFrameThenTogglingObserverProducesCorrectFrame) { |
143 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 147 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
144 source_->AddObserver(obs_.get()); | 148 source_->AddObserver(obs_.get()); |
145 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 149 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
146 1000 + kDeadline, kInterval); | 150 1000 + kDeadline, kInterval); |
147 task_runner_->RunPendingTasks(); | 151 task_runner_->RunPendingTasks(); |
148 | 152 |
149 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 153 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
150 source_->DidFinishFrame(obs_.get(), 0); | 154 source_->DidFinishFrame(obs_.get(), |
| 155 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
151 | 156 |
152 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 157 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
153 source_->RemoveObserver(obs_.get()); | 158 source_->RemoveObserver(obs_.get()); |
154 | 159 |
155 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 160 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
156 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 161 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
157 source_->AddObserver(obs_.get()); | 162 source_->AddObserver(obs_.get()); |
158 | 163 |
159 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 164 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
160 // Ticks at the time at which the observer was added, ignoring the | 165 // Ticks at the time at which the observer was added, ignoring the |
161 // last change to "now". | 166 // last change to "now". |
162 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1120, | 167 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1120, |
163 1120 + kDeadline, kInterval); | 168 1120 + kDeadline, kInterval); |
164 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 169 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
165 task_runner_->RunPendingTasks(); | 170 task_runner_->RunPendingTasks(); |
166 } | 171 } |
167 | 172 |
168 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameNoObserver) { | 173 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameNoObserver) { |
169 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 174 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
170 source_->AddObserver(obs_.get()); | 175 source_->AddObserver(obs_.get()); |
171 source_->RemoveObserver(obs_.get()); | 176 source_->RemoveObserver(obs_.get()); |
172 source_->DidFinishFrame(obs_.get(), 0); | 177 source_->DidFinishFrame(obs_.get(), |
| 178 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
173 EXPECT_FALSE(task_runner_->RunPendingTasks()); | 179 EXPECT_FALSE(task_runner_->RunPendingTasks()); |
174 } | 180 } |
175 | 181 |
176 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameRemainingFrames) { | 182 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameRemainingFrames) { |
177 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 183 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
178 source_->AddObserver(obs_.get()); | 184 source_->AddObserver(obs_.get()); |
179 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 185 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
180 1000 + kDeadline, kInterval); | 186 1000 + kDeadline, kInterval); |
181 // Runs the pending begin frame. | 187 // Runs the pending begin frame. |
182 task_runner_->RunPendingTasks(); | 188 task_runner_->RunPendingTasks(); |
183 // While running the begin frame, the next frame was cancelled, this | 189 // While running the begin frame, the next frame was cancelled, this |
184 // runs the next frame, sees it was cancelled, and goes to sleep. | 190 // runs the next frame, sees it was cancelled, and goes to sleep. |
185 task_runner_->RunPendingTasks(); | 191 task_runner_->RunPendingTasks(); |
186 EXPECT_FALSE(task_runner_->HasPendingTasks()); | 192 EXPECT_FALSE(task_runner_->HasPendingTasks()); |
187 | 193 |
188 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 194 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
189 | 195 |
190 source_->DidFinishFrame(obs_.get(), 3); | 196 source_->DidFinishFrame(obs_.get(), |
| 197 BeginFrameAck(source_->source_id(), 1, 1, 3, true)); |
191 EXPECT_FALSE(task_runner_->HasPendingTasks()); | 198 EXPECT_FALSE(task_runner_->HasPendingTasks()); |
192 source_->DidFinishFrame(obs_.get(), 2); | 199 source_->DidFinishFrame(obs_.get(), |
| 200 BeginFrameAck(source_->source_id(), 1, 1, 2, true)); |
193 EXPECT_FALSE(task_runner_->HasPendingTasks()); | 201 EXPECT_FALSE(task_runner_->HasPendingTasks()); |
194 source_->DidFinishFrame(obs_.get(), 1); | 202 source_->DidFinishFrame(obs_.get(), |
| 203 BeginFrameAck(source_->source_id(), 1, 1, 1, true)); |
195 EXPECT_FALSE(task_runner_->HasPendingTasks()); | 204 EXPECT_FALSE(task_runner_->HasPendingTasks()); |
196 | 205 |
197 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, | 206 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, |
198 1100 + kDeadline, kInterval); | 207 1100 + kDeadline, kInterval); |
199 source_->DidFinishFrame(obs_.get(), 0); | 208 source_->DidFinishFrame(obs_.get(), |
| 209 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
200 EXPECT_EQ(base::TimeDelta(), task_runner_->DelayToNextTaskTime()); | 210 EXPECT_EQ(base::TimeDelta(), task_runner_->DelayToNextTaskTime()); |
201 task_runner_->RunPendingTasks(); | 211 task_runner_->RunPendingTasks(); |
202 } | 212 } |
203 | 213 |
204 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameMultipleCallsIdempotent) { | 214 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameMultipleCallsIdempotent) { |
205 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 215 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
206 source_->AddObserver(obs_.get()); | 216 source_->AddObserver(obs_.get()); |
207 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 217 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
208 1000 + kDeadline, kInterval); | 218 1000 + kDeadline, kInterval); |
209 task_runner_->RunPendingTasks(); | 219 task_runner_->RunPendingTasks(); |
210 | 220 |
211 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 221 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
212 source_->DidFinishFrame(obs_.get(), 0); | 222 source_->DidFinishFrame(obs_.get(), |
213 source_->DidFinishFrame(obs_.get(), 0); | 223 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
214 source_->DidFinishFrame(obs_.get(), 0); | 224 source_->DidFinishFrame(obs_.get(), |
| 225 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
| 226 source_->DidFinishFrame(obs_.get(), |
| 227 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
215 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, | 228 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, |
216 1100 + kDeadline, kInterval); | 229 1100 + kDeadline, kInterval); |
217 task_runner_->RunPendingTasks(); | 230 task_runner_->RunPendingTasks(); |
218 | 231 |
219 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 232 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
220 source_->DidFinishFrame(obs_.get(), 0); | 233 source_->DidFinishFrame(obs_.get(), |
221 source_->DidFinishFrame(obs_.get(), 0); | 234 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); |
222 source_->DidFinishFrame(obs_.get(), 0); | 235 source_->DidFinishFrame(obs_.get(), |
| 236 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); |
| 237 source_->DidFinishFrame(obs_.get(), |
| 238 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); |
223 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 3, 1200, | 239 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 3, 1200, |
224 1200 + kDeadline, kInterval); | 240 1200 + kDeadline, kInterval); |
225 task_runner_->RunPendingTasks(); | 241 task_runner_->RunPendingTasks(); |
226 } | 242 } |
227 | 243 |
228 TEST_F(BackToBackBeginFrameSourceTest, DelayInPostedTaskProducesCorrectFrame) { | 244 TEST_F(BackToBackBeginFrameSourceTest, DelayInPostedTaskProducesCorrectFrame) { |
229 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 245 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
230 source_->AddObserver(obs_.get()); | 246 source_->AddObserver(obs_.get()); |
231 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 247 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
232 1000 + kDeadline, kInterval); | 248 1000 + kDeadline, kInterval); |
233 task_runner_->RunPendingTasks(); | 249 task_runner_->RunPendingTasks(); |
234 | 250 |
235 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 251 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
236 source_->DidFinishFrame(obs_.get(), 0); | 252 source_->DidFinishFrame(obs_.get(), |
| 253 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
237 now_src_->Advance(base::TimeDelta::FromMicroseconds(50)); | 254 now_src_->Advance(base::TimeDelta::FromMicroseconds(50)); |
238 // Ticks at the time the last frame finished, so ignores the last change to | 255 // Ticks at the time the last frame finished, so ignores the last change to |
239 // "now". | 256 // "now". |
240 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, | 257 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, |
241 1100 + kDeadline, kInterval); | 258 1100 + kDeadline, kInterval); |
242 | 259 |
243 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 260 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
244 task_runner_->RunPendingTasks(); | 261 task_runner_->RunPendingTasks(); |
245 } | 262 } |
246 | 263 |
247 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversSynchronized) { | 264 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversSynchronized) { |
248 StrictMock<MockBeginFrameObserver> obs1, obs2; | 265 StrictMock<MockBeginFrameObserver> obs1, obs2; |
249 | 266 |
250 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); | 267 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); |
251 source_->AddObserver(&obs1); | 268 source_->AddObserver(&obs1); |
252 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); | 269 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); |
253 source_->AddObserver(&obs2); | 270 source_->AddObserver(&obs2); |
254 | 271 |
255 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, | 272 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, |
256 kInterval); | 273 kInterval); |
257 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline, | 274 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline, |
258 kInterval); | 275 kInterval); |
259 task_runner_->RunPendingTasks(); | 276 task_runner_->RunPendingTasks(); |
260 | 277 |
261 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 278 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
262 source_->DidFinishFrame(&obs1, 0); | 279 source_->DidFinishFrame(&obs1, |
263 source_->DidFinishFrame(&obs2, 0); | 280 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
| 281 source_->DidFinishFrame(&obs2, |
| 282 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
264 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 1100, 1100 + kDeadline, | 283 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 1100, 1100 + kDeadline, |
265 kInterval); | 284 kInterval); |
266 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, | 285 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, |
267 kInterval); | 286 kInterval); |
268 task_runner_->RunPendingTasks(); | 287 task_runner_->RunPendingTasks(); |
269 | 288 |
270 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 289 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
271 source_->DidFinishFrame(&obs1, 0); | 290 source_->DidFinishFrame(&obs1, |
272 source_->DidFinishFrame(&obs2, 0); | 291 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); |
| 292 source_->DidFinishFrame(&obs2, |
| 293 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); |
273 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 294 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
274 source_->RemoveObserver(&obs1); | 295 source_->RemoveObserver(&obs1); |
275 source_->RemoveObserver(&obs2); | 296 source_->RemoveObserver(&obs2); |
276 task_runner_->RunPendingTasks(); | 297 task_runner_->RunPendingTasks(); |
277 } | 298 } |
278 | 299 |
279 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversInterleaved) { | 300 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversInterleaved) { |
280 StrictMock<MockBeginFrameObserver> obs1, obs2; | 301 StrictMock<MockBeginFrameObserver> obs1, obs2; |
281 | 302 |
282 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); | 303 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); |
283 source_->AddObserver(&obs1); | 304 source_->AddObserver(&obs1); |
284 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, | 305 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, |
285 kInterval); | 306 kInterval); |
286 task_runner_->RunPendingTasks(); | 307 task_runner_->RunPendingTasks(); |
287 | 308 |
288 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 309 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
289 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); | 310 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); |
290 source_->AddObserver(&obs2); | 311 source_->AddObserver(&obs2); |
291 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, | 312 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, |
292 kInterval); | 313 kInterval); |
293 task_runner_->RunPendingTasks(); | 314 task_runner_->RunPendingTasks(); |
294 | 315 |
295 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 316 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
296 source_->DidFinishFrame(&obs1, 0); | 317 source_->DidFinishFrame(&obs1, |
| 318 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
297 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 3, 1200, 1200 + kDeadline, | 319 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 3, 1200, 1200 + kDeadline, |
298 kInterval); | 320 kInterval); |
299 task_runner_->RunPendingTasks(); | 321 task_runner_->RunPendingTasks(); |
300 | 322 |
301 source_->DidFinishFrame(&obs1, 0); | 323 source_->DidFinishFrame(&obs1, |
| 324 BeginFrameAck(source_->source_id(), 3, 3, 0, true)); |
302 source_->RemoveObserver(&obs1); | 325 source_->RemoveObserver(&obs1); |
303 // Removing all finished observers should disable the time source. | 326 // Removing all finished observers should disable the time source. |
304 EXPECT_FALSE(delay_based_time_source_->Active()); | 327 EXPECT_FALSE(delay_based_time_source_->Active()); |
305 // Finishing the frame for |obs1| posts a begin frame task, which will be | 328 // Finishing the frame for |obs1| posts a begin frame task, which will be |
306 // aborted since |obs1| is removed. Clear that from the task runner. | 329 // aborted since |obs1| is removed. Clear that from the task runner. |
307 task_runner_->RunPendingTasks(); | 330 task_runner_->RunPendingTasks(); |
308 | 331 |
309 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 332 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
310 source_->DidFinishFrame(&obs2, 0); | 333 source_->DidFinishFrame(&obs2, |
| 334 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); |
311 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 4, 1300, 1300 + kDeadline, | 335 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 4, 1300, 1300 + kDeadline, |
312 kInterval); | 336 kInterval); |
313 task_runner_->RunPendingTasks(); | 337 task_runner_->RunPendingTasks(); |
314 | 338 |
315 source_->DidFinishFrame(&obs2, 0); | 339 source_->DidFinishFrame(&obs2, |
| 340 BeginFrameAck(source_->source_id(), 4, 4, 0, true)); |
316 source_->RemoveObserver(&obs2); | 341 source_->RemoveObserver(&obs2); |
317 } | 342 } |
318 | 343 |
319 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversAtOnce) { | 344 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversAtOnce) { |
320 StrictMock<MockBeginFrameObserver> obs1, obs2; | 345 StrictMock<MockBeginFrameObserver> obs1, obs2; |
321 | 346 |
322 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); | 347 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); |
323 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); | 348 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); |
324 source_->AddObserver(&obs1); | 349 source_->AddObserver(&obs1); |
325 source_->AddObserver(&obs2); | 350 source_->AddObserver(&obs2); |
326 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, | 351 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, |
327 kInterval); | 352 kInterval); |
328 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline, | 353 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline, |
329 kInterval); | 354 kInterval); |
330 task_runner_->RunPendingTasks(); | 355 task_runner_->RunPendingTasks(); |
331 | 356 |
332 // |obs1| finishes first. | 357 // |obs1| finishes first. |
333 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 358 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
334 source_->DidFinishFrame(&obs1, 0); | 359 source_->DidFinishFrame(&obs1, |
| 360 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
335 | 361 |
336 // |obs2| finishes also, before getting to the newly posted begin frame. | 362 // |obs2| finishes also, before getting to the newly posted begin frame. |
337 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 363 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
338 source_->DidFinishFrame(&obs2, 0); | 364 source_->DidFinishFrame(&obs2, |
| 365 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
339 | 366 |
340 // Because the begin frame source already ticked when |obs1| finished, | 367 // Because the begin frame source already ticked when |obs1| finished, |
341 // we see it as the frame time for both observers. | 368 // we see it as the frame time for both observers. |
342 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 1100, 1100 + kDeadline, | 369 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 1100, 1100 + kDeadline, |
343 kInterval); | 370 kInterval); |
344 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, | 371 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, |
345 kInterval); | 372 kInterval); |
346 task_runner_->RunPendingTasks(); | 373 task_runner_->RunPendingTasks(); |
347 | 374 |
348 source_->DidFinishFrame(&obs1, 0); | 375 source_->DidFinishFrame(&obs1, |
| 376 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); |
349 source_->RemoveObserver(&obs1); | 377 source_->RemoveObserver(&obs1); |
350 source_->DidFinishFrame(&obs2, 0); | 378 source_->DidFinishFrame(&obs2, |
| 379 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); |
351 source_->RemoveObserver(&obs2); | 380 source_->RemoveObserver(&obs2); |
352 } | 381 } |
353 | 382 |
354 // DelayBasedBeginFrameSource testing ------------------------------------------ | 383 // DelayBasedBeginFrameSource testing ------------------------------------------ |
355 class DelayBasedBeginFrameSourceTest : public ::testing::Test { | 384 class DelayBasedBeginFrameSourceTest : public ::testing::Test { |
356 public: | 385 public: |
357 std::unique_ptr<base::SimpleTestTickClock> now_src_; | 386 std::unique_ptr<base::SimpleTestTickClock> now_src_; |
358 scoped_refptr<OrderedSimpleTaskRunner> task_runner_; | 387 scoped_refptr<OrderedSimpleTaskRunner> task_runner_; |
359 std::unique_ptr<DelayBasedBeginFrameSource> source_; | 388 std::unique_ptr<DelayBasedBeginFrameSource> source_; |
360 std::unique_ptr<MockBeginFrameObserver> obs_; | 389 std::unique_ptr<MockBeginFrameObserver> obs_; |
(...skipping 187 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
548 // Sequence number is incremented again, because the missed frame has | 577 // Sequence number is incremented again, because the missed frame has |
549 // different time/interval. | 578 // different time/interval. |
550 EXPECT_BEGIN_FRAME_USED_MISSED(obs, source_->source_id(), 3, 10000, 20000, | 579 EXPECT_BEGIN_FRAME_USED_MISSED(obs, source_->source_id(), 3, 10000, 20000, |
551 10000); | 580 10000); |
552 source_->AddObserver(&obs); | 581 source_->AddObserver(&obs); |
553 source_->RemoveObserver(&obs); | 582 source_->RemoveObserver(&obs); |
554 } | 583 } |
555 | 584 |
556 } // namespace | 585 } // namespace |
557 } // namespace cc | 586 } // namespace cc |
OLD | NEW |