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_(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 |
OLD | NEW |