Simplify interface for media/cast: CastTransportSenderImpl

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 76 matching lines @@
   compressed.reserve(base_16.size() / 2);
 
   std::vector<uint8_t> v;
   if (!base::HexStringToBytes(base_16, &v)) {
     NOTREACHED();
   }
   compressed.assign(reinterpret_cast<const char*>(&v[0]), v.size());
   return compressed;
 }
 
-void UpdateCastTransportStatus(CastTransportStatus status) {
-  bool result = (status == TRANSPORT_AUDIO_INITIALIZED ||
-                 status == TRANSPORT_VIDEO_INITIALIZED);
-  EXPECT_TRUE(result);
-}
-
 void ExpectSuccessOperationalStatus(OperationalStatus status) {
   EXPECT_EQ(STATUS_INITIALIZED, status);
 }
 
 // This is wrapped in a struct because it needs to be put into a std::map.
 typedef struct { int counter[kNumOfLoggingEvents]; } LoggingEventCounts;
 
 // Constructs a map from each frame (RTP timestamp) to counts of each event
 // type logged for that frame.
 std::map<RtpTimeTicks, LoggingEventCounts> GetEventCountsForFrameEvents(
@@ skipping 93 matching lines @@
         return true;
     }
 
     scoped_ptr<Packet> packet_copy(new Packet(packet->data));
     packet_pipe_->Send(std::move(packet_copy));
     return true;
   }
 
   int64_t GetBytesSent() final { return bytes_sent_; }
 
+  void StartReceiving(
+      const PacketReceiverCallbackWithStatus& packet_receiver) final {}
+
+  void StopReceiving() final {}
+
   void SetSendPackets(bool send_packets) { send_packets_ = send_packets; }
 
   void DropAllPacketsBelongingToOddFrames() {
     drop_packets_belonging_to_odd_frames_ = true;
   }
 
   void SetPacketPipe(scoped_ptr<test::PacketPipe> pipe) {
     // Append the loopback pipe to the end.
     pipe->AppendToPipe(std::move(packet_pipe_));
     packet_pipe_ = std::move(pipe);
@@ skipping 164 matching lines @@
   int num_called_;
   std::list<ExpectedVideoFrame> expected_frame_;
   base::TimeTicks last_playout_time_;
 };
 
 }  // namespace
 
 // 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 {
+ public:
+  void ReceivePacket(scoped_ptr<media::cast::Packet> packet) {
+    cast_receiver_->ReceivePacket(std::move(packet));
+  };
+
  protected:
   End2EndTest()
       : start_time_(),
         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_),
             task_runner_sender_,
             task_runner_sender_,
             task_runner_sender_)),
         cast_environment_receiver_(new CastEnvironment(
             scoped_ptr<base::TickClock>(testing_clock_receiver_),
             task_runner_receiver_,
             task_runner_receiver_,
             task_runner_receiver_)),
