Cast: Add tests for clocks being slow/fast

media/cast/test/utility/udp_proxy.cc

 // Copyright 2014 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 "media/cast/test/utility/udp_proxy.h"
 
 #include "base/logging.h"
 #include "base/memory/linked_ptr.h"
 #include "base/rand_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
+#include "base/time/default_tick_clock.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/udp/udp_socket.h"
 
 namespace media {
 namespace cast {
 namespace test {
 
 const size_t kMaxPacketSize = 65536;
 
 PacketPipe::PacketPipe() {}
 PacketPipe::~PacketPipe() {}
 void PacketPipe::InitOnIOThread(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) {
+    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    base::TickClock* clock) {
   task_runner_ = task_runner;
+  clock_ = clock;
   if (pipe_) {
-    pipe_->InitOnIOThread(task_runner);
+    pipe_->InitOnIOThread(task_runner, clock);
   }
 }
 void PacketPipe::AppendToPipe(scoped_ptr<PacketPipe> pipe) {
   if (pipe_) {
     pipe_->AppendToPipe(pipe.Pass());
   } else {
     pipe_ = pipe.Pass();
   }
 }
 
@@ skipping 137 matching lines @@
         seconds_between_extra_delay_(seconds_between_extra_delay),
         weak_factory_(this) {}
 
   virtual void Send(scoped_ptr<transport::Packet> packet) OVERRIDE {
     buffer_.push_back(linked_ptr<transport::Packet>(packet.release()));
     if (buffer_.size() == 1) {
       Schedule();
     }
   }
   virtual void InitOnIOThread(
-      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) OVERRIDE {
-    PacketPipe::InitOnIOThread(task_runner);
+      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+      base::TickClock* clock) OVERRIDE {
+    PacketPipe::InitOnIOThread(task_runner, clock);
     // As we start the stream, assume that we are in a random
     // place between two extra delays, thus multiplier = 1.0;
     ScheduleExtraDelay(1.0);
   }
 
  private:
   void ScheduleExtraDelay(double mult) {
     double seconds = seconds_between_extra_delay_ * mult * base::RandDouble();
     int64 microseconds = static_cast<int64>(seconds * 1E6);
     task_runner_->PostDelayedTask(
         FROM_HERE,
         base::Bind(&RandomSortedDelay::CauseExtraDelay,
                    weak_factory_.GetWeakPtr()),
         base::TimeDelta::FromMicroseconds(microseconds));
   }
 
   void CauseExtraDelay() {
-    block_until_ = base::TimeTicks::Now() +
+    block_until_ = clock_->NowTicks() +
         base::TimeDelta::FromMicroseconds(
             static_cast<int64>(extra_delay_ * 1E6));
     // An extra delay just happened, wait up to seconds_between_extra_delay_*2
     // before scheduling another one to make the average equal to
     // seconds_between_extra_delay_.
     ScheduleExtraDelay(2.0);
   }
 
   void Schedule() {
     double seconds = base::RandDouble() * random_delay_;
@@ skipping 41 matching lines @@
 
 class NetworkGlitchPipe : public PacketPipe {
  public:
   NetworkGlitchPipe(double average_work_time, double average_outage_time)
       : works_(false),
         max_work_time_(average_work_time * 2),
         max_outage_time_(average_outage_time * 2),
         weak_factory_(this) {}
 
   virtual void InitOnIOThread(
-      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) OVERRIDE {
-    PacketPipe::InitOnIOThread(task_runner);
+      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+      base::TickClock* clock) OVERRIDE {
+    PacketPipe::InitOnIOThread(task_runner, clock);
     Flip();
   }
 
   virtual void Send(scoped_ptr<transport::Packet> packet) OVERRIDE {
     if (works_) {
       pipe_->Send(packet.Pass());
     }
   }
 
  private:
@@ skipping 179 matching lines @@
  private:
   void Start(base::WaitableEvent* start_event,
              net::NetLog* net_log) {
     socket_.reset(new net::UDPSocket(net::DatagramSocket::DEFAULT_BIND,
                                      net::RandIntCallback(),
                                      net_log,
                                      net::NetLog::Source()));
     BuildPipe(&to_dest_pipe_, new PacketSender(socket_.get(), &destination_));
     BuildPipe(&from_dest_pipe_,
               new PacketSender(socket_.get(), &return_address_));
-    to_dest_pipe_->InitOnIOThread(base::MessageLoopProxy::current());
-    from_dest_pipe_->InitOnIOThread(base::MessageLoopProxy::current());
+    to_dest_pipe_->InitOnIOThread(base::MessageLoopProxy::current(),
+                                  &tick_clock_);
+    from_dest_pipe_->InitOnIOThread(base::MessageLoopProxy::current(),
+                                    &tick_clock_);
 
     VLOG(0) << "From:" << local_port_.ToString();
     VLOG(0) << "To:" << destination_.ToString();
 
     CHECK_GE(socket_->Bind(local_port_), 0);
 
     start_event->Signal();
     PollRead();
   }
 
@@ skipping 38 matching lines @@
           base::Bind(&UDPProxyImpl::ReadCallback,
                      base::Unretained(this),
                      recv_buf));
       if (len == net::ERR_IO_PENDING)
         break;
       ProcessPacket(recv_buf, len);
     }
   }
 
 
+  base::DefaultTickClock tick_clock_;
   net::IPEndPoint local_port_;
   net::IPEndPoint destination_;
   net::IPEndPoint recv_address_;
   net::IPEndPoint return_address_;
   base::Thread proxy_thread_;
   scoped_ptr<net::UDPSocket> socket_;
   scoped_ptr<PacketPipe> to_dest_pipe_;
   scoped_ptr<PacketPipe> from_dest_pipe_;
   scoped_ptr<transport::Packet> packet_;
 };
 
 scoped_ptr<UDPProxy> UDPProxy::Create(
     const net::IPEndPoint& local_port,
     const net::IPEndPoint& destination,
     scoped_ptr<PacketPipe> to_dest_pipe,
     scoped_ptr<PacketPipe> from_dest_pipe,
     net::NetLog* net_log) {
   scoped_ptr<UDPProxy> ret(new UDPProxyImpl(local_port,
                                             destination,
                                             to_dest_pipe.Pass(),
                                             from_dest_pipe.Pass(),
                                             net_log));
   return ret.Pass();
 }
 
 }  // namespace test
 }  // namespace cast
 }  // namespace media