Use LatencyInfoSwapPromise to track LatencyInfo through compositor

cc/base/swap_promise.cc

Index: cc/base/swap_promise.cc
diff --git a/cc/base/swap_promise.cc b/cc/base/swap_promise.cc
new file mode 100644
index 0000000000000000000000000000000000000000..86c3563bafb12612619eb0270004b0f4f3507409
--- /dev/null
+++ b/cc/base/swap_promise.cc
@@ -0,0 +1,63 @@
+// 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.
+
+#include "base/logging.h"
+#include "cc/base/swap_promise.h"
+
+namespace {
+  ui::LatencyComponentType DidNotSwapReasonToLatencyComponentType(
+      cc::SwapPromise::DidNotSwapReason reason) {
+    switch (reason) {
+      case cc::SwapPromise::DID_NOT_SWAP_UNKNOWN:
+      case cc::SwapPromise::SWAP_FAILS:
+        return ui::INPUT_EVENT_LATENCY_TERMINATED_SWAP_FAILED_COMPONENT;
+        break;
+      case cc::SwapPromise::COMMIT_FAILS:
+        return ui::INPUT_EVENT_LATENCY_TERMINATED_COMMIT_FAILED_COMPONENT;
+        break;
+      case cc::SwapPromise::SWAP_PROMISE_LIST_OVERFLOW:
+        return ui::LATENCY_INFO_LIST_TERMINATED_OVERFLOW_COMPONENT;
+        break;
+      default:
+        DLOG(WARNING) << "Unhandled DidNotSwapReason.\n";
+        break;
+    }
+    return ui::INPUT_EVENT_LATENCY_TERMINATED_SWAP_FAILED_COMPONENT;
+  }
+}  // namespace
+
+namespace cc {
+
+SwapPromise::SwapPromise(SwapPromiseType type) : type_(type) {
+}
+
+SwapPromise::~SwapPromise() {}
+
+SwapPromise::SwapPromiseType SwapPromise::type() {
+  return type_;
+}
+
+LatencyInfoSwapPromise::LatencyInfoSwapPromise(const ui::LatencyInfo& latency)
+    : SwapPromise(SWAP_PROMISE_LATENCY_INFO),
+      latency_(latency) {
+}
+
+LatencyInfoSwapPromise::~LatencyInfoSwapPromise() {
+}
+
+void LatencyInfoSwapPromise::DidSwap() {
+  CHECK(!latency_.terminated);
+}
+
+void LatencyInfoSwapPromise::DidNotSwap(DidNotSwapReason reason) {
+  latency_.AddLatencyNumber(DidNotSwapReasonToLatencyComponentType(reason),

[danakj, 2013/11/26 19:17:53]

these methods can be called on either thread. you need to use a base::Lock
around any access to latency_.

[Yufeng Shen (Slow to review), 2013/11/27 20:05:33]

But one SwapPromise can only live either on impl or main thread, so
even DidNotSwap can happen concurrently on impl/main threads, it won't operate
on the same latency_ (it's a local copy of the LatencyInfoSwapPromise) right ?

+                            0, 0);
+  CHECK(latency_.terminated);
+}
+
+const ui::LatencyInfo& LatencyInfoSwapPromise::GetLatencyInfo() {
+  return latency_;
+}
+
+}  // namespace cc