Implemented ScopedFakeTime, faking rtc::TimeNanos.

webrtc/base/faketime.h

Index: webrtc/base/faketime.h
diff --git a/webrtc/base/faketime.h b/webrtc/base/faketime.h
new file mode 100644
index 0000000000000000000000000000000000000000..a45a2d7a99db1ea24c804b77f229b5d2a9f0a8af
--- /dev/null
+++ b/webrtc/base/faketime.h
@@ -0,0 +1,50 @@
+/*
+ *  Copyright 2009 The WebRTC Project Authors. All rights reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef WEBRTC_BASE_FAKETIME_H_
+#define WEBRTC_BASE_FAKETIME_H_
+
+#include "webrtc/base/checks.h"
+#include "webrtc/base/timeutils.h"
+
+namespace rtc {
+namespace test {
+class FakeTime : public FakeTimeInterface {
+ public:
+  explicit FakeTime(uint64_t start_time) : current_time_ns_(start_time) {}
+  uint64_t TimeNanos() override {
+    rtc::CritScope cs(&time_lock_);
+    return current_time_ns_;
+  }
+  void AdvanceTime(uint64_t interval) {
+    rtc::CritScope cs(&time_lock_);
+    current_time_ns_ += interval;
+  }
+ private:
+  CriticalSection time_lock_;
+  uint64_t current_time_ns_ GUARDED_BY(time_lock_);
+};
+
+class ScopedFakeTime : public FakeTime {

[pthatcher1, 2016/06/03 00:34:45]

Have you seen FakeClock in fakeclock.h? It looks *very* similar.

And ScopedFakeClock is being added to it in an upcoming CL.

[nisse-webrtc, 2016/06/03 11:40:07]

It look very similar indeed. Great minds think alike ;-)

I'm happy to leave this to you. Taylor, have a look the ScopedFakeTime in this
cl, maybe there's something there which is useful to you, or maybe there isn't.

[Taylor Brandstetter, 2016/06/03 16:30:16]

Aside from FakeTime taking a time in its constructor, and naming, I think our
implementations are exactly the same. I'm honestly amazed.

By the way, take a look at this upcoming CL:
https://codereview.webrtc.org/2024813004/

The goal is to handle events that piggyback off of each other. If the expiration
of one timeout triggers another timeout, then it's not enough to advance the
clock once, because that will only trigger the first timeout. So the
SIMULATED_WAIT macro advances the fake clock by 1ms ticks, processing all
pending events on each tick. Let me know what you think.

+ public:
+  explicit ScopedFakeTime(uint64_t start_time) : FakeTime(start_time) {
+    rtc::test::SetFakeTime(this);
+  }
+  ScopedFakeTime() : ScopedFakeTime(rtc::TimeNanos()) {}
+
+  ~ScopedFakeTime() {
+    rtc::test::SetFakeTime(nullptr);
+  }
+};
+
+}  // namespace test
+}  // namespace rtc
+
+#endif  // WEBRTC_BASE_FAKETIME_H_