Update VirtualSocketServerTest to use a fake clock.

webrtc/base/testclient.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.
  */
 
 #include "webrtc/base/testclient.h"
+
+#include "webrtc/base/gunit.h"
 #include "webrtc/base/ptr_util.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
 
 namespace rtc {
 
 // DESIGN: Each packet received is put it into a list of packets.
 //         Callers can retrieve received packets from any thread by calling
 //         NextPacket.
 
 TestClient::TestClient(std::unique_ptr<AsyncPacketSocket> socket)
-    : socket_(std::move(socket)), prev_packet_timestamp_(-1) {
+    : TestClient(std::move(socket), nullptr) {}
+
+TestClient::TestClient(std::unique_ptr<AsyncPacketSocket> socket,
+                       FakeClock* fake_clock)
+    : fake_clock_(fake_clock),
+      socket_(std::move(socket)),
+      prev_packet_timestamp_(-1) {
   socket_->SignalReadPacket.connect(this, &TestClient::OnPacket);
   socket_->SignalReadyToSend.connect(this, &TestClient::OnReadyToSend);
 }
 
 TestClient::~TestClient() {}
 
 bool TestClient::CheckConnState(AsyncPacketSocket::State state) {
   // Wait for our timeout value until the socket reaches the desired state.
   int64_t end = TimeAfter(kTimeoutMs);
   while (socket_->GetState() != state && TimeUntil(end) > 0) {
-    Thread::Current()->ProcessMessages(1);
+    AdvanceTime(1);
   }
   return (socket_->GetState() == state);
 }
 
 int TestClient::Send(const char* buf, size_t size) {
   rtc::PacketOptions options;
   return socket_->Send(buf, size, options);
 }
 
 int TestClient::SendTo(const char* buf, size_t size,
@@ skipping 15 matching lines @@
   // the wrong thread to non-thread-safe objects.
 
   int64_t end = TimeAfter(timeout_ms);
   while (TimeUntil(end) > 0) {
     {
       CritScope cs(&crit_);
       if (packets_.size() != 0) {
         break;
       }
     }
-    Thread::Current()->ProcessMessages(1);
+    AdvanceTime(1);
   }
 
   // Return the first packet placed in the queue.
   std::unique_ptr<Packet> packet;
   CritScope cs(&crit_);
   if (packets_.size() > 0) {
     packet = std::move(packets_.front());
     packets_.erase(packets_.begin());
   }
 
@@ skipping 20 matching lines @@
   }
   if (prev_packet_timestamp_ != -1) {
     if (packet_timestamp < prev_packet_timestamp_) {
       res = false;
     }
   }
   prev_packet_timestamp_ = packet_timestamp;
   return res;
 }
 
+void TestClient::AdvanceTime(int ms) {
+  // If the test is using a fake clock, we must advance the fake clock to
+  // advance time. Otherwise, ProcessMessages will work.
+  if (fake_clock_) {
+    SIMULATED_WAIT(false, ms, *fake_clock_);
+  } else {
+    Thread::Current()->ProcessMessages(1);
+  }
+}
+
 bool TestClient::CheckNoPacket() {
   return NextPacket(kNoPacketTimeoutMs) == nullptr;
 }
 
 int TestClient::GetError() {
   return socket_->GetError();
 }
 
 int TestClient::SetOption(Socket::Option opt, int value) {
   return socket_->SetOption(opt, value);
@@ skipping 23 matching lines @@
     : addr(p.addr), buf(0), size(p.size), packet_time(p.packet_time) {
   buf = new char[size];
   memcpy(buf, p.buf, size);
 }
 
 TestClient::Packet::~Packet() {
   delete[] buf;
 }
 
 }  // namespace rtc