Adds BeginFrameControl via DevTools.

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..de11441d3c03dd01c3a79b3a1b41089cad26ae20
--- /dev/null
+++ b/cc/surfaces/display_begin_frame_source.cc
@@ -0,0 +1,135 @@
+// 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 "base/stl_util.h"
+
+namespace cc {
+
+DisplayBeginFrameSource::DisplayBeginFrameSource(
+    std::unique_ptr<BeginFrameSource> target_source)
+    : target_source_(std::move(target_source)),
+      observing_begin_frames_(false),
+      frame_active_(false),
+      client_(nullptr) {}
+
+DisplayBeginFrameSource::~DisplayBeginFrameSource() {
+  if (target_source_ && observing_begin_frames_)
+    target_source_->RemoveObserver(this);
+}
+
+bool DisplayBeginFrameSource::AllObserversFinishedFrame() {
+  if (!frame_active_)
+    return true;
+  return base::STLIncludes(finished_observers_, observers_);
+}
+
+void DisplayBeginFrameSource::SwapTargetSource(
+    std::unique_ptr<BeginFrameSource>* begin_frame_source) {
+  if (client_)
+    client_->BeginFrameSourceSwapping(begin_frame_source->get());
+
+  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,
+                                             size_t remaining_frames) {
+  if (!target_source_)
+    return;
+
+  finished_observers_.insert(obs);
+  ObserverStatusChanged();
+}
+
+void DisplayBeginFrameSource::AddObserver(BeginFrameObserver* obs) {
+  if (!target_source_)
+    return;
+
+  observers_.insert(obs);
+
+  if (!observing_begin_frames_) {
+    observing_begin_frames_ = true;
+    target_source_->AddObserver(this);
+  }
+
+  ObserverStatusChanged();
+}
+
+void DisplayBeginFrameSource::RemoveObserver(BeginFrameObserver* obs) {
+  if (!target_source_)
+    return;
+
+  observers_.erase(obs);
+  finished_observers_.erase(obs);
+
+  if (observers_.empty()) {
+    DCHECK(observing_begin_frames_);
+    observing_begin_frames_ = false;
+    target_source_->RemoveObserver(this);
+  }
+
+  ObserverStatusChanged();
+}
+
+bool DisplayBeginFrameSource::IsThrottled() const {
+  if (target_source_)
+    return target_source_->IsThrottled();
+  return false;
+}
+
+void DisplayBeginFrameSource::OnBeginFrame(const BeginFrameArgs& args) {
+  // Reset finished observers for the next frame.
+  // TODO(eseckler): Need sequence numbers here to ensure that we don't count
+  // DidFinishFrame() from observers that abort the previous BeginFrame when
+  // this OnBeginFrame() reaches them.
+  finished_observers_.clear();
+  frame_active_ = true;
+
+  last_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);
+    // TODO(eseckler): Need sequence numbers in args to distinguish emulated
+    // args with equal timestamps.
+    if (obs->LastUsedBeginFrameArgs().frame_time != args.frame_time)
+      finished_observers_.insert(obs);
+  }
+
+  ObserverStatusChanged();
+}
+
+const BeginFrameArgs& DisplayBeginFrameSource::LastUsedBeginFrameArgs() const {
+  return last_begin_frame_args_;
+}
+
+void DisplayBeginFrameSource::OnBeginFrameSourcePausedChanged(bool paused) {
+  // BeginFrameSources used as target sources do not make use of this feature.
+  if (paused)
+    NOTIMPLEMENTED();
+}
+
+void DisplayBeginFrameSource::ObserverStatusChanged() {
+  MaybeFinishFrame();
+  if (client_)
+    client_->ObserverStatusChanged();
+}
+
+void DisplayBeginFrameSource::MaybeFinishFrame() {
+  if (!frame_active_ || !AllObserversFinishedFrame())
+    return;
+
+  frame_active_ = false;
+  target_source_->DidFinishFrame(this, 0);
+}
+
+}  // namespace cc