-        receiver_to_sender_(cast_environment_receiver_),
-        sender_to_receiver_(cast_environment_sender_),
+        receiver_to_sender_(new LoopBackTransport(cast_environment_receiver_)),
+        sender_to_receiver_(new LoopBackTransport(cast_environment_sender_)),
         test_receiver_audio_callback_(new TestReceiverAudioCallback()),
         test_receiver_video_callback_(new TestReceiverVideoCallback()) {
     testing_clock_.Advance(
         base::TimeDelta::FromMilliseconds(kStartMillisecond));
     cast_environment_sender_->logger()->Subscribe(&event_subscriber_sender_);
   }
 
   void Configure(Codec video_codec, Codec audio_codec) {
     audio_sender_config_.ssrc = 1;
     audio_sender_config_.receiver_ssrc = 2;
@@ skipping 110 matching lines @@
 
   void RequestAudioFrames(int count, bool with_check) {
     for (int i = 0; i < count; ++i) {
       cast_receiver_->RequestDecodedAudioFrame(
           base::Bind(with_check ? &TestReceiverAudioCallback::CheckAudioFrame :
                                   &TestReceiverAudioCallback::IgnoreAudioFrame,
                      test_receiver_audio_callback_));
     }
   }
 
-  void ReceivePacket(scoped_ptr<Packet> packet) {
-    cast_receiver_->ReceivePacket(std::move(packet));
-  }
-
-  void Create() {
-    net::IPEndPoint dummy_endpoint;
-    transport_sender_.reset(new CastTransportSenderImpl(
-        nullptr, testing_clock_sender_, dummy_endpoint, dummy_endpoint,
-        make_scoped_ptr(new base::DictionaryValue),
-        base::Bind(&UpdateCastTransportStatus),
-        base::Bind(&LogEventDispatcher::DispatchBatchOfEvents,
-                   base::Unretained(cast_environment_sender_->logger())),
-        base::TimeDelta::FromMilliseconds(1), task_runner_sender_,
-        PacketReceiverCallback(), &sender_to_receiver_));
-
-    transport_receiver_.reset(new CastTransportSenderImpl(
-        nullptr, testing_clock_sender_, dummy_endpoint, dummy_endpoint,
-        make_scoped_ptr(new base::DictionaryValue),
-        base::Bind(&UpdateCastTransportStatus),
-        base::Bind(&LogEventDispatcher::DispatchBatchOfEvents,
-                   base::Unretained(cast_environment_receiver_->logger())),
-        base::TimeDelta::FromMilliseconds(1), task_runner_sender_,
-        base::Bind(&End2EndTest::ReceivePacket, base::Unretained(this)),
-        &receiver_to_sender_));
-
-    cast_receiver_ = CastReceiver::Create(cast_environment_receiver_,
-                                          audio_receiver_config_,
-                                          video_receiver_config_,
-                                          transport_receiver_.get());
-
-    cast_sender_ =
-        CastSender::Create(cast_environment_sender_, transport_sender_.get());
-
-    // Initializing audio and video senders.
-    cast_sender_->InitializeAudio(
-        audio_sender_config_,
-        base::Bind(&ExpectSuccessOperationalStatus));
-    cast_sender_->InitializeVideo(
-        video_sender_config_,
-        base::Bind(&ExpectSuccessOperationalStatus),
-        CreateDefaultVideoEncodeAcceleratorCallback(),
-        CreateDefaultVideoEncodeMemoryCallback());
-    task_runner_->RunTasks();
-
-    receiver_to_sender_.SetPacketReceiver(
-        transport_sender_->PacketReceiverForTesting(),
-        task_runner_,
-        &testing_clock_);
-    sender_to_receiver_.SetPacketReceiver(
-        transport_receiver_->PacketReceiverForTesting(),
-        task_runner_,
-        &testing_clock_);
-
-    audio_frame_input_ = cast_sender_->audio_frame_input();
-    video_frame_input_ = cast_sender_->video_frame_input();
-
-    audio_bus_factory_.reset(
-        new TestAudioBusFactory(audio_sender_config_.channels,
-                                audio_sender_config_.frequency,
-                                kSoundFrequency,
-                                kSoundVolume));
-  }
+  void Create();
 
   ~End2EndTest() override {
     cast_environment_sender_->logger()->Unsubscribe(&event_subscriber_sender_);
   }
 
   void TearDown() final {
     cast_sender_.reset();
     cast_receiver_.reset();
     task_runner_->RunTasks();
   }
@@ skipping 285 matching lines @@
   base::TimeDelta min_video_playout_delta_;
   base::TimeDelta max_video_playout_delta_;
   base::TimeDelta max_video_playout_curvature_;
   base::TimeTicks last_video_playout_time_;
   base::TimeDelta last_video_playout_delta_;
   base::TimeTicks last_audio_playout_time_;
 
   scoped_refptr<CastEnvironment> cast_environment_sender_;
   scoped_refptr<CastEnvironment> cast_environment_receiver_;
 
-  LoopBackTransport receiver_to_sender_;
-  LoopBackTransport sender_to_receiver_;
+  LoopBackTransport* receiver_to_sender_;  // Owned by CastTransportSender.
+  LoopBackTransport* sender_to_receiver_;  // Owned by CastTransportSender.
+
   scoped_ptr<CastTransportSenderImpl> transport_sender_;
   scoped_ptr<CastTransportSenderImpl> transport_receiver_;
 
   scoped_ptr<CastReceiver> cast_receiver_;
   scoped_ptr<CastSender> cast_sender_;
   scoped_refptr<AudioFrameInput> audio_frame_input_;
   scoped_refptr<VideoFrameInput> video_frame_input_;
 
   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<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_;
 };
 
