Nuke TickTime::UseFakeClock.

webrtc/test/fake_network_pipe.cc

 /*
  *  Copyright (c) 2012 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/test/fake_network_pipe.h"
 
 #include <assert.h>
 #include <math.h>
 #include <string.h>
 #include <algorithm>
 
 #include "webrtc/call.h"
-#include "webrtc/system_wrappers/include/tick_util.h"
+#include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 
 const double kPi = 3.14159265;
 
 static int GaussianRandom(int mean_delay_ms, int standard_deviation_ms) {
   // Creating a Normal distribution variable from two independent uniform
   // variables based on the Box-Muller transform.
   double uniform1 = (rand() + 1.0) / (RAND_MAX + 1.0);  // NOLINT
   double uniform2 = (rand() + 1.0) / (RAND_MAX + 1.0);  // NOLINT
@@ skipping 33 matching lines @@
   // The packet data.
   uint8_t* data_;
   // Length of data_.
   size_t data_length_;
   // The time the packet was sent out on the network.
   const int64_t send_time_;
   // The time the packet should arrive at the reciver.
   int64_t arrival_time_;
 };
 
-FakeNetworkPipe::FakeNetworkPipe(const FakeNetworkPipe::Config& config)
-    : packet_receiver_(NULL),
+FakeNetworkPipe::FakeNetworkPipe(Clock* clock,
+                                 const FakeNetworkPipe::Config& config)
+    : clock_(clock),
+      packet_receiver_(NULL),
       config_(config),
       dropped_packets_(0),
       sent_packets_(0),
       total_packet_delay_(0),
-      next_process_time_(TickTime::MillisecondTimestamp()) {
-}
+      next_process_time_(clock_->TimeInMilliseconds()) {}
 
 FakeNetworkPipe::~FakeNetworkPipe() {
   while (!capacity_link_.empty()) {
     delete capacity_link_.front();
     capacity_link_.pop();
   }
   while (!delay_link_.empty()) {
     delete delay_link_.front();
     delay_link_.pop();
   }
@@ skipping 14 matching lines @@
   if (packet_receiver_ == NULL)
     return;
   rtc::CritScope crit(&lock_);
   if (config_.queue_length_packets > 0 &&
       capacity_link_.size() >= config_.queue_length_packets) {
     // Too many packet on the link, drop this one.
     ++dropped_packets_;
     return;
   }
 
-  int64_t time_now = TickTime::MillisecondTimestamp();
+  int64_t time_now = clock_->TimeInMilliseconds();
 
   // Delay introduced by the link capacity.
   int64_t capacity_delay_ms = 0;
   if (config_.link_capacity_kbps > 0)
     capacity_delay_ms = data_length / (config_.link_capacity_kbps / 8);
   int64_t network_start_time = time_now;
 
   // Check if there already are packets on the link and change network start
   // time if there is.
   if (capacity_link_.size() > 0)
@@ skipping 16 matching lines @@
 
 int FakeNetworkPipe::AverageDelay() {
   rtc::CritScope crit(&lock_);
   if (sent_packets_ == 0)
     return 0;
 
   return total_packet_delay_ / static_cast<int>(sent_packets_);
 }
 
 void FakeNetworkPipe::Process() {
-  int64_t time_now = TickTime::MillisecondTimestamp();
+  int64_t time_now = clock_->TimeInMilliseconds();
   std::queue<NetworkPacket*> packets_to_deliver;
   {
     rtc::CritScope crit(&lock_);
     // Check the capacity link first.
     while (capacity_link_.size() > 0 &&
            time_now >= capacity_link_.front()->arrival_time()) {
       // Time to get this packet.
       NetworkPacket* packet = capacity_link_.front();
       capacity_link_.pop();
 
@@ skipping 40 matching lines @@
                                     packet->data_length(), PacketTime());
     delete packet;
   }
 }
 
 int64_t FakeNetworkPipe::TimeUntilNextProcess() const {
   rtc::CritScope crit(&lock_);
   const int64_t kDefaultProcessIntervalMs = 30;
   if (capacity_link_.size() == 0 || delay_link_.size() == 0)
     return kDefaultProcessIntervalMs;
-  return std::max<int64_t>(
-      next_process_time_ - TickTime::MillisecondTimestamp(), 0);
+  return std::max<int64_t>(next_process_time_ - clock_->TimeInMilliseconds(),
+                           0);
 }
 
 }  // namespace webrtc