Simplify interface for media/cast: CastTransportSenderImpl

media/cast/test/end2end_unittest.cc

Index: media/cast/test/end2end_unittest.cc
diff --git a/media/cast/test/end2end_unittest.cc b/media/cast/test/end2end_unittest.cc
index 2dd2f934f1c928bb444e4b8ebb4eedd3c616a12e..7145ba369a3a9868427ce91042aa783e3da2f062 100644
--- a/media/cast/test/end2end_unittest.cc
+++ b/media/cast/test/end2end_unittest.cc
@@ -94,12 +94,6 @@ std::string ConvertFromBase16String(const std::string& base_16) {
   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);
 }
@@ -213,6 +207,11 @@ class LoopBackTransport : public PacketSender {
 
   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() {
@@ -397,6 +396,11 @@ class TestReceiverVideoCallback
 // 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_(),
@@ -417,8 +421,8 @@ class End2EndTest : public ::testing::Test {
             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(
@@ -549,68 +553,7 @@ class End2EndTest : public ::testing::Test {
     }
   }
 
-  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_);
@@ -916,8 +859,9 @@ class End2EndTest : public ::testing::Test {
   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_;
 
@@ -940,6 +884,83 @@ class End2EndTest : public ::testing::Test {
   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();
@@ -980,7 +1001,7 @@ TEST_F(End2EndTest, DISABLED_StartSenderBeforeReceiver) {
   int frame_number = 0;
   int audio_diff = kFrameTimerMs;
 
-  sender_to_receiver_.SetSendPackets(false);
+  sender_to_receiver_->SetSendPackets(false);
 
   const int test_delay_ms = 100;
 
@@ -1015,7 +1036,7 @@ TEST_F(End2EndTest, DISABLED_StartSenderBeforeReceiver) {
   }
 
   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) {
@@ -1142,8 +1163,8 @@ TEST_F(End2EndTest, SmoothPlayoutWithFivePercentClockRateSkew) {
 
 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();
 
@@ -1164,8 +1185,8 @@ TEST_F(End2EndTest, EvilNetwork) {
 // 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();
 
@@ -1185,7 +1206,7 @@ TEST_F(End2EndTest, ShoveHighFrameRateDownYerThroat) {
 
 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(
@@ -1197,7 +1218,7 @@ TEST_F(End2EndTest, OldPacketNetwork) {
   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();