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 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
46 const int64_t BackToBackBeginFrameSourceTest::kDeadline = | 46 const int64_t BackToBackBeginFrameSourceTest::kDeadline = |
47 BeginFrameArgs::DefaultInterval().ToInternalValue(); | 47 BeginFrameArgs::DefaultInterval().ToInternalValue(); |
48 | 48 |
49 const int64_t BackToBackBeginFrameSourceTest::kInterval = | 49 const int64_t BackToBackBeginFrameSourceTest::kInterval = |
50 BeginFrameArgs::DefaultInterval().ToInternalValue(); | 50 BeginFrameArgs::DefaultInterval().ToInternalValue(); |
51 | 51 |
52 TEST_F(BackToBackBeginFrameSourceTest, AddObserverSendsBeginFrame) { | 52 TEST_F(BackToBackBeginFrameSourceTest, AddObserverSendsBeginFrame) { |
53 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 53 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
54 source_->AddObserver(obs_.get()); | 54 source_->AddObserver(obs_.get()); |
55 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 55 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
56 EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval); | 56 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
| 57 1000 + kDeadline, kInterval); |
57 task_runner_->RunPendingTasks(); | 58 task_runner_->RunPendingTasks(); |
58 | 59 |
59 EXPECT_BEGIN_FRAME_USED(*obs_, 1100, 1100 + kDeadline, kInterval); | 60 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, |
| 61 1100 + kDeadline, kInterval); |
60 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 62 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
61 source_->DidFinishFrame(obs_.get(), 0); | 63 source_->DidFinishFrame(obs_.get(), |
| 64 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
62 task_runner_->RunPendingTasks(); | 65 task_runner_->RunPendingTasks(); |
63 } | 66 } |
64 | 67 |
65 TEST_F(BackToBackBeginFrameSourceTest, | 68 TEST_F(BackToBackBeginFrameSourceTest, |
66 DidFinishFrameThenRemoveObserverProducesNoFrame) { | 69 RemoveObserverThenDidFinishFrameProducesNoFrame) { |
67 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 70 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
68 source_->AddObserver(obs_.get()); | 71 source_->AddObserver(obs_.get()); |
69 EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval); | 72 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
| 73 1000 + kDeadline, kInterval); |
70 task_runner_->RunPendingTasks(); | 74 task_runner_->RunPendingTasks(); |
71 | 75 |
72 source_->RemoveObserver(obs_.get()); | 76 source_->RemoveObserver(obs_.get()); |
73 source_->DidFinishFrame(obs_.get(), 0); | 77 source_->DidFinishFrame(obs_.get(), |
| 78 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
74 | 79 |
75 // Verify no BeginFrame is sent to |obs_|. There is a pending task in the | 80 // Verify no BeginFrame is sent to |obs_|. There is a pending task in the |
76 // task_runner_ as a BeginFrame was posted, but it gets aborted since |obs_| | 81 // task_runner_ as a BeginFrame was posted, but it gets aborted since |obs_| |
77 // is removed. | 82 // is removed. |
78 task_runner_->RunPendingTasks(); | 83 task_runner_->RunPendingTasks(); |
79 EXPECT_FALSE(task_runner_->HasPendingTasks()); | 84 EXPECT_FALSE(task_runner_->HasPendingTasks()); |
80 } | 85 } |
81 | 86 |
82 TEST_F(BackToBackBeginFrameSourceTest, | 87 TEST_F(BackToBackBeginFrameSourceTest, |
83 RemoveObserverThenDidFinishFrameProducesNoFrame) { | 88 DidFinishFrameThenRemoveObserverProducesNoFrame) { |
84 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 89 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
85 source_->AddObserver(obs_.get()); | 90 source_->AddObserver(obs_.get()); |
86 EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval); | 91 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
| 92 1000 + kDeadline, kInterval); |
87 task_runner_->RunPendingTasks(); | 93 task_runner_->RunPendingTasks(); |
88 | 94 |
89 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 95 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
90 source_->DidFinishFrame(obs_.get(), 0); | 96 source_->DidFinishFrame(obs_.get(), |
| 97 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
91 source_->RemoveObserver(obs_.get()); | 98 source_->RemoveObserver(obs_.get()); |
92 | 99 |
93 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 100 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
94 task_runner_->RunPendingTasks(); | 101 task_runner_->RunPendingTasks(); |
95 } | 102 } |
96 | 103 |
97 TEST_F(BackToBackBeginFrameSourceTest, | 104 TEST_F(BackToBackBeginFrameSourceTest, |
98 TogglingObserverThenDidFinishFrameProducesCorrectFrame) { | 105 TogglingObserverThenDidFinishFrameProducesCorrectFrame) { |
99 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 106 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
100 source_->AddObserver(obs_.get()); | 107 source_->AddObserver(obs_.get()); |
101 EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval); | 108 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
| 109 1000 + kDeadline, kInterval); |
102 task_runner_->RunPendingTasks(); | 110 task_runner_->RunPendingTasks(); |
103 | 111 |
104 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 112 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
105 source_->RemoveObserver(obs_.get()); | 113 source_->RemoveObserver(obs_.get()); |
106 | 114 |
107 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 115 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
108 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 116 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
109 source_->AddObserver(obs_.get()); | 117 source_->AddObserver(obs_.get()); |
110 | 118 |
111 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 119 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
112 source_->DidFinishFrame(obs_.get(), 0); | 120 source_->DidFinishFrame(obs_.get(), |
| 121 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
113 | 122 |
114 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 123 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
115 // The begin frame is posted at the time when the observer was added, | 124 // The begin frame is posted at the time when the observer was added, |
116 // so it ignores changes to "now" afterward. | 125 // so it ignores changes to "now" afterward. |
117 EXPECT_BEGIN_FRAME_USED(*obs_, 1110, 1110 + kDeadline, kInterval); | 126 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1110, |
| 127 1110 + kDeadline, kInterval); |
118 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 128 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
119 task_runner_->RunPendingTasks(); | 129 task_runner_->RunPendingTasks(); |
120 } | 130 } |
121 | 131 |
122 TEST_F(BackToBackBeginFrameSourceTest, | 132 TEST_F(BackToBackBeginFrameSourceTest, |
123 DidFinishFrameThenTogglingObserverProducesCorrectFrame) { | 133 DidFinishFrameThenTogglingObserverProducesCorrectFrame) { |
124 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 134 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
125 source_->AddObserver(obs_.get()); | 135 source_->AddObserver(obs_.get()); |
126 EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval); | 136 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
| 137 1000 + kDeadline, kInterval); |
127 task_runner_->RunPendingTasks(); | 138 task_runner_->RunPendingTasks(); |
128 | 139 |
129 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 140 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
130 source_->DidFinishFrame(obs_.get(), 0); | 141 source_->DidFinishFrame(obs_.get(), |
| 142 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
131 | 143 |
132 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 144 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
133 source_->RemoveObserver(obs_.get()); | 145 source_->RemoveObserver(obs_.get()); |
134 | 146 |
135 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 147 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
136 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 148 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
137 source_->AddObserver(obs_.get()); | 149 source_->AddObserver(obs_.get()); |
138 | 150 |
139 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); | 151 now_src_->Advance(base::TimeDelta::FromMicroseconds(10)); |
140 // Ticks at the time at which the observer was added, ignoring the | 152 // Ticks at the time at which the observer was added, ignoring the |
141 // last change to "now". | 153 // last change to "now". |
142 EXPECT_BEGIN_FRAME_USED(*obs_, 1120, 1120 + kDeadline, kInterval); | 154 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1120, |
| 155 1120 + kDeadline, kInterval); |
143 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 156 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
144 task_runner_->RunPendingTasks(); | 157 task_runner_->RunPendingTasks(); |
145 } | 158 } |
146 | 159 |
147 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameNoObserver) { | 160 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameNoObserver) { |
148 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 161 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
149 source_->AddObserver(obs_.get()); | 162 source_->AddObserver(obs_.get()); |
150 source_->RemoveObserver(obs_.get()); | 163 source_->RemoveObserver(obs_.get()); |
151 source_->DidFinishFrame(obs_.get(), 0); | 164 source_->DidFinishFrame(obs_.get(), |
| 165 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
152 EXPECT_FALSE(task_runner_->RunPendingTasks()); | 166 EXPECT_FALSE(task_runner_->RunPendingTasks()); |
153 } | 167 } |
154 | 168 |
155 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameRemainingFrames) { | 169 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameRemainingFrames) { |
156 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 170 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
157 source_->AddObserver(obs_.get()); | 171 source_->AddObserver(obs_.get()); |
158 EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval); | 172 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
| 173 1000 + kDeadline, kInterval); |
159 // Runs the pending begin frame. | 174 // Runs the pending begin frame. |
160 task_runner_->RunPendingTasks(); | 175 task_runner_->RunPendingTasks(); |
161 // While running the begin frame, the next frame was cancelled, this | 176 // While running the begin frame, the next frame was cancelled, this |
162 // runs the next frame, sees it was cancelled, and goes to sleep. | 177 // runs the next frame, sees it was cancelled, and goes to sleep. |
163 task_runner_->RunPendingTasks(); | 178 task_runner_->RunPendingTasks(); |
164 EXPECT_FALSE(task_runner_->HasPendingTasks()); | 179 EXPECT_FALSE(task_runner_->HasPendingTasks()); |
165 | 180 |
166 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 181 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
167 | 182 |
168 source_->DidFinishFrame(obs_.get(), 3); | 183 source_->DidFinishFrame(obs_.get(), |
| 184 BeginFrameAck(source_->source_id(), 1, 1, 3, true)); |
169 EXPECT_FALSE(task_runner_->HasPendingTasks()); | 185 EXPECT_FALSE(task_runner_->HasPendingTasks()); |
170 source_->DidFinishFrame(obs_.get(), 2); | 186 source_->DidFinishFrame(obs_.get(), |
| 187 BeginFrameAck(source_->source_id(), 1, 1, 2, true)); |
171 EXPECT_FALSE(task_runner_->HasPendingTasks()); | 188 EXPECT_FALSE(task_runner_->HasPendingTasks()); |
172 source_->DidFinishFrame(obs_.get(), 1); | 189 source_->DidFinishFrame(obs_.get(), |
| 190 BeginFrameAck(source_->source_id(), 1, 1, 1, true)); |
173 EXPECT_FALSE(task_runner_->HasPendingTasks()); | 191 EXPECT_FALSE(task_runner_->HasPendingTasks()); |
174 | 192 |
175 EXPECT_BEGIN_FRAME_USED(*obs_, 1100, 1100 + kDeadline, kInterval); | 193 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, |
176 source_->DidFinishFrame(obs_.get(), 0); | 194 1100 + kDeadline, kInterval); |
| 195 source_->DidFinishFrame(obs_.get(), |
| 196 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
177 EXPECT_EQ(base::TimeDelta(), task_runner_->DelayToNextTaskTime()); | 197 EXPECT_EQ(base::TimeDelta(), task_runner_->DelayToNextTaskTime()); |
178 task_runner_->RunPendingTasks(); | 198 task_runner_->RunPendingTasks(); |
179 } | 199 } |
180 | 200 |
181 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameMultipleCallsIdempotent) { | 201 TEST_F(BackToBackBeginFrameSourceTest, DidFinishFrameMultipleCallsIdempotent) { |
182 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 202 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
183 source_->AddObserver(obs_.get()); | 203 source_->AddObserver(obs_.get()); |
184 EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval); | 204 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
| 205 1000 + kDeadline, kInterval); |
185 task_runner_->RunPendingTasks(); | 206 task_runner_->RunPendingTasks(); |
186 | 207 |
187 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 208 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
188 source_->DidFinishFrame(obs_.get(), 0); | 209 source_->DidFinishFrame(obs_.get(), |
189 source_->DidFinishFrame(obs_.get(), 0); | 210 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
190 source_->DidFinishFrame(obs_.get(), 0); | 211 source_->DidFinishFrame(obs_.get(), |
191 EXPECT_BEGIN_FRAME_USED(*obs_, 1100, 1100 + kDeadline, kInterval); | 212 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
| 213 source_->DidFinishFrame(obs_.get(), |
| 214 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
| 215 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, |
| 216 1100 + kDeadline, kInterval); |
192 task_runner_->RunPendingTasks(); | 217 task_runner_->RunPendingTasks(); |
193 | 218 |
194 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 219 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
195 source_->DidFinishFrame(obs_.get(), 0); | 220 source_->DidFinishFrame(obs_.get(), |
196 source_->DidFinishFrame(obs_.get(), 0); | 221 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); |
197 source_->DidFinishFrame(obs_.get(), 0); | 222 source_->DidFinishFrame(obs_.get(), |
198 EXPECT_BEGIN_FRAME_USED(*obs_, 1200, 1200 + kDeadline, kInterval); | 223 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); |
| 224 source_->DidFinishFrame(obs_.get(), |
| 225 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); |
| 226 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 3, 1200, |
| 227 1200 + kDeadline, kInterval); |
199 task_runner_->RunPendingTasks(); | 228 task_runner_->RunPendingTasks(); |
200 } | 229 } |
201 | 230 |
202 TEST_F(BackToBackBeginFrameSourceTest, DelayInPostedTaskProducesCorrectFrame) { | 231 TEST_F(BackToBackBeginFrameSourceTest, DelayInPostedTaskProducesCorrectFrame) { |
203 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 232 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
204 source_->AddObserver(obs_.get()); | 233 source_->AddObserver(obs_.get()); |
205 EXPECT_BEGIN_FRAME_USED(*obs_, 1000, 1000 + kDeadline, kInterval); | 234 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 1, 1000, |
| 235 1000 + kDeadline, kInterval); |
206 task_runner_->RunPendingTasks(); | 236 task_runner_->RunPendingTasks(); |
207 | 237 |
208 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 238 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
209 source_->DidFinishFrame(obs_.get(), 0); | 239 source_->DidFinishFrame(obs_.get(), |
| 240 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
210 now_src_->Advance(base::TimeDelta::FromMicroseconds(50)); | 241 now_src_->Advance(base::TimeDelta::FromMicroseconds(50)); |
211 // Ticks at the time the last frame finished, so ignores the last change to | 242 // Ticks at the time the last frame finished, so ignores the last change to |
212 // "now". | 243 // "now". |
213 EXPECT_BEGIN_FRAME_USED(*obs_, 1100, 1100 + kDeadline, kInterval); | 244 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 1100, |
| 245 1100 + kDeadline, kInterval); |
214 | 246 |
215 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 247 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
216 task_runner_->RunPendingTasks(); | 248 task_runner_->RunPendingTasks(); |
217 } | 249 } |
218 | 250 |
219 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversSynchronized) { | 251 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversSynchronized) { |
220 StrictMock<MockBeginFrameObserver> obs1, obs2; | 252 StrictMock<MockBeginFrameObserver> obs1, obs2; |
221 | 253 |
222 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); | 254 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); |
223 source_->AddObserver(&obs1); | 255 source_->AddObserver(&obs1); |
224 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); | 256 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); |
225 source_->AddObserver(&obs2); | 257 source_->AddObserver(&obs2); |
226 | 258 |
227 EXPECT_BEGIN_FRAME_USED(obs1, 1000, 1000 + kDeadline, kInterval); | 259 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, |
228 EXPECT_BEGIN_FRAME_USED(obs2, 1000, 1000 + kDeadline, kInterval); | 260 kInterval); |
| 261 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline, |
| 262 kInterval); |
229 task_runner_->RunPendingTasks(); | 263 task_runner_->RunPendingTasks(); |
230 | 264 |
231 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 265 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
232 source_->DidFinishFrame(&obs1, 0); | 266 source_->DidFinishFrame(&obs1, |
233 source_->DidFinishFrame(&obs2, 0); | 267 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
234 EXPECT_BEGIN_FRAME_USED(obs1, 1100, 1100 + kDeadline, kInterval); | 268 source_->DidFinishFrame(&obs2, |
235 EXPECT_BEGIN_FRAME_USED(obs2, 1100, 1100 + kDeadline, kInterval); | 269 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
| 270 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 1100, 1100 + kDeadline, |
| 271 kInterval); |
| 272 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, |
| 273 kInterval); |
236 task_runner_->RunPendingTasks(); | 274 task_runner_->RunPendingTasks(); |
237 | 275 |
238 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 276 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
239 source_->DidFinishFrame(&obs1, 0); | 277 source_->DidFinishFrame(&obs1, |
240 source_->DidFinishFrame(&obs2, 0); | 278 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); |
| 279 source_->DidFinishFrame(&obs2, |
| 280 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); |
241 EXPECT_TRUE(task_runner_->HasPendingTasks()); | 281 EXPECT_TRUE(task_runner_->HasPendingTasks()); |
242 source_->RemoveObserver(&obs1); | 282 source_->RemoveObserver(&obs1); |
243 source_->RemoveObserver(&obs2); | 283 source_->RemoveObserver(&obs2); |
244 task_runner_->RunPendingTasks(); | 284 task_runner_->RunPendingTasks(); |
245 } | 285 } |
246 | 286 |
247 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversInterleaved) { | 287 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversInterleaved) { |
248 StrictMock<MockBeginFrameObserver> obs1, obs2; | 288 StrictMock<MockBeginFrameObserver> obs1, obs2; |
249 | 289 |
250 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); | 290 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); |
251 source_->AddObserver(&obs1); | 291 source_->AddObserver(&obs1); |
252 EXPECT_BEGIN_FRAME_USED(obs1, 1000, 1000 + kDeadline, kInterval); | 292 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, |
| 293 kInterval); |
253 task_runner_->RunPendingTasks(); | 294 task_runner_->RunPendingTasks(); |
254 | 295 |
255 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 296 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
256 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); | 297 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); |
257 source_->AddObserver(&obs2); | 298 source_->AddObserver(&obs2); |
258 EXPECT_BEGIN_FRAME_USED(obs2, 1100, 1100 + kDeadline, kInterval); | 299 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, |
| 300 kInterval); |
259 task_runner_->RunPendingTasks(); | 301 task_runner_->RunPendingTasks(); |
260 | 302 |
261 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 303 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
262 source_->DidFinishFrame(&obs1, 0); | 304 source_->DidFinishFrame(&obs1, |
263 EXPECT_BEGIN_FRAME_USED(obs1, 1200, 1200 + kDeadline, kInterval); | 305 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
| 306 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 3, 1200, 1200 + kDeadline, |
| 307 kInterval); |
264 task_runner_->RunPendingTasks(); | 308 task_runner_->RunPendingTasks(); |
265 | 309 |
266 source_->DidFinishFrame(&obs1, 0); | 310 source_->DidFinishFrame(&obs1, |
| 311 BeginFrameAck(source_->source_id(), 3, 3, 0, true)); |
267 source_->RemoveObserver(&obs1); | 312 source_->RemoveObserver(&obs1); |
268 // Finishing the frame for |obs1| posts a begin frame task, which will be | 313 // Finishing the frame for |obs1| posts a begin frame task, which will be |
269 // aborted since |obs1| is removed. Clear that from the task runner. | 314 // aborted since |obs1| is removed. Clear that from the task runner. |
270 task_runner_->RunPendingTasks(); | 315 task_runner_->RunPendingTasks(); |
271 | 316 |
272 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 317 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
273 source_->DidFinishFrame(&obs2, 0); | 318 source_->DidFinishFrame(&obs2, |
274 EXPECT_BEGIN_FRAME_USED(obs2, 1300, 1300 + kDeadline, kInterval); | 319 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); |
| 320 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 4, 1300, 1300 + kDeadline, |
| 321 kInterval); |
275 task_runner_->RunPendingTasks(); | 322 task_runner_->RunPendingTasks(); |
276 | 323 |
277 source_->DidFinishFrame(&obs2, 0); | 324 source_->DidFinishFrame(&obs2, |
| 325 BeginFrameAck(source_->source_id(), 4, 4, 0, true)); |
278 source_->RemoveObserver(&obs2); | 326 source_->RemoveObserver(&obs2); |
279 } | 327 } |
280 | 328 |
281 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversAtOnce) { | 329 TEST_F(BackToBackBeginFrameSourceTest, MultipleObserversAtOnce) { |
282 StrictMock<MockBeginFrameObserver> obs1, obs2; | 330 StrictMock<MockBeginFrameObserver> obs1, obs2; |
283 | 331 |
284 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); | 332 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); |
285 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); | 333 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); |
286 source_->AddObserver(&obs1); | 334 source_->AddObserver(&obs1); |
287 source_->AddObserver(&obs2); | 335 source_->AddObserver(&obs2); |
288 EXPECT_BEGIN_FRAME_USED(obs1, 1000, 1000 + kDeadline, kInterval); | 336 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 1, 1000, 1000 + kDeadline, |
289 EXPECT_BEGIN_FRAME_USED(obs2, 1000, 1000 + kDeadline, kInterval); | 337 kInterval); |
| 338 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 1, 1000, 1000 + kDeadline, |
| 339 kInterval); |
290 task_runner_->RunPendingTasks(); | 340 task_runner_->RunPendingTasks(); |
291 | 341 |
292 // |obs1| finishes first. | 342 // |obs1| finishes first. |
293 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 343 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
294 source_->DidFinishFrame(&obs1, 0); | 344 source_->DidFinishFrame(&obs1, |
| 345 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
295 | 346 |
296 // |obs2| finishes also, before getting to the newly posted begin frame. | 347 // |obs2| finishes also, before getting to the newly posted begin frame. |
297 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); | 348 now_src_->Advance(base::TimeDelta::FromMicroseconds(100)); |
298 source_->DidFinishFrame(&obs2, 0); | 349 source_->DidFinishFrame(&obs2, |
| 350 BeginFrameAck(source_->source_id(), 1, 1, 0, true)); |
299 | 351 |
300 // Because the begin frame source already ticked when |obs1| finished, | 352 // Because the begin frame source already ticked when |obs1| finished, |
301 // we see it as the frame time for both observers. | 353 // we see it as the frame time for both observers. |
302 EXPECT_BEGIN_FRAME_USED(obs1, 1100, 1100 + kDeadline, kInterval); | 354 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 1100, 1100 + kDeadline, |
303 EXPECT_BEGIN_FRAME_USED(obs2, 1100, 1100 + kDeadline, kInterval); | 355 kInterval); |
| 356 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 2, 1100, 1100 + kDeadline, |
| 357 kInterval); |
304 task_runner_->RunPendingTasks(); | 358 task_runner_->RunPendingTasks(); |
305 | 359 |
306 source_->DidFinishFrame(&obs1, 0); | 360 source_->DidFinishFrame(&obs1, |
| 361 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); |
307 source_->RemoveObserver(&obs1); | 362 source_->RemoveObserver(&obs1); |
308 source_->DidFinishFrame(&obs2, 0); | 363 source_->DidFinishFrame(&obs2, |
| 364 BeginFrameAck(source_->source_id(), 2, 2, 0, true)); |
309 source_->RemoveObserver(&obs2); | 365 source_->RemoveObserver(&obs2); |
310 } | 366 } |
311 | 367 |
| 368 // TODO(eseckler): Tests for BeginFrame numbering in BackToBackBFS. |
| 369 |
312 // DelayBasedBeginFrameSource testing ------------------------------------------ | 370 // DelayBasedBeginFrameSource testing ------------------------------------------ |
313 class DelayBasedBeginFrameSourceTest : public ::testing::Test { | 371 class DelayBasedBeginFrameSourceTest : public ::testing::Test { |
314 public: | 372 public: |
315 std::unique_ptr<base::SimpleTestTickClock> now_src_; | 373 std::unique_ptr<base::SimpleTestTickClock> now_src_; |
316 scoped_refptr<OrderedSimpleTaskRunner> task_runner_; | 374 scoped_refptr<OrderedSimpleTaskRunner> task_runner_; |
317 std::unique_ptr<DelayBasedBeginFrameSource> source_; | 375 std::unique_ptr<DelayBasedBeginFrameSource> source_; |
318 std::unique_ptr<MockBeginFrameObserver> obs_; | 376 std::unique_ptr<MockBeginFrameObserver> obs_; |
319 | 377 |
320 void SetUp() override { | 378 void SetUp() override { |
321 now_src_.reset(new base::SimpleTestTickClock()); | 379 now_src_.reset(new base::SimpleTestTickClock()); |
322 now_src_->Advance(base::TimeDelta::FromMicroseconds(1000)); | 380 now_src_->Advance(base::TimeDelta::FromMicroseconds(1000)); |
323 task_runner_ = | 381 task_runner_ = |
324 make_scoped_refptr(new OrderedSimpleTaskRunner(now_src_.get(), false)); | 382 make_scoped_refptr(new OrderedSimpleTaskRunner(now_src_.get(), false)); |
325 std::unique_ptr<DelayBasedTimeSource> time_source( | 383 std::unique_ptr<DelayBasedTimeSource> time_source( |
326 new TestDelayBasedTimeSource(now_src_.get(), task_runner_.get())); | 384 new TestDelayBasedTimeSource(now_src_.get(), task_runner_.get())); |
327 time_source->SetTimebaseAndInterval( | 385 time_source->SetTimebaseAndInterval( |
328 base::TimeTicks(), base::TimeDelta::FromMicroseconds(10000)); | 386 base::TimeTicks(), base::TimeDelta::FromMicroseconds(10000)); |
329 source_.reset(new DelayBasedBeginFrameSource(std::move(time_source))); | 387 source_.reset(new DelayBasedBeginFrameSource(std::move(time_source))); |
330 obs_.reset(new MockBeginFrameObserver); | 388 obs_.reset(new MockBeginFrameObserver); |
331 } | 389 } |
332 | 390 |
333 void TearDown() override { obs_.reset(); } | 391 void TearDown() override { obs_.reset(); } |
334 }; | 392 }; |
335 | 393 |
336 TEST_F(DelayBasedBeginFrameSourceTest, | 394 TEST_F(DelayBasedBeginFrameSourceTest, |
337 AddObserverCallsOnBeginFrameWithMissedTick) { | 395 AddObserverCallsOnBeginFrameWithMissedTick) { |
338 now_src_->Advance(base::TimeDelta::FromMicroseconds(9010)); | 396 now_src_->Advance(base::TimeDelta::FromMicroseconds(9010)); |
339 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 397 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
340 EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, 10000, 20000, 10000); | 398 EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, source_->source_id(), 1, 10000, 20000, |
| 399 10000); |
341 source_->AddObserver(obs_.get()); // Should cause the last tick to be sent | 400 source_->AddObserver(obs_.get()); // Should cause the last tick to be sent |
342 // No tasks should need to be run for this to occur. | 401 // No tasks should need to be run for this to occur. |
343 } | 402 } |
344 | 403 |
345 TEST_F(DelayBasedBeginFrameSourceTest, AddObserverCallsCausesOnBeginFrame) { | 404 TEST_F(DelayBasedBeginFrameSourceTest, AddObserverCallsCausesOnBeginFrame) { |
346 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 405 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
347 EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, 0, 10000, 10000); | 406 EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, source_->source_id(), 1, 0, 10000, |
| 407 10000); |
348 source_->AddObserver(obs_.get()); | 408 source_->AddObserver(obs_.get()); |
349 EXPECT_EQ(10000, task_runner_->NextTaskTime().ToInternalValue()); | 409 EXPECT_EQ(10000, task_runner_->NextTaskTime().ToInternalValue()); |
350 | 410 |
351 EXPECT_BEGIN_FRAME_USED(*obs_, 10000, 20000, 10000); | 411 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 10000, 20000, 10000); |
352 now_src_->Advance(base::TimeDelta::FromMicroseconds(9010)); | 412 now_src_->Advance(base::TimeDelta::FromMicroseconds(9010)); |
353 task_runner_->RunPendingTasks(); | 413 task_runner_->RunPendingTasks(); |
354 } | 414 } |
355 | 415 |
356 TEST_F(DelayBasedBeginFrameSourceTest, BasicOperation) { | 416 TEST_F(DelayBasedBeginFrameSourceTest, BasicOperation) { |
357 task_runner_->SetAutoAdvanceNowToPendingTasks(true); | 417 task_runner_->SetAutoAdvanceNowToPendingTasks(true); |
358 | 418 |
359 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 419 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
360 EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, 0, 10000, 10000); | 420 EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, source_->source_id(), 1, 0, 10000, |
| 421 10000); |
361 source_->AddObserver(obs_.get()); | 422 source_->AddObserver(obs_.get()); |
362 EXPECT_BEGIN_FRAME_USED(*obs_, 10000, 20000, 10000); | 423 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 10000, 20000, 10000); |
363 EXPECT_BEGIN_FRAME_USED(*obs_, 20000, 30000, 10000); | 424 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 3, 20000, 30000, 10000); |
364 EXPECT_BEGIN_FRAME_USED(*obs_, 30000, 40000, 10000); | 425 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 4, 30000, 40000, 10000); |
365 task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(30001)); | 426 task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(30001)); |
366 | 427 |
367 source_->RemoveObserver(obs_.get()); | 428 source_->RemoveObserver(obs_.get()); |
368 // No new frames.... | 429 // No new frames.... |
369 task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(60000)); | 430 task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(60000)); |
370 } | 431 } |
371 | 432 |
372 TEST_F(DelayBasedBeginFrameSourceTest, VSyncChanges) { | 433 TEST_F(DelayBasedBeginFrameSourceTest, VSyncChanges) { |
373 task_runner_->SetAutoAdvanceNowToPendingTasks(true); | 434 task_runner_->SetAutoAdvanceNowToPendingTasks(true); |
374 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 435 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
375 EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, 0, 10000, 10000); | 436 EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, source_->source_id(), 1, 0, 10000, |
| 437 10000); |
376 source_->AddObserver(obs_.get()); | 438 source_->AddObserver(obs_.get()); |
377 | 439 |
378 EXPECT_BEGIN_FRAME_USED(*obs_, 10000, 20000, 10000); | 440 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 10000, 20000, 10000); |
379 EXPECT_BEGIN_FRAME_USED(*obs_, 20000, 30000, 10000); | 441 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 3, 20000, 30000, 10000); |
380 EXPECT_BEGIN_FRAME_USED(*obs_, 30000, 40000, 10000); | 442 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 4, 30000, 40000, 10000); |
381 task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(30001)); | 443 task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(30001)); |
382 | 444 |
383 // Update the vsync information | 445 // Update the vsync information |
384 source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(27500), | 446 source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(27500), |
385 base::TimeDelta::FromMicroseconds(10001)); | 447 base::TimeDelta::FromMicroseconds(10001)); |
386 | 448 |
387 EXPECT_BEGIN_FRAME_USED(*obs_, 40000, 47502, 10001); | 449 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 5, 40000, 47502, 10001); |
388 EXPECT_BEGIN_FRAME_USED(*obs_, 47502, 57503, 10001); | 450 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 6, 47502, 57503, 10001); |
389 EXPECT_BEGIN_FRAME_USED(*obs_, 57503, 67504, 10001); | 451 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 7, 57503, 67504, 10001); |
390 task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(60000)); | 452 task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(60000)); |
391 } | 453 } |
392 | 454 |
393 TEST_F(DelayBasedBeginFrameSourceTest, AuthoritativeVSyncChanges) { | 455 TEST_F(DelayBasedBeginFrameSourceTest, AuthoritativeVSyncChanges) { |
394 task_runner_->SetAutoAdvanceNowToPendingTasks(true); | 456 task_runner_->SetAutoAdvanceNowToPendingTasks(true); |
395 source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(500), | 457 source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(500), |
396 base::TimeDelta::FromMicroseconds(10000)); | 458 base::TimeDelta::FromMicroseconds(10000)); |
397 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); | 459 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(*obs_, false); |
398 EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, 500, 10500, 10000); | 460 EXPECT_BEGIN_FRAME_USED_MISSED(*obs_, source_->source_id(), 1, 500, 10500, |
| 461 10000); |
399 source_->AddObserver(obs_.get()); | 462 source_->AddObserver(obs_.get()); |
400 | 463 |
401 EXPECT_BEGIN_FRAME_USED(*obs_, 10500, 20500, 10000); | 464 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 2, 10500, 20500, 10000); |
402 EXPECT_BEGIN_FRAME_USED(*obs_, 20500, 30500, 10000); | 465 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 3, 20500, 30500, 10000); |
403 task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(20501)); | 466 task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(20501)); |
404 | 467 |
405 // This will keep the same timebase, so 500, 9999 | 468 // This will keep the same timebase, so 500, 9999 |
406 source_->SetAuthoritativeVSyncInterval( | 469 source_->SetAuthoritativeVSyncInterval( |
407 base::TimeDelta::FromMicroseconds(9999)); | 470 base::TimeDelta::FromMicroseconds(9999)); |
408 EXPECT_BEGIN_FRAME_USED(*obs_, 30500, 40496, 9999); | 471 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 4, 30500, 40496, 9999); |
409 EXPECT_BEGIN_FRAME_USED(*obs_, 40496, 50495, 9999); | 472 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 5, 40496, 50495, 9999); |
410 task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(40497)); | 473 task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(40497)); |
411 | 474 |
412 // Change the vsync params, but the new interval will be ignored. | 475 // Change the vsync params, but the new interval will be ignored. |
413 source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(400), | 476 source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(400), |
414 base::TimeDelta::FromMicroseconds(1)); | 477 base::TimeDelta::FromMicroseconds(1)); |
415 EXPECT_BEGIN_FRAME_USED(*obs_, 50495, 60394, 9999); | 478 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 6, 50495, 60394, 9999); |
416 EXPECT_BEGIN_FRAME_USED(*obs_, 60394, 70393, 9999); | 479 EXPECT_BEGIN_FRAME_USED(*obs_, source_->source_id(), 7, 60394, 70393, 9999); |
417 task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(60395)); | 480 task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(60395)); |
418 } | 481 } |
419 | 482 |
420 TEST_F(DelayBasedBeginFrameSourceTest, MultipleObservers) { | 483 TEST_F(DelayBasedBeginFrameSourceTest, MultipleObservers) { |
421 StrictMock<MockBeginFrameObserver> obs1, obs2; | 484 StrictMock<MockBeginFrameObserver> obs1, obs2; |
422 | 485 |
423 // now_src_ starts off at 1000. | 486 // now_src_ starts off at 1000. |
424 task_runner_->RunForPeriod(base::TimeDelta::FromMicroseconds(9010)); | 487 task_runner_->RunForPeriod(base::TimeDelta::FromMicroseconds(9010)); |
425 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); | 488 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs1, false); |
426 EXPECT_BEGIN_FRAME_USED_MISSED(obs1, 10000, 20000, 10000); | 489 EXPECT_BEGIN_FRAME_USED_MISSED(obs1, source_->source_id(), 1, 10000, 20000, |
| 490 10000); |
427 source_->AddObserver(&obs1); // Should cause the last tick to be sent | 491 source_->AddObserver(&obs1); // Should cause the last tick to be sent |
428 // No tasks should need to be run for this to occur. | 492 // No tasks should need to be run for this to occur. |
429 | 493 |
430 EXPECT_BEGIN_FRAME_USED(obs1, 20000, 30000, 10000); | 494 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 2, 20000, 30000, 10000); |
431 task_runner_->RunForPeriod(base::TimeDelta::FromMicroseconds(10000)); | 495 task_runner_->RunForPeriod(base::TimeDelta::FromMicroseconds(10000)); |
432 | 496 |
433 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); | 497 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs2, false); |
434 EXPECT_BEGIN_FRAME_USED_MISSED(obs2, 20000, 30000, 10000); | 498 EXPECT_BEGIN_FRAME_USED_MISSED(obs2, source_->source_id(), 2, 20000, 30000, |
| 499 10000); |
435 source_->AddObserver(&obs2); // Should cause the last tick to be sent | 500 source_->AddObserver(&obs2); // Should cause the last tick to be sent |
436 // No tasks should need to be run for this to occur. | 501 // No tasks should need to be run for this to occur. |
437 | 502 |
438 EXPECT_BEGIN_FRAME_USED(obs1, 30000, 40000, 10000); | 503 EXPECT_BEGIN_FRAME_USED(obs1, source_->source_id(), 3, 30000, 40000, 10000); |
439 EXPECT_BEGIN_FRAME_USED(obs2, 30000, 40000, 10000); | 504 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 3, 30000, 40000, 10000); |
440 task_runner_->RunForPeriod(base::TimeDelta::FromMicroseconds(10000)); | 505 task_runner_->RunForPeriod(base::TimeDelta::FromMicroseconds(10000)); |
441 | 506 |
442 source_->RemoveObserver(&obs1); | 507 source_->RemoveObserver(&obs1); |
443 | 508 |
444 EXPECT_BEGIN_FRAME_USED(obs2, 40000, 50000, 10000); | 509 EXPECT_BEGIN_FRAME_USED(obs2, source_->source_id(), 4, 40000, 50000, 10000); |
445 task_runner_->RunForPeriod(base::TimeDelta::FromMicroseconds(10000)); | 510 task_runner_->RunForPeriod(base::TimeDelta::FromMicroseconds(10000)); |
446 | 511 |
447 source_->RemoveObserver(&obs2); | 512 source_->RemoveObserver(&obs2); |
448 task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(50000)); | 513 task_runner_->RunUntilTime(base::TimeTicks::FromInternalValue(50000)); |
449 EXPECT_FALSE(task_runner_->HasPendingTasks()); | 514 EXPECT_FALSE(task_runner_->HasPendingTasks()); |
450 } | 515 } |
451 | 516 |
452 TEST_F(DelayBasedBeginFrameSourceTest, DoubleTick) { | 517 TEST_F(DelayBasedBeginFrameSourceTest, DoubleTick) { |
453 StrictMock<MockBeginFrameObserver> obs; | 518 StrictMock<MockBeginFrameObserver> obs; |
454 | 519 |
455 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs, false); | 520 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs, false); |
456 EXPECT_BEGIN_FRAME_USED_MISSED(obs, 0, 10000, 10000); | 521 EXPECT_BEGIN_FRAME_USED_MISSED(obs, source_->source_id(), 1, 0, 10000, 10000); |
457 source_->AddObserver(&obs); | 522 source_->AddObserver(&obs); |
458 | 523 |
459 source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(5000), | 524 source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(5000), |
460 base::TimeDelta::FromInternalValue(10000)); | 525 base::TimeDelta::FromInternalValue(10000)); |
461 now_src_->Advance(base::TimeDelta::FromInternalValue(4000)); | 526 now_src_->Advance(base::TimeDelta::FromInternalValue(4000)); |
462 | 527 |
463 // No begin frame received. | 528 // No begin frame received. |
464 task_runner_->RunPendingTasks(); | 529 task_runner_->RunPendingTasks(); |
465 | 530 |
466 // Begin frame received. | 531 // Begin frame received. |
467 source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(10000), | 532 source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(10000), |
468 base::TimeDelta::FromInternalValue(10000)); | 533 base::TimeDelta::FromInternalValue(10000)); |
469 now_src_->Advance(base::TimeDelta::FromInternalValue(5000)); | 534 now_src_->Advance(base::TimeDelta::FromInternalValue(5000)); |
470 EXPECT_BEGIN_FRAME_USED(obs, 10000, 20000, 10000); | 535 EXPECT_BEGIN_FRAME_USED(obs, source_->source_id(), 2, 10000, 20000, 10000); |
471 task_runner_->RunPendingTasks(); | 536 task_runner_->RunPendingTasks(); |
472 } | 537 } |
473 | 538 |
474 TEST_F(DelayBasedBeginFrameSourceTest, DoubleTickMissedFrame) { | 539 TEST_F(DelayBasedBeginFrameSourceTest, DoubleTickMissedFrame) { |
475 StrictMock<MockBeginFrameObserver> obs; | 540 StrictMock<MockBeginFrameObserver> obs; |
476 | 541 |
477 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs, false); | 542 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs, false); |
478 EXPECT_BEGIN_FRAME_USED_MISSED(obs, 0, 10000, 10000); | 543 EXPECT_BEGIN_FRAME_USED_MISSED(obs, source_->source_id(), 1, 0, 10000, 10000); |
479 source_->AddObserver(&obs); | 544 source_->AddObserver(&obs); |
480 source_->RemoveObserver(&obs); | 545 source_->RemoveObserver(&obs); |
481 | 546 |
482 source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(5000), | 547 source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(5000), |
483 base::TimeDelta::FromInternalValue(10000)); | 548 base::TimeDelta::FromInternalValue(10000)); |
484 now_src_->Advance(base::TimeDelta::FromInternalValue(4000)); | 549 now_src_->Advance(base::TimeDelta::FromInternalValue(4000)); |
485 | 550 |
486 // No missed frame received. | 551 // No missed frame received. |
487 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs, false); | 552 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs, false); |
488 source_->AddObserver(&obs); | 553 source_->AddObserver(&obs); |
489 source_->RemoveObserver(&obs); | 554 source_->RemoveObserver(&obs); |
490 | 555 |
491 // Missed frame received. | 556 // Missed frame received. |
492 source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(10000), | 557 source_->OnUpdateVSyncParameters(base::TimeTicks::FromInternalValue(10000), |
493 base::TimeDelta::FromInternalValue(10000)); | 558 base::TimeDelta::FromInternalValue(10000)); |
494 now_src_->Advance(base::TimeDelta::FromInternalValue(5000)); | 559 now_src_->Advance(base::TimeDelta::FromInternalValue(5000)); |
495 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs, false); | 560 EXPECT_BEGIN_FRAME_SOURCE_PAUSED(obs, false); |
496 EXPECT_BEGIN_FRAME_USED_MISSED(obs, 10000, 20000, 10000); | 561 EXPECT_BEGIN_FRAME_USED_MISSED(obs, source_->source_id(), 3, 10000, 20000, |
| 562 10000); |
497 source_->AddObserver(&obs); | 563 source_->AddObserver(&obs); |
498 source_->RemoveObserver(&obs); | 564 source_->RemoveObserver(&obs); |
499 } | 565 } |
500 | 566 |
| 567 // TODO(eseckler): Tests for source ids. |
| 568 |
| 569 // TODO(eseckler): Tests for BeginFrame numbering in DelayBasedBeginFrameSource. |
| 570 |
| 571 // TODO(eseckler): Tests for BeginFrameObserverAckTracker. |
| 572 |
| 573 // TODO(eseckler): Tests for ExternalBeginFrameSource (especially client calls). |
| 574 |
| 575 // TODO(eseckler): Tests for DelegatingBeginFrameSource. |
| 576 |
501 } // namespace | 577 } // namespace |
502 } // namespace cc | 578 } // namespace cc |
OLD | NEW |