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 56 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
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, 0, true)); | 77 BeginFrameAck(source_->source_id(), 1, 1, true)); |
78 task_runner_->RunPendingTasks(); | 78 task_runner_->RunPendingTasks(); |
79 } | 79 } |
80 | 80 |
81 TEST_F(BackToBackBeginFrameSourceTest, | 81 TEST_F(BackToBackBeginFrameSourceTest, |
82 RemoveObserverThenDidFinishFrameProducesNoFrame) { | 82 RemoveObserverThenDidFinishFrameProducesNoFrame) { |
83 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 83 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
84 source_->AddObserver(obs_.get()); | 84 source_->AddObserver(obs_.get()); |
85 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 85 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
86 1000 + kDeadline, kInterval); | 86 1000 + kDeadline, kInterval); |
87 task_runner_->RunPendingTasks(); | 87 task_runner_->RunPendingTasks(); |
88 | 88 |
89 source_->RemoveObserver(obs_.get()); | 89 source_->RemoveObserver(obs_.get()); |
90 source_->DidFinishFrame(obs_.get(), | 90 source_->DidFinishFrame(obs_.get(), |
91 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); | 91 BeginFrameAck(source_->source_id(), 1, 1, true)); |
92 | 92 |
93 // 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 |
94 // 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_| |
95 // is removed. | 95 // is removed. |
96 task_runner_->RunPendingTasks(); | 96 task_runner_->RunPendingTasks(); |
97 EXPECT_FALSE(task_runner_->HasPendingTasks()); | 97 EXPECT_FALSE(task_runner_->HasPendingTasks()); |
98 } | 98 } |
99 | 99 |
100 TEST_F(BackToBackBeginFrameSourceTest, | 100 TEST_F(BackToBackBeginFrameSourceTest, |
101 DidFinishFrameThenRemoveObserverProducesNoFrame) { | 101 DidFinishFrameThenRemoveObserverProducesNoFrame) { |
102 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 102 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
103 source_->AddObserver(obs_.get()); | 103 source_->AddObserver(obs_.get()); |
104 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 104 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
105 1000 + kDeadline, kInterval); | 105 1000 + kDeadline, kInterval); |
106 task_runner_->RunPendingTasks(); | 106 task_runner_->RunPendingTasks(); |
107 | 107 |
108 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 108 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
109 source_->DidFinishFrame(obs_.get(), | 109 source_->DidFinishFrame(obs_.get(), |
110 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); | 110 BeginFrameAck(source_->source_id(), 1, 1, true)); |
111 source_->RemoveObserver(obs_.get()); | 111 source_->RemoveObserver(obs_.get()); |
112 | 112 |
113 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 113 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
114 task_runner_->RunPendingTasks(); | 114 task_runner_->RunPendingTasks(); |
115 } | 115 } |
116 | 116 |
117 TEST_F(BackToBackBeginFrameSourceTest, | 117 TEST_F(BackToBackBeginFrameSourceTest, |
118 TogglingObserverThenDidFinishFrameProducesCorrectFrame) { | 118 TogglingObserverThenDidFinishFrameProducesCorrectFrame) { |
119 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 119 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
120 source_->AddObserver(obs_.get()); | 120 source_->AddObserver(obs_.get()); |
121 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 121 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
122 1000 + kDeadline, kInterval); | 122 1000 + kDeadline, kInterval); |
123 task_runner_->RunPendingTasks(); | 123 task_runner_->RunPendingTasks(); |
124 | 124 |
125 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 125 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
126 source_->RemoveObserver(obs_.get()); | 126 source_->RemoveObserver(obs_.get()); |
127 | 127 |
128 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 128 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
129 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 129 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
130 source_->AddObserver(obs_.get()); | 130 source_->AddObserver(obs_.get()); |
131 | 131 |
132 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 132 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
133 source_->DidFinishFrame(obs_.get(), | 133 source_->DidFinishFrame(obs_.get(), |
134 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); | 134 BeginFrameAck(source_->source_id(), 1, 1, true)); |
135 | 135 |
136 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 136 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
137 // 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, |
138 // so it ignores changes to "now" afterward. | 138 // so it ignores changes to "now" afterward. |
139 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1110, | 139 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1110, |
140 1110 + kDeadline, kInterval); | 140 1110 + kDeadline, kInterval); |
141 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 141 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
142 task_runner_->RunPendingTasks(); | 142 task_runner_->RunPendingTasks(); |
143 } | 143 } |
144 | 144 |
145 TEST_F(BackToBackBeginFrameSourceTest, | 145 TEST_F(BackToBackBeginFrameSourceTest, |
146 DidFinishFrameThenTogglingObserverProducesCorrectFrame) { | 146 DidFinishFrameThenTogglingObserverProducesCorrectFrame) { |
147 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 147 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
148 source_->AddObserver(obs_.get()); | 148 source_->AddObserver(obs_.get()); |
149 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 149 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
150 1000 + kDeadline, kInterval); | 150 1000 + kDeadline, kInterval); |
151 task_runner_->RunPendingTasks(); | 151 task_runner_->RunPendingTasks(); |
152 | 152 |
153 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 153 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
154 source_->DidFinishFrame(obs_.get(), | 154 source_->DidFinishFrame(obs_.get(), |
155 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); | 155 BeginFrameAck(source_->source_id(), 1, 1, true)); |
156 | 156 |
157 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 157 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
158 source_->RemoveObserver(obs_.get()); | 158 source_->RemoveObserver(obs_.get()); |
159 | 159 |
160 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 160 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
161 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 161 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
162 source_->AddObserver(obs_.get()); | 162 source_->AddObserver(obs_.get()); |
163 | 163 |
164 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 164 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
165 // 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 |
166 // last change to "now". | 166 // last change to "now". |
167 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1120, | 167 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1120, |
168 1120 + kDeadline, kInterval); | 168 1120 + kDeadline, kInterval); |
169 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 169 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
170 task_runner_->RunPendingTasks(); | 170 task_runner_->RunPendingTasks(); |
171 } | 171 } |
172 | 172 |
173 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameNoObserver) { | 173 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameNoObserver) { |
174 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 174 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
175 source_->AddObserver(obs_.get()); | 175 source_->AddObserver(obs_.get()); |
176 source_->RemoveObserver(obs_.get()); | 176 source_->RemoveObserver(obs_.get()); |
177 source_->DidFinishFrame(obs_.get(), | 177 source_->DidFinishFrame(obs_.get(), |
178 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); | 178 BeginFrameAck(source_->source_id(), 1, 1, true)); |
179 EXPECT_FALSE(task_runner_->RunPendingTasks()); | 179 EXPECT_FALSE(task_runner_->RunPendingTasks()); |
180 } | 180 } |
181 | 181 |
182 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameRemainingFrames) { | |
183 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | |
184 source_->AddObserver(obs_.get()); | |
185 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | |
186 1000 + kDeadline, kInterval); | |
187 // Runs the pending begin frame. | |
188 task_runner_->RunPendingTasks(); | |
189 // While running the begin frame, the next frame was cancelled, this | |
190 // runs the next frame, sees it was cancelled, and goes to sleep. | |
191 task_runner_->RunPendingTasks(); | |
192 EXPECT_FALSE(task_runner_->HasPendingTasks()); | |
193 | |
194 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | |
195 | |
196 source_->DidFinishFrame(obs_.get(), | |
197 BeginFrameAck(source_->source_id(), 1, 1, 3, true)); | |
198 EXPECT_FALSE(task_runner_->HasPendingTasks()); | |
199 source_->DidFinishFrame(obs_.get(), | |
200 BeginFrameAck(source_->source_id(), 1, 1, 2, true)); | |
201 EXPECT_FALSE(task_runner_->HasPendingTasks()); | |
202 source_->DidFinishFrame(obs_.get(), | |
203 BeginFrameAck(source_->source_id(), 1, 1, 1, true)); | |
204 EXPECT_FALSE(task_runner_->HasPendingTasks()); | |
205 | |
206 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, | |
207 1100 + kDeadline, kInterval); | |
208 source_->DidFinishFrame(obs_.get(), | |
209 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); | |
210 EXPECT_EQ(base::TimeDelta(), task_runner_->DelayToNextTaskTime()); | |
211 task_runner_->RunPendingTasks(); | |
212 } | |
213 | |
214 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameMultipleCallsIdempotent) { | 182 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameMultipleCallsIdempotent) { |
215 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 183 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
216 source_->AddObserver(obs_.get()); | 184 source_->AddObserver(obs_.get()); |
217 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 185 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
218 1000 + kDeadline, kInterval); | 186 1000 + kDeadline, kInterval); |
219 task_runner_->RunPendingTasks(); | 187 task_runner_->RunPendingTasks(); |
220 | 188 |
221 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 189 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
222 source_->DidFinishFrame(obs_.get(), | 190 source_->DidFinishFrame(obs_.get(), |
223 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); | 191 BeginFrameAck(source_->source_id(), 1, 1, true)); |
224 source_->DidFinishFrame(obs_.get(), | 192 source_->DidFinishFrame(obs_.get(), |
225 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); | 193 BeginFrameAck(source_->source_id(), 1, 1, true)); |
226 source_->DidFinishFrame(obs_.get(), | 194 source_->DidFinishFrame(obs_.get(), |
227 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); | 195 BeginFrameAck(source_->source_id(), 1, 1, true)); |
228 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, | 196 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, |
229 1100 + kDeadline, kInterval); | 197 1100 + kDeadline, kInterval); |
230 task_runner_->RunPendingTasks(); | 198 task_runner_->RunPendingTasks(); |
231 | 199 |
232 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 200 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
233 source_->DidFinishFrame(obs_.get(), | 201 source_->DidFinishFrame(obs_.get(), |
234 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); | 202 BeginFrameAck(source_->source_id(), 2, 2, true)); |
235 source_->DidFinishFrame(obs_.get(), | 203 source_->DidFinishFrame(obs_.get(), |
236 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); | 204 BeginFrameAck(source_->source_id(), 2, 2, true)); |
237 source_->DidFinishFrame(obs_.get(), | 205 source_->DidFinishFrame(obs_.get(), |
238 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); | 206 BeginFrameAck(source_->source_id(), 2, 2, true)); |
239 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 3, 1200, | 207 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 3, 1200, |
240 1200 + kDeadline, kInterval); | 208 1200 + kDeadline, kInterval); |
241 task_runner_->RunPendingTasks(); | 209 task_runner_->RunPendingTasks(); |
242 } | 210 } |
243 | 211 |
244 TEST_F(BackToBackBeginFrameSourceTest, DelayInPostedTaskProducesCorrectFrame) { | 212 TEST_F(BackToBackBeginFrameSourceTest, DelayInPostedTaskProducesCorrectFrame) { |
245 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 213 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
246 source_->AddObserver(obs_.get()); | 214 source_->AddObserver(obs_.get()); |
247 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, | 215 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
248 1000 + kDeadline, kInterval); | 216 1000 + kDeadline, kInterval); |
249 task_runner_->RunPendingTasks(); | 217 task_runner_->RunPendingTasks(); |
250 | 218 |
251 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 219 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
252 source_->DidFinishFrame(obs_.get(), | 220 source_->DidFinishFrame(obs_.get(), |
253 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); | 221 BeginFrameAck(source_->source_id(), 1, 1, true)); |
254 now_src_->Advance(base::TimeDelta::FromMicroseconds(50)); | 222 now_src_->Advance(base::TimeDelta::FromMicroseconds(50)); |
255 // Ticks at the time the last frame finished, so ignores the last change to | 223 // Ticks at the time the last frame finished, so ignores the last change to |
256 // "now". | 224 // "now". |
257 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, | 225 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, |
258 1100 + kDeadline, kInterval); | 226 1100 + kDeadline, kInterval); |
259 | 227 |
260 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 228 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
261 task_runner_->RunPendingTasks(); | 229 task_runner_->RunPendingTasks(); |
262 } | 230 } |
263 | 231 |
264 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversSynchronized) { | 232 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversSynchronized) { |
265 StrictMock<MockBeginFrameObserver> obs1, obs2; | 233 StrictMock<MockBeginFrameObserver> obs1, obs2; |
266 | 234 |
267 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); | 235 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); |
268 source_->AddObserver(&obs1); | 236 source_->AddObserver(&obs1); |
269 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); | 237 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); |
270 source_->AddObserver(&obs2); | 238 source_->AddObserver(&obs2); |
271 | 239 |
272 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, | 240 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, |
273 kInterval); | 241 kInterval); |
274 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline, | 242 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline, |
275 kInterval); | 243 kInterval); |
276 task_runner_->RunPendingTasks(); | 244 task_runner_->RunPendingTasks(); |
277 | 245 |
278 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 246 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
279 source_->DidFinishFrame(&obs1, | 247 source_->DidFinishFrame(&obs1, |
280 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); | 248 BeginFrameAck(source_->source_id(), 1, 1, true)); |
281 source_->DidFinishFrame(&obs2, | 249 source_->DidFinishFrame(&obs2, |
282 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); | 250 BeginFrameAck(source_->source_id(), 1, 1, true)); |
283 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 1100, 1100 + kDeadline, | 251 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 1100, 1100 + kDeadline, |
284 kInterval); | 252 kInterval); |
285 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, | 253 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, |
286 kInterval); | 254 kInterval); |
287 task_runner_->RunPendingTasks(); | 255 task_runner_->RunPendingTasks(); |
288 | 256 |
289 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 257 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
290 source_->DidFinishFrame(&obs1, | 258 source_->DidFinishFrame(&obs1, |
291 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); | 259 BeginFrameAck(source_->source_id(), 2, 2, true)); |
292 source_->DidFinishFrame(&obs2, | 260 source_->DidFinishFrame(&obs2, |
293 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); | 261 BeginFrameAck(source_->source_id(), 2, 2, true)); |
294 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 262 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
295 source_->RemoveObserver(&obs1); | 263 source_->RemoveObserver(&obs1); |
296 source_->RemoveObserver(&obs2); | 264 source_->RemoveObserver(&obs2); |
297 task_runner_->RunPendingTasks(); | 265 task_runner_->RunPendingTasks(); |
298 } | 266 } |
299 | 267 |
300 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversInterleaved) { | 268 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversInterleaved) { |
301 StrictMock<MockBeginFrameObserver> obs1, obs2; | 269 StrictMock<MockBeginFrameObserver> obs1, obs2; |
302 | 270 |
303 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); | 271 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); |
304 source_->AddObserver(&obs1); | 272 source_->AddObserver(&obs1); |
305 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, | 273 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, |
306 kInterval); | 274 kInterval); |
307 task_runner_->RunPendingTasks(); | 275 task_runner_->RunPendingTasks(); |
308 | 276 |
309 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 277 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
310 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); | 278 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); |
311 source_->AddObserver(&obs2); | 279 source_->AddObserver(&obs2); |
312 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, | 280 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, |
313 kInterval); | 281 kInterval); |
314 task_runner_->RunPendingTasks(); | 282 task_runner_->RunPendingTasks(); |
315 | 283 |
316 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 284 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
317 source_->DidFinishFrame(&obs1, | 285 source_->DidFinishFrame(&obs1, |
318 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); | 286 BeginFrameAck(source_->source_id(), 1, 1, true)); |
319 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 3, 1200, 1200 + kDeadline, | 287 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 3, 1200, 1200 + kDeadline, |
320 kInterval); | 288 kInterval); |
321 task_runner_->RunPendingTasks(); | 289 task_runner_->RunPendingTasks(); |
322 | 290 |
323 source_->DidFinishFrame(&obs1, | 291 source_->DidFinishFrame(&obs1, |
324 BeginFrameAck(source_->source_id(), 3, 3, 0, true)); | 292 BeginFrameAck(source_->source_id(), 3, 3, true)); |
325 source_->RemoveObserver(&obs1); | 293 source_->RemoveObserver(&obs1); |
326 // Removing all finished observers should disable the time source. | 294 // Removing all finished observers should disable the time source. |
327 EXPECT_FALSE(delay_based_time_source_->Active()); | 295 EXPECT_FALSE(delay_based_time_source_->Active()); |
328 // Finishing the frame for |obs1| posts a begin frame task, which will be | 296 // Finishing the frame for |obs1| posts a begin frame task, which will be |
329 // aborted since |obs1| is removed. Clear that from the task runner. | 297 // aborted since |obs1| is removed. Clear that from the task runner. |
330 task_runner_->RunPendingTasks(); | 298 task_runner_->RunPendingTasks(); |
331 | 299 |
332 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 300 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
333 source_->DidFinishFrame(&obs2, | 301 source_->DidFinishFrame(&obs2, |
334 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); | 302 BeginFrameAck(source_->source_id(), 2, 2, true)); |
335 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 4, 1300, 1300 + kDeadline, | 303 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 4, 1300, 1300 + kDeadline, |
336 kInterval); | 304 kInterval); |
337 task_runner_->RunPendingTasks(); | 305 task_runner_->RunPendingTasks(); |
338 | 306 |
339 source_->DidFinishFrame(&obs2, | 307 source_->DidFinishFrame(&obs2, |
340 BeginFrameAck(source_->source_id(), 4, 4, 0, true)); | 308 BeginFrameAck(source_->source_id(), 4, 4, true)); |
341 source_->RemoveObserver(&obs2); | 309 source_->RemoveObserver(&obs2); |
342 } | 310 } |
343 | 311 |
344 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversAtOnce) { | 312 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversAtOnce) { |
345 StrictMock<MockBeginFrameObserver> obs1, obs2; | 313 StrictMock<MockBeginFrameObserver> obs1, obs2; |
346 | 314 |
347 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); | 315 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); |
348 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); | 316 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); |
349 source_->AddObserver(&obs1); | 317 source_->AddObserver(&obs1); |
350 source_->AddObserver(&obs2); | 318 source_->AddObserver(&obs2); |
351 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, | 319 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, |
352 kInterval); | 320 kInterval); |
353 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline, | 321 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline, |
354 kInterval); | 322 kInterval); |
355 task_runner_->RunPendingTasks(); | 323 task_runner_->RunPendingTasks(); |
356 | 324 |
357 // |obs1| finishes first. | 325 // |obs1| finishes first. |
358 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 326 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
359 source_->DidFinishFrame(&obs1, | 327 source_->DidFinishFrame(&obs1, |
360 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); | 328 BeginFrameAck(source_->source_id(), 1, 1, true)); |
361 | 329 |
362 // |obs2| finishes also, before getting to the newly posted begin frame. | 330 // |obs2| finishes also, before getting to the newly posted begin frame. |
363 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 331 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
364 source_->DidFinishFrame(&obs2, | 332 source_->DidFinishFrame(&obs2, |
365 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); | 333 BeginFrameAck(source_->source_id(), 1, 1, true)); |
366 | 334 |
367 // Because the begin frame source already ticked when |obs1| finished, | 335 // Because the begin frame source already ticked when |obs1| finished, |
368 // we see it as the frame time for both observers. | 336 // we see it as the frame time for both observers. |
369 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 1100, 1100 + kDeadline, | 337 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 1100, 1100 + kDeadline, |
370 kInterval); | 338 kInterval); |
371 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, | 339 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, |
372 kInterval); | 340 kInterval); |
373 task_runner_->RunPendingTasks(); | 341 task_runner_->RunPendingTasks(); |
374 | 342 |
375 source_->DidFinishFrame(&obs1, | 343 source_->DidFinishFrame(&obs1, |
376 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); | 344 BeginFrameAck(source_->source_id(), 2, 2, true)); |
377 source_->RemoveObserver(&obs1); | 345 source_->RemoveObserver(&obs1); |
378 source_->DidFinishFrame(&obs2, | 346 source_->DidFinishFrame(&obs2, |
379 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); | 347 BeginFrameAck(source_->source_id(), 2, 2, true)); |
380 source_->RemoveObserver(&obs2); | 348 source_->RemoveObserver(&obs2); |
381 } | 349 } |
382 | 350 |
383 // DelayBasedBeginFrameSource testing ------------------------------------------ | 351 // DelayBasedBeginFrameSource testing ------------------------------------------ |
384 class DelayBasedBeginFrameSourceTest : public ::testing::Test { | 352 class DelayBasedBeginFrameSourceTest : public ::testing::Test { |
385 public: | 353 public: |
386 std::unique_ptr<base::SimpleTestTickClock> now_src_; | 354 std::unique_ptr<base::SimpleTestTickClock> now_src_; |
387 scoped_refptr<OrderedSimpleTaskRunner> task_runner_; | 355 scoped_refptr<OrderedSimpleTaskRunner> task_runner_; |
388 std::unique_ptr<DelayBasedBeginFrameSource> source_; | 356 std::unique_ptr<DelayBasedBeginFrameSource> source_; |
389 std::unique_ptr<MockBeginFrameObserver> obs_; | 357 std::unique_ptr<MockBeginFrameObserver> obs_; |
(...skipping 250 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
640 tracker_->OnObserverRemoved(&obs1_); | 608 tracker_->OnObserverRemoved(&obs1_); |
641 EXPECT_ACK_TRACKER_STATE(true, false, 1u); | 609 EXPECT_ACK_TRACKER_STATE(true, false, 1u); |
642 | 610 |
643 // After adding it back, the BeginFrame is again not finished or confirmed. | 611 // After adding it back, the BeginFrame is again not finished or confirmed. |
644 tracker_->OnObserverAdded(&obs1_); | 612 tracker_->OnObserverAdded(&obs1_); |
645 EXPECT_ACK_TRACKER_STATE(false, false, 0u); // up to date to previous frame. | 613 EXPECT_ACK_TRACKER_STATE(false, false, 0u); // up to date to previous frame. |
646 | 614 |
647 // When the observer finishes and confirms, the BeginFrame is finished | 615 // When the observer finishes and confirms, the BeginFrame is finished |
648 // and confirmed. | 616 // and confirmed. |
649 obs1_.OnBeginFrame(current_args_); | 617 obs1_.OnBeginFrame(current_args_); |
650 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 1, 1, 0, false)); | 618 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 1, 1, false)); |
651 EXPECT_ACK_TRACKER_STATE(true, false, 1u); | 619 EXPECT_ACK_TRACKER_STATE(true, false, 1u); |
652 | 620 |
653 // A new BeginFrame is initially not finished or confirmed. | 621 // A new BeginFrame is initially not finished or confirmed. |
654 current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 2); | 622 current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 2); |
655 tracker_->OnBeginFrame(current_args_); | 623 tracker_->OnBeginFrame(current_args_); |
656 EXPECT_ACK_TRACKER_STATE(false, false, 1u); | 624 EXPECT_ACK_TRACKER_STATE(false, false, 1u); |
657 | 625 |
658 // Stray ACK for an old BeginFrame is ignored. | 626 // Stray ACK for an old BeginFrame is ignored. |
659 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 1, 1, 0, false)); | 627 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 1, 1, false)); |
660 EXPECT_ACK_TRACKER_STATE(false, false, 1u); | 628 EXPECT_ACK_TRACKER_STATE(false, false, 1u); |
661 | 629 |
662 // When the observer finishes but doesn't confirm, the BeginFrame is finished | 630 // When the observer finishes but doesn't confirm, the BeginFrame is finished |
663 // but not confirmed. | 631 // but not confirmed. |
664 obs1_.OnBeginFrame(current_args_); | 632 obs1_.OnBeginFrame(current_args_); |
665 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 2, 1, 0, false)); | 633 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 2, 1, false)); |
666 EXPECT_ACK_TRACKER_STATE(true, false, 1u); | 634 EXPECT_ACK_TRACKER_STATE(true, false, 1u); |
667 | 635 |
668 // Damage from ACK propagates. | 636 // Damage from ACK propagates. |
669 current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 3); | 637 current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 3); |
670 tracker_->OnBeginFrame(current_args_); | 638 tracker_->OnBeginFrame(current_args_); |
671 EXPECT_ACK_TRACKER_STATE(false, false, 1u); | 639 EXPECT_ACK_TRACKER_STATE(false, false, 1u); |
672 obs1_.OnBeginFrame(current_args_); | 640 obs1_.OnBeginFrame(current_args_); |
673 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 3, 3, 0, true)); | 641 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 3, 3, true)); |
674 EXPECT_ACK_TRACKER_STATE(true, true, 3u); | 642 EXPECT_ACK_TRACKER_STATE(true, true, 3u); |
675 | 643 |
676 // Removing an out-of-date observer confirms the latest BeginFrame. | 644 // Removing an out-of-date observer confirms the latest BeginFrame. |
677 current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 4); | 645 current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 4); |
678 tracker_->OnBeginFrame(current_args_); | 646 tracker_->OnBeginFrame(current_args_); |
679 EXPECT_ACK_TRACKER_STATE(false, false, 3u); | 647 EXPECT_ACK_TRACKER_STATE(false, false, 3u); |
680 obs1_.OnBeginFrame(current_args_); | 648 obs1_.OnBeginFrame(current_args_); |
681 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 4, 3, 0, false)); | 649 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 4, 3, false)); |
682 EXPECT_ACK_TRACKER_STATE(true, false, 3u); | 650 EXPECT_ACK_TRACKER_STATE(true, false, 3u); |
683 tracker_->OnObserverRemoved(&obs1_); | 651 tracker_->OnObserverRemoved(&obs1_); |
684 EXPECT_ACK_TRACKER_STATE(true, false, 4u); | 652 EXPECT_ACK_TRACKER_STATE(true, false, 4u); |
685 } | 653 } |
686 | 654 |
687 TEST_F(BeginFrameObserverAckTrackerTest, CorrectnessWith2Observers) { | 655 TEST_F(BeginFrameObserverAckTrackerTest, CorrectnessWith2Observers) { |
688 // Check initial state. | 656 // Check initial state. |
689 EXPECT_ACK_TRACKER_STATE(true, false, 1u); | 657 EXPECT_ACK_TRACKER_STATE(true, false, 1u); |
690 | 658 |
691 // After adding observers, the BeginFrame is not finished or confirmed. | 659 // After adding observers, the BeginFrame is not finished or confirmed. |
692 tracker_->OnObserverAdded(&obs1_); | 660 tracker_->OnObserverAdded(&obs1_); |
693 EXPECT_ACK_TRACKER_STATE(false, false, 0u); // up to date to previous frame. | 661 EXPECT_ACK_TRACKER_STATE(false, false, 0u); // up to date to previous frame. |
694 tracker_->OnObserverAdded(&obs2_); | 662 tracker_->OnObserverAdded(&obs2_); |
695 EXPECT_ACK_TRACKER_STATE(false, false, 0u); // up to date to previous frame. | 663 EXPECT_ACK_TRACKER_STATE(false, false, 0u); // up to date to previous frame. |
696 | 664 |
697 // Removing one of them changes nothing. Same for adding back. | 665 // Removing one of them changes nothing. Same for adding back. |
698 tracker_->OnObserverRemoved(&obs1_); | 666 tracker_->OnObserverRemoved(&obs1_); |
699 EXPECT_ACK_TRACKER_STATE(false, false, 0u); | 667 EXPECT_ACK_TRACKER_STATE(false, false, 0u); |
700 tracker_->OnObserverAdded(&obs1_); | 668 tracker_->OnObserverAdded(&obs1_); |
701 EXPECT_ACK_TRACKER_STATE(false, false, 0u); | 669 EXPECT_ACK_TRACKER_STATE(false, false, 0u); |
702 | 670 |
703 // When one observer finishes and confirms, nothing changes. | 671 // When one observer finishes and confirms, nothing changes. |
704 obs1_.OnBeginFrame(current_args_); | 672 obs1_.OnBeginFrame(current_args_); |
705 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 1, 1, 0, false)); | 673 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 1, 1, false)); |
706 EXPECT_ACK_TRACKER_STATE(false, false, 0u); | 674 EXPECT_ACK_TRACKER_STATE(false, false, 0u); |
707 // When both finish and confirm, the BeginFrame is finished and confirmed. | 675 // When both finish and confirm, the BeginFrame is finished and confirmed. |
708 obs2_.OnBeginFrame(current_args_); | 676 obs2_.OnBeginFrame(current_args_); |
709 tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 1, 1, 0, false)); | 677 tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 1, 1, false)); |
710 EXPECT_ACK_TRACKER_STATE(true, false, 1u); | 678 EXPECT_ACK_TRACKER_STATE(true, false, 1u); |
711 | 679 |
712 // A new BeginFrame is not finished or confirmed. | 680 // A new BeginFrame is not finished or confirmed. |
713 current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 2); | 681 current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 2); |
714 tracker_->OnBeginFrame(current_args_); | 682 tracker_->OnBeginFrame(current_args_); |
715 EXPECT_ACK_TRACKER_STATE(false, false, 1u); | 683 EXPECT_ACK_TRACKER_STATE(false, false, 1u); |
716 | 684 |
717 // When both observers finish but only one confirms, the BeginFrame is | 685 // When both observers finish but only one confirms, the BeginFrame is |
718 // finished but not confirmed. | 686 // finished but not confirmed. |
719 obs1_.OnBeginFrame(current_args_); | 687 obs1_.OnBeginFrame(current_args_); |
720 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 2, 2, 0, false)); | 688 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 2, 2, false)); |
721 EXPECT_ACK_TRACKER_STATE(false, false, 1u); | 689 EXPECT_ACK_TRACKER_STATE(false, false, 1u); |
722 obs2_.OnBeginFrame(current_args_); | 690 obs2_.OnBeginFrame(current_args_); |
723 tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 2, 1, 0, false)); | 691 tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 2, 1, false)); |
724 EXPECT_ACK_TRACKER_STATE(true, false, 1u); | 692 EXPECT_ACK_TRACKER_STATE(true, false, 1u); |
725 | 693 |
726 // With reversed confirmations in the next ACKs, the latest confirmed frame | 694 // With reversed confirmations in the next ACKs, the latest confirmed frame |
727 // increases but the latest BeginFrame remains unconfirmed. | 695 // increases but the latest BeginFrame remains unconfirmed. |
728 current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 3); | 696 current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 3); |
729 tracker_->OnBeginFrame(current_args_); | 697 tracker_->OnBeginFrame(current_args_); |
730 EXPECT_ACK_TRACKER_STATE(false, false, 1u); | 698 EXPECT_ACK_TRACKER_STATE(false, false, 1u); |
731 obs1_.OnBeginFrame(current_args_); | 699 obs1_.OnBeginFrame(current_args_); |
732 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 3, 2, 0, false)); | 700 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 3, 2, false)); |
733 EXPECT_ACK_TRACKER_STATE(false, false, 1u); | 701 EXPECT_ACK_TRACKER_STATE(false, false, 1u); |
734 obs2_.OnBeginFrame(current_args_); | 702 obs2_.OnBeginFrame(current_args_); |
735 tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 3, 3, 0, false)); | 703 tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 3, 3, false)); |
736 EXPECT_ACK_TRACKER_STATE(true, false, 2u); | 704 EXPECT_ACK_TRACKER_STATE(true, false, 2u); |
737 | 705 |
738 // Only a single ACK with damage suffices. | 706 // Only a single ACK with damage suffices. |
739 current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 4); | 707 current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 4); |
740 tracker_->OnBeginFrame(current_args_); | 708 tracker_->OnBeginFrame(current_args_); |
741 EXPECT_ACK_TRACKER_STATE(false, false, 2u); | 709 EXPECT_ACK_TRACKER_STATE(false, false, 2u); |
742 obs1_.OnBeginFrame(current_args_); | 710 obs1_.OnBeginFrame(current_args_); |
743 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 4, 4, 0, true)); | 711 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 4, 4, true)); |
744 EXPECT_ACK_TRACKER_STATE(false, true, 3u); | 712 EXPECT_ACK_TRACKER_STATE(false, true, 3u); |
745 obs2_.OnBeginFrame(current_args_); | 713 obs2_.OnBeginFrame(current_args_); |
746 tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 4, 4, 0, false)); | 714 tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 4, 4, false)); |
747 EXPECT_ACK_TRACKER_STATE(true, true, 4u); | 715 EXPECT_ACK_TRACKER_STATE(true, true, 4u); |
748 | 716 |
749 // Removing the damaging observer makes no difference in this case. | 717 // Removing the damaging observer makes no difference in this case. |
750 tracker_->OnObserverRemoved(&obs1_); | 718 tracker_->OnObserverRemoved(&obs1_); |
751 EXPECT_ACK_TRACKER_STATE(true, true, 4u); | 719 EXPECT_ACK_TRACKER_STATE(true, true, 4u); |
752 | 720 |
753 // Adding the observer back considers it up to date up to the current | 721 // Adding the observer back considers it up to date up to the current |
754 // BeginFrame, because it is the last used one. Thus, the current BeginFrame | 722 // BeginFrame, because it is the last used one. Thus, the current BeginFrame |
755 // is still finished, too. | 723 // is still finished, too. |
756 tracker_->OnObserverAdded(&obs1_); | 724 tracker_->OnObserverAdded(&obs1_); |
757 EXPECT_ACK_TRACKER_STATE(true, true, 4u); | 725 EXPECT_ACK_TRACKER_STATE(true, true, 4u); |
758 | 726 |
759 // Adding the observer back after the next BeginFrame considers it up to date | 727 // Adding the observer back after the next BeginFrame considers it up to date |
760 // up to last BeginFrame only. | 728 // up to last BeginFrame only. |
761 tracker_->OnObserverRemoved(&obs1_); | 729 tracker_->OnObserverRemoved(&obs1_); |
762 current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 5); | 730 current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 0, 5); |
763 tracker_->OnBeginFrame(current_args_); | 731 tracker_->OnBeginFrame(current_args_); |
764 tracker_->OnObserverAdded(&obs1_); | 732 tracker_->OnObserverAdded(&obs1_); |
765 EXPECT_ACK_TRACKER_STATE(false, false, 4u); | 733 EXPECT_ACK_TRACKER_STATE(false, false, 4u); |
766 // Both observers need to finish for the BeginFrame to be finished. | 734 // Both observers need to finish for the BeginFrame to be finished. |
767 obs1_.OnBeginFrame(current_args_); | 735 obs1_.OnBeginFrame(current_args_); |
768 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 5, 5, 0, false)); | 736 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(0, 5, 5, false)); |
769 EXPECT_ACK_TRACKER_STATE(false, false, 4u); | 737 EXPECT_ACK_TRACKER_STATE(false, false, 4u); |
770 obs2_.OnBeginFrame(current_args_); | 738 obs2_.OnBeginFrame(current_args_); |
771 tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 5, 5, 0, false)); | 739 tracker_->OnObserverFinishedFrame(&obs2_, BeginFrameAck(0, 5, 5, false)); |
772 EXPECT_ACK_TRACKER_STATE(true, false, 5u); | 740 EXPECT_ACK_TRACKER_STATE(true, false, 5u); |
773 } | 741 } |
774 | 742 |
775 TEST_F(BeginFrameObserverAckTrackerTest, ChangingSourceIdOnBeginFrame) { | 743 TEST_F(BeginFrameObserverAckTrackerTest, ChangingSourceIdOnBeginFrame) { |
776 // Check initial state. | 744 // Check initial state. |
777 EXPECT_ACK_TRACKER_STATE(true, false, 1u); | 745 EXPECT_ACK_TRACKER_STATE(true, false, 1u); |
778 | 746 |
779 // Changing source id without observer updates confirmed BeginFrame. | 747 // Changing source id without observer updates confirmed BeginFrame. |
780 current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 1, 10); | 748 current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 1, 10); |
781 tracker_->OnBeginFrame(current_args_); | 749 tracker_->OnBeginFrame(current_args_); |
782 EXPECT_ACK_TRACKER_STATE(true, false, 10u); | 750 EXPECT_ACK_TRACKER_STATE(true, false, 10u); |
783 | 751 |
784 // Setup an observer for current BeginFrame. | 752 // Setup an observer for current BeginFrame. |
785 tracker_->OnObserverAdded(&obs1_); | 753 tracker_->OnObserverAdded(&obs1_); |
786 EXPECT_ACK_TRACKER_STATE(false, false, 9u); // up to date to previous frame. | 754 EXPECT_ACK_TRACKER_STATE(false, false, 9u); // up to date to previous frame. |
787 obs1_.OnBeginFrame(current_args_); | 755 obs1_.OnBeginFrame(current_args_); |
788 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(1, 10, 10, 0, true)); | 756 tracker_->OnObserverFinishedFrame(&obs1_, BeginFrameAck(1, 10, 10, true)); |
789 EXPECT_ACK_TRACKER_STATE(true, true, 10u); | 757 EXPECT_ACK_TRACKER_STATE(true, true, 10u); |
790 | 758 |
791 // Changing source id with an observer sets confirmed BeginFrame to invalid. | 759 // Changing source id with an observer sets confirmed BeginFrame to invalid. |
792 current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 2, 20); | 760 current_args_ = CreateBeginFrameArgsForTesting(BEGINFRAME_FROM_HERE, 2, 20); |
793 tracker_->OnBeginFrame(current_args_); | 761 tracker_->OnBeginFrame(current_args_); |
794 EXPECT_ACK_TRACKER_STATE(false, false, BeginFrameArgs::kInvalidFrameNumber); | 762 EXPECT_ACK_TRACKER_STATE(false, false, BeginFrameArgs::kInvalidFrameNumber); |
795 } | 763 } |
796 | 764 |
797 // ExternalBeginFrameSource testing -------------------------------------------- | 765 // ExternalBeginFrameSource testing -------------------------------------------- |
798 class MockExternalBeginFrameSourceClient | 766 class MockExternalBeginFrameSourceClient |
(...skipping 15 matching lines...) Expand all Loading... |
814 obs_.reset(new MockBeginFrameObserver); | 782 obs_.reset(new MockBeginFrameObserver); |
815 } | 783 } |
816 | 784 |
817 void TearDown() override { | 785 void TearDown() override { |
818 client_.reset(); | 786 client_.reset(); |
819 obs_.reset(); | 787 obs_.reset(); |
820 } | 788 } |
821 }; | 789 }; |
822 | 790 |
823 TEST_F(ExternalBeginFrameSourceTest, CallsOnDidFinishFrameWithoutObservers) { | 791 TEST_F(ExternalBeginFrameSourceTest, CallsOnDidFinishFrameWithoutObservers) { |
824 EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 2, 0, false))) | 792 EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 2, false))) |
825 .Times(1); | 793 .Times(1); |
826 source_->OnBeginFrame(CreateBeginFrameArgsForTesting( | 794 source_->OnBeginFrame(CreateBeginFrameArgsForTesting( |
827 BEGINFRAME_FROM_HERE, 0, 2, base::TimeTicks::FromInternalValue(10000))); | 795 BEGINFRAME_FROM_HERE, 0, 2, base::TimeTicks::FromInternalValue(10000))); |
828 } | 796 } |
829 | 797 |
830 TEST_F(ExternalBeginFrameSourceTest, | 798 TEST_F(ExternalBeginFrameSourceTest, |
831 CallsOnDidFinishFrameWhenObserverFinishes) { | 799 CallsOnDidFinishFrameWhenObserverFinishes) { |
832 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 800 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
833 EXPECT_CALL((*client_), OnNeedsBeginFrames(true)).Times(1); | 801 EXPECT_CALL((*client_), OnNeedsBeginFrames(true)).Times(1); |
834 source_->AddObserver(obs_.get()); | 802 source_->AddObserver(obs_.get()); |
835 | 803 |
836 BeginFrameArgs args = CreateBeginFrameArgsForTesting( | 804 BeginFrameArgs args = CreateBeginFrameArgsForTesting( |
837 BEGINFRAME_FROM_HERE, 0, 2, base::TimeTicks::FromInternalValue(10000)); | 805 BEGINFRAME_FROM_HERE, 0, 2, base::TimeTicks::FromInternalValue(10000)); |
838 EXPECT_BEGIN_FRAME_ARGS_USED(*obs_, args); | 806 EXPECT_BEGIN_FRAME_ARGS_USED(*obs_, args); |
839 source_->OnBeginFrame(args); | 807 source_->OnBeginFrame(args); |
840 | 808 |
841 EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 2, 0, true))) | 809 EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 2, true))) |
842 .Times(1); | 810 .Times(1); |
843 source_->DidFinishFrame(obs_.get(), BeginFrameAck(0, 2, 2, 0, true)); | 811 source_->DidFinishFrame(obs_.get(), BeginFrameAck(0, 2, 2, true)); |
844 | 812 |
845 args = CreateBeginFrameArgsForTesting( | 813 args = CreateBeginFrameArgsForTesting( |
846 BEGINFRAME_FROM_HERE, 0, 3, base::TimeTicks::FromInternalValue(20000)); | 814 BEGINFRAME_FROM_HERE, 0, 3, base::TimeTicks::FromInternalValue(20000)); |
847 EXPECT_BEGIN_FRAME_ARGS_USED(*obs_, args); | 815 EXPECT_BEGIN_FRAME_ARGS_USED(*obs_, args); |
848 source_->OnBeginFrame(args); | 816 source_->OnBeginFrame(args); |
849 | 817 |
850 EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 3, 2, 0, false))) | 818 EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 3, 2, false))) |
851 .Times(1); | 819 .Times(1); |
852 source_->DidFinishFrame(obs_.get(), BeginFrameAck(0, 3, 2, 0, false)); | 820 source_->DidFinishFrame(obs_.get(), BeginFrameAck(0, 3, 2, false)); |
853 } | 821 } |
854 | 822 |
855 TEST_F(ExternalBeginFrameSourceTest, | 823 TEST_F(ExternalBeginFrameSourceTest, |
856 CallsOnDidFinishFrameWhenObserverDropsBeginFrame) { | 824 CallsOnDidFinishFrameWhenObserverDropsBeginFrame) { |
857 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 825 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
858 EXPECT_CALL((*client_), OnNeedsBeginFrames(true)).Times(1); | 826 EXPECT_CALL((*client_), OnNeedsBeginFrames(true)).Times(1); |
859 source_->AddObserver(obs_.get()); | 827 source_->AddObserver(obs_.get()); |
860 | 828 |
861 BeginFrameArgs args = CreateBeginFrameArgsForTesting( | 829 BeginFrameArgs args = CreateBeginFrameArgsForTesting( |
862 BEGINFRAME_FROM_HERE, 0, 2, base::TimeTicks::FromInternalValue(10000)); | 830 BEGINFRAME_FROM_HERE, 0, 2, base::TimeTicks::FromInternalValue(10000)); |
863 EXPECT_BEGIN_FRAME_ARGS_DROP(*obs_, args); | 831 EXPECT_BEGIN_FRAME_ARGS_DROP(*obs_, args); |
864 source_->OnBeginFrame(args); | 832 source_->OnBeginFrame(args); |
865 EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 0, 0, false))) | 833 EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 0, false))) |
866 .Times(1); | 834 .Times(1); |
867 source_->DidFinishFrame(obs_.get(), BeginFrameAck(0, 2, 0, 0, false)); | 835 source_->DidFinishFrame(obs_.get(), BeginFrameAck(0, 2, 0, false)); |
868 } | 836 } |
869 | 837 |
870 TEST_F(ExternalBeginFrameSourceTest, CallsOnDidFinishFrameWhenObserverRemoved) { | 838 TEST_F(ExternalBeginFrameSourceTest, CallsOnDidFinishFrameWhenObserverRemoved) { |
871 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 839 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
872 EXPECT_CALL((*client_), OnNeedsBeginFrames(true)).Times(1); | 840 EXPECT_CALL((*client_), OnNeedsBeginFrames(true)).Times(1); |
873 source_->AddObserver(obs_.get()); | 841 source_->AddObserver(obs_.get()); |
874 | 842 |
875 BeginFrameArgs args = CreateBeginFrameArgsForTesting( | 843 BeginFrameArgs args = CreateBeginFrameArgsForTesting( |
876 BEGINFRAME_FROM_HERE, 0, 2, base::TimeTicks::FromInternalValue(10000)); | 844 BEGINFRAME_FROM_HERE, 0, 2, base::TimeTicks::FromInternalValue(10000)); |
877 EXPECT_BEGIN_FRAME_ARGS_USED(*obs_, args); | 845 EXPECT_BEGIN_FRAME_ARGS_USED(*obs_, args); |
878 source_->OnBeginFrame(args); | 846 source_->OnBeginFrame(args); |
879 | 847 |
880 EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 2, 0, false))) | 848 EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 2, false))) |
881 .Times(1); | 849 .Times(1); |
882 EXPECT_CALL((*client_), OnNeedsBeginFrames(false)).Times(1); | 850 EXPECT_CALL((*client_), OnNeedsBeginFrames(false)).Times(1); |
883 source_->RemoveObserver(obs_.get()); | 851 source_->RemoveObserver(obs_.get()); |
884 } | 852 } |
885 | 853 |
886 // https://crbug.com/690127: Duplicate BeginFrame caused DCHECK crash. | 854 // https://crbug.com/690127: Duplicate BeginFrame caused DCHECK crash. |
887 TEST_F(ExternalBeginFrameSourceTest, OnBeginFrameChecksBeginFrameContinuity) { | 855 TEST_F(ExternalBeginFrameSourceTest, OnBeginFrameChecksBeginFrameContinuity) { |
888 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 856 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
889 EXPECT_CALL((*client_), OnNeedsBeginFrames(true)).Times(1); | 857 EXPECT_CALL((*client_), OnNeedsBeginFrames(true)).Times(1); |
890 source_->AddObserver(obs_.get()); | 858 source_->AddObserver(obs_.get()); |
891 | 859 |
892 BeginFrameArgs args = CreateBeginFrameArgsForTesting( | 860 BeginFrameArgs args = CreateBeginFrameArgsForTesting( |
893 BEGINFRAME_FROM_HERE, 0, 2, base::TimeTicks::FromInternalValue(10000)); | 861 BEGINFRAME_FROM_HERE, 0, 2, base::TimeTicks::FromInternalValue(10000)); |
894 EXPECT_BEGIN_FRAME_ARGS_USED(*obs_, args); | 862 EXPECT_BEGIN_FRAME_ARGS_USED(*obs_, args); |
895 source_->OnBeginFrame(args); | 863 source_->OnBeginFrame(args); |
896 | 864 |
897 // Providing same args again to OnBeginFrame() should not notify observer. | 865 // Providing same args again to OnBeginFrame() should not notify observer. |
898 EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 0, 0, false))) | 866 EXPECT_CALL((*client_), OnDidFinishFrame(BeginFrameAck(0, 2, 0, false))) |
899 .Times(1); | 867 .Times(1); |
900 source_->OnBeginFrame(args); | 868 source_->OnBeginFrame(args); |
901 | 869 |
902 // Providing same args through a different ExternalBeginFrameSource also does | 870 // Providing same args through a different ExternalBeginFrameSource also does |
903 // not notify observer. | 871 // not notify observer. |
904 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 872 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
905 EXPECT_CALL((*client_), OnNeedsBeginFrames(true)).Times(1); | 873 EXPECT_CALL((*client_), OnNeedsBeginFrames(true)).Times(1); |
906 ExternalBeginFrameSource source2(client_.get()); | 874 ExternalBeginFrameSource source2(client_.get()); |
907 source2.AddObserver(obs_.get()); | 875 source2.AddObserver(obs_.get()); |
908 source2.OnBeginFrame(args); | 876 source2.OnBeginFrame(args); |
909 } | 877 } |
910 | 878 |
911 } // namespace | 879 } // namespace |
912 } // namespace cc | 880 } // namespace cc |
OLD | NEW |