cc: Add SwapPromiseManager and SurfaceSequenceGenerator.

cc/trees/swap_promise_manager.cc

Index: cc/trees/swap_promise_manager.cc
diff --git a/cc/trees/swap_promise_manager.cc b/cc/trees/swap_promise_manager.cc
new file mode 100644
index 0000000000000000000000000000000000000000..eeca336266db4cacfa1d89197a6dc7bfcf2406cf
--- /dev/null
+++ b/cc/trees/swap_promise_manager.cc
@@ -0,0 +1,56 @@
+// 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/trees/swap_promise_manager.h"
+
+#include "cc/output/swap_promise.h"
+#include "cc/trees/swap_promise_monitor.h"
+
+namespace cc {
+
+SwapPromiseManager::SwapPromiseManager() {}
+
+SwapPromiseManager::~SwapPromiseManager() {
+  DCHECK(swap_promise_monitor_.empty());
+  BreakSwapPromises(SwapPromise::COMMIT_FAILS);
+}
+
+void SwapPromiseManager::QueueSwapPromise(
+    std::unique_ptr<SwapPromise> swap_promise) {
+  DCHECK(swap_promise);
+  swap_promise_list_.push_back(std::move(swap_promise));
+}
+
+void SwapPromiseManager::InsertSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
+  swap_promise_monitor_.insert(monitor);
+}
+
+void SwapPromiseManager::RemoveSwapPromiseMonitor(SwapPromiseMonitor* monitor) {
+  swap_promise_monitor_.erase(monitor);
+}
+
+void SwapPromiseManager::NotifySwapPromiseMonitorsOfSetNeedsCommit() {
+  std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
+  for (; it != swap_promise_monitor_.end(); it++)
+    (*it)->OnSetNeedsCommitOnMain();
+}
+
+void SwapPromiseManager::WillCommit() {
+  for (const auto& swap_promise : swap_promise_list_)
+    swap_promise->OnCommit();
+}
+
+std::vector<std::unique_ptr<SwapPromise>>
+SwapPromiseManager::TakeSwapPromises() {
+  return std::move(swap_promise_list_);

[vmpstr, 2016/09/09 20:45:45]

This leaves swap_promise_list_ in an unspecified state. Although this very
likely leaves the source vector empty (due to the complexity guarantee of
vector(vector&&)), it's not guaranteed in all cases...

I wonder if we should do something like

std::vector<std::unique_ptr<SwapPromise>> result;
result.swap(swap_promise_list_);
return result;

(this is just me being pedantic, so I can be convinced that this is fine)

[Khushal, 2016/09/09 21:09:34]

Thanks for pointing this out. It was quite subtle, sorry I missed it earlier.
Done.

+}
+
+void SwapPromiseManager::BreakSwapPromises(
+    SwapPromise::DidNotSwapReason reason) {
+  for (const auto& swap_promise : swap_promise_list_)
+    swap_promise->DidNotSwap(reason);
+  swap_promise_list_.clear();
+}
+
+}  // namespace cc