Cast: Add tests for clocks being slow/fast

media/cast/test/end2end_unittest.cc

 // Copyright 2013 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.
 //
 // This test generate synthetic data. For audio it's a sinusoid waveform with
 // frequency kSoundFrequency and different amplitudes. For video it's a pattern
 // that is shifting by one pixel per frame, each pixels neighbors right and down
 // is this pixels value +1, since the pixel value is 8 bit it will wrap
 // frequently within the image. Visually this will create diagonally color bands
 // that moves across the screen
@@ skipping 13 matching lines @@
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/tick_clock.h"
 #include "media/base/audio_bus.h"
 #include "media/base/video_frame.h"
 #include "media/cast/cast_config.h"
 #include "media/cast/cast_environment.h"
 #include "media/cast/cast_receiver.h"
 #include "media/cast/cast_sender.h"
 #include "media/cast/logging/simple_event_subscriber.h"
 #include "media/cast/test/fake_single_thread_task_runner.h"
+#include "media/cast/test/skewed_single_thread_task_runner.h"
+#include "media/cast/test/skewed_tick_clock.h"
 #include "media/cast/test/utility/audio_utility.h"
 #include "media/cast/test/utility/default_config.h"
 #include "media/cast/test/utility/udp_proxy.h"
 #include "media/cast/test/utility/video_utility.h"
 #include "media/cast/transport/cast_transport_config.h"
 #include "media/cast/transport/cast_transport_defines.h"
 #include "media/cast/transport/cast_transport_sender.h"
 #include "media/cast/transport/cast_transport_sender_impl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 107 matching lines @@
       ++(new_counter.counter[it->type]);
       event_counter_for_packet.insert(
           std::make_pair(it->packet_id, new_counter));
     } else {
       ++(map_it->second.counter[it->type]);
     }
   }
   return event_counter_for_packet;
 }
 
-void CountVideoFrame(int* counter,
-                     const scoped_refptr<media::VideoFrame>& video_frame,
-                     const base::TimeTicks& render_time, bool continuous) {
-  ++*counter;
-}
-
 }  // namespace
 