+namespace {
+
+class TransportClient : public CastTransportSender::Client {
+ public:
+  TransportClient(LogEventDispatcher* log_event_dispatcher,
+                  End2EndTest* e2e_test)
+      : log_event_dispatcher_(log_event_dispatcher), e2e_test_(e2e_test) {}
+
+  void OnStatusChanged(media::cast::CastTransportStatus status) final {
+    bool result = (status == TRANSPORT_AUDIO_INITIALIZED ||
+                   status == TRANSPORT_VIDEO_INITIALIZED);
+    EXPECT_TRUE(result);
+  };
+  void OnLoggingEventsReceived(
+      scoped_ptr<std::vector<FrameEvent>> frame_events,
+      scoped_ptr<std::vector<PacketEvent>> packet_events) final {
+    log_event_dispatcher_->DispatchBatchOfEvents(std::move(frame_events),
+                                                 std::move(packet_events));
+  };
+  void ProcessRtpPacket(scoped_ptr<Packet> packet) final {
+    if (e2e_test_)
+      e2e_test_->ReceivePacket(std::move(packet));
+  };
+
+ private:
+  LogEventDispatcher* const log_event_dispatcher_;  // Not owned by this class.
+  End2EndTest* const e2e_test_;                     // Not owned by this class.
+
+  DISALLOW_COPY_AND_ASSIGN(TransportClient);
+};
+
+}  // namespace
+
+void End2EndTest::Create() {
+  transport_sender_.reset(new CastTransportSenderImpl(
+      testing_clock_sender_, base::TimeDelta::FromMilliseconds(1),
+      make_scoped_ptr(
+          new TransportClient(cast_environment_sender_->logger(), nullptr)),
+      make_scoped_ptr(sender_to_receiver_), task_runner_sender_));
+
+  transport_receiver_.reset(new CastTransportSenderImpl(
+      testing_clock_sender_, base::TimeDelta::FromMilliseconds(1),
+      make_scoped_ptr(
+          new TransportClient(cast_environment_receiver_->logger(), this)),
+      make_scoped_ptr(receiver_to_sender_), task_runner_sender_));
+
+  cast_receiver_ =
+      CastReceiver::Create(cast_environment_receiver_, audio_receiver_config_,
+                           video_receiver_config_, transport_receiver_.get());
+
+  cast_sender_ =
+      CastSender::Create(cast_environment_sender_, transport_sender_.get());
+
+  // Initializing audio and video senders.
+  cast_sender_->InitializeAudio(audio_sender_config_,
+                                base::Bind(&ExpectSuccessOperationalStatus));
+  cast_sender_->InitializeVideo(video_sender_config_,
+                                base::Bind(&ExpectSuccessOperationalStatus),
+                                CreateDefaultVideoEncodeAcceleratorCallback(),
+                                CreateDefaultVideoEncodeMemoryCallback());
+  task_runner_->RunTasks();
+
+  receiver_to_sender_->SetPacketReceiver(
+      transport_sender_->PacketReceiverForTesting(), task_runner_,
+      &testing_clock_);
+  sender_to_receiver_->SetPacketReceiver(
+      transport_receiver_->PacketReceiverForTesting(), task_runner_,
+      &testing_clock_);
+
+  audio_frame_input_ = cast_sender_->audio_frame_input();
+  video_frame_input_ = cast_sender_->video_frame_input();
+
+  audio_bus_factory_.reset(new TestAudioBusFactory(
+      audio_sender_config_.channels, audio_sender_config_.frequency,
+      kSoundFrequency, kSoundVolume));
+}
+
 TEST_F(End2EndTest, LoopWithLosslessEncoding) {
   Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16);
   Create();
 
   const auto frames_sent = RunAudioVideoLoop(base::TimeDelta::FromSeconds(3));
 
   // Make sure that we send a RTCP message containing receiver log data, then
   // verify the accumulated logging data.
   RunTasks(750);
   VerifyLogging(frames_sent.first, frames_sent.second);
