cc: Introduce BeginFrame sequence numbers and acknowledgements.

cc/surfaces/display_begin_frame_source.cc

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 needing frames?

[Eric Seckler, 2016/12/06 17:34:00]

You're right. Should now be covered in UpdateObservingBeginFrames().

+}
+
+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 SetClientNeedsBeginFrames?

[Eric Seckler, 2016/12/06 17:34:00]

Extracted common bits into UpdateObservingBeginFrames() / GetMissedArgs().

+    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