Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(920)

Side by Side Diff: cc/scheduler/begin_frame_source.cc

Issue 2527283003: cc: Introduce BeginFrame sequence numbers and acknowledgements.
Patch Set: Address Sami's comments, DisplayScheduler observes while BFSObservers exist. Created 4 years ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright 2014 The Chromium Authors. All rights reserved. 1 // Copyright 2014 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 <stddef.h> 7 #include <stddef.h>
8 8
9 #include "base/atomic_sequence_num.h"
9 #include "base/auto_reset.h" 10 #include "base/auto_reset.h"
10 #include "base/location.h" 11 #include "base/location.h"
11 #include "base/logging.h" 12 #include "base/logging.h"
12 #include "base/memory/ptr_util.h" 13 #include "base/memory/ptr_util.h"
14 #include "base/process/process_handle.h"
15 #include "base/stl_util.h"
13 #include "base/strings/string_number_conversions.h" 16 #include "base/strings/string_number_conversions.h"
14 #include "base/strings/stringprintf.h" 17 #include "base/strings/stringprintf.h"
15 #include "base/trace_event/trace_event.h" 18 #include "base/trace_event/trace_event.h"
16 #include "base/trace_event/trace_event_argument.h" 19 #include "base/trace_event/trace_event_argument.h"
17 #include "cc/scheduler/delay_based_time_source.h" 20 #include "cc/scheduler/delay_based_time_source.h"
18 #include "cc/scheduler/scheduler.h" 21 #include "cc/scheduler/scheduler.h"
19 22
20 namespace cc { 23 namespace cc {
21 24
22 namespace { 25 namespace {
23 // kDoubleTickDivisor prevents the SyntheticBFS from sending BeginFrames too 26 // kDoubleTickDivisor prevents the SyntheticBFS from sending BeginFrames too
24 // often to an observer. 27 // often to an observer.
25 static const double kDoubleTickDivisor = 2.0; 28 static const double kDoubleTickDivisor = 2.0;
26 } 29 }
27 30
28 // BeginFrameObserverBase ----------------------------------------------- 31 // BeginFrameObserverBase -------------------------------------------------
29 BeginFrameObserverBase::BeginFrameObserverBase() 32 BeginFrameObserverBase::BeginFrameObserverBase()
30 : last_begin_frame_args_(), dropped_begin_frame_args_(0) { 33 : last_begin_frame_args_(), dropped_begin_frame_args_(0) {}
31 }
32 34
33 const BeginFrameArgs& BeginFrameObserverBase::LastUsedBeginFrameArgs() const { 35 const BeginFrameArgs& BeginFrameObserverBase::LastUsedBeginFrameArgs() const {
34 return last_begin_frame_args_; 36 return last_begin_frame_args_;
35 } 37 }
38
36 void BeginFrameObserverBase::OnBeginFrame(const BeginFrameArgs& args) { 39 void BeginFrameObserverBase::OnBeginFrame(const BeginFrameArgs& args) {
37 DCHECK(args.IsValid()); 40 DCHECK(args.IsValid()) << "args: " << BeginFrameArgs::TypeToString(args.type)
41 << " " << args.source_id << " " << args.sequence_number
42 << " " << args.frame_time.ToInternalValue() << " "
43 << args.interval.ToInternalValue() << " "
44 << args.deadline.ToInternalValue();
45 DCHECK(args.sequence_number > last_begin_frame_args_.sequence_number ||
46 args.source_id != last_begin_frame_args_.source_id);
38 DCHECK(args.frame_time >= last_begin_frame_args_.frame_time); 47 DCHECK(args.frame_time >= last_begin_frame_args_.frame_time);
39 bool used = OnBeginFrameDerivedImpl(args); 48 bool used = OnBeginFrameDerivedImpl(args);
40 if (used) { 49 if (used) {
41 last_begin_frame_args_ = args; 50 last_begin_frame_args_ = args;
42 } else { 51 } else {
43 ++dropped_begin_frame_args_; 52 ++dropped_begin_frame_args_;
44 } 53 }
45 } 54 }
46 55
56 // BeginFrameSource -------------------------------------------------------
57 namespace {
58 static base::StaticAtomicSequenceNumber next_source_id_;
59
60 uint64_t CreateSourceId() {
61 // Create a FNV hash from the process id for XORing.
62 // See http://isthe.com/chongo/tech/comp/fnv/ for algorithm details.
63 const uint64_t kOffsetBasis = 14695981039346656037ull;
64 const uint64_t kFnvPrime = 1099511628211ull;
65 const uint64_t pid = static_cast<uint64_t>(base::GetUniqueIdForProcess());
66 const uint64_t process_id_hash = (kOffsetBasis ^ pid) * kFnvPrime;
67
68 const uint64_t source_id = static_cast<uint64_t>(next_source_id_.GetNext());
69 // Make source id unlikely to collide with other processes.
70 return source_id ^ process_id_hash;
71 }
72 } // namespace
73
74 BeginFrameSource::BeginFrameSource() : source_id_(CreateSourceId()) {}
75
76 uint64_t BeginFrameSource::source_id() const {
77 return source_id_;
78 }
79
80 // StubBeginFrameSource ---------------------------------------------------
47 bool StubBeginFrameSource::IsThrottled() const { 81 bool StubBeginFrameSource::IsThrottled() const {
48 return true; 82 return true;
49 } 83 }
50 84
51 // SyntheticBeginFrameSource --------------------------------------------- 85 // SyntheticBeginFrameSource ----------------------------------------------
52 SyntheticBeginFrameSource::~SyntheticBeginFrameSource() = default; 86 SyntheticBeginFrameSource::~SyntheticBeginFrameSource() = default;
53 87
54 // BackToBackBeginFrameSource -------------------------------------------- 88 // BackToBackBeginFrameSource ---------------------------------------------
55 BackToBackBeginFrameSource::BackToBackBeginFrameSource( 89 BackToBackBeginFrameSource::BackToBackBeginFrameSource(
56 std::unique_ptr<DelayBasedTimeSource> time_source) 90 std::unique_ptr<DelayBasedTimeSource> time_source)
57 : time_source_(std::move(time_source)), weak_factory_(this) { 91 : time_source_(std::move(time_source)),
92 next_sequence_number_(1),
93 weak_factory_(this) {
58 time_source_->SetClient(this); 94 time_source_->SetClient(this);
59 // The time_source_ ticks immediately, so we SetActive(true) for a single 95 // The time_source_ ticks immediately, so we SetActive(true) for a single
60 // tick when we need it, and keep it as SetActive(false) otherwise. 96 // tick when we need it, and keep it as SetActive(false) otherwise.
61 time_source_->SetTimebaseAndInterval(base::TimeTicks(), base::TimeDelta()); 97 time_source_->SetTimebaseAndInterval(base::TimeTicks(), base::TimeDelta());
62 } 98 }
63 99
64 BackToBackBeginFrameSource::~BackToBackBeginFrameSource() = default; 100 BackToBackBeginFrameSource::~BackToBackBeginFrameSource() = default;
65 101
66 void BackToBackBeginFrameSource::AddObserver(BeginFrameObserver* obs) { 102 void BackToBackBeginFrameSource::AddObserver(BeginFrameObserver* obs) {
67 DCHECK(obs); 103 DCHECK(obs);
68 DCHECK(observers_.find(obs) == observers_.end()); 104 DCHECK(observers_.find(obs) == observers_.end());
69 observers_.insert(obs); 105 observers_.insert(obs);
70 pending_begin_frame_observers_.insert(obs); 106 pending_begin_frame_observers_.insert(obs);
71 obs->OnBeginFrameSourcePausedChanged(false); 107 obs->OnBeginFrameSourcePausedChanged(false);
72 time_source_->SetActive(true); 108 time_source_->SetActive(true);
73 } 109 }
74 110
75 void BackToBackBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) { 111 void BackToBackBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) {
76 DCHECK(obs); 112 DCHECK(obs);
77 DCHECK(observers_.find(obs) != observers_.end()); 113 DCHECK(observers_.find(obs) != observers_.end());
78 observers_.erase(obs); 114 observers_.erase(obs);
79 pending_begin_frame_observers_.erase(obs); 115 pending_begin_frame_observers_.erase(obs);
80 if (observers_.empty()) 116 if (pending_begin_frame_observers_.empty())
81 time_source_->SetActive(false); 117 time_source_->SetActive(false);
82 } 118 }
83 119
84 void BackToBackBeginFrameSource::DidFinishFrame(BeginFrameObserver* obs, 120 void BackToBackBeginFrameSource::DidFinishFrame(BeginFrameObserver* obs,
85 size_t remaining_frames) { 121 const BeginFrameAck& ack) {
86 if (remaining_frames == 0 && observers_.find(obs) != observers_.end()) { 122 if (ack.remaining_frames == 0 && observers_.find(obs) != observers_.end()) {
87 pending_begin_frame_observers_.insert(obs); 123 pending_begin_frame_observers_.insert(obs);
88 time_source_->SetActive(true); 124 time_source_->SetActive(true);
89 } 125 }
90 } 126 }
91 127
92 bool BackToBackBeginFrameSource::IsThrottled() const { 128 bool BackToBackBeginFrameSource::IsThrottled() const {
93 return false; 129 return false;
94 } 130 }
95 131
96 void BackToBackBeginFrameSource::OnTimerTick() { 132 void BackToBackBeginFrameSource::OnTimerTick() {
97 base::TimeTicks frame_time = time_source_->LastTickTime(); 133 base::TimeTicks frame_time = time_source_->LastTickTime();
98 base::TimeDelta default_interval = BeginFrameArgs::DefaultInterval(); 134 base::TimeDelta default_interval = BeginFrameArgs::DefaultInterval();
99 BeginFrameArgs args = BeginFrameArgs::Create( 135 BeginFrameArgs args = BeginFrameArgs::Create(
100 BEGINFRAME_FROM_HERE, frame_time, frame_time + default_interval, 136 BEGINFRAME_FROM_HERE, source_id(), next_sequence_number_++, frame_time,
101 default_interval, BeginFrameArgs::NORMAL); 137 frame_time + default_interval, default_interval, BeginFrameArgs::NORMAL);
102 138
103 // This must happen after getting the LastTickTime() from the time source. 139 // This must happen after getting the LastTickTime() from the time source.
104 time_source_->SetActive(false); 140 time_source_->SetActive(false);
105 141
106 std::unordered_set<BeginFrameObserver*> pending_observers; 142 std::unordered_set<BeginFrameObserver*> pending_observers;
107 pending_observers.swap(pending_begin_frame_observers_); 143 pending_observers.swap(pending_begin_frame_observers_);
108 for (BeginFrameObserver* obs : pending_observers) 144 for (BeginFrameObserver* obs : pending_observers) {
109 obs->OnBeginFrame(args); 145 obs->OnBeginFrame(args);
146 }
110 } 147 }
111 148
112 // DelayBasedBeginFrameSource --------------------------------------------- 149 // DelayBasedBeginFrameSource ---------------------------------------------
113 DelayBasedBeginFrameSource::DelayBasedBeginFrameSource( 150 DelayBasedBeginFrameSource::DelayBasedBeginFrameSource(
114 std::unique_ptr<DelayBasedTimeSource> time_source) 151 std::unique_ptr<DelayBasedTimeSource> time_source)
115 : time_source_(std::move(time_source)) { 152 : time_source_(std::move(time_source)), current_sequence_number_(1) {
116 time_source_->SetClient(this); 153 time_source_->SetClient(this);
117 } 154 }
118 155
119 DelayBasedBeginFrameSource::~DelayBasedBeginFrameSource() = default; 156 DelayBasedBeginFrameSource::~DelayBasedBeginFrameSource() = default;
120 157
121 void DelayBasedBeginFrameSource::OnUpdateVSyncParameters( 158 void DelayBasedBeginFrameSource::OnUpdateVSyncParameters(
122 base::TimeTicks timebase, 159 base::TimeTicks timebase,
123 base::TimeDelta interval) { 160 base::TimeDelta interval) {
124 if (!authoritative_interval_.is_zero()) { 161 if (!authoritative_interval_.is_zero()) {
125 interval = authoritative_interval_; 162 interval = authoritative_interval_;
126 } else if (interval.is_zero()) { 163 } else if (interval.is_zero()) {
127 // TODO(brianderson): We should not be receiving 0 intervals. 164 // TODO(brianderson): We should not be receiving 0 intervals.
128 interval = BeginFrameArgs::DefaultInterval(); 165 interval = BeginFrameArgs::DefaultInterval();
129 } 166 }
130 167
131 last_timebase_ = timebase; 168 last_timebase_ = timebase;
132 time_source_->SetTimebaseAndInterval(timebase, interval); 169 time_source_->SetTimebaseAndInterval(timebase, interval);
133 } 170 }
134 171
135 void DelayBasedBeginFrameSource::SetAuthoritativeVSyncInterval( 172 void DelayBasedBeginFrameSource::SetAuthoritativeVSyncInterval(
136 base::TimeDelta interval) { 173 base::TimeDelta interval) {
137 authoritative_interval_ = interval; 174 authoritative_interval_ = interval;
138 OnUpdateVSyncParameters(last_timebase_, interval); 175 OnUpdateVSyncParameters(last_timebase_, interval);
139 } 176 }
140 177
141 BeginFrameArgs DelayBasedBeginFrameSource::CreateBeginFrameArgs( 178 BeginFrameArgs DelayBasedBeginFrameSource::CreateBeginFrameArgs(
179 uint64_t sequence_number,
142 base::TimeTicks frame_time, 180 base::TimeTicks frame_time,
143 BeginFrameArgs::BeginFrameArgsType type) { 181 BeginFrameArgs::BeginFrameArgsType type) {
144 return BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time, 182 return BeginFrameArgs::Create(
145 time_source_->NextTickTime(), 183 BEGINFRAME_FROM_HERE, source_id(), sequence_number, frame_time,
146 time_source_->Interval(), type); 184 time_source_->NextTickTime(), time_source_->Interval(), type);
147 } 185 }
148 186
149 void DelayBasedBeginFrameSource::AddObserver(BeginFrameObserver* obs) { 187 void DelayBasedBeginFrameSource::AddObserver(BeginFrameObserver* obs) {
150 DCHECK(obs); 188 DCHECK(obs);
151 DCHECK(observers_.find(obs) == observers_.end()); 189 DCHECK(observers_.find(obs) == observers_.end());
152 190
153 observers_.insert(obs); 191 observers_.insert(obs);
154 obs->OnBeginFrameSourcePausedChanged(false); 192 obs->OnBeginFrameSourcePausedChanged(false);
155 time_source_->SetActive(true); 193 time_source_->SetActive(true);
194 base::TimeTicks frame_time =
195 time_source_->NextTickTime() - time_source_->Interval();
196 if (current_begin_frame_time_ != frame_time) {
197 // Increment the sequence number if we are producing a frame that is
198 // different from the latest one we sent out.
199 current_sequence_number_++;
200 current_begin_frame_time_ = frame_time;
201 }
156 BeginFrameArgs args = CreateBeginFrameArgs( 202 BeginFrameArgs args = CreateBeginFrameArgs(
157 time_source_->NextTickTime() - time_source_->Interval(), 203 current_sequence_number_, frame_time, BeginFrameArgs::MISSED);
158 BeginFrameArgs::MISSED);
159 BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs(); 204 BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs();
160 if (!last_args.IsValid() || 205 if (!last_args.IsValid() ||
161 (args.frame_time > 206 (args.frame_time >
162 last_args.frame_time + args.interval / kDoubleTickDivisor)) { 207 last_args.frame_time + args.interval / kDoubleTickDivisor)) {
163 obs->OnBeginFrame(args); 208 obs->OnBeginFrame(args);
164 } 209 }
165 } 210 }
166 211
167 void DelayBasedBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) { 212 void DelayBasedBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) {
168 DCHECK(obs); 213 DCHECK(obs);
169 DCHECK(observers_.find(obs) != observers_.end()); 214 DCHECK(observers_.find(obs) != observers_.end());
170 215
171 observers_.erase(obs); 216 observers_.erase(obs);
172 if (observers_.empty()) 217 if (observers_.empty())
173 time_source_->SetActive(false); 218 time_source_->SetActive(false);
174 } 219 }
175 220
176 bool DelayBasedBeginFrameSource::IsThrottled() const { 221 bool DelayBasedBeginFrameSource::IsThrottled() const {
177 return true; 222 return true;
178 } 223 }
179 224
180 void DelayBasedBeginFrameSource::OnTimerTick() { 225 void DelayBasedBeginFrameSource::OnTimerTick() {
181 BeginFrameArgs args = CreateBeginFrameArgs(time_source_->LastTickTime(), 226 BeginFrameArgs args = CreateBeginFrameArgs(++current_sequence_number_,
227 time_source_->LastTickTime(),
182 BeginFrameArgs::NORMAL); 228 BeginFrameArgs::NORMAL);
229 current_begin_frame_time_ = args.frame_time;
183 std::unordered_set<BeginFrameObserver*> observers(observers_); 230 std::unordered_set<BeginFrameObserver*> observers(observers_);
184 for (auto* obs : observers) { 231 for (auto* obs : observers) {
185 BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs(); 232 BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs();
186 if (!last_args.IsValid() || 233 if (!last_args.IsValid() ||
187 (args.frame_time > 234 (args.frame_time >
188 last_args.frame_time + args.interval / kDoubleTickDivisor)) 235 last_args.frame_time + args.interval / kDoubleTickDivisor))
189 obs->OnBeginFrame(args); 236 obs->OnBeginFrame(args);
190 } 237 }
191 } 238 }
192 239
240 // BeginFrameObserverAckTracker -------------------------------------------
241 BeginFrameObserverAckTracker::BeginFrameObserverAckTracker()
242 : current_source_id_(0),
243 current_sequence_number_(1),
244 observers_had_updates_(false) {}
245
246 BeginFrameObserverAckTracker::~BeginFrameObserverAckTracker() {}
247
248 void BeginFrameObserverAckTracker::OnBeginFrame(const BeginFrameArgs& args) {
249 if (current_source_id_ != args.source_id)
250 SourceChanged(args);
251
252 DCHECK_GE(args.sequence_number, current_sequence_number_);
253 // Reset for new BeginFrame.
254 current_sequence_number_ = args.sequence_number;
255 finished_observers_.clear();
256 observers_had_updates_ = false;
257 }
258
259 void BeginFrameObserverAckTracker::OnObserverBeginFrame(
260 BeginFrameObserver* obs,
261 const BeginFrameArgs& args) {
262 if (current_source_id_ != args.source_id)
263 SourceChanged(args);
264
265 DCHECK_EQ(args.sequence_number, current_sequence_number_);
266 // Observer may choose not to use the BeginFrame.
267 if (obs->LastUsedBeginFrameArgs().sequence_number != current_sequence_number_)
268 finished_observers_.insert(obs);
269 }
270
271 void BeginFrameObserverAckTracker::SourceChanged(const BeginFrameArgs& args) {
272 current_source_id_ = args.source_id;
273 current_sequence_number_ = args.sequence_number;
274
275 // We have no choice but to consider everyone up to date up to the last frame.
276 for (auto& entry : oldest_incorporated_frames_) {
277 entry.second = current_sequence_number_ - 1;
278 }
279 }
280
281 void BeginFrameObserverAckTracker::OnObserverFinishedFrame(
282 BeginFrameObserver* obs,
283 const BeginFrameAck& ack) {
284 if (ack.source_id != current_source_id_)
285 return;
286
287 DCHECK_LE(ack.sequence_number, current_sequence_number_);
288 // Only consider acks for the current frame.
289 if (ack.sequence_number != current_sequence_number_)
290 return;
291
292 finished_observers_.insert(obs);
293 observers_had_updates_ |= ack.has_updates;
294
295 // We max() with the current value in |oldest_incorporated_frames_| to handle
296 // situations where an observer just started observing (again) and may
297 // acknowledge with an ancient oldest_incorporated_frame.
298 oldest_incorporated_frames_[obs] =
299 std::max(ack.oldest_incorporated_frame, oldest_incorporated_frames_[obs]);
300 }
301
302 void BeginFrameObserverAckTracker::OnObserverAdded(BeginFrameObserver* obs) {
303 observers_.insert(obs);
304
305 // Since the observer didn't want BeginFrames before, we consider it "fresh"
306 // up to the last BeginFrame.
307 oldest_incorporated_frames_[obs] = current_sequence_number_ - 1;
308 }
309
310 void BeginFrameObserverAckTracker::OnObserverRemoved(BeginFrameObserver* obs) {
311 observers_.erase(obs);
312 finished_observers_.erase(obs);
313 oldest_incorporated_frames_.erase(obs);
314 }
315
316 bool BeginFrameObserverAckTracker::AllObserversFinishedFrame() const {
317 return base::STLIncludes(finished_observers_, observers_);
318 }
319
320 bool BeginFrameObserverAckTracker::AnyObserversHadUpdates() const {
321 return observers_had_updates_;
322 }
323
324 uint64_t BeginFrameObserverAckTracker::OldestIncorporatedFrame() const {
325 uint64_t oldest_incorporated_frame = current_sequence_number_;
326 for (const auto& entry : oldest_incorporated_frames_) {
327 oldest_incorporated_frame =
328 std::min(oldest_incorporated_frame, entry.second);
329 }
330 return oldest_incorporated_frame;
331 }
332
333 // ExternalBeginFrameSource -----------------------------------------------
193 ExternalBeginFrameSource::ExternalBeginFrameSource( 334 ExternalBeginFrameSource::ExternalBeginFrameSource(
194 ExternalBeginFrameSourceClient* client) 335 ExternalBeginFrameSourceClient* client)
195 : client_(client) { 336 : client_(client) {
196 DCHECK(client_); 337 DCHECK(client_);
197 } 338 }
198 339
199 ExternalBeginFrameSource::~ExternalBeginFrameSource() = default; 340 ExternalBeginFrameSource::~ExternalBeginFrameSource() = default;
200 341
201 void ExternalBeginFrameSource::AddObserver(BeginFrameObserver* obs) { 342 void ExternalBeginFrameSource::AddObserver(BeginFrameObserver* obs) {
202 DCHECK(obs); 343 DCHECK(obs);
203 DCHECK(observers_.find(obs) == observers_.end()); 344 DCHECK(observers_.find(obs) == observers_.end());
204 345
205 bool observers_was_empty = observers_.empty(); 346 bool observers_was_empty = observers_.empty();
206 observers_.insert(obs); 347 observers_.insert(obs);
348 ack_tracker_.OnObserverAdded(obs);
207 obs->OnBeginFrameSourcePausedChanged(paused_); 349 obs->OnBeginFrameSourcePausedChanged(paused_);
208 if (observers_was_empty) 350 if (observers_was_empty)
209 client_->OnNeedsBeginFrames(true); 351 client_->OnNeedsBeginFrames(true);
210 352
211 // Send a MISSED begin frame if necessary. 353 // Send a MISSED begin frame if necessary.
212 if (missed_begin_frame_args_.IsValid()) { 354 if (missed_begin_frame_args_.IsValid()) {
213 BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs(); 355 BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs();
214 if (!last_args.IsValid() || 356 if (!last_args.IsValid() ||
215 (missed_begin_frame_args_.frame_time > last_args.frame_time)) { 357 (missed_begin_frame_args_.source_id != last_args.source_id) ||
358 (missed_begin_frame_args_.sequence_number >
359 last_args.sequence_number)) {
216 obs->OnBeginFrame(missed_begin_frame_args_); 360 obs->OnBeginFrame(missed_begin_frame_args_);
361 ack_tracker_.OnObserverBeginFrame(obs, missed_begin_frame_args_);
217 } 362 }
218 } 363 }
219 } 364 }
220 365
221 void ExternalBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) { 366 void ExternalBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) {
222 DCHECK(obs); 367 DCHECK(obs);
223 DCHECK(observers_.find(obs) != observers_.end()); 368 DCHECK(observers_.find(obs) != observers_.end());
224 369
225 observers_.erase(obs); 370 observers_.erase(obs);
371 ack_tracker_.OnObserverRemoved(obs);
372 MaybeFinishFrame();
226 if (observers_.empty()) { 373 if (observers_.empty()) {
227 missed_begin_frame_args_ = BeginFrameArgs(); 374 missed_begin_frame_args_ = BeginFrameArgs();
228 client_->OnNeedsBeginFrames(false); 375 client_->OnNeedsBeginFrames(false);
229 } 376 }
230 } 377 }
231 378
379 void ExternalBeginFrameSource::DidFinishFrame(BeginFrameObserver* obs,
380 const BeginFrameAck& ack) {
381 ack_tracker_.OnObserverFinishedFrame(obs, ack);
382 MaybeFinishFrame();
383 }
384
232 bool ExternalBeginFrameSource::IsThrottled() const { 385 bool ExternalBeginFrameSource::IsThrottled() const {
233 return true; 386 return true;
234 } 387 }
235 388
236 void ExternalBeginFrameSource::OnSetBeginFrameSourcePaused(bool paused) { 389 void ExternalBeginFrameSource::OnSetBeginFrameSourcePaused(bool paused) {
237 if (paused_ == paused) 390 if (paused_ == paused)
238 return; 391 return;
239 paused_ = paused; 392 paused_ = paused;
240 std::unordered_set<BeginFrameObserver*> observers(observers_); 393 std::unordered_set<BeginFrameObserver*> observers(observers_);
241 for (auto* obs : observers) 394 for (auto* obs : observers)
242 obs->OnBeginFrameSourcePausedChanged(paused_); 395 obs->OnBeginFrameSourcePausedChanged(paused_);
243 } 396 }
244 397
245 void ExternalBeginFrameSource::OnBeginFrame(const BeginFrameArgs& args) { 398 void ExternalBeginFrameSource::OnBeginFrame(const BeginFrameArgs& args) {
399 if (frame_active_)
400 FinishFrame();
401
402 frame_active_ = true;
246 missed_begin_frame_args_ = args; 403 missed_begin_frame_args_ = args;
247 missed_begin_frame_args_.type = BeginFrameArgs::MISSED; 404 missed_begin_frame_args_.type = BeginFrameArgs::MISSED;
405 ack_tracker_.OnBeginFrame(args);
248 std::unordered_set<BeginFrameObserver*> observers(observers_); 406 std::unordered_set<BeginFrameObserver*> observers(observers_);
249 for (auto* obs : observers) 407 for (auto* obs : observers) {
250 obs->OnBeginFrame(args); 408 obs->OnBeginFrame(args);
409 ack_tracker_.OnObserverBeginFrame(obs, args);
410 }
411 MaybeFinishFrame();
412 }
413
414 void ExternalBeginFrameSource::MaybeFinishFrame() {
415 if (!frame_active_ || !ack_tracker_.AllObserversFinishedFrame())
416 return;
417 FinishFrame();
418 }
419
420 void ExternalBeginFrameSource::FinishFrame() {
421 frame_active_ = false;
422
423 BeginFrameAck ack(missed_begin_frame_args_.source_id,
424 missed_begin_frame_args_.sequence_number,
425 ack_tracker_.OldestIncorporatedFrame(), 0,
426 ack_tracker_.AnyObserversHadUpdates());
427 client_->OnDidFinishFrame(ack);
428 }
429
430 // DelegatingBeginFrameSource ---------------------------------------------
431 DelegatingBeginFrameSource::DelegatingBeginFrameSource(
432 BeginFrameSource* delegate)
433 : delegate_(delegate) {
434 DCHECK(delegate_);
435 }
436
437 void DelegatingBeginFrameSource::DidFinishFrame(BeginFrameObserver* obs,
438 const BeginFrameAck& ack) {
439 delegate_->DidFinishFrame(obs, ack);
440 }
441
442 void DelegatingBeginFrameSource::AddObserver(BeginFrameObserver* obs) {
443 delegate_->AddObserver(obs);
444 }
445
446 void DelegatingBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) {
447 delegate_->RemoveObserver(obs);
448 }
449
450 bool DelegatingBeginFrameSource::IsThrottled() const {
451 return delegate_->IsThrottled();
452 }
453
454 uint64_t DelegatingBeginFrameSource::source_id() const {
455 return delegate_->source_id();
251 } 456 }
252 457
253 } // namespace cc 458 } // namespace cc
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698