@@ skipping 20 matching lines @@
 // discontinuity in the timeline, throwing off the test expectations.  See TODOs
 // in audio_receiver.cc for likely cause(s) of this bug.
 // http://crbug.com/573126 (history: http://crbug.com/314233)
 TEST_F(End2EndTest, DISABLED_StartSenderBeforeReceiver) {
   Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16);
   Create();
 
   int frame_number = 0;
   int audio_diff = kFrameTimerMs;
 
-  sender_to_receiver_.SetSendPackets(false);
+  sender_to_receiver_->SetSendPackets(false);
 
   const int test_delay_ms = 100;
 
   const int kNumVideoFramesBeforeReceiverStarted = 2;
   const base::TimeTicks initial_send_time = testing_clock_sender_->NowTicks();
   const base::TimeDelta expected_delay =
       base::TimeDelta::FromMilliseconds(test_delay_ms + kFrameTimerMs);
   for (int i = 0; i < kNumVideoFramesBeforeReceiverStarted; ++i) {
     const int num_audio_frames = audio_diff / kAudioFrameDurationMs;
     audio_diff -= num_audio_frames * kAudioFrameDurationMs;
@@ skipping 14 matching lines @@
     if (num_audio_frames > 0)
       RunTasks(kAudioFrameDurationMs);  // Advance clock forward.
     if (num_audio_frames > 1)
       FeedAudioFramesWithExpectedDelay(num_audio_frames - 1, expected_delay);
 
     RunTasks(kFrameTimerMs - kAudioFrameDurationMs);
     audio_diff += kFrameTimerMs;
   }
 
   RunTasks(test_delay_ms);
