Revert of Improving the fake clock and using it to fix a flaky STUN timeout test.

webrtc/base/timeutils_unittest.cc

 /*
  *  Copyright 2004 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.
  */
 
@@ skipping 283 matching lines @@
   EXPECT_EQ(TimeDelta::FromMilliseconds(500),
             TimeDelta::FromMilliseconds(1000) /= 2);
   EXPECT_EQ(TimeDelta::FromMilliseconds(2000),
             2 * TimeDelta::FromMilliseconds(1000));
 }
 
 // Test that all the time functions exposed by TimeUtils get time from the
 // fake clock when it's set.
 TEST(FakeClock, TimeFunctionsUseFakeClock) {
   FakeClock clock;
-  SetClockForTesting(&clock);
+  SetClock(&clock);
 
   clock.SetTimeNanos(987654321u);
   EXPECT_EQ(987u, Time32());
   EXPECT_EQ(987, TimeMillis());
   EXPECT_EQ(987654u, TimeMicros());
   EXPECT_EQ(987654321u, TimeNanos());
   EXPECT_EQ(1000u, TimeAfter(13));
 
-  SetClockForTesting(nullptr);
+  SetClock(nullptr);
   // After it's unset, we should get a normal time.
   EXPECT_NE(987, TimeMillis());
 }
 
 TEST(FakeClock, InitialTime) {
   FakeClock clock;
   EXPECT_EQ(0u, clock.TimeNanos());
 }
 
 TEST(FakeClock, SetTimeNanos) {
@@ skipping 17 matching lines @@
 }
 
 // When the clock is advanced, threads that are waiting in a socket select
 // should wake up and look at the new time. This allows tests using the
 // fake clock to run much faster, if the test is bound by time constraints
 // (such as a test for a STUN ping timeout).
 TEST(FakeClock, SettingTimeWakesThreads) {
   int64_t real_start_time_ms = TimeMillis();
 
   FakeClock clock;
-  SetClockForTesting(&clock);
+  SetClock(&clock);
 
   Thread worker;
   worker.Start();
 
   // Post an event that won't be executed for 10 seconds.
   Event message_handler_dispatched(false, false);
   auto functor = [&message_handler_dispatched] {
     message_handler_dispatched.Set();
   };
   FunctorMessageHandler<void, decltype(functor)> handler(functor);
-  worker.PostDelayed(60000, &handler);
+  worker.PostDelayed(10000, &handler);
 
   // Wait for a bit for the worker thread to be started and enter its socket
-  // select(). Otherwise this test would be trivial since the worker thread
-  // would process the event as soon as it was started.
+  // select().
   Thread::Current()->SleepMs(1000);
 
   // Advance the fake clock, expecting the worker thread to wake up
-  // and dispatch the message instantly.
-  clock.AdvanceTime(TimeDelta::FromSeconds(60u));
-  EXPECT_TRUE(message_handler_dispatched.Wait(0));
+  // and dispatch the message quickly.
+  clock.AdvanceTime(TimeDelta::FromSeconds(10u));
+  message_handler_dispatched.Wait(Event::kForever);
   worker.Stop();
 
-  SetClockForTesting(nullptr);
+  SetClock(nullptr);
 
-  // The message should have been dispatched long before the 60 seconds fully
-  // elapsed (just a sanity check).
+  // The message should have been dispatched long before the 10 seconds fully
+  // elapsed.
   int64_t real_end_time_ms = TimeMillis();
-  EXPECT_LT(real_end_time_ms - real_start_time_ms, 10000);
+  EXPECT_LT(real_end_time_ms - real_start_time_ms, 2000);
 }
 
 }  // namespace rtc