OLD | NEW |
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_(BeginFrameArgs::kStartingFrameNumber), |
| 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); |
110 } | 146 } |
111 | 147 |
(...skipping 20 matching lines...) Expand all Loading... |
132 time_source_->SetTimebaseAndInterval(timebase, interval); | 168 time_source_->SetTimebaseAndInterval(timebase, interval); |
133 } | 169 } |
134 | 170 |
135 void DelayBasedBeginFrameSource::SetAuthoritativeVSyncInterval( | 171 void DelayBasedBeginFrameSource::SetAuthoritativeVSyncInterval( |
136 base::TimeDelta interval) { | 172 base::TimeDelta interval) { |
137 authoritative_interval_ = interval; | 173 authoritative_interval_ = interval; |
138 OnUpdateVSyncParameters(last_timebase_, interval); | 174 OnUpdateVSyncParameters(last_timebase_, interval); |
139 } | 175 } |
140 | 176 |
141 BeginFrameArgs DelayBasedBeginFrameSource::CreateBeginFrameArgs( | 177 BeginFrameArgs DelayBasedBeginFrameSource::CreateBeginFrameArgs( |
| 178 uint64_t sequence_number, |
142 base::TimeTicks frame_time, | 179 base::TimeTicks frame_time, |
143 BeginFrameArgs::BeginFrameArgsType type) { | 180 BeginFrameArgs::BeginFrameArgsType type) { |
144 return BeginFrameArgs::Create(BEGINFRAME_FROM_HERE, frame_time, | 181 return BeginFrameArgs::Create( |
145 time_source_->NextTickTime(), | 182 BEGINFRAME_FROM_HERE, source_id(), sequence_number, frame_time, |
146 time_source_->Interval(), type); | 183 time_source_->NextTickTime(), time_source_->Interval(), type); |
147 } | 184 } |
148 | 185 |
149 void DelayBasedBeginFrameSource::AddObserver(BeginFrameObserver* obs) { | 186 void DelayBasedBeginFrameSource::AddObserver(BeginFrameObserver* obs) { |
150 DCHECK(obs); | 187 DCHECK(obs); |
151 DCHECK(observers_.find(obs) == observers_.end()); | 188 DCHECK(observers_.find(obs) == observers_.end()); |
152 | 189 |
153 observers_.insert(obs); | 190 observers_.insert(obs); |
154 obs->OnBeginFrameSourcePausedChanged(false); | 191 obs->OnBeginFrameSourcePausedChanged(false); |
155 time_source_->SetActive(true); | 192 time_source_->SetActive(true); |
156 BeginFrameArgs args = CreateBeginFrameArgs( | 193 |
157 time_source_->NextTickTime() - time_source_->Interval(), | 194 // Check if |current_begin_frame_args_| are still valid. They may not be valid |
158 BeginFrameArgs::MISSED); | 195 // if OnTimerTick() has never run yet, the time source was inactive before |
| 196 // AddObserver() was called, or the interval changed. |
| 197 base::TimeTicks last_or_missed_tick_time = |
| 198 time_source_->NextTickTime() - time_source_->Interval(); |
| 199 if (current_begin_frame_args_.IsValid() && |
| 200 current_begin_frame_args_.frame_time == last_or_missed_tick_time && |
| 201 current_begin_frame_args_.interval == time_source_->Interval()) { |
| 202 // Ensure that the args have the right type. |
| 203 current_begin_frame_args_.type = BeginFrameArgs::MISSED; |
| 204 } else { |
| 205 // The args are invalid, we need to create new ones with the missed tick's |
| 206 // time and a new sequence number. |
| 207 current_begin_frame_args_ = |
| 208 CreateBeginFrameArgs(current_begin_frame_args_.sequence_number + 1, |
| 209 last_or_missed_tick_time, BeginFrameArgs::MISSED); |
| 210 } |
| 211 |
159 BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs(); | 212 BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs(); |
160 if (!last_args.IsValid() || | 213 if (!last_args.IsValid() || |
161 (args.frame_time > | 214 (current_begin_frame_args_.frame_time > |
162 last_args.frame_time + args.interval / kDoubleTickDivisor)) { | 215 last_args.frame_time + |
163 obs->OnBeginFrame(args); | 216 current_begin_frame_args_.interval / kDoubleTickDivisor)) { |
| 217 obs->OnBeginFrame(current_begin_frame_args_); |
164 } | 218 } |
165 } | 219 } |
166 | 220 |
167 void DelayBasedBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) { | 221 void DelayBasedBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) { |
168 DCHECK(obs); | 222 DCHECK(obs); |
169 DCHECK(observers_.find(obs) != observers_.end()); | 223 DCHECK(observers_.find(obs) != observers_.end()); |
170 | 224 |
171 observers_.erase(obs); | 225 observers_.erase(obs); |
172 if (observers_.empty()) | 226 if (observers_.empty()) |
173 time_source_->SetActive(false); | 227 time_source_->SetActive(false); |
174 } | 228 } |
175 | 229 |
176 bool DelayBasedBeginFrameSource::IsThrottled() const { | 230 bool DelayBasedBeginFrameSource::IsThrottled() const { |
177 return true; | 231 return true; |
178 } | 232 } |
179 | 233 |
180 void DelayBasedBeginFrameSource::OnTimerTick() { | 234 void DelayBasedBeginFrameSource::OnTimerTick() { |
181 BeginFrameArgs args = CreateBeginFrameArgs(time_source_->LastTickTime(), | 235 current_begin_frame_args_ = CreateBeginFrameArgs( |
182 BeginFrameArgs::NORMAL); | 236 current_begin_frame_args_.sequence_number + 1, |
| 237 time_source_->LastTickTime(), BeginFrameArgs::NORMAL); |
183 std::unordered_set<BeginFrameObserver*> observers(observers_); | 238 std::unordered_set<BeginFrameObserver*> observers(observers_); |
184 for (auto* obs : observers) { | 239 for (auto* obs : observers) { |
185 BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs(); | 240 BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs(); |
186 if (!last_args.IsValid() || | 241 if (!last_args.IsValid() || |
187 (args.frame_time > | 242 (current_begin_frame_args_.frame_time > |
188 last_args.frame_time + args.interval / kDoubleTickDivisor)) | 243 last_args.frame_time + |
189 obs->OnBeginFrame(args); | 244 current_begin_frame_args_.interval / kDoubleTickDivisor)) |
| 245 obs->OnBeginFrame(current_begin_frame_args_); |
190 } | 246 } |
191 } | 247 } |
192 | 248 |
| 249 // BeginFrameObserverAckTracker ------------------------------------------- |
| 250 BeginFrameObserverAckTracker::BeginFrameObserverAckTracker() |
| 251 : current_source_id_(0), |
| 252 current_sequence_number_(BeginFrameArgs::kStartingFrameNumber), |
| 253 observers_had_damage_(false) {} |
| 254 |
| 255 BeginFrameObserverAckTracker::~BeginFrameObserverAckTracker() {} |
| 256 |
| 257 void BeginFrameObserverAckTracker::OnBeginFrame(const BeginFrameArgs& args) { |
| 258 if (current_source_id_ != args.source_id) |
| 259 SourceChanged(args); |
| 260 |
| 261 DCHECK_GE(args.sequence_number, current_sequence_number_); |
| 262 // Reset for new BeginFrame. |
| 263 current_sequence_number_ = args.sequence_number; |
| 264 finished_observers_.clear(); |
| 265 observers_had_damage_ = false; |
| 266 } |
| 267 |
| 268 void BeginFrameObserverAckTracker::OnObserverBeginFrame( |
| 269 BeginFrameObserver* obs, |
| 270 const BeginFrameArgs& args) { |
| 271 if (current_source_id_ != args.source_id) |
| 272 SourceChanged(args); |
| 273 |
| 274 DCHECK_EQ(args.sequence_number, current_sequence_number_); |
| 275 // Observer may choose not to use the BeginFrame. |
| 276 if (obs->LastUsedBeginFrameArgs().sequence_number != current_sequence_number_) |
| 277 finished_observers_.insert(obs); |
| 278 } |
| 279 |
| 280 void BeginFrameObserverAckTracker::SourceChanged(const BeginFrameArgs& args) { |
| 281 current_source_id_ = args.source_id; |
| 282 current_sequence_number_ = args.sequence_number; |
| 283 |
| 284 // We have no choice but to consider everyone up to date up to the last frame. |
| 285 for (auto& entry : latest_confirmed_frames_) { |
| 286 DCHECK_LT(BeginFrameArgs::kInvalidFrameNumber, current_sequence_number_); |
| 287 entry.second = current_sequence_number_ - 1; |
| 288 } |
| 289 } |
| 290 |
| 291 void BeginFrameObserverAckTracker::OnObserverFinishedFrame( |
| 292 BeginFrameObserver* obs, |
| 293 const BeginFrameAck& ack) { |
| 294 if (ack.source_id != current_source_id_) |
| 295 return; |
| 296 |
| 297 DCHECK_LE(ack.sequence_number, current_sequence_number_); |
| 298 // Only consider acks for the current frame. |
| 299 if (ack.sequence_number != current_sequence_number_) |
| 300 return; |
| 301 |
| 302 finished_observers_.insert(obs); |
| 303 observers_had_damage_ |= ack.has_damage; |
| 304 |
| 305 // We max() with the current value in |latest_confirmed_frames_| to handle |
| 306 // situations where an observer just started observing (again) and may |
| 307 // acknowledge with an ancient latest_confirmed_frame. |
| 308 latest_confirmed_frames_[obs] = |
| 309 std::max(ack.latest_confirmed_frame, latest_confirmed_frames_[obs]); |
| 310 } |
| 311 |
| 312 void BeginFrameObserverAckTracker::OnObserverAdded(BeginFrameObserver* obs) { |
| 313 observers_.insert(obs); |
| 314 |
| 315 // Since the observer didn't want BeginFrames before, we consider it "fresh" |
| 316 // up to the last BeginFrame. |
| 317 DCHECK_LT(BeginFrameArgs::kInvalidFrameNumber, current_sequence_number_); |
| 318 latest_confirmed_frames_[obs] = current_sequence_number_ - 1; |
| 319 } |
| 320 |
| 321 void BeginFrameObserverAckTracker::OnObserverRemoved(BeginFrameObserver* obs) { |
| 322 observers_.erase(obs); |
| 323 finished_observers_.erase(obs); |
| 324 latest_confirmed_frames_.erase(obs); |
| 325 } |
| 326 |
| 327 bool BeginFrameObserverAckTracker::AllObserversFinishedFrame() const { |
| 328 return base::STLIncludes(finished_observers_, observers_); |
| 329 } |
| 330 |
| 331 bool BeginFrameObserverAckTracker::AnyObserversHadDamage() const { |
| 332 return observers_had_damage_; |
| 333 } |
| 334 |
| 335 uint64_t BeginFrameObserverAckTracker::LatestConfirmedFrame() const { |
| 336 uint64_t latest_confirmed_frame = current_sequence_number_; |
| 337 for (const auto& entry : latest_confirmed_frames_) { |
| 338 latest_confirmed_frame = std::min(latest_confirmed_frame, entry.second); |
| 339 } |
| 340 return latest_confirmed_frame; |
| 341 } |
| 342 |
| 343 // ExternalBeginFrameSource ----------------------------------------------- |
193 ExternalBeginFrameSource::ExternalBeginFrameSource( | 344 ExternalBeginFrameSource::ExternalBeginFrameSource( |
194 ExternalBeginFrameSourceClient* client) | 345 ExternalBeginFrameSourceClient* client) |
195 : client_(client) { | 346 : client_(client) { |
196 DCHECK(client_); | 347 DCHECK(client_); |
197 } | 348 } |
198 | 349 |
199 ExternalBeginFrameSource::~ExternalBeginFrameSource() = default; | 350 ExternalBeginFrameSource::~ExternalBeginFrameSource() = default; |
200 | 351 |
201 void ExternalBeginFrameSource::AddObserver(BeginFrameObserver* obs) { | 352 void ExternalBeginFrameSource::AddObserver(BeginFrameObserver* obs) { |
202 DCHECK(obs); | 353 DCHECK(obs); |
203 DCHECK(observers_.find(obs) == observers_.end()); | 354 DCHECK(observers_.find(obs) == observers_.end()); |
204 | 355 |
205 bool observers_was_empty = observers_.empty(); | 356 bool observers_was_empty = observers_.empty(); |
206 observers_.insert(obs); | 357 observers_.insert(obs); |
| 358 ack_tracker_.OnObserverAdded(obs); |
207 obs->OnBeginFrameSourcePausedChanged(paused_); | 359 obs->OnBeginFrameSourcePausedChanged(paused_); |
208 if (observers_was_empty) | 360 if (observers_was_empty) |
209 client_->OnNeedsBeginFrames(true); | 361 client_->OnNeedsBeginFrames(true); |
210 | 362 |
211 // Send a MISSED begin frame if necessary. | 363 // Send a MISSED begin frame if necessary. |
212 if (missed_begin_frame_args_.IsValid()) { | 364 if (missed_begin_frame_args_.IsValid()) { |
213 BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs(); | 365 BeginFrameArgs last_args = obs->LastUsedBeginFrameArgs(); |
214 if (!last_args.IsValid() || | 366 if (!last_args.IsValid() || |
215 (missed_begin_frame_args_.frame_time > last_args.frame_time)) { | 367 (missed_begin_frame_args_.source_id != last_args.source_id) || |
| 368 (missed_begin_frame_args_.sequence_number > |
| 369 last_args.sequence_number)) { |
216 obs->OnBeginFrame(missed_begin_frame_args_); | 370 obs->OnBeginFrame(missed_begin_frame_args_); |
| 371 ack_tracker_.OnObserverBeginFrame(obs, missed_begin_frame_args_); |
217 } | 372 } |
218 } | 373 } |
219 } | 374 } |
220 | 375 |
221 void ExternalBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) { | 376 void ExternalBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) { |
222 DCHECK(obs); | 377 DCHECK(obs); |
223 DCHECK(observers_.find(obs) != observers_.end()); | 378 DCHECK(observers_.find(obs) != observers_.end()); |
224 | 379 |
225 observers_.erase(obs); | 380 observers_.erase(obs); |
| 381 ack_tracker_.OnObserverRemoved(obs); |
| 382 MaybeFinishFrame(); |
226 if (observers_.empty()) { | 383 if (observers_.empty()) { |
227 missed_begin_frame_args_ = BeginFrameArgs(); | 384 missed_begin_frame_args_ = BeginFrameArgs(); |
228 client_->OnNeedsBeginFrames(false); | 385 client_->OnNeedsBeginFrames(false); |
229 } | 386 } |
230 } | 387 } |
231 | 388 |
| 389 void ExternalBeginFrameSource::DidFinishFrame(BeginFrameObserver* obs, |
| 390 const BeginFrameAck& ack) { |
| 391 ack_tracker_.OnObserverFinishedFrame(obs, ack); |
| 392 MaybeFinishFrame(); |
| 393 } |
| 394 |
232 bool ExternalBeginFrameSource::IsThrottled() const { | 395 bool ExternalBeginFrameSource::IsThrottled() const { |
233 return true; | 396 return true; |
234 } | 397 } |
235 | 398 |
236 void ExternalBeginFrameSource::OnSetBeginFrameSourcePaused(bool paused) { | 399 void ExternalBeginFrameSource::OnSetBeginFrameSourcePaused(bool paused) { |
237 if (paused_ == paused) | 400 if (paused_ == paused) |
238 return; | 401 return; |
239 paused_ = paused; | 402 paused_ = paused; |
240 std::unordered_set<BeginFrameObserver*> observers(observers_); | 403 std::unordered_set<BeginFrameObserver*> observers(observers_); |
241 for (auto* obs : observers) | 404 for (auto* obs : observers) |
242 obs->OnBeginFrameSourcePausedChanged(paused_); | 405 obs->OnBeginFrameSourcePausedChanged(paused_); |
243 } | 406 } |
244 | 407 |
245 void ExternalBeginFrameSource::OnBeginFrame(const BeginFrameArgs& args) { | 408 void ExternalBeginFrameSource::OnBeginFrame(const BeginFrameArgs& args) { |
| 409 if (frame_active_) |
| 410 FinishFrame(); |
| 411 |
| 412 frame_active_ = true; |
246 missed_begin_frame_args_ = args; | 413 missed_begin_frame_args_ = args; |
247 missed_begin_frame_args_.type = BeginFrameArgs::MISSED; | 414 missed_begin_frame_args_.type = BeginFrameArgs::MISSED; |
| 415 ack_tracker_.OnBeginFrame(args); |
248 std::unordered_set<BeginFrameObserver*> observers(observers_); | 416 std::unordered_set<BeginFrameObserver*> observers(observers_); |
249 for (auto* obs : observers) | 417 for (auto* obs : observers) { |
250 obs->OnBeginFrame(args); | 418 obs->OnBeginFrame(args); |
| 419 ack_tracker_.OnObserverBeginFrame(obs, args); |
| 420 } |
| 421 MaybeFinishFrame(); |
| 422 } |
| 423 |
| 424 void ExternalBeginFrameSource::MaybeFinishFrame() { |
| 425 if (!frame_active_ || !ack_tracker_.AllObserversFinishedFrame()) |
| 426 return; |
| 427 FinishFrame(); |
| 428 } |
| 429 |
| 430 void ExternalBeginFrameSource::FinishFrame() { |
| 431 frame_active_ = false; |
| 432 |
| 433 BeginFrameAck ack(missed_begin_frame_args_.source_id, |
| 434 missed_begin_frame_args_.sequence_number, |
| 435 ack_tracker_.LatestConfirmedFrame(), 0, |
| 436 ack_tracker_.AnyObserversHadDamage()); |
| 437 client_->OnDidFinishFrame(ack); |
| 438 } |
| 439 |
| 440 // DelegatingBeginFrameSource --------------------------------------------- |
| 441 DelegatingBeginFrameSource::DelegatingBeginFrameSource( |
| 442 BeginFrameSource* delegate) |
| 443 : delegate_(delegate) { |
| 444 DCHECK(delegate_); |
| 445 } |
| 446 |
| 447 void DelegatingBeginFrameSource::DidFinishFrame(BeginFrameObserver* obs, |
| 448 const BeginFrameAck& ack) { |
| 449 delegate_->DidFinishFrame(obs, ack); |
| 450 } |
| 451 |
| 452 void DelegatingBeginFrameSource::AddObserver(BeginFrameObserver* obs) { |
| 453 delegate_->AddObserver(obs); |
| 454 } |
| 455 |
| 456 void DelegatingBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) { |
| 457 delegate_->RemoveObserver(obs); |
| 458 } |
| 459 |
| 460 bool DelegatingBeginFrameSource::IsThrottled() const { |
| 461 return delegate_->IsThrottled(); |
251 } | 462 } |
252 | 463 |
253 } // namespace cc | 464 } // namespace cc |
OLD | NEW |