+// Shim that turns forwards packets from a test::PacketPipe to a
+// PacketReceiverCallback.
 class LoopBackPacketPipe : public test::PacketPipe {
  public:
   LoopBackPacketPipe(const transport::PacketReceiverCallback& packet_receiver)
       : packet_receiver_(packet_receiver) {}
 
   virtual ~LoopBackPacketPipe() {}
 
   // PacketPipe implementations.
   virtual void Send(scoped_ptr<transport::Packet> packet) OVERRIDE {
     packet_receiver_.Run(packet.Pass());
   }
 
  private:
   transport::PacketReceiverCallback packet_receiver_;
 };
 
 // Class that sends the packet direct from sender into the receiver with the
 // ability to drop packets between the two.
 class LoopBackTransport : public transport::PacketSender {
  public:
   explicit LoopBackTransport(scoped_refptr<CastEnvironment> cast_environment)
       : send_packets_(true),
         drop_packets_belonging_to_odd_frames_(false),
         cast_environment_(cast_environment) {}
 
   void SetPacketReceiver(
-      const transport::PacketReceiverCallback& packet_receiver) {
+      const transport::PacketReceiverCallback& packet_receiver,
+      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+      base::TickClock* clock) {
     scoped_ptr<test::PacketPipe> loopback_pipe(
         new LoopBackPacketPipe(packet_receiver));
     if (packet_pipe_) {
       packet_pipe_->AppendToPipe(loopback_pipe.Pass());
     } else {
       packet_pipe_ = loopback_pipe.Pass();
     }
+    packet_pipe_->InitOnIOThread(task_runner, clock);
   }
 
   virtual bool SendPacket(transport::PacketRef packet,
                           const base::Closure& cb) OVERRIDE {
     DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
     if (!send_packets_)
       return false;
 
     if (drop_packets_belonging_to_odd_frames_) {
       uint32 frame_id = packet->data[13];
@@ skipping 215 matching lines @@
   int num_called_;
   std::list<ExpectedVideoFrame> expected_frame_;
 };
 
 // The actual test class, generate synthetic data for both audio and video and
 // send those through the sender and receiver and analyzes the result.
 class End2EndTest : public ::testing::Test {
  protected:
   End2EndTest()
       : start_time_(),
-        testing_clock_sender_(new base::SimpleTestTickClock()),
-        testing_clock_receiver_(new base::SimpleTestTickClock()),
-        task_runner_(
-            new test::FakeSingleThreadTaskRunner(testing_clock_sender_)),
+        task_runner_(new test::FakeSingleThreadTaskRunner(&testing_clock_)),
+        testing_clock_sender_(new test::SkewedTickClock(&testing_clock_)),
+        task_runner_sender_(
+            new test::SkewedSingleThreadTaskRunner(task_runner_)),
+        testing_clock_receiver_(new test::SkewedTickClock(&testing_clock_)),
+        task_runner_receiver_(
+            new test::SkewedSingleThreadTaskRunner(task_runner_)),
         cast_environment_sender_(new CastEnvironment(
             scoped_ptr<base::TickClock>(testing_clock_sender_).Pass(),
-            task_runner_,
-            task_runner_,
-            task_runner_)),
+            task_runner_sender_,
+            task_runner_sender_,
+            task_runner_sender_)),
         cast_environment_receiver_(new CastEnvironment(
             scoped_ptr<base::TickClock>(testing_clock_receiver_).Pass(),
-            task_runner_,
-            task_runner_,
-            task_runner_)),
+            task_runner_receiver_,
+            task_runner_receiver_,
+            task_runner_receiver_)),
         receiver_to_sender_(cast_environment_receiver_),
         sender_to_receiver_(cast_environment_sender_),
         test_receiver_audio_callback_(new TestReceiverAudioCallback()),
         test_receiver_video_callback_(new TestReceiverVideoCallback()) {
-    testing_clock_sender_->Advance(
-        base::TimeDelta::FromMilliseconds(kStartMillisecond));
-    testing_clock_receiver_->Advance(
+    testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
     cast_environment_sender_->Logging()->AddRawEventSubscriber(
         &event_subscriber_sender_);
   }
 
   void Configure(transport::VideoCodec video_codec,
                  transport::AudioCodec audio_codec,
                  int audio_sampling_frequency,
                  bool external_audio_decoder,
                  int max_number_of_video_buffers_used) {
@@ skipping 37 matching lines @@
 
     video_receiver_config_.feedback_ssrc =
         video_sender_config_.incoming_feedback_ssrc;
     video_receiver_config_.incoming_ssrc = video_sender_config_.rtp_config.ssrc;
     video_receiver_config_.rtp_payload_type =
         video_sender_config_.rtp_config.payload_type;
     video_receiver_config_.use_external_decoder = false;
     video_receiver_config_.codec = video_sender_config_.codec;
   }
 
+  void SetSenderSkew(double skew, base::TimeDelta offset) {
+    testing_clock_sender_->SetSkew(skew, offset);
+    task_runner_sender_->SetSkew(1.0 / skew);
+  }
+
+  void SetReceiverSkew(double skew, base::TimeDelta offset) {
+    testing_clock_receiver_->SetSkew(skew, offset);
+    task_runner_receiver_->SetSkew(1.0 / skew);
+  }
+
   void FeedAudioFrames(int count, bool will_be_checked) {
     for (int i = 0; i < count; ++i) {
       scoped_ptr<AudioBus> audio_bus(audio_bus_factory_->NextAudioBus(
           base::TimeDelta::FromMilliseconds(kAudioFrameDurationMs)));
       const base::TimeTicks send_time =
           testing_clock_sender_->NowTicks() +
               i * base::TimeDelta::FromMilliseconds(kAudioFrameDurationMs);
       if (will_be_checked)
         test_receiver_audio_callback_->AddExpectedResult(*audio_bus, send_time);
       audio_frame_input_->InsertAudio(audio_bus.Pass(), send_time);
@@ skipping 29 matching lines @@
                                           video_receiver_config_,
                                           &receiver_to_sender_);
     net::IPEndPoint dummy_endpoint;
     transport_sender_.reset(new transport::CastTransportSenderImpl(
         NULL,
         testing_clock_sender_,
         dummy_endpoint,
         base::Bind(&UpdateCastTransportStatus),
         base::Bind(&End2EndTest::LogRawEvents, base::Unretained(this)),
         base::TimeDelta::FromSeconds(1),
-        task_runner_,
+        task_runner_sender_,
         &sender_to_receiver_));
 
     cast_sender_ =
         CastSender::Create(cast_environment_sender_, transport_sender_.get());
 
     // Initializing audio and video senders.
     cast_sender_->InitializeAudio(audio_sender_config_,
                                   base::Bind(&AudioInitializationStatus));
     cast_sender_->InitializeVideo(video_sender_config_,
                                   base::Bind(&VideoInitializationStatus),
                                   CreateDefaultVideoEncodeAcceleratorCallback(),
                                   CreateDefaultVideoEncodeMemoryCallback());
 
-    receiver_to_sender_.SetPacketReceiver(cast_sender_->packet_receiver());
-    sender_to_receiver_.SetPacketReceiver(cast_receiver_->packet_receiver());
+    receiver_to_sender_.SetPacketReceiver(cast_sender_->packet_receiver(),
+                                          task_runner_,
+                                          &testing_clock_);
+    sender_to_receiver_.SetPacketReceiver(cast_receiver_->packet_receiver(),
+                                          task_runner_,
+                                          &testing_clock_);
 
     audio_frame_input_ = cast_sender_->audio_frame_input();
     video_frame_input_ = cast_sender_->video_frame_input();
 
     frame_receiver_ = cast_receiver_->frame_receiver();
 
     audio_bus_factory_.reset(
         new TestAudioBusFactory(audio_sender_config_.channels,
                                 audio_sender_config_.frequency,
                                 kSoundFrequency,
@@ skipping 23 matching lines @@
             VideoFrame::I420, size, gfx::Rect(size), size, time_diff);
     PopulateVideoFrame(video_frame, start_value);
     video_frame_input_->InsertRawVideoFrame(video_frame, capture_time);
   }
 
   void SendFakeVideoFrame(const base::TimeTicks& capture_time) {
     video_frame_input_->InsertRawVideoFrame(
         media::VideoFrame::CreateBlackFrame(gfx::Size(2, 2)), capture_time);
   }
 
-  void RunTasks(int during_ms) {
-    for (int i = 0; i < during_ms; ++i) {
-      // Call process the timers every 1 ms.
-      testing_clock_sender_->Advance(base::TimeDelta::FromMilliseconds(1));
-      testing_clock_receiver_->Advance(base::TimeDelta::FromMilliseconds(1));
-      task_runner_->RunTasks();
-    }
+  void RunTasks(int ms) {
+    task_runner_->Sleep(base::TimeDelta::FromMilliseconds(ms));
+  }
+
+  void BasicPlayerGotVideoFrame(
+      const scoped_refptr<media::VideoFrame>& video_frame,
+      const base::TimeTicks& render_time, bool continuous) {
+    video_ticks_.push_back(std::make_pair(
+        testing_clock_receiver_->NowTicks(),
+        render_time));
+    frame_receiver_->GetRawVideoFrame(
+        base::Bind(&End2EndTest::BasicPlayerGotVideoFrame,
+                   base::Unretained(this)));
+  }
+
+  void BasicPlayerGotAudioFrame(scoped_ptr<AudioBus> audio_bus,
+                                const base::TimeTicks& playout_time,
+                                bool is_continuous) {
+    audio_ticks_.push_back(std::make_pair(
+        testing_clock_receiver_->NowTicks(),
+        playout_time));
+    frame_receiver_->GetRawAudioFrame(
+        base::Bind(&End2EndTest::BasicPlayerGotAudioFrame,
+                   base::Unretained(this)));
+  }
+
+  void StartBasicPlayer() {
+    frame_receiver_->GetRawVideoFrame(
+        base::Bind(&End2EndTest::BasicPlayerGotVideoFrame,
+                   base::Unretained(this)));
+    frame_receiver_->GetRawAudioFrame(
+        base::Bind(&End2EndTest::BasicPlayerGotAudioFrame,
+                   base::Unretained(this)));
   }
 
   void LogRawEvents(const std::vector<PacketEvent>& packet_events) {
     EXPECT_FALSE(packet_events.empty());
     for (std::vector<media::cast::PacketEvent>::const_iterator it =
              packet_events.begin();
          it != packet_events.end();
          ++it) {
       cast_environment_sender_->Logging()->InsertPacketEvent(it->timestamp,
                                                              it->type,
                                                              it->media_type,
                                                              it->rtp_timestamp,
                                                              it->frame_id,
                                                              it->packet_id,
                                                              it->max_packet_id,
                                                              it->size);
     }
   }
 
   AudioReceiverConfig audio_receiver_config_;
   VideoReceiverConfig video_receiver_config_;
   AudioSenderConfig audio_sender_config_;
   VideoSenderConfig video_sender_config_;
 
   base::TimeTicks start_time_;
-  base::SimpleTestTickClock* testing_clock_sender_;
-  base::SimpleTestTickClock* testing_clock_receiver_;
+
+  // These run in "test time"
+  base::SimpleTestTickClock testing_clock_;
   scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
+
+  // These run on the sender timeline.
+  test::SkewedTickClock* testing_clock_sender_;
+  scoped_refptr<test::SkewedSingleThreadTaskRunner> task_runner_sender_;
+
+  // These run on the receiver timeline.
+  test::SkewedTickClock* testing_clock_receiver_;
+  scoped_refptr<test::SkewedSingleThreadTaskRunner> task_runner_receiver_;
+
   scoped_refptr<CastEnvironment> cast_environment_sender_;
   scoped_refptr<CastEnvironment> cast_environment_receiver_;
 
   LoopBackTransport receiver_to_sender_;
   LoopBackTransport sender_to_receiver_;
   scoped_ptr<transport::CastTransportSenderImpl> transport_sender_;
 
   scoped_ptr<CastReceiver> cast_receiver_;
   scoped_ptr<CastSender> cast_sender_;
   scoped_refptr<AudioFrameInput> audio_frame_input_;
   scoped_refptr<VideoFrameInput> video_frame_input_;
   scoped_refptr<FrameReceiver> frame_receiver_;
 
   scoped_refptr<TestReceiverAudioCallback> test_receiver_audio_callback_;
   scoped_refptr<TestReceiverVideoCallback> test_receiver_video_callback_;
 
   scoped_ptr<TestAudioBusFactory> audio_bus_factory_;
 
   SimpleEventSubscriber event_subscriber_sender_;
   std::vector<FrameEvent> frame_events_;
   std::vector<PacketEvent> packet_events_;
+  std::vector<std::pair<base::TimeTicks, base::TimeTicks> > audio_ticks_;
+  std::vector<std::pair<base::TimeTicks, base::TimeTicks> > video_ticks_;
   // |transport_sender_| has a RepeatingTimer which needs a MessageLoop.
   base::MessageLoop message_loop_;
 };
 
 TEST_F(End2EndTest, LoopNoLossPcm16) {
   Configure(transport::kVp8, transport::kPcm16, 32000, false, 1);
   // Reduce video resolution to allow processing multiple frames within a
   // reasonable time frame.
   video_sender_config_.width = kVideoQcifWidth;
   video_sender_config_.height = kVideoQcifHeight;
@@ skipping 542 matching lines @@
 
     // Verify that there were no other events logged with respect to this frame.
     // (i.e. Total event count = expected event count)
     EXPECT_EQ(total_event_count_for_frame, expected_event_count_for_frame);
   }
 }
 
 TEST_F(End2EndTest, BasicFakeSoftwareVideo) {
   Configure(transport::kFakeSoftwareVideo, transport::kPcm16, 32000, false, 1);
   Create();
+  StartBasicPlayer();
 
   int frames_counter = 0;
-  int received_counter = 0;
   for (; frames_counter < 1000; ++frames_counter) {
     SendFakeVideoFrame(testing_clock_sender_->NowTicks());
-    frame_receiver_->GetRawVideoFrame(
-        base::Bind(&CountVideoFrame, &received_counter));
     RunTasks(kFrameTimerMs);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
-  EXPECT_EQ(1000, received_counter);
+  EXPECT_EQ(1000ul, video_ticks_.size());
+}
+
+TEST_F(End2EndTest, WonkyClock1) {
+  Configure(transport::kFakeSoftwareVideo, transport::kPcm16, 32000, false, 1);
+  Create();
+  StartBasicPlayer();
+  SetReceiverSkew(2.0, base::TimeDelta());
+
+  int frames_counter = 0;
+  for (; frames_counter < 10000; ++frames_counter) {
+    SendFakeVideoFrame(testing_clock_sender_->NowTicks());
+    RunTasks(kFrameTimerMs);
+  }
+  RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
+  EXPECT_EQ(10000ul, video_ticks_.size());
+}
+
+TEST_F(End2EndTest, WonkyClock2) {

[Alpha Left Google, 2014/05/15 22:21:24]

How is this different from the test above? Please either have a comment or have
a more accurate test name.

[hubbe, 2014/05/16 04:31:10]

Done.

+  Configure(transport::kFakeSoftwareVideo, transport::kPcm16, 32000, false, 1);
+  Create();
+  StartBasicPlayer();
+  SetReceiverSkew(0.5, base::TimeDelta());
+
+  int frames_counter = 0;
+  for (; frames_counter < 10000; ++frames_counter) {
+    SendFakeVideoFrame(testing_clock_sender_->NowTicks());
+    RunTasks(kFrameTimerMs);
+  }
+  RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
+  EXPECT_EQ(10000ul, video_ticks_.size());
+}
+
+TEST_F(End2EndTest, EvilNetwork) {
+  Configure(transport::kFakeSoftwareVideo, transport::kPcm16, 32000, false, 1);
+  receiver_to_sender_.SetPacketPipe(test::EvilNetwork().Pass());
+  sender_to_receiver_.SetPacketPipe(test::EvilNetwork().Pass());
+  Create();
+  StartBasicPlayer();
+
+  int frames_counter = 0;
+  for (; frames_counter < 10000; ++frames_counter) {
+    SendFakeVideoFrame(testing_clock_sender_->NowTicks());
+    RunTasks(kFrameTimerMs);
+  }
+  base::TimeTicks test_end = testing_clock_receiver_->NowTicks();
+  RunTasks(100 * kFrameTimerMs + 1);  // Empty the pipeline.
+  EXPECT_GT(video_ticks_.size(), 100ul);
+  EXPECT_LT((video_ticks_.back().second - test_end).InMilliseconds(), 1000);
 }
 
 // TODO(pwestin): Add repeatable packet loss test.
 // TODO(pwestin): Add test for misaligned send get calls.
 // TODO(pwestin): Add more tests that does not resample.
 // TODO(pwestin): Add test when we have starvation for our RunTask.
 
 }  // namespace cast
 }  // namespace media