Index: cc/surfaces/display_begin_frame_source.cc |
diff --git a/cc/surfaces/display_begin_frame_source.cc b/cc/surfaces/display_begin_frame_source.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..5cb9b9f25b19c78db08d1e5296bac2f001c29535 |
--- /dev/null |
+++ b/cc/surfaces/display_begin_frame_source.cc |
@@ -0,0 +1,175 @@ |
+// Copyright 2016 The Chromium Authors. All rights reserved. |
+// Use of this source code is governed by a BSD-style license that can be |
+// found in the LICENSE file. |
+ |
+#include "cc/surfaces/display_begin_frame_source.h" |
+ |
+#include <algorithm> |
+ |
+namespace cc { |
+ |
+DisplayBeginFrameSource::DisplayBeginFrameSource( |
+ std::unique_ptr<BeginFrameSource> target_source) |
+ : target_source_(std::move(target_source)), |
+ observing_begin_frames_(false), |
+ frame_active_(false), |
+ current_source_id_(0), |
+ oldest_incorporated_frame_(0), |
+ client_(nullptr), |
+ client_needs_begin_frames_(false) {} |
+ |
+DisplayBeginFrameSource::~DisplayBeginFrameSource() { |
+ if (target_source_ && observing_begin_frames_) |
+ target_source_->RemoveObserver(this); |
+} |
+ |
+void DisplayBeginFrameSource::SetClientNeedsBeginFrames( |
+ bool needs_begin_frames) { |
+ DCHECK(client_); |
+ bool did_need_begin_frames = client_needs_begin_frames_; |
+ client_needs_begin_frames_ = needs_begin_frames; |
+ |
+ if (client_needs_begin_frames_ && !did_need_begin_frames) { |
+ if (!observing_begin_frames_) { |
+ // We need to start observing, a missed BeginFrame will be triggered by |
+ // the target source. |
+ observing_begin_frames_ = true; |
+ target_source_->AddObserver(this); |
+ } else if (current_begin_frame_args_.IsValid()) { |
+ // We were already observing, but the client may have missed the last |
+ // BeginFrame. |
+ const BeginFrameArgs& last_args = client_->LastUsedBeginFrameArgs(); |
+ if (!last_args.IsValid() || (last_args.sequence_number < |
+ current_begin_frame_args_.sequence_number)) { |
+ BeginFrameArgs missed_args = current_begin_frame_args_; |
+ missed_args.type = BeginFrameArgs::MISSED; |
+ client_->OnBeginFrame(missed_args); |
+ } |
+ } |
+ } |
Sami
2016/12/06 12:41:07
Are we missing the case where the client stops nee
Eric Seckler
2016/12/06 17:34:00
You're right. Should now be covered in UpdateObser
|
+} |
+ |
+void DisplayBeginFrameSource::FinishFrame(bool had_updates, |
+ bool has_pending_updates) { |
+ if (!frame_active_) |
Sami
2016/12/06 12:41:07
Is someone calling this at a bad time?
Eric Seckler
2016/12/06 17:34:00
Shouldn't :) Changed to a DCHECK.
|
+ return; |
+ |
+ frame_active_ = false; |
+ |
+ // Only update the oldest_incorporated_frame if there are no further pending |
+ // updates (i.e. the Display didn't have to draw or drew successfully). |
+ if (!has_pending_updates) |
+ oldest_incorporated_frame_ = ack_tracker_.OldestIncorporatedFrame(); |
+ |
+ BeginFrameAck ack(current_begin_frame_args_.source_id, |
+ current_begin_frame_args_.sequence_number, had_updates, |
+ oldest_incorporated_frame_, 0); |
+ if (target_source_) |
+ target_source_->DidFinishFrame(this, ack); |
+} |
+ |
+bool DisplayBeginFrameSource::ObserversFinishedFrame() { |
+ return ack_tracker_.ObserversFinishedFrame(); |
+} |
+ |
+void DisplayBeginFrameSource::SwapTargetSource( |
+ std::unique_ptr<BeginFrameSource>* begin_frame_source) { |
+ if (target_source_ && observing_begin_frames_) |
+ target_source_->RemoveObserver(this); |
+ |
+ target_source_.swap(*begin_frame_source); |
+ |
+ if (target_source_ && observing_begin_frames_) |
+ target_source_->AddObserver(this); |
+} |
+ |
+void DisplayBeginFrameSource::DidFinishFrame(BeginFrameObserver* obs, |
+ const BeginFrameAck& ack) { |
+ ack_tracker_.OnObserverFinishedFrame(obs, ack); |
+ ObserverStatusChanged(); |
+} |
+ |
+void DisplayBeginFrameSource::AddObserver(BeginFrameObserver* obs) { |
+ observers_.insert(obs); |
+ ack_tracker_.OnObserverAdded(obs); |
+ |
+ if (!observing_begin_frames_) { |
Sami
2016/12/06 12:41:07
Maybe fold this together with the logic in SetClie
Eric Seckler
2016/12/06 17:34:00
Extracted common bits into UpdateObservingBeginFra
|
+ observing_begin_frames_ = true; |
+ if (target_source_) |
+ target_source_->AddObserver(this); |
+ } else if (current_begin_frame_args_.IsValid()) { |
+ // We were already observing, but the observer may have missed the last |
+ // BeginFrame. |
+ const BeginFrameArgs& last_args = obs->LastUsedBeginFrameArgs(); |
+ if (!last_args.IsValid() || (last_args.sequence_number < |
+ current_begin_frame_args_.sequence_number)) { |
+ BeginFrameArgs missed_args = current_begin_frame_args_; |
+ missed_args.type = BeginFrameArgs::MISSED; |
+ obs->OnBeginFrame(missed_args); |
+ ack_tracker_.OnObserverBeginFrame(obs, missed_args); |
+ } |
+ } |
+ |
+ ObserverStatusChanged(); |
+} |
+ |
+void DisplayBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) { |
+ observers_.erase(obs); |
+ ack_tracker_.OnObserverRemoved(obs); |
+ |
+ if (observers_.empty() && !client_needs_begin_frames_) { |
+ DCHECK(observing_begin_frames_); |
+ observing_begin_frames_ = false; |
+ if (target_source_) |
+ target_source_->RemoveObserver(this); |
+ } |
+ |
+ ObserverStatusChanged(); |
+} |
+ |
+bool DisplayBeginFrameSource::IsThrottled() const { |
+ if (target_source_) |
+ return target_source_->IsThrottled(); |
+ return true; |
+} |
+ |
+void DisplayBeginFrameSource::OnBeginFrame(const BeginFrameArgs& args) { |
+ if (client_ && client_needs_begin_frames_) |
+ client_->OnBeginFrame(args); |
+ |
+ // Reset for the new frame. |
+ frame_active_ = true; |
+ ack_tracker_.OnBeginFrame(args); |
+ |
+ // BeginFrameObserverAckTracker will have updated the oldest incorporated |
+ // frame if the target source changes. |
+ if (args.source_id != current_source_id_) |
+ oldest_incorporated_frame_ = ack_tracker_.OldestIncorporatedFrame(); |
+ |
+ current_begin_frame_args_ = args; |
+ |
+ // Observers may remove themselves during OnBeginFrame(), so use a copy. |
+ std::set<BeginFrameObserver*> observers = observers_; |
+ for (BeginFrameObserver* obs : observers) { |
+ obs->OnBeginFrame(args); |
+ ack_tracker_.OnObserverBeginFrame(obs, args); |
+ } |
+ |
+ ObserverStatusChanged(); |
+} |
+ |
+const BeginFrameArgs& DisplayBeginFrameSource::LastUsedBeginFrameArgs() const { |
+ return current_begin_frame_args_; |
+} |
+ |
+void DisplayBeginFrameSource::OnBeginFrameSourcePausedChanged(bool paused) { |
+ // BeginFrameSources used as target sources do not make use of this feature. |
+ DCHECK(!paused); |
+} |
+ |
+void DisplayBeginFrameSource::ObserverStatusChanged() { |
+ if (client_) |
+ client_->BeginFrameObserverStatusChanged(); |
+} |
+ |
+} // namespace cc |