-  sender_to_receiver_.SetSendPackets(true);
+  sender_to_receiver_->SetSendPackets(true);
 
   int num_audio_frames_requested = 0;
   for (int j = 0; j < 10; ++j) {
     const int num_audio_frames = audio_diff / kAudioFrameDurationMs;
     audio_diff -= num_audio_frames * kAudioFrameDurationMs;
 
     if (num_audio_frames > 0)
       FeedAudioFrames(1, true);
 
     test_receiver_video_callback_->AddExpectedResult(
@@ skipping 106 matching lines @@
        ++frames_counter) {
     SendVideoFrame(frames_counter, testing_clock_sender_->NowTicks());
     RunTasks(kFrameTimerMs);
   }
   RunTasks(2 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_EQ(static_cast<size_t>(kLongTestIterations), video_ticks_.size());
 }
 
 TEST_F(End2EndTest, EvilNetwork) {
   Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16);
-  receiver_to_sender_.SetPacketPipe(test::EvilNetwork());
-  sender_to_receiver_.SetPacketPipe(test::EvilNetwork());
+  receiver_to_sender_->SetPacketPipe(test::EvilNetwork());
+  sender_to_receiver_->SetPacketPipe(test::EvilNetwork());
   Create();
   StartBasicPlayer();
 
   for (int frames_counter = 0; frames_counter < kLongTestIterations;
        ++frames_counter) {
     SendVideoFrame(frames_counter, testing_clock_sender_->NowTicks());
     RunTasks(kFrameTimerMs);
   }
   base::TimeTicks test_end = testing_clock_receiver_->NowTicks();
   RunTasks(100 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_LT(static_cast<size_t>(kLongTestIterations / 100),
             video_ticks_.size());
   VLOG(1) << "Fully transmitted " << video_ticks_.size() << " frames.";
   EXPECT_GT(1000, (video_ticks_.back().second - test_end).InMilliseconds());
 }
 
 // Tests that a system configured for 30 FPS drops frames when input is provided
 // at a much higher frame rate.
 TEST_F(End2EndTest, ShoveHighFrameRateDownYerThroat) {
   Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16);
-  receiver_to_sender_.SetPacketPipe(test::EvilNetwork());
-  sender_to_receiver_.SetPacketPipe(test::EvilNetwork());
+  receiver_to_sender_->SetPacketPipe(test::EvilNetwork());
+  sender_to_receiver_->SetPacketPipe(test::EvilNetwork());
   Create();
   StartBasicPlayer();
 
   for (int frames_counter = 0; frames_counter < kLongTestIterations;
        ++frames_counter) {
     SendVideoFrame(frames_counter, testing_clock_sender_->NowTicks());
     RunTasks(10 /* 10 ms, but 33.3 expected by system */);
   }
   base::TimeTicks test_end = testing_clock_receiver_->NowTicks();
   RunTasks(100 * kFrameTimerMs + 1);  // Empty the pipeline.
   EXPECT_LT(static_cast<size_t>(kLongTestIterations / 100),
             video_ticks_.size());
   EXPECT_GE(static_cast<size_t>(kLongTestIterations / 3), video_ticks_.size());
   VLOG(1) << "Fully transmitted " << video_ticks_.size() << " frames.";
   EXPECT_LT((video_ticks_.back().second - test_end).InMilliseconds(), 1000);
 }
 
 TEST_F(End2EndTest, OldPacketNetwork) {
   Configure(CODEC_VIDEO_FAKE, CODEC_AUDIO_PCM16);
-  sender_to_receiver_.SetPacketPipe(test::NewRandomDrop(0.01));
+  sender_to_receiver_->SetPacketPipe(test::NewRandomDrop(0.01));
   scoped_ptr<test::PacketPipe> echo_chamber(
       test::NewDuplicateAndDelay(1, 10 * kFrameTimerMs));
   echo_chamber->AppendToPipe(
       test::NewDuplicateAndDelay(1, 20 * kFrameTimerMs));
   echo_chamber->AppendToPipe(
       test::NewDuplicateAndDelay(1, 40 * kFrameTimerMs));
   echo_chamber->AppendToPipe(
       test::NewDuplicateAndDelay(1, 80 * kFrameTimerMs));
   echo_chamber->AppendToPipe(
       test::NewDuplicateAndDelay(1, 160 * kFrameTimerMs));
 
-  receiver_to_sender_.SetPacketPipe(std::move(echo_chamber));
+  receiver_to_sender_->SetPacketPipe(std::move(echo_chamber));
   Create();
   StartBasicPlayer();
 
   SetExpectedVideoPlayoutSmoothness(
       base::TimeDelta::FromMilliseconds(kFrameTimerMs) * 90 / 100,
       base::TimeDelta::FromMilliseconds(kFrameTimerMs) * 110 / 100,
       base::TimeDelta::FromMilliseconds(kFrameTimerMs) / 10);
 
   for (int frames_counter = 0; frames_counter < kLongTestIterations;
        ++frames_counter) {
@@ skipping 38 matching lines @@
       EXPECT_EQ(0u, jump);
       jump = i;
     }
   }
   EXPECT_GT(jump, 49u);
   EXPECT_LT(jump, 120u);
 }
 
 }  // namespace cast
 }  // namespace media