Add SwapPromise support to LayerTreeHost and LayerTreeImpl

When a change to the compositor's state/invalidation/whatever happens, a                                                                                                                                
Swap Promise can be inserted into LayerTreeHost/LayerTreeImpl, to track                                                                                                                                 
whether the compositor's reply to the new state/invaliadtion/whatever is                                                                                                                                
completed in the compositor, i.e. the compositor knows it has been sent                                                                                                                                 
to its output or not.                                                                                                                                                                                   
                                                                                                                                                                                                         
If the new compositor state is sent to the output, SwapPromise::DidSwap()                                                                                                                               
will be called, and if the compositor fails to send its new state to the                                                                                                                                
output, e.g. commit fails on main thread, new frame data has no actual
damage so LayerTreeHostImpl::SwapBuffers() bails out early, then
Promise::DidNotSwap() will be called.

BUG=246034, 271583
TEST=unittests pass.

Review URL: https://codereview.chromium.org/60513007

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@237444 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 48 insertions, 0 deletions

diff --git a/cc/base/swap_promise.h b/cc/base/swap_promise.h
new file mode 100644
index 0000000..90bf6af
--- /dev/null
+++ b/cc/base/swap_promise.h
@@ -0,0 +1,48 @@
+// Copyright 2013 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.
+
+#ifndef CC_BASE_SWAP_PROMISE_H_
+#define CC_BASE_SWAP_PROMISE_H_
+
+namespace cc {
+
+const unsigned int kMaxQueuedSwapPromiseNumber = 100;
+
+// When a change to the compositor's state/invalidation/whatever happens, a
+// Swap Promise can be inserted into LayerTreeHost/LayerTreeImpl, to track
+// whether the compositor's reply to the new state/invaliadtion/whatever is
+// completed in the compositor, i.e. the compositor knows it has been sent
+// to its output or not.
+//
+// If the new compositor state is sent to the output, SwapPromise::DidSwap()
+// will be called, and if the compositor fails to send its new state to the
+// output, SwapPromise::DidNotSwap() will be called.
+//
+// Client wishes to use SwapPromise should have a subclass that defines
+// the behavior of DidSwap() and DidNotSwap(). Notice that the promise can
+// be broken at either main or impl thread, e.g. commit fails on main thread,
+// new frame data has no actual damage so LayerTreeHostImpl::SwapBuffers()
+// bails out early on impl thread, so don't assume that DidSwap() and
+// DidNotSwap() are called at a particular thread. It is better to let the
+// subclass carry thread-safe member data and operate on that member data in
+// DidSwap() and DidNotSwap().
+class SwapPromise {
+ public:
+  SwapPromise() {}
+  virtual ~SwapPromise() {}
+
+  enum DidNotSwapReason {
+    DID_NOT_SWAP_UNKNOWN,
+    SWAP_FAILS,
+    COMMIT_FAILS,
+    SWAP_PROMISE_LIST_OVERFLOW,
+  };
+
+  virtual void DidSwap() = 0;
+  virtual void DidNotSwap(DidNotSwapReason reason) = 0;
+};
+
+}  // namespace cc
+
+#endif  // CC_BASE_SWAP_PROMISE_H_