OLD | NEW |
1 // Copyright 2015 The Chromium Authors. All rights reserved. | 1 // Copyright 2015 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/surfaces/display_scheduler.h" | 5 #include "cc/surfaces/display_scheduler.h" |
6 | 6 |
7 #include "base/logging.h" | 7 #include "base/logging.h" |
8 #include "base/test/null_task_runner.h" | 8 #include "base/test/null_task_runner.h" |
9 #include "base/test/simple_test_tick_clock.h" | 9 #include "base/test/simple_test_tick_clock.h" |
10 #include "base/trace_event/trace_event.h" | 10 #include "base/trace_event/trace_event.h" |
(...skipping 36 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
47 int max_pending_swaps) | 47 int max_pending_swaps) |
48 : DisplayScheduler(task_runner, max_pending_swaps), | 48 : DisplayScheduler(task_runner, max_pending_swaps), |
49 scheduler_begin_frame_deadline_count_(0) { | 49 scheduler_begin_frame_deadline_count_(0) { |
50 SetBeginFrameSource(begin_frame_source); | 50 SetBeginFrameSource(begin_frame_source); |
51 } | 51 } |
52 | 52 |
53 base::TimeTicks DesiredBeginFrameDeadlineTimeForTest() { | 53 base::TimeTicks DesiredBeginFrameDeadlineTimeForTest() { |
54 return DesiredBeginFrameDeadlineTime(); | 54 return DesiredBeginFrameDeadlineTime(); |
55 } | 55 } |
56 | 56 |
57 void BeginFrameDeadlineForTest() { OnBeginFrameDeadline(); } | 57 void BeginFrameDeadlineForTest() { |
| 58 // Ensure that any missed BeginFrames were handled by the scheduler. We need |
| 59 // to run the scheduled task ourselves since the NullTaskRunner won't. |
| 60 if (!missed_begin_frame_task_.IsCancelled()) |
| 61 missed_begin_frame_task_.callback().Run(); |
| 62 OnBeginFrameDeadline(); |
| 63 } |
58 | 64 |
59 void ScheduleBeginFrameDeadline() override { | 65 void ScheduleBeginFrameDeadline() override { |
60 scheduler_begin_frame_deadline_count_++; | 66 scheduler_begin_frame_deadline_count_++; |
61 DisplayScheduler::ScheduleBeginFrameDeadline(); | 67 DisplayScheduler::ScheduleBeginFrameDeadline(); |
62 } | 68 } |
63 | 69 |
64 int scheduler_begin_frame_deadline_count() { | 70 int scheduler_begin_frame_deadline_count() { |
65 return scheduler_begin_frame_deadline_count_; | 71 return scheduler_begin_frame_deadline_count_; |
66 } | 72 } |
67 | 73 |
| 74 bool inside_begin_frame_deadline_interval() { |
| 75 return inside_begin_frame_deadline_interval_; |
| 76 } |
| 77 |
68 protected: | 78 protected: |
69 int scheduler_begin_frame_deadline_count_; | 79 int scheduler_begin_frame_deadline_count_; |
70 }; | 80 }; |
71 | 81 |
72 class DisplaySchedulerTest : public testing::Test { | 82 class DisplaySchedulerTest : public testing::Test { |
73 public: | 83 public: |
74 DisplaySchedulerTest() | 84 DisplaySchedulerTest() |
75 : fake_begin_frame_source_(0.f, false), | 85 : fake_begin_frame_source_(0.f, false), |
76 task_runner_(new base::NullTaskRunner), | 86 task_runner_(new base::NullTaskRunner), |
77 scheduler_(&fake_begin_frame_source_, | 87 scheduler_(&fake_begin_frame_source_, |
78 task_runner_.get(), | 88 task_runner_.get(), |
79 kMaxPendingSwaps) { | 89 kMaxPendingSwaps) { |
80 now_src_.Advance(base::TimeDelta::FromMicroseconds(10000)); | 90 now_src_.Advance(base::TimeDelta::FromMicroseconds(10000)); |
81 scheduler_.SetClient(&client_); | 91 scheduler_.SetClient(&client_); |
82 } | 92 } |
83 | 93 |
84 ~DisplaySchedulerTest() override {} | 94 ~DisplaySchedulerTest() override {} |
85 | 95 |
86 void SetUp() override { scheduler_.SetRootSurfaceResourcesLocked(false); } | 96 void SetUp() override { scheduler_.SetRootSurfaceResourcesLocked(false); } |
87 | 97 |
88 void BeginFrameForTest() { | 98 void AdvanceTimeAndBeginFrameForTest() { |
| 99 now_src_.Advance(base::TimeDelta::FromMicroseconds(10000)); |
89 base::TimeTicks frame_time = now_src_.NowTicks(); | 100 base::TimeTicks frame_time = now_src_.NowTicks(); |
90 base::TimeDelta interval = BeginFrameArgs::DefaultInterval(); | 101 base::TimeDelta interval = BeginFrameArgs::DefaultInterval(); |
91 base::TimeTicks deadline = frame_time + interval; | 102 base::TimeTicks deadline = frame_time + interval; |
92 // FakeBeginFrameSource deals with |source_id| and |sequence_number|. | 103 // FakeBeginFrameSource deals with |source_id| and |sequence_number|. |
93 fake_begin_frame_source_.TestOnBeginFrame( | 104 fake_begin_frame_source_.TestOnBeginFrame( |
94 BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, 0, 1, frame_time, deadline, | 105 BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, 0, 1, frame_time, deadline, |
95 interval, BeginFrameArgs::NORMAL)); | 106 interval, BeginFrameArgs::NORMAL)); |
96 } | 107 } |
97 | 108 |
98 protected: | 109 protected: |
(...skipping 14 matching lines...) Expand all Loading... |
113 LocalFrameId(1, base::UnguessableToken::Create())); | 124 LocalFrameId(1, base::UnguessableToken::Create())); |
114 SurfaceId root_surface_id2(kArbitraryFrameSinkId, | 125 SurfaceId root_surface_id2(kArbitraryFrameSinkId, |
115 LocalFrameId(2, base::UnguessableToken::Create())); | 126 LocalFrameId(2, base::UnguessableToken::Create())); |
116 SurfaceId sid1(kArbitraryFrameSinkId, | 127 SurfaceId sid1(kArbitraryFrameSinkId, |
117 LocalFrameId(3, base::UnguessableToken::Create())); | 128 LocalFrameId(3, base::UnguessableToken::Create())); |
118 base::TimeTicks late_deadline; | 129 base::TimeTicks late_deadline; |
119 | 130 |
120 scheduler_.SetVisible(true); | 131 scheduler_.SetVisible(true); |
121 | 132 |
122 // Go trough an initial BeginFrame cycle with the root surface. | 133 // Go trough an initial BeginFrame cycle with the root surface. |
123 BeginFrameForTest(); | 134 AdvanceTimeAndBeginFrameForTest(); |
124 scheduler_.SetNewRootSurface(root_surface_id1); | 135 scheduler_.SetNewRootSurface(root_surface_id1); |
125 scheduler_.BeginFrameDeadlineForTest(); | 136 scheduler_.BeginFrameDeadlineForTest(); |
126 | 137 |
127 // Resize on the next begin frame cycle should cause the deadline to wait | 138 // Resize on the next begin frame cycle should cause the deadline to wait |
128 // for a new root surface. | 139 // for a new root surface. |
| 140 AdvanceTimeAndBeginFrameForTest(); |
129 late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval(); | 141 late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval(); |
130 BeginFrameForTest(); | |
131 scheduler_.SurfaceDamaged(sid1); | 142 scheduler_.SurfaceDamaged(sid1); |
132 EXPECT_GT(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 143 EXPECT_GT(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
133 scheduler_.DisplayResized(); | 144 scheduler_.DisplayResized(); |
134 EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 145 EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
135 scheduler_.SetNewRootSurface(root_surface_id2); | 146 scheduler_.SetNewRootSurface(root_surface_id2); |
136 EXPECT_GE(now_src().NowTicks(), | 147 EXPECT_GE(now_src().NowTicks(), |
137 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 148 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
138 scheduler_.BeginFrameDeadlineForTest(); | 149 scheduler_.BeginFrameDeadlineForTest(); |
139 | 150 |
140 // Verify deadline goes back to normal after resize. | 151 // Verify deadline goes back to normal after resize. |
141 late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval(); | 152 late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval(); |
142 BeginFrameForTest(); | 153 AdvanceTimeAndBeginFrameForTest(); |
143 scheduler_.SurfaceDamaged(sid1); | 154 scheduler_.SurfaceDamaged(sid1); |
144 EXPECT_GT(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 155 EXPECT_GT(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
145 scheduler_.SurfaceDamaged(root_surface_id2); | 156 scheduler_.SurfaceDamaged(root_surface_id2); |
146 EXPECT_GE(now_src().NowTicks(), | 157 EXPECT_GE(now_src().NowTicks(), |
147 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 158 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
148 scheduler_.BeginFrameDeadlineForTest(); | 159 scheduler_.BeginFrameDeadlineForTest(); |
149 } | 160 } |
150 | 161 |
151 TEST_F(DisplaySchedulerTest, ResizeHasLateDeadlineUntilDamagedSurface) { | 162 TEST_F(DisplaySchedulerTest, ResizeHasLateDeadlineUntilDamagedSurface) { |
152 SurfaceId root_surface_id(kArbitraryFrameSinkId, | 163 SurfaceId root_surface_id(kArbitraryFrameSinkId, |
153 LocalFrameId(1, base::UnguessableToken::Create())); | 164 LocalFrameId(1, base::UnguessableToken::Create())); |
154 SurfaceId sid1(kArbitraryFrameSinkId, | 165 SurfaceId sid1(kArbitraryFrameSinkId, |
155 LocalFrameId(2, base::UnguessableToken::Create())); | 166 LocalFrameId(2, base::UnguessableToken::Create())); |
156 base::TimeTicks late_deadline; | 167 base::TimeTicks late_deadline; |
157 | 168 |
158 scheduler_.SetVisible(true); | 169 scheduler_.SetVisible(true); |
159 | 170 |
160 // Go trough an initial BeginFrame cycle with the root surface. | 171 // Go trough an initial BeginFrame cycle with the root surface. |
161 BeginFrameForTest(); | 172 AdvanceTimeAndBeginFrameForTest(); |
162 scheduler_.SetNewRootSurface(root_surface_id); | 173 scheduler_.SetNewRootSurface(root_surface_id); |
163 scheduler_.BeginFrameDeadlineForTest(); | 174 scheduler_.BeginFrameDeadlineForTest(); |
164 | 175 |
165 // Resize on the next begin frame cycle should cause the deadline to wait | 176 // Resize on the next begin frame cycle should cause the deadline to wait |
166 // for a new root surface. | 177 // for a new root surface. |
| 178 AdvanceTimeAndBeginFrameForTest(); |
167 late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval(); | 179 late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval(); |
168 BeginFrameForTest(); | |
169 scheduler_.SurfaceDamaged(sid1); | 180 scheduler_.SurfaceDamaged(sid1); |
170 EXPECT_GT(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 181 EXPECT_GT(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
171 scheduler_.DisplayResized(); | 182 scheduler_.DisplayResized(); |
172 EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 183 EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
173 scheduler_.SurfaceDamaged(root_surface_id); | 184 scheduler_.SurfaceDamaged(root_surface_id); |
174 EXPECT_GE(now_src().NowTicks(), | 185 EXPECT_GE(now_src().NowTicks(), |
175 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 186 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
176 scheduler_.BeginFrameDeadlineForTest(); | 187 scheduler_.BeginFrameDeadlineForTest(); |
177 | 188 |
178 // Verify deadline goes back to normal after resize. | 189 // Verify deadline goes back to normal after resize. |
| 190 AdvanceTimeAndBeginFrameForTest(); |
179 late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval(); | 191 late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval(); |
180 BeginFrameForTest(); | |
181 scheduler_.SurfaceDamaged(sid1); | 192 scheduler_.SurfaceDamaged(sid1); |
182 EXPECT_GT(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 193 EXPECT_GT(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
183 scheduler_.SurfaceDamaged(root_surface_id); | 194 scheduler_.SurfaceDamaged(root_surface_id); |
184 EXPECT_GE(now_src().NowTicks(), | 195 EXPECT_GE(now_src().NowTicks(), |
185 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 196 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
186 scheduler_.BeginFrameDeadlineForTest(); | 197 scheduler_.BeginFrameDeadlineForTest(); |
187 } | 198 } |
188 | 199 |
189 TEST_F(DisplaySchedulerTest, SurfaceDamaged) { | 200 TEST_F(DisplaySchedulerTest, SurfaceDamaged) { |
190 SurfaceId root_surface_id(kArbitraryFrameSinkId, | 201 SurfaceId root_surface_id(kArbitraryFrameSinkId, |
191 LocalFrameId(0, base::UnguessableToken::Create())); | 202 LocalFrameId(0, base::UnguessableToken::Create())); |
192 SurfaceId sid1(kArbitraryFrameSinkId, | 203 SurfaceId sid1(kArbitraryFrameSinkId, |
193 LocalFrameId(1, base::UnguessableToken::Create())); | 204 LocalFrameId(1, base::UnguessableToken::Create())); |
194 SurfaceId sid2(kArbitraryFrameSinkId, | 205 SurfaceId sid2(kArbitraryFrameSinkId, |
195 LocalFrameId(2, base::UnguessableToken::Create())); | 206 LocalFrameId(2, base::UnguessableToken::Create())); |
196 | 207 |
197 scheduler_.SetVisible(true); | 208 scheduler_.SetVisible(true); |
198 | 209 |
199 // Set the root surface | 210 // Set the root surface |
200 scheduler_.SetNewRootSurface(root_surface_id); | 211 scheduler_.SetNewRootSurface(root_surface_id); |
201 | 212 |
202 // Get scheduler to detect surface 1 as active by drawing | 213 // Get scheduler to detect surface 1 as active by drawing |
203 // two frames in a row with damage from surface 1. | 214 // two frames in a row with damage from surface 1. |
204 BeginFrameForTest(); | 215 AdvanceTimeAndBeginFrameForTest(); |
205 scheduler_.SurfaceDamaged(sid1); | 216 scheduler_.SurfaceDamaged(sid1); |
206 scheduler_.BeginFrameDeadlineForTest(); | 217 scheduler_.BeginFrameDeadlineForTest(); |
207 BeginFrameForTest(); | 218 AdvanceTimeAndBeginFrameForTest(); |
208 scheduler_.SurfaceDamaged(sid1); | 219 scheduler_.SurfaceDamaged(sid1); |
209 scheduler_.BeginFrameDeadlineForTest(); | 220 scheduler_.BeginFrameDeadlineForTest(); |
210 | 221 |
211 // Damage only from surface 2 (inactive) does not trigger deadline early. | 222 // Damage only from surface 2 (inactive) does not trigger deadline early. |
212 BeginFrameForTest(); | 223 AdvanceTimeAndBeginFrameForTest(); |
213 scheduler_.SurfaceDamaged(sid2); | 224 scheduler_.SurfaceDamaged(sid2); |
214 EXPECT_LT(now_src().NowTicks(), | 225 EXPECT_LT(now_src().NowTicks(), |
215 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 226 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
216 | 227 |
217 // Damage from surface 1 triggers deadline early. | 228 // Damage from surface 1 triggers deadline early. |
218 scheduler_.SurfaceDamaged(sid1); | 229 scheduler_.SurfaceDamaged(sid1); |
219 EXPECT_GE(now_src().NowTicks(), | 230 EXPECT_GE(now_src().NowTicks(), |
220 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 231 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
221 scheduler_.BeginFrameDeadlineForTest(); | 232 scheduler_.BeginFrameDeadlineForTest(); |
222 | 233 |
223 // Make both surface 1 and 2 active. | 234 // Make both surface 1 and 2 active. |
224 BeginFrameForTest(); | 235 AdvanceTimeAndBeginFrameForTest(); |
225 scheduler_.SurfaceDamaged(sid2); | 236 scheduler_.SurfaceDamaged(sid2); |
226 scheduler_.SurfaceDamaged(sid1); | 237 scheduler_.SurfaceDamaged(sid1); |
227 scheduler_.BeginFrameDeadlineForTest(); | 238 scheduler_.BeginFrameDeadlineForTest(); |
228 | 239 |
229 // Deadline doesn't trigger early until surface 1 and 2 are both damaged. | 240 // Deadline doesn't trigger early until surface 1 and 2 are both damaged. |
230 BeginFrameForTest(); | 241 AdvanceTimeAndBeginFrameForTest(); |
231 EXPECT_LT(now_src().NowTicks(), | 242 EXPECT_LT(now_src().NowTicks(), |
232 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 243 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
233 scheduler_.SurfaceDamaged(sid1); | 244 scheduler_.SurfaceDamaged(sid1); |
234 EXPECT_LT(now_src().NowTicks(), | 245 EXPECT_LT(now_src().NowTicks(), |
235 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 246 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
236 scheduler_.SurfaceDamaged(sid2); | 247 scheduler_.SurfaceDamaged(sid2); |
237 EXPECT_GE(now_src().NowTicks(), | 248 EXPECT_GE(now_src().NowTicks(), |
238 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 249 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
239 scheduler_.BeginFrameDeadlineForTest(); | 250 scheduler_.BeginFrameDeadlineForTest(); |
240 | 251 |
241 // Make the system idle | 252 // Make the system idle |
242 BeginFrameForTest(); | 253 AdvanceTimeAndBeginFrameForTest(); |
243 scheduler_.BeginFrameDeadlineForTest(); | 254 scheduler_.BeginFrameDeadlineForTest(); |
244 BeginFrameForTest(); | 255 AdvanceTimeAndBeginFrameForTest(); |
245 scheduler_.BeginFrameDeadlineForTest(); | 256 EXPECT_FALSE(scheduler_.inside_begin_frame_deadline_interval()); |
246 | 257 |
247 // Deadline should trigger early if child surfaces are idle and | 258 // Deadline should trigger early if child surfaces are idle and |
248 // we get damage on the root surface. | 259 // we get damage on the root surface. |
249 BeginFrameForTest(); | 260 AdvanceTimeAndBeginFrameForTest(); |
250 EXPECT_LT(now_src().NowTicks(), | 261 EXPECT_FALSE(scheduler_.inside_begin_frame_deadline_interval()); |
251 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | |
252 scheduler_.SurfaceDamaged(root_surface_id); | 262 scheduler_.SurfaceDamaged(root_surface_id); |
253 EXPECT_GE(now_src().NowTicks(), | 263 EXPECT_GE(now_src().NowTicks(), |
254 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 264 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
255 scheduler_.BeginFrameDeadlineForTest(); | 265 scheduler_.BeginFrameDeadlineForTest(); |
256 } | 266 } |
257 | 267 |
258 TEST_F(DisplaySchedulerTest, OutputSurfaceLost) { | 268 TEST_F(DisplaySchedulerTest, OutputSurfaceLost) { |
259 SurfaceId root_surface_id(kArbitraryFrameSinkId, | 269 SurfaceId root_surface_id(kArbitraryFrameSinkId, |
260 LocalFrameId(0, base::UnguessableToken::Create())); | 270 LocalFrameId(0, base::UnguessableToken::Create())); |
261 SurfaceId sid1(kArbitraryFrameSinkId, | 271 SurfaceId sid1(kArbitraryFrameSinkId, |
262 LocalFrameId(1, base::UnguessableToken::Create())); | 272 LocalFrameId(1, base::UnguessableToken::Create())); |
263 | 273 |
264 scheduler_.SetVisible(true); | 274 scheduler_.SetVisible(true); |
265 | 275 |
266 // Set the root surface | 276 // Set the root surface |
267 scheduler_.SetNewRootSurface(root_surface_id); | 277 scheduler_.SetNewRootSurface(root_surface_id); |
268 | 278 |
269 // DrawAndSwap normally. | 279 // DrawAndSwap normally. |
270 BeginFrameForTest(); | 280 AdvanceTimeAndBeginFrameForTest(); |
271 EXPECT_LT(now_src().NowTicks(), | 281 EXPECT_LT(now_src().NowTicks(), |
272 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 282 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
273 EXPECT_EQ(0, client_.draw_and_swap_count()); | 283 EXPECT_EQ(0, client_.draw_and_swap_count()); |
274 scheduler_.SurfaceDamaged(sid1); | 284 scheduler_.SurfaceDamaged(sid1); |
275 scheduler_.BeginFrameDeadlineForTest(); | 285 scheduler_.BeginFrameDeadlineForTest(); |
276 EXPECT_EQ(1, client_.draw_and_swap_count()); | 286 EXPECT_EQ(1, client_.draw_and_swap_count()); |
277 | 287 |
278 // Deadline triggers immediately on OutputSurfaceLost. | 288 // Deadline triggers immediately on OutputSurfaceLost. |
279 BeginFrameForTest(); | 289 AdvanceTimeAndBeginFrameForTest(); |
280 EXPECT_LT(now_src().NowTicks(), | 290 EXPECT_LT(now_src().NowTicks(), |
281 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 291 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
282 scheduler_.OutputSurfaceLost(); | 292 scheduler_.OutputSurfaceLost(); |
283 EXPECT_GE(now_src().NowTicks(), | 293 EXPECT_GE(now_src().NowTicks(), |
284 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 294 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
285 | 295 |
286 // Deadline does not DrawAndSwap after OutputSurfaceLost. | 296 // Deadline does not DrawAndSwap after OutputSurfaceLost. |
287 EXPECT_EQ(1, client_.draw_and_swap_count()); | 297 EXPECT_EQ(1, client_.draw_and_swap_count()); |
288 scheduler_.SurfaceDamaged(sid1); | 298 scheduler_.SurfaceDamaged(sid1); |
289 scheduler_.BeginFrameDeadlineForTest(); | 299 scheduler_.BeginFrameDeadlineForTest(); |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
327 SurfaceId root_surface_id(kArbitraryFrameSinkId, | 337 SurfaceId root_surface_id(kArbitraryFrameSinkId, |
328 LocalFrameId(0, base::UnguessableToken::Create())); | 338 LocalFrameId(0, base::UnguessableToken::Create())); |
329 SurfaceId sid1(kArbitraryFrameSinkId, | 339 SurfaceId sid1(kArbitraryFrameSinkId, |
330 LocalFrameId(1, base::UnguessableToken::Create())); | 340 LocalFrameId(1, base::UnguessableToken::Create())); |
331 | 341 |
332 scheduler_.SetNewRootSurface(root_surface_id); | 342 scheduler_.SetNewRootSurface(root_surface_id); |
333 scheduler_.SetVisible(true); | 343 scheduler_.SetVisible(true); |
334 EXPECT_EQ(1u, fake_begin_frame_source_.num_observers()); | 344 EXPECT_EQ(1u, fake_begin_frame_source_.num_observers()); |
335 | 345 |
336 // DrawAndSwap normally. | 346 // DrawAndSwap normally. |
337 BeginFrameForTest(); | 347 AdvanceTimeAndBeginFrameForTest(); |
338 EXPECT_LT(now_src().NowTicks(), | 348 EXPECT_LT(now_src().NowTicks(), |
339 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 349 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
340 EXPECT_EQ(0, client_.draw_and_swap_count()); | 350 EXPECT_EQ(0, client_.draw_and_swap_count()); |
341 scheduler_.SurfaceDamaged(sid1); | 351 scheduler_.SurfaceDamaged(sid1); |
342 scheduler_.BeginFrameDeadlineForTest(); | 352 scheduler_.BeginFrameDeadlineForTest(); |
343 EXPECT_EQ(1, client_.draw_and_swap_count()); | 353 EXPECT_EQ(1, client_.draw_and_swap_count()); |
344 | 354 |
345 BeginFrameForTest(); | 355 AdvanceTimeAndBeginFrameForTest(); |
346 EXPECT_LT(now_src().NowTicks(), | 356 EXPECT_LT(now_src().NowTicks(), |
347 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 357 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
348 | 358 |
349 // Become not visible. | 359 // Become not visible. |
350 scheduler_.SetVisible(false); | 360 scheduler_.SetVisible(false); |
351 | 361 |
352 // It will stop listening for begin frames after the current deadline. | 362 // It will stop listening for begin frames after the current deadline. |
353 EXPECT_EQ(1u, fake_begin_frame_source_.num_observers()); | 363 EXPECT_EQ(1u, fake_begin_frame_source_.num_observers()); |
354 | 364 |
355 // Deadline does not DrawAndSwap when not visible. | 365 // Deadline does not DrawAndSwap when not visible. |
(...skipping 23 matching lines...) Expand all Loading... |
379 LocalFrameId(0, base::UnguessableToken::Create())); | 389 LocalFrameId(0, base::UnguessableToken::Create())); |
380 SurfaceId sid1(kArbitraryFrameSinkId, | 390 SurfaceId sid1(kArbitraryFrameSinkId, |
381 LocalFrameId(1, base::UnguessableToken::Create())); | 391 LocalFrameId(1, base::UnguessableToken::Create())); |
382 | 392 |
383 scheduler_.SetVisible(true); | 393 scheduler_.SetVisible(true); |
384 | 394 |
385 // Set the root surface | 395 // Set the root surface |
386 scheduler_.SetNewRootSurface(root_surface_id); | 396 scheduler_.SetNewRootSurface(root_surface_id); |
387 | 397 |
388 // DrawAndSwap normally. | 398 // DrawAndSwap normally. |
389 BeginFrameForTest(); | 399 AdvanceTimeAndBeginFrameForTest(); |
390 EXPECT_LT(now_src().NowTicks(), | 400 EXPECT_LT(now_src().NowTicks(), |
391 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 401 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
392 EXPECT_EQ(0, client_.draw_and_swap_count()); | 402 EXPECT_EQ(0, client_.draw_and_swap_count()); |
393 scheduler_.SurfaceDamaged(sid1); | 403 scheduler_.SurfaceDamaged(sid1); |
394 scheduler_.BeginFrameDeadlineForTest(); | 404 scheduler_.BeginFrameDeadlineForTest(); |
395 EXPECT_EQ(1, client_.draw_and_swap_count()); | 405 EXPECT_EQ(1, client_.draw_and_swap_count()); |
396 | 406 |
397 scheduler_.DisplayResized(); | 407 scheduler_.DisplayResized(); |
398 BeginFrameForTest(); | 408 AdvanceTimeAndBeginFrameForTest(); |
399 // DisplayResized should trigger a swap to happen. | 409 // DisplayResized should trigger a swap to happen. |
400 scheduler_.BeginFrameDeadlineForTest(); | 410 scheduler_.BeginFrameDeadlineForTest(); |
401 EXPECT_EQ(2, client_.draw_and_swap_count()); | 411 EXPECT_EQ(2, client_.draw_and_swap_count()); |
402 } | 412 } |
403 | 413 |
404 TEST_F(DisplaySchedulerTest, RootSurfaceResourcesLocked) { | 414 TEST_F(DisplaySchedulerTest, RootSurfaceResourcesLocked) { |
405 SurfaceId root_surface_id(kArbitraryFrameSinkId, | 415 SurfaceId root_surface_id(kArbitraryFrameSinkId, |
406 LocalFrameId(0, base::UnguessableToken::Create())); | 416 LocalFrameId(0, base::UnguessableToken::Create())); |
407 SurfaceId sid1(kArbitraryFrameSinkId, | 417 SurfaceId sid1(kArbitraryFrameSinkId, |
408 LocalFrameId(1, base::UnguessableToken::Create())); | 418 LocalFrameId(1, base::UnguessableToken::Create())); |
409 base::TimeTicks late_deadline; | 419 base::TimeTicks late_deadline; |
410 | 420 |
411 scheduler_.SetVisible(true); | 421 scheduler_.SetVisible(true); |
412 | 422 |
413 // Set the root surface | 423 // Set the root surface |
414 scheduler_.SetNewRootSurface(root_surface_id); | 424 scheduler_.SetNewRootSurface(root_surface_id); |
415 | 425 |
416 // DrawAndSwap normally. | 426 // DrawAndSwap normally. |
417 BeginFrameForTest(); | 427 AdvanceTimeAndBeginFrameForTest(); |
418 EXPECT_LT(now_src().NowTicks(), | 428 EXPECT_LT(now_src().NowTicks(), |
419 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 429 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
420 EXPECT_EQ(0, client_.draw_and_swap_count()); | 430 EXPECT_EQ(0, client_.draw_and_swap_count()); |
421 scheduler_.SurfaceDamaged(sid1); | 431 scheduler_.SurfaceDamaged(sid1); |
422 scheduler_.BeginFrameDeadlineForTest(); | 432 scheduler_.BeginFrameDeadlineForTest(); |
423 EXPECT_EQ(1, client_.draw_and_swap_count()); | 433 EXPECT_EQ(1, client_.draw_and_swap_count()); |
424 | 434 |
425 // Deadline triggers late while root resources are locked. | 435 // Deadline triggers late while root resources are locked. |
| 436 AdvanceTimeAndBeginFrameForTest(); |
426 late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval(); | 437 late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval(); |
427 BeginFrameForTest(); | |
428 scheduler_.SurfaceDamaged(sid1); | 438 scheduler_.SurfaceDamaged(sid1); |
429 EXPECT_GT(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 439 EXPECT_GT(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
430 scheduler_.SetRootSurfaceResourcesLocked(true); | 440 scheduler_.SetRootSurfaceResourcesLocked(true); |
431 EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 441 EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
432 | 442 |
433 // Deadline does not DrawAndSwap while root resources are locked. | 443 // Deadline does not DrawAndSwap while root resources are locked. |
434 EXPECT_EQ(1, client_.draw_and_swap_count()); | 444 EXPECT_EQ(1, client_.draw_and_swap_count()); |
435 scheduler_.SurfaceDamaged(sid1); | 445 scheduler_.SurfaceDamaged(sid1); |
436 scheduler_.BeginFrameDeadlineForTest(); | 446 scheduler_.BeginFrameDeadlineForTest(); |
437 EXPECT_EQ(1, client_.draw_and_swap_count()); | 447 EXPECT_EQ(1, client_.draw_and_swap_count()); |
438 | 448 |
439 // Deadline triggers normally when root resources are unlocked. | 449 // Deadline triggers normally when root resources are unlocked. |
| 450 AdvanceTimeAndBeginFrameForTest(); |
440 late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval(); | 451 late_deadline = now_src().NowTicks() + BeginFrameArgs::DefaultInterval(); |
441 BeginFrameForTest(); | |
442 scheduler_.SurfaceDamaged(sid1); | 452 scheduler_.SurfaceDamaged(sid1); |
443 EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 453 EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
444 scheduler_.SetRootSurfaceResourcesLocked(false); | 454 scheduler_.SetRootSurfaceResourcesLocked(false); |
445 scheduler_.SurfaceDamaged(root_surface_id); | 455 scheduler_.SurfaceDamaged(root_surface_id); |
446 EXPECT_EQ(base::TimeTicks(), | 456 EXPECT_EQ(base::TimeTicks(), |
447 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 457 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
448 | 458 |
449 EXPECT_EQ(1, client_.draw_and_swap_count()); | 459 EXPECT_EQ(1, client_.draw_and_swap_count()); |
450 scheduler_.BeginFrameDeadlineForTest(); | 460 scheduler_.BeginFrameDeadlineForTest(); |
451 EXPECT_EQ(2, client_.draw_and_swap_count()); | 461 EXPECT_EQ(2, client_.draw_and_swap_count()); |
452 } | 462 } |
453 | 463 |
454 TEST_F(DisplaySchedulerTest, DidSwapBuffers) { | 464 TEST_F(DisplaySchedulerTest, DidSwapBuffers) { |
455 SurfaceId root_surface_id(kArbitraryFrameSinkId, | 465 SurfaceId root_surface_id(kArbitraryFrameSinkId, |
456 LocalFrameId(0, base::UnguessableToken::Create())); | 466 LocalFrameId(0, base::UnguessableToken::Create())); |
457 SurfaceId sid1(kArbitraryFrameSinkId, | 467 SurfaceId sid1(kArbitraryFrameSinkId, |
458 LocalFrameId(1, base::UnguessableToken::Create())); | 468 LocalFrameId(1, base::UnguessableToken::Create())); |
459 SurfaceId sid2(kArbitraryFrameSinkId, | 469 SurfaceId sid2(kArbitraryFrameSinkId, |
460 LocalFrameId(2, base::UnguessableToken::Create())); | 470 LocalFrameId(2, base::UnguessableToken::Create())); |
461 | 471 |
462 scheduler_.SetVisible(true); | 472 scheduler_.SetVisible(true); |
463 | 473 |
464 // Set the root surface | 474 // Set the root surface |
465 scheduler_.SetNewRootSurface(root_surface_id); | 475 scheduler_.SetNewRootSurface(root_surface_id); |
466 | 476 |
467 // Get scheduler to detect surface 1 and 2 as active. | 477 // Get scheduler to detect surface 1 and 2 as active. |
468 BeginFrameForTest(); | 478 AdvanceTimeAndBeginFrameForTest(); |
469 scheduler_.SurfaceDamaged(sid1); | 479 scheduler_.SurfaceDamaged(sid1); |
470 scheduler_.SurfaceDamaged(sid2); | 480 scheduler_.SurfaceDamaged(sid2); |
471 scheduler_.BeginFrameDeadlineForTest(); | 481 scheduler_.BeginFrameDeadlineForTest(); |
472 BeginFrameForTest(); | 482 AdvanceTimeAndBeginFrameForTest(); |
473 scheduler_.SurfaceDamaged(sid1); | 483 scheduler_.SurfaceDamaged(sid1); |
474 scheduler_.SurfaceDamaged(sid2); | 484 scheduler_.SurfaceDamaged(sid2); |
475 scheduler_.BeginFrameDeadlineForTest(); | 485 scheduler_.BeginFrameDeadlineForTest(); |
476 | 486 |
477 // DrawAndSwap normally. | 487 // DrawAndSwap normally. |
478 BeginFrameForTest(); | 488 AdvanceTimeAndBeginFrameForTest(); |
479 EXPECT_LT(now_src().NowTicks(), | 489 EXPECT_LT(now_src().NowTicks(), |
480 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 490 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
481 EXPECT_EQ(2, client_.draw_and_swap_count()); | 491 EXPECT_EQ(2, client_.draw_and_swap_count()); |
482 scheduler_.SurfaceDamaged(sid1); | 492 scheduler_.SurfaceDamaged(sid1); |
483 scheduler_.SurfaceDamaged(sid2); | 493 scheduler_.SurfaceDamaged(sid2); |
484 scheduler_.BeginFrameDeadlineForTest(); | 494 scheduler_.BeginFrameDeadlineForTest(); |
485 EXPECT_EQ(3, client_.draw_and_swap_count()); | 495 EXPECT_EQ(3, client_.draw_and_swap_count()); |
486 scheduler_.DidSwapBuffers(); | 496 scheduler_.DidSwapBuffers(); |
487 | 497 |
488 // Deadline triggers late when swap throttled. | 498 // Deadline triggers late when swap throttled. |
| 499 AdvanceTimeAndBeginFrameForTest(); |
489 base::TimeTicks late_deadline = | 500 base::TimeTicks late_deadline = |
490 now_src().NowTicks() + BeginFrameArgs::DefaultInterval(); | 501 now_src().NowTicks() + BeginFrameArgs::DefaultInterval(); |
491 BeginFrameForTest(); | |
492 // Damage surface 1, but not surface 2 so we avoid triggering deadline | 502 // Damage surface 1, but not surface 2 so we avoid triggering deadline |
493 // early because all surfaces are ready. | 503 // early because all surfaces are ready. |
494 scheduler_.SurfaceDamaged(sid1); | 504 scheduler_.SurfaceDamaged(sid1); |
495 EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 505 EXPECT_EQ(late_deadline, scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
496 | 506 |
497 // Don't draw and swap in deadline while swap throttled. | 507 // Don't draw and swap in deadline while swap throttled. |
498 EXPECT_EQ(3, client_.draw_and_swap_count()); | 508 EXPECT_EQ(3, client_.draw_and_swap_count()); |
499 scheduler_.BeginFrameDeadlineForTest(); | 509 scheduler_.BeginFrameDeadlineForTest(); |
500 EXPECT_EQ(3, client_.draw_and_swap_count()); | 510 EXPECT_EQ(3, client_.draw_and_swap_count()); |
501 | 511 |
502 // Deadline triggers normally once not swap throttled. | 512 // Deadline triggers normally once not swap throttled. |
503 // Damage from previous BeginFrame should cary over, so don't damage again. | 513 // Damage from previous BeginFrame should cary over, so don't damage again. |
| 514 scheduler_.DidReceiveSwapBuffersAck(); |
| 515 AdvanceTimeAndBeginFrameForTest(); |
504 base::TimeTicks expected_deadline = | 516 base::TimeTicks expected_deadline = |
505 scheduler_.LastUsedBeginFrameArgs().deadline - | 517 scheduler_.LastUsedBeginFrameArgs().deadline - |
506 BeginFrameArgs::DefaultEstimatedParentDrawTime(); | 518 BeginFrameArgs::DefaultEstimatedParentDrawTime(); |
507 scheduler_.DidReceiveSwapBuffersAck(); | |
508 BeginFrameForTest(); | |
509 EXPECT_EQ(expected_deadline, | 519 EXPECT_EQ(expected_deadline, |
510 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); | 520 scheduler_.DesiredBeginFrameDeadlineTimeForTest()); |
511 // Still waiting for surface 2. Once it updates, deadline should trigger | 521 // Still waiting for surface 2. Once it updates, deadline should trigger |
512 // immediately again. | 522 // immediately again. |
513 scheduler_.SurfaceDamaged(sid2); | 523 scheduler_.SurfaceDamaged(sid2); |
514 EXPECT_EQ(scheduler_.DesiredBeginFrameDeadlineTimeForTest(), | 524 EXPECT_EQ(scheduler_.DesiredBeginFrameDeadlineTimeForTest(), |
515 base::TimeTicks()); | 525 base::TimeTicks()); |
516 // Draw and swap now that we aren't throttled. | 526 // Draw and swap now that we aren't throttled. |
517 EXPECT_EQ(3, client_.draw_and_swap_count()); | 527 EXPECT_EQ(3, client_.draw_and_swap_count()); |
518 scheduler_.BeginFrameDeadlineForTest(); | 528 scheduler_.BeginFrameDeadlineForTest(); |
(...skipping 23 matching lines...) Expand all Loading... |
542 scheduler_.SetNewRootSurface(root_surface_id); | 552 scheduler_.SetNewRootSurface(root_surface_id); |
543 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); | 553 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); |
544 | 554 |
545 scheduler_.SetVisible(true); | 555 scheduler_.SetVisible(true); |
546 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); | 556 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); |
547 | 557 |
548 // Set the root surface while visible. | 558 // Set the root surface while visible. |
549 scheduler_.SetNewRootSurface(root_surface_id); | 559 scheduler_.SetNewRootSurface(root_surface_id); |
550 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); | 560 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); |
551 | 561 |
552 BeginFrameForTest(); | 562 AdvanceTimeAndBeginFrameForTest(); |
553 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); | 563 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); |
554 | 564 |
555 scheduler_.BeginFrameDeadlineForTest(); | 565 scheduler_.BeginFrameDeadlineForTest(); |
556 scheduler_.DidSwapBuffers(); | 566 scheduler_.DidSwapBuffers(); |
557 BeginFrameForTest(); | 567 AdvanceTimeAndBeginFrameForTest(); |
558 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); | 568 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); |
559 | 569 |
560 scheduler_.DidReceiveSwapBuffersAck(); | 570 scheduler_.DidReceiveSwapBuffersAck(); |
561 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); | 571 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); |
562 | 572 |
563 scheduler_.DisplayResized(); | 573 scheduler_.DisplayResized(); |
564 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); | 574 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); |
565 | 575 |
566 scheduler_.SetNewRootSurface(root_surface_id); | 576 scheduler_.SetNewRootSurface(root_surface_id); |
567 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); | 577 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); |
568 | 578 |
569 scheduler_.SurfaceDamaged(sid1); | 579 scheduler_.SurfaceDamaged(sid1); |
570 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); | 580 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); |
571 | 581 |
572 scheduler_.SetRootSurfaceResourcesLocked(true); | 582 scheduler_.SetRootSurfaceResourcesLocked(true); |
573 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); | 583 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); |
574 | 584 |
575 scheduler_.OutputSurfaceLost(); | 585 scheduler_.OutputSurfaceLost(); |
576 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); | 586 EXPECT_EQ(++count, scheduler_.scheduler_begin_frame_deadline_count()); |
577 } | 587 } |
578 | 588 |
579 } // namespace | 589 } // namespace |
580 } // namespace cc | 590 } // namespace cc |
OLD | NEW |