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

Unified Diff: cc/surfaces/display_begin_frame_source.cc

Issue 2527283003: cc: Introduce BeginFrame sequence numbers and acknowledgements.
Patch Set: . 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 side-by-side diff with in-line comments
Download patch
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

Powered by Google App Engine
This is Rietveld 408576698